typescript 4.6.0-dev.20220208 → 4.6.1-rc

package/lib/typingsInstaller.js

@@ -22,7 +22,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
             ar[i] = from[i];
         }
     }
-    return to.concat(ar || from);
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220208";
+    ts.version = "".concat(ts.versionMajorMinor, ".1-rc");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -136,7 +136,7 @@ var ts;
         var constructor = (_a = NativeCollections[nativeFactory]()) !== null && _a !== void 0 ? _a : ts.ShimCollections === null || ts.ShimCollections === void 0 ? void 0 : ts.ShimCollections[shimFactory](ts.getIterator);
         if (constructor)
             return constructor;
-        throw new Error("TypeScript requires an environment that provides a compatible native " + name + " implementation.");
+        throw new Error("TypeScript requires an environment that provides a compatible native ".concat(name, " implementation."));
     }
 })(ts || (ts = {}));
 /* @internal */
@@ -1486,7 +1486,7 @@ var ts;
     function cast(value, test) {
         if (value !== undefined && test(value))
             return value;
-        return ts.Debug.fail("Invalid cast. The supplied value " + value + " did not pass the test '" + ts.Debug.getFunctionName(test) + "'.");
+        return ts.Debug.fail("Invalid cast. The supplied value ".concat(value, " did not pass the test '").concat(ts.Debug.getFunctionName(test), "'."));
     }
     ts.cast = cast;
     /** Does nothing. */
@@ -1577,7 +1577,7 @@ var ts;
     function memoizeOne(callback) {
         var map = new ts.Map();
         return function (arg) {
-            var key = typeof arg + ":" + arg;
+            var key = "".concat(typeof arg, ":").concat(arg);
             var value = map.get(key);
             if (value === undefined && !map.has(key)) {
                 value = callback(arg);
@@ -2027,7 +2027,7 @@ var ts;
     ts.createGetCanonicalFileName = createGetCanonicalFileName;
     function patternText(_a) {
         var prefix = _a.prefix, suffix = _a.suffix;
-        return prefix + "*" + suffix;
+        return "".concat(prefix, "*").concat(suffix);
     }
     ts.patternText = patternText;
     /**
@@ -2340,7 +2340,7 @@ var ts;
         }
         function fail(message, stackCrawlMark) {
             debugger;
-            var e = new Error(message ? "Debug Failure. " + message : "Debug Failure.");
+            var e = new Error(message ? "Debug Failure. ".concat(message) : "Debug Failure.");
             if (Error.captureStackTrace) {
                 Error.captureStackTrace(e, stackCrawlMark || fail);
             }
@@ -2348,12 +2348,12 @@ var ts;
         }
         Debug.fail = fail;
         function failBadSyntaxKind(node, message, stackCrawlMark) {
-            return fail((message || "Unexpected node.") + "\r\nNode " + formatSyntaxKind(node.kind) + " was unexpected.", stackCrawlMark || failBadSyntaxKind);
+            return fail("".concat(message || "Unexpected node.", "\r\nNode ").concat(formatSyntaxKind(node.kind), " was unexpected."), stackCrawlMark || failBadSyntaxKind);
         }
         Debug.failBadSyntaxKind = failBadSyntaxKind;
         function assert(expression, message, verboseDebugInfo, stackCrawlMark) {
             if (!expression) {
-                message = message ? "False expression: " + message : "False expression.";
+                message = message ? "False expression: ".concat(message) : "False expression.";
                 if (verboseDebugInfo) {
                     message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
                 }
@@ -2363,26 +2363,26 @@ var ts;
         Debug.assert = assert;
         function assertEqual(a, b, msg, msg2, stackCrawlMark) {
             if (a !== b) {
-                var message = msg ? msg2 ? msg + " " + msg2 : msg : "";
-                fail("Expected " + a + " === " + b + ". " + message, stackCrawlMark || assertEqual);
+                var message = msg ? msg2 ? "".concat(msg, " ").concat(msg2) : msg : "";
+                fail("Expected ".concat(a, " === ").concat(b, ". ").concat(message), stackCrawlMark || assertEqual);
             }
         }
         Debug.assertEqual = assertEqual;
         function assertLessThan(a, b, msg, stackCrawlMark) {
             if (a >= b) {
-                fail("Expected " + a + " < " + b + ". " + (msg || ""), stackCrawlMark || assertLessThan);
+                fail("Expected ".concat(a, " < ").concat(b, ". ").concat(msg || ""), stackCrawlMark || assertLessThan);
             }
         }
         Debug.assertLessThan = assertLessThan;
         function assertLessThanOrEqual(a, b, stackCrawlMark) {
             if (a > b) {
-                fail("Expected " + a + " <= " + b, stackCrawlMark || assertLessThanOrEqual);
+                fail("Expected ".concat(a, " <= ").concat(b), stackCrawlMark || assertLessThanOrEqual);
             }
         }
         Debug.assertLessThanOrEqual = assertLessThanOrEqual;
         function assertGreaterThanOrEqual(a, b, stackCrawlMark) {
             if (a < b) {
-                fail("Expected " + a + " >= " + b, stackCrawlMark || assertGreaterThanOrEqual);
+                fail("Expected ".concat(a, " >= ").concat(b), stackCrawlMark || assertGreaterThanOrEqual);
             }
         }
         Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
@@ -2413,42 +2413,42 @@ var ts;
         function assertNever(member, message, stackCrawlMark) {
             if (message === void 0) { message = "Illegal value:"; }
             var detail = typeof member === "object" && ts.hasProperty(member, "kind") && ts.hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
-            return fail(message + " " + detail, stackCrawlMark || assertNever);
+            return fail("".concat(message, " ").concat(detail), stackCrawlMark || assertNever);
         }
         Debug.assertNever = assertNever;
         function assertEachNode(nodes, test, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertEachNode")) {
-                assert(test === undefined || ts.every(nodes, test), message || "Unexpected node.", function () { return "Node array did not pass test '" + getFunctionName(test) + "'."; }, stackCrawlMark || assertEachNode);
+                assert(test === undefined || ts.every(nodes, test), message || "Unexpected node.", function () { return "Node array did not pass test '".concat(getFunctionName(test), "'."); }, stackCrawlMark || assertEachNode);
             }
         }
         Debug.assertEachNode = assertEachNode;
         function assertNode(node, test, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertNode")) {
-                assert(node !== undefined && (test === undefined || test(node)), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, stackCrawlMark || assertNode);
+                assert(node !== undefined && (test === undefined || test(node)), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " did not pass test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertNode);
             }
         }
         Debug.assertNode = assertNode;
         function assertNotNode(node, test, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertNotNode")) {
-                assert(node === undefined || test === undefined || !test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " should not have passed test '" + getFunctionName(test) + "'."; }, stackCrawlMark || assertNotNode);
+                assert(node === undefined || test === undefined || !test(node), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node.kind), " should not have passed test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertNotNode);
             }
         }
         Debug.assertNotNode = assertNotNode;
         function assertOptionalNode(node, test, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertOptionalNode")) {
-                assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, stackCrawlMark || assertOptionalNode);
+                assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " did not pass test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertOptionalNode);
             }
         }
         Debug.assertOptionalNode = assertOptionalNode;
         function assertOptionalToken(node, kind, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertOptionalToken")) {
-                assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind) + " was not a '" + formatSyntaxKind(kind) + "' token."; }, stackCrawlMark || assertOptionalToken);
+                assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " was not a '").concat(formatSyntaxKind(kind), "' token."); }, stackCrawlMark || assertOptionalToken);
             }
         }
         Debug.assertOptionalToken = assertOptionalToken;
         function assertMissingNode(node, message, stackCrawlMark) {
             if (shouldAssertFunction(1 /* Normal */, "assertMissingNode")) {
-                assert(node === undefined, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " was unexpected'."; }, stackCrawlMark || assertMissingNode);
+                assert(node === undefined, message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node.kind), " was unexpected'."); }, stackCrawlMark || assertMissingNode);
             }
         }
         Debug.assertMissingNode = assertMissingNode;
@@ -2469,7 +2469,7 @@ var ts;
         }
         Debug.getFunctionName = getFunctionName;
         function formatSymbol(symbol) {
-            return "{ name: " + ts.unescapeLeadingUnderscores(symbol.escapedName) + "; flags: " + formatSymbolFlags(symbol.flags) + "; declarations: " + ts.map(symbol.declarations, function (node) { return formatSyntaxKind(node.kind); }) + " }";
+            return "{ name: ".concat(ts.unescapeLeadingUnderscores(symbol.escapedName), "; flags: ").concat(formatSymbolFlags(symbol.flags), "; declarations: ").concat(ts.map(symbol.declarations, function (node) { return formatSyntaxKind(node.kind); }), " }");
         }
         Debug.formatSymbol = formatSymbol;
         /**
@@ -2490,7 +2490,7 @@ var ts;
                         break;
                     }
                     if (enumValue !== 0 && enumValue & value) {
-                        result = "" + result + (result ? "|" : "") + enumName;
+                        result = "".concat(result).concat(result ? "|" : "").concat(enumName);
                         remainingFlags &= ~enumValue;
                     }
                 }
@@ -2600,7 +2600,7 @@ var ts;
                                                                     this.flags & 1 /* Unreachable */ ? "FlowUnreachable" :
                                                                         "UnknownFlow";
                             var remainingFlags = this.flags & ~(2048 /* Referenced */ - 1);
-                            return "" + flowHeader + (remainingFlags ? " (" + formatFlowFlags(remainingFlags) + ")" : "");
+                            return "".concat(flowHeader).concat(remainingFlags ? " (".concat(formatFlowFlags(remainingFlags), ")") : "");
                         }
                     },
                     __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts.FlowFlags, /*isFlags*/ true); } },
@@ -2639,7 +2639,7 @@ var ts;
                             // We don't care, this is debug code that's only enabled with a debugger attached -
                             // we're just taking note of it for anyone checking regex performance in the future.
                             defaultValue = String(defaultValue).replace(/(?:,[\s\w\d_]+:[^,]+)+\]$/, "]");
-                            return "NodeArray " + defaultValue;
+                            return "NodeArray ".concat(defaultValue);
                         }
                     }
                 });
@@ -2694,7 +2694,7 @@ var ts;
                         var symbolHeader = this.flags & 33554432 /* Transient */ ? "TransientSymbol" :
                             "Symbol";
                         var remainingSymbolFlags = this.flags & ~33554432 /* Transient */;
-                        return symbolHeader + " '" + ts.symbolName(this) + "'" + (remainingSymbolFlags ? " (" + formatSymbolFlags(remainingSymbolFlags) + ")" : "");
+                        return "".concat(symbolHeader, " '").concat(ts.symbolName(this), "'").concat(remainingSymbolFlags ? " (".concat(formatSymbolFlags(remainingSymbolFlags), ")") : "");
                     }
                 },
                 __debugFlags: { get: function () { return formatSymbolFlags(this.flags); } }
@@ -2704,11 +2704,11 @@ var ts;
                 __tsDebuggerDisplay: {
                     value: function () {
                         var typeHeader = this.flags & 98304 /* Nullable */ ? "NullableType" :
-                            this.flags & 384 /* StringOrNumberLiteral */ ? "LiteralType " + JSON.stringify(this.value) :
-                                this.flags & 2048 /* BigIntLiteral */ ? "LiteralType " + (this.value.negative ? "-" : "") + this.value.base10Value + "n" :
+                            this.flags & 384 /* StringOrNumberLiteral */ ? "LiteralType ".concat(JSON.stringify(this.value)) :
+                                this.flags & 2048 /* BigIntLiteral */ ? "LiteralType ".concat(this.value.negative ? "-" : "").concat(this.value.base10Value, "n") :
                                     this.flags & 8192 /* UniqueESSymbol */ ? "UniqueESSymbolType" :
                                         this.flags & 32 /* Enum */ ? "EnumType" :
-                                            this.flags & 67359327 /* Intrinsic */ ? "IntrinsicType " + this.intrinsicName :
+                                            this.flags & 67359327 /* Intrinsic */ ? "IntrinsicType ".concat(this.intrinsicName) :
                                                 this.flags & 1048576 /* Union */ ? "UnionType" :
                                                     this.flags & 2097152 /* Intersection */ ? "IntersectionType" :
                                                         this.flags & 4194304 /* Index */ ? "IndexType" :
@@ -2727,7 +2727,7 @@ var ts;
                                                                                                             "ObjectType" :
                                                                                 "Type";
                         var remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~1343 /* ObjectTypeKindMask */ : 0;
-                        return "" + typeHeader + (this.symbol ? " '" + ts.symbolName(this.symbol) + "'" : "") + (remainingObjectFlags ? " (" + formatObjectFlags(remainingObjectFlags) + ")" : "");
+                        return "".concat(typeHeader).concat(this.symbol ? " '".concat(ts.symbolName(this.symbol), "'") : "").concat(remainingObjectFlags ? " (".concat(formatObjectFlags(remainingObjectFlags), ")") : "");
                     }
                 },
                 __debugFlags: { get: function () { return formatTypeFlags(this.flags); } },
@@ -2763,11 +2763,11 @@ var ts;
                         __tsDebuggerDisplay: {
                             value: function () {
                                 var nodeHeader = ts.isGeneratedIdentifier(this) ? "GeneratedIdentifier" :
-                                    ts.isIdentifier(this) ? "Identifier '" + ts.idText(this) + "'" :
-                                        ts.isPrivateIdentifier(this) ? "PrivateIdentifier '" + ts.idText(this) + "'" :
-                                            ts.isStringLiteral(this) ? "StringLiteral " + JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...") :
-                                                ts.isNumericLiteral(this) ? "NumericLiteral " + this.text :
-                                                    ts.isBigIntLiteral(this) ? "BigIntLiteral " + this.text + "n" :
+                                    ts.isIdentifier(this) ? "Identifier '".concat(ts.idText(this), "'") :
+                                        ts.isPrivateIdentifier(this) ? "PrivateIdentifier '".concat(ts.idText(this), "'") :
+                                            ts.isStringLiteral(this) ? "StringLiteral ".concat(JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...")) :
+                                                ts.isNumericLiteral(this) ? "NumericLiteral ".concat(this.text) :
+                                                    ts.isBigIntLiteral(this) ? "BigIntLiteral ".concat(this.text, "n") :
                                                         ts.isTypeParameterDeclaration(this) ? "TypeParameterDeclaration" :
                                                             ts.isParameter(this) ? "ParameterDeclaration" :
                                                                 ts.isConstructorDeclaration(this) ? "ConstructorDeclaration" :
@@ -2799,7 +2799,7 @@ var ts;
                                                                                                                                                                         ts.isNamedTupleMember(this) ? "NamedTupleMember" :
                                                                                                                                                                             ts.isImportTypeNode(this) ? "ImportTypeNode" :
                                                                                                                                                                                 formatSyntaxKind(this.kind);
-                                return "" + nodeHeader + (this.flags ? " (" + formatNodeFlags(this.flags) + ")" : "");
+                                return "".concat(nodeHeader).concat(this.flags ? " (".concat(formatNodeFlags(this.flags), ")") : "");
                             }
                         },
                         __debugKind: { get: function () { return formatSyntaxKind(this.kind); } },
@@ -2846,10 +2846,10 @@ var ts;
         Debug.enableDebugInfo = enableDebugInfo;
         function formatDeprecationMessage(name, error, errorAfter, since, message) {
             var deprecationMessage = error ? "DeprecationError: " : "DeprecationWarning: ";
-            deprecationMessage += "'" + name + "' ";
-            deprecationMessage += since ? "has been deprecated since v" + since : "is deprecated";
-            deprecationMessage += error ? " and can no longer be used." : errorAfter ? " and will no longer be usable after v" + errorAfter + "." : ".";
-            deprecationMessage += message ? " " + ts.formatStringFromArgs(message, [name], 0) : "";
+            deprecationMessage += "'".concat(name, "' ");
+            deprecationMessage += since ? "has been deprecated since v".concat(since) : "is deprecated";
+            deprecationMessage += error ? " and can no longer be used." : errorAfter ? " and will no longer be usable after v".concat(errorAfter, ".") : ".";
+            deprecationMessage += message ? " ".concat(ts.formatStringFromArgs(message, [name], 0)) : "";
             return deprecationMessage;
         }
         function createErrorDeprecation(name, errorAfter, since, message) {
@@ -2980,11 +2980,11 @@ var ts;
             }
         };
         Version.prototype.toString = function () {
-            var result = this.major + "." + this.minor + "." + this.patch;
+            var result = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
             if (ts.some(this.prerelease))
-                result += "-" + this.prerelease.join(".");
+                result += "-".concat(this.prerelease.join("."));
             if (ts.some(this.build))
-                result += "+" + this.build.join(".");
+                result += "+".concat(this.build.join("."));
             return result;
         };
         Version.zero = new Version(0, 0, 0);
@@ -3251,7 +3251,7 @@ var ts;
         return ts.map(comparators, formatComparator).join(" ");
     }
     function formatComparator(comparator) {
-        return "" + comparator.operator + comparator.operand;
+        return "".concat(comparator.operator).concat(comparator.operand);
     }
 })(ts || (ts = {}));
 /*@internal*/
@@ -3549,7 +3549,7 @@ var ts;
                     fs = require("fs");
                 }
                 catch (e) {
-                    throw new Error("tracing requires having fs\n(original error: " + (e.message || e) + ")");
+                    throw new Error("tracing requires having fs\n(original error: ".concat(e.message || e, ")"));
                 }
             }
             mode = tracingMode;
@@ -3561,11 +3561,11 @@ var ts;
             if (!fs.existsSync(traceDir)) {
                 fs.mkdirSync(traceDir, { recursive: true });
             }
-            var countPart = mode === "build" ? "." + process.pid + "-" + ++traceCount
-                : mode === "server" ? "." + process.pid
+            var countPart = mode === "build" ? ".".concat(process.pid, "-").concat(++traceCount)
+                : mode === "server" ? ".".concat(process.pid)
                     : "";
