typescript 4.6.0-dev.20220131 → 4.6.0-dev.20220204

package/lib/tsserver.js

@@ -100,7 +100,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.20220131";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220204";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5724,704 +5724,6 @@ var ts;
         },
     };
 })(ts || (ts = {}));
-/* @internal */
-var ts;
-(function (ts) {
-    /**
-     * Internally, we represent paths as strings with '/' as the directory separator.
-     * When we make system calls (eg: LanguageServiceHost.getDirectory()),
-     * we expect the host to correctly handle paths in our specified format.
-     */
-    ts.directorySeparator = "/";
-    ts.altDirectorySeparator = "\\";
-    var urlSchemeSeparator = "://";
-    var backslashRegExp = /\\/g;
-    //// Path Tests
-    /**
-     * Determines whether a charCode corresponds to `/` or `\`.
-     */
-    function isAnyDirectorySeparator(charCode) {
-        return charCode === 47 /* slash */ || charCode === 92 /* backslash */;
-    }
-    ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
-    /**
-     * Determines whether a path starts with a URL scheme (e.g. starts with `http://`, `ftp://`, `file://`, etc.).
-     */
-    function isUrl(path) {
-        return getEncodedRootLength(path) < 0;
-    }
-    ts.isUrl = isUrl;
-    /**
-     * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
-     * like `c:`, `c:\` or `c:/`).
-     */
-    function isRootedDiskPath(path) {
-        return getEncodedRootLength(path) > 0;
-    }
-    ts.isRootedDiskPath = isRootedDiskPath;
-    /**
-     * Determines whether a path consists only of a path root.
-     */
-    function isDiskPathRoot(path) {
-        var rootLength = getEncodedRootLength(path);
-        return rootLength > 0 && rootLength === path.length;
-    }
-    ts.isDiskPathRoot = isDiskPathRoot;
-    /**
-     * Determines whether a path starts with an absolute path component (i.e. `/`, `c:/`, `file://`, etc.).
-     *
-     * ```ts
-     * // POSIX
-     * pathIsAbsolute("/path/to/file.ext") === true
-     * // DOS
-     * pathIsAbsolute("c:/path/to/file.ext") === true
-     * // URL
-     * pathIsAbsolute("file:///path/to/file.ext") === true
-     * // Non-absolute
-     * pathIsAbsolute("path/to/file.ext") === false
-     * pathIsAbsolute("./path/to/file.ext") === false
-     * ```
-     */
-    function pathIsAbsolute(path) {
-        return getEncodedRootLength(path) !== 0;
-    }
-    ts.pathIsAbsolute = pathIsAbsolute;
-    /**
-     * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
-     */
-    function pathIsRelative(path) {
-        return /^\.\.?($|[\\/])/.test(path);
-    }
-    ts.pathIsRelative = pathIsRelative;
-    /**
-     * Determines whether a path is neither relative nor absolute, e.g. "path/to/file".
-     * Also known misleadingly as "non-relative".
-     */
-    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;
-    /**
-     * Determines whether a path has a trailing separator (`/` or `\\`).
-     */
-    function hasTrailingDirectorySeparator(path) {
-        return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
-    }
-    ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
-    //// Path Parsing
-    function isVolumeCharacter(charCode) {
-        return (charCode >= 97 /* a */ && charCode <= 122 /* z */) ||
-            (charCode >= 65 /* A */ && charCode <= 90 /* Z */);
-    }
-    function getFileUrlVolumeSeparatorEnd(url, start) {
-        var ch0 = url.charCodeAt(start);
-        if (ch0 === 58 /* colon */)
-            return start + 1;
-        if (ch0 === 37 /* percent */ && url.charCodeAt(start + 1) === 51 /* _3 */) {
-            var ch2 = url.charCodeAt(start + 2);
-            if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
-                return start + 3;
-        }
-        return -1;
-    }
-    /**
-     * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
-     * If the root is part of a URL, the twos-complement of the root length is returned.
-     */
-    function getEncodedRootLength(path) {
-        if (!path)
-            return 0;
-        var ch0 = path.charCodeAt(0);
-        // POSIX or UNC
-        if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
-            if (path.charCodeAt(1) !== ch0)
-                return 1; // POSIX: "/" (or non-normalized "\")
-            var p1 = path.indexOf(ch0 === 47 /* slash */ ? ts.directorySeparator : ts.altDirectorySeparator, 2);
-            if (p1 < 0)
-                return path.length; // UNC: "//server" or "\\server"
-            return p1 + 1; // UNC: "//server/" or "\\server\"
-        }
-        // DOS
-        if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
-            var ch2 = path.charCodeAt(2);
-            if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
-                return 3; // DOS: "c:/" or "c:\"
-            if (path.length === 2)
-                return 2; // DOS: "c:" (but not "c:d")
-        }
-        // URL
-        var schemeEnd = path.indexOf(urlSchemeSeparator);
-        if (schemeEnd !== -1) {
-            var authorityStart = schemeEnd + urlSchemeSeparator.length;
-            var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
-            if (authorityEnd !== -1) { // URL: "file:///", "file://server/", "file://server/path"
-                // For local "file" URLs, include the leading DOS volume (if present).
-                // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
-                // special case interpreted as "the machine from which the URL is being interpreted".
-                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 /* slash */) {
-                            // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
-                            return ~(volumeSeparatorEnd + 1);
-                        }
-                        if (volumeSeparatorEnd === path.length) {
-                            // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
-                            // but not "file:///c:d" or "file:///c%3ad"
-                            return ~volumeSeparatorEnd;
-                        }
-                    }
-                }
-                return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
-            }
-            return ~path.length; // URL: "file://server", "http://server"
-        }
-        // relative
-        return 0;
-    }
-    /**
-     * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
-     *
-     * For example:
-     * ```ts
-     * getRootLength("a") === 0                   // ""
-     * getRootLength("/") === 1                   // "/"
-     * getRootLength("c:") === 2                  // "c:"
-     * getRootLength("c:d") === 0                 // ""
-     * getRootLength("c:/") === 3                 // "c:/"
-     * getRootLength("c:\\") === 3                // "c:\\"
-     * getRootLength("//server") === 7            // "//server"
-     * getRootLength("//server/share") === 8      // "//server/"
-     * getRootLength("\\\\server") === 7          // "\\\\server"
-     * getRootLength("\\\\server\\share") === 8   // "\\\\server\\"
-     * getRootLength("file:///path") === 8        // "file:///"
-     * getRootLength("file:///c:") === 10         // "file:///c:"
-     * getRootLength("file:///c:d") === 8         // "file:///"
-     * getRootLength("file:///c:/path") === 11    // "file:///c:/"
-     * getRootLength("file://server") === 13      // "file://server"
-     * getRootLength("file://server/path") === 14 // "file://server/"
-     * getRootLength("http://server") === 13      // "http://server"
-     * getRootLength("http://server/path") === 14 // "http://server/"
-     * ```
-     */
-    function getRootLength(path) {
-        var rootLength = getEncodedRootLength(path);
-        return rootLength < 0 ? ~rootLength : rootLength;
-    }
-    ts.getRootLength = getRootLength;
-    function getDirectoryPath(path) {
-        path = normalizeSlashes(path);
-        // If the path provided is itself the root, then return it.
-        var rootLength = getRootLength(path);
-        if (rootLength === path.length)
-            return path;
-        // return the leading portion of the path up to the last (non-terminal) directory separator
-        // but not including any trailing directory separator.
-        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);
-        // if the path provided is itself the root, then it has not file name.
-        var rootLength = getRootLength(path);
-        if (rootLength === path.length)
-            return "";
-        // return the trailing portion of the path starting after the last (non-terminal) directory
-        // separator but not including any trailing directory separator.
-        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 /* dot */) {
-            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) {
-        // Retrieves any string from the final "." onwards from a base file name.
-        // Unlike extensionFromPath, which throws an exception on unrecognized extensions.
-        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);
-    }
-    /**
-     * Parse a path into an array containing a root component (at index 0) and zero or more path
-     * components (at indices > 0). The result is not normalized.
-     * If the path is relative, the root component is `""`.
-     * If the path is absolute, the root component includes the first path separator (`/`).
-     *
-     * ```ts
-     * // POSIX
-     * getPathComponents("/path/to/file.ext") === ["/", "path", "to", "file.ext"]
-     * getPathComponents("/path/to/") === ["/", "path", "to"]
-     * getPathComponents("/") === ["/"]
-     * // DOS
-     * getPathComponents("c:/path/to/file.ext") === ["c:/", "path", "to", "file.ext"]
-     * getPathComponents("c:/path/to/") === ["c:/", "path", "to"]
-     * getPathComponents("c:/") === ["c:/"]
-     * getPathComponents("c:") === ["c:"]
-     * // URL
-     * getPathComponents("http://typescriptlang.org/path/to/file.ext") === ["http://typescriptlang.org/", "path", "to", "file.ext"]
-     * getPathComponents("http://typescriptlang.org/path/to/") === ["http://typescriptlang.org/", "path", "to"]
-     * getPathComponents("http://typescriptlang.org/") === ["http://typescriptlang.org/"]
-     * getPathComponents("http://typescriptlang.org") === ["http://typescriptlang.org"]
-     * getPathComponents("file://server/path/to/file.ext") === ["file://server/", "path", "to", "file.ext"]
-     * getPathComponents("file://server/path/to/") === ["file://server/", "path", "to"]
-     * getPathComponents("file://server/") === ["file://server/"]
-     * getPathComponents("file://server") === ["file://server"]
-     * getPathComponents("file:///path/to/file.ext") === ["file:///", "path", "to", "file.ext"]
-     * getPathComponents("file:///path/to/") === ["file:///", "path", "to"]
-     * getPathComponents("file:///") === ["file:///"]
-     * getPathComponents("file://") === ["file://"]
-     */
-    function getPathComponents(path, currentDirectory) {
-        if (currentDirectory === void 0) { currentDirectory = ""; }
-        path = combinePaths(currentDirectory, path);
-        return pathComponents(path, getRootLength(path));
-    }
-    ts.getPathComponents = getPathComponents;
-    //// Path Formatting
-    /**
-     * Formats a parsed path consisting of a root component (at index 0) and zero or more path
-     * segments (at indices > 0).
-     *
-     * ```ts
-     * getPathFromPathComponents(["/", "path", "to", "file.ext"]) === "/path/to/file.ext"
-     * ```
-     */
-    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;
-    //// Path Normalization
-    /**
-     * Normalize path separators, converting `\` into `/`.
-     */
-    function normalizeSlashes(path) {
-        var index = path.indexOf("\\");
-        if (index === -1) {
-            return path;
-        }
-        backslashRegExp.lastIndex = index; // prime regex with known position
-        return path.replace(backslashRegExp, ts.directorySeparator);
-    }
-    ts.normalizeSlashes = normalizeSlashes;
-    /**
-     * Reduce an array of path components to a more simplified path by navigating any
-     * `"."` or `".."` entries in the path.
-     */
-    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;
-    /**
-     * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
-     *
-     * ```ts
-     * // Non-rooted
-     * combinePaths("path", "to", "file.ext") === "path/to/file.ext"
-     * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext"
-     * // POSIX
-     * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext"
-     * combinePaths("/path", "/to", "file.ext") === "/to/file.ext"
-     * // DOS
-     * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext"
-     * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext"
-     * // URL
-     * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext"
-     * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
-     * ```
-     */
-    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;
-    /**
-     * Combines and resolves paths. If a path is absolute, it replaces any previous path. Any
-     * `.` and `..` path components are resolved. Trailing directory separators are preserved.
-     *
-     * ```ts
-     * resolvePath("/path", "to", "file.ext") === "path/to/file.ext"
-     * resolvePath("/path", "to", "file.ext/") === "path/to/file.ext/"
-     * resolvePath("/path", "dir", "..", "to", "file.ext") === "path/to/file.ext"
-     * ```
-     */
-    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;
-    /**
-     * Parse a path into an array containing a root component (at index 0) and zero or more path
-     * components (at indices > 0). The result is normalized.
-     * If the path is relative, the root component is `""`.
-     * If the path is absolute, the root component includes the first path separator (`/`).
-     *
-     * ```ts
-     * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"]
-     * ```
-     */
-    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);
-        // Most paths don't require normalization
-        if (!relativePathSegmentRegExp.test(path)) {
-            return path;
-        }
-        // Some paths only require cleanup of `/./` or leading `./`
-        var simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
-        if (simplified !== path) {
-            path = simplified;
-            if (!relativePathSegmentRegExp.test(path)) {
-                return path;
-            }
-        }
-        // Other paths require full normalization
-        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;
-    /**
-     * Ensures a path is either absolute (prefixed with `/` or `c:`) or dot-relative (prefixed
-     * with `./` or `../`) so as not to be confused with an unprefixed module name.
-     *
-     * ```ts
-     * ensurePathIsNonModuleName("/path/to/file.ext") === "/path/to/file.ext"
-     * ensurePathIsNonModuleName("./path/to/file.ext") === "./path/to/file.ext"
-     * ensurePathIsNonModuleName("../path/to/file.ext") === "../path/to/file.ext"
-     * ensurePathIsNonModuleName("path/to/file.ext") === "./path/to/file.ext"
-     * ```
-     */
-    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;
-    //// Path Comparisons
-    // check path for these segments: '', '.'. '..'
-    var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
-    function comparePathsWorker(a, b, componentComparer) {
-        if (a === b)
-            return 0 /* EqualTo */;
-        if (a === undefined)
-            return -1 /* LessThan */;
-        if (b === undefined)
-            return 1 /* GreaterThan */;
-        // NOTE: Performance optimization - shortcut if the root segments differ as there would be no
-        //       need to perform path reduction.
-        var aRoot = a.substring(0, getRootLength(a));
-        var bRoot = b.substring(0, getRootLength(b));
-        var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
-        if (result !== 0 /* EqualTo */) {
-            return result;
-        }
-        // NOTE: Performance optimization - shortcut if there are no relative path segments in
-        //       the non-root portion of the path
-        var aRest = a.substring(aRoot.length);
-        var bRest = b.substring(bRoot.length);
-        if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
-            return componentComparer(aRest, bRest);
-        }
-        // The path contains a relative path segment. Normalize the paths and perform a slower component
-        // by component comparison.
-        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 /* EqualTo */) {
-                return result_2;
-            }
-        }
-        return ts.compareValues(aComponents.length, bComponents.length);
-    }
-    /**
-     * Performs a case-sensitive comparison of two paths. Path roots are always compared case-insensitively.
-     */
-    function comparePathsCaseSensitive(a, b) {
-        return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
-    }
-    ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
-    /**
-     * Performs a case-insensitive comparison of two paths.
-     */
-    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;
-    /**
-     * Determines whether `fileName` starts with the specified `directoryName` using the provided path canonicalization callback.
-     * Comparison is case-sensitive between the canonical paths.
-     *
-     * Use `containsPath` if file names are not already reduced and absolute.
-     */
-    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;
-    //// Relative Paths
-    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, /*isAbsolutePathAnUrl*/ 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) {
     /**
@@ -7854,6 +7156,704 @@ var ts;
         ts.Debug.isDebugging = true;
     }
 })(ts || (ts = {}));
+/* @internal */
+var ts;
+(function (ts) {
+    /**
+     * Internally, we represent paths as strings with '/' as the directory separator.
+     * When we make system calls (eg: LanguageServiceHost.getDirectory()),
+     * we expect the host to correctly handle paths in our specified format.
+     */
+    ts.directorySeparator = "/";
+    ts.altDirectorySeparator = "\\";
+    var urlSchemeSeparator = "://";
+    var backslashRegExp = /\\/g;
+    //// Path Tests
+    /**
+     * Determines whether a charCode corresponds to `/` or `\`.
+     */
+    function isAnyDirectorySeparator(charCode) {
+        return charCode === 47 /* slash */ || charCode === 92 /* backslash */;
+    }
+    ts.isAnyDirectorySeparator = isAnyDirectorySeparator;
+    /**
+     * Determines whether a path starts with a URL scheme (e.g. starts with `http://`, `ftp://`, `file://`, etc.).
+     */
+    function isUrl(path) {
+        return getEncodedRootLength(path) < 0;
+    }
+    ts.isUrl = isUrl;
+    /**
+     * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
+     * like `c:`, `c:\` or `c:/`).
+     */
+    function isRootedDiskPath(path) {
+        return getEncodedRootLength(path) > 0;
+    }
+    ts.isRootedDiskPath = isRootedDiskPath;
+    /**
+     * Determines whether a path consists only of a path root.
+     */
+    function isDiskPathRoot(path) {
+        var rootLength = getEncodedRootLength(path);
+        return rootLength > 0 && rootLength === path.length;
+    }
+    ts.isDiskPathRoot = isDiskPathRoot;
+    /**
+     * Determines whether a path starts with an absolute path component (i.e. `/`, `c:/`, `file://`, etc.).
+     *
+     * ```ts
+     * // POSIX
+     * pathIsAbsolute("/path/to/file.ext") === true
+     * // DOS
+     * pathIsAbsolute("c:/path/to/file.ext") === true
+     * // URL
+     * pathIsAbsolute("file:///path/to/file.ext") === true
+     * // Non-absolute
+     * pathIsAbsolute("path/to/file.ext") === false
+     * pathIsAbsolute("./path/to/file.ext") === false
+     * ```
+     */
+    function pathIsAbsolute(path) {
+        return getEncodedRootLength(path) !== 0;
+    }
+    ts.pathIsAbsolute = pathIsAbsolute;
+    /**
+     * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
+     */
+    function pathIsRelative(path) {
+        return /^\.\.?($|[\\/])/.test(path);
+    }
+    ts.pathIsRelative = pathIsRelative;
+    /**
+     * Determines whether a path is neither relative nor absolute, e.g. "path/to/file".
+     * Also known misleadingly as "non-relative".
+     */
+    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;
+    /**
+     * Determines whether a path has a trailing separator (`/` or `\\`).
+     */
+    function hasTrailingDirectorySeparator(path) {
+        return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+    }
+    ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
+    //// Path Parsing
+    function isVolumeCharacter(charCode) {
+        return (charCode >= 97 /* a */ && charCode <= 122 /* z */) ||
+            (charCode >= 65 /* A */ && charCode <= 90 /* Z */);
+    }
+    function getFileUrlVolumeSeparatorEnd(url, start) {
+        var ch0 = url.charCodeAt(start);
+        if (ch0 === 58 /* colon */)
+            return start + 1;
+        if (ch0 === 37 /* percent */ && url.charCodeAt(start + 1) === 51 /* _3 */) {
+            var ch2 = url.charCodeAt(start + 2);
+            if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
+                return start + 3;
+        }
+        return -1;
+    }
+    /**
+     * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+     * If the root is part of a URL, the twos-complement of the root length is returned.
+     */
+    function getEncodedRootLength(path) {
+        if (!path)
+            return 0;
+        var ch0 = path.charCodeAt(0);
+        // POSIX or UNC
+        if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
+            if (path.charCodeAt(1) !== ch0)
+                return 1; // POSIX: "/" (or non-normalized "\")
+            var p1 = path.indexOf(ch0 === 47 /* slash */ ? ts.directorySeparator : ts.altDirectorySeparator, 2);
+            if (p1 < 0)
+                return path.length; // UNC: "//server" or "\\server"
+            return p1 + 1; // UNC: "//server/" or "\\server\"
+        }
+        // DOS
+        if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
+            var ch2 = path.charCodeAt(2);
+            if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
+                return 3; // DOS: "c:/" or "c:\"
+            if (path.length === 2)
+                return 2; // DOS: "c:" (but not "c:d")
+        }
+        // URL
+        var schemeEnd = path.indexOf(urlSchemeSeparator);
+        if (schemeEnd !== -1) {
+            var authorityStart = schemeEnd + urlSchemeSeparator.length;
+            var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart);
+            if (authorityEnd !== -1) { // URL: "file:///", "file://server/", "file://server/path"
+                // For local "file" URLs, include the leading DOS volume (if present).
+                // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
+                // special case interpreted as "the machine from which the URL is being interpreted".
+                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 /* slash */) {
+                            // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
+                            return ~(volumeSeparatorEnd + 1);
+                        }
+                        if (volumeSeparatorEnd === path.length) {
+                            // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
+                            // but not "file:///c:d" or "file:///c%3ad"
+                            return ~volumeSeparatorEnd;
+                        }
+                    }
+                }
+                return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
+            }
+            return ~path.length; // URL: "file://server", "http://server"
+        }
+        // relative
+        return 0;
+    }
+    /**
+     * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+     *
+     * For example:
+     * ```ts
+     * getRootLength("a") === 0                   // ""
+     * getRootLength("/") === 1                   // "/"
+     * getRootLength("c:") === 2                  // "c:"
+     * getRootLength("c:d") === 0                 // ""
+     * getRootLength("c:/") === 3                 // "c:/"
+     * getRootLength("c:\\") === 3                // "c:\\"
+     * getRootLength("//server") === 7            // "//server"
+     * getRootLength("//server/share") === 8      // "//server/"
+     * getRootLength("\\\\server") === 7          // "\\\\server"
+     * getRootLength("\\\\server\\share") === 8   // "\\\\server\\"
+     * getRootLength("file:///path") === 8        // "file:///"
+     * getRootLength("file:///c:") === 10         // "file:///c:"
+     * getRootLength("file:///c:d") === 8         // "file:///"
+     * getRootLength("file:///c:/path") === 11    // "file:///c:/"
+     * getRootLength("file://server") === 13      // "file://server"
+     * getRootLength("file://server/path") === 14 // "file://server/"
+     * getRootLength("http://server") === 13      // "http://server"
+     * getRootLength("http://server/path") === 14 // "http://server/"
+     * ```
+     */
+    function getRootLength(path) {
+        var rootLength = getEncodedRootLength(path);
+        return rootLength < 0 ? ~rootLength : rootLength;
+    }
+    ts.getRootLength = getRootLength;
+    function getDirectoryPath(path) {
+        path = normalizeSlashes(path);
+        // If the path provided is itself the root, then return it.
+        var rootLength = getRootLength(path);
+        if (rootLength === path.length)
+            return path;
+        // return the leading portion of the path up to the last (non-terminal) directory separator
+        // but not including any trailing directory separator.
+        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);
+        // if the path provided is itself the root, then it has not file name.
+        var rootLength = getRootLength(path);
+        if (rootLength === path.length)
+            return "";
+        // return the trailing portion of the path starting after the last (non-terminal) directory
+        // separator but not including any trailing directory separator.
+        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 /* dot */) {
+            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) {
+        // Retrieves any string from the final "." onwards from a base file name.
+        // Unlike extensionFromPath, which throws an exception on unrecognized extensions.
+        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);
+    }
+    /**
+     * Parse a path into an array containing a root component (at index 0) and zero or more path
+     * components (at indices > 0). The result is not normalized.
+     * If the path is relative, the root component is `""`.
+     * If the path is absolute, the root component includes the first path separator (`/`).
+     *
+     * ```ts
+     * // POSIX
+     * getPathComponents("/path/to/file.ext") === ["/", "path", "to", "file.ext"]
+     * getPathComponents("/path/to/") === ["/", "path", "to"]
+     * getPathComponents("/") === ["/"]
+     * // DOS
+     * getPathComponents("c:/path/to/file.ext") === ["c:/", "path", "to", "file.ext"]
+     * getPathComponents("c:/path/to/") === ["c:/", "path", "to"]
+     * getPathComponents("c:/") === ["c:/"]
+     * getPathComponents("c:") === ["c:"]
+     * // URL
+     * getPathComponents("http://typescriptlang.org/path/to/file.ext") === ["http://typescriptlang.org/", "path", "to", "file.ext"]
+     * getPathComponents("http://typescriptlang.org/path/to/") === ["http://typescriptlang.org/", "path", "to"]
+     * getPathComponents("http://typescriptlang.org/") === ["http://typescriptlang.org/"]
+     * getPathComponents("http://typescriptlang.org") === ["http://typescriptlang.org"]
+     * getPathComponents("file://server/path/to/file.ext") === ["file://server/", "path", "to", "file.ext"]
+     * getPathComponents("file://server/path/to/") === ["file://server/", "path", "to"]
+     * getPathComponents("file://server/") === ["file://server/"]
+     * getPathComponents("file://server") === ["file://server"]
+     * getPathComponents("file:///path/to/file.ext") === ["file:///", "path", "to", "file.ext"]
+     * getPathComponents("file:///path/to/") === ["file:///", "path", "to"]
+     * getPathComponents("file:///") === ["file:///"]
+     * getPathComponents("file://") === ["file://"]
+     */
+    function getPathComponents(path, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
+        path = combinePaths(currentDirectory, path);
+        return pathComponents(path, getRootLength(path));
+    }
+    ts.getPathComponents = getPathComponents;
+    //// Path Formatting
+    /**
+     * Formats a parsed path consisting of a root component (at index 0) and zero or more path
+     * segments (at indices > 0).
+     *
+     * ```ts
+     * getPathFromPathComponents(["/", "path", "to", "file.ext"]) === "/path/to/file.ext"
+     * ```
+     */
+    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;
+    //// Path Normalization
+    /**
+     * Normalize path separators, converting `\` into `/`.
+     */
+    function normalizeSlashes(path) {
+        var index = path.indexOf("\\");
+        if (index === -1) {
+            return path;
+        }
+        backslashRegExp.lastIndex = index; // prime regex with known position
+        return path.replace(backslashRegExp, ts.directorySeparator);
+    }
+    ts.normalizeSlashes = normalizeSlashes;
+    /**
+     * Reduce an array of path components to a more simplified path by navigating any
+     * `"."` or `".."` entries in the path.
+     */
+    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;
+    /**
+     * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
+     *
+     * ```ts
+     * // Non-rooted
+     * combinePaths("path", "to", "file.ext") === "path/to/file.ext"
+     * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext"
+     * // POSIX
+     * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext"
+     * combinePaths("/path", "/to", "file.ext") === "/to/file.ext"
+     * // DOS
+     * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext"
+     * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext"
+     * // URL
+     * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext"
+     * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
+     * ```
+     */
+    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;
+    /**
+     * Combines and resolves paths. If a path is absolute, it replaces any previous path. Any
+     * `.` and `..` path components are resolved. Trailing directory separators are preserved.
+     *
+     * ```ts
+     * resolvePath("/path", "to", "file.ext") === "path/to/file.ext"
+     * resolvePath("/path", "to", "file.ext/") === "path/to/file.ext/"
+     * resolvePath("/path", "dir", "..", "to", "file.ext") === "path/to/file.ext"
+     * ```
+     */
+    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;
+    /**
+     * Parse a path into an array containing a root component (at index 0) and zero or more path
+     * components (at indices > 0). The result is normalized.
+     * If the path is relative, the root component is `""`.
+     * If the path is absolute, the root component includes the first path separator (`/`).
+     *
+     * ```ts
+     * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"]
+     * ```
+     */
+    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);
+        // Most paths don't require normalization
+        if (!relativePathSegmentRegExp.test(path)) {
+            return path;
+        }
+        // Some paths only require cleanup of `/./` or leading `./`
+        var simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
+        if (simplified !== path) {
+            path = simplified;
+            if (!relativePathSegmentRegExp.test(path)) {
+                return path;
+            }
+        }
+        // Other paths require full normalization
+        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;
+    /**
+     * Ensures a path is either absolute (prefixed with `/` or `c:`) or dot-relative (prefixed
+     * with `./` or `../`) so as not to be confused with an unprefixed module name.
+     *
+     * ```ts
+     * ensurePathIsNonModuleName("/path/to/file.ext") === "/path/to/file.ext"
+     * ensurePathIsNonModuleName("./path/to/file.ext") === "./path/to/file.ext"
+     * ensurePathIsNonModuleName("../path/to/file.ext") === "../path/to/file.ext"
+     * ensurePathIsNonModuleName("path/to/file.ext") === "./path/to/file.ext"
+     * ```
+     */
+    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;
+    //// Path Comparisons
+    // check path for these segments: '', '.'. '..'
+    var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
+    function comparePathsWorker(a, b, componentComparer) {
+        if (a === b)
+            return 0 /* EqualTo */;
+        if (a === undefined)
+            return -1 /* LessThan */;
+        if (b === undefined)
+            return 1 /* GreaterThan */;
+        // NOTE: Performance optimization - shortcut if the root segments differ as there would be no
+        //       need to perform path reduction.
+        var aRoot = a.substring(0, getRootLength(a));
+        var bRoot = b.substring(0, getRootLength(b));
+        var result = ts.compareStringsCaseInsensitive(aRoot, bRoot);
+        if (result !== 0 /* EqualTo */) {
+            return result;
+        }
+        // NOTE: Performance optimization - shortcut if there are no relative path segments in
+        //       the non-root portion of the path
+        var aRest = a.substring(aRoot.length);
+        var bRest = b.substring(bRoot.length);
+        if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
+            return componentComparer(aRest, bRest);
+        }
+        // The path contains a relative path segment. Normalize the paths and perform a slower component
+        // by component comparison.
+        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 /* EqualTo */) {
+                return result_2;
+            }
+        }
+        return ts.compareValues(aComponents.length, bComponents.length);
+    }
+    /**
+     * Performs a case-sensitive comparison of two paths. Path roots are always compared case-insensitively.
+     */
+    function comparePathsCaseSensitive(a, b) {
+        return comparePathsWorker(a, b, ts.compareStringsCaseSensitive);
+    }
+    ts.comparePathsCaseSensitive = comparePathsCaseSensitive;
+    /**
+     * Performs a case-insensitive comparison of two paths.
+     */
+    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;
+    /**
+     * Determines whether `fileName` starts with the specified `directoryName` using the provided path canonicalization callback.
+     * Comparison is case-sensitive between the canonical paths.
+     *
+     * Use `containsPath` if file names are not already reduced and absolute.
+     */
+    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;
+    //// Relative Paths
+    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, /*isAbsolutePathAnUrl*/ 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 = {}));
 // <auto-generated />
 // generated from './diagnosticMessages.json' in 'src/compiler'
 /* @internal */
