typescript 4.7.0-dev.20220309 → 4.7.0-dev.20220312

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220309";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220312";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1662,6 +1662,159 @@ var ts;
         return createMultiMap();
     }
     ts.createUnderscoreEscapedMultiMap = createUnderscoreEscapedMultiMap;
+    /**
+     * Creates a Set with custom equality and hash code functionality.  This is useful when you
+     * want to use something looser than object identity - e.g. "has the same span".
+     *
+     * If `equals(a, b)`, it must be the case that `getHashCode(a) === getHashCode(b)`.
+     * The converse is not required.
+     *
+     * To facilitate a perf optimization (lazy allocation of bucket arrays), `TElement` is
+     * assumed not to be an array type.
+     */
+    function createSet(getHashCode, equals) {
+        var multiMap = new ts.Map();
+        var size = 0;
+        function getElementIterator() {
+            var valueIt = multiMap.values();
+            var arrayIt;
+            return {
+                next: function () {
+                    while (true) {
+                        if (arrayIt) {
+                            var n = arrayIt.next();
+                            if (!n.done) {
+                                return { value: n.value };
+                            }
+                            arrayIt = undefined;
+                        }
+                        else {
+                            var n = valueIt.next();
+                            if (n.done) {
+                                return { value: undefined, done: true };
+                            }
+                            if (!isArray(n.value)) {
+                                return { value: n.value };
+                            }
+                            arrayIt = arrayIterator(n.value);
+                        }
+                    }
+                }
+            };
+        }
+        var set = {
+            has: function (element) {
+                var hash = getHashCode(element);
+                if (!multiMap.has(hash))
+                    return false;
+                var candidates = multiMap.get(hash);
+                if (!isArray(candidates))
+                    return equals(candidates, element);
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
+                    if (equals(candidate, element)) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            add: function (element) {
+                var hash = getHashCode(element);
+                if (multiMap.has(hash)) {
+                    var values = multiMap.get(hash);
+                    if (isArray(values)) {
+                        if (!contains(values, element, equals)) {
+                            values.push(element);
+                            size++;
+                        }
+                    }
+                    else {
+                        var value = values;
+                        if (!equals(value, element)) {
+                            multiMap.set(hash, [value, element]);
+                            size++;
+                        }
+                    }
+                }
+                else {
+                    multiMap.set(hash, element);
+                    size++;
+                }
+                return this;
+            },
+            delete: function (element) {
+                var hash = getHashCode(element);
+                if (!multiMap.has(hash))
+                    return false;
+                var candidates = multiMap.get(hash);
+                if (isArray(candidates)) {
+                    for (var i = 0; i < candidates.length; i++) {
+                        if (equals(candidates[i], element)) {
+                            if (candidates.length === 1) {
+                                multiMap.delete(hash);
+                            }
+                            else if (candidates.length === 2) {
+                                multiMap.set(hash, candidates[1 - i]);
+                            }
+                            else {
+                                unorderedRemoveItemAt(candidates, i);
+                            }
+                            size--;
+                            return true;
+                        }
+                    }
+                }
+                else {
+                    var candidate = candidates;
+                    if (equals(candidate, element)) {
+                        multiMap.delete(hash);
+                        size--;
+                        return true;
+                    }
+                }
+                return false;
+            },
+            clear: function () {
+                multiMap.clear();
+                size = 0;
+            },
+            get size() {
+                return size;
+            },
+            forEach: function (action) {
+                for (var _i = 0, _a = arrayFrom(multiMap.values()); _i < _a.length; _i++) {
+                    var elements = _a[_i];
+                    if (isArray(elements)) {
+                        for (var _b = 0, elements_1 = elements; _b < elements_1.length; _b++) {
+                            var element = elements_1[_b];
+                            action(element, element);
+                        }
+                    }
+                    else {
+                        var element = elements;
+                        action(element, element);
+                    }
+                }
+            },
+            keys: function () {
+                return getElementIterator();
+            },
+            values: function () {
+                return getElementIterator();
+            },
+            entries: function () {
+                var it = getElementIterator();
+                return {
+                    next: function () {
+                        var n = it.next();
+                        return n.done ? n : { value: [n.value, n.value] };
+                    }
+                };
+            },
+        };
+        return set;
+    }
+    ts.createSet = createSet;
     /**
      * Tests whether a value is an array.
      */
@@ -2055,8 +2208,8 @@ var ts;
         var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
         var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother.
         var bestCandidate;
-        for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
-            var candidate = candidates_1[_i];
+        for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+            var candidate = candidates_2[_i];
             var candidateName = getName(candidate);
             if (candidateName !== undefined && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) {
                 if (candidateName === name) {
@@ -2293,13 +2446,15 @@ var ts;
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
+            var lastResult;
             for (var _a = 0, fs_1 = fs; _a < fs_1.length; _a++) {
                 var f = fs_1[_a];
-                if (f.apply(void 0, args)) {
-                    return true;
+                lastResult = f.apply(void 0, args);
+                if (lastResult) {
+                    return lastResult;
                 }
             }
-            return false;
+            return lastResult;
         };
     }
     ts.or = or;
@@ -4358,6 +4513,7 @@ var ts;
         SyntaxKind[SyntaxKind["JSDocFunctionType"] = 316] = "JSDocFunctionType";
         SyntaxKind[SyntaxKind["JSDocVariadicType"] = 317] = "JSDocVariadicType";
         SyntaxKind[SyntaxKind["JSDocNamepathType"] = 318] = "JSDocNamepathType";
+        /** @deprecated Use SyntaxKind.JSDoc */
         SyntaxKind[SyntaxKind["JSDocComment"] = 319] = "JSDocComment";
         SyntaxKind[SyntaxKind["JSDocText"] = 320] = "JSDocText";
         SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 321] = "JSDocTypeLiteral";
@@ -4431,6 +4587,7 @@ var ts;
         SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 346] = "LastJSDocTagNode";
         /* @internal */ SyntaxKind[SyntaxKind["FirstContextualKeyword"] = 126] = "FirstContextualKeyword";
         /* @internal */ SyntaxKind[SyntaxKind["LastContextualKeyword"] = 159] = "LastContextualKeyword";
+        SyntaxKind[SyntaxKind["JSDoc"] = 319] = "JSDoc";
     })(SyntaxKind = ts.SyntaxKind || (ts.SyntaxKind = {}));
     var NodeFlags;
     (function (NodeFlags) {
@@ -5317,6 +5474,21 @@ var ts;
         ModuleResolutionKind[ModuleResolutionKind["Node12"] = 3] = "Node12";
         ModuleResolutionKind[ModuleResolutionKind["NodeNext"] = 99] = "NodeNext";
     })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));