-            var tracePath = ts.combinePaths(traceDir, "trace" + countPart + ".json");
-            var typesPath = ts.combinePaths(traceDir, "types" + countPart + ".json");
+            var tracePath = ts.combinePaths(traceDir, "trace".concat(countPart, ".json"));
+            var typesPath = ts.combinePaths(traceDir, "types".concat(countPart, ".json"));
             legend.push({
                 configFilePath: configFilePath,
                 tracePath: tracePath,
@@ -3655,7 +3655,7 @@ var ts;
             }
             // test if [time,endTime) straddles a sampling point
             else if (sampleInterval - (time % sampleInterval) <= endTime - time) {
-                writeEvent("X", phase, name, args, "\"dur\":" + (endTime - time), time);
+                writeEvent("X", phase, name, args, "\"dur\":".concat(endTime - time), time);
             }
         }
         function writeEvent(eventType, phase, name, args, extras, time) {
@@ -3664,11 +3664,11 @@ var ts;
             if (mode === "server" && phase === "checkTypes" /* CheckTypes */)
                 return;
             ts.performance.mark("beginTracing");
-            fs.writeSync(traceFd, ",\n{\"pid\":1,\"tid\":1,\"ph\":\"" + eventType + "\",\"cat\":\"" + phase + "\",\"ts\":" + time + ",\"name\":\"" + name + "\"");
+            fs.writeSync(traceFd, ",\n{\"pid\":1,\"tid\":1,\"ph\":\"".concat(eventType, "\",\"cat\":\"").concat(phase, "\",\"ts\":").concat(time, ",\"name\":\"").concat(name, "\""));
             if (extras)
-                fs.writeSync(traceFd, "," + extras);
+                fs.writeSync(traceFd, ",".concat(extras));
             if (args)
-                fs.writeSync(traceFd, ",\"args\":" + JSON.stringify(args));
+                fs.writeSync(traceFd, ",\"args\":".concat(JSON.stringify(args)));
             fs.writeSync(traceFd, "}");
             ts.performance.mark("endTracing");
             ts.performance.measure("Tracing", "beginTracing", "endTracing");
@@ -5781,7 +5781,7 @@ var ts;
         pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;
         ts.unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || ts.unchangedPollThresholds;
         function getLevel(envVar, level) {
-            return system.getEnvironmentVariable(envVar + "_" + level.toUpperCase());
+            return system.getEnvironmentVariable("".concat(envVar, "_").concat(level.toUpperCase()));
         }
         function getCustomLevels(baseVariable) {
             var customLevels;
@@ -6250,7 +6250,7 @@ var ts;
         }
         function onTimerToUpdateChildWatches() {
             timerToUpdateChildWatches = undefined;
-            sysLog("sysLog:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size);
+            sysLog("sysLog:: onTimerToUpdateChildWatches:: ".concat(cacheToUpdateChildWatches.size));
             var start = ts.timestamp();
             var invokeMap = new ts.Map();
             while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
@@ -6263,7 +6263,7 @@ var ts;
                 var hasChanges = updateChildWatches(dirName, dirPath, options);
                 invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames);
             }
-            sysLog("sysLog:: invokingWatchers:: Elapsed:: " + (ts.timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size);
+            sysLog("sysLog:: invokingWatchers:: Elapsed:: ".concat(ts.timestamp() - start, "ms:: ").concat(cacheToUpdateChildWatches.size));
             callbackCache.forEach(function (callbacks, rootDirName) {
                 var existing = invokeMap.get(rootDirName);
                 if (existing) {
@@ -6279,7 +6279,7 @@ var ts;
                 }
             });
             var elapsed = ts.timestamp() - start;
-            sysLog("sysLog:: Elapsed:: " + elapsed + "ms:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size + " " + timerToUpdateChildWatches);
+            sysLog("sysLog:: Elapsed:: ".concat(elapsed, "ms:: onTimerToUpdateChildWatches:: ").concat(cacheToUpdateChildWatches.size, " ").concat(timerToUpdateChildWatches));
         }
         function removeChildWatches(parentWatcher) {
             if (!parentWatcher)
@@ -6739,7 +6739,7 @@ var ts;
                 var remappedPaths = new ts.Map();
                 var normalizedDir = ts.normalizeSlashes(__dirname);
                 // Windows rooted dir names need an extra `/` prepended to be valid file:/// urls
-                var fileUrlRoot = "file://" + (ts.getRootLength(normalizedDir) === 1 ? "" : "/") + normalizedDir;
+                var fileUrlRoot = "file://".concat(ts.getRootLength(normalizedDir) === 1 ? "" : "/").concat(normalizedDir);
                 for (var _i = 0, _a = profile.nodes; _i < _a.length; _i++) {
                     var node = _a[_i];
                     if (node.callFrame.url) {
@@ -6748,7 +6748,7 @@ var ts;
                             node.callFrame.url = ts.getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, ts.createGetCanonicalFileName(useCaseSensitiveFileNames), /*isAbsolutePathAnUrl*/ true);
                         }
                         else if (!nativePattern.test(url)) {
-                            node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, "external" + externalFileCounter + ".js")).get(url);
+                            node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, "external".concat(externalFileCounter, ".js"))).get(url);
                             externalFileCounter++;
                         }
                     }
@@ -6764,7 +6764,7 @@ var ts;
                         if (!err) {
                             try {
                                 if ((_b = statSync(profilePath)) === null || _b === void 0 ? void 0 : _b.isDirectory()) {
-                                    profilePath = _path.join(profilePath, (new Date()).toISOString().replace(/:/g, "-") + "+P" + process.pid + ".cpuprofile");
+                                    profilePath = _path.join(profilePath, "".concat((new Date()).toISOString().replace(/:/g, "-"), "+P").concat(process.pid, ".cpuprofile"));
                                 }
                             }
                             catch (_c) {
@@ -6866,7 +6866,7 @@ var ts;
                  * @param createWatcher
                  */
                 function invokeCallbackAndUpdateWatcher(createWatcher) {
-                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
+                    sysLog("sysLog:: ".concat(fileOrDirectory, ":: Changing watcher to ").concat(createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing", "FileSystemEntryWatcher"));
                     // Call the callback for current directory
                     callback("rename", "");
                     // If watcher is not closed, update it
@@ -6891,7 +6891,7 @@ var ts;
                         }
                     }
                     if (hitSystemWatcherLimit) {
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to fsWatchFile");
+                        sysLog("sysLog:: ".concat(fileOrDirectory, ":: Defaulting to fsWatchFile"));
                         return watchPresentFileSystemEntryWithFsWatchFile();
                     }
                     try {
@@ -6907,7 +6907,7 @@ var ts;
                         // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
                         // so instead of throwing error, use fs.watchFile
                         hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile");
+                        sysLog("sysLog:: ".concat(fileOrDirectory, ":: Changing to fsWatchFile"));
                         return watchPresentFileSystemEntryWithFsWatchFile();
                     }
                 }
@@ -8034,10 +8034,10 @@ var ts;
         A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."),
         A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."),
         An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1231, ts.DiagnosticCategory.Error, "An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration_1231", "An export assignment must be at the top level of a file or module declaration."),
-        An_import_declaration_can_only_be_used_in_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", "An import declaration can only be used in a namespace or module."),
-        An_export_declaration_can_only_be_used_in_a_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_in_a_module_1233", "An export declaration can only be used in a module."),
+        An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1232", "An import declaration can only be used at the top level of a namespace or module."),
+        An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1233", "An export declaration can only be used at the top level of a namespace or module."),
         An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts.DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."),
-        A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", "A namespace declaration is only allowed in a namespace or module."),
+        A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module_1235", "A namespace declaration is only allowed at the top level of a namespace or module."),
         The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts.DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."),
         The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts.DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."),
         Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."),
@@ -8069,6 +8069,7 @@ var ts;
         An_optional_element_cannot_follow_a_rest_element: diag(1266, ts.DiagnosticCategory.Error, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."),
         Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, ts.DiagnosticCategory.Error, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."),
         An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."),
+        Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, ts.DiagnosticCategory.Error, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
@@ -8205,6 +8206,8 @@ var ts;
         The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
         Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
         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."),
         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),
@@ -9625,6 +9628,9 @@ var ts;
         Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"),
         Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
         Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
+        Delete_unused_param_tag_0: diag(95171, ts.DiagnosticCategory.Message, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"),
+        Delete_all_unused_param_tags: diag(95172, ts.DiagnosticCategory.Message, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"),
+        Rename_param_tag_name_0_to_1: diag(95173, ts.DiagnosticCategory.Message, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -9916,7 +9922,7 @@ var ts;
                 line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line;
             }
             else {
-                ts.Debug.fail("Bad line number. Line: " + line + ", lineStarts.length: " + lineStarts.length + " , line map is correct? " + (debugText !== undefined ? ts.arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown"));
+                ts.Debug.fail("Bad line number. Line: ".concat(line, ", lineStarts.length: ").concat(lineStarts.length, " , line map is correct? ").concat(debugText !== undefined ? ts.arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown"));
             }
         }
         var res = lineStarts[line] + character;
@@ -12806,7 +12812,7 @@ var ts;
                 : "linkplain";
         var name = link.name ? ts.entityNameToString(link.name) : "";
         var space = link.name && link.text.startsWith("://") ? "" : " ";
-        return "{@" + kind + " " + name + space + link.text + "}";
+        return "{@".concat(kind, " ").concat(name).concat(space).concat(link.text, "}");
     }
     /**
      * Gets the effective type parameters. If the node was parsed in a
@@ -13886,6 +13892,10 @@ var ts;
         return undefined;
     }
     ts.getDeclarationOfKind = getDeclarationOfKind;
+    function getDeclarationsOfKind(symbol, kind) {
+        return ts.filter(symbol.declarations || ts.emptyArray, function (d) { return d.kind === kind; });
+    }
+    ts.getDeclarationsOfKind = getDeclarationsOfKind;
     function createSymbolTable(symbols) {
         var result = new ts.Map();
         if (symbols) {
@@ -14059,11 +14069,11 @@ var ts;
     }
     function packageIdToPackageName(_a) {
         var name = _a.name, subModuleName = _a.subModuleName;
-        return subModuleName ? name + "/" + subModuleName : name;
+        return subModuleName ? "".concat(name, "/").concat(subModuleName) : name;
     }
     ts.packageIdToPackageName = packageIdToPackageName;
     function packageIdToString(packageId) {
-        return packageIdToPackageName(packageId) + "@" + packageId.version;
+        return "".concat(packageIdToPackageName(packageId), "@").concat(packageId.version);
     }
     ts.packageIdToString = packageIdToString;
     function typeDirectiveIsEqualTo(oldResolution, newResolution) {
@@ -14121,6 +14131,10 @@ var ts;
         return getSourceFileOfNode(module.valueDeclaration || getNonAugmentationDeclaration(module));
     }
     ts.getSourceFileOfModule = getSourceFileOfModule;
+    function isPlainJsFile(file, checkJs) {
+        return !!file && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */) && !file.checkJsDirective && checkJs === undefined;
+    }
+    ts.isPlainJsFile = isPlainJsFile;
     function isStatementWithLocals(node) {
         switch (node.kind) {
             case 234 /* Block */:
@@ -14142,7 +14156,7 @@ var ts;
     function nodePosToString(node) {
         var file = getSourceFileOfNode(node);
         var loc = ts.getLineAndCharacterOfPosition(file, node.pos);
-        return file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + ")";
+        return "".concat(file.fileName, "(").concat(loc.line + 1, ",").concat(loc.character + 1, ")");
     }
     ts.nodePosToString = nodePosToString;
     function getEndLinePosition(line, sourceFile) {
@@ -14281,7 +14295,7 @@ var ts;
     ts.isPinnedComment = isPinnedComment;
     function createCommentDirectivesMap(sourceFile, commentDirectives) {
         var directivesByLine = new ts.Map(commentDirectives.map(function (commentDirective) { return ([
-            "" + ts.getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line,
+            "".concat(ts.getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line),
             commentDirective,
         ]); }));
         var usedLines = new ts.Map();
@@ -14298,10 +14312,10 @@ var ts;
             });
         }
         function markUsed(line) {
-            if (!directivesByLine.has("" + line)) {
+            if (!directivesByLine.has("".concat(line))) {
                 return false;
             }
-            usedLines.set("" + line, true);
+            usedLines.set("".concat(line), true);
             return true;
         }
     }
@@ -14531,7 +14545,7 @@ var ts;
                 }
                 return node.text;
         }
-        return ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for.");
+        return ts.Debug.fail("Literal kind '".concat(node.kind, "' not accounted for."));
     }
     ts.getLiteralText = getLiteralText;
     function canUseOriginalText(node, flags) {
@@ -17112,11 +17126,11 @@ var ts;
     }
     ts.getEscapedTextOfIdentifierOrLiteral = getEscapedTextOfIdentifierOrLiteral;
     function getPropertyNameForUniqueESSymbol(symbol) {
-        return "__@" + ts.getSymbolId(symbol) + "@" + symbol.escapedName;
+        return "__@".concat(ts.getSymbolId(symbol), "@").concat(symbol.escapedName);
     }
     ts.getPropertyNameForUniqueESSymbol = getPropertyNameForUniqueESSymbol;
     function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) {
-        return "__#" + ts.getSymbolId(containingClassSymbol) + "@" + description;
+        return "__#".concat(ts.getSymbolId(containingClassSymbol), "@").concat(description);
     }
     ts.getSymbolNameForPrivateIdentifier = getSymbolNameForPrivateIdentifier;
     function isKnownSymbol(symbol) {
@@ -19818,7 +19832,7 @@ var ts;
     }
     ts.getJSXImplicitImportBase = getJSXImplicitImportBase;
     function getJSXRuntimeImport(base, options) {
-        return base ? base + "/" + (options.jsx === 5 /* ReactJSXDev */ ? "jsx-dev-runtime" : "jsx-runtime") : undefined;
+        return base ? "".concat(base, "/").concat(options.jsx === 5 /* ReactJSXDev */ ? "jsx-dev-runtime" : "jsx-runtime") : undefined;
     }
     ts.getJSXRuntimeImport = getJSXRuntimeImport;
     function hasZeroOrOneAsteriskCharacter(str) {
@@ -19925,7 +19939,7 @@ var ts;
     }
     var wildcardCharCodes = [42 /* asterisk */, 63 /* question */];
     ts.commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"];
-    var implicitExcludePathRegexPattern = "(?!(" + ts.commonPackageFolders.join("|") + ")(/|$))";
+    var implicitExcludePathRegexPattern = "(?!(".concat(ts.commonPackageFolders.join("|"), ")(/|$))");
     var filesMatcher = {
         /**
          * Matches any single directory segment unless it is the last segment and a .min.js file
@@ -19938,7 +19952,7 @@ var ts;
          * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
          * files or directories, does not match subdirectories that start with a . character
          */
-        doubleAsteriskRegexFragment: "(/" + implicitExcludePathRegexPattern + "[^/.][^/]*)*?",
+        doubleAsteriskRegexFragment: "(/".concat(implicitExcludePathRegexPattern, "[^/.][^/]*)*?"),
         replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment); }
     };
     var directoriesMatcher = {
@@ -19947,7 +19961,7 @@ var ts;
          * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
          * files or directories, does not match subdirectories that start with a . character
          */
-        doubleAsteriskRegexFragment: "(/" + implicitExcludePathRegexPattern + "[^/.][^/]*)*?",
+        doubleAsteriskRegexFragment: "(/".concat(implicitExcludePathRegexPattern, "[^/.][^/]*)*?"),
         replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment); }
     };
     var excludeMatcher = {
@@ -19965,10 +19979,10 @@ var ts;
         if (!patterns || !patterns.length) {
             return undefined;
         }
-        var pattern = patterns.map(function (pattern) { return "(" + pattern + ")"; }).join("|");
+        var pattern = patterns.map(function (pattern) { return "(".concat(pattern, ")"); }).join("|");
         // If excluding, match "foo/bar/baz...", but if including, only allow "foo".
         var terminator = usage === "exclude" ? "($|/)" : "$";
-        return "^(" + pattern + ")" + terminator;
+        return "^(".concat(pattern, ")").concat(terminator);
     }
     ts.getRegularExpressionForWildcard = getRegularExpressionForWildcard;
     function getRegularExpressionsForWildcards(specs, basePath, usage) {
@@ -19990,7 +20004,7 @@ var ts;
     ts.isImplicitGlob = isImplicitGlob;
     function getPatternFromSpec(spec, basePath, usage) {
         var pattern = spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]);
-        return pattern && "^(" + pattern + ")" + (usage === "exclude" ? "($|/)" : "$");
+        return pattern && "^(".concat(pattern, ")").concat(usage === "exclude" ? "($|/)" : "$");
     }
     ts.getPatternFromSpec = getPatternFromSpec;
     function getSubPatternFromSpec(spec, basePath, usage, _a) {
@@ -20068,7 +20082,7 @@ var ts;
         currentDirectory = ts.normalizePath(currentDirectory);
         var absolutePath = ts.combinePaths(currentDirectory, path);
         return {
-            includeFilePatterns: ts.map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), function (pattern) { return "^" + pattern + "$"; }),
+            includeFilePatterns: ts.map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), function (pattern) { return "^".concat(pattern, "$"); }),
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
@@ -20349,7 +20363,7 @@ var ts;
      */
     function extensionFromPath(path) {
         var ext = tryGetExtensionFromPath(path);
-        return ext !== undefined ? ext : ts.Debug.fail("File " + path + " has unknown extension.");
+        return ext !== undefined ? ext : ts.Debug.fail("File ".concat(path, " has unknown extension."));
     }
     ts.extensionFromPath = extensionFromPath;
     function isAnySupportedFileExtension(path) {
@@ -26432,7 +26446,7 @@ var ts;
             case 326 /* JSDocAugmentsTag */: return "augments";
             case 327 /* JSDocImplementsTag */: return "implements";
             default:
-                return ts.Debug.fail("Unsupported kind: " + ts.Debug.formatSyntaxKind(kind));
+                return ts.Debug.fail("Unsupported kind: ".concat(ts.Debug.formatSyntaxKind(kind)));
         }
     }
     var rawTextScanner;
@@ -26760,7 +26774,7 @@ var ts;
             };
             var definedTextGetter_1 = function (path) {
                 var result = textGetter_1(path);
-                return result !== undefined ? result : "/* Input file " + path + " was missing */\r\n";
+                return result !== undefined ? result : "/* Input file ".concat(path, " was missing */\r\n");
             };
             var buildInfo_1;
             var getAndCacheBuildInfo_1 = function (getText) {
@@ -31298,7 +31312,7 @@ var ts;
             for (var _i = 0, viableKeywordSuggestions_1 = viableKeywordSuggestions; _i < viableKeywordSuggestions_1.length; _i++) {
                 var keyword = viableKeywordSuggestions_1[_i];
                 if (expressionText.length > keyword.length + 2 && ts.startsWith(expressionText, keyword)) {
-                    return keyword + " " + expressionText.slice(keyword.length);
+                    return "".concat(keyword, " ").concat(expressionText.slice(keyword.length));
                 }
             }
             return undefined;
@@ -38068,7 +38082,7 @@ var ts;
         if (namedArgRegExCache.has(name)) {
             return namedArgRegExCache.get(name);
         }
-        var result = new RegExp("(\\s" + name + "\\s*=\\s*)(?:(?:'([^']*)')|(?:\"([^\"]*)\"))", "im");
+        var result = new RegExp("(\\s".concat(name, "\\s*=\\s*)(?:(?:'([^']*)')|(?:\"([^\"]*)\"))"), "im");
         namedArgRegExCache.set(name, result);
         return result;
     }
@@ -39546,8 +39560,8 @@ var ts;
     }
     ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType;
     function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
-        var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'" + key + "'"; }).join(", ");
-        return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--" + opt.name, namesOfType);
+        var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'".concat(key, "'"); }).join(", ");
+        return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--".concat(opt.name), namesOfType);
     }
     /* @internal */
     function parseCustomTypeOption(opt, value, errors) {
@@ -40341,10 +40355,10 @@ var ts;
                 var newValue = compilerOptionsMap.get(cmd.name);
                 var defaultValue = getDefaultValueForOption(cmd);
                 if (newValue !== defaultValue) {
-                    result.push("" + tab + cmd.name + ": " + newValue);
+                    result.push("".concat(tab).concat(cmd.name, ": ").concat(newValue));
                 }
                 else if (ts.hasProperty(ts.defaultInitCompilerOptions, cmd.name)) {
-                    result.push("" + tab + cmd.name + ": " + defaultValue);
+                    result.push("".concat(tab).concat(cmd.name, ": ").concat(defaultValue));
                 }
             });
             return result.join(newLine) + newLine;
@@ -40395,19 +40409,19 @@ var ts;
                 if (entries.length !== 0) {
                     entries.push({ value: "" });
                 }
