typescript 4.6.0-dev.20220111 → 4.6.0-dev.20220115

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-dev.20220111";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220115";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8482,7 +8482,7 @@ var ts;
         Parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts.DiagnosticCategory.Error, "Parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Parameter '{0}' cannot reference identifier '{1}' declared after it."),
         Duplicate_index_signature_for_type_0: diag(2374, ts.DiagnosticCategory.Error, "Duplicate_index_signature_for_type_0_2374", "Duplicate index signature for type '{0}'."),
         Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2375, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2375", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
-        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", "A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers."),
+        A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_2376", "A 'super' call must be the first statement in the constructor to refer to 'super' or 'this' when a derived class contains initialized properties, parameter properties, or private identifiers."),
         Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts.DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."),
         A_get_accessor_must_return_a_value: diag(2378, ts.DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."),
         Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2379, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_tr_2379", "Argument of type '{0}' is not assignable to parameter of type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
@@ -8505,6 +8505,7 @@ var ts;
         constructor_cannot_be_used_as_a_parameter_property_name: diag(2398, ts.DiagnosticCategory.Error, "constructor_cannot_be_used_as_a_parameter_property_name_2398", "'constructor' cannot be used as a parameter property name."),
         Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts.DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."),
         Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."),
+        A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2401, ts.DiagnosticCategory.Error, "A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_in_2401", "A 'super' call must be a root-level statement within a constructor of a derived class that contains initialized properties, parameter properties, or private identifiers."),
         Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts.DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."),
         Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts.DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'."),
         The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."),
@@ -15665,6 +15666,34 @@ var ts;
         }
     }
     ts.getThisContainer = getThisContainer;
+    /**
+     * @returns Whether the node creates a new 'this' scope for its children.
+     */
+    function isThisContainerOrFunctionBlock(node) {
+        switch (node.kind) {
+            // Arrow functions use the same scope, but may do so in a "delayed" manner
+            // For example, `const getThis = () => this` may be before a super() call in a derived constructor
+            case 213 /* ArrowFunction */:
+            case 255 /* FunctionDeclaration */:
+            case 212 /* FunctionExpression */:
+            case 166 /* PropertyDeclaration */:
+                return true;
+            case 234 /* Block */:
+                switch (node.parent.kind) {
+                    case 170 /* Constructor */:
+                    case 168 /* MethodDeclaration */:
+                    case 171 /* GetAccessor */:
+                    case 172 /* SetAccessor */:
+                        // Object properties can have computed names; only method-like bodies start a new scope
+                        return true;
+                    default:
+                        return false;
+                }
+            default:
+                return false;
+        }
+    }
+    ts.isThisContainerOrFunctionBlock = isThisContainerOrFunctionBlock;
     function isInTopLevelContext(node) {
         // The name of a class or function declaration is a BindingIdentifier in its surrounding scope.
         if (ts.isIdentifier(node) && (ts.isClassDeclaration(node.parent) || ts.isFunctionDeclaration(node.parent)) && node.parent.name === node) {
@@ -19985,16 +20014,6 @@ var ts;
                     (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(symlinkPath, real);
                 }
             },
-            setSymlinkedDirectoryFromSymlinkedFile: function (symlink, real) {
-                this.setSymlinkedFile(ts.toPath(symlink, cwd, getCanonicalFileName), real);
-                var _a = guessDirectorySymlink(real, symlink, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _a[0], commonOriginal = _a[1];
-                if (commonResolved && commonOriginal) {
-                    this.setSymlinkedDirectory(commonOriginal, {
-                        real: commonResolved,
-                        realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName),
-                    });
-                }
-            },
             setSymlinksFromResolutions: function (files, typeReferenceDirectives) {
                 var _this = this;
                 var _a;
@@ -26261,7 +26280,7 @@ var ts;
          * @param visitor Optional callback used to visit any custom prologue directives.
          */
         function copyPrologue(source, target, ensureUseStrict, visitor) {
-            var offset = copyStandardPrologue(source, target, ensureUseStrict);
+            var offset = copyStandardPrologue(source, target, 0, ensureUseStrict);
             return copyCustomPrologue(source, target, offset, visitor);
         }
         function isUseStrictPrologue(node) {
@@ -26274,12 +26293,14 @@ var ts;
          * Copies only the standard (string-expression) prologue-directives into the target statement-array.
          * @param source origin statements array
          * @param target result statements array
+         * @param statementOffset The offset at which to begin the copy.
          * @param ensureUseStrict boolean determining whether the function need to add prologue-directives
+         * @returns Count of how many directive statements were copied.
          */
-        function copyStandardPrologue(source, target, ensureUseStrict) {
+        function copyStandardPrologue(source, target, statementOffset, ensureUseStrict) {
+            if (statementOffset === void 0) { statementOffset = 0; }
             ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
             var foundUseStrict = false;
-            var statementOffset = 0;
             var numStatements = source.length;
             while (statementOffset < numStatements) {
                 var statement = source[statementOffset];
@@ -27702,7 +27723,7 @@ var ts;
         importName: "__createBinding",
         scoped: false,
         priority: 1,
-        text: "\n            var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n            }) : (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                o[k2] = m[k];\n            }));"
+        text: "\n            var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                var desc = Object.getOwnPropertyDescriptor(m, k);\n                if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n                  desc = { enumerable: true, get: function() { return m[k]; } };\n                }\n                Object.defineProperty(o, k2, desc);\n            }) : (function(o, m, k, k2) {\n                if (k2 === undefined) k2 = k;\n                o[k2] = m[k];\n            }));"
     };
     ts.setModuleDefaultHelper = {
         name: "typescript:commonjscreatevalue",
@@ -41337,7 +41358,7 @@ var ts;
                     ? 1 /* Recursive */ : 0 /* None */
             };
         }
-        if (ts.isImplicitGlob(spec)) {
+        if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) {
             return {
                 key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
                 flags: 1 /* Recursive */
@@ -41703,9 +41724,7 @@ var ts;
             }
         }
         var failedLookupLocations = [];
-        var features = ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
-            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
-                NodeResolutionFeatures.None;
+        var features = getDefaultNodeResolutionFeatures(options);
         var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: ["node", "require", "types"] };
         var resolved = primaryLookup();
         var primary = true;
@@ -41790,6 +41809,34 @@ var ts;
         }
     }
     ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
+    function getDefaultNodeResolutionFeatures(options) {
+        return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
+            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
+                NodeResolutionFeatures.None;
+    }
+    /**
+     * @internal
+     * Does not try `@types/${packageName}` - use a second pass if needed.
+     */
+    function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ts.emptyArray,
+            features: NodeResolutionFeatures.None,
+        };
+        return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
+            if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
+                var nodeModulesFolder = ts.combinePaths(ancestorDirectory, "node_modules");
+                var candidate = ts.combinePaths(nodeModulesFolder, packageName);
+                return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState);
+            }
+        });
+    }
+    ts.resolvePackageNameToPackageJson = resolvePackageNameToPackageJson;
     /**
      * Given a set of options, returns the set of type directive names
      *   that should be included for this program automatically.
@@ -42363,11 +42410,6 @@ var ts;
     }
     ts.resolveJSModule = resolveJSModule;
     /* @internal */
