typescript 4.6.0-dev.20220130 → 4.6.0-dev.20220203

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.6";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220130";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220203";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -3343,491 +3343,6 @@ var ts;
     };
 })(ts || (ts = {}));
 var ts;
-(function (ts) {
-    ts.directorySeparator = "/";
-    ts.altDirectorySeparator = "\\";
-    var urlSchemeSeparator = "://";
-    var backslashRegExp = /\\/g;
-    function isAnyDirectorySeparator(charCode) {
-        return charCode === 47 || charCode === 92;
-    }
-    ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
-    function isUrl(path) {
-        return getEncodedRootLength(path) < 0;
-    }
-    ts.isUrl = isUrl;
-    function isRootedDiskPath(path) {
-        return getEncodedRootLength(path) > 0;
-    }
-    ts.isRootedDiskPath = isRootedDiskPath;
-    function isDiskPathRoot(path) {
-        var rootLength = getEncodedRootLength(path);
-        return rootLength > 0 && rootLength === path.length;
-    }
-    ts.isDiskPathRoot = isDiskPathRoot;
-    function pathIsAbsolute(path) {
-        return getEncodedRootLength(path) !== 0;
-    }
-    ts.pathIsAbsolute = pathIsAbsolute;
-    function pathIsRelative(path) {
-        return /^\.\.?($|[\\/])/.test(path);
-    }
-    ts.pathIsRelative = pathIsRelative;
-    function pathIsBareSpecifier(path) {
-        return !pathIsAbsolute(path) && !pathIsRelative(path);
-    }
-    ts.pathIsBareSpecifier = pathIsBareSpecifier;
-    function hasExtension(fileName) {
-        return ts.stringContains(getBaseFileName(fileName), ".");
-    }
-    ts.hasExtension = hasExtension;
-    function fileExtensionIs(path, extension) {
-        return path.length > extension.length && ts.endsWith(path, extension);
-    }
-    ts.fileExtensionIs = fileExtensionIs;
-    function fileExtensionIsOneOf(path, extensions) {
-        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
-            var extension = extensions_1[_i];
-            if (fileExtensionIs(path, extension)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    ts.fileExtensionIsOneOf = fileExtensionIsOneOf;
-    function hasTrailingDirectorySeparator(path) {
-        return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
-    }
-    ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
-    function isVolumeCharacter(charCode) {
-        return (charCode >= 97 && charCode <= 122) ||
-            (charCode >= 65 && charCode <= 90);
-    }
-    function getFileUrlVolumeSeparatorEnd(url, start) {
-        var ch0 = url.charCodeAt(start);
-        if (ch0 === 58)
-            return start + 1;
-        if (ch0 === 37 && url.charCodeAt(start + 1) === 51) {
-            var ch2 = url.charCodeAt(start + 2);
-            if (ch2 === 97 || ch2 === 65)
-                return start + 3;
-        }
-        return -1;
-    }
-    function getEncodedRootLength(path) {
-        if (!path)
-            return 0;
-        var ch0 = path.charCodeAt(0);
-        if (ch0 === 47 || ch0 === 92) {
-            if (path.charCodeAt(1) !== ch0)
-                return 1;
-            var p1 = path.indexOf(ch0 === 47 ? ts.directorySeparator : ts.altDirectorySeparator, 2);
-            if (p1 < 0)
-                return path.length;
-            return p1 + 1;
-        }
-        if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) {
-            var ch2 = path.charCodeAt(2);
-            if (ch2 === 47 || ch2 === 92)
-                return 3;
-            if (path.length === 2)
-                return 2;
-        }
-        var schemeEnd = path.indexOf(urlSchemeSeparator);
-        if (schemeEnd !== -1) {
-            var authorityStart = schemeEnd + urlSchemeSeparator.length;
-            var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
-            if (authorityEnd !== -1) {
-                var scheme = path.slice(0, schemeEnd);
-                var authority = path.slice(authorityStart, authorityEnd);
-                if (scheme === "file" && (authority === "" || authority === "localhost") &&
-                    isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
-                    var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
-                    if (volumeSeparatorEnd !== -1) {
-                        if (path.charCodeAt(volumeSeparatorEnd) === 47) {
-                            return ~(volumeSeparatorEnd + 1);
-                        }
-                        if (volumeSeparatorEnd === path.length) {
-                            return ~volumeSeparatorEnd;
-                        }
-                    }
-                }
-                return ~(authorityEnd + 1);
-            }
-            return ~path.length;
-        }
-        return 0;
-    }
-    function getRootLength(path) {
-        var rootLength = getEncodedRootLength(path);
-        return rootLength < 0 ? ~rootLength : rootLength;
-    }
-    ts.getRootLength = getRootLength;
-    function getDirectoryPath(path) {
-        path = normalizeSlashes(path);
-        var rootLength = getRootLength(path);
-        if (rootLength === path.length)
-            return path;
-        path = removeTrailingDirectorySeparator(path);
-        return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator)));
-    }
-    ts.getDirectoryPath = getDirectoryPath;
-    function getBaseFileName(path, extensions, ignoreCase) {
-        path = normalizeSlashes(path);
-        var rootLength = getRootLength(path);
-        if (rootLength === path.length)
-            return "";
-        path = removeTrailingDirectorySeparator(path);
-        var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1));
-        var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
-        return extension ? name.slice(0, name.length - extension.length) : name;
-    }
-    ts.getBaseFileName = getBaseFileName;
-    function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
-        if (!ts.startsWith(extension, "."))
-            extension = "." + extension;
-        if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) {
-            var pathExtension = path.slice(path.length - extension.length);
-            if (stringEqualityComparer(pathExtension, extension)) {
-                return pathExtension;
-            }
-        }
-    }
-    function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
-        if (typeof extensions === "string") {
-            return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
-        }
-        for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) {
-            var extension = extensions_2[_i];
-            var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
-            if (result)
-                return result;
-        }
-        return "";
-    }
-    function getAnyExtensionFromPath(path, extensions, ignoreCase) {
-        if (extensions) {
-            return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive);
-        }
-        var baseFileName = getBaseFileName(path);
-        var extensionIndex = baseFileName.lastIndexOf(".");
-        if (extensionIndex >= 0) {
-            return baseFileName.substring(extensionIndex);
-        }
-        return "";
-    }
-    ts.getAnyExtensionFromPath = getAnyExtensionFromPath;
-    function pathComponents(path, rootLength) {
-        var root = path.substring(0, rootLength);
-        var rest = path.substring(rootLength).split(ts.directorySeparator);
-        if (rest.length && !ts.lastOrUndefined(rest))
-            rest.pop();
-        return __spreadArray([root], rest, true);
-    }
-    function getPathComponents(path, currentDirectory) {
-        if (currentDirectory === void 0) { currentDirectory = ""; }
-        path = combinePaths(currentDirectory, path);
-        return pathComponents(path, getRootLength(path));
-    }
-    ts.getPathComponents = getPathComponents;
-    function getPathFromPathComponents(pathComponents) {
-        if (pathComponents.length === 0)
-            return "";
-        var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
-        return root + pathComponents.slice(1).join(ts.directorySeparator);
-    }
-    ts.getPathFromPathComponents = getPathFromPathComponents;
-    function normalizeSlashes(path) {
-        var index = path.indexOf("\\");
-        if (index === -1) {
-            return path;
-        }
-        backslashRegExp.lastIndex = index;
-        return path.replace(backslashRegExp, ts.directorySeparator);
-    }
-    ts.normalizeSlashes = normalizeSlashes;
-    function reducePathComponents(components) {
-        if (!ts.some(components))
-            return [];
-        var reduced = [components[0]];
-        for (var i = 1; i < components.length; i++) {
-            var component = components[i];
-            if (!component)
-                continue;
-            if (component === ".")
-                continue;
-            if (component === "..") {
-                if (reduced.length > 1) {
-                    if (reduced[reduced.length - 1] !== "..") {
-                        reduced.pop();
-                        continue;
-                    }
-                }
-                else if (reduced[0])
-                    continue;
-            }
-            reduced.push(component);
-        }
-        return reduced;
-    }
-    ts.reducePathComponents = reducePathComponents;
-    function combinePaths(path) {
-        var paths = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            paths[_i - 1] = arguments[_i];
-        }
-        if (path)
-            path = normalizeSlashes(path);
-        for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
-            var relativePath = paths_1[_a];
-            if (!relativePath)
-                continue;
-            relativePath = normalizeSlashes(relativePath);
-            if (!path || getRootLength(relativePath) !== 0) {
-                path = relativePath;
-            }
-            else {
-                path = ensureTrailingDirectorySeparator(path) + relativePath;
-            }
-        }
-        return path;
-    }
-    ts.combinePaths = combinePaths;
-    function resolvePath(path) {
-        var paths = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            paths[_i - 1] = arguments[_i];
-        }
-        return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArray([path], paths, false)) : normalizeSlashes(path));
-    }
-    ts.resolvePath = resolvePath;
-    function getNormalizedPathComponents(path, currentDirectory) {
-        return reducePathComponents(getPathComponents(path, currentDirectory));
-    }
-    ts.getNormalizedPathComponents = getNormalizedPathComponents;
-    function getNormalizedAbsolutePath(fileName, currentDirectory) {
-        return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
-    }
-    ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath;
-    function normalizePath(path) {
-        path = normalizeSlashes(path);
-        if (!relativePathSegmentRegExp.test(path)) {
-            return path;
-        }
-        var simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
-        if (simplified !== path) {
-            path = simplified;
-            if (!relativePathSegmentRegExp.test(path)) {
-                return path;
-            }
-        }
-        var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
-        return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
-    }
-    ts.normalizePath = normalizePath;
-    function getPathWithoutRoot(pathComponents) {
-        if (pathComponents.length === 0)
-            return "";
-        return pathComponents.slice(1).join(ts.directorySeparator);
-    }
-    function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
-        return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
-    }
-    ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot;
-    function toPath(fileName, basePath, getCanonicalFileName) {
-        var nonCanonicalizedPath = isRootedDiskPath(fileName)
-            ? normalizePath(fileName)
-            : getNormalizedAbsolutePath(fileName, basePath);
-        return getCanonicalFileName(nonCanonicalizedPath);
-    }
-    ts.toPath = toPath;
-    function normalizePathAndParts(path) {
-        path = normalizeSlashes(path);
-        var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1);
-        if (parts.length) {
-            var joinedParts = root + parts.join(ts.directorySeparator);
-            return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts };
-        }
-        else {
-            return { path: root, parts: parts };
-        }
-    }
-    ts.normalizePathAndParts = normalizePathAndParts;
-    function removeTrailingDirectorySeparator(path) {
-        if (hasTrailingDirectorySeparator(path)) {
-            return path.substr(0, path.length - 1);
-        }
-        return path;
-    }
-    ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
-    function ensureTrailingDirectorySeparator(path) {
-        if (!hasTrailingDirectorySeparator(path)) {
-            return path + ts.directorySeparator;
-        }
-        return path;
-    }
-    ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
-    function ensurePathIsNonModuleName(path) {
-        return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
-    }
-    ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName;
-    function changeAnyExtension(path, ext, extensions, ignoreCase) {
-        var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
-        return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path;
-    }
-    ts.changeAnyExtension = changeAnyExtension;
-    var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
-    function comparePathsWorker(a, b, componentComparer) {
-        if (a === b)
-            return 0;
-        if (a === undefined)
-            return -1;
-        if (b === undefined)
-            return 1;
-        var aRoot = a.substring(0, getRootLength(a));
-        var bRoot = b.substring(0, getRootLength(b));
-        var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
-        if (result !== 0) {
-            return result;
-        }
-        var aRest = a.substring(aRoot.length);
-        var bRest = b.substring(bRoot.length);
-        if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
-            return componentComparer(aRest, bRest);
-        }
-        var aComponents = reducePathComponents(getPathComponents(a));
-        var bComponents = reducePathComponents(getPathComponents(b));
-        var sharedLength = Math.min(aComponents.length, bComponents.length);
-        for (var i = 1; i < sharedLength; i++) {
-            var result_2 = componentComparer(aComponents[i], bComponents[i]);
-            if (result_2 !== 0) {
-                return result_2;
-            }
-        }
-        return ts.compareValues(aComponents.length, bComponents.length);
-    }
-    function comparePathsCaseSensitive(a, b) {
-        return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
-    }
-    ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
-    function comparePathsCaseInsensitive(a, b) {
-        return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive);
-    }
-    ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive;
-    function comparePaths(a, b, currentDirectory, ignoreCase) {
-        if (typeof currentDirectory === "string") {
-            a = combinePaths(currentDirectory, a);
-            b = combinePaths(currentDirectory, b);
-        }
-        else if (typeof currentDirectory === "boolean") {
-            ignoreCase = currentDirectory;
-        }
-        return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase));
-    }
-    ts.comparePaths = comparePaths;
-    function containsPath(parent, child, currentDirectory, ignoreCase) {
-        if (typeof currentDirectory === "string") {
-            parent = combinePaths(currentDirectory, parent);
-            child = combinePaths(currentDirectory, child);
-        }
-        else if (typeof currentDirectory === "boolean") {
-            ignoreCase = currentDirectory;
-        }
-        if (parent === undefined || child === undefined)
-            return false;
-        if (parent === child)
-            return true;
-        var parentComponents = reducePathComponents(getPathComponents(parent));
-        var childComponents = reducePathComponents(getPathComponents(child));
-        if (childComponents.length < parentComponents.length) {
-            return false;
-        }
-        var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive;
-        for (var i = 0; i < parentComponents.length; i++) {
-            var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer;
-            if (!equalityComparer(parentComponents[i], childComponents[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    ts.containsPath = containsPath;
-    function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
-        var canonicalFileName = getCanonicalFileName(fileName);
-        var canonicalDirectoryName = getCanonicalFileName(directoryName);
-        return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\");
-    }
-    ts.startsWithDirectory = startsWithDirectory;
-    function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
-        var fromComponents = reducePathComponents(getPathComponents(from));
-        var toComponents = reducePathComponents(getPathComponents(to));
-        var start;
-        for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
-            var fromComponent = getCanonicalFileName(fromComponents[start]);
-            var toComponent = getCanonicalFileName(toComponents[start]);
-            var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer;
-            if (!comparer(fromComponent, toComponent))
-                break;
-        }
-        if (start === 0) {
-            return toComponents;
-        }
-        var components = toComponents.slice(start);
-        var relative = [];
-        for (; start < fromComponents.length; start++) {
-            relative.push("..");
-        }
-        return __spreadArray(__spreadArray([""], relative, true), components, true);
-    }
-    ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo;
-    function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
-        ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative");
-        var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity;
-        var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
-        var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName);
-        return getPathFromPathComponents(pathComponents);
-    }
-    ts.getRelativePathFromDirectory = getRelativePathFromDirectory;
-    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
-        return !isRootedDiskPath(absoluteOrRelativePath)
-            ? absoluteOrRelativePath
-            : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
-    }
-    ts.convertToRelativePath = convertToRelativePath;
-    function getRelativePathFromFile(from, to, getCanonicalFileName) {
-        return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
-    }
-    ts.getRelativePathFromFile = getRelativePathFromFile;
-    function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
-        var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName);
-        var firstComponent = pathComponents[0];
-        if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
-            var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///";
-            pathComponents[0] = prefix + firstComponent;
-        }
-        return getPathFromPathComponents(pathComponents);
-    }
-    ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl;
-    function forEachAncestorDirectory(directory, callback) {
-        while (true) {
-            var result = callback(directory);
-            if (result !== undefined) {
-                return result;
-            }
-            var parentPath = getDirectoryPath(directory);
-            if (parentPath === directory) {
-                return undefined;
-            }
-            directory = parentPath;
-        }
-    }
-    ts.forEachAncestorDirectory = forEachAncestorDirectory;
-    function isNodeModulesDirectory(dirPath) {
-        return ts.endsWith(dirPath, "/node_modules");
-    }
-    ts.isNodeModulesDirectory = isNodeModulesDirectory;
-})(ts || (ts = {}));
-var ts;
 (function (ts) {
     function generateDjb2Hash(data) {
         var acc = 5381;
@@ -5072,6 +4587,491 @@ var ts;
     }
 })(ts || (ts = {}));
 var ts;