-                entries.push({ value: "/* " + category + " */" });
+                entries.push({ value: "/* ".concat(category, " */") });
                 for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
                     var option = options_1[_i];
                     var optionName = void 0;
                     if (compilerOptionsMap.has(option.name)) {
-                        optionName = "\"" + option.name + "\": " + JSON.stringify(compilerOptionsMap.get(option.name)) + ((seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ",");
+                        optionName = "\"".concat(option.name, "\": ").concat(JSON.stringify(compilerOptionsMap.get(option.name))).concat((seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ",");
                     }
                     else {
-                        optionName = "// \"" + option.name + "\": " + JSON.stringify(getDefaultValueForOption(option)) + ",";
+                        optionName = "// \"".concat(option.name, "\": ").concat(JSON.stringify(getDefaultValueForOption(option)), ",");
                     }
                     entries.push({
                         value: optionName,
-                        description: "/* " + (option.description && ts.getLocaleSpecificMessage(option.description) || option.name) + " */"
+                        description: "/* ".concat(option.description && ts.getLocaleSpecificMessage(option.description) || option.name, " */")
                     });
                     marginLength = Math.max(optionName.length, marginLength);
                 }
@@ -40416,25 +40430,25 @@ var ts;
             var tab = makePadding(2);
             var result = [];
             result.push("{");
-            result.push(tab + "\"compilerOptions\": {");
-            result.push("" + tab + tab + "/* " + ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file) + " */");
+            result.push("".concat(tab, "\"compilerOptions\": {"));
+            result.push("".concat(tab).concat(tab, "/* ").concat(ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file), " */"));
             result.push("");
             // Print out each row, aligning all the descriptions on the same column.
             for (var _a = 0, entries_2 = entries; _a < entries_2.length; _a++) {
                 var entry = entries_2[_a];
                 var value = entry.value, _b = entry.description, description = _b === void 0 ? "" : _b;
-                result.push(value && "" + tab + tab + value + (description && (makePadding(marginLength - value.length + 2) + description)));
+                result.push(value && "".concat(tab).concat(tab).concat(value).concat(description && (makePadding(marginLength - value.length + 2) + description)));
             }
             if (fileNames.length) {
-                result.push(tab + "},");
-                result.push(tab + "\"files\": [");
+                result.push("".concat(tab, "},"));
+                result.push("".concat(tab, "\"files\": ["));
                 for (var i = 0; i < fileNames.length; i++) {
-                    result.push("" + tab + tab + JSON.stringify(fileNames[i]) + (i === fileNames.length - 1 ? "" : ","));
+                    result.push("".concat(tab).concat(tab).concat(JSON.stringify(fileNames[i])).concat(i === fileNames.length - 1 ? "" : ","));
                 }
-                result.push(tab + "]");
+                result.push("".concat(tab, "]"));
             }
             else {
-                result.push(tab + "}");
+                result.push("".concat(tab, "}"));
             }
             result.push("}");
             return result.join(newLine) + newLine;
@@ -40832,7 +40846,7 @@ var ts;
         if (ts.isRootedDiskPath(extendedConfig) || ts.startsWith(extendedConfig, "./") || ts.startsWith(extendedConfig, "../")) {
             var extendedConfigPath = ts.getNormalizedAbsolutePath(extendedConfig, basePath);
             if (!host.fileExists(extendedConfigPath) && !ts.endsWith(extendedConfigPath, ".json" /* Json */)) {
-                extendedConfigPath = extendedConfigPath + ".json";
+                extendedConfigPath = "".concat(extendedConfigPath, ".json");
                 if (!host.fileExists(extendedConfigPath)) {
                     errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig));
                     return undefined;
@@ -41077,7 +41091,7 @@ var ts;
                     // Valid only if *.json specified
                     if (!jsonOnlyIncludeRegexes) {
                         var includes = validatedIncludeSpecs.filter(function (s) { return ts.endsWith(s, ".json" /* Json */); });
-                        var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^" + pattern + "$"; });
+                        var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^".concat(pattern, "$"); });
                         jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(function (pattern) { return ts.getRegexFromPattern(pattern, host.useCaseSensitiveFileNames); }) : ts.emptyArray;
                     }
                     var includeIndex = ts.findIndex(jsonOnlyIncludeRegexes, function (re) { return re.test(file); });
@@ -41513,7 +41527,7 @@ var ts;
         var bestVersionKey = result.version, bestVersionPaths = result.paths;
         if (typeof bestVersionPaths !== "object") {
             if (state.traceEnabled) {
-                trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['" + bestVersionKey + "']", "object", typeof bestVersionPaths);
+                trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['".concat(bestVersionKey, "']"), "object", typeof bestVersionPaths);
             }
             return;
         }
@@ -41920,7 +41934,7 @@ var ts;
         };
         return cache;
         function getUnderlyingCacheKey(specifier, mode) {
-            var result = mode === undefined ? specifier : mode + "|" + specifier;
+            var result = mode === undefined ? specifier : "".concat(mode, "|").concat(specifier);
             memoizedReverseKeys.set(result, [specifier, mode]);
             return result;
         }
@@ -41951,7 +41965,7 @@ var ts;
         }
         function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
             ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
-            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : mode + "|" + nonRelativeModuleName, createPerModuleNameCache);
+            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : "".concat(mode, "|").concat(nonRelativeModuleName), createPerModuleNameCache);
         }
         function createPerModuleNameCache() {
             var directoryPathMap = new ts.Map();
@@ -42098,10 +42112,10 @@ var ts;
                     result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
                     break;
                 default:
-                    return ts.Debug.fail("Unexpected moduleResolution: " + moduleResolution);
+                    return ts.Debug.fail("Unexpected moduleResolution: ".concat(moduleResolution));
             }
             if (result && result.resolvedModule)
-                ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\"");
+                ts.perfLogger.logInfoEvent("Module \"".concat(moduleName, "\" resolved to \"").concat(result.resolvedModule.resolvedFileName, "\""));
             ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");
             if (perFolderCache) {
                 perFolderCache.set(moduleName, resolutionMode, result);
@@ -42304,7 +42318,7 @@ var ts;
     function resolveJSModule(moduleName, initialDir, host) {
         var _a = tryResolveJSModuleWorker(moduleName, initialDir, host), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations;
         if (!resolvedModule) {
-            throw new Error("Could not resolve JS module '" + moduleName + "' starting at '" + initialDir + "'. Looked in: " + failedLookupLocations.join(", "));
+            throw new Error("Could not resolve JS module '".concat(moduleName, "' starting at '").concat(initialDir, "'. Looked in: ").concat(failedLookupLocations.join(", ")));
         }
         return resolvedModule.resolvedFileName;
     }
@@ -42414,7 +42428,7 @@ var ts;
         if (traceEnabled) {
             trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, path, real);
         }
-        ts.Debug.assert(host.fileExists(real), path + " linked to nonexistent file " + real);
+        ts.Debug.assert(host.fileExists(real), "".concat(path, " linked to nonexistent file ").concat(real));
         return real;
     }
     function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
@@ -42891,7 +42905,7 @@ var ts;
             return undefined;
         }
         var trailingParts = parts.slice(nameParts.length);
-        return loadModuleFromExports(scope, extensions, !ts.length(trailingParts) ? "." : "." + ts.directorySeparator + trailingParts.join(ts.directorySeparator), state, cache, redirectedReference);
+        return loadModuleFromExports(scope, extensions, !ts.length(trailingParts) ? "." : ".".concat(ts.directorySeparator).concat(trailingParts.join(ts.directorySeparator)), state, cache, redirectedReference);
     }
     function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
         if (!scope.packageJsonContent.exports) {
@@ -43219,7 +43233,7 @@ var ts;
     }
     /* @internal */
     function getTypesPackageName(packageName) {
-        return "@types/" + mangleScopedPackageName(packageName);
+        return "@types/".concat(mangleScopedPackageName(packageName));
     }
     ts.getTypesPackageName = getTypesPackageName;
     /* @internal */
@@ -43620,7 +43634,7 @@ var ts;
             if (name) {
                 if (ts.isAmbientModule(node)) {
                     var moduleName = ts.getTextOfIdentifierOrLiteral(name);
-                    return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + moduleName + "\"");
+                    return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"".concat(moduleName, "\""));
                 }
                 if (name.kind === 161 /* ComputedPropertyName */) {
                     var nameExpression = name.expression;
@@ -43677,7 +43691,7 @@ var ts;
                 case 163 /* Parameter */:
                     // Parameters with names are handled at the top of this function.  Parameters
                     // without names can only come from JSDocFunctionTypes.
-                    ts.Debug.assert(node.parent.kind === 315 /* JSDocFunctionType */, "Impossible parameter parent kind", function () { return "parent is: " + (ts.SyntaxKind ? ts.SyntaxKind[node.parent.kind] : node.parent.kind) + ", expected JSDocFunctionType"; });
+                    ts.Debug.assert(node.parent.kind === 315 /* JSDocFunctionType */, "Impossible parameter parent kind", function () { return "parent is: ".concat(ts.SyntaxKind ? ts.SyntaxKind[node.parent.kind] : node.parent.kind, ", expected JSDocFunctionType"); });
                     var functionType = node.parent;
                     var index = functionType.parameters.indexOf(node);
                     return "arg" + index;
@@ -43789,7 +43803,7 @@ var ts;
                         var relatedInformation_1 = [];
                         if (ts.isTypeAliasDeclaration(node) && ts.nodeIsMissing(node.type) && ts.hasSyntacticModifier(node, 1 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
                             // export type T; - may have meant export type { T }?
-                            relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { " + ts.unescapeLeadingUnderscores(node.name.escapedText) + " }"));
+                            relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { ".concat(ts.unescapeLeadingUnderscores(node.name.escapedText), " }")));
                         }
                         var declarationName_1 = ts.getNameOfDeclaration(node) || node;
                         ts.forEach(symbol.declarations, function (declaration, index) {
@@ -45865,7 +45879,7 @@ var ts;
             }
         }
         function bindSourceFileAsExternalModule() {
-            bindAnonymousDeclaration(file, 512 /* ValueModule */, "\"" + ts.removeFileExtension(file.fileName) + "\"");
+            bindAnonymousDeclaration(file, 512 /* ValueModule */, "\"".concat(ts.removeFileExtension(file.fileName), "\""));
         }
         function bindExportAssignment(node) {
             if (!container.symbol || !container.symbol.exports) {
@@ -46898,6 +46912,9 @@ var ts;
         CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
         CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
+        CheckMode[CheckMode["RestBindingElement"] = 32] = "RestBindingElement";
+        //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
+        //   we need to preserve generic types instead of substituting them for constraints
     })(CheckMode || (CheckMode = {}));
     var SignatureCheckMode;
     (function (SignatureCheckMode) {
@@ -47950,30 +47967,34 @@ var ts;
             else { // error
                 var isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
                 var isEitherBlockScoped_1 = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
-                var message = isEitherEnum
-                    ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
-                    : isEitherBlockScoped_1
-                        ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
+                var message = isEitherEnum ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations
+                    : isEitherBlockScoped_1 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                 var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]);
                 var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]);
+                var isSourcePlainJs = ts.isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
+                var isTargetPlainJs = ts.isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
                 var symbolName_1 = symbolToString(source);
                 // Collect top-level duplicate identifier errors into one mapping, so we can then merge their diagnostics if there are a bunch
                 if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
                     var firstFile_1 = ts.comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* LessThan */ ? sourceSymbolFile : targetSymbolFile;
                     var secondFile_1 = firstFile_1 === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
-                    var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, firstFile_1.path + "|" + secondFile_1.path, function () {
+                    var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, "".concat(firstFile_1.path, "|").concat(secondFile_1.path), function () {
                         return ({ firstFile: firstFile_1, secondFile: secondFile_1, conflictingSymbols: new ts.Map() });
                     });
                     var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () {
                         return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] });
                     });
-                    addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
-                    addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
+                    if (!isSourcePlainJs)
+                        addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
+                    if (!isTargetPlainJs)
+                        addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
                 }
                 else {
-                    addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
-                    addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
+                    if (!isSourcePlainJs)
+                        addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target);
+                    if (!isTargetPlainJs)
+                        addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source);
                 }
             }
             return target;
@@ -48430,6 +48451,8 @@ var ts;
                                     // type parameters are visible in parameter list, return type and type parameter list
                                     ? lastLocation === location.type ||
                                         lastLocation.kind === 163 /* Parameter */ ||
+                                        lastLocation.kind === 338 /* JSDocParameterTag */ ||
+                                        lastLocation.kind === 339 /* JSDocReturnTag */ ||
                                         lastLocation.kind === 162 /* TypeParameter */
                                     // local types not visible outside the function body
                                     : false;
@@ -48689,9 +48712,9 @@ var ts;
                     lastSelfReferenceLocation = location;
                 }
                 lastLocation = location;
-                location = ts.isJSDocTemplateTag(location) ?
-                    ts.getEffectiveContainerForJSDocTemplateTag(location) || location.parent :
-                    location.parent;
+                location = ts.isJSDocTemplateTag(location) ? ts.getEffectiveContainerForJSDocTemplateTag(location) || location.parent :
+                    ts.isJSDocParameterTag(location) || ts.isJSDocReturnTag(location) ? ts.getHostSignatureFromJSDoc(location) || location.parent :
+                        location.parent;
             }
             // We just climbed up parents looking for the name, meaning that we started in a descendant node of `lastLocation`.
             // If `result === lastSelfReferenceLocation.symbol`, that means that we are somewhere inside `lastSelfReferenceLocation` looking up a name, and resolving to `lastLocation` itself.
@@ -49825,16 +49848,20 @@ var ts;
                 return;
             }
             var host = ts.getJSDocHost(node);
-            if (host &&
-                ts.isExpressionStatement(host) &&
-                ts.isBinaryExpression(host.expression) &&
-                ts.getAssignmentDeclarationKind(host.expression) === 3 /* PrototypeProperty */) {
-                // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration
+            if (host && ts.isExpressionStatement(host) && ts.isPrototypePropertyAssignment(host.expression)) {
+                // /** @param {K} p */ X.prototype.m = function () { } <-- look for K on X's declaration
                 var symbol = getSymbolOfNode(host.expression.left);
                 if (symbol) {
                     return getDeclarationOfJSPrototypeContainer(symbol);
                 }
             }
+            if (host && ts.isFunctionExpression(host) && ts.isPrototypePropertyAssignment(host.parent) && ts.isExpressionStatement(host.parent.parent)) {
+                // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration
+                var symbol = getSymbolOfNode(host.parent.left);
+                if (symbol) {
+                    return getDeclarationOfJSPrototypeContainer(symbol);
+                }
+            }
             if (host && (ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) &&
                 ts.isBinaryExpression(host.parent.parent) &&
                 ts.getAssignmentDeclarationKind(host.parent.parent) === 6 /* Prototype */) {
@@ -50605,7 +50632,7 @@ var ts;
             var cache = (links.accessibleChainCache || (links.accessibleChainCache = new ts.Map()));
             // Go from enclosingDeclaration to the first scope we check, so the cache is keyed off the scope and thus shared more
             var firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, function (_, __, ___, node) { return node; });
-            var key = (useOnlyExternalAliasing ? 0 : 1) + "|" + (firstRelevantLocation && getNodeId(firstRelevantLocation)) + "|" + meaning;
+            var key = "".concat(useOnlyExternalAliasing ? 0 : 1, "|").concat(firstRelevantLocation && getNodeId(firstRelevantLocation), "|").concat(meaning);
             if (cache.has(key)) {
                 return cache.get(key);
             }
@@ -51454,7 +51481,7 @@ var ts;
                         context.symbolDepth = new ts.Map();
                     }
                     var links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
-                    var key = getTypeId(type) + "|" + context.flags;
+                    var key = "".concat(getTypeId(type), "|").concat(context.flags);
                     if (links) {
                         links.serializedTypes || (links.serializedTypes = new ts.Map());
                     }
@@ -51723,7 +51750,7 @@ var ts;
                             }
                         }
                         if (checkTruncationLength(context) && (i + 2 < properties.length - 1)) {
-                            typeElements.push(ts.factory.createPropertySignature(/*modifiers*/ undefined, "... " + (properties.length - i) + " more ...", /*questionToken*/ undefined, /*type*/ undefined));
+                            typeElements.push(ts.factory.createPropertySignature(/*modifiers*/ undefined, "... ".concat(properties.length - i, " more ..."), /*questionToken*/ undefined, /*type*/ undefined));
                             addPropertyToElementList(properties[properties.length - 1], context, typeElements);
                             break;
                         }
@@ -51838,7 +51865,7 @@ var ts;
                         else if (types.length > 2) {
                             return [
                                 typeToTypeNodeHelper(types[0], context),
-                                ts.factory.createTypeReferenceNode("... " + (types.length - 2) + " more ...", /*typeArguments*/ undefined),
+                                ts.factory.createTypeReferenceNode("... ".concat(types.length - 2, " more ..."), /*typeArguments*/ undefined),
                                 typeToTypeNodeHelper(types[types.length - 1], context)
                             ];
                         }
@@ -51852,7 +51879,7 @@ var ts;
                         var type = types_2[_i];
                         i++;
                         if (checkTruncationLength(context) && (i + 2 < types.length - 1)) {
-                            result_5.push(ts.factory.createTypeReferenceNode("... " + (types.length - i) + " more ...", /*typeArguments*/ undefined));
+                            result_5.push(ts.factory.createTypeReferenceNode("... ".concat(types.length - i, " more ..."), /*typeArguments*/ undefined));
                             var typeNode_1 = typeToTypeNodeHelper(types[types.length - 1], context);
                             if (typeNode_1) {
                                 result_5.push(typeNode_1);
@@ -52375,7 +52402,7 @@ var ts;
                     var text = rawtext;
                     while (((_b = context.typeParameterNamesByText) === null || _b === void 0 ? void 0 : _b.has(text)) || typeParameterShadowsNameInScope(text, context, type)) {
                         i++;
-                        text = rawtext + "_" + i;
+                        text = "".concat(rawtext, "_").concat(i);
                     }
                     if (text !== rawtext) {
                         result = ts.factory.createIdentifier(text, result.typeArguments);
@@ -52695,7 +52722,7 @@ var ts;
                     function getNameForJSDocFunctionParameter(p, index) {
                         return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "this" ? "this"
                             : getEffectiveDotDotDotForParameter(p) ? "args"
-                                : "arg" + index;
+                                : "arg".concat(index);
                     }
                     function rewriteModuleSpecifier(parent, lit) {
                         if (bundled) {
@@ -53780,7 +53807,7 @@ var ts;
                             return results_1;
                         }
                         // The `Constructor`'s symbol isn't in the class's properties lists, obviously, since it's a signature on the static
-                        return ts.Debug.fail("Unhandled class member kind! " + (p.__debugFlags || p.flags));
+                        return ts.Debug.fail("Unhandled class member kind! ".concat(p.__debugFlags || p.flags));
                     };
                 }
                 function serializePropertySymbolForInterface(p, baseType) {
@@ -53855,7 +53882,7 @@ var ts;
                     if (ref) {
                         return ref;
                     }
-                    var tempName = getUnusedName(rootName + "_base");
+                    var tempName = getUnusedName("".concat(rootName, "_base"));
                     var statement = ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([
                         ts.factory.createVariableDeclaration(tempName, /*exclamationToken*/ undefined, typeToTypeNodeHelper(staticType, context))
                     ], 2 /* Const */));
@@ -53902,7 +53929,7 @@ var ts;
                     var original = input;
                     while ((_a = context.usedSymbolNames) === null || _a === void 0 ? void 0 : _a.has(input)) {
                         i++;
-                        input = original + "_" + i;
+                        input = "".concat(original, "_").concat(i);
                     }
                     (_b = context.usedSymbolNames) === null || _b === void 0 ? void 0 : _b.add(input);
                     if (id) {
@@ -54010,15 +54037,15 @@ var ts;
                 if (nameType.flags & 384 /* StringOrNumberLiteral */) {
                     var name = "" + nameType.value;
                     if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) {
-                        return "\"" + ts.escapeString(name, 34 /* doubleQuote */) + "\"";
+                        return "\"".concat(ts.escapeString(name, 34 /* doubleQuote */), "\"");
                     }
                     if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) {
-                        return "[" + name + "]";
+                        return "[".concat(name, "]");
                     }
                     return name;
                 }
                 if (nameType.flags & 8192 /* UniqueESSymbol */) {
-                    return "[" + getNameOfSymbolAsWritten(nameType.symbol, context) + "]";
+                    return "[".concat(getNameOfSymbolAsWritten(nameType.symbol, context), "]");
                 }
             }
         }