+    var ModuleDetectionKind;
+    (function (ModuleDetectionKind) {
+        /**
+         * Files with imports, exports and/or import.meta are considered modules
+         */
+        ModuleDetectionKind[ModuleDetectionKind["Legacy"] = 1] = "Legacy";
+        /**
+         * Legacy, but also files with jsx under react-jsx or react-jsxdev and esm mode files under moduleResolution: node12+
+         */
+        ModuleDetectionKind[ModuleDetectionKind["Auto"] = 2] = "Auto";
+        /**
+         * Consider all non-declaration files modules, regardless of present syntax
+         */
+        ModuleDetectionKind[ModuleDetectionKind["Force"] = 3] = "Force";
+    })(ModuleDetectionKind = ts.ModuleDetectionKind || (ts.ModuleDetectionKind = {}));
     var WatchFileKind;
     (function (WatchFileKind) {
         WatchFileKind[WatchFileKind["FixedPollingInterval"] = 0] = "FixedPollingInterval";
@@ -8414,6 +8586,8 @@ var ts;
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
         An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."),
         An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."),
+        Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, ts.DiagnosticCategory.Message, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."),
+        auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node12_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node12+) as modules."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
@@ -13027,7 +13201,7 @@ var ts;
             return ts.emptyArray;
         }
         if (ts.isJSDocTypeAlias(node)) {
-            ts.Debug.assert(node.parent.kind === 319 /* JSDocComment */);
+            ts.Debug.assert(node.parent.kind === 319 /* JSDoc */);
             return ts.flatMap(node.parent.tags, function (tag) { return ts.isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; });
         }
         if (node.typeParameters) {
@@ -13974,7 +14148,7 @@ var ts;
     ts.isJSDocNode = isJSDocNode;
     /** True if node is of a kind that may contain comment text. */
     function isJSDocCommentContainingNode(node) {
-        return node.kind === 319 /* JSDocComment */
+        return node.kind === 319 /* JSDoc */
             || node.kind === 318 /* JSDocNamepathType */
             || node.kind === 320 /* JSDocText */
             || isJSDocLinkLike(node)
@@ -15539,10 +15713,23 @@ var ts;
             && node.parent.parent.kind === 236 /* VariableStatement */;
     }
     ts.isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement;
+    function isCommonJsExportedExpression(node) {
+        if (!isInJSFile(node))
+            return false;
+        return (ts.isObjectLiteralExpression(node.parent) && ts.isBinaryExpression(node.parent.parent) && getAssignmentDeclarationKind(node.parent.parent) === 2 /* ModuleExports */) ||
+            isCommonJsExportPropertyAssignment(node.parent);
+    }
+    ts.isCommonJsExportedExpression = isCommonJsExportedExpression;
+    function isCommonJsExportPropertyAssignment(node) {
+        if (!isInJSFile(node))
+            return false;
+        return (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 1 /* ExportsProperty */);
+    }
+    ts.isCommonJsExportPropertyAssignment = isCommonJsExportPropertyAssignment;
     function isValidESSymbolDeclaration(node) {
-        return ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :
+        return (ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :
             ts.isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) :
-                ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node);
+                ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node)) || isCommonJsExportPropertyAssignment(node);
     }
     ts.isValidESSymbolDeclaration = isValidESSymbolDeclaration;
     function introducesArgumentsExoticObject(node) {
@@ -18436,7 +18623,7 @@ var ts;
     ts.getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations;
     /** template tags are only available when a typedef isn't already using them */
     function isNonTypeAliasTemplate(tag) {
-        return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 319 /* JSDocComment */ && tag.parent.tags.some(isJSDocTypeAlias));
+        return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 319 /* JSDoc */ && tag.parent.tags.some(isJSDocTypeAlias));
     }
     /**
      * Gets the effective type annotation of the value parameter of a set accessor. If the node
@@ -19910,6 +20097,61 @@ var ts;
         return scriptKind === 4 /* TSX */ || scriptKind === 2 /* JSX */ || scriptKind === 1 /* JS */ || scriptKind === 6 /* JSON */ ? 1 /* JSX */ : 0 /* Standard */;
     }
     ts.getLanguageVariant = getLanguageVariant;
+    /**
+     * This is a somewhat unavoidable full tree walk to locate a JSX tag - `import.meta` requires the same,
+     * but we avoid that walk (or parts of it) if at all possible using the `PossiblyContainsImportMeta` node flag.
+     * Unfortunately, there's no `NodeFlag` space to do the same for JSX.
+     */
+    function walkTreeForJSXTags(node) {
+        if (!(node.transformFlags & 2 /* ContainsJsx */))
+            return undefined;
+        return ts.isJsxOpeningLikeElement(node) || ts.isJsxFragment(node) ? node : ts.forEachChild(node, walkTreeForJSXTags);
+    }
+    function isFileModuleFromUsingJSXTag(file) {
+        // Excludes declaration files - they still require an explicit `export {}` or the like
+        // for back compat purposes. (not that declaration files should contain JSX tags!)
+        return !file.isDeclarationFile ? walkTreeForJSXTags(file) : undefined;
+    }
+    /**
+     * Note that this requires file.impliedNodeFormat be set already; meaning it must be set very early on
+     * in SourceFile construction.
+     */
+    function isFileForcedToBeModuleByFormat(file) {
+        // Excludes declaration files - they still require an explicit `export {}` or the like
+        // for back compat purposes.
+        return file.impliedNodeFormat === ts.ModuleKind.ESNext && !file.isDeclarationFile ? true : undefined;
+    }
+    function getSetExternalModuleIndicator(options) {
+        // TODO: Should this callback be cached?
+        switch (getEmitModuleDetectionKind(options)) {
+            case ts.ModuleDetectionKind.Force:
+                // All non-declaration files are modules, declaration files still do the usual isFileProbablyExternalModule
+                return function (file) {
+                    file.externalModuleIndicator = !file.isDeclarationFile || ts.isFileProbablyExternalModule(file);
+                };
+            case ts.ModuleDetectionKind.Legacy:
+                // Files are modules if they have imports, exports, or import.meta
+                return function (file) {
+                    file.externalModuleIndicator = ts.isFileProbablyExternalModule(file);
+                };
+            case ts.ModuleDetectionKind.Auto:
+                // If module is nodenext or node12, all esm format files are modules
+                // If jsx is react-jsx or react-jsxdev then jsx tags force module-ness
+                // otherwise, the presence of import or export statments (or import.meta) implies module-ness
+                var checks = [ts.isFileProbablyExternalModule];
+                if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
+                    checks.push(isFileModuleFromUsingJSXTag);
+                }
+                var moduleKind = getEmitModuleKind(options);
+                if (moduleKind === ts.ModuleKind.Node12 || moduleKind === ts.ModuleKind.NodeNext) {
+                    checks.push(isFileForcedToBeModuleByFormat);
+                }
+                var combined_1 = ts.or.apply(void 0, checks);
+                var callback = function (file) { return void (file.externalModuleIndicator = combined_1(file)); };
+                return callback;
+        }
+    }
+    ts.getSetExternalModuleIndicator = getSetExternalModuleIndicator;
     function getEmitScriptTarget(compilerOptions) {
         return compilerOptions.target ||
             (compilerOptions.module === ts.ModuleKind.Node12 && 7 /* ES2020 */) ||
@@ -19944,6 +20186,10 @@ var ts;
         return moduleResolution;
     }
     ts.getEmitModuleResolutionKind = getEmitModuleResolutionKind;
+    function getEmitModuleDetectionKind(options) {
+        return options.moduleDetection || ts.ModuleDetectionKind.Auto;
+    }
+    ts.getEmitModuleDetectionKind = getEmitModuleDetectionKind;
     function hasJsonModuleEmitEnabled(options) {
         switch (getEmitModuleKind(options)) {
             case ts.ModuleKind.CommonJS:
@@ -25413,7 +25659,7 @@ var ts;
         }
         // @api
         function createJSDocComment(comment, tags) {
-            var node = createBaseNode(319 /* JSDocComment */);
+            var node = createBaseNode(319 /* JSDoc */);
             node.comment = comment;
             node.tags = asNodeArray(tags);
             return node;
@@ -28922,7 +29168,7 @@ var ts;
     }
     ts.isJSDocNamepathType = isJSDocNamepathType;
     function isJSDoc(node) {
-        return node.kind === 319 /* JSDocComment */;
+        return node.kind === 319 /* JSDoc */;
     }
     ts.isJSDoc = isJSDoc;
     function isJSDocTypeLiteral(node) {
@@ -30114,6 +30360,36 @@ var ts;
             text.charCodeAt(start + 3) !== 47 /* slash */;
     }
     ts.isJSDocLikeText = isJSDocLikeText;
+    /*@internal*/
+    function isFileProbablyExternalModule(sourceFile) {
+        // Try to use the first top-level import/export when available, then
+        // fall back to looking for an 'import.meta' somewhere in the tree if necessary.
+        return ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) ||
+            getImportMetaIfNecessary(sourceFile);
+    }
+    ts.isFileProbablyExternalModule = isFileProbablyExternalModule;
+    function isAnExternalModuleIndicatorNode(node) {
+        return hasModifierOfKind(node, 93 /* ExportKeyword */)
+            || ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)
+            || ts.isImportDeclaration(node)
+            || ts.isExportAssignment(node)
+            || ts.isExportDeclaration(node) ? node : undefined;
+    }
+    function getImportMetaIfNecessary(sourceFile) {
+        return sourceFile.flags & 2097152 /* PossiblyContainsImportMeta */ ?
+            walkTreeForImportMeta(sourceFile) :
+            undefined;
+    }
+    function walkTreeForImportMeta(node) {
+        return isImportMeta(node) ? node : forEachChild(node, walkTreeForImportMeta);
+    }
+    /** Do not use hasModifier inside the parser; it relies on parent pointers. Use this instead. */
+    function hasModifierOfKind(node, kind) {
+        return ts.some(node.modifiers, function (m) { return m.kind === kind; });
+    }
+    function isImportMeta(node) {
+        return ts.isMetaProperty(node) && node.keywordToken === 100 /* ImportKeyword */ && node.name.escapedText === "meta";
+    }
     /**
      * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
      * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
@@ -30547,7 +30823,7 @@ var ts;
             case 316 /* JSDocFunctionType */:
                 return visitNodes(cbNode, cbNodes, node.parameters) ||
                     visitNode(cbNode, node.type);