-    function tryResolveJSModule(moduleName, initialDir, host) {
-        return tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
-    }
-    ts.tryResolveJSModule = tryResolveJSModule;
-    /* @internal */
     var NodeResolutionFeatures;
     (function (NodeResolutionFeatures) {
         NodeResolutionFeatures[NodeResolutionFeatures["None"] = 0] = "None";
@@ -42675,6 +42717,97 @@ var ts;
         var versionPaths = packageInfo && packageInfo.versionPaths;
         return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
     }
+    /* @internal */
+    function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) {
+        if (!resolveJs && packageJsonInfo.resolvedEntrypoints !== undefined) {
+            // Cached value excludes resolutions to JS files - those could be
+            // cached separately, but they're used rarely.
+            return packageJsonInfo.resolvedEntrypoints;
+        }
+        var entrypoints;
+        var extensions = resolveJs ? Extensions.JavaScript : Extensions.TypeScript;
+        var features = getDefaultNodeResolutionFeatures(options);
+        var requireState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ["node", "require", "types"],
+            features: features,
+        };
+        var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
+        /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
+        entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path);
+        if (features & NodeResolutionFeatures.Exports && packageJsonInfo.packageJsonContent.exports) {
+            for (var _i = 0, _a = [["node", "import", "types"], ["node", "require", "types"]]; _i < _a.length; _i++) {
+                var conditions = _a[_i];
+                var exportState = __assign(__assign({}, requireState), { failedLookupLocations: [], conditions: conditions });
+                var exportResolutions = loadEntrypointsFromExportMap(packageJsonInfo, packageJsonInfo.packageJsonContent.exports, exportState, extensions);
+                if (exportResolutions) {
+                    for (var _b = 0, exportResolutions_1 = exportResolutions; _b < exportResolutions_1.length; _b++) {
+                        var resolution = exportResolutions_1[_b];
+                        entrypoints = ts.appendIfUnique(entrypoints, resolution.path);
+                    }
+                }
+            }
+        }
+        return packageJsonInfo.resolvedEntrypoints = entrypoints || false;
+    }
+    ts.getEntrypointsFromPackageJsonInfo = getEntrypointsFromPackageJsonInfo;
+    function loadEntrypointsFromExportMap(scope, exports, state, extensions) {
+        var entrypoints;
+        if (ts.isArray(exports)) {
+            for (var _i = 0, exports_1 = exports; _i < exports_1.length; _i++) {
+                var target = exports_1[_i];
+                loadEntrypointsFromTargetExports(target);
+            }
+        }
+        // eslint-disable-next-line no-null/no-null
+        else if (typeof exports === "object" && exports !== null && allKeysStartWithDot(exports)) {
+            for (var key in exports) {
+                loadEntrypointsFromTargetExports(exports[key]);
+            }
+        }
+        else {
+            loadEntrypointsFromTargetExports(exports);
+        }
+        return entrypoints;
+        function loadEntrypointsFromTargetExports(target) {
+            var _a, _b;
+            if (typeof target === "string" && ts.startsWith(target, "./") && target.indexOf("*") === -1) {
+                var partsAfterFirst = ts.getPathComponents(target).slice(2);
+                if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
+                    return false;
+                }
+                var resolvedTarget = ts.combinePaths(scope.packageDirectory, target);
+                var finalPath = ts.getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var result = loadJSOrExactTSFileName(extensions, finalPath, /*recordOnlyFailures*/ false, state);
+                if (result) {
+                    entrypoints = ts.appendIfUnique(entrypoints, result, function (a, b) { return a.path === b.path; });
+                    return true;
+                }
+            }
+            else if (Array.isArray(target)) {
+                for (var _i = 0, target_1 = target; _i < target_1.length; _i++) {
+                    var t = target_1[_i];
+                    var success = loadEntrypointsFromTargetExports(t);
+                    if (success) {
+                        return true;
+                    }
+                }
+            }
+            // eslint-disable-next-line no-null/no-null
+            else if (typeof target === "object" && target !== null) {
+                return ts.forEach(ts.getOwnKeys(target), function (key) {
+                    if (key === "default" || ts.contains(state.conditions, key) || isApplicableVersionedTypesKey(state.conditions, key)) {
+                        loadEntrypointsFromTargetExports(target[key]);
+                        return true;
+                    }
+                });
+            }
+        }
+    }
     /**
      * A function for locating the package.json scope for a given path
      */
@@ -42731,7 +42864,7 @@ var ts;
                 trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
-            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths };
+            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
             (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
             return result;
         }
@@ -43028,8 +43161,8 @@ var ts;
                         }
                         return toSearchResult(/*value*/ undefined);
                     }