@@ -54321,9 +54348,12 @@ var ts;
         }
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
-        function getTypeForBindingElementParent(node) {
+        function getTypeForBindingElementParent(node, checkMode) {
+            if (checkMode !== 0 /* Normal */) {
+                return getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode);
+            }
             var symbol = getSymbolOfNode(node);
-            return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false);
+            return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode);
         }
         function getRestType(source, properties, symbol) {
             source = filterType(source, function (t) { return !(t.flags & 98304 /* Nullable */); });
@@ -54441,7 +54471,8 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            var checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+            var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
             return parentType && getBindingElementTypeFromParentType(declaration, parentType);
         }
         function getBindingElementTypeFromParentType(declaration, parentType) {
@@ -54513,9 +54544,9 @@ var ts;
             if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
                 // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                 // undefined from the final type.
-                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
+                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
             }
-            return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration)], 2 /* Subtype */));
+            return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
         }
         function getTypeForDeclarationFromJSDocComment(declaration) {
             var jsdocType = ts.getJSDocType(declaration);
@@ -54538,11 +54569,11 @@ var ts;
             return strictNullChecks && isOptional ? getOptionalType(type, isProperty) : type;
         }
         // Return the inferred type for a variable, parameter, or property declaration
-        function getTypeForVariableLikeDeclaration(declaration, includeOptionality) {
+        function getTypeForVariableLikeDeclaration(declaration, includeOptionality, checkMode) {
             // A variable declared in a for..in statement is of type string, or of type keyof T when the
             // right hand expression is of a type parameter type.
             if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 242 /* ForInStatement */) {
-                var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression)));
+                var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression, /*checkMode*/ checkMode)));
                 return indexType.flags & (262144 /* TypeParameter */ | 4194304 /* Index */) ? getExtractStringType(indexType) : stringType;
             }
             if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 243 /* ForOfStatement */) {
@@ -54597,12 +54628,9 @@ var ts;
                     }
                 }
                 if (ts.isInJSFile(declaration)) {
-                    var typeTag = ts.getJSDocType(func);
-                    if (typeTag && ts.isFunctionTypeNode(typeTag)) {
-                        var signature = getSignatureFromDeclaration(typeTag);
-                        var pos = func.parameters.indexOf(declaration);
-                        return declaration.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
-                    }
+                    var type_1 = getParameterTypeOfTypeTag(func, declaration);
+                    if (type_1)
+                        return type_1;
                 }
                 // Use contextual parameter type if one is available
                 var type = declaration.symbol.escapedName === "this" /* This */ ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
@@ -54619,7 +54647,7 @@ var ts;
                         return containerObjectType;
                     }
                 }
-                var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration));
+                var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, checkMode));
                 return addOptionality(type, isProperty, isOptional);
             }
             if (ts.isPropertyDeclaration(declaration) && (noImplicitAny || ts.isInJSFile(declaration))) {
@@ -54991,7 +55019,7 @@ var ts;
                 // contextual type or, if the element itself is a binding pattern, with the type implied by that binding
                 // pattern.
                 var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, /*includePatternInType*/ true, /*reportErrors*/ false) : unknownType;
-                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, contextualType)));
+                return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
             }
             if (ts.isBindingPattern(element.name)) {
                 return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors);
@@ -55080,7 +55108,7 @@ var ts;
         // binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the
         // tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string.
         function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) {
-            return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true), declaration, reportErrors);
+            return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true, 0 /* Normal */), declaration, reportErrors);
         }
         function isGlobalSymbolConstructor(node) {
             var symbol = getSymbolOfNode(node);
@@ -55169,9 +55197,9 @@ var ts;
                 if (typeNode === undefined) {
                     return useUnknownInCatchVariables ? unknownType : anyType;
                 }
-                var type_1 = getTypeOfNode(typeNode);
+                var type_2 = getTypeOfNode(typeNode);
                 // an errorType will make `checkTryStatement` issue an error
-                return isTypeAny(type_1) || type_1 === unknownType ? type_1 : errorType;
+                return isTypeAny(type_2) || type_2 === unknownType ? type_2 : errorType;
             }
             // Handle export default expressions
             if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) {
@@ -55309,10 +55337,12 @@ var ts;
             if (writing === void 0) { writing = false; }
             var getter = ts.getDeclarationOfKind(symbol, 171 /* GetAccessor */);
             var setter = ts.getDeclarationOfKind(symbol, 172 /* SetAccessor */);
-            var setterType = getAnnotatedAccessorType(setter);
             // For write operations, prioritize type annotations on the setter
-            if (writing && setterType) {
-                return instantiateTypeIfNeeded(setterType, symbol);
+            if (writing) {
+                var setterType_1 = getAnnotatedAccessorType(setter);
+                if (setterType_1) {
+                    return instantiateTypeIfNeeded(setterType_1, symbol);
+                }
             }
             // Else defer to the getter type
             if (getter && ts.isInJSFile(getter)) {
@@ -55327,6 +55357,7 @@ var ts;
                 return instantiateTypeIfNeeded(getterType, symbol);
             }
             // If the user didn't specify a return type, try to use the set-accessor's parameter type.
+            var setterType = getAnnotatedAccessorType(setter);
             if (setterType) {
                 return setterType;
             }
@@ -55397,11 +55428,11 @@ var ts;
                         return errorType;
                     }
                     var exportEquals = getMergedSymbol(symbol.exports.get("export=" /* ExportEquals */));
-                    var type_2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
+                    var type_3 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule);
                     if (!popTypeResolution()) {
                         return reportCircularityError(symbol);
                     }
-                    return type_2;
+                    return type_3;
                 }
             }
             var type = createObjectType(16 /* Anonymous */, symbol);
@@ -55475,6 +55506,39 @@ var ts;
             }
             return links.type;
         }
+        function getWriteTypeOfSymbolWithDeferredType(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.writeType && links.deferralWriteConstituents) {
+                ts.Debug.assertIsDefined(links.deferralParent);
+                ts.Debug.assertIsDefined(links.deferralConstituents);
+                links.writeType = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents);
+            }
+            return links.writeType;
+        }
+        /**
+         * Distinct write types come only from set accessors, but union and intersection
+         * properties deriving from set accessors will either pre-compute or defer the
+         * union or intersection of the writeTypes of their constituents. To account for
+         * this, we will assume that any deferred type or transient symbol may have a
+         * `writeType` (or a deferred write type ready to be computed) that should be
+         * used before looking for set accessor declarations.
+         */
+        function getWriteTypeOfSymbol(symbol) {
+            var checkFlags = ts.getCheckFlags(symbol);
+            if (checkFlags & 65536 /* DeferredType */) {
+                var writeType = getWriteTypeOfSymbolWithDeferredType(symbol);
+                if (writeType) {
+                    return writeType;
+                }
+            }
+            if (symbol.flags & 33554432 /* Transient */) {
+                var writeType = symbol.writeType;
+                if (writeType) {
+                    return writeType;
+                }
+            }
+            return getSetAccessorTypeOfSymbol(symbol);
+        }
         function getSetAccessorTypeOfSymbol(symbol) {
             if (symbol.flags & 98304 /* Accessor */) {
                 var type = getTypeOfSetAccessor(symbol);
@@ -56812,7 +56876,7 @@ var ts;
                     !leftName ? rightName :
                         !rightName ? leftName :
                             undefined;
-                var paramSymbol = createSymbol(1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0), paramName || "arg" + i);
+                var paramSymbol = createSymbol(1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0), paramName || "arg".concat(i));
                 paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
                 params[i] = paramSymbol;
             }
@@ -57600,10 +57664,10 @@ var ts;
                     var baseTypes = [];
                     var different = false;
                     for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
-                        var type_3 = types_7[_i];
-                        var baseType = getBaseConstraint(type_3);
+                        var type_4 = types_7[_i];
+                        var baseType = getBaseConstraint(type_4);
                         if (baseType) {
-                            if (baseType !== type_3) {
+                            if (baseType !== type_4) {
                                 different = true;
                             }
                             baseTypes.push(baseType);
@@ -57845,6 +57909,7 @@ var ts;
             var firstType;
             var nameType;
             var propTypes = [];
+            var writeTypes;
             var firstValueDeclaration;
             var hasNonUniformValueDeclaration = false;
             for (var _d = 0, props_1 = props; _d < props_1.length; _d++) {
@@ -57861,6 +57926,10 @@ var ts;
                     firstType = type;
                     nameType = getSymbolLinks(prop).nameType;
                 }
+                var writeType = getWriteTypeOfSymbol(prop);
+                if (writeTypes || writeType !== type) {
+                    writeTypes = ts.append(!writeTypes ? propTypes.slice() : writeTypes, writeType);
+                }
                 else if (type !== firstType) {
                     checkFlags |= 64 /* HasNonUniformType */;
                 }
@@ -57889,9 +57958,13 @@ var ts;
                 result.checkFlags |= 65536 /* DeferredType */;
                 result.deferralParent = containingType;
                 result.deferralConstituents = propTypes;
+                result.deferralWriteConstituents = writeTypes;
             }
             else {
                 result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
+                if (writeTypes) {
+                    result.writeType = isUnion ? getUnionType(writeTypes) : getIntersectionType(writeTypes);
+                }
             }
             return result;
         }
@@ -58307,6 +58380,13 @@ var ts;
             var typeTag = ts.getJSDocTypeTag(node);
             return (typeTag === null || typeTag === void 0 ? void 0 : typeTag.typeExpression) && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
         }
+        function getParameterTypeOfTypeTag(func, parameter) {
+            var signature = getSignatureOfTypeTag(func);
+            if (!signature)
+                return undefined;
+            var pos = func.parameters.indexOf(parameter);
+            return parameter.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
+        }
         function getReturnTypeOfTypeTag(node) {
             var signature = getSignatureOfTypeTag(node);
             return signature && getReturnTypeOfSignature(signature);
@@ -58747,7 +58827,7 @@ var ts;
             return result;
         }
         function getAliasId(aliasSymbol, aliasTypeArguments) {
-            return aliasSymbol ? "@" + getSymbolId(aliasSymbol) + (aliasTypeArguments ? ":" + getTypeListId(aliasTypeArguments) : "") : "";
+            return aliasSymbol ? "@".concat(getSymbolId(aliasSymbol)) + (aliasTypeArguments ? ":".concat(getTypeListId(aliasTypeArguments)) : "") : "";
         }
         // This function is used to propagate certain flags when creating new object type references and union types.
         // It is only necessary to do so if a constituent type might be the undefined type, the null type, the type
@@ -58933,7 +59013,7 @@ var ts;
             return undefined;
         }
         function getSymbolPath(symbol) {
-            return symbol.parent ? getSymbolPath(symbol.parent) + "." + symbol.escapedName : symbol.escapedName;
+            return symbol.parent ? "".concat(getSymbolPath(symbol.parent), ".").concat(symbol.escapedName) : symbol.escapedName;
         }
         function getUnresolvedSymbolForEntityName(name) {
             var identifier = name.kind === 160 /* QualifiedName */ ? name.right :
@@ -58944,7 +59024,7 @@ var ts;
                 var parentSymbol = name.kind === 160 /* QualifiedName */ ? getUnresolvedSymbolForEntityName(name.left) :
                     name.kind === 205 /* PropertyAccessExpression */ ? getUnresolvedSymbolForEntityName(name.expression) :
                         undefined;
-                var path = parentSymbol ? getSymbolPath(parentSymbol) + "." + text : text;
+                var path = parentSymbol ? "".concat(getSymbolPath(parentSymbol), ".").concat(text) : text;
                 var result = unresolvedSymbols.get(path);
                 if (!result) {
                     unresolvedSymbols.set(path, result = createSymbol(524288 /* TypeAlias */, text, 1048576 /* Unresolved */));
@@ -59017,7 +59097,7 @@ var ts;
             if (substitute.flags & 3 /* AnyOrUnknown */ || substitute === baseType) {
                 return baseType;
             }
-            var id = getTypeId(baseType) + ">" + getTypeId(substitute);
+            var id = "".concat(getTypeId(baseType), ">").concat(getTypeId(substitute));
             var cached = substitutionTypes.get(id);
             if (cached) {
                 return cached;
@@ -59941,9 +60021,9 @@ var ts;
                 return types[0];
             }
             var typeKey = !origin ? getTypeListId(types) :
-                origin.flags & 1048576 /* Union */ ? "|" + getTypeListId(origin.types) :
-                    origin.flags & 2097152 /* Intersection */ ? "&" + getTypeListId(origin.types) :
-                        "#" + origin.type.id + "|" + getTypeListId(types); // origin type id alone is insufficient, as `keyof x` may resolve to multiple WIP values while `x` is still resolving
+                origin.flags & 1048576 /* Union */ ? "|".concat(getTypeListId(origin.types)) :
+                    origin.flags & 2097152 /* Intersection */ ? "&".concat(getTypeListId(origin.types)) :
+                        "#".concat(origin.type.id, "|").concat(getTypeListId(types)); // origin type id alone is insufficient, as `keyof x` may resolve to multiple WIP values while `x` is still resolving
             var id = typeKey + getAliasId(aliasSymbol, aliasTypeArguments);
             var type = unionTypes.get(id);
             if (!type) {
@@ -60465,7 +60545,7 @@ var ts;
             if (ts.every(newTexts, function (t) { return t === ""; }) && ts.every(newTypes, function (t) { return !!(t.flags & 4 /* String */); })) {
                 return stringType;
             }
-            var id = getTypeListId(newTypes) + "|" + ts.map(newTexts, function (t) { return t.length; }).join(",") + "|" + newTexts.join("");
+            var id = "".concat(getTypeListId(newTypes), "|").concat(ts.map(newTexts, function (t) { return t.length; }).join(","), "|").concat(newTexts.join(""));
             var type = templateLiteralTypes.get(id);
             if (!type) {
                 templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes));
@@ -60525,7 +60605,7 @@ var ts;
             return str;
         }
         function getStringMappingTypeForGenericType(symbol, type) {
-            var id = getSymbolId(symbol) + "," + getTypeId(type);
+            var id = "".concat(getSymbolId(symbol), ",").concat(getTypeId(type));
             var result = stringMappingTypes.get(id);
             if (!result) {
                 stringMappingTypes.set(id, result = createStringMappingType(symbol, type));
@@ -61542,7 +61622,7 @@ var ts;
         function createUniqueESSymbolType(symbol) {
             var type = createType(8192 /* UniqueESSymbol */);
             type.symbol = symbol;
-            type.escapedName = "__@" + type.symbol.escapedName + "@" + getSymbolId(type.symbol);
+            type.escapedName = "__@".concat(type.symbol.escapedName, "@").concat(getSymbolId(type.symbol));
             return type;
         }
         function getESSymbolLikeTypeForNode(node) {
@@ -63231,24 +63311,24 @@ var ts;
                         case ts.Diagnostics.Types_of_property_0_are_incompatible.code: {
                             // Parenthesize a `new` if there is one
                             if (path.indexOf("new ") === 0) {
-                                path = "(" + path + ")";
+                                path = "(".concat(path, ")");
                             }
                             var str = "" + args[0];
                             // If leading, just print back the arg (irrespective of if it's a valid identifier)
                             if (path.length === 0) {
-                                path = "" + str;
+                                path = "".concat(str);
                             }
                             // Otherwise write a dotted name if possible
                             else if (ts.isIdentifierText(str, ts.getEmitScriptTarget(compilerOptions))) {
-                                path = path + "." + str;
+                                path = "".concat(path, ".").concat(str);
                             }
                             // Failing that, check if the name is already a computed name
                             else if (str[0] === "[" && str[str.length - 1] === "]") {
-                                path = "" + path + str;
+                                path = "".concat(path).concat(str);
                             }
                             // And finally write out a computed name as a last resort
                             else {
-                                path = path + "[" + str + "]";
+                                path = "".concat(path, "[").concat(str, "]");
                             }
                             break;
                         }
@@ -63277,7 +63357,7 @@ var ts;
                                     msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code)
                                     ? ""
                                     : "...";
-                                path = "" + prefix + path + "(" + params + ")";
+                                path = "".concat(prefix).concat(path, "(").concat(params, ")");
                             }
                             break;
                         }
@@ -63290,7 +63370,7 @@ var ts;
                             break;
                         }
                         default:
-                            return ts.Debug.fail("Unhandled Diagnostic: " + msg.code);
+                            return ts.Debug.fail("Unhandled Diagnostic: ".concat(msg.code));
                     }
                 }
                 if (path) {
@@ -65492,7 +65572,7 @@ var ts;
             var constraintMarker = "";
             var sourceId = getTypeReferenceId(source, 0);
             var targetId = getTypeReferenceId(target, 0);
-            return "" + constraintMarker + sourceId + "," + targetId + postFix;
+            return "".concat(constraintMarker).concat(sourceId, ",").concat(targetId).concat(postFix);
             // getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
             // where A.id=111 and number.id=12
             function getTypeReferenceId(type, depth) {
@@ -65536,7 +65616,7 @@ var ts;
             var postFix = intersectionState ? ":" + intersectionState : "";
             return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
                 getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) :
-                source.id + "," + target.id + postFix;
+                "".concat(source.id, ",").concat(target.id).concat(postFix);
         }
         // Invoke the callback for each underlying property symbol of the given symbol and return the first
         // value that isn't undefined.
@@ -67663,11 +67743,11 @@ var ts;
                 case 79 /* Identifier */:
                     if (!ts.isThisInTypeQuery(node)) {
                         var symbol = getResolvedSymbol(node);
-                        return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + getSymbolId(symbol) : undefined;
+                        return symbol !== unknownSymbol ? "".concat(flowContainer ? getNodeId(flowContainer) : "-1", "|").concat(getTypeId(declaredType), "|").concat(getTypeId(initialType), "|").concat(getSymbolId(symbol)) : undefined;
                     }
                 // falls through
                 case 108 /* ThisKeyword */:
-                    return "0|" + (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType);
+                    return "0|".concat(flowContainer ? getNodeId(flowContainer) : "-1", "|").concat(getTypeId(declaredType), "|").concat(getTypeId(initialType));
                 case 229 /* NonNullExpression */:
                 case 211 /* ParenthesizedExpression */:
                     return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
@@ -69842,12 +69922,16 @@ var ts;
         function isGenericTypeWithoutNullableConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
         }
-        function hasNonBindingPatternContextualTypeWithNoGenericTypes(node) {
+        function hasContextualTypeWithNoGenericTypes(node, checkMode) {
             // Computing the contextual type for a child of a JSX element involves resolving the type of the
             // element's tag name, so we exclude that here to avoid circularities.
+            // If check mode has `CheckMode.RestBindingElement`, we skip binding pattern contextual types,
+            // as we want the type of a rest element to be generic when possible.
             var contextualType = (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
-                getContextualType(node, 8 /* SkipBindingPatterns */);
+                (checkMode && checkMode & 32 /* RestBindingElement */ ?
+                    getContextualType(node, 8 /* SkipBindingPatterns */)
+                    : getContextualType(node));
             return contextualType && !isGenericType(contextualType);
         }
         function getNarrowableTypeForReference(type, reference, checkMode) {
@@ -69860,7 +69944,7 @@ var ts;
             // 'string | undefined' to give control flow analysis the opportunity to narrow to type 'string'.
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
-                (isConstraintPosition(type, reference) || hasNonBindingPatternContextualTypeWithNoGenericTypes(reference));
+                (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
             return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
@@ -69928,7 +70012,7 @@ var ts;
                         var links = getNodeLinks(location);
                         if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
                             links.flags |= 268435456 /* InCheckIdentifier */;
-                            var parentType = getTypeForBindingElementParent(parent);
+                            var parentType = getTypeForBindingElementParent(parent, 0 /* Normal */);
                             links.flags &= ~268435456 /* InCheckIdentifier */;
                             if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
                                 var pattern = declaration.parent;
@@ -70781,7 +70865,7 @@ var ts;
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
             var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
-                parent.kind !== 202 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent);
+                parent.kind !== 202 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
             if (parent.name.kind === 201 /* ArrayBindingPattern */) {
@@ -71552,7 +71636,7 @@ var ts;
                     !leftName ? rightName :
                         !rightName ? leftName :
                             undefined;
-                var paramSymbol = createSymbol(1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0), paramName || "arg" + i);
+                var paramSymbol = createSymbol(1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0), paramName || "arg".concat(i));
                 paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
                 params[i] = paramSymbol;
             }
@@ -73022,7 +73106,7 @@ var ts;
                     error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right));
                     return errorType;
                 }