@@ -12809,12 +12809,17 @@ var ts;
     /** Gets the text of a jsdoc comment, flattening links to their text. */
     function getTextOfJSDocComment(comment) {
         return typeof comment === "string" ? comment
-            : comment === null || comment === void 0 ? void 0 : comment.map(function (c) {
-                // TODO: Other kinds here
-                return c.kind === 319 /* JSDocText */ ? 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 /* JSDocText */ ? c.text : formatJSDocLink(c); }).join("");
     }
     ts.getTextOfJSDocComment = getTextOfJSDocComment;
+    function formatJSDocLink(link) {
+        var kind = link.kind === 322 /* JSDocLink */ ? "link"
+            : link.kind === 323 /* JSDocLinkCode */ ? "linkcode"
+                : "linkplain";
+        var name = link.name ? ts.entityNameToString(link.name) : "";
+        var space = link.name && link.text.startsWith("://") ? "" : " ";
+        return "{@" + kind + " " + name + space + link.text + "}";
+    }
     /**
      * Gets the effective type parameters. If the node was parsed in a
      * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
@@ -46863,8 +46868,8 @@ var ts;
         TypeFacts[TypeFacts["AllTypeofNE"] = 556800] = "AllTypeofNE";
         TypeFacts[TypeFacts["EmptyObjectFacts"] = 16777215] = "EmptyObjectFacts";
         // Masks
-        TypeFacts[TypeFacts["OrFactsMask"] = 8288] = "OrFactsMask";
-        TypeFacts[TypeFacts["AndFactsMask"] = 16768927] = "AndFactsMask";
+        TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
+        TypeFacts[TypeFacts["AndFactsMask"] = 16768959] = "AndFactsMask";
     })(TypeFacts || (TypeFacts = {}));
     var typeofEQFacts = new ts.Map(ts.getEntries({
         string: 1 /* TypeofEQString */,
