@zzzen/pyright-internal 1.1.254

package/dist/common/pathUtils.js

@@ -0,0 +1,762 @@
+"use strict";
+/*
+ * pathUtils.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Pathname utility functions.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileSystemCaseSensitiveInternal = exports.isFileSystemCaseSensitive = exports.normalizePathCase = exports.convertPathToUri = exports.extractPathFromUri = exports.convertUriToPath = exports.isDiskPathRoot = exports.isRootedDiskPath = exports.getRegexEscapedSeparator = exports.getFileSpec = exports.hasPythonExtension = exports.getWildcardRoot = exports.getWildcardRegexPattern = exports.getFileSystemEntriesFromDirEntries = exports.getFileSystemEntries = exports.tryRealpath = exports.tryStat = exports.isFile = exports.isDirectory = exports.normalizePath = exports.stripFileExtension = exports.getFileName = exports.getFileExtension = exports.stripTrailingDirectorySeparator = exports.hasTrailingDirectorySeparator = exports.ensureTrailingDirectorySeparator = exports.comparePathsCaseInsensitive = exports.comparePathsCaseSensitive = exports.getRelativePathComponentsFromDirectory = exports.getRelativePathFromDirectory = exports.getBaseFileName = exports.getAnyExtensionFromPath = exports.changeAnyExtension = exports.containsPath = exports.comparePaths = exports.combinePaths = exports.resolvePaths = exports.normalizeSlashes = exports.directoryExists = exports.fileExists = exports.getFileSize = exports.makeDirectories = exports.getRelativePath = exports.combinePathComponents = exports.reducePathComponents = exports.getPathComponents = exports.getRootLength = exports.getDirectoryPath = exports.forEachAncestorDirectory = exports.FileSpec = void 0;
+exports.getDirectoryChangeKind = exports.getLibraryPathWithoutExtension = void 0;
+const path = __importStar(require("path"));
+const vscode_uri_1 = require("vscode-uri");
+const collectionUtils_1 = require("./collectionUtils");
+const core_1 = require("./core");
+const crypto_1 = require("./crypto");
+const debug = __importStar(require("./debug"));
+const stringUtils_1 = require("./stringUtils");
+let _fsCaseSensitivity = undefined;
+var FileSpec;
+(function (FileSpec) {
+    function is(value) {
+        const candidate = value;
+        return candidate && !!candidate.wildcardRoot && !!candidate.regExp;
+    }
+    FileSpec.is = is;
+})(FileSpec = exports.FileSpec || (exports.FileSpec = {}));
+function forEachAncestorDirectory(directory, callback) {
+    while (true) {
+        const result = callback(directory);
+        if (result !== undefined) {
+            return result;
+        }
+        const parentPath = getDirectoryPath(directory);
+        if (parentPath === directory) {
+            return undefined;
+        }
+        directory = parentPath;
+    }
+}
+exports.forEachAncestorDirectory = forEachAncestorDirectory;
+function getDirectoryPath(pathString) {
+    return pathString.substr(0, Math.max(getRootLength(pathString), pathString.lastIndexOf(path.sep)));
+}
+exports.getDirectoryPath = getDirectoryPath;
+function getRootLength(pathString) {
+    if (pathString.charAt(0) === path.sep) {
+        if (pathString.charAt(1) !== path.sep) {
+            return 1;
+        }
+        const p1 = pathString.indexOf(path.sep, 2);
+        if (p1 < 0) {
+            return 2;
+        }
+        const p2 = pathString.indexOf(path.sep, p1 + 1);
+        if (p2 < 0) {
+            return p1 + 1;
+        }
+        return p2 + 1;
+    }
+    if (pathString.charAt(1) === ':') {
+        if (pathString.charAt(2) === path.sep) {
+            return 3;
+        }
+    }
+    return 0;
+}
+exports.getRootLength = getRootLength;
+function getPathComponents(pathString) {
+    const normalizedPath = normalizeSlashes(pathString);
+    const rootLength = getRootLength(normalizedPath);
+    const root = normalizedPath.substring(0, rootLength);
+    const rest = normalizedPath.substring(rootLength).split(path.sep);
+    if (rest.length > 0 && !rest[rest.length - 1]) {
+        rest.pop();
+    }
+    return reducePathComponents([root, ...rest]);
+}
+exports.getPathComponents = getPathComponents;
+function reducePathComponents(components) {
+    if (!(0, collectionUtils_1.some)(components)) {
+        return [];
+    }
+    // Reduce the path components by eliminating
+    // any '.' or '..'.
+    const reduced = [components[0]];
+    for (let i = 1; i < components.length; i++) {
+        const component = components[i];
+        if (!component || 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;
+}
+exports.reducePathComponents = reducePathComponents;
+function combinePathComponents(components) {
+    if (components.length === 0) {
+        return '';
+    }
+    const root = components[0] && ensureTrailingDirectorySeparator(components[0]);
+    return normalizeSlashes(root + components.slice(1).join(path.sep));
+}
+exports.combinePathComponents = combinePathComponents;
+function getRelativePath(dirPath, relativeTo) {
+    if (!dirPath.startsWith(ensureTrailingDirectorySeparator(relativeTo))) {
+        return undefined;
+    }
+    const pathComponents = getPathComponents(dirPath);
+    const relativeToComponents = getPathComponents(relativeTo);
+    let relativePath = '.';
+    for (let i = relativeToComponents.length; i < pathComponents.length; i++) {
+        relativePath += path.sep + pathComponents[i];
+    }
+    return relativePath;
+}
+exports.getRelativePath = getRelativePath;
+// Creates a directory hierarchy for a path, starting from some ancestor path.
+function makeDirectories(fs, dirPath, startingFromDirPath) {
+    if (!dirPath.startsWith(startingFromDirPath)) {
+        return;
+    }
+    const pathComponents = getPathComponents(dirPath);
+    const relativeToComponents = getPathComponents(startingFromDirPath);
+    let curPath = startingFromDirPath;
+    for (let i = relativeToComponents.length; i < pathComponents.length; i++) {
+        curPath = combinePaths(curPath, pathComponents[i]);
+        if (!fs.existsSync(curPath)) {
+            fs.mkdirSync(curPath);
+        }
+    }
+}
+exports.makeDirectories = makeDirectories;
+function getFileSize(fs, path) {
+    const stat = tryStat(fs, path);
+    if (stat === null || stat === void 0 ? void 0 : stat.isFile()) {
+        return stat.size;
+    }
+    return 0;
+}
+exports.getFileSize = getFileSize;
+function fileExists(fs, path) {
+    return fileSystemEntryExists(fs, path, 0 /* File */);
+}
+exports.fileExists = fileExists;
+function directoryExists(fs, path) {
+    return fileSystemEntryExists(fs, path, 1 /* Directory */);
+}
+exports.directoryExists = directoryExists;
+const getInvalidSeparator = (sep) => (sep === '/' ? '\\' : '/');
+function normalizeSlashes(pathString, sep = path.sep) {
+    if (pathString.includes(getInvalidSeparator(sep))) {
+        const separatorRegExp = /[\\/]/g;
+        return pathString.replace(separatorRegExp, sep);
+    }
+    return pathString;
+}
+exports.normalizeSlashes = normalizeSlashes;
+/**
+ * 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 resolvePaths(path, ...paths) {
+    return normalizePath((0, collectionUtils_1.some)(paths) ? combinePaths(path, ...paths) : normalizeSlashes(path));
+}
+exports.resolvePaths = resolvePaths;
+function combinePaths(pathString, ...paths) {
+    if (pathString) {
+        pathString = normalizeSlashes(pathString);
+    }
+    for (let relativePath of paths) {
+        if (!relativePath) {
+            continue;
+        }
+        relativePath = normalizeSlashes(relativePath);
+        if (!pathString || getRootLength(relativePath) !== 0) {
+            pathString = relativePath;
+        }
+        else {
+            pathString = ensureTrailingDirectorySeparator(pathString) + relativePath;
+        }
+    }
+    return pathString;
+}
+exports.combinePaths = combinePaths;
+function comparePaths(a, b, currentDirectory, ignoreCase) {
+    a = normalizePath(a);
+    b = normalizePath(b);
+    if (typeof currentDirectory === 'string') {
+        a = combinePaths(currentDirectory, a);
+        b = combinePaths(currentDirectory, b);
+    }
+    else if (typeof currentDirectory === 'boolean') {
+        ignoreCase = currentDirectory;
+    }
+    return comparePathsWorker(a, b, (0, stringUtils_1.getStringComparer)(ignoreCase));
+}
+exports.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;
+    }
+    const parentComponents = getPathComponents(parent);
+    const childComponents = getPathComponents(child);
+    if (childComponents.length < parentComponents.length) {
+        return false;
+    }
+    const componentEqualityComparer = ignoreCase ? stringUtils_1.equateStringsCaseInsensitive : stringUtils_1.equateStringsCaseSensitive;
+    for (let i = 0; i < parentComponents.length; i++) {
+        const equalityComparer = i === 0 ? stringUtils_1.equateStringsCaseInsensitive : componentEqualityComparer;
+        if (!equalityComparer(parentComponents[i], childComponents[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.containsPath = containsPath;
+function changeAnyExtension(path, ext, extensions, ignoreCase) {
+    const pathExt = extensions !== undefined && ignoreCase !== undefined
+        ? getAnyExtensionFromPath(path, extensions, ignoreCase)
+        : getAnyExtensionFromPath(path);
+    return pathExt ? path.slice(0, path.length - pathExt.length) + (ext.startsWith('.') ? ext : '.' + ext) : path;
+}
+exports.changeAnyExtension = changeAnyExtension;
+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(stripTrailingDirectorySeparator(path), extensions, ignoreCase ? stringUtils_1.equateStringsCaseInsensitive : stringUtils_1.equateStringsCaseSensitive);
+    }
+    const baseFileName = getBaseFileName(path);
+    const extensionIndex = baseFileName.lastIndexOf('.');
+    if (extensionIndex >= 0) {
+        return baseFileName.substring(extensionIndex);
+    }
+    return '';
+}
+exports.getAnyExtensionFromPath = getAnyExtensionFromPath;
+function getBaseFileName(pathString, extensions, ignoreCase) {
+    pathString = normalizeSlashes(pathString);
+    // if the path provided is itself the root, then it has not file name.
+    const rootLength = getRootLength(pathString);
+    if (rootLength === pathString.length) {
+        return '';
+    }
+    // return the trailing portion of the path starting after the last (non-terminal) directory
+    // separator but not including any trailing directory separator.
+    pathString = stripTrailingDirectorySeparator(pathString);
+    const name = pathString.slice(Math.max(getRootLength(pathString), pathString.lastIndexOf(path.sep) + 1));
+    const extension = extensions !== undefined && ignoreCase !== undefined
+        ? getAnyExtensionFromPath(name, extensions, ignoreCase)
+        : undefined;
+    return extension ? name.slice(0, name.length - extension.length) : name;
+}
+exports.getBaseFileName = getBaseFileName;
+function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
+    const pathComponents = getRelativePathComponentsFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase);
+    return combinePathComponents(pathComponents);
+}
+exports.getRelativePathFromDirectory = getRelativePathFromDirectory;
+function getRelativePathComponentsFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
+    debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, 'Paths must either both be absolute or both be relative');
+    const getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === 'function' ? getCanonicalFileNameOrIgnoreCase : core_1.identity;
+    const ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === 'boolean' ? getCanonicalFileNameOrIgnoreCase : false;
+    const pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? stringUtils_1.equateStringsCaseInsensitive : stringUtils_1.equateStringsCaseSensitive, getCanonicalFileName);
+    return pathComponents;
+}
+exports.getRelativePathComponentsFromDirectory = getRelativePathComponentsFromDirectory;
+/**
+ * Performs a case-sensitive comparison of two paths. Path roots are always compared case-insensitively.
+ */
+function comparePathsCaseSensitive(a, b) {
+    return comparePathsWorker(a, b, stringUtils_1.compareStringsCaseSensitive);
+}
+exports.comparePathsCaseSensitive = comparePathsCaseSensitive;
+/**
+ * Performs a case-insensitive comparison of two paths.
+ */
+function comparePathsCaseInsensitive(a, b) {
+    return comparePathsWorker(a, b, stringUtils_1.compareStringsCaseInsensitive);
+}
+exports.comparePathsCaseInsensitive = comparePathsCaseInsensitive;
+function ensureTrailingDirectorySeparator(pathString) {
+    if (!hasTrailingDirectorySeparator(pathString)) {
+        return pathString + path.sep;
+    }
+    return pathString;
+}
+exports.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator;
+function hasTrailingDirectorySeparator(pathString) {
+    if (pathString.length === 0) {
+        return false;
+    }
+    const ch = pathString.charCodeAt(pathString.length - 1);
+    return ch === 47 /* Slash */ || ch === 92 /* Backslash */;
+}
+exports.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator;
+function stripTrailingDirectorySeparator(pathString) {
+    if (!hasTrailingDirectorySeparator(pathString)) {
+        return pathString;
+    }
+    return pathString.substr(0, pathString.length - 1);
+}
+exports.stripTrailingDirectorySeparator = stripTrailingDirectorySeparator;
+function getFileExtension(fileName, multiDotExtension = false) {
+    if (!multiDotExtension) {
+        return path.extname(fileName);
+    }
+    fileName = getFileName(fileName);
+    const firstDotIndex = fileName.indexOf('.');
+    return fileName.substr(firstDotIndex);
+}
+exports.getFileExtension = getFileExtension;
+function getFileName(pathString) {
+    return path.basename(pathString);
+}
+exports.getFileName = getFileName;
+function stripFileExtension(fileName, multiDotExtension = false) {
+    const ext = getFileExtension(fileName, multiDotExtension);
+    return fileName.substr(0, fileName.length - ext.length);
+}
+exports.stripFileExtension = stripFileExtension;
+function normalizePath(pathString) {
+    return normalizeSlashes(path.normalize(pathString));
+}
+exports.normalizePath = normalizePath;
+function isDirectory(fs, path) {
+    var _a, _b;
+    return (_b = (_a = tryStat(fs, path)) === null || _a === void 0 ? void 0 : _a.isDirectory()) !== null && _b !== void 0 ? _b : false;
+}
+exports.isDirectory = isDirectory;
+function isFile(fs, path, treatZipDirectoryAsFile = false) {
+    var _a, _b;
+    const stats = tryStat(fs, path);
+    if (stats === null || stats === void 0 ? void 0 : stats.isFile()) {
+        return true;
+    }
+    if (!treatZipDirectoryAsFile) {
+        return false;
+    }
+    return (_b = (_a = stats === null || stats === void 0 ? void 0 : stats.isZipDirectory) === null || _a === void 0 ? void 0 : _a.call(stats)) !== null && _b !== void 0 ? _b : false;
+}
+exports.isFile = isFile;
+function tryStat(fs, path) {
+    try {
+        return fs.statSync(path);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.tryStat = tryStat;
+function tryRealpath(fs, path) {
+    try {
+        return fs.realpathSync(path);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.tryRealpath = tryRealpath;
+function getFileSystemEntries(fs, path) {
+    try {
+        return getFileSystemEntriesFromDirEntries(fs.readdirEntriesSync(path || '.'), fs, path);
+    }
+    catch (e) {
+        return { files: [], directories: [] };
+    }
+}
+exports.getFileSystemEntries = getFileSystemEntries;
+// Sorts the entires into files and directories, including any symbolic links.
+function getFileSystemEntriesFromDirEntries(dirEntries, fs, path) {
+    const entries = dirEntries.sort((a, b) => {
+        if (a.name < b.name) {
+            return -1;
+        }
+        else if (a.name > b.name) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    });
+    const files = [];
+    const directories = [];
+    for (const entry of entries) {
+        // This is necessary because on some file system node fails to exclude
+        // "." and "..". See https://github.com/nodejs/node/issues/4002
+        if (entry.name === '.' || entry.name === '..') {
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(entry.name);
+        }
+        else if (entry.isDirectory()) {
+            directories.push(entry.name);
+        }
+        else if (entry.isSymbolicLink()) {
+            const entryPath = combinePaths(path, entry.name);
+            const stat = tryStat(fs, entryPath);
+            if (stat === null || stat === void 0 ? void 0 : stat.isFile()) {
+                files.push(entry.name);
+            }
+            else if (stat === null || stat === void 0 ? void 0 : stat.isDirectory()) {
+                directories.push(entry.name);
+            }
+        }
+    }
+    return { files, directories };
+}
+exports.getFileSystemEntriesFromDirEntries = getFileSystemEntriesFromDirEntries;
+// Transforms a relative file spec (one that potentially contains
+// escape characters **, * or ?) and returns a regular expression
+// that can be used for matching against.
+function getWildcardRegexPattern(rootPath, fileSpec) {
+    let absolutePath = normalizePath(combinePaths(rootPath, fileSpec));
+    if (!hasPythonExtension(absolutePath)) {
+        absolutePath = ensureTrailingDirectorySeparator(absolutePath);
+    }
+    const pathComponents = getPathComponents(absolutePath);
+    const escapedSeparator = getRegexEscapedSeparator();
+    const doubleAsteriskRegexFragment = `(${escapedSeparator}[^${escapedSeparator}.][^${escapedSeparator}]*)*?`;
+    const reservedCharacterPattern = new RegExp(`[^\\w\\s${escapedSeparator}]`, 'g');
+    // Strip the directory separator from the root component.
+    if (pathComponents.length > 0) {
+        pathComponents[0] = stripTrailingDirectorySeparator(pathComponents[0]);
+    }
+    let regExPattern = '';
+    let firstComponent = true;
+    for (let component of pathComponents) {
+        if (component === '**') {
+            regExPattern += doubleAsteriskRegexFragment;
+        }
+        else {
+            if (!firstComponent) {
+                component = escapedSeparator + component;
+            }
+            regExPattern += component.replace(reservedCharacterPattern, (match) => {
+                if (match === '*') {
+                    return `[^${escapedSeparator}]*`;
+                }
+                else if (match === '?') {
+                    return `[^${escapedSeparator}]`;
+                }
+                else {
+                    // escaping anything that is not reserved characters - word/space/separator
+                    return '\\' + match;
+                }
+            });
+            firstComponent = false;
+        }
+    }
+    return regExPattern;
+}
+exports.getWildcardRegexPattern = getWildcardRegexPattern;
+// Returns the topmost path that contains no wildcard characters.
+function getWildcardRoot(rootPath, fileSpec) {
+    let absolutePath = normalizePath(combinePaths(rootPath, fileSpec));
+    if (!hasPythonExtension(absolutePath)) {
+        absolutePath = ensureTrailingDirectorySeparator(absolutePath);
+    }
+    const pathComponents = getPathComponents(absolutePath);
+    // Strip the directory separator from the root component.
+    if (pathComponents.length > 0) {
+        pathComponents[0] = stripTrailingDirectorySeparator(pathComponents[0]);
+    }
+    if (pathComponents.length === 1 && !pathComponents[0]) {
+        return path.sep;
+    }
+    let wildcardRoot = '';
+    let firstComponent = true;
+    for (let component of pathComponents) {
+        if (component === '**') {
+            break;
+        }
+        else {
+            if (component.match(/[*?]/)) {
+                break;
+            }
+            if (!firstComponent) {
+                component = path.sep + component;
+            }
+            wildcardRoot += component;
+            firstComponent = false;
+        }
+    }
+    return wildcardRoot;
+}
+exports.getWildcardRoot = getWildcardRoot;
+function hasPythonExtension(path) {
+    return path.endsWith('.py') || path.endsWith('.pyi');
+}
+exports.hasPythonExtension = hasPythonExtension;
+function getFileSpec(fs, rootPath, fileSpec) {
+    let regExPattern = getWildcardRegexPattern(rootPath, fileSpec);
+    const escapedSeparator = getRegexEscapedSeparator();
+    regExPattern = `^(${regExPattern})($|${escapedSeparator})`;
+    const regExp = new RegExp(regExPattern, isFileSystemCaseSensitive(fs) ? undefined : 'i');
+    const wildcardRoot = getWildcardRoot(rootPath, fileSpec);
+    return {
+        wildcardRoot,
+        regExp,
+    };
+}
+exports.getFileSpec = getFileSpec;
+function getRegexEscapedSeparator() {
+    // we don't need to escape "/" in typescript regular expression
+    return path.sep === '/' ? '/' : '\\\\';
+}
+exports.getRegexEscapedSeparator = getRegexEscapedSeparator;
+/**
+ * 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 getRootLength(path) > 0;
+}
+exports.isRootedDiskPath = isRootedDiskPath;
+/**
+ * Determines whether a path consists only of a path root.
+ */
+function isDiskPathRoot(path) {
+    const rootLength = getRootLength(path);
+    return rootLength > 0 && rootLength === path.length;
+}
+exports.isDiskPathRoot = isDiskPathRoot;
+//// Path Comparisons
+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.
+    const aRoot = a.substring(0, getRootLength(a));
+    const bRoot = b.substring(0, getRootLength(b));
+    const result = (0, stringUtils_1.compareStringsCaseInsensitive)(aRoot, bRoot);
+    if (result !== 0 /* EqualTo */) {
+        return result;
+    }
+    // check path for these segments: '', '.'. '..'
+    const escapedSeparator = getRegexEscapedSeparator();
+    const relativePathSegmentRegExp = new RegExp(`(^|${escapedSeparator}).{0,2}($|${escapedSeparator})`);
+    // NOTE: Performance optimization - shortcut if there are no relative path segments in
+    //       the non-root portion of the path
+    const aRest = a.substring(aRoot.length);
+    const 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.
+    const aComponents = getPathComponents(a);
+    const bComponents = getPathComponents(b);
+    const sharedLength = Math.min(aComponents.length, bComponents.length);
+    for (let i = 1; i < sharedLength; i++) {
+        const result = componentComparer(aComponents[i], bComponents[i]);
+        if (result !== 0 /* EqualTo */) {
+            return result;
+        }
+    }
+    return (0, core_1.compareValues)(aComponents.length, bComponents.length);
+}
+function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
+    if (typeof extensions === 'string') {
+        return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || '';
+    }
+    for (const extension of extensions) {
+        const result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
+        if (result) {
+            return result;
+        }
+    }
+    return '';
+}
+function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+    if (!extension.startsWith('.')) {
+        extension = '.' + extension;
+    }
+    if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* Period */) {
+        const pathExtension = path.slice(path.length - extension.length);
+        if (stringEqualityComparer(pathExtension, extension)) {
+            return pathExtension;
+        }
+    }
+    return undefined;
+}
+function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
+    const fromComponents = getPathComponents(from);
+    const toComponents = getPathComponents(to);
+    let start;
+    for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
+        const fromComponent = getCanonicalFileName(fromComponents[start]);
+        const toComponent = getCanonicalFileName(toComponents[start]);
+        const comparer = start === 0 ? stringUtils_1.equateStringsCaseInsensitive : stringEqualityComparer;
+        if (!comparer(fromComponent, toComponent)) {
+            break;
+        }
+    }
+    if (start === 0) {
+        return toComponents;
+    }
+    const components = toComponents.slice(start);
+    const relative = [];
+    for (; start < fromComponents.length; start++) {
+        relative.push('..');
+    }
+    return ['', ...relative, ...components];
+}
+function fileSystemEntryExists(fs, path, entryKind) {
+    try {
+        const stat = fs.statSync(path);
+        switch (entryKind) {
+            case 0 /* File */:
+                return stat.isFile();
+            case 1 /* Directory */:
+                return stat.isDirectory();
+            default:
+                return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+}
+function convertUriToPath(fs, uriString) {
+    return fs.getMappedFilePath(extractPathFromUri(uriString));
+}
+exports.convertUriToPath = convertUriToPath;
+function extractPathFromUri(uriString) {
+    const uri = vscode_uri_1.URI.parse(uriString);
+    let convertedPath = normalizePath(uri.path);
+    // If this is a DOS-style path with a drive letter, remove
+    // the leading slash.
+    if (convertedPath.match(/^\\[a-zA-Z]:\\/)) {
+        convertedPath = convertedPath.substr(1);
+    }
+    return convertedPath;
+}
+exports.extractPathFromUri = extractPathFromUri;
+function convertPathToUri(fs, path) {
+    return fs.getUri(fs.getOriginalFilePath(path));
+}
+exports.convertPathToUri = convertPathToUri;
+// For file systems that are case-insensitive, returns a lowercase
+// version of the path. For case-sensitive file systems, leaves the
+// path as is.
+function normalizePathCase(fs, path) {
+    if (isFileSystemCaseSensitive(fs)) {
+        return path;
+    }
+    return path.toLowerCase();
+}
+exports.normalizePathCase = normalizePathCase;
+function isFileSystemCaseSensitive(fs) {
+    if (_fsCaseSensitivity !== undefined) {
+        return _fsCaseSensitivity;
+    }
+    _fsCaseSensitivity = isFileSystemCaseSensitiveInternal(fs);
+    return _fsCaseSensitivity;
+}
+exports.isFileSystemCaseSensitive = isFileSystemCaseSensitive;
+function isFileSystemCaseSensitiveInternal(fs) {
+    let filePath = undefined;
+    try {
+        // Make unique file name.
+        let name;
+        let mangledFilePath;
+        do {
+            name = `${(0, crypto_1.randomBytesHex)(21)}-a`;
+            filePath = path.join(fs.tmpdir(), name);
+            mangledFilePath = path.join(fs.tmpdir(), name.toUpperCase());
+        } while (fs.existsSync(filePath) || fs.existsSync(mangledFilePath));
+        fs.writeFileSync(filePath, '', 'utf8');
+        // If file exists, then it is insensitive.
+        return !fs.existsSync(mangledFilePath);
+    }
+    catch (e) {
+        return false;
+    }
+    finally {
+        if (filePath) {
+            // remove temp file created
+            fs.unlinkSync(filePath);
+        }
+    }
+}
+exports.isFileSystemCaseSensitiveInternal = isFileSystemCaseSensitiveInternal;
+function getLibraryPathWithoutExtension(libraryFilePath) {
+    let filePathWithoutExtension = stripFileExtension(libraryFilePath);
+    // Strip off the '/__init__' if it's present.
+    if (filePathWithoutExtension.endsWith('__init__')) {
+        filePathWithoutExtension = filePathWithoutExtension.substr(0, filePathWithoutExtension.length - 9);
+    }
+    return filePathWithoutExtension;
+}
+exports.getLibraryPathWithoutExtension = getLibraryPathWithoutExtension;
+function getDirectoryChangeKind(fs, oldDirectory, newDirectory) {
+    if (fs.realCasePath(oldDirectory) === fs.realCasePath(newDirectory)) {
+        return 'Same';
+    }
+    const relativePaths = getRelativePathComponentsFromDirectory(oldDirectory, newDirectory, (f) => fs.realCasePath(f));
+    // 3 means only last folder name has changed.
+    if (relativePaths.length === 3 && relativePaths[1] === '..' && relativePaths[2] !== '..') {
+        return 'Renamed';
+    }
+    return 'Moved';
+}
+exports.getDirectoryChangeKind = getDirectoryChangeKind;
+//# sourceMappingURL=pathUtils.js.map