-                propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getSetAccessorTypeOfSymbol(prop) : getTypeOfSymbol(prop);
+                propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
             }
             return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
         }
@@ -75492,8 +75576,8 @@ var ts;
             if (hasDefaultOnly && type && !isErrorType(type)) {
                 var synthType = type;
                 if (!synthType.defaultOnlyType) {
-                    var type_4 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
-                    synthType.defaultOnlyType = type_4;
+                    var type_5 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
+                    synthType.defaultOnlyType = type_5;
                 }
                 return synthType.defaultOnlyType;
             }
@@ -75947,7 +76031,7 @@ var ts;
             var links = getSymbolLinks(parameter);
             if (!links.type) {
                 var declaration = parameter.valueDeclaration;
-                links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true);
+                links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
                 if (declaration.name.kind !== 79 /* Identifier */) {
                     // if inference didn't come up with anything but unknown, fall back to the binding pattern if present.
                     if (links.type === unknownType) {
@@ -76220,12 +76304,12 @@ var ts;
                 var witnesses = getSwitchClauseTypeOfWitnesses(node, /*retainDefault*/ false);
                 // notEqualFacts states that the type of the switched value is not equal to every type in the switch.
                 var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, /*hasDefault*/ true);
-                var type_5 = getBaseConstraintOfType(operandType) || operandType;
+                var type_6 = getBaseConstraintOfType(operandType) || operandType;
                 // Take any/unknown as a special condition. Or maybe we could change `type` to a union containing all primitive types.
-                if (type_5.flags & 3 /* AnyOrUnknown */) {
+                if (type_6.flags & 3 /* AnyOrUnknown */) {
                     return (556800 /* AllTypeofNE */ & notEqualFacts_1) === 556800 /* AllTypeofNE */;
                 }
-                return !!(filterType(type_5, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
+                return !!(filterType(type_6, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -77678,11 +77762,11 @@ var ts;
             }
         }
         function checkExpressionCached(node, checkMode) {
+            if (checkMode && checkMode !== 0 /* Normal */) {
+                return checkExpression(node, checkMode);
+            }
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
-                if (checkMode && checkMode !== 0 /* Normal */) {
-                    return checkExpression(node, checkMode);
-                }
                 // When computing a type that we're going to cache, we need to ignore any ongoing control flow
                 // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart
                 // to the top of the stack ensures all transient types are computed from a known point.
@@ -77702,10 +77786,12 @@ var ts;
                 node.kind === 228 /* AsExpression */ ||
                 ts.isJSDocTypeAssertion(node);
         }
-        function checkDeclarationInitializer(declaration, contextualType) {
+        function checkDeclarationInitializer(declaration, checkMode, contextualType) {
             var initializer = ts.getEffectiveInitializer(declaration);
             var type = getQuickTypeOfExpression(initializer) ||
-                (contextualType ? checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, 0 /* Normal */) : checkExpressionCached(initializer));
+                (contextualType ?
+                    checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, checkMode || 0 /* Normal */)
+                    : checkExpressionCached(initializer, checkMode));
             return ts.isParameter(declaration) && declaration.name.kind === 201 /* ArrayBindingPattern */ &&
                 isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ?
                 padTupleType(type, declaration.name) : type;
@@ -78345,6 +78431,7 @@ var ts;
                 }
             }
             checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node));
+            checkUnmatchedJSDocParameters(node);
             ts.forEach(node.parameters, checkParameter);
             // TODO(rbuckton): Should we start checking JSDoc types?
             if (node.type) {
@@ -79916,31 +80003,6 @@ var ts;
         }
         function checkJSDocParameterTag(node) {
             checkSourceElement(node.typeExpression);
-            if (!ts.getParameterSymbolFromJSDoc(node)) {
-                var decl = ts.getHostSignatureFromJSDoc(node);
-                // don't issue an error for invalid hosts -- just functions --
-                // and give a better error message when the host function mentions `arguments`
-                // but the tag doesn't have an array type
-                if (decl) {
-                    var i = ts.getJSDocTags(decl).filter(ts.isJSDocParameterTag).indexOf(node);
-                    if (i > -1 && i < decl.parameters.length && ts.isBindingPattern(decl.parameters[i].name)) {
-                        return;
-                    }
-                    if (!containsArgumentsReference(decl)) {
-                        if (ts.isQualifiedName(node.name)) {
-                            error(node.name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(node.name), ts.entityNameToString(node.name.left));
-                        }
-                        else {
-                            error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(node.name));
-                        }
-                    }
-                    else if (ts.findLast(ts.getJSDocTags(decl), ts.isJSDocParameterTag) === node &&
-                        node.typeExpression && node.typeExpression.type &&
-                        !isArrayType(getTypeFromTypeNode(node.typeExpression.type))) {
-                        error(node.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(node.name.kind === 160 /* QualifiedName */ ? node.name.right : node.name));
-                    }
-                }
-            }
         }
         function checkJSDocPropertyTag(node) {
             checkSourceElement(node.typeExpression);
@@ -80642,7 +80704,8 @@ var ts;
                 }
                 // check private/protected variable access
                 var parent = node.parent.parent;
-                var parentType = getTypeForBindingElementParent(parent);
+                var parentCheckMode = node.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+                var parentType = getTypeForBindingElementParent(parent, parentCheckMode);
                 var name = node.propertyName || node.name;
                 if (parentType && !ts.isBindingPattern(name)) {
                     var exprType = getLiteralTypeFromPropertyName(name);
@@ -81440,7 +81503,7 @@ var ts;
         function getPropertyNameForKnownSymbolName(symbolName) {
             var ctorType = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ false);
             var uniqueType = ctorType && getTypeOfPropertyOfType(getTypeOfSymbol(ctorType), ts.escapeLeadingUnderscores(symbolName));
-            return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : "__@" + symbolName;
+            return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : "__@".concat(symbolName);
         }
         /**
          * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like
@@ -81881,7 +81944,7 @@ var ts;
                     var declaration = catchClause.variableDeclaration;
                     var typeNode = ts.getEffectiveTypeAnnotationNode(ts.getRootDeclaration(declaration));
                     if (typeNode) {
-                        var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false);
+                        var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false, 0 /* Normal */);
                         if (type && !(type.flags & 3 /* AnyOrUnknown */)) {
                             grammarErrorOnFirstToken(typeNode, ts.Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified);
                         }
@@ -82012,6 +82075,45 @@ var ts;
                 error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]); // https://github.com/Microsoft/TypeScript/issues/17494
             }
         }
+        function checkUnmatchedJSDocParameters(node) {
+            var jsdocParameters = ts.filter(ts.getJSDocTags(node), ts.isJSDocParameterTag);
+            if (!ts.length(jsdocParameters))
+                return;
+            var isJs = ts.isInJSFile(node);
+            var parameters = new ts.Set();
+            var excludedParameters = new ts.Set();
+            ts.forEach(node.parameters, function (_a, index) {
+                var name = _a.name;
+                if (ts.isIdentifier(name)) {
+                    parameters.add(name.escapedText);
+                }
+                if (ts.isBindingPattern(name)) {
+                    excludedParameters.add(index);
+                }
+            });
+            var containsArguments = containsArgumentsReference(node);
+            if (containsArguments) {
+                var lastJSDocParam = ts.lastOrUndefined(jsdocParameters);
+                if (lastJSDocParam && ts.isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression &&
+                    lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
+                    errorOrSuggestion(isJs, lastJSDocParam.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(lastJSDocParam.name));
+                }
+            }
+            else {
+                ts.forEach(jsdocParameters, function (_a, index) {
+                    var name = _a.name;
+                    if (excludedParameters.has(index) || ts.isIdentifier(name) && parameters.has(name.escapedText)) {
+                        return;
+                    }
+                    if (ts.isQualifiedName(name)) {
+                        errorOrSuggestion(isJs, name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(name), ts.entityNameToString(name.left));
+                    }
+                    else {
+                        errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                    }
+                });
+            }
+        }
         /**
          * Check each type parameter and check that type parameters have no duplicate type parameter declarations
          */
@@ -82987,7 +83089,7 @@ var ts;
                 var isAmbientExternalModule = ts.isAmbientModule(node);
                 var contextErrorMessage = isAmbientExternalModule
                     ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
-                    : ts.Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
+                    : ts.Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module;
                 if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
                     // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors.
                     return;
@@ -83220,6 +83322,9 @@ var ts;
                                     var name = ts.idText(node.kind === 269 /* ImportSpecifier */ ? node.propertyName || node.name : node.name);
                                     addTypeOnlyDeclarationRelatedInfo(error(node, message, name), isType ? undefined : typeOnlyAlias, name);
                                 }
+                                if (isType && node.kind === 264 /* ImportEqualsDeclaration */ && ts.hasEffectiveModifier(node, 1 /* Export */)) {
+                                    error(node, ts.Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided);
+                                }
                                 break;
                             }
                             case 274 /* ExportSpecifier */: {
@@ -83303,7 +83408,7 @@ var ts;
             }
         }
         function checkImportDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -83336,7 +83441,7 @@ var ts;
             checkAssertClause(node);
         }
         function checkImportEqualsDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -83373,7 +83478,7 @@ var ts;
             }
         }
         function checkExportDeclaration(node) {
-            if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
+            if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
                 // If we hit an export in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
@@ -84607,7 +84712,7 @@ var ts;
                 return errorType;
             }
             if (ts.isBindingPattern(node)) {
-                return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true) || errorType;
+                return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true, 0 /* Normal */) || errorType;
             }
             if (isInRightSideOfImportOrExportAssignment(node)) {
                 var symbol = getSymbolAtLocation(node);
@@ -88450,7 +88555,7 @@ var ts;
                 value >= 52 && value < 62 ? 48 /* _0 */ + value - 52 :
                     value === 62 ? 43 /* plus */ :
                         value === 63 ? 47 /* slash */ :
-                            ts.Debug.fail(value + ": not a base64 value");
+                            ts.Debug.fail("".concat(value, ": not a base64 value"));
     }
     function base64FormatDecode(ch) {
         return ch >= 65 /* A */ && ch <= 90 /* Z */ ? ch - 65 /* A */ :
@@ -88525,7 +88630,7 @@ var ts;
                 var mappings = ts.arrayFrom(decoder, processMapping);
                 if (decoder.error !== undefined) {
                     if (host.log) {
-                        host.log("Encountered error while decoding sourcemap: " + decoder.error);
+                        host.log("Encountered error while decoding sourcemap: ".concat(decoder.error));
                     }
                     decodedMappings = ts.emptyArray;
                 }
@@ -92200,7 +92305,7 @@ var ts;
                     var propertyName = ts.isPropertyAccessExpression(originalNode)
                         ? ts.declarationNameToString(originalNode.name)
                         : ts.getTextOfNode(originalNode.argumentExpression);
-                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " " + propertyName + " ");
+                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " ".concat(propertyName, " "));
                 }
                 return substitute;
             }
@@ -93676,8 +93781,8 @@ var ts;
         }
         function createHoistedVariableForClass(name, node) {
             var className = getPrivateIdentifierEnvironment().className;
-            var prefix = className ? "_" + className : "";
-            var identifier = factory.createUniqueName(prefix + "_" + name, 16 /* Optimistic */);
+            var prefix = className ? "_".concat(className) : "";
+            var identifier = factory.createUniqueName("".concat(prefix, "_").concat(name), 16 /* Optimistic */);
             if (resolver.getNodeCheckFlags(node) & 524288 /* BlockScopedBindingInLoop */) {
                 addBlockScopedVariable(identifier);
             }
@@ -95682,7 +95787,7 @@ var ts;
                 specifierSourceImports = new ts.Map();
                 currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
             }
-            var generatedName = factory.createUniqueName("_" + name, 16 /* Optimistic */ | 32 /* FileLevel */ | 64 /* AllowNameSubstitution */);
+            var generatedName = factory.createUniqueName("_".concat(name), 16 /* Optimistic */ | 32 /* FileLevel */ | 64 /* AllowNameSubstitution */);
             var specifier = factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier(name), generatedName);
             generatedName.generatedImportReference = specifier;
             specifierSourceImports.set(name, specifier);
@@ -96830,11 +96935,11 @@ var ts;
                     }
                     else {
                         if (node.kind === 245 /* BreakStatement */) {
-                            labelMarker = "break-" + label.escapedText;
+                            labelMarker = "break-".concat(label.escapedText);
                             setLabeledJump(convertedLoopState, /*isBreak*/ true, ts.idText(label), labelMarker);
                         }
                         else {
-                            labelMarker = "continue-" + label.escapedText;
+                            labelMarker = "continue-".concat(label.escapedText);
                             setLabeledJump(convertedLoopState, /*isBreak*/ false, ts.idText(label), labelMarker);
                         }
                     }
@@ -105691,7 +105796,7 @@ var ts;
             return getTypeAliasDeclarationVisibilityError;
         }
         else {
-            return ts.Debug.assertNever(node, "Attempted to set a declaration diagnostic context for unhandled node kind: " + ts.SyntaxKind[node.kind]);
+            return ts.Debug.assertNever(node, "Attempted to set a declaration diagnostic context for unhandled node kind: ".concat(ts.SyntaxKind[node.kind]));
         }
         function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
             if (node.kind === 253 /* VariableDeclaration */ || node.kind === 202 /* BindingElement */) {
@@ -105902,7 +106007,7 @@ var ts;
                             ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 :
                         ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_private_name_1;
                 default:
-                    return ts.Debug.fail("Unknown parent for parameter: " + ts.SyntaxKind[node.parent.kind]);
+                    return ts.Debug.fail("Unknown parent for parameter: ".concat(ts.SyntaxKind[node.parent.kind]));
             }
         }
         function getTypeParameterConstraintVisibilityError() {
@@ -106660,7 +106765,7 @@ var ts;
             while (ts.length(lateMarkedStatements)) {
                 var i = lateMarkedStatements.shift();
                 if (!ts.isLateVisibilityPaintedStatement(i)) {
-                    return ts.Debug.fail("Late replaced statement was found which is not handled by the declaration transformer!: " + (ts.SyntaxKind ? ts.SyntaxKind[i.kind] : i.kind));
+                    return ts.Debug.fail("Late replaced statement was found which is not handled by the declaration transformer!: ".concat(ts.SyntaxKind ? ts.SyntaxKind[i.kind] : i.kind));
                 }
                 var priorNeedsDeclare = needsDeclare;
                 needsDeclare = i.parent && ts.isSourceFile(i.parent) && !(ts.isExternalModule(i.parent) && isBundledEmit);
@@ -106849,7 +106954,7 @@ var ts;
                             return cleanup(input);
                         return cleanup(factory.updateImportTypeNode(input, factory.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), input.qualifier, ts.visitNodes(input.typeArguments, visitDeclarationSubtree, ts.isTypeNode), input.isTypeOf));
                     }
-                    default: ts.Debug.assertNever(input, "Attempted to process unhandled node kind: " + ts.SyntaxKind[input.kind]);
+                    default: ts.Debug.assertNever(input, "Attempted to process unhandled node kind: ".concat(ts.SyntaxKind[input.kind]));
                 }
             }
             if (ts.isTupleTypeNode(input) && (ts.getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === ts.getLineAndCharacterOfPosition(currentSourceFile, input.end).line)) {
@@ -107140,7 +107245,7 @@ var ts;
                     if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 104 /* NullKeyword */) {
                         // We must add a temporary declaration for the extends clause expression
                         var oldId = input.name ? ts.unescapeLeadingUnderscores(input.name.escapedText) : "default";
-                        var newId_1 = factory.createUniqueName(oldId + "_base", 16 /* Optimistic */);
+                        var newId_1 = factory.createUniqueName("".concat(oldId, "_base"), 16 /* Optimistic */);
                         getSymbolAccessibilityDiagnostic = function () { return ({
                             diagnosticMessage: ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
                             errorNode: extendsClause_1,
@@ -107181,7 +107286,7 @@ var ts;
                 }
             }
             // Anything left unhandled is an error, so this should be unreachable
-            return ts.Debug.assertNever(input, "Unhandled top-level node in declaration emit: " + ts.SyntaxKind[input.kind]);
+            return ts.Debug.assertNever(input, "Unhandled top-level node in declaration emit: ".concat(ts.SyntaxKind[input.kind]));
             function cleanup(node) {
                 if (isEnclosingDeclaration(input)) {
                     enclosingDeclaration = previousEnclosingDeclaration;
@@ -108073,13 +108178,13 @@ var ts;
         if (ts.fileExtensionIs(inputFileName, ".json" /* Json */))
             return;
         if (js && configFile.options.sourceMap) {
-            addOutput(js + ".map");
+            addOutput("".concat(js, ".map"));
         }
         if (ts.getEmitDeclarations(configFile.options)) {
             var dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory);
             addOutput(dts);
             if (configFile.options.declarationMap) {
-                addOutput(dts + ".map");
+                addOutput("".concat(dts, ".map"));
             }
         }
     }
@@ -108148,7 +108253,7 @@ var ts;
     function getFirstProjectOutput(configFile, ignoreCase) {
         if (ts.outFile(configFile.options)) {
             var jsFilePath = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false).jsFilePath;
-            return ts.Debug.checkDefined(jsFilePath, "project " + configFile.options.configFilePath + " expected to have at least one output");
+            return ts.Debug.checkDefined(jsFilePath, "project ".concat(configFile.options.configFilePath, " expected to have at least one output"));
         }
         var getCommonSourceDirectory = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); });
         for (var _a = 0, _b = configFile.fileNames; _a < _b.length; _a++) {
@@ -108167,7 +108272,7 @@ var ts;
         var buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options);
         if (buildInfoPath)
             return buildInfoPath;
-        return ts.Debug.fail("project " + configFile.options.configFilePath + " expected to have at least one output");
+        return ts.Debug.fail("project ".concat(configFile.options.configFilePath, " expected to have at least one output"));
     }
     ts.getFirstProjectOutput = getFirstProjectOutput;
     /*@internal*/
@@ -108393,7 +108498,7 @@ var ts;
                 if (sourceMappingURL) {
                     if (!writer.isAtStartOfLine())
                         writer.rawWrite(newLine);
-                    writer.writeComment("//# " + "sourceMappingURL" + "=" + sourceMappingURL); // Tools can sometimes see this line as a source mapping url comment
+                    writer.writeComment("//# ".concat("sourceMappingURL", "=").concat(sourceMappingURL)); // Tools can sometimes see this line as a source mapping url comment
                 }
                 // Write the source map
                 if (sourceMapFilePath) {
@@ -108442,7 +108547,7 @@ var ts;
                 // Encode the sourceMap into the sourceMap url
                 var sourceMapText = sourceMapGenerator.toString();
                 var base64SourceMapText = ts.base64encode(ts.sys, sourceMapText);
-                return "data:application/json;base64," + base64SourceMapText;
+                return "data:application/json;base64,".concat(base64SourceMapText);
             }
             var sourceMapFile = ts.getBaseFileName(ts.normalizeSlashes(ts.Debug.checkDefined(sourceMapFilePath)));
             if (mapOptions.mapRoot) {
@@ -108622,7 +108727,7 @@ var ts;
                             return;
                         break;
                     default:
-                        ts.Debug.fail("Unexpected path: " + name);
+                        ts.Debug.fail("Unexpected path: ".concat(name));
                 }
                 outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark });
             },