@@ -67972,7 +67977,10 @@ var ts;
                     (type === falseType || type === regularFalseType) ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ :
                     (type === falseType || type === regularFalseType) ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
             }
-            if (flags & 524288 /* Object */ && !ignoreObjects) {
+            if (flags & 524288 /* Object */) {
+                if (ignoreObjects) {
+                    return 16768959 /* AndFactsMask */; // This is the identity element for computing type facts of intersection.
+                }
                 return ts.getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ?
                     strictNullChecks ? 16318463 /* EmptyObjectStrictFacts */ : 16777215 /* EmptyObjectFacts */ :
                     isFunctionObjectType(type) ?
@@ -68020,7 +68028,7 @@ var ts;
                 oredFacts |= f;
                 andedFacts &= f;
             }
-            return oredFacts & 8288 /* OrFactsMask */ | andedFacts & 16768927 /* AndFactsMask */;
+            return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 16768959 /* AndFactsMask */;
         }
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
@@ -69980,6 +69988,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;
@@ -71771,7 +71782,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 /* InKeyword */) {
+                    && ts.isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101 /* InKeyword */
+                    && node.parent.kind !== 171 /* GetAccessor */ && node.parent.kind !== 172 /* SetAccessor */) {
                     return links.resolvedType = errorType;
                 }
                 links.resolvedType = checkExpression(node.expression);