-                    for (var _d = 0, target_1 = target; _d < target_1.length; _d++) {
-                        var elem = target_1[_d];
+                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
+                        var elem = target_2[_d];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -52262,8 +52395,8 @@ var ts;
                     }
                     else {
                         if (parent && getExportsOfSymbol(parent)) {
-                            var exports_1 = getExportsOfSymbol(parent);
-                            ts.forEachEntry(exports_1, function (ex, name) {
+                            var exports_2 = getExportsOfSymbol(parent);
+                            ts.forEachEntry(exports_2, function (ex, name) {
                                 if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
                                     symbolName = ts.unescapeLeadingUnderscores(name);
                                     return true;
@@ -57374,6 +57507,11 @@ var ts;
             return simplified !== type ? simplified : getConstraintOfType(type);
         }
         function getConstraintFromIndexedAccess(type) {
+            if (isMappedTypeGenericIndexedAccess(type)) {
+                // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                // we substitute an instantiation of E where P is replaced with X.
+                return substituteIndexedMappedType(type.objectType, type.indexType);
+            }
             var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
             if (indexConstraint && indexConstraint !== type.indexType) {
                 var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags);
@@ -57578,6 +57716,11 @@ var ts;
                     return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
                 }
                 if (t.flags & 8388608 /* IndexedAccess */) {
+                    if (isMappedTypeGenericIndexedAccess(t)) {
+                        // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                        // we substitute an instantiation of E where P is replaced with X.
+                        return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType));
+                    }
                     var baseObjectType = getBaseConstraint(t.objectType);
                     var baseIndexType = getBaseConstraint(t.indexType);
                     var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags);
@@ -57662,13 +57805,7 @@ var ts;
          * type itself.
          */
         function getApparentType(type) {
-            // We obtain the base constraint for all instantiable types, except indexed access types of the form
-            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
-            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
-            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
-            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
-                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
-                    getBaseConstraintOfType(type) || unknownType;
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -64332,6 +64469,17 @@ var ts;
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
+                        if (isMappedTypeGenericIndexedAccess(source)) {
+                            // For an indexed access type { [P in K]: E}[X], above we have already explored an instantiation of E with X
+                            // substituted for P. We also want to explore type { [P in K]: E }[C], where C is the constraint of X.
+                            var indexConstraint = getConstraintOfType(source.indexType);
+                            if (indexConstraint) {
+                                if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
+                                    resetErrorInfo(saveErrorInfo);
+                                    return result;
+                                }
+                            }
+                        }
                     }
                 }
                 else if (source.flags & 4194304 /* Index */) {
@@ -78595,32 +78743,38 @@ var ts;
                     if (classExtendsNull) {
                         error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
                     }
-                    // The first statement in the body of a constructor (excluding prologue directives) must be a super call
-                    // if both of the following are true:
+                    // A super call must be root-level in a constructor if both of the following are true:
                     // - The containing class is a derived class.
                     // - The constructor declares parameter properties
                     //   or the containing class declares instance member variables with initializers.
-                    var superCallShouldBeFirst = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) &&
+                    var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) &&
                         (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
                             ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */); }));
-                    // Skip past any prologue directives to find the first statement
-                    // to ensure that it was a super call.
-                    if (superCallShouldBeFirst) {
-                        var statements = node.body.statements;
-                        var superCallStatement = void 0;
-                        for (var _i = 0, statements_4 = statements; _i < statements_4.length; _i++) {
-                            var statement = statements_4[_i];
-                            if (statement.kind === 237 /* ExpressionStatement */ && ts.isSuperCall(statement.expression)) {
-                                superCallStatement = statement;
-                                break;
+                    if (superCallShouldBeRootLevel) {
+                        // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional
+                        // See GH #8277
+                        if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
+                            error(superCall, ts.Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers);
+                        }
+                        // Skip past any prologue directives to check statements for referring to 'super' or 'this' before a super call
+                        else {
+                            var superCallStatement = void 0;
+                            for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) {
+                                var statement = _a[_i];
+                                if (ts.isExpressionStatement(statement) && ts.isSuperCall(ts.skipOuterExpressions(statement.expression))) {
+                                    superCallStatement = statement;
+                                    break;
+                                }
+                                if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                    break;
+                                }
                             }
-                            if (!ts.isPrologueDirective(statement)) {
-                                break;
+                            // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional
+                            // See GH #8277
+                            if (superCallStatement === undefined) {
+                                error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
                             }
                         }
-                        if (!superCallStatement) {
-                            error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
-                        }
                     }
                 }
                 else if (!classExtendsNull) {
@@ -78628,6 +78782,19 @@ var ts;
                 }
             }
         }
+        function superCallIsRootLevelInConstructor(superCall, body) {
+            var superCallParent = ts.walkUpParenthesizedExpressions(superCall.parent);
+            return ts.isExpressionStatement(superCallParent) && superCallParent.parent === body;
+        }
+        function nodeImmediatelyReferencesSuperOrThis(node) {
+            if (node.kind === 106 /* SuperKeyword */ || node.kind === 108 /* ThisKeyword */) {
+                return true;
+            }
+            if (ts.isThisContainerOrFunctionBlock(node)) {
+                return false;
+            }
+            return !!ts.forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
+        }
         function checkAccessorDeclaration(node) {
             if (produceDiagnostics) {
                 // Grammar checking accessors
@@ -83450,9 +83617,9 @@ var ts;
                     }
                 }
                 // Checks for export * conflicts