+(function (ts) {
+    ts.directorySeparator = "/";
+    ts.altDirectorySeparator = "\\";
+    var urlSchemeSeparator = "://";
+    var backslashRegExp = /\\/g;
+    function isAnyDirectorySeparator(charCode) {
+        return charCode === 47 || charCode === 92;
+    }
+    ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
+    function isUrl(path) {
+        return getEncodedRootLength(path) < 0;
+    }
+    ts.isUrl = isUrl;
+    function isRootedDiskPath(path) {
+        return getEncodedRootLength(path) > 0;
+    }
+    ts.isRootedDiskPath = isRootedDiskPath;
+    function isDiskPathRoot(path) {
+        var rootLength = getEncodedRootLength(path);
+        return rootLength > 0 && rootLength === path.length;
+    }
+    ts.isDiskPathRoot = isDiskPathRoot;
+    function pathIsAbsolute(path) {
+        return getEncodedRootLength(path) !== 0;
+    }
+    ts.pathIsAbsolute = pathIsAbsolute;
+    function pathIsRelative(path) {
+        return /^\.\.?($|[\\/])/.test(path);
+    }
+    ts.pathIsRelative = pathIsRelative;
+    function pathIsBareSpecifier(path) {
+        return !pathIsAbsolute(path) && !pathIsRelative(path);
+    }
+    ts.pathIsBareSpecifier = pathIsBareSpecifier;
+    function hasExtension(fileName) {
+        return ts.stringContains(getBaseFileName(fileName), ".");
+    }
+    ts.hasExtension = hasExtension;
+    function fileExtensionIs(path, extension) {
+        return path.length > extension.length && ts.endsWith(path, extension);
+    }
+    ts.fileExtensionIs = fileExtensionIs;
+    function fileExtensionIsOneOf(path, extensions) {
+        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
+            var extension = extensions_1[_i];
+            if (fileExtensionIs(path, extension)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    ts.fileExtensionIsOneOf = fileExtensionIsOneOf;
+    function hasTrailingDirectorySeparator(path) {
+        return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+    }
+    ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
+    function isVolumeCharacter(charCode) {
+        return (charCode >= 97 && charCode <= 122) ||
+            (charCode >= 65 && charCode <= 90);
+    }
+    function getFileUrlVolumeSeparatorEnd(url, start) {
+        var ch0 = url.charCodeAt(start);
+        if (ch0 === 58)
+            return start + 1;
+        if (ch0 === 37 && url.charCodeAt(start + 1) === 51) {
+            var ch2 = url.charCodeAt(start + 2);
+            if (ch2 === 97 || ch2 === 65)
+                return start + 3;
+        }
+        return -1;
+    }
+    function getEncodedRootLength(path) {
+        if (!path)
+            return 0;
+        var ch0 = path.charCodeAt(0);
+        if (ch0 === 47 || ch0 === 92) {
+            if (path.charCodeAt(1) !== ch0)
+                return 1;
+            var p1 = path.indexOf(ch0 === 47 ? ts.directorySeparator : ts.altDirectorySeparator, 2);
+            if (p1 < 0)
+                return path.length;
+            return p1 + 1;
+        }
+        if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) {
+            var ch2 = path.charCodeAt(2);
+            if (ch2 === 47 || ch2 === 92)
+                return 3;
+            if (path.length === 2)
+                return 2;
+        }
+        var schemeEnd = path.indexOf(urlSchemeSeparator);
+        if (schemeEnd !== -1) {
+            var authorityStart = schemeEnd + urlSchemeSeparator.length;
+            var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
+            if (authorityEnd !== -1) {
+                var scheme = path.slice(0, schemeEnd);
+                var authority = path.slice(authorityStart, authorityEnd);
+                if (scheme === "file" && (authority === "" || authority === "localhost") &&
+                    isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+                    var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+                    if (volumeSeparatorEnd !== -1) {
+                        if (path.charCodeAt(volumeSeparatorEnd) === 47) {
+                            return ~(volumeSeparatorEnd + 1);
+                        }
+                        if (volumeSeparatorEnd === path.length) {
+                            return ~volumeSeparatorEnd;
+                        }
+                    }
+                }
+                return ~(authorityEnd + 1);
+            }
+            return ~path.length;
+        }
+        return 0;
+    }
+    function getRootLength(path) {
+        var rootLength = getEncodedRootLength(path);
+        return rootLength < 0 ? ~rootLength : rootLength;
+    }
+    ts.getRootLength = getRootLength;
+    function getDirectoryPath(path) {
+        path = normalizeSlashes(path);
+        var rootLength = getRootLength(path);
+        if (rootLength === path.length)
+            return path;
+        path = removeTrailingDirectorySeparator(path);
+        return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator)));
+    }
+    ts.getDirectoryPath = getDirectoryPath;
+    function getBaseFileName(path, extensions, ignoreCase) {
+        path = normalizeSlashes(path);
+        var rootLength = getRootLength(path);
+        if (rootLength === path.length)
+            return "";
+        path = removeTrailingDirectorySeparator(path);
+        var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1));
+        var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
+        return extension ? name.slice(0, name.length - extension.length) : name;
+    }
+    ts.getBaseFileName = getBaseFileName;
+    function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+        if (!ts.startsWith(extension, "."))
+            extension = "." + extension;
+        if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) {
+            var pathExtension = path.slice(path.length - extension.length);
+            if (stringEqualityComparer(pathExtension, extension)) {
+                return pathExtension;
+            }
+        }
+    }
+    function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
+        if (typeof extensions === "string") {
+            return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
+        }
+        for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) {
+            var extension = extensions_2[_i];
+            var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
+            if (result)
+                return result;
+        }
+        return "";
+    }
+    function getAnyExtensionFromPath(path, extensions, ignoreCase) {
+        if (extensions) {
+            return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive);
+        }
+        var baseFileName = getBaseFileName(path);
+        var extensionIndex = baseFileName.lastIndexOf(".");
+        if (extensionIndex >= 0) {
+            return baseFileName.substring(extensionIndex);
+        }
+        return "";
+    }
+    ts.getAnyExtensionFromPath = getAnyExtensionFromPath;
+    function pathComponents(path, rootLength) {
+        var root = path.substring(0, rootLength);
+        var rest = path.substring(rootLength).split(ts.directorySeparator);
+        if (rest.length && !ts.lastOrUndefined(rest))
+            rest.pop();
+        return __spreadArray([root], rest, true);
+    }
+    function getPathComponents(path, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
+        path = combinePaths(currentDirectory, path);
+        return pathComponents(path, getRootLength(path));
+    }
+    ts.getPathComponents = getPathComponents;
+    function getPathFromPathComponents(pathComponents) {
+        if (pathComponents.length === 0)
+            return "";
+        var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
+        return root + pathComponents.slice(1).join(ts.directorySeparator);
+    }
+    ts.getPathFromPathComponents = getPathFromPathComponents;
+    function normalizeSlashes(path) {
+        var index = path.indexOf("\\");
+        if (index === -1) {
+            return path;
+        }
+        backslashRegExp.lastIndex = index;
+        return path.replace(backslashRegExp, ts.directorySeparator);
+    }
+    ts.normalizeSlashes = normalizeSlashes;
+    function reducePathComponents(components) {
+        if (!ts.some(components))
+            return [];
+        var reduced = [components[0]];
+        for (var i = 1; i < components.length; i++) {
+            var component = components[i];
+            if (!component)
+                continue;
+            if (component === ".")
+                continue;
+            if (component === "..") {
+                if (reduced.length > 1) {
+                    if (reduced[reduced.length - 1] !== "..") {
+                        reduced.pop();
+                        continue;
+                    }
+                }
+                else if (reduced[0])
+                    continue;
+            }
+            reduced.push(component);
+        }
+        return reduced;
+    }
+    ts.reducePathComponents = reducePathComponents;
+    function combinePaths(path) {
+        var paths = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            paths[_i - 1] = arguments[_i];
+        }
+        if (path)
+            path = normalizeSlashes(path);
+        for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) {
+            var relativePath = paths_1[_a];
+            if (!relativePath)
+                continue;
+            relativePath = normalizeSlashes(relativePath);
+            if (!path || getRootLength(relativePath) !== 0) {
+                path = relativePath;
+            }
+            else {
+                path = ensureTrailingDirectorySeparator(path) + relativePath;
+            }
+        }
+        return path;
+    }
+    ts.combinePaths = combinePaths;
+    function resolvePath(path) {
+        var paths = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            paths[_i - 1] = arguments[_i];
+        }
+        return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArray([path], paths, false)) : normalizeSlashes(path));
+    }
+    ts.resolvePath = resolvePath;
+    function getNormalizedPathComponents(path, currentDirectory) {
+        return reducePathComponents(getPathComponents(path, currentDirectory));
+    }
+    ts.getNormalizedPathComponents = getNormalizedPathComponents;
+    function getNormalizedAbsolutePath(fileName, currentDirectory) {
+        return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
+    }
+    ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath;
+    function normalizePath(path) {
+        path = normalizeSlashes(path);
+        if (!relativePathSegmentRegExp.test(path)) {
+            return path;
+        }
+        var simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
+        if (simplified !== path) {
+            path = simplified;
+            if (!relativePathSegmentRegExp.test(path)) {
+                return path;
+            }
+        }
+        var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+        return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+    }
+    ts.normalizePath = normalizePath;
+    function getPathWithoutRoot(pathComponents) {
+        if (pathComponents.length === 0)
+            return "";
+        return pathComponents.slice(1).join(ts.directorySeparator);
+    }
+    function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
+        return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
+    }
+    ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
+    function normalizePathAndParts(path) {
+        path = normalizeSlashes(path);
+        var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1);
+        if (parts.length) {
+            var joinedParts = root + parts.join(ts.directorySeparator);
+            return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts };
+        }
+        else {
+            return { path: root, parts: parts };
+        }
+    }
+    ts.normalizePathAndParts = normalizePathAndParts;
+    function removeTrailingDirectorySeparator(path) {
+        if (hasTrailingDirectorySeparator(path)) {
+            return path.substr(0, path.length - 1);
+        }
+        return path;
+    }
+    ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
+    function ensureTrailingDirectorySeparator(path) {
+        if (!hasTrailingDirectorySeparator(path)) {
+            return path + ts.directorySeparator;
+        }
+        return path;
+    }
+    ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
+    function ensurePathIsNonModuleName(path) {
+        return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
+    }
+    ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName;
+    function changeAnyExtension(path, ext, extensions, ignoreCase) {
+        var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
+        return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path;
+    }
+    ts.changeAnyExtension = changeAnyExtension;
+    var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
+    function comparePathsWorker(a, b, componentComparer) {
+        if (a === b)
+            return 0;
+        if (a === undefined)
+            return -1;
+        if (b === undefined)
+            return 1;
+        var aRoot = a.substring(0, getRootLength(a));
+        var bRoot = b.substring(0, getRootLength(b));
+        var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
+        if (result !== 0) {
+            return result;
+        }
+        var aRest = a.substring(aRoot.length);
+        var bRest = b.substring(bRoot.length);
+        if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
+            return componentComparer(aRest, bRest);
+        }
+        var aComponents = reducePathComponents(getPathComponents(a));
+        var bComponents = reducePathComponents(getPathComponents(b));
+        var sharedLength = Math.min(aComponents.length, bComponents.length);
+        for (var i = 1; i < sharedLength; i++) {
+            var result_2 = componentComparer(aComponents[i], bComponents[i]);
+            if (result_2 !== 0) {
+                return result_2;
+            }
+        }
+        return ts.compareValues(aComponents.length, bComponents.length);
+    }
+    function comparePathsCaseSensitive(a, b) {
+        return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
+    }
+    ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
+    function comparePathsCaseInsensitive(a, b) {
+        return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive);
+    }
+    ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive;
+    function comparePaths(a, b, currentDirectory, ignoreCase) {
+        if (typeof currentDirectory === "string") {
+            a = combinePaths(currentDirectory, a);
+            b = combinePaths(currentDirectory, b);
+        }
+        else if (typeof currentDirectory === "boolean") {
+            ignoreCase = currentDirectory;
+        }
+        return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase));
+    }
+    ts.comparePaths = comparePaths;
+    function containsPath(parent, child, currentDirectory, ignoreCase) {
+        if (typeof currentDirectory === "string") {
+            parent = combinePaths(currentDirectory, parent);
+            child = combinePaths(currentDirectory, child);
+        }
+        else if (typeof currentDirectory === "boolean") {
+            ignoreCase = currentDirectory;
+        }
+        if (parent === undefined || child === undefined)
+            return false;
+        if (parent === child)
+            return true;
+        var parentComponents = reducePathComponents(getPathComponents(parent));
+        var childComponents = reducePathComponents(getPathComponents(child));
+        if (childComponents.length < parentComponents.length) {
+            return false;
+        }
+        var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive;
+        for (var i = 0; i < parentComponents.length; i++) {
+            var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer;
+            if (!equalityComparer(parentComponents[i], childComponents[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ts.containsPath = containsPath;
+    function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
+        var canonicalFileName = getCanonicalFileName(fileName);
+        var canonicalDirectoryName = getCanonicalFileName(directoryName);
+        return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\");
+    }
+    ts.startsWithDirectory = startsWithDirectory;
+    function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
+        var fromComponents = reducePathComponents(getPathComponents(from));
+        var toComponents = reducePathComponents(getPathComponents(to));
+        var start;
+        for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
+            var fromComponent = getCanonicalFileName(fromComponents[start]);
+            var toComponent = getCanonicalFileName(toComponents[start]);
+            var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer;
+            if (!comparer(fromComponent, toComponent))
+                break;
+        }
+        if (start === 0) {
+            return toComponents;
+        }
+        var components = toComponents.slice(start);
+        var relative = [];
+        for (; start < fromComponents.length; start++) {
+            relative.push("..");
+        }
+        return __spreadArray(__spreadArray([""], relative, true), components, true);
+    }
+    ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo;
+    function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
+        ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative");
+        var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity;
+        var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
+        var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName);
+        return getPathFromPathComponents(pathComponents);
+    }
+    ts.getRelativePathFromDirectory = getRelativePathFromDirectory;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
+    function getRelativePathFromFile(from, to, getCanonicalFileName) {
+        return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
+    }
+    ts.getRelativePathFromFile = getRelativePathFromFile;
+    function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
+        var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName);
+        var firstComponent = pathComponents[0];
+        if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
+            var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///";
+            pathComponents[0] = prefix + firstComponent;
+        }
+        return getPathFromPathComponents(pathComponents);
+    }
+    ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl;
+    function forEachAncestorDirectory(directory, callback) {
+        while (true) {
+            var result = callback(directory);
+            if (result !== undefined) {
+                return result;
+            }
+            var parentPath = getDirectoryPath(directory);
+            if (parentPath === directory) {
+                return undefined;
+            }
+            directory = parentPath;
+        }
+    }
+    ts.forEachAncestorDirectory = forEachAncestorDirectory;
+    function isNodeModulesDirectory(dirPath) {
+        return ts.endsWith(dirPath, "/node_modules");
+    }
+    ts.isNodeModulesDirectory = isNodeModulesDirectory;
+})(ts || (ts = {}));
+var ts;
 (function (ts) {
     function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated) {
         return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid, reportsDeprecated: reportsDeprecated };
@@ -9583,11 +9583,17 @@ var ts;
     ts.getAllJSDocTagsOfKind = getAllJSDocTagsOfKind;
     function getTextOfJSDocComment(comment) {
         return typeof comment === "string" ? comment
-            : comment === null || comment === void 0 ? void 0 : comment.map(function (c) {
-                return c.kind === 319 ? c.text : "{@link " + (c.name ? ts.entityNameToString(c.name) + " " : "") + c.text + "}";
-            }).join("");
+            : comment === null || comment === void 0 ? void 0 : comment.map(function (c) { return c.kind === 319 ? c.text : formatJSDocLink(c); }).join("");
     }
     ts.getTextOfJSDocComment = getTextOfJSDocComment;
+    function formatJSDocLink(link) {
+        var kind = link.kind === 322 ? "link"
+            : link.kind === 323 ? "linkcode"
+                : "linkplain";
+        var name = link.name ? ts.entityNameToString(link.name) : "";
+        var space = link.name && link.text.startsWith("://") ? "" : " ";
+        return "{@" + kind + " " + name + space + link.text + "}";
+    }
     function getEffectiveTypeParameterDeclarations(node) {
         if (ts.isJSDocSignature(node)) {
             return ts.emptyArray;
@@ -56725,7 +56731,10 @@ var ts;
                     (type === falseType || type === regularFalseType) ? 12121864 : 7927560 :
                     (type === falseType || type === regularFalseType) ? 12580616 : 16774920;
             }
-            if (flags & 524288 && !ignoreObjects) {
+            if (flags & 524288) {
+                if (ignoreObjects) {
+                    return 16768959;
+                }
                 return ts.getObjectFlags(type) & 16 && isEmptyObjectType(type) ?
                     strictNullChecks ? 16318463 : 16777215 :
                     isFunctionObjectType(type) ?
@@ -56769,7 +56778,7 @@ var ts;
                 oredFacts |= f;
                 andedFacts &= f;
             }
-            return oredFacts & 8288 | andedFacts & 16768927;
+            return oredFacts & 8256 | andedFacts & 16768959;
         }
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
@@ -58448,6 +58457,9 @@ var ts;
             return getTypeOfSymbol(symbol);
         }
         function checkIdentifier(node, checkMode) {
+            if (ts.isThisInTypeQuery(node)) {
+                return checkThisExpression(node);
+            }
             var symbol = getResolvedSymbol(node);
             if (symbol === unknownSymbol) {
                 return errorType;
@@ -59944,7 +59956,8 @@ var ts;
             var links = getNodeLinks(node.expression);
             if (!links.resolvedType) {
                 if ((ts.isTypeLiteralNode(node.parent.parent) || ts.isClassLike(node.parent.parent) || ts.isInterfaceDeclaration(node.parent.parent))
-                    && ts.isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101) {
+                    && ts.isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101
+                    && node.parent.kind !== 171 && node.parent.kind !== 172) {
                     return links.resolvedType = errorType;
                 }
                 links.resolvedType = checkExpression(node.expression);
@@ -63318,6 +63331,10 @@ var ts;
             return restParameter.escapedName;
         }
         function getParameterIdentifierNameAtPosition(signature, pos) {
+            var _a;
+            if (((_a = signature.declaration) === null || _a === void 0 ? void 0 : _a.kind) === 315) {
+                return undefined;
+            }
             var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
             if (pos < paramCount) {
                 var param = signature.parameters[pos];
@@ -70864,7 +70881,9 @@ var ts;
                 case 80:
                 case 205:
                 case 160:
-                    return getSymbolOfNameOrPropertyAccessExpression(node);
+                    if (!ts.isThisInTypeQuery(node)) {
+                        return getSymbolOfNameOrPropertyAccessExpression(node);
+                    }
                 case 108:
                     var container = ts.getThisContainer(node, false);
                     if (ts.isFunctionLike(container)) {
@@ -78849,6 +78868,7 @@ var ts;
         var exportedVariableStatement = false;
         var enabledSubstitutions;
         var enclosingFunctionFlags;
+        var parametersWithPrecedingObjectRestOrSpread;
         var enclosingSuperContainerFlags = 0;
         var hierarchyFacts = 0;
         var currentSourceFile;
@@ -79229,6 +79249,7 @@ var ts;
                 ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
                 factory.createVariableDeclaration(result)
             ]), node.expression), 2097152), factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256);
+            ts.setOriginalNode(forStatement, node);
             return factory.createTryStatement(factory.createBlock([
                 factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
             ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([
@@ -79243,77 +79264,118 @@ var ts;
                 ]), 1))
             ]));
         }