@@ -75719,6 +75731,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 /* JSDocFunctionType */) {
+                return undefined;
+            }
             var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
             if (pos < paramCount) {
                 var param = signature.parameters[pos];
@@ -84483,7 +84499,10 @@ var ts;
                 case 80 /* PrivateIdentifier */:
                 case 205 /* PropertyAccessExpression */:
                 case 160 /* QualifiedName */:
-                    return getSymbolOfNameOrPropertyAccessExpression(node);
+                    if (!ts.isThisInTypeQuery(node)) {
+                        return getSymbolOfNameOrPropertyAccessExpression(node);
+                    }
+                // falls through
                 case 108 /* ThisKeyword */:
                     var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
                     if (ts.isFunctionLike(container)) {
@@ -94457,6 +94476,7 @@ var ts;
         var exportedVariableStatement = false;
         var enabledSubstitutions;
         var enclosingFunctionFlags;
+        var parametersWithPrecedingObjectRestOrSpread;
         var enclosingSuperContainerFlags = 0;
         var hierarchyFacts = 0;
         var currentSourceFile;
@@ -94913,6 +94933,7 @@ var ts;
             /*incrementor*/ undefined, 
             /*statement*/ convertForOfStatementHead(node, getValue)), 
             /*location*/ node), 256 /* NoTokenTrailingSourceMaps */);