@@ -109482,7 +109587,7 @@ var ts;
                 return writeTokenNode(node, writeKeyword);
             if (ts.isTokenKind(node.kind))
                 return writeTokenNode(node, writePunctuation);
-            ts.Debug.fail("Unhandled SyntaxKind: " + ts.Debug.formatSyntaxKind(node.kind) + ".");
+            ts.Debug.fail("Unhandled SyntaxKind: ".concat(ts.Debug.formatSyntaxKind(node.kind), "."));
         }
         function emitMappedTypeParameter(node) {
             emit(node.name);
@@ -109652,16 +109757,16 @@ var ts;
             }
         }
         function emitPlaceholder(hint, node, snippet) {
-            nonEscapingWrite("${" + snippet.order + ":"); // `${2:`
+            nonEscapingWrite("${".concat(snippet.order, ":")); // `${2:`
             pipelineEmitWithHintWorker(hint, node, /*allowSnippets*/ false); // `...`
             nonEscapingWrite("}"); // `}`
             // `${2:...}`
         }
         function emitTabStop(hint, node, snippet) {
             // A tab stop should only be attached to an empty node, i.e. a node that doesn't emit any text.
-            ts.Debug.assert(node.kind === 235 /* EmptyStatement */, "A tab stop cannot be attached to a node of kind " + ts.Debug.formatSyntaxKind(node.kind) + ".");
+            ts.Debug.assert(node.kind === 235 /* EmptyStatement */, "A tab stop cannot be attached to a node of kind ".concat(ts.Debug.formatSyntaxKind(node.kind), "."));
             ts.Debug.assert(hint !== 5 /* EmbeddedStatement */, "A tab stop cannot be attached to an embedded statement.");
-            nonEscapingWrite("$" + snippet.order);
+            nonEscapingWrite("$".concat(snippet.order));
         }
         //
         // Identifiers
@@ -111423,17 +111528,17 @@ var ts;
                 writeLine();
             }
             if (currentSourceFile && currentSourceFile.moduleName) {
-                writeComment("/// <amd-module name=\"" + currentSourceFile.moduleName + "\" />");
+                writeComment("/// <amd-module name=\"".concat(currentSourceFile.moduleName, "\" />"));
                 writeLine();
             }
             if (currentSourceFile && currentSourceFile.amdDependencies) {
                 for (var _a = 0, _b = currentSourceFile.amdDependencies; _a < _b.length; _a++) {
                     var dep = _b[_a];
                     if (dep.name) {
-                        writeComment("/// <amd-dependency name=\"" + dep.name + "\" path=\"" + dep.path + "\" />");
+                        writeComment("/// <amd-dependency name=\"".concat(dep.name, "\" path=\"").concat(dep.path, "\" />"));
                     }
                     else {
-                        writeComment("/// <amd-dependency path=\"" + dep.path + "\" />");
+                        writeComment("/// <amd-dependency path=\"".concat(dep.path, "\" />"));
                     }
                     writeLine();
                 }
@@ -111441,7 +111546,7 @@ var ts;
             for (var _c = 0, files_2 = files; _c < files_2.length; _c++) {
                 var directive = files_2[_c];
                 var pos = writer.getTextPos();
-                writeComment("/// <reference path=\"" + directive.fileName + "\" />");
+                writeComment("/// <reference path=\"".concat(directive.fileName, "\" />"));
                 if (bundleFileInfo)
                     bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName });
                 writeLine();
@@ -111449,7 +111554,7 @@ var ts;
             for (var _d = 0, types_24 = types; _d < types_24.length; _d++) {
                 var directive = types_24[_d];
                 var pos = writer.getTextPos();
-                writeComment("/// <reference types=\"" + directive.fileName + "\" />");
+                writeComment("/// <reference types=\"".concat(directive.fileName, "\" />"));
                 if (bundleFileInfo)
                     bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "type" /* Type */, data: directive.fileName });
                 writeLine();
@@ -111457,7 +111562,7 @@ var ts;
             for (var _e = 0, libs_1 = libs; _e < libs_1.length; _e++) {
                 var directive = libs_1[_e];
                 var pos = writer.getTextPos();
-                writeComment("/// <reference lib=\"" + directive.fileName + "\" />");
+                writeComment("/// <reference lib=\"".concat(directive.fileName, "\" />"));
                 if (bundleFileInfo)
                     bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "lib" /* Lib */, data: directive.fileName });
                 writeLine();
@@ -112237,9 +112342,9 @@ var ts;
                 var textSourceNode = node.textSourceNode;
                 if (ts.isIdentifier(textSourceNode) || ts.isNumericLiteral(textSourceNode)) {
                     var text = ts.isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode(textSourceNode);
-                    return jsxAttributeEscape ? "\"" + ts.escapeJsxAttributeString(text) + "\"" :
-                        neverAsciiEscape || (ts.getEmitFlags(node) & 16777216 /* NoAsciiEscaping */) ? "\"" + ts.escapeString(text) + "\"" :
-                            "\"" + ts.escapeNonAsciiString(text) + "\"";
+                    return jsxAttributeEscape ? "\"".concat(ts.escapeJsxAttributeString(text), "\"") :
+                        neverAsciiEscape || (ts.getEmitFlags(node) & 16777216 /* NoAsciiEscaping */) ? "\"".concat(ts.escapeString(text), "\"") :
+                            "\"".concat(ts.escapeNonAsciiString(text), "\"");
                 }
                 else {
                     return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);
@@ -112716,8 +112821,8 @@ var ts;
         }
         function formatSynthesizedComment(comment) {
             return comment.kind === 3 /* MultiLineCommentTrivia */
-                ? "/*" + comment.text + "*/"
-                : "//" + comment.text;
+                ? "/*".concat(comment.text, "*/")
+                : "//".concat(comment.text);
         }
         function emitBodyWithDetachedComments(node, detachedRange, emitCallback) {
             enterComment();
@@ -113438,7 +113543,7 @@ var ts;
         var watchedDirPath = _a.watchedDirPath, fileOrDirectory = _a.fileOrDirectory, fileOrDirectoryPath = _a.fileOrDirectoryPath, configFileName = _a.configFileName, options = _a.options, program = _a.program, extraFileExtensions = _a.extraFileExtensions, currentDirectory = _a.currentDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, writeLog = _a.writeLog, toPath = _a.toPath;
         var newPath = ts.removeIgnoredPath(fileOrDirectoryPath);
         if (!newPath) {
-            writeLog("Project: " + configFileName + " Detected ignored path: " + fileOrDirectory);
+            writeLog("Project: ".concat(configFileName, " Detected ignored path: ").concat(fileOrDirectory));
             return true;
         }
         fileOrDirectoryPath = newPath;
@@ -113447,11 +113552,11 @@ var ts;
         // If the the added or created file or directory is not supported file name, ignore the file
         // But when watched directory is added/removed, we need to reload the file list
         if (ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, options, extraFileExtensions)) {
-            writeLog("Project: " + configFileName + " Detected file add/remove of non supported extension: " + fileOrDirectory);
+            writeLog("Project: ".concat(configFileName, " Detected file add/remove of non supported extension: ").concat(fileOrDirectory));
             return true;
         }
         if (ts.isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) {
-            writeLog("Project: " + configFileName + " Detected excluded file: " + fileOrDirectory);
+            writeLog("Project: ".concat(configFileName, " Detected excluded file: ").concat(fileOrDirectory));
             return true;
         }
         if (!program)
@@ -113475,7 +113580,7 @@ var ts;
         var builderProgram = !realProgram && !ts.isArray(program) ? program : undefined;
         if (hasSourceFile((filePathWithoutExtension + ".ts" /* Ts */)) ||
             hasSourceFile((filePathWithoutExtension + ".tsx" /* Tsx */))) {
-            writeLog("Project: " + configFileName + " Detected output file: " + fileOrDirectory);
+            writeLog("Project: ".concat(configFileName, " Detected output file: ").concat(fileOrDirectory));
             return true;
         }
         return false;
@@ -113543,36 +113648,36 @@ var ts;
                 host.useCaseSensitiveFileNames();
         }
         function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) {
-            log("ExcludeWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
+            log("ExcludeWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)));
             return {
-                close: function () { return log("ExcludeWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); }
+                close: function () { return log("ExcludeWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo))); }
             };
         }
         function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
-            log("FileWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
+            log("FileWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)));
             var watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2);
             return {
                 close: function () {
-                    log("FileWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
+                    log("FileWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)));
                     watcher.close();
                 }
             };
         }
         function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
-            var watchInfo = "DirectoryWatcher:: Added:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo);
+            var watchInfo = "DirectoryWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
             log(watchInfo);
             var start = ts.timestamp();
             var watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2);
             var elapsed = ts.timestamp() - start;
-            log("Elapsed:: " + elapsed + "ms " + watchInfo);
+            log("Elapsed:: ".concat(elapsed, "ms ").concat(watchInfo));
             return {
                 close: function () {
-                    var watchInfo = "DirectoryWatcher:: Close:: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo);
+                    var watchInfo = "DirectoryWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
                     log(watchInfo);
                     var start = ts.timestamp();
                     watcher.close();
                     var elapsed = ts.timestamp() - start;
-                    log("Elapsed:: " + elapsed + "ms " + watchInfo);
+                    log("Elapsed:: ".concat(elapsed, "ms ").concat(watchInfo));
                 }
             };
         }
@@ -113582,16 +113687,16 @@ var ts;
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                var triggerredInfo = (key === "watchFile" ? "FileWatcher" : "DirectoryWatcher") + ":: Triggered with " + args[0] + " " + (args[1] !== undefined ? args[1] : "") + ":: " + getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo);
+                var triggerredInfo = "".concat(key === "watchFile" ? "FileWatcher" : "DirectoryWatcher", ":: Triggered with ").concat(args[0], " ").concat(args[1] !== undefined ? args[1] : "", ":: ").concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo));
                 log(triggerredInfo);
                 var start = ts.timestamp();
                 cb.call.apply(cb, __spreadArray([/*thisArg*/ undefined], args, false));
                 var elapsed = ts.timestamp() - start;
-                log("Elapsed:: " + elapsed + "ms " + triggerredInfo);
+                log("Elapsed:: ".concat(elapsed, "ms ").concat(triggerredInfo));
             }, flags, options, detailInfo1, detailInfo2); };
         }
         function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo) {
-            return "WatchInfo: " + file + " " + flags + " " + JSON.stringify(options) + " " + (getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : detailInfo1 + " " + detailInfo2);
+            return "WatchInfo: ".concat(file, " ").concat(flags, " ").concat(JSON.stringify(options), " ").concat(getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : "".concat(detailInfo1, " ").concat(detailInfo2));
         }
     }
     ts.getWatchFactory = getWatchFactory;
@@ -113898,12 +114003,12 @@ var ts;
     }
     ts.formatDiagnostics = formatDiagnostics;
     function formatDiagnostic(diagnostic, host) {
-        var errorMessage = ts.diagnosticCategoryName(diagnostic) + " TS" + diagnostic.code + ": " + flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine()) + host.getNewLine();
+        var errorMessage = "".concat(ts.diagnosticCategoryName(diagnostic), " TS").concat(diagnostic.code, ": ").concat(flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())).concat(host.getNewLine());
         if (diagnostic.file) {
             var _a = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), line = _a.line, character = _a.character; // TODO: GH#18217
             var fileName = diagnostic.file.fileName;
             var relativeFileName = ts.convertToRelativePath(fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); });
-            return relativeFileName + "(" + (line + 1) + "," + (character + 1) + "): " + errorMessage;
+            return "".concat(relativeFileName, "(").concat(line + 1, ",").concat(character + 1, "): ") + errorMessage;
         }
         return errorMessage;
     }
@@ -113991,9 +114096,9 @@ var ts;
         var output = "";
         output += color(relativeFileName, ForegroundColorEscapeSequences.Cyan);
         output += ":";
-        output += color("" + (firstLine + 1), ForegroundColorEscapeSequences.Yellow);
+        output += color("".concat(firstLine + 1), ForegroundColorEscapeSequences.Yellow);
         output += ":";
-        output += color("" + (firstLineChar + 1), ForegroundColorEscapeSequences.Yellow);
+        output += color("".concat(firstLineChar + 1), ForegroundColorEscapeSequences.Yellow);
         return output;
     }
     ts.formatLocation = formatLocation;
@@ -114007,7 +114112,7 @@ var ts;
                 output += " - ";
             }
             output += formatColorAndReset(ts.diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category));
-            output += formatColorAndReset(" TS" + diagnostic.code + ": ", ForegroundColorEscapeSequences.Grey);
+            output += formatColorAndReset(" TS".concat(diagnostic.code, ": "), ForegroundColorEscapeSequences.Grey);
             output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine());
             if (diagnostic.file) {
                 output += host.getNewLine();
@@ -114116,7 +114221,7 @@ var ts;
             var result = void 0;
             var mode = getModeForResolutionAtIndex(containingFile, i);
             i++;
-            var cacheKey = mode !== undefined ? mode + "|" + name : name;
+            var cacheKey = mode !== undefined ? "".concat(mode, "|").concat(name) : name;
             if (cache.has(cacheKey)) {
                 result = cache.get(cacheKey);
             }
@@ -114354,9 +114459,9 @@ var ts;
         ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
         ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
         ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
-        ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module.code,
+        ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
         ts.Diagnostics.An_export_declaration_cannot_have_modifiers.code,
-        ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module.code,
+        ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
         ts.Diagnostics.An_import_declaration_cannot_have_modifiers.code,
         ts.Diagnostics.An_object_member_cannot_be_declared_optional.code,
         ts.Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code,
@@ -115424,7 +115529,7 @@ var ts;
                 ts.Debug.assert(!!sourceFile.bindDiagnostics);
                 var isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
                 var isCheckJs = isJs && ts.isCheckJsEnabledForFile(sourceFile, options);
-                var isPlainJs = isJs && !sourceFile.checkJsDirective && options.checkJs === undefined;
+                var isPlainJs = ts.isPlainJsFile(sourceFile, options.checkJs);
                 var isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
                 // By default, only type-check .ts, .tsx, Deferred, plain JS, checked JS and External
                 // - plain JS: .js files with no // ts-check and checkJs: undefined
@@ -116305,7 +116410,7 @@ var ts;
                 path += (i === 2 ? "/" : "-") + components[i];
                 i++;
             }
-            var resolveFrom = ts.combinePaths(currentDirectory, "__lib_node_modules_lookup_" + libFileName + "__.ts");
+            var resolveFrom = ts.combinePaths(currentDirectory, "__lib_node_modules_lookup_".concat(libFileName, "__.ts"));
             var localOverrideModuleResult = ts.resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, moduleResolutionCache);
             if (localOverrideModuleResult === null || localOverrideModuleResult === void 0 ? void 0 : localOverrideModuleResult.resolvedModule) {
                 return localOverrideModuleResult.resolvedModule.resolvedFileName;
@@ -117126,12 +117231,12 @@ var ts;
         }
         function directoryExistsIfProjectReferenceDeclDir(dir) {
             var dirPath = host.toPath(dir);
-            var dirPathWithTrailingDirectorySeparator = "" + dirPath + ts.directorySeparator;
+            var dirPathWithTrailingDirectorySeparator = "".concat(dirPath).concat(ts.directorySeparator);
             return ts.forEachKey(setOfDeclarationDirectories, function (declDirPath) { return dirPath === declDirPath ||
                 // Any parent directory of declaration dir
                 ts.startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) ||
                 // Any directory inside declaration dir
-                ts.startsWith(dirPath, declDirPath + "/"); });
+                ts.startsWith(dirPath, "".concat(declDirPath, "/")); });
         }
         function handleDirectoryCouldBeSymlink(directory) {
             var _a;
@@ -117184,7 +117289,7 @@ var ts;
                 if (isFile && result) {
                     // Store the real path for the file'
                     var absolutePath = ts.getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory());
-                    symlinkCache.setSymlinkedFile(fileOrDirectoryPath, "" + symlinkedDirectory.real + absolutePath.replace(new RegExp(directoryPath, "i"), ""));
+                    symlinkCache.setSymlinkedFile(fileOrDirectoryPath, "".concat(symlinkedDirectory.real).concat(absolutePath.replace(new RegExp(directoryPath, "i"), "")));
                 }
                 return result;
             }) || false;
@@ -117642,7 +117747,7 @@ var ts;
                 /*forceDtsEmit*/ true);
                 var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
                 if (firstDts_1) {
-                    ts.Debug.assert(ts.fileExtensionIsOneOf(firstDts_1.name, [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */]), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
+                    ts.Debug.assert(ts.fileExtensionIsOneOf(firstDts_1.name, [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */]), "File extension for signature expected to be dts", function () { return "Found: ".concat(ts.getAnyExtensionFromPath(firstDts_1.name), " for ").concat(firstDts_1.name, ":: All output files: ").concat(JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; }))); });
                     latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
                     if (exportedModulesMapCache && latestSignature !== prevSignature) {
                         updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
@@ -118150,7 +118255,7 @@ var ts;
             return;
         }
         else {
-            ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
+            ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: ".concat(affectedFile.fileName));
         }
         if (!state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) {
             forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, function (state, path) { return handleDtsMayChangeOf(state, path, cancellationToken, computeHash); });
@@ -119295,7 +119400,7 @@ var ts;
                 failedLookupLocation = ts.isRootedDiskPath(failedLookupLocation) ? ts.normalizePath(failedLookupLocation) : ts.getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
                 var failedLookupPathSplit = failedLookupLocationPath.split(ts.directorySeparator);
                 var failedLookupSplit = failedLookupLocation.split(ts.directorySeparator);
-                ts.Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, "FailedLookup: " + failedLookupLocation + " failedLookupLocationPath: " + failedLookupLocationPath);
+                ts.Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, "FailedLookup: ".concat(failedLookupLocation, " failedLookupLocationPath: ").concat(failedLookupLocationPath));
                 if (failedLookupPathSplit.length > rootSplitLength + 1) {
                     // Instead of watching root, watch directory in root to avoid watching excluded directories not needed for module resolution
                     return {
@@ -120377,7 +120482,7 @@ var ts;
         }
         function getJSExtensionForFile(fileName, options) {
             var _a;
-            return (_a = tryGetJSExtensionForFile(fileName, options)) !== null && _a !== void 0 ? _a : ts.Debug.fail("Extension " + ts.extensionFromPath(fileName) + " is unsupported:: FileName:: " + fileName);
+            return (_a = tryGetJSExtensionForFile(fileName, options)) !== null && _a !== void 0 ? _a : ts.Debug.fail("Extension ".concat(ts.extensionFromPath(fileName), " is unsupported:: FileName:: ").concat(fileName));
         }
         function tryGetJSExtensionForFile(fileName, options) {
             var ext = ts.tryGetExtensionFromPath(fileName);
@@ -120480,8 +120585,8 @@ var ts;
         return pretty ?
             function (diagnostic, newLine, options) {
                 clearScreenIfNotWatchingForFileChanges(system, diagnostic, options);
-                var output = "[" + ts.formatColorAndReset(getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey) + "] ";
-                output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + (newLine + newLine);
+                var output = "[".concat(ts.formatColorAndReset(getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey), "] ");
+                output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(newLine + newLine);
                 system.write(output);
             } :
             function (diagnostic, newLine, options) {
@@ -120489,8 +120594,8 @@ var ts;
                 if (!clearScreenIfNotWatchingForFileChanges(system, diagnostic, options)) {
                     output += newLine;
                 }
-                output += getLocaleTimeString(system) + " - ";
-                output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + getPlainDiagnosticFollowingNewLines(diagnostic, newLine);
+                output += "".concat(getLocaleTimeString(system), " - ");
+                output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(getPlainDiagnosticFollowingNewLines(diagnostic, newLine));
                 system.write(output);
             };
     }
@@ -120513,7 +120618,7 @@ var ts;
             .map(function (errorDiagnostic) {
             if (errorDiagnostic.file === undefined)
                 return;
-            return "" + errorDiagnostic.file.fileName;
+            return "".concat(errorDiagnostic.file.fileName);
         });
         return filesInError.map(function (fileName) {
             var diagnosticForFileName = ts.find(diagnostics, function (diagnostic) {
@@ -120546,7 +120651,7 @@ var ts;
         if (errorCount === 0)
             return "";
         var nonNilFiles = filesInError.filter(function (fileInError) { return fileInError !== undefined; });
-        var distinctFileNamesWithLines = nonNilFiles.map(function (fileInError) { return fileInError.fileName + ":" + fileInError.line; })
+        var distinctFileNamesWithLines = nonNilFiles.map(function (fileInError) { return "".concat(fileInError.fileName, ":").concat(fileInError.line); })
             .filter(function (value, index, self) { return self.indexOf(value) === index; });
         var firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory());
         var d = errorCount === 1 ?
@@ -120559,7 +120664,7 @@ var ts;
                     ts.Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 :
                     ts.Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length);
         var suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "";
-        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + suffix;
+        return "".concat(newLine).concat(ts.flattenDiagnosticMessageText(d.messageText, newLine)).concat(newLine).concat(newLine).concat(suffix);
     }
     ts.getErrorSummaryText = getErrorSummaryText;
     function createTabularErrorsDisplay(filesInError, host) {
@@ -120582,7 +120687,7 @@ var ts;
                 " ".repeat(leftPaddingGoal - errorCountDigitsLength)
                 : "";
             var fileRef = prettyPathForFileError(file, host.getCurrentDirectory());
-            tabularData += "" + leftPadding + errorCount + "  " + fileRef + "\n";
+            tabularData += "".concat(leftPadding).concat(errorCount, "  ").concat(fileRef, "\n");
         });
         return tabularData;
     }