+        function parameterVisitor(node) {
+            ts.Debug.assertNode(node, ts.isParameter);
+            return visitParameter(node);
+        }
         function visitParameter(node) {
+            if (parametersWithPrecedingObjectRestOrSpread === null || parametersWithPrecedingObjectRestOrSpread === void 0 ? void 0 : parametersWithPrecedingObjectRestOrSpread.has(node)) {
+                return factory.updateParameterDeclaration(node, undefined, undefined, node.dotDotDotToken, ts.isBindingPattern(node.name) ? factory.getGeneratedNameForNode(node) : node.name, undefined, undefined, undefined);
+            }
             if (node.transformFlags & 32768) {
                 return factory.updateParameterDeclaration(node, undefined, undefined, node.dotDotDotToken, factory.getGeneratedNameForNode(node), undefined, undefined, ts.visitNode(node.initializer, visitor, ts.isExpression));
             }
             return ts.visitEachChild(node, visitor, context);
         }
+        function collectParametersWithPrecedingObjectRestOrSpread(node) {
+            var parameters;
+            for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
+                var parameter = _a[_i];
+                if (parameters) {
+                    parameters.add(parameter);
+                }
+                else if (parameter.transformFlags & 32768) {
+                    parameters = new ts.Set();
+                }
+            }
+            return parameters;
+        }
         function visitConstructorDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