-                var exports_2 = getExportsOfModule(moduleSymbol);
-                if (exports_2) {
-                    exports_2.forEach(function (_a, id) {
+                var exports_3 = getExportsOfModule(moduleSymbol);
+                if (exports_3) {
+                    exports_3.forEach(function (_a, id) {
                         var declarations = _a.declarations, flags = _a.flags;
                         if (id === "__export") {
                             return;
@@ -88750,34 +88917,31 @@ var ts;
     }
     ts.getNonAssignmentOperatorForCompoundAssignment = getNonAssignmentOperatorForCompoundAssignment;
     /**
-     * Adds super call and preceding prologue directives into the list of statements.
-     *
-     * @param ctor The constructor node.
-     * @param result The list of statements.
-     * @param visitor The visitor to apply to each node added to the result array.
-     * @returns index of the statement that follows super call
+     * @returns Contained super() call from descending into the statement ignoring parentheses, if that call exists.
+     */
+    function getSuperCallFromStatement(statement) {
+        if (!ts.isExpressionStatement(statement)) {
+            return undefined;
+        }
+        var expression = ts.skipParentheses(statement.expression);
+        return ts.isSuperCall(expression)
+            ? expression
+            : undefined;
+    }
+    ts.getSuperCallFromStatement = getSuperCallFromStatement;
+    /**
+     * @returns The index (after prologue statements) of a super call, or -1 if not found.
      */
-    function addPrologueDirectivesAndInitialSuperCall(factory, ctor, result, visitor) {
-        if (ctor.body) {
-            var statements = ctor.body.statements;
-            // add prologue directives to the list (if any)
-            var index = factory.copyPrologue(statements, result, /*ensureUseStrict*/ false, visitor);
-            if (index === statements.length) {
-                // list contains nothing but prologue directives (or empty) - exit
-                return index;
-            }
-            var superIndex = ts.findIndex(statements, function (s) { return ts.isExpressionStatement(s) && ts.isSuperCall(s.expression); }, index);
-            if (superIndex > -1) {
-                for (var i = index; i <= superIndex; i++) {
-                    result.push(ts.visitNode(statements[i], visitor, ts.isStatement));
-                }
-                return superIndex + 1;
+    function findSuperStatementIndex(statements, indexAfterLastPrologueStatement) {
+        for (var i = indexAfterLastPrologueStatement; i < statements.length; i += 1) {
+            var statement = statements[i];
+            if (getSuperCallFromStatement(statement)) {
+                return i;
             }
-            return index;
         }
-        return 0;
+        return -1;
     }
-    ts.addPrologueDirectivesAndInitialSuperCall = addPrologueDirectivesAndInitialSuperCall;
+    ts.findSuperStatementIndex = findSuperStatementIndex;
     function getProperties(node, requireInitializer, isStatic) {
         return ts.filter(node.members, function (m) { return isInitializedOrStaticProperty(m, requireInitializer, isStatic); });
     }
@@ -90676,6 +90840,7 @@ var ts;
                 case 176 /* TypePredicate */:
                 case 133 /* BooleanKeyword */:
                     return factory.createIdentifier("Boolean");
+                case 197 /* TemplateLiteralType */:
                 case 149 /* StringKeyword */:
                     return factory.createIdentifier("String");
                 case 147 /* ObjectKeyword */:
@@ -91014,10 +91179,14 @@ var ts;
                 return ts.visitFunctionBody(body, visitor, context);
             }
             var statements = [];
-            var indexOfFirstStatement = 0;
             resumeLexicalEnvironment();
-            indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
-            // Add parameters with property assignments. Transforms this:
+            var indexAfterLastPrologueStatement = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor);
+            var superStatementIndex = ts.findSuperStatementIndex(body.statements, indexAfterLastPrologueStatement);
+            // If there was a super call, visit existing statements up to and including it
+            if (superStatementIndex >= 0) {
+                ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexAfterLastPrologueStatement, superStatementIndex + 1 - indexAfterLastPrologueStatement));
+            }
+            // Transform parameters into property assignments. Transforms this:
             //
             //  constructor (public x, public y) {
             //  }
@@ -91029,9 +91198,17 @@ var ts;
             //      this.y = y;
             //  }
             //
-            ts.addRange(statements, ts.map(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment));
-            // Add the existing statements, skipping the initial super call.
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexOfFirstStatement));
+            var parameterPropertyAssignments = ts.mapDefined(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment);
+            // If there is a super() call, the parameter properties go immediately after it
+            if (superStatementIndex >= 0) {
+                ts.addRange(statements, parameterPropertyAssignments);
+            }
+            // Since there was no super() call, parameter properties are the first statements in the constructor
+            else {
+                statements = ts.addRange(parameterPropertyAssignments, statements);
+            }
+            // Add remaining statements from the body, skipping the super() call if it was found
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -92929,6 +93106,7 @@ var ts;
             /*modifiers*/ undefined, parameters !== null && parameters !== void 0 ? parameters : [], body), constructor || node), constructor));
         }
         function transformConstructorBody(node, constructor, isDerivedClass) {
+            var _a;
             var properties = ts.getProperties(node, /*requireInitializer*/ false, /*isStatic*/ false);
             if (!useDefineForClassFields) {
                 properties = ts.filter(properties, function (property) { return !!property.initializer || ts.isPrivateIdentifier(property.name); });
@@ -92940,9 +93118,21 @@ var ts;
                 return ts.visitFunctionBody(/*node*/ undefined, visitor, context);
             }
             resumeLexicalEnvironment();
-            var indexOfFirstStatement = 0;
+            var needsSyntheticConstructor = !constructor && isDerivedClass;
+            var indexOfFirstStatementAfterSuper = 0;
+            var prologueStatementCount = 0;
+            var superStatementIndex = -1;
             var statements = [];
-            if (!constructor && isDerivedClass) {
+            if ((_a = constructor === null || constructor === void 0 ? void 0 : constructor.body) === null || _a === void 0 ? void 0 : _a.statements) {
+                prologueStatementCount = factory.copyPrologue(constructor.body.statements, statements, /*ensureUseStrict*/ false, visitor);
+                superStatementIndex = ts.findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
+                // If there was a super call, visit existing statements up to and including it
+                if (superStatementIndex >= 0) {
+                    indexOfFirstStatementAfterSuper = superStatementIndex + 1;
+                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuper - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                }
+            }
+            if (needsSyntheticConstructor) {
                 // Add a synthetic `super` call:
                 //
                 //  super(...arguments);
@@ -92950,9 +93140,6 @@ var ts;
                 statements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), 
                 /*typeArguments*/ undefined, [factory.createSpreadElement(factory.createIdentifier("arguments"))])));
             }
-            if (constructor) {
-                indexOfFirstStatement = ts.addPrologueDirectivesAndInitialSuperCall(factory, constructor, statements, visitor);
-            }
             // Add the property initializers. Transforms this:
             //
             //  public x = 1;
@@ -92963,31 +93150,59 @@ var ts;
             //      this.x = 1;
             //  }
             //
+            // If we do useDefineForClassFields, they'll be converted elsewhere.
+            // We instead *remove* them from the transformed output at this stage.
+            var parameterPropertyDeclarationCount = 0;
             if (constructor === null || constructor === void 0 ? void 0 : constructor.body) {
-                var afterParameterProperties = ts.findIndex(constructor.body.statements, function (s) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(s), constructor); }, indexOfFirstStatement);
-                if (afterParameterProperties === -1) {
-                    afterParameterProperties = constructor.body.statements.length;
+                if (useDefineForClassFields) {
+                    statements = statements.filter(function (statement) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor); });
                 }