@@ -120609,9 +120714,9 @@ var ts;
         var relativeFileName = function (fileName) { return ts.convertToRelativePath(fileName, program.getCurrentDirectory(), getCanonicalFileName); };
         for (var _i = 0, _c = program.getSourceFiles(); _i < _c.length; _i++) {
             var file = _c[_i];
-            write("" + toFileName(file, relativeFileName));
-            (_a = reasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(function (reason) { return write("  " + fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText); });
-            (_b = explainIfFileIsRedirect(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write("  " + d.messageText); });
+            write("".concat(toFileName(file, relativeFileName)));
+            (_a = reasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(function (reason) { return write("  ".concat(fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText)); });
+            (_b = explainIfFileIsRedirect(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write("  ".concat(d.messageText)); });
         }
     }
     ts.explainFiles = explainFiles;
@@ -120651,7 +120756,7 @@ var ts;
             if (isJsonFile && !ts.endsWith(includeSpec, ".json" /* Json */))
                 return false;
             var pattern = ts.getPatternFromSpec(includeSpec, basePath, "files");
-            return !!pattern && ts.getRegexFromPattern("(" + pattern + ")$", useCaseSensitiveFileNames).test(fileName);
+            return !!pattern && ts.getRegexFromPattern("(".concat(pattern, ")$"), useCaseSensitiveFileNames).test(fileName);
         });
     }
     ts.getMatchedIncludeSpec = getMatchedIncludeSpec;
@@ -120660,7 +120765,7 @@ var ts;
         var options = program.getCompilerOptions();
         if (ts.isReferencedFile(reason)) {
             var referenceLocation = ts.getReferencedFileLocation(function (path) { return program.getSourceFileByPath(path); }, reason);
-            var referenceText = ts.isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : "\"" + referenceLocation.text + "\"";
+            var referenceText = ts.isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : "\"".concat(referenceLocation.text, "\"");
             var message = void 0;
             ts.Debug.assert(ts.isReferenceFileLocation(referenceLocation) || reason.kind === ts.FileIncludeKind.Import, "Only synthetic references are imports");
             switch (reason.kind) {
@@ -120784,7 +120889,7 @@ var ts;
             var currentDir_1 = program.getCurrentDirectory();
             ts.forEach(emittedFiles, function (file) {
                 var filepath = ts.getNormalizedAbsolutePath(file, currentDir_1);
-                write("TSFILE: " + filepath);
+                write("TSFILE: ".concat(filepath));
             });
             listFiles(program, write);
         }
@@ -121113,7 +121218,7 @@ var ts;
         }
         var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog;
         var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
-        writeLog("Current directory: " + currentDirectory + " CaseSensitiveFileNames: " + useCaseSensitiveFileNames);
+        writeLog("Current directory: ".concat(currentDirectory, " CaseSensitiveFileNames: ").concat(useCaseSensitiveFileNames));
         var configFileWatcher;
         if (configFileName) {
             configFileWatcher = watchFile(configFileName, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ConfigFile);
@@ -121269,10 +121374,10 @@ var ts;
         function createNewProgram(hasInvalidatedResolution) {
             // Compile the program
             writeLog("CreatingProgramWith::");
-            writeLog("  roots: " + JSON.stringify(rootFileNames));
-            writeLog("  options: " + JSON.stringify(compilerOptions));
+            writeLog("  roots: ".concat(JSON.stringify(rootFileNames)));
+            writeLog("  options: ".concat(JSON.stringify(compilerOptions)));
             if (projectReferences)
-                writeLog("  projectReferences: " + JSON.stringify(projectReferences));
+                writeLog("  projectReferences: ".concat(JSON.stringify(projectReferences)));
             var needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram();
             hasChangedCompilerOptions = false;
             hasChangedConfigFileParsingErrors = false;
@@ -121433,7 +121538,7 @@ var ts;
                 return resolutionCache.invalidateResolutionsOfFailedLookupLocations();
             }
             var pending = clearInvalidateResolutionsOfFailedLookupLocations();
-            writeLog("Scheduling invalidateFailedLookup" + (pending ? ", Cancelled earlier one" : ""));
+            writeLog("Scheduling invalidateFailedLookup".concat(pending ? ", Cancelled earlier one" : ""));
             timerToInvalidateFailedLookupResolutions = host.setTimeout(invalidateResolutionsOfFailedLookup, 250);
         }
         function invalidateResolutionsOfFailedLookup() {
@@ -121493,7 +121598,7 @@ var ts;
             synchronizeProgram();
         }
         function reloadConfigFile() {
-            writeLog("Reloading config file: " + configFileName);
+            writeLog("Reloading config file: ".concat(configFileName));
             reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             if (cachedDirectoryStructureHost) {
                 cachedDirectoryStructureHost.clearCache();
@@ -121534,7 +121639,7 @@ var ts;
                     return config.parsedCommandLine;
                 }
             }
-            writeLog("Loading config file: " + configFileName);
+            writeLog("Loading config file: ".concat(configFileName));
             var parsedCommandLine = host.getParsedCommandLine ?
                 host.getParsedCommandLine(configFileName) :
                 getParsedCommandLineFromConfigFileHost(configFileName);
@@ -121838,8 +121943,8 @@ var ts;
      */
     function createBuilderStatusReporter(system, pretty) {
         return function (diagnostic) {
-            var output = pretty ? "[" + ts.formatColorAndReset(ts.getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey) + "] " : ts.getLocaleTimeString(system) + " - ";
-            output += "" + ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine) + (system.newLine + system.newLine);
+            var output = pretty ? "[".concat(ts.formatColorAndReset(ts.getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey), "] ") : "".concat(ts.getLocaleTimeString(system), " - ");
+            output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(system.newLine + system.newLine);
             system.write(output);
         };
     }
@@ -122614,7 +122719,7 @@ var ts;
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
-            write("TSFILE: " + file);
+            write("TSFILE: ".concat(file));
         }
     }
     function getOldProgram(_a, proj, parsed) {
@@ -122643,7 +122748,7 @@ var ts;
     function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) {
         var canEmitBuildInfo = !(buildResult & BuildResultFlags.SyntaxErrors) && program && !ts.outFile(program.getCompilerOptions());
         reportAndStoreErrors(state, resolvedPath, diagnostics);
-        state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" });
+        state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: "".concat(errorType, " errors") });
         if (canEmitBuildInfo)
             return { buildResult: buildResult, step: BuildStep.EmitBuildInfo };
         afterProgramDone(state, program, config);
@@ -122671,7 +122776,7 @@ var ts;
             if (!host.fileExists(inputFile)) {
                 return {
                     type: ts.UpToDateStatusType.Unbuildable,
-                    reason: inputFile + " does not exist"
+                    reason: "".concat(inputFile, " does not exist")
                 };
             }
             if (!force) {
@@ -123030,7 +123135,7 @@ var ts;
             }
         }
         if (filesToDelete) {
-            reportStatus(state, ts.Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map(function (f) { return "\r\n * " + f; }).join(""));
+            reportStatus(state, ts.Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map(function (f) { return "\r\n * ".concat(f); }).join(""));
         }
         return ts.ExitStatus.Success;
     }
@@ -123368,7 +123473,7 @@ var ts;
         function nowString() {
             // E.g. "12:34:56.789"
             var d = new Date();
-            return ts.padLeft(d.getHours().toString(), 2, "0") + ":" + ts.padLeft(d.getMinutes().toString(), 2, "0") + ":" + ts.padLeft(d.getSeconds().toString(), 2, "0") + "." + ts.padLeft(d.getMilliseconds().toString(), 3, "0");
+            return "".concat(ts.padLeft(d.getHours().toString(), 2, "0"), ":").concat(ts.padLeft(d.getMinutes().toString(), 2, "0"), ":").concat(ts.padLeft(d.getSeconds().toString(), 2, "0"), ".").concat(ts.padLeft(d.getMilliseconds().toString(), 3, "0"));
         }
         server.nowString = nowString;
     })(server = ts.server || (ts.server = {}));
@@ -123379,7 +123484,7 @@ var ts;
     var JsTyping;
     (function (JsTyping) {
         function isTypingUpToDate(cachedTyping, availableTypingVersions) {
-            var availableVersion = new ts.Version(ts.getProperty(availableTypingVersions, "ts" + ts.versionMajorMinor) || ts.getProperty(availableTypingVersions, "latest"));
+            var availableVersion = new ts.Version(ts.getProperty(availableTypingVersions, "ts".concat(ts.versionMajorMinor)) || ts.getProperty(availableTypingVersions, "latest"));
             return availableVersion.compareTo(cachedTyping.version) <= 0;
         }
         JsTyping.isTypingUpToDate = isTypingUpToDate;
@@ -123432,7 +123537,7 @@ var ts;
             "worker_threads",
             "zlib"
         ];
-        JsTyping.prefixedNodeCoreModuleList = unprefixedNodeCoreModuleList.map(function (name) { return "node:" + name; });
+        JsTyping.prefixedNodeCoreModuleList = unprefixedNodeCoreModuleList.map(function (name) { return "node:".concat(name); });
         JsTyping.nodeCoreModuleList = __spreadArray(__spreadArray([], unprefixedNodeCoreModuleList, true), JsTyping.prefixedNodeCoreModuleList, true);
         JsTyping.nodeCoreModules = new ts.Set(JsTyping.nodeCoreModuleList);
         function nonRelativeModuleNameForTypingCache(moduleName) {
@@ -123505,7 +123610,7 @@ var ts;
                 var excludeTypingName = exclude_1[_i];
                 var didDelete = inferredTypings.delete(excludeTypingName);
                 if (didDelete && log)
-                    log("Typing for " + excludeTypingName + " is in exclude list, will be ignored.");
+                    log("Typing for ".concat(excludeTypingName, " is in exclude list, will be ignored."));
             }
             var newTypingNames = [];
             var cachedTypingPaths = [];
@@ -123519,7 +123624,7 @@ var ts;
             });
             var result = { cachedTypingPaths: cachedTypingPaths, newTypingNames: newTypingNames, filesToWatch: filesToWatch };
             if (log)
-                log("Result: " + JSON.stringify(result));
+                log("Result: ".concat(JSON.stringify(result)));
             return result;
             function addInferredTyping(typingName) {
                 if (!inferredTypings.has(typingName)) {
@@ -123528,7 +123633,7 @@ var ts;
             }
             function addInferredTypings(typingNames, message) {
                 if (log)
-                    log(message + ": " + JSON.stringify(typingNames));
+                    log("".concat(message, ": ").concat(JSON.stringify(typingNames)));
                 ts.forEach(typingNames, addInferredTyping);
             }
             /**
@@ -123550,7 +123655,7 @@ var ts;
                     filesToWatch.push(manifestPath);
                     manifest = ts.readConfigFile(manifestPath, function (path) { return host.readFile(path); }).config;
                     manifestTypingNames = ts.flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], ts.getOwnKeys);
-                    addInferredTypings(manifestTypingNames, "Typing names in '" + manifestPath + "' dependencies");
+                    addInferredTypings(manifestTypingNames, "Typing names in '".concat(manifestPath, "' dependencies"));
                 }
                 // Now we scan the directories for typing information in
                 // already-installed dependencies (if present). Note that this
@@ -123594,7 +123699,7 @@ var ts;
                             !isScoped && pathComponents[pathComponents.length - 3].toLowerCase() === modulesDirName; // `node_modules/foo`
                     });
                 if (log)
-                    log("Searching for typing names in " + packagesFolderPath + "; all files: " + JSON.stringify(dependencyManifestNames));
+                    log("Searching for typing names in ".concat(packagesFolderPath, "; all files: ").concat(JSON.stringify(dependencyManifestNames)));
                 // Once we have the names of things to look up, we iterate over
                 // and either collect their included typings, or add them to the
                 // list of typings we need to look up separately.
@@ -123613,12 +123718,12 @@ var ts;
                         var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName));
                         if (host.fileExists(absolutePath)) {
                             if (log)
-                                log("    Package '" + manifest_1.name + "' provides its own types.");
+                                log("    Package '".concat(manifest_1.name, "' provides its own types."));
                             inferredTypings.set(manifest_1.name, absolutePath);
                         }
                         else {
                             if (log)
-                                log("    Package '" + manifest_1.name + "' provides its own types but they are missing.");
+                                log("    Package '".concat(manifest_1.name, "' provides its own types but they are missing."));
                         }
                     }
                     else {
@@ -123714,15 +123819,15 @@ var ts;
             var kind = isScopeName ? "Scope" : "Package";
             switch (result) {
                 case 1 /* EmptyName */:
-                    return "'" + typing + "':: " + kind + " name '" + name + "' cannot be empty";
+                    return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot be empty");
                 case 2 /* NameTooLong */:
-                    return "'" + typing + "':: " + kind + " name '" + name + "' should be less than " + maxPackageNameLength + " characters";
+                    return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' should be less than ").concat(maxPackageNameLength, " characters");
                 case 3 /* NameStartsWithDot */:
-                    return "'" + typing + "':: " + kind + " name '" + name + "' cannot start with '.'";
+                    return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot start with '.'");
                 case 4 /* NameStartsWithUnderscore */:
-                    return "'" + typing + "':: " + kind + " name '" + name + "' cannot start with '_'";
+                    return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot start with '_'");
                 case 5 /* NameContainsNonURISafeCharacters */:
-                    return "'" + typing + "':: " + kind + " name '" + name + "' contains non URI safe characters";
+                    return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' contains non URI safe characters");
                 case 0 /* Ok */:
                     return ts.Debug.fail(); // Shouldn't have called this.
                 default:
@@ -123748,7 +123853,7 @@ var ts;
                 }
                 catch (e) {
                     if (log.isEnabled()) {
-                        log.writeLine("Failed to resolve " + packageName + " in folder '" + cachePath + "': " + e.message);
+                        log.writeLine("Failed to resolve ".concat(packageName, " in folder '").concat(cachePath, "': ").concat(e.message));
                     }
                     return undefined;
                 }
@@ -123769,7 +123874,7 @@ var ts;
                 var sliceStart = packageNames.length - remaining;
                 var command, toSlice = remaining;
                 while (true) {
-                    command = npmPath + " install --ignore-scripts " + (toSlice === packageNames.length ? packageNames : packageNames.slice(sliceStart, sliceStart + toSlice)).join(" ") + " --save-dev --user-agent=\"typesInstaller/" + tsVersion + "\"";
+                    command = "".concat(npmPath, " install --ignore-scripts ").concat((toSlice === packageNames.length ? packageNames : packageNames.slice(sliceStart, sliceStart + toSlice)).join(" "), " --save-dev --user-agent=\"typesInstaller/").concat(tsVersion, "\"");
                     if (command.length < 8000) {
                         break;
                     }
@@ -123796,12 +123901,12 @@ var ts;
                 ProjectWatcherType["DirectoryWatcher"] = "DirectoryWatcher";
             })(ProjectWatcherType || (ProjectWatcherType = {}));
             function getDetailWatchInfo(projectName, watchers) {
-                return "Project: " + projectName + " watcher already invoked: " + watchers.isInvoked;
+                return "Project: ".concat(projectName, " watcher already invoked: ").concat(watchers.isInvoked);
             }
             var TypingsInstaller = /** @class */ (function () {
                 function TypingsInstaller(installTypingHost, globalCachePath, safeListPath, typesMapLocation, throttleLimit, log) {
-                    var _this = this;
                     if (log === void 0) { log = nullLog; }
+                    var _this = this;
                     this.installTypingHost = installTypingHost;
                     this.globalCachePath = globalCachePath;
                     this.safeListPath = safeListPath;
@@ -123820,7 +123925,7 @@ var ts;
                     this.globalCachePackageJsonPath = ts.combinePaths(globalCachePath, "package.json");
                     var isLoggingEnabled = this.log.isEnabled();
                     if (isLoggingEnabled) {
-                        this.log.writeLine("Global cache location '" + globalCachePath + "', safe file path '" + safeListPath + "', types map path " + typesMapLocation);
+                        this.log.writeLine("Global cache location '".concat(globalCachePath, "', safe file path '").concat(safeListPath, "', types map path ").concat(typesMapLocation));
                     }
                     this.watchFactory = ts.getWatchFactory(this.installTypingHost, isLoggingEnabled ? ts.WatchLogLevel.Verbose : ts.WatchLogLevel.None, function (s) { return _this.log.writeLine(s); }, getDetailWatchInfo);
                     this.processCacheLocation(this.globalCachePath);
@@ -123830,30 +123935,30 @@ var ts;
                 };
                 TypingsInstaller.prototype.closeWatchers = function (projectName) {
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Closing file watchers for project '" + projectName + "'");
+                        this.log.writeLine("Closing file watchers for project '".concat(projectName, "'"));
                     }
                     var watchers = this.projectWatchers.get(projectName);
                     if (!watchers) {
                         if (this.log.isEnabled()) {
-                            this.log.writeLine("No watchers are registered for project '" + projectName + "'");
+                            this.log.writeLine("No watchers are registered for project '".concat(projectName, "'"));
                         }
                         return;
                     }
                     ts.clearMap(watchers, ts.closeFileWatcher);
                     this.projectWatchers.delete(projectName);
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Closing file watchers for project '" + projectName + "' - done.");
+                        this.log.writeLine("Closing file watchers for project '".concat(projectName, "' - done."));
                     }
                 };
                 TypingsInstaller.prototype.install = function (req) {
                     var _this = this;
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Got install request " + JSON.stringify(req));
+                        this.log.writeLine("Got install request ".concat(JSON.stringify(req)));
                     }
                     // load existing typing information from the cache
                     if (req.cachePath) {
                         if (this.log.isEnabled()) {
-                            this.log.writeLine("Request specifies cache path '" + req.cachePath + "', loading cached information...");
+                            this.log.writeLine("Request specifies cache path '".concat(req.cachePath, "', loading cached information..."));
                         }
                         this.processCacheLocation(req.cachePath);
                     }