-            enclosingFunctionFlags = 0;
-            var updated = factory.updateConstructorDeclaration(node, undefined, node.modifiers, ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
+            var updated = factory.updateConstructorDeclaration(node, undefined, node.modifiers, ts.visitParameterList(node.parameters, parameterVisitor, context), transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitGetAccessorDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
-            enclosingFunctionFlags = 0;
-            var updated = factory.updateGetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), undefined, transformFunctionBody(node));
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
+            var updated = factory.updateGetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, parameterVisitor, context), undefined, transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitSetAccessorDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
-            enclosingFunctionFlags = 0;
-            var updated = factory.updateSetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
+            var updated = factory.updateSetAccessorDeclaration(node, undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, parameterVisitor, context), transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitMethodDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
             enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateMethodDeclaration(node, undefined, enclosingFunctionFlags & 1
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2
                 ? undefined
-                : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(undefined, visitor, ts.isToken), undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
+                : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(undefined, visitor, ts.isToken), undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
                 ? transformAsyncGeneratorFunctionBody(node)
                 : transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitFunctionDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
             enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateFunctionDeclaration(node, undefined, enclosingFunctionFlags & 1
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2
                 ? undefined
-                : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
+                : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
                 ? transformAsyncGeneratorFunctionBody(node)
                 : transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitArrowFunction(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
             enclosingFunctionFlags = ts.getFunctionFlags(node);
-            var updated = factory.updateArrowFunction(node, node.modifiers, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, node.equalsGreaterThanToken, transformFunctionBody(node));
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
+            var updated = factory.updateArrowFunction(node, node.modifiers, undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), undefined, node.equalsGreaterThanToken, transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitFunctionExpression(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
             enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateFunctionExpression(node, enclosingFunctionFlags & 1
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2
                 ? undefined
-                : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, visitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
+                : node.asteriskToken, node.name, undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), undefined, enclosingFunctionFlags & 2 && enclosingFunctionFlags & 1
                 ? transformAsyncGeneratorFunctionBody(node)
                 : transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function transformAsyncGeneratorFunctionBody(node) {
@@ -79368,13 +79430,55 @@ var ts;
             return body;
         }
         function appendObjectRestAssignmentsIfNeeded(statements, node) {
+            var containsPrecedingObjectRestOrSpread = false;
             for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) {
                 var parameter = _a[_i];
-                if (parameter.transformFlags & 32768) {
-                    var temp = factory.getGeneratedNameForNode(parameter);
-                    var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1, temp, false, true);
+                if (containsPrecedingObjectRestOrSpread) {
+                    if (ts.isBindingPattern(parameter.name)) {
+                        if (parameter.name.elements.length > 0) {
+                            var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 0, factory.getGeneratedNameForNode(parameter));
+                            if (ts.some(declarations)) {
+                                var declarationList = factory.createVariableDeclarationList(declarations);
+                                var statement = factory.createVariableStatement(undefined, declarationList);
+                                ts.setEmitFlags(statement, 1048576);
+                                statements = ts.append(statements, statement);
+                            }
+                        }
+                        else if (parameter.initializer) {
+                            var name = factory.getGeneratedNameForNode(parameter);
+                            var initializer = ts.visitNode(parameter.initializer, visitor, ts.isExpression);
+                            var assignment = factory.createAssignment(name, initializer);
+                            var statement = factory.createExpressionStatement(assignment);
+                            ts.setEmitFlags(statement, 1048576);
+                            statements = ts.append(statements, statement);
+                        }
+                    }
+                    else if (parameter.initializer) {
+                        var name = factory.cloneNode(parameter.name);
+                        ts.setTextRange(name, parameter.name);
+                        ts.setEmitFlags(name, 48);
+                        var initializer = ts.visitNode(parameter.initializer, visitor, ts.isExpression);
+                        ts.addEmitFlags(initializer, 48 | 1536);
+                        var assignment = factory.createAssignment(name, initializer);
+                        ts.setTextRange(assignment, parameter);
+                        ts.setEmitFlags(assignment, 1536);
+                        var block = factory.createBlock([factory.createExpressionStatement(assignment)]);
+                        ts.setTextRange(block, parameter);
+                        ts.setEmitFlags(block, 1 | 32 | 384 | 1536);
+                        var typeCheck = factory.createTypeCheck(factory.cloneNode(parameter.name), "undefined");
+                        var statement = factory.createIfStatement(typeCheck, block);
+                        ts.startOnNewLine(statement);
+                        ts.setTextRange(statement, parameter);
+                        ts.setEmitFlags(statement, 384 | 32 | 1048576 | 1536);
+                        statements = ts.append(statements, statement);
+                    }
+                }
+                else if (parameter.transformFlags & 32768) {
+                    containsPrecedingObjectRestOrSpread = true;
+                    var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1, factory.getGeneratedNameForNode(parameter), false, true);
                     if (ts.some(declarations)) {
-                        var statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(declarations));
+                        var declarationList = factory.createVariableDeclarationList(declarations);
+                        var statement = factory.createVariableStatement(undefined, declarationList);
                         ts.setEmitFlags(statement, 1048576);
                         statements = ts.append(statements, statement);
                     }
@@ -81782,10 +81886,12 @@ var ts;
             var loopParameters = [];
             var loopOutParameters = [];
             if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 3)) {
-                var hasCapturedBindingsInForInitializer = shouldConvertInitializerOfForStatement(node);
+                var hasCapturedBindingsInForHead = shouldConvertInitializerOfForStatement(node) ||
+                    shouldConvertConditionOfForStatement(node) ||
+                    shouldConvertIncrementorOfForStatement(node);
                 for (var _i = 0, _a = loopInitializer.declarations; _i < _a.length; _i++) {
                     var decl = _a[_i];
-                    processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer);
+                    processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
                 }
             }
             var currentState = { loopParameters: loopParameters, loopOutParameters: loopOutParameters };