-            case 319 /* JSDocComment */:
+            case 319 /* JSDoc */:
                 return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))
                     || visitNodes(cbNode, cbNodes, node.tags);
             case 345 /* JSDocSeeTag */:
@@ -30695,17 +30971,25 @@ var ts;
             children.unshift(n);
         }
     }
-    function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
+    function setExternalModuleIndicator(sourceFile) {
+        sourceFile.externalModuleIndicator = isFileProbablyExternalModule(sourceFile);
+    }
+    function createSourceFile(fileName, sourceText, languageVersionOrOptions, setParentNodes, scriptKind) {
         if (setParentNodes === void 0) { setParentNodes = false; }
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("parse" /* Parse */, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true);
         ts.performance.mark("beforeParse");
         var result;
         ts.perfLogger.logStartParseSourceFile(fileName);
+        var _a = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions }, languageVersion = _a.languageVersion, overrideSetExternalModuleIndicator = _a.setExternalModuleIndicator, format = _a.impliedNodeFormat;
         if (languageVersion === 100 /* JSON */) {
-            result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, 6 /* JSON */);
+            result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, 6 /* JSON */, ts.noop);
         }
         else {
-            result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);
+            var setIndicator = format === undefined ? overrideSetExternalModuleIndicator : function (file) {
+                file.impliedNodeFormat = format;
+                return (overrideSetExternalModuleIndicator || setExternalModuleIndicator)(file);
+            };
+            result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind, setIndicator);
         }
         ts.perfLogger.logStopParseSourceFile();
         ts.performance.mark("afterParse");
@@ -30891,7 +31175,7 @@ var ts;
         // Note: any errors at the end of the file that do not precede a regular node, should get
         // attached to the EOF token.
         var parseErrorBeforeNextFinishedNode = false;
-        function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind) {
+        function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind, setExternalModuleIndicatorOverride) {
             var _a;
             if (setParentNodes === void 0) { setParentNodes = false; }
             scriptKind = ts.ensureScriptKind(fileName, scriptKind);
@@ -30907,7 +31191,7 @@ var ts;
                 return result_3;
             }
             initializeState(fileName, sourceText, languageVersion, syntaxCursor, scriptKind);
-            var result = parseSourceFileWorker(languageVersion, setParentNodes, scriptKind);
+            var result = parseSourceFileWorker(languageVersion, setParentNodes, scriptKind, setExternalModuleIndicatorOverride || setExternalModuleIndicator);
             clearState();
             return result;
         }
@@ -30991,7 +31275,7 @@ var ts;
                 endOfFileToken = parseExpectedToken(1 /* EndOfFileToken */, ts.Diagnostics.Unexpected_token);
             }
             // Set source file so that errors will be reported with this file name
-            var sourceFile = createSourceFile(fileName, 2 /* ES2015 */, 6 /* JSON */, /*isDeclaration*/ false, statements, endOfFileToken, sourceFlags);
+            var sourceFile = createSourceFile(fileName, 2 /* ES2015 */, 6 /* JSON */, /*isDeclaration*/ false, statements, endOfFileToken, sourceFlags, ts.noop);
             if (setParentNodes) {
                 fixupParentReferences(sourceFile);
             }
@@ -31065,7 +31349,7 @@ var ts;
             notParenthesizedArrow = undefined;
             topLevel = true;
         }
-        function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind) {
+        function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind, setExternalModuleIndicator) {
             var isDeclarationFile = isDeclarationFileName(fileName);
             if (isDeclarationFile) {
                 contextFlags |= 8388608 /* Ambient */;
@@ -31076,7 +31360,7 @@ var ts;
             var statements = parseList(0 /* SourceElements */, parseStatement);
             ts.Debug.assert(token() === 1 /* EndOfFileToken */);
             var endOfFileToken = addJSDocComment(parseTokenNode());
-            var sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags);
+            var sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator);
             // A member of ReadonlyArray<T> isn't assignable to a member of T[] (and prevents a direct cast) - but this is where we set up those members so they can be readonly in the future
             processCommentPragmas(sourceFile, sourceText);
             processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
@@ -31213,25 +31497,30 @@ var ts;
             ts.setParentRecursive(rootNode, /*incremental*/ true);
         }
         Parser.fixupParentReferences = fixupParentReferences;
-        function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, flags) {
+        function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, flags, setExternalModuleIndicator) {
             // code from createNode is inlined here so createNode won't have to deal with special case of creating source files
             // this is quite rare comparing to other nodes and createNode should be as fast as possible
             var sourceFile = factory.createSourceFile(statements, endOfFileToken, flags);
             ts.setTextRangePosWidth(sourceFile, 0, sourceText.length);
-            setExternalModuleIndicator(sourceFile);
+            setFields(sourceFile);
             // If we parsed this as an external module, it may contain top-level await
             if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 16777216 /* ContainsPossibleTopLevelAwait */) {
                 sourceFile = reparseTopLevelAwait(sourceFile);
+                setFields(sourceFile);
             }
-            sourceFile.text = sourceText;
-            sourceFile.bindDiagnostics = [];
-            sourceFile.bindSuggestionDiagnostics = undefined;
-            sourceFile.languageVersion = languageVersion;
-            sourceFile.fileName = fileName;
-            sourceFile.languageVariant = ts.getLanguageVariant(scriptKind);
-            sourceFile.isDeclarationFile = isDeclarationFile;
-            sourceFile.scriptKind = scriptKind;
             return sourceFile;
+            function setFields(sourceFile) {
+                sourceFile.text = sourceText;
+                sourceFile.bindDiagnostics = [];
+                sourceFile.bindSuggestionDiagnostics = undefined;
+                sourceFile.languageVersion = languageVersion;
+                sourceFile.fileName = fileName;
+                sourceFile.languageVariant = ts.getLanguageVariant(scriptKind);
+                sourceFile.isDeclarationFile = isDeclarationFile;
+                sourceFile.scriptKind = scriptKind;
+                setExternalModuleIndicator(sourceFile);
+                sourceFile.setExternalModuleIndicator = setExternalModuleIndicator;
+            }
         }
         function setContextFlag(val, flag) {
             if (val) {
@@ -36714,35 +37003,6 @@ var ts;
             var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function setExternalModuleIndicator(sourceFile) {
-            // Try to use the first top-level import/export when available, then
-            // fall back to looking for an 'import.meta' somewhere in the tree if necessary.
-            sourceFile.externalModuleIndicator =
-                ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) ||
-                    getImportMetaIfNecessary(sourceFile);
-        }
-        function isAnExternalModuleIndicatorNode(node) {
-            return hasModifierOfKind(node, 93 /* ExportKeyword */)
-                || ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)
-                || ts.isImportDeclaration(node)
-                || ts.isExportAssignment(node)
-                || ts.isExportDeclaration(node) ? node : undefined;
-        }
-        function getImportMetaIfNecessary(sourceFile) {
-            return sourceFile.flags & 2097152 /* PossiblyContainsImportMeta */ ?
-                walkTreeForExternalModuleIndicators(sourceFile) :
-                undefined;
-        }
-        function walkTreeForExternalModuleIndicators(node) {
-            return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators);
-        }
-        /** Do not use hasModifier inside the parser; it relies on parent pointers. Use this instead. */
-        function hasModifierOfKind(node, kind) {
-            return ts.some(node.modifiers, function (m) { return m.kind === kind; });
-        }
-        function isImportMeta(node) {
-            return ts.isMetaProperty(node) && node.keywordToken === 100 /* ImportKeyword */ && node.name.escapedText === "meta";
-        }
         var ParsingContext;
         (function (ParsingContext) {
             ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements";
@@ -36785,7 +37045,7 @@ var ts;
                 scanner.setText(content, start, length);
                 currentToken = scanner.scan();
                 var jsDocTypeExpression = parseJSDocTypeExpression();
-                var sourceFile = createSourceFile("file.js", 99 /* Latest */, 1 /* JS */, /*isDeclarationFile*/ false, [], factory.createToken(1 /* EndOfFileToken */), 0 /* None */);
+                var sourceFile = createSourceFile("file.js", 99 /* Latest */, 1 /* JS */, /*isDeclarationFile*/ false, [], factory.createToken(1 /* EndOfFileToken */), 0 /* None */, ts.noop);
                 var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile);
                 if (jsDocDiagnostics) {
                     sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
@@ -37746,7 +38006,7 @@ var ts;
             if (sourceFile.statements.length === 0) {
                 // If we don't have any statements in the current source file, then there's no real
                 // way to incrementally parse.  So just do a full parse instead.
-                return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setParentNodes*/ true, sourceFile.scriptKind);
+                return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setParentNodes*/ true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
             }
             // Make sure we're not trying to incrementally update a source file more than once.  Once
             // we do an update the original source file is considered unusable from that point onwards.
@@ -37803,7 +38063,7 @@ var ts;
             // inconsistent tree.  Setting the parents on the new tree should be very fast.  We
             // will immediately bail out of walking any subtrees when we can see that their parents
             // are already correct.
-            var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /*setParentNodes*/ true, sourceFile.scriptKind);
+            var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /*setParentNodes*/ true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
             result.commentDirectives = getNewCommentDirectives(sourceFile.commentDirectives, result.commentDirectives, changeRange.span.start, ts.textSpanEnd(changeRange.span), delta, oldText, newText, aggressiveChecks);
             result.impliedNodeFormat = sourceFile.impliedNodeFormat;
             return result;