+            ts.setOriginalNode(forStatement, node);
             return factory.createTryStatement(factory.createBlock([
                 factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
             ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([
@@ -94930,7 +94951,19 @@ var ts;
                 ]), 1 /* SingleLine */))
             ]));
         }
+        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, 
+                /*decorators*/ undefined, 
+                /*modifiers*/ undefined, node.dotDotDotToken, ts.isBindingPattern(node.name) ? factory.getGeneratedNameForNode(node) : node.name, 
+                /*questionToken*/ undefined, 
+                /*type*/ undefined, 
+                /*initializer*/ undefined);
+            }
             if (node.transformFlags & 32768 /* ContainsObjectRestOrSpread */) {
                 // Binding patterns are converted into a generated name and are
                 // evaluated inside the function body.
@@ -94942,85 +94975,119 @@ var ts;
             }
             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 /* ContainsObjectRestOrSpread */) {
+                    parameters = new ts.Set();
+                }
+            }
+            return parameters;
+        }
         function visitConstructorDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
-            enclosingFunctionFlags = 0 /* Normal */;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateConstructorDeclaration(node, 
-            /*decorators*/ undefined, node.modifiers, ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+            /*decorators*/ 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 /* Normal */;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateGetAccessorDeclaration(node, 
-            /*decorators*/ undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), 
+            /*decorators*/ undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ undefined, transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitSetAccessorDeclaration(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
-            enclosingFunctionFlags = 0 /* Normal */;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
+            enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateSetAccessorDeclaration(node, 
-            /*decorators*/ undefined, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, visitor, context), transformFunctionBody(node));
+            /*decorators*/ 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, 
             /*decorators*/ undefined, enclosingFunctionFlags & 1 /* Generator */
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2 /* Async */
                 ? undefined
                 : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(/*questionToken*/ undefined, visitor, ts.isToken), 
-            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
+            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ undefined, enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */
                 ? 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, 
             /*decorators*/ undefined, enclosingFunctionFlags & 1 /* Generator */
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2 /* Async */
                 ? undefined
                 : node.asteriskToken, node.name, 
-            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
+            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ undefined, enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */
                 ? transformAsyncGeneratorFunctionBody(node)
                 : transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function visitArrowFunction(node) {
             var savedEnclosingFunctionFlags = enclosingFunctionFlags;
+            var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
             enclosingFunctionFlags = ts.getFunctionFlags(node);
+            parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
             var updated = factory.updateArrowFunction(node, node.modifiers, 
-            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
+            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ 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 /* Generator */
                 ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier)
                 : node.modifiers, enclosingFunctionFlags & 2 /* Async */
                 ? undefined
                 : node.asteriskToken, node.name, 
-            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
+            /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), 
             /*type*/ undefined, enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */
                 ? transformAsyncGeneratorFunctionBody(node)
                 : transformFunctionBody(node));
             enclosingFunctionFlags = savedEnclosingFunctionFlags;