@@ -82006,27 +82112,33 @@ var ts;
                 caseClauses.push(factory.createCaseClause(factory.createStringLiteral(labelMarker), statements));
             });
         }
-        function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer) {
+        function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead) {
             var name = decl.name;
             if (ts.isBindingPattern(name)) {
                 for (var _i = 0, _a = name.elements; _i < _a.length; _i++) {
                     var element = _a[_i];
                     if (!ts.isOmittedExpression(element)) {
-                        processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForInitializer);
+                        processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
                     }
                 }
             }
             else {
                 loopParameters.push(factory.createParameterDeclaration(undefined, undefined, undefined, name));
                 var checkFlags = resolver.getNodeCheckFlags(decl);
-                if (checkFlags & 4194304 || hasCapturedBindingsInForInitializer) {
+                if (checkFlags & 4194304 || hasCapturedBindingsInForHead) {
                     var outParamName = factory.createUniqueName("out_" + ts.idText(name));
                     var flags = 0;
                     if (checkFlags & 4194304) {
                         flags |= 1;
                     }
-                    if (ts.isForStatement(container) && container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
-                        flags |= 2;
+                    if (ts.isForStatement(container)) {
+                        if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
+                            flags |= 2;
+                        }
+                        if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) ||
+                            container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) {
+                            flags |= 1;
+                        }
                     }
                     loopOutParameters.push({ flags: flags, originalName: name, outParamName: outParamName });
                 }