@@ -123862,7 +123967,7 @@ var ts;
                     }
                     var discoverTypingsResult = ts.JsTyping.discoverTypings(this.installTypingHost, this.log.isEnabled() ? (function (s) { return _this.log.writeLine(s); }) : undefined, req.fileNames, req.projectRootPath, this.safeList, this.packageNameToTypingLocation, req.typeAcquisition, req.unresolvedImports, this.typesRegistry);
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Finished typings discovery: " + JSON.stringify(discoverTypingsResult));
+                        this.log.writeLine("Finished typings discovery: ".concat(JSON.stringify(discoverTypingsResult)));
                     }
                     // start watching files
                     this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch, req.projectRootPath, req.watchOptions);
@@ -123882,17 +123987,17 @@ var ts;
                     if (this.typesMapLocation) {
                         var safeListFromMap = ts.JsTyping.loadTypesMap(this.installTypingHost, this.typesMapLocation);
                         if (safeListFromMap) {
-                            this.log.writeLine("Loaded safelist from types map file '" + this.typesMapLocation + "'");
+                            this.log.writeLine("Loaded safelist from types map file '".concat(this.typesMapLocation, "'"));
                             this.safeList = safeListFromMap;
                             return;
                         }
-                        this.log.writeLine("Failed to load safelist from types map file '" + this.typesMapLocation + "'");
+                        this.log.writeLine("Failed to load safelist from types map file '".concat(this.typesMapLocation, "'"));
                     }
                     this.safeList = ts.JsTyping.loadSafeList(this.installTypingHost, this.safeListPath);
                 };
                 TypingsInstaller.prototype.processCacheLocation = function (cacheLocation) {
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Processing cache location '" + cacheLocation + "'");
+                        this.log.writeLine("Processing cache location '".concat(cacheLocation, "'"));
                     }
                     if (this.knownCachesSet.has(cacheLocation)) {
                         if (this.log.isEnabled()) {
@@ -123903,14 +124008,14 @@ var ts;
                     var packageJson = ts.combinePaths(cacheLocation, "package.json");
                     var packageLockJson = ts.combinePaths(cacheLocation, "package-lock.json");
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Trying to find '" + packageJson + "'...");
+                        this.log.writeLine("Trying to find '".concat(packageJson, "'..."));
                     }
                     if (this.installTypingHost.fileExists(packageJson) && this.installTypingHost.fileExists(packageLockJson)) {
                         var npmConfig = JSON.parse(this.installTypingHost.readFile(packageJson)); // TODO: GH#18217
                         var npmLock = JSON.parse(this.installTypingHost.readFile(packageLockJson)); // TODO: GH#18217
                         if (this.log.isEnabled()) {
-                            this.log.writeLine("Loaded content of '" + packageJson + "': " + JSON.stringify(npmConfig));
-                            this.log.writeLine("Loaded content of '" + packageLockJson + "'");
+                            this.log.writeLine("Loaded content of '".concat(packageJson, "': ").concat(JSON.stringify(npmConfig)));
+                            this.log.writeLine("Loaded content of '".concat(packageLockJson, "'"));
                         }
                         if (npmConfig.devDependencies && npmLock.dependencies) {
                             for (var key in npmConfig.devDependencies) {
@@ -123934,11 +124039,11 @@ var ts;
                                         continue;
                                     }
                                     if (this.log.isEnabled()) {
-                                        this.log.writeLine("New typing for package " + packageName + " from '" + typingFile + "' conflicts with existing typing file '" + existingTypingFile + "'");
+                                        this.log.writeLine("New typing for package ".concat(packageName, " from '").concat(typingFile, "' conflicts with existing typing file '").concat(existingTypingFile, "'"));
                                     }
                                 }
                                 if (this.log.isEnabled()) {
-                                    this.log.writeLine("Adding entry into typings cache: '" + packageName + "' => '" + typingFile + "'");
+                                    this.log.writeLine("Adding entry into typings cache: '".concat(packageName, "' => '").concat(typingFile, "'"));
                                 }
                                 var info = ts.getProperty(npmLock.dependencies, key);
                                 var version_1 = info && info.version;
@@ -123951,7 +124056,7 @@ var ts;
                         }
                     }
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Finished processing cache location '" + cacheLocation + "'");
+                        this.log.writeLine("Finished processing cache location '".concat(cacheLocation, "'"));
                     }
                     this.knownCachesSet.add(cacheLocation);
                 };
@@ -123961,7 +124066,7 @@ var ts;
                         var typingKey = ts.mangleScopedPackageName(typing);
                         if (_this.missingTypingsSet.has(typingKey)) {
                             if (_this.log.isEnabled())
-                                _this.log.writeLine("'" + typing + "':: '" + typingKey + "' is in missingTypingsSet - skipping...");
+                                _this.log.writeLine("'".concat(typing, "':: '").concat(typingKey, "' is in missingTypingsSet - skipping..."));
                             return undefined;
                         }
                         var validationResult = ts.JsTyping.validatePackageName(typing);
@@ -123974,12 +124079,12 @@ var ts;
                         }
                         if (!_this.typesRegistry.has(typingKey)) {
                             if (_this.log.isEnabled())
-                                _this.log.writeLine("'" + typing + "':: Entry for package '" + typingKey + "' does not exist in local types registry - skipping...");
+                                _this.log.writeLine("'".concat(typing, "':: Entry for package '").concat(typingKey, "' does not exist in local types registry - skipping..."));
                             return undefined;
                         }
                         if (_this.packageNameToTypingLocation.get(typingKey) && ts.JsTyping.isTypingUpToDate(_this.packageNameToTypingLocation.get(typingKey), _this.typesRegistry.get(typingKey))) {
                             if (_this.log.isEnabled())
-                                _this.log.writeLine("'" + typing + "':: '" + typingKey + "' already has an up-to-date typing - skipping...");
+                                _this.log.writeLine("'".concat(typing, "':: '").concat(typingKey, "' already has an up-to-date typing - skipping..."));
                             return undefined;
                         }
                         return typingKey;
@@ -123988,11 +124093,11 @@ var ts;
                 TypingsInstaller.prototype.ensurePackageDirectoryExists = function (directory) {
                     var npmConfigPath = ts.combinePaths(directory, "package.json");
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Npm config file: " + npmConfigPath);
+                        this.log.writeLine("Npm config file: ".concat(npmConfigPath));
                     }
                     if (!this.installTypingHost.fileExists(npmConfigPath)) {
                         if (this.log.isEnabled()) {
-                            this.log.writeLine("Npm config file: '" + npmConfigPath + "' is missing, creating new one...");
+                            this.log.writeLine("Npm config file: '".concat(npmConfigPath, "' is missing, creating new one..."));
                         }
                         this.ensureDirectoryExists(directory, this.installTypingHost);
                         this.installTypingHost.writeFile(npmConfigPath, '{ "private": true }');
@@ -124001,7 +124106,7 @@ var ts;
                 TypingsInstaller.prototype.installTypings = function (req, cachePath, currentlyCachedTypings, typingsToInstall) {
                     var _this = this;
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Installing typings " + JSON.stringify(typingsToInstall));
+                        this.log.writeLine("Installing typings ".concat(JSON.stringify(typingsToInstall)));
                     }
                     var filteredTypings = this.filterTypings(typingsToInstall);
                     if (filteredTypings.length === 0) {
@@ -124028,7 +124133,7 @@ var ts;
                         try {
                             if (!ok) {
                                 if (_this.log.isEnabled()) {
-                                    _this.log.writeLine("install request failed, marking packages as missing to prevent repeated requests: " + JSON.stringify(filteredTypings));
+                                    _this.log.writeLine("install request failed, marking packages as missing to prevent repeated requests: ".concat(JSON.stringify(filteredTypings)));
                                 }
                                 for (var _i = 0, filteredTypings_1 = filteredTypings; _i < filteredTypings_1.length; _i++) {
                                     var typing = filteredTypings_1[_i];
@@ -124038,7 +124143,7 @@ var ts;
                             }
                             // TODO: watch project directory
                             if (_this.log.isEnabled()) {
-                                _this.log.writeLine("Installed typings " + JSON.stringify(scopedTypings));
+                                _this.log.writeLine("Installed typings ".concat(JSON.stringify(scopedTypings)));
                             }
                             var installedTypingFiles = [];
                             for (var _a = 0, filteredTypings_2 = filteredTypings; _a < filteredTypings_2.length; _a++) {
@@ -124050,13 +124155,13 @@ var ts;
                                 }
                                 // packageName is guaranteed to exist in typesRegistry by filterTypings
                                 var distTags = _this.typesRegistry.get(packageName);
-                                var newVersion = new ts.Version(distTags["ts" + ts.versionMajorMinor] || distTags[_this.latestDistTag]);
+                                var newVersion = new ts.Version(distTags["ts".concat(ts.versionMajorMinor)] || distTags[_this.latestDistTag]);
                                 var newTyping = { typingLocation: typingFile, version: newVersion };
                                 _this.packageNameToTypingLocation.set(packageName, newTyping);
                                 installedTypingFiles.push(typingFile);
                             }
                             if (_this.log.isEnabled()) {
-                                _this.log.writeLine("Installed typing files " + JSON.stringify(installedTypingFiles));
+                                _this.log.writeLine("Installed typing files ".concat(JSON.stringify(installedTypingFiles)));
                             }
                             _this.sendResponse(_this.createSetTypings(req, currentlyCachedTypings.concat(installedTypingFiles)));
                         }
@@ -124110,7 +124215,7 @@ var ts;
                             return;
                         }
                         if (isLoggingEnabled) {
-                            _this.log.writeLine(projectWatcherType + ":: Added:: WatchInfo: " + path);
+                            _this.log.writeLine("".concat(projectWatcherType, ":: Added:: WatchInfo: ").concat(path));
                         }
                         var watcher = projectWatcherType === "FileWatcher" /* FileWatcher */ ?
                             _this.watchFactory.watchFile(path, function () {
@@ -124131,7 +124236,7 @@ var ts;
                             }, 1 /* Recursive */, options, projectName, watchers);
                         watchers.set(canonicalPath, isLoggingEnabled ? {
                             close: function () {
-                                _this.log.writeLine(projectWatcherType + ":: Closed:: WatchInfo: " + path);
+                                _this.log.writeLine("".concat(projectWatcherType, ":: Closed:: WatchInfo: ").concat(path));
                                 watcher.close();
                             }
                         } : watcher);
@@ -124206,7 +124311,7 @@ var ts;
             typingsInstaller.TypingsInstaller = TypingsInstaller;
             /* @internal */
             function typingsName(packageName) {
-                return "@types/" + packageName + "@ts" + ts.versionMajorMinor;
+                return "@types/".concat(packageName, "@ts").concat(ts.versionMajorMinor);
             }
             typingsInstaller.typingsName = typingsName;
         })(typingsInstaller = server.typingsInstaller || (server.typingsInstaller = {}));
@@ -124231,7 +124336,7 @@ var ts;
                         if (typeof _this.logFile !== "string")
                             return;
                         try {
-                            fs.appendFileSync(_this.logFile, "[" + server.nowString() + "] " + text + ts.sys.newLine);
+                            fs.appendFileSync(_this.logFile, "[".concat(server.nowString(), "] ").concat(text).concat(ts.sys.newLine));
                         }
                         catch (e) {
                             _this.logFile = undefined;
@@ -124247,7 +124352,7 @@ var ts;
                         return npmPath;
                     }
                     if (host.fileExists(npmPath)) {
-                        return "\"" + npmPath + "\"";
+                        return "\"".concat(npmPath, "\"");
                     }
                 }
                 return "npm";
@@ -124255,7 +124360,7 @@ var ts;
             function loadTypesRegistryFile(typesRegistryFilePath, host, log) {
                 if (!host.fileExists(typesRegistryFilePath)) {
                     if (log.isEnabled()) {
-                        log.writeLine("Types registry file '" + typesRegistryFilePath + "' does not exist");
+                        log.writeLine("Types registry file '".concat(typesRegistryFilePath, "' does not exist"));
                     }
                     return new ts.Map();
                 }
@@ -124265,14 +124370,14 @@ var ts;
                 }
                 catch (e) {
                     if (log.isEnabled()) {
-                        log.writeLine("Error when loading types registry file '" + typesRegistryFilePath + "': " + e.message + ", " + e.stack);
+                        log.writeLine("Error when loading types registry file '".concat(typesRegistryFilePath, "': ").concat(e.message, ", ").concat(e.stack));
                     }
                     return new ts.Map();
                 }
             }
             var typesRegistryPackageName = "types-registry";
             function getTypesRegistryFileLocation(globalTypingsCacheLocation) {
-                return ts.combinePaths(ts.normalizeSlashes(globalTypingsCacheLocation), "node_modules/" + typesRegistryPackageName + "/index.json");
+                return ts.combinePaths(ts.normalizeSlashes(globalTypingsCacheLocation), "node_modules/".concat(typesRegistryPackageName, "/index.json"));
             }
             var NodeTypingsInstaller = (function (_super) {
                 __extends(NodeTypingsInstaller, _super);
@@ -124280,27 +124385,27 @@ var ts;
                     var _this = _super.call(this, ts.sys, globalTypingsCacheLocation, typingSafeListLocation ? ts.toPath(typingSafeListLocation, "", ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)) : ts.toPath("typingSafeList.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), typesMapLocation ? ts.toPath(typesMapLocation, "", ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)) : ts.toPath("typesMap.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), throttleLimit, log) || this;
                     _this.npmPath = npmLocation !== undefined ? npmLocation : getDefaultNPMLocation(process.argv[0], validateDefaultNpmLocation, _this.installTypingHost);
                     if (ts.stringContains(_this.npmPath, " ") && _this.npmPath[0] !== "\"") {
-                        _this.npmPath = "\"" + _this.npmPath + "\"";
+                        _this.npmPath = "\"".concat(_this.npmPath, "\"");
                     }
                     if (_this.log.isEnabled()) {
-                        _this.log.writeLine("Process id: " + process.pid);
-                        _this.log.writeLine("NPM location: " + _this.npmPath + " (explicit '" + server.Arguments.NpmLocation + "' " + (npmLocation === undefined ? "not " : "") + " provided)");
-                        _this.log.writeLine("validateDefaultNpmLocation: " + validateDefaultNpmLocation);
+                        _this.log.writeLine("Process id: ".concat(process.pid));
+                        _this.log.writeLine("NPM location: ".concat(_this.npmPath, " (explicit '").concat(server.Arguments.NpmLocation, "' ").concat(npmLocation === undefined ? "not " : "", " provided)"));
+                        _this.log.writeLine("validateDefaultNpmLocation: ".concat(validateDefaultNpmLocation));
                     }
                     (_this.nodeExecSync = require("child_process").execSync);
                     _this.ensurePackageDirectoryExists(globalTypingsCacheLocation);
                     try {
                         if (_this.log.isEnabled()) {
-                            _this.log.writeLine("Updating " + typesRegistryPackageName + " npm package...");
+                            _this.log.writeLine("Updating ".concat(typesRegistryPackageName, " npm package..."));
                         }
-                        _this.execSyncAndLog(_this.npmPath + " install --ignore-scripts " + typesRegistryPackageName + "@" + _this.latestDistTag, { cwd: globalTypingsCacheLocation });
+                        _this.execSyncAndLog("".concat(_this.npmPath, " install --ignore-scripts ").concat(typesRegistryPackageName, "@").concat(_this.latestDistTag), { cwd: globalTypingsCacheLocation });
                         if (_this.log.isEnabled()) {
-                            _this.log.writeLine("Updated " + typesRegistryPackageName + " npm package");
+                            _this.log.writeLine("Updated ".concat(typesRegistryPackageName, " npm package"));
                         }
                     }
                     catch (e) {
                         if (_this.log.isEnabled()) {
-                            _this.log.writeLine("Error updating " + typesRegistryPackageName + " package: " + e.message);
+                            _this.log.writeLine("Error updating ".concat(typesRegistryPackageName, " package: ").concat(e.message));
                         }
                         _this.delayedInitializationError = {
                             kind: "event::initializationFailed",
@@ -124339,7 +124444,7 @@ var ts;
                                 var cwd = getDirectoryOfPackageJson(fileName, _this.installTypingHost) || projectRootPath;
                                 if (cwd) {
                                     _this.installWorker(-1, [packageName_1], cwd, function (success) {
-                                        var message = success ? "Package " + packageName_1 + " installed." : "There was an error installing " + packageName_1 + ".";
+                                        var message = success ? "Package ".concat(packageName_1, " installed.") : "There was an error installing ".concat(packageName_1, ".");
                                         var response = { kind: server.ActionPackageInstalled, projectName: projectName_1, success: success, message: message };
                                         _this.sendResponse(response);
                                     });
@@ -124357,7 +124462,7 @@ var ts;
                 };
                 NodeTypingsInstaller.prototype.sendResponse = function (response) {
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Sending response:\n    " + JSON.stringify(response));
+                        this.log.writeLine("Sending response:\n    ".concat(JSON.stringify(response)));
                     }
                     process.send(response);
                     if (this.log.isEnabled()) {
@@ -124367,29 +124472,29 @@ var ts;
                 NodeTypingsInstaller.prototype.installWorker = function (requestId, packageNames, cwd, onRequestCompleted) {
                     var _this = this;
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("#" + requestId + " with arguments'" + JSON.stringify(packageNames) + "'.");
+                        this.log.writeLine("#".concat(requestId, " with arguments'").concat(JSON.stringify(packageNames), "'."));
                     }
                     var start = Date.now();
                     var hasError = typingsInstaller.installNpmPackages(this.npmPath, ts.version, packageNames, function (command) { return _this.execSyncAndLog(command, { cwd: cwd }); });
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("npm install #" + requestId + " took: " + (Date.now() - start) + " ms");
+                        this.log.writeLine("npm install #".concat(requestId, " took: ").concat(Date.now() - start, " ms"));
                     }
                     onRequestCompleted(!hasError);
                 };
                 NodeTypingsInstaller.prototype.execSyncAndLog = function (command, options) {
                     if (this.log.isEnabled()) {
-                        this.log.writeLine("Exec: " + command);
+                        this.log.writeLine("Exec: ".concat(command));
                     }
                     try {
                         var stdout = this.nodeExecSync(command, __assign(__assign({}, options), { encoding: "utf-8" }));
                         if (this.log.isEnabled()) {
-                            this.log.writeLine("    Succeeded. stdout:" + indent(ts.sys.newLine, stdout));
+                            this.log.writeLine("    Succeeded. stdout:".concat(indent(ts.sys.newLine, stdout)));
                         }
                         return false;
                     }
                     catch (error) {
                         var stdout = error.stdout, stderr = error.stderr;
-                        this.log.writeLine("    Failed. stdout:" + indent(ts.sys.newLine, stdout) + ts.sys.newLine + "    stderr:" + indent(ts.sys.newLine, stderr));
+                        this.log.writeLine("    Failed. stdout:".concat(indent(ts.sys.newLine, stdout)).concat(ts.sys.newLine, "    stderr:").concat(indent(ts.sys.newLine, stderr)));
                         return true;
                     }
                 };
@@ -124412,7 +124517,7 @@ var ts;
             var log = new FileLog(logFilePath);
             if (log.isEnabled()) {
                 process.on("uncaughtException", function (e) {
-                    log.writeLine("Unhandled exception: " + e + " at " + e.stack);
+                    log.writeLine("Unhandled exception: ".concat(e, " at ").concat(e.stack));
                 });
             }
             process.on("disconnect", function () {
@@ -124425,7 +124530,7 @@ var ts;
             installer.listen();
             function indent(newline, str) {
                 return str && str.length
-                    ? newline + "    " + str.replace(/\r?\n/, newline + "    ")
+                    ? "".concat(newline, "    ") + str.replace(/\r?\n/, "".concat(newline, "    "))
                     : "";
             }
         })(typingsInstaller = server.typingsInstaller || (server.typingsInstaller = {}));