-                if (afterParameterProperties > indexOfFirstStatement) {
-                    if (!useDefineForClassFields) {
-                        ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement, afterParameterProperties - indexOfFirstStatement));
+                else {
+                    for (var _i = 0, _b = constructor.body.statements; _i < _b.length; _i++) {
+                        var statement = _b[_i];
+                        if (ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) {
+                            parameterPropertyDeclarationCount++;
+                        }
+                    }
+                    if (parameterPropertyDeclarationCount > 0) {
+                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuper, parameterPropertyDeclarationCount);
+                        // If there was a super() call found, add parameter properties immediately after it
+                        if (superStatementIndex >= 0) {
+                            ts.addRange(statements, parameterProperties);
+                        }
+                        // If a synthetic super() call was added, add them just after it
+                        else if (needsSyntheticConstructor) {
+                            statements = __spreadArray(__spreadArray([
+                                statements[0]
+                            ], parameterProperties, true), statements.slice(1), true);
+                        }
+                        // Since there wasn't a super() call, add them to the top of the constructor
+                        else {
+                            statements = __spreadArray(__spreadArray([], parameterProperties, true), statements, true);
+                        }
+                        indexOfFirstStatementAfterSuper += parameterPropertyDeclarationCount;
                     }
-                    indexOfFirstStatement = afterParameterProperties;
                 }
             }
             var receiver = factory.createThis();
             // private methods can be called in property initializers, they should execute first.
             addMethodStatements(statements, privateMethodsAndAccessors, receiver);
             addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
-            // Add existing statements, skipping the initial super call.
+            // Add existing statements after the initial prologues and super call
             if (constructor) {
-                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatement));
+                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuper + prologueStatementCount));
             }
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), 
             /*location*/ constructor ? constructor.body.statements : node.members), 
             /*multiLine*/ true), 
             /*location*/ constructor ? constructor.body : undefined);
+            function visitBodyStatement(statement) {
+                if (useDefineForClassFields && ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) {
+                    return undefined;
+                }
+                return visitor(statement);
+            }
         }
         /**
          * Generates assignment statements for property initializers.
@@ -93008,6 +93223,11 @@ var ts;
                 ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
                 ts.setCommentRange(statement, property);
                 ts.setOriginalNode(statement, property);
+                // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
+                // `statement` and `expression` have a copy of the synthesized comments.
+                // Drop the comments from expression to avoid printing them twice.
+                ts.setSyntheticLeadingComments(expression, undefined);
+                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
@@ -96774,37 +96994,39 @@ var ts;
             var prologue = [];
             var statements = [];
             resumeLexicalEnvironment();
+            // In derived classes, there may be code before the necessary super() call
+            // We'll remove pre-super statements to be tacked on after the rest of the body
+            var existingPrologue = ts.takeWhile(constructor.body.statements, ts.isPrologueDirective);
+            var _a = findSuperCallAndStatementIndex(constructor.body.statements, existingPrologue), superCall = _a.superCall, superStatementIndex = _a.superStatementIndex;
+            var postSuperStatementsStart = superStatementIndex === -1 ? existingPrologue.length : superStatementIndex + 1;
             // If a super call has already been synthesized,
             // we're going to assume that we should just transform everything after that.
             // The assumption is that no prior step in the pipeline has added any prologue directives.
-            var statementOffset = 0;
+            var statementOffset = postSuperStatementsStart;
             if (!hasSynthesizedSuper)
-                statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, /*ensureUseStrict*/ false);
-            addDefaultValueAssignmentsIfNeeded(statements, constructor);
-            addRestParameterIfNeeded(statements, constructor, hasSynthesizedSuper);
+                statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, statementOffset, /*ensureUseStrict*/ false);
             if (!hasSynthesizedSuper)
-                statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor);
-            // If the first statement is a call to `super()`, visit the statement directly
+                statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor, /*filter*/ undefined);
+            // If there already exists a call to `super()`, visit the statement directly
             var superCallExpression;
             if (hasSynthesizedSuper) {
                 superCallExpression = createDefaultSuperCallOrThis();
             }
-            else if (isDerivedClass && statementOffset < constructor.body.statements.length) {
-                var firstStatement = constructor.body.statements[statementOffset];
-                if (ts.isExpressionStatement(firstStatement) && ts.isSuperCall(firstStatement.expression)) {
-                    superCallExpression = visitImmediateSuperCallInBody(firstStatement.expression);
-                }
+            else if (superCall) {
+                superCallExpression = visitSuperCallInBody(superCall);
             }
             if (superCallExpression) {
                 hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
-                statementOffset++; // skip this statement, we will add it after visiting the rest of the body.
             }
+            // Add parameter defaults at the beginning of the output, with prologue statements
+            addDefaultValueAssignmentsIfNeeded(prologue, constructor);
+            addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper);
             // visit the remaining statements
             ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, /*start*/ statementOffset));
             factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
             insertCaptureNewTargetIfNeeded(prologue, constructor, /*copyOnWrite*/ false);
-            if (isDerivedClass) {
-                if (superCallExpression && statementOffset === constructor.body.statements.length && !(constructor.body.transformFlags & 8192 /* ContainsLexicalThis */)) {
+            if (isDerivedClass || superCallExpression) {
+                if (superCallExpression && postSuperStatementsStart === constructor.body.statements.length && !(constructor.body.transformFlags & 8192 /* ContainsLexicalThis */)) {
                     // If the subclass constructor does *not* contain `this` and *ends* with a `super()` call, we will use the
                     // following representation:
                     //
@@ -96824,10 +97046,10 @@ var ts;
                     //     return C;
                     // })(Base);
                     // ```
-                    var superCall = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression);
+                    var superCall_1 = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression);
                     var returnStatement = factory.createReturnStatement(superCallExpression);
-                    ts.setCommentRange(returnStatement, ts.getCommentRange(superCall));
-                    ts.setEmitFlags(superCall, 1536 /* NoComments */);
+                    ts.setCommentRange(returnStatement, ts.getCommentRange(superCall_1));
+                    ts.setEmitFlags(superCall_1, 1536 /* NoComments */);
                     statements.push(returnStatement);
                 }
                 else {
@@ -96852,9 +97074,19 @@ var ts;
                     //     return C;
                     // })(Base);
                     // ```
-                    // Since the `super()` call was the first statement, we insert the `this` capturing call to
-                    // `super()` at the top of the list of `statements` (after any pre-existing custom prologues).
-                    insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
+                    // If the super() call is the first statement, we can directly create and assign its result to `_this`
+                    if (superStatementIndex <= existingPrologue.length) {
+                        insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
+                    }
+                    // Since the `super()` call isn't the first statement, it's split across 1-2 statements:
+                    // * A prologue `var _this = this;`, in case the constructor accesses this before super()
+                    // * If it exists, a reassignment to that `_this` of the super() call
+                    else {
+                        insertCaptureThisForNode(prologue, constructor, createActualThis());
+                        if (superCallExpression) {
+                            insertSuperThisCaptureThisForNode(statements, superCallExpression);
+                        }
+                    }
                     if (!isSufficientlyCoveredByReturnStatements(constructor.body)) {
                         statements.push(factory.createReturnStatement(factory.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)));
                     }
@@ -96877,11 +97109,27 @@ var ts;
                 // ```
                 insertCaptureThisForNodeIfNeeded(prologue, constructor);
             }