+            parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
             return updated;
         }
         function transformAsyncGeneratorFunctionBody(node) {
@@ -95081,16 +95148,71 @@ 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 /* ContainsObjectRestOrSpread */) {
-                    var temp = factory.getGeneratedNameForNode(parameter);
-                    var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1 /* ObjectRest */, temp, 
+                if (containsPrecedingObjectRestOrSpread) {
+                    if (ts.isBindingPattern(parameter.name)) {
+                        // In cases where a binding pattern is simply '[]' or '{}',
+                        // we usually don't want to emit a var declaration; however, in the presence
+                        // of an initializer, we must emit that expression to preserve side effects.
+                        //
+                        // NOTE: see `insertDefaultValueAssignmentForBindingPattern` in es2015.ts
+                        if (parameter.name.elements.length > 0) {
+                            var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 0 /* All */, factory.getGeneratedNameForNode(parameter));
+                            if (ts.some(declarations)) {
+                                var declarationList = factory.createVariableDeclarationList(declarations);
+                                var statement = factory.createVariableStatement(/*modifiers*/ undefined, declarationList);
+                                ts.setEmitFlags(statement, 1048576 /* CustomPrologue */);
+                                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 /* CustomPrologue */);
+                            statements = ts.append(statements, statement);
+                        }
+                    }
+                    else if (parameter.initializer) {
+                        // Converts a parameter initializer into a function body statement, i.e.:
+                        //
+                        //  function f(x = 1) { }
+                        //
+                        // becomes
+                        //
+                        //  function f(x) {
+                        //    if (typeof x === "undefined") { x = 1; }
+                        //  }
+                        var name = factory.cloneNode(parameter.name);
+                        ts.setTextRange(name, parameter.name);
+                        ts.setEmitFlags(name, 48 /* NoSourceMap */);
+                        var initializer = ts.visitNode(parameter.initializer, visitor, ts.isExpression);
+                        ts.addEmitFlags(initializer, 48 /* NoSourceMap */ | 1536 /* NoComments */);
+                        var assignment = factory.createAssignment(name, initializer);
+                        ts.setTextRange(assignment, parameter);
+                        ts.setEmitFlags(assignment, 1536 /* NoComments */);
+                        var block = factory.createBlock([factory.createExpressionStatement(assignment)]);
+                        ts.setTextRange(block, parameter);
+                        ts.setEmitFlags(block, 1 /* SingleLine */ | 32 /* NoTrailingSourceMap */ | 384 /* NoTokenSourceMaps */ | 1536 /* NoComments */);
+                        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 /* NoTokenSourceMaps */ | 32 /* NoTrailingSourceMap */ | 1048576 /* CustomPrologue */ | 1536 /* NoComments */);
+                        statements = ts.append(statements, statement);
+                    }
+                }
+                else if (parameter.transformFlags & 32768 /* ContainsObjectRestOrSpread */) {
+                    containsPrecedingObjectRestOrSpread = true;
+                    var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1 /* ObjectRest */, factory.getGeneratedNameForNode(parameter), 
                     /*doNotRecordTempVariablesInLine*/ false, 
                     /*skipInitializer*/ true);
                     if (ts.some(declarations)) {
-                        var statement = factory.createVariableStatement(
-                        /*modifiers*/ undefined, factory.createVariableDeclarationList(declarations));
+                        var declarationList = factory.createVariableDeclarationList(declarations);
+                        var statement = factory.createVariableStatement(/*modifiers*/ undefined, declarationList);
                         ts.setEmitFlags(statement, 1048576 /* CustomPrologue */);
                         statements = ts.append(statements, statement);
                     }