@@ -39719,6 +39979,18 @@ var ts;
             description: ts.Diagnostics.Specify_a_list_of_language_service_plugins_to_include,
             category: ts.Diagnostics.Editor_Support,
         },
+        {
+            name: "moduleDetection",
+            type: new ts.Map(ts.getEntries({
+                auto: ts.ModuleDetectionKind.Auto,
+                legacy: ts.ModuleDetectionKind.Legacy,
+                force: ts.ModuleDetectionKind.Force,
+            })),
+            affectsModuleResolution: true,
+            description: ts.Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
+            category: ts.Diagnostics.Language_and_Environment,
+            defaultValueDescription: ts.Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node12_as_modules,
+        }
     ];
     /* @internal */
     ts.optionDeclarations = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild, true), commandOptionsWithoutBuild, true);
@@ -47861,6 +48133,8 @@ var ts;
         var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
         var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t; });
         var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? wildcardType : t; });
+        var uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never"); // `uniqueLiteralType` is a special `never` flagged by union reduction to behave as a literal
+        var uniqueLiteralMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t; }); // replace all type parameters with the unique literal type (disregarding constraints)
         var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
@@ -48799,7 +49073,7 @@ var ts;
                             // - parameters are only in the scope of function body
                             // This restriction does not apply to JSDoc comment types because they are parented
                             // at a higher level than type parameters would normally be
-                            if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 319 /* JSDocComment */) {
+                            if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 319 /* JSDoc */) {
                                 useResult = result.flags & 262144 /* TypeParameter */
                                     // type parameters are visible in parameter list, return type and type parameter list
                                     ? lastLocation === location.type ||
@@ -51765,10 +52039,16 @@ var ts;
                     var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
                     var questionToken = type.declaration.questionToken ? ts.factory.createToken(type.declaration.questionToken.kind) : undefined;
                     var appropriateConstraintTypeNode;
+                    var newTypeVariable;
                     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                         // We have a { [P in keyof T]: X }
                         // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
-                        appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(140 /* KeyOfKeyword */, typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
+                        if (!(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                            var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
+                            var name = typeParameterToName(newParam, context);
+                            newTypeVariable = ts.factory.createTypeReferenceNode(name);
+                        }
+                        appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(140 /* KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
                     }
                     else {
                         appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context);
@@ -51778,7 +52058,14 @@ var ts;
                     var templateTypeNode = typeToTypeNodeHelper(removeMissingType(getTemplateTypeFromMappedType(type), !!(getMappedTypeModifiers(type) & 4 /* IncludeOptional */)), context);
                     var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
                     context.approximateLength += 10;
-                    return ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
+                    var result = ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
+                    if (isMappedTypeWithKeyofConstraintDeclaration(type) && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                        // homomorphic mapped type with a non-homomorphic naive inlining
+                        // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
+                        // type stays homomorphic
+                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(ts.factory.cloneNode(newTypeVariable.typeName))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                    }
+                    return result;
                 }
                 function createAnonymousTypeNode(type) {
                     var _a;
@@ -53399,7 +53686,7 @@ var ts;
                 // If it's a class/interface/function: emit a class/interface/function with a `default` modifier
                 // These forms can merge, eg (`export default 12; export default interface A {}`)
                 function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
-                    var _a, _b;
+                    var _a, _b, _c, _d;
                     var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName);
                     var isDefault = symbol.escapedName === "default" /* Default */;
                     if (isPrivate && !(context.flags & 131072 /* AllowAnonymousIdentifier */) && ts.isStringANonContextualKeyword(symbolName) && !isDefault) {
@@ -53450,17 +53737,21 @@ var ts;
                             else {
                                 // A Class + Property merge is made for a `module.exports.Member = class {}`, and it doesn't serialize well as either a class _or_ a property symbol - in fact, _it behaves like an alias!_
                                 // `var` is `FunctionScopedVariable`, `const` and `let` are `BlockScopedVariable`, and `module.exports.thing =` is `Property`
-                                var flags = !(symbol.flags & 2 /* BlockScopedVariable */) ? undefined
-                                    : isConstVariable(symbol) ? 2 /* Const */
+                                var flags = !(symbol.flags & 2 /* BlockScopedVariable */)
+                                    ? ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) && ts.isSourceFile((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration)
+                                        ? 2 /* Const */
+                                        : undefined
+                                    : isConstVariable(symbol)
+                                        ? 2 /* Const */
                                         : 1 /* Let */;
                                 var name = (needsPostExportDefault || !(symbol.flags & 4 /* Property */)) ? localName : getUnusedName(localName, symbol);
                                 var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); });
                                 if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
                                     textRange = textRange.parent.parent;
                                 }