-            var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(ts.concatenate(prologue, statements)), 
+            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex)), true), statements, true)), 
             /*location*/ constructor.body.statements), 
             /*multiLine*/ true);
-            ts.setTextRange(block, constructor.body);
-            return block;
+            ts.setTextRange(body, constructor.body);
+            return body;
+        }
+        function findSuperCallAndStatementIndex(originalBodyStatements, existingPrologue) {
+            for (var i = existingPrologue.length; i < originalBodyStatements.length; i += 1) {
+                var superCall = ts.getSuperCallFromStatement(originalBodyStatements[i]);
+                if (superCall) {
+                    // With a super() call, split the statements into pre-super() and 'body' (post-super())
+                    return {
+                        superCall: superCall,
+                        superStatementIndex: i,
+                    };
+                }
+            }
+            // Since there was no super() call found, consider all statements to be in the main 'body' (post-super())
+            return {
+                superStatementIndex: -1,
+            };
         }
         /**
          * We want to try to avoid emitting a return statement in certain cases if a user already returned something.
@@ -97110,6 +97358,18 @@ var ts;
             }
             return false;
         }
+        /**
+         * Assigns the `this` in a constructor to the result of its `super()` call.
+         *
+         * @param statements Statements in the constructor body.
+         * @param superExpression Existing `super()` call for the constructor.
+         */
+        function insertSuperThisCaptureThisForNode(statements, superExpression) {
+            enableSubstitutionsForCapturedThis();
+            var assignSuperExpression = factory.createExpressionStatement(factory.createBinaryExpression(factory.createThis(), 63 /* EqualsToken */, superExpression));
+            ts.insertStatementAfterCustomPrologue(statements, assignSuperExpression);
+            ts.setCommentRange(assignSuperExpression, ts.getOriginalNode(superExpression).parent);
+        }
         function insertCaptureThisForNode(statements, node, initializer) {
             enableSubstitutionsForCapturedThis();
             var captureThisStatement = factory.createVariableStatement(
@@ -97419,7 +97679,7 @@ var ts;
             if (ts.isBlock(body)) {
                 // ensureUseStrict is false because no new prologue-directive should be added.
                 // addStandardPrologue will put already-existing directives at the beginning of the target statement-array
-                statementOffset = factory.copyStandardPrologue(body.statements, prologue, /*ensureUseStrict*/ false);
+                statementOffset = factory.copyStandardPrologue(body.statements, prologue, 0, /*ensureUseStrict*/ false);
                 statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedFunction);
                 statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedVariableStatement);
             }
@@ -98790,7 +99050,7 @@ var ts;
             /*type*/ undefined, factory.updateBlock(func.body, statements))), 
             /*typeArguments*/ undefined, call.arguments))));
         }
-        function visitImmediateSuperCallInBody(node) {
+        function visitSuperCallInBody(node) {
             return visitCallExpressionWithPotentialCapturedThisAssignment(node, /*assignToCapturedThis*/ false);
         }
         function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
@@ -119348,28 +119608,37 @@ var ts;
                 useCaseSensitiveFileNames: (_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host),
             };
         }
-        function updateModuleSpecifier(compilerOptions, importingSourceFileName, toFileName, host, oldImportSpecifier) {
-            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the file renamer, `importingSourceFile` is the file being renamed,
+        // while `importingSourceFileName` its *new* name. We need a source file just to get its
+        // `impliedNodeFormat` and to detect certain preferences from existing import module specifiers.
+        function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, oldImportSpecifier) {
+            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
             if (res === oldImportSpecifier)
                 return undefined;
             return res;
         }
         moduleSpecifiers_1.updateModuleSpecifier = updateModuleSpecifier;
-        // Note: importingSourceFile is just for usesJsExtensionOnImports
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the declaration emitter, `importingSourceFile` is the implementation
+        // file, but `importingSourceFileName` and `toFileName` refer to declaration files (the former to the
+        // one currently being produced; the latter to the one being imported). We need an implementation file
+        // just to get its `impliedNodeFormat` and to detect certain preferences from existing import module
+        // specifiers.
         function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host) {
-            return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
+            return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
         }
         moduleSpecifiers_1.getModuleSpecifier = getModuleSpecifier;
-        function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host, preferences) {
-            var info = getInfo(importingSourceFileName, host);
-            var modulePaths = getAllModulePaths(importingSourceFileName, nodeModulesFileName, host, preferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions, /*packageNameOnly*/ true); });
+        function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences) {
+            var info = getInfo(importingSourceFile.path, host);
+            var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences);
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ true); });
         }
         moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName;
-        function getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, preferences, userPreferences) {
+        function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences) {
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions); }) ||
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions); }) ||
                 getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences) {
@@ -119436,7 +119705,7 @@ var ts;
             var relativeSpecifiers;
             for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
                 var modulePath = modulePaths_1[_i];
-                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions);
+                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions);
                 nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
                 if (specifier && modulePath.isRedirect) {
                     // If we got a specifier for a redirect, it was a bare package specifier (e.g. "@foo/bar",
@@ -119828,7 +120097,7 @@ var ts;
                 ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
                 : ts.removeFileExtension(relativePath);
         }