@@ -98341,10 +98463,12 @@ var ts;
             // variables declared in the loop initializer that will be changed inside the loop
             var loopOutParameters = [];
             if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 3 /* BlockScoped */)) {
-                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 };
@@ -98698,27 +98822,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(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, name));
                 var checkFlags = resolver.getNodeCheckFlags(decl);
-                if (checkFlags & 4194304 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForInitializer) {
+                if (checkFlags & 4194304 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
                     var outParamName = factory.createUniqueName("out_" + ts.idText(name));
                     var flags = 0;
                     if (checkFlags & 4194304 /* NeedsLoopOutParameter */) {
                         flags |= 1 /* Body */;
                     }
-                    if (ts.isForStatement(container) && container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
-                        flags |= 2 /* Initializer */;
+                    if (ts.isForStatement(container)) {
+                        if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
+                            flags |= 2 /* Initializer */;
+                        }
+                        if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) ||
+                            container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) {
+                            flags |= 1 /* Body */;
+                        }
                     }
                     loopOutParameters.push({ flags: flags, originalName: name, outParamName: outParamName });
                 }
@@ -125738,7 +125868,7 @@ var ts;
                     parts.push(linkTextPart(text));
             }
             else {
-                parts.push(linkTextPart(name + (suffix ? "" : " ") + text));
+                parts.push(linkTextPart(name + (suffix || text.indexOf("://") === 0 ? "" : " ") + text));
             }
         }
         parts.push(linkPart("}"));