-                                var propertyAccessRequire = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isPropertyAccessExpression);
+                                var propertyAccessRequire = (_c = symbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isPropertyAccessExpression);
                                 if (propertyAccessRequire && ts.isBinaryExpression(propertyAccessRequire.parent) && ts.isIdentifier(propertyAccessRequire.parent.right)
-                                    && ((_b = type.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) {
+                                    && ((_d = type.symbol) === null || _d === void 0 ? void 0 : _d.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) {
                                     var alias = localName === propertyAccessRequire.parent.right.escapedText ? undefined : propertyAccessRequire.parent.right;
                                     addResult(ts.factory.createExportDeclaration(
                                     /*decorators*/ undefined, 
@@ -53540,8 +53831,8 @@ var ts;
                         // synthesize export * from "moduleReference"
                         // Straightforward - only one thing to do - make an export declaration
                         if (symbol.declarations) {
-                            for (var _i = 0, _c = symbol.declarations; _i < _c.length; _i++) {
-                                var node = _c[_i];
+                            for (var _i = 0, _e = symbol.declarations; _i < _e.length; _i++) {
+                                var node = _e[_i];
                                 var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
                                 if (!resolvedModule)
                                     continue;
@@ -55347,7 +55638,10 @@ var ts;
             if (containsSameNamedThisProperty(expression.left, expression.right)) {
                 return anyType;
             }
-            var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right));
+            var isDirectExport = kind === 1 /* ExportsProperty */ && (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) && (ts.isModuleExportsAccessExpression(expression.left.expression) || (ts.isIdentifier(expression.left.expression) && ts.isExportsIdentifier(expression.left.expression)));
+            var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol)
+                : isDirectExport ? getRegularTypeOfLiteralType(checkExpressionCached(expression.right))
+                    : getWidenedLiteralType(checkExpressionCached(expression.right));
             if (type.flags & 524288 /* Object */ &&
                 kind === 2 /* ModuleExports */ &&
                 symbol.escapedName === "export=" /* ExportEquals */) {
@@ -56091,7 +56385,7 @@ var ts;
                             node = paramSymbol.valueDeclaration;
                         }
                         break;
-                    case 319 /* JSDocComment */: {
+                    case 319 /* JSDoc */: {
                         var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
                         return node.tags
                             ? appendTypeParameters(outerTypeParameters, ts.flatMap(node.tags, function (t) { return ts.isJSDocTemplateTag(t) ? t.typeParameters : undefined; }))
@@ -58352,10 +58646,10 @@ var ts;
                 else if (type !== firstType) {
                     checkFlags |= 64 /* HasNonUniformType */;
                 }
-                if (isLiteralType(type) || isPatternLiteralType(type)) {
+                if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) {
                     checkFlags |= 128 /* HasLiteralType */;
                 }
-                if (type.flags & 131072 /* Never */) {
+                if (type.flags & 131072 /* Never */ && type !== uniqueLiteralType) {
                     checkFlags |= 131072 /* HasNeverType */;
                 }
                 propTypes.push(type);
@@ -59540,7 +59834,7 @@ var ts;
         function getConditionalFlowTypeOfType(type, node) {
             var constraints;
             var covariant = true;
-            while (node && !ts.isStatement(node) && node.kind !== 319 /* JSDocComment */) {
+            while (node && !ts.isStatement(node) && node.kind !== 319 /* JSDoc */) {
                 var parent = node.parent;
                 // only consider variance flipped by parameter locations - `keyof` types would usually be considered variance inverting, but
                 // often get used in indexed accesses where they behave sortof invariantly, but our checking is lax
@@ -60896,10 +61190,24 @@ var ts;
             return getUnionType(ts.concatenate(propertyTypes, indexKeyTypes), 1 /* Literal */, 
             /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
         }
+        /**
+         * A union type which is reducible upon instantiation (meaning some members are removed under certain instantiations)
+         * must be kept generic, as that instantiation information needs to flow through the type system. By replacing all
+         * type parameters in the union with a special never type that is treated as a literal in `getReducedType`, we can cause the `getReducedType` logic
+         * to reduce the resulting type if possible (since only intersections with conflicting literal-typed properties are reducible).
+         */
+        function isPossiblyReducibleByInstantiation(type) {
+            return ts.some(type.types, function (t) {
+                var uniqueFilled = getUniqueLiteralFilledInstantiation(t);
+                return getReducedType(uniqueFilled) !== uniqueFilled;
+            });
+        }
         function getIndexType(type, stringsOnly, noIndexSignatures) {
             if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
             type = getReducedType(type);
-            return type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+            return type.flags & 1048576 /* Union */ ? isPossiblyReducibleByInstantiation(type)
+                ? getIndexTypeForGenericType(type, stringsOnly)
+                : getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                 type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                     type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
                         ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
@@ -61527,6 +61835,10 @@ var ts;
             }
             return type;
         }
+        function maybeCloneTypeParameter(p) {
+            var constraint = getConstraintOfTypeParameter(p);
+            return constraint && (isGenericObjectType(constraint) || isGenericIndexType(constraint)) ? cloneTypeParameter(p) : p;
+        }
         function isTypicalNondistributiveConditional(root) {
             return !root.isDistributive && isSingletonTupleType(root.node.checkType) && isSingletonTupleType(root.node.extendsType);
         }
@@ -61545,37 +61857,65 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            // We loop here for an immediately nested conditional type in the false position, effectively treating
-            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
-            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
-            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
-            // cases we increment the tail recursion counter and stop after 1000 iterations.
-            while (true) {
+            var _loop_18 = function () {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
-                    break;
+                    return "break";
                 }
                 var isUnwrapped = isTypicalNondistributiveConditional(root);
                 var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
                 var checkTypeInstantiable = isGenericType(checkType);
                 var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
                 if (checkType === wildcardType || extendsType === wildcardType) {
-                    return wildcardType;
+                    return { value: wildcardType };
                 }
                 var combinedMapper = void 0;
                 if (root.inferTypeParameters) {
-                    var context = createInferenceContext(root.inferTypeParameters, /*signature*/ undefined, 0 /* None */);
-                    if (!checkTypeInstantiable) {
+                    // When we're looking at making an inference for an infer type, when we get its constraint, it'll automagically be
+                    // instantiated with the context, so it doesn't need the mapper for the inference contex - however the constraint
+                    // may refer to another _root_, _uncloned_ `infer` type parameter [1], or to something mapped by `mapper` [2].
+                    // [1] Eg, if we have `Foo<T, U extends T>` and `Foo<number, infer B>` - `B` is constrained to `T`, which, in turn, has been instantiated
+                    // as `number`
+                    // Conversely, if we have `Foo<infer A, infer B>`, `B` is still constrained to `T` and `T` is instantiated as `A`
+                    // [2] Eg, if we have `Foo<T, U extends T>` and `Foo<Q, infer B>` where `Q` is mapped by `mapper` into `number` - `B` is constrained to `T`
+                    // which is in turn instantiated as `Q`, which is in turn instantiated as `number`.
+                    // So we need to:
+                    //    * Clone the type parameters so their constraints can be instantiated in the context of `mapper` (otherwise theyd only get inference context information)
+                    //    * Set the clones to both map the conditional's enclosing `mapper` and the original params
+                    //    * instantiate the extends type with the clones
+                    //    * incorporate all of the component mappers into the combined mapper for the true and false members
+                    // This means we have three mappers that need applying:
+                    //    * The original `mapper` used to create this conditional
+                    //    * The mapper that maps the old root type parameter to the clone (`freshMapper`)
+                    //    * The mapper that maps the clone to its inference result (`context.mapper`)
+                    var freshParams = ts.sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
+                    var freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : undefined;
+                    var context = createInferenceContext(freshParams, /*signature*/ undefined, 0 /* None */);
+                    if (freshMapper) {
+                        var freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
+                        for (var _i = 0, freshParams_1 = freshParams; _i < freshParams_1.length; _i++) {
+                            var p = freshParams_1[_i];
+                            if (root.inferTypeParameters.indexOf(p) === -1) {
+                                p.mapper = freshCombinedMapper;
+                            }
+                        }
+                    }
+                    // We skip inference of the possible `infer` types unles the `extendsType` _is_ an infer type
+                    // if it was, it's trivial to say that extendsType = checkType, however such a pattern is used to
+                    // "reset" the type being build up during constraint calculation and avoid making an apparently "infinite" constraint
+                    // so in those cases we refain from performing inference and retain the uninfered type parameter
+                    if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
                         // We don't want inferences from constraints as they may cause us to eagerly resolve the
                         // conditional type instead of deferring resolution. Also, we always want strict function
                         // types rules (i.e. proper contravariance) for inferences.
-                        inferTypes(context.inferences, checkType, extendsType, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+                        inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
                     }
+                    var innerMapper = combineTypeMappers(freshMapper, context.mapper);
                     // It's possible for 'infer T' type paramteters to be given uninstantiated constraints when the
                     // those type parameters are used in type references (see getInferredTypeParameterConstraint). For
                     // that reason we need context.mapper to be first in the combined mapper. See #42636 for examples.
-                    combinedMapper = mapper ? combineTypeMappers(context.mapper, mapper) : context.mapper;
+                    combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
                 }
                 // Instantiate the extends type including inferences for 'infer T' type parameters
                 var inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType;
@@ -61597,14 +61937,14 @@ var ts;
                             var newRoot = falseType_1.root;
                             if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
                                 root = newRoot;
-                                continue;
+                                return "continue";
                             }
                             if (canTailRecurse(falseType_1, mapper)) {
-                                continue;
+                                return "continue";
                             }
                         }
                         result = instantiateType(falseType_1, mapper);
-                        break;
+                        return "break";
                     }
                     // Return trueType for a definitely true extends check. We check instantiations of the two
                     // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter
@@ -61615,10 +61955,10 @@ var ts;
                         var trueType_1 = getTypeFromTypeNode(root.node.trueType);
                         var trueMapper = combinedMapper || mapper;
                         if (canTailRecurse(trueType_1, trueMapper)) {
-                            continue;
+                            return "continue";
                         }
                         result = instantiateType(trueType_1, trueMapper);
-                        break;
+                        return "break";
                     }
                 }
                 // Return a deferred type for a check that is neither definitely true nor definitely false
@@ -61630,7 +61970,19 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
-                break;
+                return "break";
+            };
+            // We loop here for an immediately nested conditional type in the false position, effectively treating
+            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
+            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
+            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
+            // cases we increment the tail recursion counter and stop after 1000 iterations.
+            while (true) {
+                var state_5 = _loop_18();
+                if (typeof state_5 === "object")
+                    return state_5.value;
+                if (state_5 === "break")
+                    break;
             }
             return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
             // We tail-recurse for generic conditional types that (a) have not already been evaluated and cached, and
@@ -62052,9 +62404,11 @@ var ts;
         }
         function getESSymbolLikeTypeForNode(node) {
             if (ts.isValidESSymbolDeclaration(node)) {
-                var symbol = getSymbolOfNode(node);
-                var links = getSymbolLinks(symbol);
-                return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+                var symbol = ts.isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node);
+                if (symbol) {
+                    var links = getSymbolLinks(symbol);
+                    return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+                }
             }
             return esSymbolType;
         }
@@ -62698,6 +63052,10 @@ var ts;
             }
             return type; // Nested invocation of `inferTypeForHomomorphicMappedType` or the `source` instantiated into something unmappable
         }
+        function getUniqueLiteralFilledInstantiation(type) {
+            return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type :
+                type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+        }
         function getPermissiveInstantiation(type) {
             return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type :
                 type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
@@ -63586,7 +63944,8 @@ var ts;
                     return true;
                 }
             }
-            else {
+            else if (!((source.flags | target.flags) & (3145728 /* UnionOrIntersection */ | 8388608 /* IndexedAccess */ | 16777216 /* Conditional */ | 33554432 /* Substitution */))) {
+                // We have excluded types that may simplify to other forms, so types must have identical flags
                 if (source.flags !== target.flags)
                     return false;
                 if (source.flags & 67358815 /* Singleton */)
@@ -64157,7 +64516,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_18 = function (prop) {
+                var _loop_19 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -64220,9 +64579,9 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_5 = _loop_18(prop);
-                    if (typeof state_5 === "object")
-                        return state_5.value;
+                    var state_6 = _loop_19(prop);
+                    if (typeof state_6 === "object")
+                        return state_6.value;
                 }
                 return false;
             }
@@ -65212,11 +65571,11 @@ var ts;
                 // constituents of 'target'. If any combination does not have a match then 'source' is not relatable.
                 var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
                 var matchingTypes = [];
-                var _loop_19 = function (combination) {
+                var _loop_20 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_20 = function (i) {
+                        var _loop_21 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -65232,8 +65591,8 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_7 = _loop_20(i);
-                            switch (state_7) {
+                            var state_8 = _loop_21(i);
+                            switch (state_8) {
                                 case "continue-outer": continue outer;
                             }
                         }
@@ -65246,9 +65605,9 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_6 = _loop_19(combination);
-                    if (typeof state_6 === "object")
-                        return state_6.value;
+                    var state_7 = _loop_20(combination);
+                    if (typeof state_7 === "object")
+                        return state_7.value;
                 }
                 // Compare the remaining non-discriminant properties of each match.
                 var result = -1 /* True */;
@@ -65961,7 +66320,7 @@ var ts;
                 // The emptyArray singleton is used to signal a recursive invocation.
                 cache.variances = ts.emptyArray;
                 variances = [];
-                var _loop_21 = function (tp) {
+                var _loop_22 = function (tp) {
                     var unmeasurable = false;
                     var unreliable = false;
                     var oldHandler = outofbandVarianceMarkerHandler;
@@ -65993,7 +66352,7 @@ var ts;
                 };
                 for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
                     var tp = typeParameters_1[_i];
-                    _loop_21(tp);
+                    _loop_22(tp);
                 }
                 cache.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -68364,7 +68723,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_22 = function (type) {
+            var _loop_23 = function (type) {
                 if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -68390,9 +68749,9 @@ var ts;
             };
             for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
                 var type = types_16[_i];
-                var state_8 = _loop_22(type);
-                if (typeof state_8 === "object")
-                    return state_8.value;
+                var state_9 = _loop_23(type);
+                if (typeof state_9 === "object")
+                    return state_9.value;
             }
             return count >= 10 && count * 2 >= types.length ? map : undefined;
         }
@@ -69662,7 +70021,7 @@ var ts;
                 return result;
             }
             function getCandidateDiscriminantPropertyAccess(expr) {
-                if (ts.isBindingPattern(reference) || ts.isFunctionExpressionOrArrowFunction(reference)) {
+                if (ts.isBindingPattern(reference) || ts.isFunctionExpressionOrArrowFunction(reference) || ts.isObjectLiteralMethod(reference)) {
                     // When the reference is a binding pattern or function or arrow expression, we are narrowing a pesudo-reference in
                     // getNarrowedTypeOfSymbol. An identifier for a destructuring variable declared in the same binding pattern or
                     // parameter declared in the same parameter list is a candidate.
@@ -74723,7 +75082,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_23 = function (i) {
+                var _loop_24 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 224 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -74740,7 +75099,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_23(i);
+                    _loop_24(i);
                 }
                 return effectiveArgs_1;
             }
@@ -75053,7 +75412,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_24 = function (c) {
+                        var _loop_25 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -75071,7 +75430,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_24(c);
+                            _loop_25(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -75229,7 +75588,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_25 = function (i) {
+            var _loop_26 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -75237,7 +75596,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_25(i);
+                _loop_26(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* None */;
@@ -76634,6 +76993,9 @@ var ts;
                     assignBindingElementTypes(declaration.name, links.type);
                 }
             }
+            else if (type) {
+                ts.Debug.assertEqual(links.type, type, "Parameter symbol already has a cached type which differs from newly assigned type");
+            }
         }
         // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push
         // the destructured type into the contained binding elements.
@@ -78464,7 +78826,7 @@ var ts;
         }
         function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
             var type = checkExpression(node, checkMode, forceTuple);
-            return isConstContext(node) ? getRegularTypeOfLiteralType(type) :
+            return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
                     getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
         }
@@ -79233,7 +79595,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_26 = function (declaration) {
+                var _loop_27 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -79248,7 +79610,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_26(declaration);
+                    _loop_27(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -82627,7 +82989,7 @@ var ts;
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 257 /* InterfaceDeclaration */) : undefined;
             var localPropDeclaration = declaration && declaration.kind === 220 /* BinaryExpression */ ||
                 name && name.kind === 161 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_27 = function (info) {
+            var _loop_28 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -82640,7 +83002,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_27(info);
+                _loop_28(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -82648,7 +83010,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 257 /* InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_28 = function (info) {
+            var _loop_29 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -82663,7 +83025,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_28(info);
+                _loop_29(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -82974,7 +83336,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_29 = function (member) {
+            var _loop_30 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -82991,7 +83353,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_29(member);
+                _loop_30(member);
             }
         }
         /**
@@ -83079,7 +83441,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_30 = function (member) {
+            var _loop_31 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -83098,7 +83460,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_30(member);
+                _loop_31(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -87526,8 +87888,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
-                    var element = elements_1[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (!ts.isOmittedExpression(element)) {
                         return checkESModuleMarker(element.name);
                     }
@@ -87543,8 +87905,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
-                    var element = elements_2[_i];
+                for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) {
+                    var element = elements_3[_i];
                     if (!ts.isOmittedExpression(element)) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -89798,8 +90160,8 @@ var ts;
     }
     function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) {
         var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern);
-        for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) {
-            var element = elements_3[_i];
+        for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) {
+            var element = elements_4[_i];
             if (bindingOrAssignmentElementAssignsToName(element, escapedName)) {
                 return true;
             }
@@ -95417,8 +95779,8 @@ var ts;
         function chunkObjectLiteralElements(elements) {
             var chunkObject;
             var objects = [];
-            for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) {
-                var e = elements_4[_i];
+            for (var _i = 0, elements_5 = elements; _i < elements_5.length; _i++) {
+                var e = elements_5[_i];
                 if (e.kind === 297 /* SpreadAssignment */) {
                     if (chunkObject) {
                         objects.push(factory.createObjectLiteralExpression(chunkObject));
@@ -110063,7 +110425,7 @@ var ts;
                         return emitRestOrJSDocVariadicType(node);
                     case 318 /* JSDocNamepathType */:
                         return;
-                    case 319 /* JSDocComment */:
+                    case 319 /* JSDoc */:
                         return emitJSDoc(node);
                     case 321 /* JSDocTypeLiteral */:
                         return emitJSDocTypeLiteral(node);
@@ -114439,7 +114801,7 @@ var ts;
         var existingDirectories = new ts.Map();
         var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames);
         var computeHash = ts.maybeBind(system, system.createHash) || ts.generateDjb2Hash;
-        function getSourceFile(fileName, languageVersion, onError) {
+        function getSourceFile(fileName, languageVersionOrOptions, onError) {
             var text;
             try {
                 ts.performance.mark("beforeIORead");
@@ -114453,7 +114815,7 @@ var ts;
                 }
                 text = "";
             }
-            return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined;
+            return text !== undefined ? ts.createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : undefined;
         }
         function directoryExists(directoryPath) {
             if (existingDirectories.has(directoryPath)) {
@@ -115859,8 +116221,8 @@ var ts;
             for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) {
                 var oldSourceFile = oldSourceFiles_2[_i];
                 var newSourceFile = host.getSourceFileByPath
-                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, ts.getEmitScriptTarget(options), /*onError*/ undefined, shouldCreateNewSourceFile)
-                    : host.getSourceFile(oldSourceFile.fileName, ts.getEmitScriptTarget(options), /*onError*/ undefined, shouldCreateNewSourceFile); // TODO: GH#18217
+                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options), /*onError*/ undefined, shouldCreateNewSourceFile)
+                    : host.getSourceFile(oldSourceFile.fileName, getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options), /*onError*/ undefined, shouldCreateNewSourceFile); // TODO: GH#18217
                 if (!newSourceFile) {
                     return 0 /* Not */;
                 }
@@ -115891,7 +116253,6 @@ var ts;
                 newSourceFile.originalFileName = oldSourceFile.originalFileName;
                 newSourceFile.resolvedPath = oldSourceFile.resolvedPath;
                 newSourceFile.fileName = oldSourceFile.fileName;
-                newSourceFile.impliedNodeFormat = oldSourceFile.impliedNodeFormat;
                 var packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path);
                 if (packageName !== undefined) {
                     // If there are 2 different source files for the same package name and at least one of them changes,
@@ -116810,6 +117171,17 @@ var ts;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
+        function getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options) {
+            // It's a _little odd_ that we can't set `impliedNodeFormat` until the program step - but it's the first and only time we have a resolution cache
+            // and a freshly made source file node on hand at the same time, and we need both to set the field. Persisting the resolution cache all the way
+            // to the check and emit steps would be bad - so we much prefer detecting and storing the format information on the source file node upfront.
+            var impliedNodeFormat = getImpliedNodeFormatForFile(toPath(fileName), moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
+            return {
+                languageVersion: ts.getEmitScriptTarget(options),
+                impliedNodeFormat: impliedNodeFormat,
+                setExternalModuleIndicator: ts.getSetExternalModuleIndicator(options)
+            };
+        }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
             var path = toPath(fileName);
             if (useSourceOfProjectReferenceRedirect) {
@@ -116897,7 +117269,7 @@ var ts;
                 }
             }
             // We haven't looked for this file, do so now and cache result
-            var file = host.getSourceFile(fileName, ts.getEmitScriptTarget(options), function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile);
+            var file = host.getSourceFile(fileName, getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options), function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile);
             if (packageId) {
                 var packageIdKey = ts.packageIdToString(packageId);
                 var fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
@@ -116925,10 +117297,6 @@ var ts;
                 file.path = path;
                 file.resolvedPath = toPath(fileName);
                 file.originalFileName = originalFileName;
-                // It's a _little odd_ that we can't set `impliedNodeFormat` until the program step - but it's the first and only time we have a resolution cache
-                // and a freshly made source file node on hand at the same time, and we need both to set the field. Persisting the resolution cache all the way
-                // to the check and emit steps would be bad - so we much prefer detecting and storing the format information on the source file node upfront.
-                file.impliedNodeFormat = getImpliedNodeFormatForFile(file.resolvedPath, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
                 addFileIncludeReason(file, reason);
                 if (host.useCaseSensitiveFileNames()) {
                     var pathLowerCase = ts.toFileNameLowerCase(path);
@@ -117430,7 +117798,7 @@ var ts;
             }
             else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 /* ES2015 */ && options.module === ts.ModuleKind.None) {
                 // We cannot use createDiagnosticFromNode because nodes do not have parents yet
-                var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
+                var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
                 programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
             }
             // Cannot specify module gen that isn't amd or system with --out
@@ -117439,7 +117807,7 @@ var ts;
                     createDiagnosticForOptionName(ts.Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module");
                 }
                 else if (options.module === undefined && firstNonAmbientExternalModuleSourceFile) {
-                    var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
+                    var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
                     programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile"));
                 }
             }
@@ -120885,7 +121253,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_31 = function (directory) {
+            var _loop_32 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -120909,9 +121277,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_9 = _loop_31(directory);
+                var state_10 = _loop_32(directory);
                 directory = out_directory_1;
-                if (state_9 === "break")
+                if (state_10 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -121701,7 +122069,7 @@ var ts;
         var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
         var hostGetNewLine = ts.memoize(function () { return host.getNewLine(); });
         return {
-            getSourceFile: function (fileName, languageVersion, onError) {
+            getSourceFile: function (fileName, languageVersionOrOptions, onError) {
                 var text;
                 try {
                     ts.performance.mark("beforeIORead");
@@ -121715,7 +122083,7 @@ var ts;
                     }
                     text = "";
                 }
-                return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion) : undefined;
+                return text !== undefined ? ts.createSourceFile(fileName, text, languageVersionOrOptions) : undefined;
             },
             getDefaultLibLocation: ts.maybeBind(host, host.getDefaultLibLocation),
             getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
@@ -122183,7 +122551,7 @@ var ts;
             }
             return directoryStructureHost.fileExists(fileName);
         }
-        function getVersionedSourceFileByPath(fileName, path, languageVersion, onError, shouldCreateNewSourceFile) {
+        function getVersionedSourceFileByPath(fileName, path, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             var hostSourceFile = sourceFilesCache.get(path);
             // No source file on the host
             if (isFileMissingOnHost(hostSourceFile)) {
@@ -122191,7 +122559,7 @@ var ts;
             }
             // Create new source file if requested or the versions dont match
             if (hostSourceFile === undefined || shouldCreateNewSourceFile || isFilePresenceUnknownOnHost(hostSourceFile)) {
-                var sourceFile = getNewSourceFile(fileName, languageVersion, onError);
+                var sourceFile = getNewSourceFile(fileName, languageVersionOrOptions, onError);
                 if (hostSourceFile) {
                     if (sourceFile) {
                         // Set the source file and create file watcher now that file was present on the disk
@@ -134296,9 +134664,15 @@ var ts;
             });
             return JSON.stringify(bucketInfoArray, undefined, 2);
         }
+        function getCompilationSettings(settingsOrHost) {
+            if (typeof settingsOrHost.getCompilationSettings === "function") {
+                return settingsOrHost.getCompilationSettings();
+            }
+            return settingsOrHost;
+        }
         function acquireDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
             var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
-            var key = getKeyForCompilationSettings(compilationSettings);
+            var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
             return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
         }
         function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
@@ -134306,20 +134680,28 @@ var ts;
         }
         function updateDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
             var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
-            var key = getKeyForCompilationSettings(compilationSettings);
+            var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
             return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
         }
         function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
-            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+            return acquireOrUpdateDocument(fileName, path, getCompilationSettings(compilationSettings), key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
         }
         function getDocumentRegistryEntry(bucketEntry, scriptKind) {
             var entry = isDocumentRegistryEntry(bucketEntry) ? bucketEntry : bucketEntry.get(ts.Debug.checkDefined(scriptKind, "If there are more than one scriptKind's for same document the scriptKind should be provided"));
             ts.Debug.assert(scriptKind === undefined || !entry || entry.sourceFile.scriptKind === scriptKind, "Script kind should match provided ScriptKind:" + scriptKind + " and sourceFile.scriptKind: " + (entry === null || entry === void 0 ? void 0 : entry.sourceFile.scriptKind) + ", !entry: " + !entry);
             return entry;
         }
-        function acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, acquiring, scriptKind) {
+        function acquireOrUpdateDocument(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, acquiring, scriptKind) {
+            var _a, _b, _c, _d;
             scriptKind = ts.ensureScriptKind(fileName, scriptKind);
+            var compilationSettings = getCompilationSettings(compilationSettingsOrHost);
+            var host = compilationSettingsOrHost === compilationSettings ? undefined : compilationSettingsOrHost;
             var scriptTarget = scriptKind === 6 /* JSON */ ? 100 /* JSON */ : ts.getEmitScriptTarget(compilationSettings);
+            var sourceFileOptions = {
+                languageVersion: scriptTarget,
+                impliedNodeFormat: host && ts.getImpliedNodeFormatForFile(path, (_d = (_c = (_b = (_a = host.getCompilerHost) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getModuleResolutionCache) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
+                setExternalModuleIndicator: ts.getSetExternalModuleIndicator(compilationSettings)
+            };
             var oldBucketCount = buckets.size;
             var bucket = ts.getOrUpdate(buckets, key, function () { return new ts.Map(); });
             if (ts.tracing) {
@@ -134353,7 +134735,7 @@ var ts;
             }
             if (!entry) {
                 // Have never seen this file with these settings.  Create a new source file for it.
-                var sourceFile = ts.createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, /*setNodeParents*/ false, scriptKind);
+                var sourceFile = ts.createLanguageServiceSourceFile(fileName, scriptSnapshot, sourceFileOptions, version, /*setNodeParents*/ false, scriptKind);
                 if (externalCache) {
                     externalCache.setDocument(key, path, sourceFile);
                 }
@@ -142797,7 +143179,7 @@ var ts;
                     continue;
                 var module_1 = ts.getResolvedModule(sourceFile, moduleSpecifier.text, ts.getModeForUsageLocation(sourceFile, moduleSpecifier));
                 var resolvedFile = module_1 && program.getSourceFile(module_1.resolvedFileName);
-                if (resolvedFile && resolvedFile.externalModuleIndicator && ts.isExportAssignment(resolvedFile.externalModuleIndicator) && resolvedFile.externalModuleIndicator.isExportEquals) {
+                if (resolvedFile && resolvedFile.externalModuleIndicator && resolvedFile.externalModuleIndicator !== true && ts.isExportAssignment(resolvedFile.externalModuleIndicator) && resolvedFile.externalModuleIndicator.isExportEquals) {
                     diags.push(ts.createDiagnosticForNode(name, ts.Diagnostics.Import_may_be_converted_to_a_default_import));
                 }
             }
@@ -143713,19 +144095,7 @@ var ts;
         options.suppressOutputPathCheck = true;
         // Filename can be non-ts file.
         options.allowNonTsExtensions = true;
-        // if jsx is specified then treat file as .tsx
-        var inputFileName = transpileOptions.fileName || (transpileOptions.compilerOptions && transpileOptions.compilerOptions.jsx ? "module.tsx" : "module.ts");
-        var sourceFile = ts.createSourceFile(inputFileName, input, ts.getEmitScriptTarget(options));
-        if (transpileOptions.moduleName) {
-            sourceFile.moduleName = transpileOptions.moduleName;
-        }
-        if (transpileOptions.renamedDependencies) {
-            sourceFile.renamedDependencies = new ts.Map(ts.getEntries(transpileOptions.renamedDependencies));
-        }
         var newLine = ts.getNewLineCharacter(options);
-        // Output
-        var outputText;
-        var sourceMapText;
         // Create a compilerHost object to allow the compiler to read and write files
         var compilerHost = {
             getSourceFile: function (fileName) { return fileName === ts.normalizePath(inputFileName) ? sourceFile : undefined; },
@@ -143749,6 +144119,22 @@ var ts;
             directoryExists: function () { return true; },
             getDirectories: function () { return []; }
         };
+        // if jsx is specified then treat file as .tsx
+        var inputFileName = transpileOptions.fileName || (transpileOptions.compilerOptions && transpileOptions.compilerOptions.jsx ? "module.tsx" : "module.ts");
+        var sourceFile = ts.createSourceFile(inputFileName, input, {
+            languageVersion: ts.getEmitScriptTarget(options),
+            impliedNodeFormat: ts.getImpliedNodeFormatForFile(ts.toPath(inputFileName, "", compilerHost.getCanonicalFileName), /*cache*/ undefined, compilerHost, options),
+            setExternalModuleIndicator: ts.getSetExternalModuleIndicator(options)
+        });
+        if (transpileOptions.moduleName) {
+            sourceFile.moduleName = transpileOptions.moduleName;
+        }
+        if (transpileOptions.renamedDependencies) {
+            sourceFile.renamedDependencies = new ts.Map(ts.getEntries(transpileOptions.renamedDependencies));
+        }
+        // Output
+        var outputText;
+        var sourceMapText;
         var program = ts.createProgram([inputFileName], options, compilerHost);
         if (transpileOptions.reportDiagnostics) {
             ts.addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile));
@@ -160261,7 +160647,7 @@ var ts;
             for (var i = 1;; i++) {
                 var name = ts.combinePaths(inDirectory, newModuleName + extension);
                 if (!host.fileExists(name))
-                    return newModuleName; // TODO: GH#18217
+                    return newModuleName;
                 newModuleName = moduleName + "." + i;
             }
         }
@@ -162621,6 +163007,7 @@ var ts;
             this.host = host;
         }
         SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             var scriptSnapshot = this.host.getScriptSnapshot(fileName);
             if (!scriptSnapshot) {
                 // The host does not know about this file.
@@ -162631,7 +163018,12 @@ var ts;
             var sourceFile;
             if (this.currentFileName !== fileName) {
                 // This is a new file, just parse it
-                sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 99 /* Latest */, version, /*setNodeParents*/ true, scriptKind);
+                var options = {
+                    languageVersion: 99 /* Latest */,
+                    impliedNodeFormat: ts.getImpliedNodeFormatForFile(ts.toPath(fileName, this.host.getCurrentDirectory(), ((_c = (_b = (_a = this.host).getCompilerHost) === null || _b === void 0 ? void 0 : _b.call(_a)) === null || _c === void 0 ? void 0 : _c.getCanonicalFileName) || ts.hostGetCanonicalFileName(this.host)), (_h = (_g = (_f = (_e = (_d = this.host).getCompilerHost) === null || _e === void 0 ? void 0 : _e.call(_d)) === null || _f === void 0 ? void 0 : _f.getModuleResolutionCache) === null || _g === void 0 ? void 0 : _g.call(_f)) === null || _h === void 0 ? void 0 : _h.getPackageJsonInfoCache(), this.host, this.host.getCompilationSettings()),
+                    setExternalModuleIndicator: ts.getSetExternalModuleIndicator(this.host.getCompilationSettings())
+                };
+                sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, options, version, /*setNodeParents*/ true, scriptKind);
             }
             else if (this.currentFileVersion !== version) {
                 // This is the same file, just a newer version. Incrementally parse the file.
@@ -162653,8 +163045,8 @@ var ts;
         sourceFile.version = version;
         sourceFile.scriptSnapshot = scriptSnapshot;
     }
-    function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, setNodeParents, scriptKind) {
-        var sourceFile = ts.createSourceFile(fileName, ts.getSnapshotText(scriptSnapshot), scriptTarget, setNodeParents, scriptKind);
+    function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTargetOrOptions, version, setNodeParents, scriptKind) {
+        var sourceFile = ts.createSourceFile(fileName, ts.getSnapshotText(scriptSnapshot), scriptTargetOrOptions, setNodeParents, scriptKind);
         setSourceFileFields(sourceFile, scriptSnapshot, version);
         return sourceFile;
     }