-        function tryGetModuleNameAsNodeModule(_a, _b, host, options, packageNameOnly) {
+        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, packageNameOnly) {
             var path = _a.path, isRedirect = _a.isRedirect;
             var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
             if (!host.fileExists || !host.readFile) {
@@ -119891,11 +120160,19 @@ var ts;
                 var moduleFileToTry = path;
                 if (host.fileExists(packageJsonPath)) {
                     var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
-                    // TODO: Inject `require` or `import` condition based on the intended import mode
                     if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
-                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                        // `conditions` *could* be made to go against `importingSourceFile.impliedNodeFormat` if something wanted to generate
+                        // an ImportEqualsDeclaration in an ESM-implied file or an ImportCall in a CJS-implied file. But since this function is
+                        // usually called to conjure an import out of thin air, we don't have an existing usage to call `getModeForUsageAtIndex`
+                        // with, so for now we just stick with the mode of the file.
+                        var conditions = ["node", importingSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext ? "import" : "require", "types"];
+                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string"
+                            ? tryGetModuleNameFromExports(options, path, packageRootPath, ts.getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions)
+                            : undefined;
                         if (fromExports) {
-                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry)
+                                ? fromExports
+                                : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
                             return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
                         }
                         if (packageJsonContent.exports) {
@@ -120001,8 +120278,8 @@ var ts;
         }
         function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
             return ts.firstDefined(rootDirs, function (rootDir) {
-                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName); // TODO: GH#18217
-                return isPathRelativeToParent(relativePath) ? undefined : relativePath;
+                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
+                return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
         }
         function removeExtensionAndIndexPostFix(fileName, ending, options) {
@@ -126631,7 +126908,7 @@ var ts;
             if (!ts.stringContains(importedFileName, "node_modules")) {
                 return undefined;
             }
-            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile.path, importedFileName, moduleSpecifierResolutionHost, preferences);
+            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile, importedFileName, moduleSpecifierResolutionHost, preferences);
             if (!specifier) {
                 return undefined;
             }
@@ -129447,7 +129724,7 @@ var ts;
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
         function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext) {
-            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
+            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
                 var completionInfo = getJsxClosingTagCompletion(location, sourceFile);
@@ -129458,7 +129735,7 @@ var ts;
             var entries = ts.createSortedArray();
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); // TODO: GH#18217
             }
             else {
@@ -129466,7 +129743,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -129572,7 +129849,7 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind, formatContext) {
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a, _b;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
@@ -129643,8 +129920,7 @@ var ts;
                     source = CompletionSource.ClassMemberSnippet;
                 }
             }
-            var kind = ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location);
-            if (kind === "JSX attribute" /* jsxAttribute */ && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
+            if (isJsxIdentifierExpected && !isRightOfOpenTag && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
                 var useBraces_1 = preferences.jsxAttributeCompletionStyle === "braces";
                 var type = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
                 // If is boolean like or undefined, don't return a snippet we want just to return the completion.
@@ -129682,7 +129958,7 @@ var ts;
             // entries (like JavaScript identifier entries).
             return {
                 name: name,
-                kind: kind,
+                kind: ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location),
                 kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol),
                 sortText: sortText,
                 source: source,
@@ -129978,7 +130254,7 @@ var ts;
                 return CompletionSource.ThisProperty;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
@@ -129999,7 +130275,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
                 var sortText = (isDeprecated(symbol, typeChecker) ? 8 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
-                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind, formatContext);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag);
                 if (!entry) {
                     continue;
                 }
@@ -130593,6 +130869,7 @@ var ts;
                 symbolToSortTextIdMap: symbolToSortTextIdMap,
                 isTypeOnlyLocation: isTypeOnlyLocation,
                 isJsxIdentifierExpected: isJsxIdentifierExpected,
+                isRightOfOpenTag: isRightOfOpenTag,
                 importCompletionNode: importCompletionNode,
                 hasUnresolvedAutoImports: hasUnresolvedAutoImports,
             };
@@ -136277,7 +136554,7 @@ var ts;
                     : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
                 // Need an update if the imported file moved, or the importing file moved and was using a relative path.
                 return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && ts.pathIsRelative(importLiteral.text)))
-                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
+                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
                     : undefined;
             });
         };
@@ -137922,6 +138199,9 @@ var ts;
         // We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes.
         // Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'!
         function areSameModule(a, b) {
+            if (!a.body || !b.body) {
+                return a.body === b.body;
+            }
             return a.body.kind === b.body.kind && (a.body.kind !== 260 /* ModuleDeclaration */ || areSameModule(a.body, b.body));
         }
         /** Merge source into target. Source should be thrown away after this is called. */
@@ -146699,20 +146979,31 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function getCodeActionsToAddConvertToUnknownForNonOverlappingTypes(context) {
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start); });
+                var assertion = getAssertion(context.sourceFile, context.span.start);
+                if (assertion === undefined)
+                    return undefined;
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, assertion); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_unknown_conversion_for_non_overlapping_types, fixId, ts.Diagnostics.Add_unknown_to_all_conversions_of_non_overlapping_types)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start); }); },
+            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
+                var assertion = getAssertion(diag.file, diag.start);
+                if (assertion) {
+                    makeChange(changes, diag.file, assertion);
+                }
+            }); },
         });
-        function makeChange(changeTracker, sourceFile, pos) {
-            var token = ts.getTokenAtPosition(sourceFile, pos);
-            var assertion = ts.Debug.checkDefined(ts.findAncestor(token, function (n) { return ts.isAsExpression(n) || ts.isTypeAssertionExpression(n); }), "Expected to find an assertion expression");
+        function makeChange(changeTracker, sourceFile, assertion) {
             var replacement = ts.isAsExpression(assertion)
                 ? ts.factory.createAsExpression(assertion.expression, ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */))
                 : ts.factory.createTypeAssertion(ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */), assertion.expression);
             changeTracker.replaceNode(sourceFile, assertion.expression, replacement);
         }
+        function getAssertion(sourceFile, pos) {
+            if (ts.isInJSFile(sourceFile))
+                return undefined;
+            return ts.findAncestor(ts.getTokenAtPosition(sourceFile, pos), function (n) { return ts.isAsExpression(n) || ts.isTypeAssertionExpression(n); });
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */
@@ -149830,10 +150121,15 @@ var ts;
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
                 return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
+                    || ts.compareBooleans(isOnlyDotsAndSlashes(a.moduleSpecifier), isOnlyDotsAndSlashes(b.moduleSpecifier))
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
             return 0 /* EqualTo */;
         }