@@ -138362,7 +138492,7 @@ var ts;
                         newImportSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, ts.factory.createIdentifier("default"), defaultImport.importClause.name)); // TODO: GH#18217
                     }
                 }
-                newImportSpecifiers.push.apply(newImportSpecifiers, ts.flatMap(namedImports, function (i) { return i.importClause.namedBindings.elements; })); // TODO: GH#18217
+                newImportSpecifiers.push.apply(newImportSpecifiers, getNewImportSpecifiers(namedImports));
                 var sortedImportSpecifiers = sortSpecifiers(newImportSpecifiers);
                 var importDecl = defaultImports.length > 0
                     ? defaultImports[0]
@@ -138572,6 +138702,21 @@ var ts;
                     return 6;
             }
         }
+        function getNewImportSpecifiers(namedImports) {
+            return ts.flatMap(namedImports, function (namedImport) {
+                return ts.map(tryGetNamedBindingElements(namedImport), function (importSpecifier) {
+                    return importSpecifier.name && importSpecifier.propertyName && importSpecifier.name.escapedText === importSpecifier.propertyName.escapedText
+                        ? ts.factory.updateImportSpecifier(importSpecifier, importSpecifier.isTypeOnly, /*propertyName*/ undefined, importSpecifier.name)
+                        : importSpecifier;
+                });
+            });
+        }
+        function tryGetNamedBindingElements(namedImport) {
+            var _a;
+            return ((_a = namedImport.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) && ts.isNamedImports(namedImport.importClause.namedBindings)
+                ? namedImport.importClause.namedBindings.elements
+                : undefined;
+        }
     })(OrganizeImports = ts.OrganizeImports || (ts.OrganizeImports = {}));
 })(ts || (ts = {}));
 /* @internal */
@@ -141434,7 +141579,7 @@ var ts;
             if (typeChecker.isArgumentsSymbol(symbol)) {
                 return "local var" /* localVariableElement */;
             }
-            if (location.kind === 108 /* ThisKeyword */ && ts.isExpression(location)) {
+            if (location.kind === 108 /* ThisKeyword */ && ts.isExpression(location) || ts.isThisInTypeQuery(location)) {
                 return "parameter" /* parameterElement */;
             }
             var flags = ts.getCombinedLocalAndExportSymbolFlags(symbol);
@@ -141529,7 +141674,7 @@ var ts;
             var symbolFlags = ts.getCombinedLocalAndExportSymbolFlags(symbol);
             var symbolKind = semanticMeaning & 1 /* Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) : "" /* unknown */;
             var hasAddedSymbolInfo = false;
-            var isThisExpression = location.kind === 108 /* ThisKeyword */ && ts.isInExpressionContext(location);
+            var isThisExpression = location.kind === 108 /* ThisKeyword */ && ts.isInExpressionContext(location) || ts.isThisInTypeQuery(location);
             var type;
             var printer;
             var documentationFromAlias;
@@ -141942,6 +142087,18 @@ var ts;
                     }
                 }
             }
+            if (documentation.length === 0 && ts.isIdentifier(location) && symbol.valueDeclaration && ts.isBindingElement(symbol.valueDeclaration)) {
+                var declaration = symbol.valueDeclaration;
+                var parent = declaration.parent;
+                if (ts.isIdentifier(declaration.name) && ts.isObjectBindingPattern(parent)) {
+                    var name_4 = ts.getTextOfIdentifierOrLiteral(declaration.name);
+                    var objectType = typeChecker.getTypeAtLocation(parent);
+                    documentation = ts.firstDefined(objectType.isUnion() ? objectType.types : [objectType], function (t) {
+                        var prop = t.getProperty(name_4);
+                        return prop ? prop.getDocumentationComment(typeChecker) : undefined;
+                    }) || ts.emptyArray;
+                }
+            }
             if (tags.length === 0 && !hasMultipleSignatures) {
                 tags = symbol.getContextualJsDocTags(enclosingDeclaration, typeChecker);
             }
@@ -158934,7 +159091,7 @@ var ts;
         var convertParamsToDestructuredObject;
         (function (convertParamsToDestructuredObject) {
             var refactorName = "Convert parameters to destructured object";
-            var minimumParameterLength = 2;
+            var minimumParameterLength = 1;
             var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_parameters_to_destructured_object);
             var toDestructuredAction = {
                 name: refactorName,