@@ -162702,8 +163094,13 @@ var ts;
                 return newSourceFile;
             }
         }
+        var options = {
+            languageVersion: sourceFile.languageVersion,
+            impliedNodeFormat: sourceFile.impliedNodeFormat,
+            setExternalModuleIndicator: sourceFile.setExternalModuleIndicator,
+        };
         // Otherwise, just create a new source file.
-        return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents*/ true, sourceFile.scriptKind);
+        return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, options, version, /*setNodeParents*/ true, sourceFile.scriptKind);
     }
     ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile;
     var NoopCancellationToken = {
@@ -163047,7 +163444,7 @@ var ts;
                         // file's script kind, i.e. in one project some file is treated as ".ts"
                         // and in another as ".js"
                         if (hostFileInformation.scriptKind === oldSourceFile.scriptKind) {
-                            return documentRegistry.updateDocumentWithKey(fileName, path, newSettings, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+                            return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
                         }
                         else {
                             // Release old source file and fall through to aquire new file with new script kind
@@ -163057,7 +163454,7 @@ var ts;
                     // We didn't already have the file.  Fall through and acquire it from the registry.
                 }
                 // Could not find this file in the old program, create a new SourceFile for it.
-                return documentRegistry.acquireDocumentWithKey(fileName, path, newSettings, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+                return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
             }
         }
         // TODO: GH#18217 frequently asserted as defined