+        var notDotOrSlashPattern = /[^.\/]/;
+        function isOnlyDotsAndSlashes(path) {
+            return !notDotOrSlashPattern.test(path);
+        }
         function compareNodeCoreModuleSpecifiers(a, b, importingFile, program) {
             if (ts.startsWith(a, "node:") && !ts.startsWith(b, "node:"))
                 return ts.shouldUseUriStyleNodeCoreModules(importingFile, program) ? -1 /* LessThan */ : 1 /* GreaterThan */;
@@ -155136,7 +155432,7 @@ var ts;
                 defaultToNamedAction.kind,
                 namedToDefaultAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndDefaultExports(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -155154,7 +155450,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndDefaultExports(context, actionName) {
                 ts.Debug.assert(actionName === defaultToNamedAction.name || actionName === namedToDefaultAction.name, "Unexpected action name");
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -155382,7 +155678,7 @@ var ts;
                 namespaceToNamedAction.kind,
                 namedToNamespaceAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) {
                 var info = getImportToConvert(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -155401,7 +155697,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName) {
                 ts.Debug.assert(actionName === namespaceToNamedAction.name || actionName === namedToNamespaceAction.name, "Unexpected action name");
                 var info = getImportToConvert(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -155567,10 +155863,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toOptionalChainAction.kind],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToConvertToOptionalChain,
+                getAvailableActions: getRefactorActionsToConvertToOptionalChain,
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToOptionalChain(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -155590,7 +155886,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToOptionalChain(context, actionName) {
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) {
@@ -155833,10 +156129,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [functionOverloadAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
+                getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!info)
@@ -155847,7 +156143,7 @@ var ts;
                         actions: [functionOverloadAction]
                     }];
             }
-            function getEditsForAction(context) {
+            function getRefactorEditsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!signatureDecls)
@@ -156003,14 +156299,14 @@ var ts;
                     extractConstantAction.kind,
                     extractFunctionAction.kind
                 ],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToExtractSymbol,
+                getAvailableActions: getRefactorActionsToExtractSymbol,
             });
             /**
              * Compute the associated code actions
              * Exported for tests.
              */
-            function getAvailableActions(context) {
+            function getRefactorActionsToExtractSymbol(context) {
                 var requestedRefactor = context.kind;
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context), context.triggerReason === "invoked");
                 var targetRange = rangeToExtract.targetRange;
@@ -156139,9 +156435,9 @@ var ts;
                     return error;
                 }
             }
-            extractSymbol.getAvailableActions = getAvailableActions;
+            extractSymbol.getRefactorActionsToExtractSymbol = getRefactorActionsToExtractSymbol;
             /* Exported for tests */
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToExtractSymbol(context, actionName) {
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context));
                 var targetRange = rangeToExtract.targetRange; // TODO:GH#18217
                 var parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName);
@@ -156158,7 +156454,7 @@ var ts;
                 }
                 ts.Debug.fail("Unrecognized action name");
             }
-            extractSymbol.getEditsForAction = getEditsForAction;
+            extractSymbol.getRefactorEditsToExtractSymbol = getRefactorEditsToExtractSymbol;
             // Move these into diagnostic messages if they become user-facing
             var Messages;
             (function (Messages) {
@@ -157709,7 +158005,7 @@ var ts;
                 extractToInterfaceAction.kind,
                 extractToTypeDefAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToExtractType(context) {
                 var info = getRangeToExtract(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -157734,7 +158030,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToExtractType(context, actionName) {
                 var file = context.file;
                 var info = getRangeToExtract(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected to find a range to extract");
@@ -157902,7 +158198,7 @@ var ts;
             };
             refactor.registerRefactor(actionName, {
                 kinds: [generateGetSetAction.kind],
-                getEditsForAction: function (context, actionName) {
+                getEditsForAction: function getRefactorActionsToGenerateGetAndSetAccessors(context, actionName) {
                     if (!context.endPosition)
                         return undefined;
                     var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition);
@@ -157981,7 +158277,7 @@ var ts;
         };
         refactor.registerRefactor(refactorName, {
             kinds: [moveToNewFileAction.kind],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
                 var statements = getStatementsToMove(context);
                 if (context.preferences.allowTextChangesInNewFiles && statements) {
                     return [{ name: refactorName, description: description, actions: [moveToNewFileAction] }];
@@ -157992,7 +158288,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Wrong refactor invoked");
                 var statements = ts.Debug.checkDefined(getStatementsToMove(context));
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, statements, t, context.host, context.preferences); });
@@ -158723,10 +159019,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [removeBracesAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
+                getAvailableActions: getRefactorActionsToRemoveFunctionBraces
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToRemoveFunctionBraces(context) {
                 var file = context.file, startPosition = context.startPosition, triggerReason = context.triggerReason;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked");
                 if (!info)
@@ -158752,7 +159048,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToRemoveFunctionBraces(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -158826,10 +159122,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toDestructuredAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
+                getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertParametersToDestructuredObject(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var isJSFile = ts.isSourceFileJS(file);
                 if (isJSFile)
@@ -158843,7 +159139,7 @@ var ts;
                         actions: [toDestructuredAction]
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Unexpected action name");
                 var file = context.file, startPosition = context.startPosition, program = context.program, cancellationToken = context.cancellationToken, host = context.host;
                 var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
@@ -159353,10 +159649,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [convertStringAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertToTemplateString,
+                getAvailableActions: getRefactorActionsToConvertToTemplateString
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToTemplateString(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 var maybeBinary = getParentBinaryExpression(node);
@@ -159382,7 +159678,7 @@ var ts;
                 }
                 return node;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToTemplateString(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 switch (actionName) {
@@ -159596,10 +159892,10 @@ var ts;
                     toNamedFunctionAction.kind,
                     toArrowFunctionAction.kind
                 ],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertFunctionExpressions,
+                getAvailableActions: getRefactorActionsToConvertFunctionExpressions
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertFunctionExpressions(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program, kind = context.kind;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -159643,7 +159939,7 @@ var ts;
                             errors : possibleActions
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertFunctionExpressions(context, actionName) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -159803,10 +160099,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [inferReturnTypeAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToInferReturnType,
+                getAvailableActions: getRefactorActionsToInferReturnType
             });
-            function getEditsForAction(context) {
+            function getRefactorEditsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (info && !refactor.isRefactorErrorInfo(info)) {
                     var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, t, info.declaration, info.returnTypeNode); });
@@ -159814,7 +160110,7 @@ var ts;
                 }
                 return undefined;
             }
-            function getAvailableActions(context) {
+            function getRefactorActionsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (!info)
                     return ts.emptyArray;