@volar/typescript 1.6.8 → 1.7.0

package/out/typescript/path.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsPath = exports.removeTrailingDirectorySeparator = exports.normalizePath = exports.getNormalizedPathComponents = exports.combinePaths = exports.getDirectoryPath = exports.fileExtensionIsOneOf = exports.hasExtension = exports.isRootedDiskPath = exports.directorySeparator = void 0;
+const core_1 = require("./core");
+/**
+ * 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.
+ */
+exports.directorySeparator = "/";
+const altDirectorySeparator = "\\";
+const urlSchemeSeparator = "://";
+const backslashRegExp = /\\/g;
+//// Path Tests
+/**
+ * Determines whether a charCode corresponds to `/` or `\`.
+ */
+function isAnyDirectorySeparator(charCode) {
+    return charCode === 47 /* CharacterCodes.slash */ || charCode === 92 /* CharacterCodes.backslash */;
+}
+/**
+ * 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;
+}
+exports.isRootedDiskPath = isRootedDiskPath;
+function hasExtension(fileName) {
+    return (0, core_1.stringContains)(getBaseFileName(fileName), ".");
+}
+exports.hasExtension = hasExtension;
+function fileExtensionIs(path, extension) {
+    return path.length > extension.length && (0, core_1.endsWith)(path, extension);
+}
+function fileExtensionIsOneOf(path, extensions) {
+    for (const extension of extensions) {
+        if (fileExtensionIs(path, extension)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.fileExtensionIsOneOf = fileExtensionIsOneOf;
+/**
+ * Determines whether a path has a trailing separator (`/` or `\\`).
+ */
+function hasTrailingDirectorySeparator(path) {
+    return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+}
+//// Path Parsing
+function isVolumeCharacter(charCode) {
+    return (charCode >= 97 /* CharacterCodes.a */ && charCode <= 122 /* CharacterCodes.z */) ||
+        (charCode >= 65 /* CharacterCodes.A */ && charCode <= 90 /* CharacterCodes.Z */);
+}
+function getFileUrlVolumeSeparatorEnd(url, start) {
+    const ch0 = url.charCodeAt(start);
+    if (ch0 === 58 /* CharacterCodes.colon */)
+        return start + 1;
+    if (ch0 === 37 /* CharacterCodes.percent */ && url.charCodeAt(start + 1) === 51 /* CharacterCodes._3 */) {
+        const ch2 = url.charCodeAt(start + 2);
+        if (ch2 === 97 /* CharacterCodes.a */ || ch2 === 65 /* CharacterCodes.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;
+    const ch0 = path.charCodeAt(0);
+    // POSIX or UNC
+    if (ch0 === 47 /* CharacterCodes.slash */ || ch0 === 92 /* CharacterCodes.backslash */) {
+        if (path.charCodeAt(1) !== ch0)
+            return 1; // POSIX: "/" (or non-normalized "\")
+        const p1 = path.indexOf(ch0 === 47 /* CharacterCodes.slash */ ? exports.directorySeparator : 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 /* CharacterCodes.colon */) {
+        const ch2 = path.charCodeAt(2);
+        if (ch2 === 47 /* CharacterCodes.slash */ || ch2 === 92 /* CharacterCodes.backslash */)
+            return 3; // DOS: "c:/" or "c:\"
+        if (path.length === 2)
+            return 2; // DOS: "c:" (but not "c:d")
+    }
+    // URL
+    const schemeEnd = path.indexOf(urlSchemeSeparator);
+    if (schemeEnd !== -1) {
+        const authorityStart = schemeEnd + urlSchemeSeparator.length;
+        const authorityEnd = path.indexOf(exports.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".
+            const scheme = path.slice(0, schemeEnd);
+            const authority = path.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") &&
+                isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+                const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+                if (volumeSeparatorEnd !== -1) {
+                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* CharacterCodes.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) {
+    const rootLength = getEncodedRootLength(path);
+    return rootLength < 0 ? ~rootLength : rootLength;
+}
+function getDirectoryPath(path) {
+    path = normalizeSlashes(path);
+    // If the path provided is itself the root, then return it.
+    const 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(exports.directorySeparator)));
+}
+exports.getDirectoryPath = getDirectoryPath;
+function getBaseFileName(path, extensions, ignoreCase) {
+    path = normalizeSlashes(path);
+    // if the path provided is itself the root, then it has not file name.
+    const 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);
+    const name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(exports.directorySeparator) + 1));
+    const extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
+    return extension ? name.slice(0, name.length - extension.length) : name;
+}
+function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+    if (!(0, core_1.startsWith)(extension, "."))
+        extension = "." + extension;
+    if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* CharacterCodes.dot */) {
+        const 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 (const extension of extensions) {
+        const 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 ? core_1.equateStringsCaseInsensitive : core_1.equateStringsCaseSensitive);
+    }
+    const baseFileName = getBaseFileName(path);
+    const extensionIndex = baseFileName.lastIndexOf(".");
+    if (extensionIndex >= 0) {
+        return baseFileName.substring(extensionIndex);
+    }
+    return "";
+}
+function pathComponents(path, rootLength) {
+    const root = path.substring(0, rootLength);
+    const rest = path.substring(rootLength).split(exports.directorySeparator);
+    if (rest.length && !(0, core_1.lastOrUndefined)(rest))
+        rest.pop();
+    return [root, ...rest];
+}
+/**
+ * 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 = "") {
+    path = combinePaths(currentDirectory, path);
+    return pathComponents(path, getRootLength(path));
+}
+//// 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 "";
+    const root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
+    return root + pathComponents.slice(1).join(exports.directorySeparator);
+}
+//// Path Normalization
+/**
+ * Normalize path separators, converting `\` into `/`.
+ */
+function normalizeSlashes(path) {
+    return path.indexOf("\\") !== -1
+        ? path.replace(backslashRegExp, exports.directorySeparator)
+        : path;
+}
+/**
+ * Reduce an array of path components to a more simplified path by navigating any
+ * `"."` or `".."` entries in the path.
+ */
+function reducePathComponents(components) {
+    if (!(0, core_1.some)(components))
+        return [];
+    const reduced = [components[0]];
+    for (let i = 1; i < components.length; i++) {
+        const 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;
+}
+/**
+ * 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, ...paths) {
+    if (path)
+        path = normalizeSlashes(path);
+    for (let relativePath of paths) {
+        if (!relativePath)
+            continue;
+        relativePath = normalizeSlashes(relativePath);
+        if (!path || getRootLength(relativePath) !== 0) {
+            path = relativePath;
+        }
+        else {
+            path = ensureTrailingDirectorySeparator(path) + relativePath;
+        }
+    }
+    return path;
+}
+exports.combinePaths = combinePaths;
+/**
+ * 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));
+}
+exports.getNormalizedPathComponents = getNormalizedPathComponents;
+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 `./`
+    const simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
+    if (simplified !== path) {
+        path = simplified;
+        if (!relativePathSegmentRegExp.test(path)) {
+            return path;
+        }
+    }
+    // Other paths require full normalization
+    const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+    return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+}
+exports.normalizePath = normalizePath;
+function removeTrailingDirectorySeparator(path) {
+    if (hasTrailingDirectorySeparator(path)) {
+        return path.substr(0, path.length - 1);
+    }
+    return path;
+}
+exports.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
+function ensureTrailingDirectorySeparator(path) {
+    if (!hasTrailingDirectorySeparator(path)) {
+        return path + exports.directorySeparator;
+    }
+    return path;
+}
+//// Path Comparisons
+// check path for these segments: '', '.'. '..'
+const relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
+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 = reducePathComponents(getPathComponents(parent));
+    const childComponents = reducePathComponents(getPathComponents(child));
+    if (childComponents.length < parentComponents.length) {
+        return false;
+    }
+    const componentEqualityComparer = ignoreCase ? core_1.equateStringsCaseInsensitive : core_1.equateStringsCaseSensitive;
+    for (let i = 0; i < parentComponents.length; i++) {
+        const equalityComparer = i === 0 ? core_1.equateStringsCaseInsensitive : componentEqualityComparer;
+        if (!equalityComparer(parentComponents[i], childComponents[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.containsPath = containsPath;
+//# sourceMappingURL=path.js.map

package/out/typescript/types.d.ts

@@ -0,0 +1,129 @@
+export type Path = string & {
+    __pathBrand: any;
+};
+export declare const enum CharacterCodes {
+    nullCharacter = 0,
+    maxAsciiCharacter = 127,
+    lineFeed = 10,
+    carriageReturn = 13,
+    lineSeparator = 8232,
+    paragraphSeparator = 8233,
+    nextLine = 133,
+    space = 32,
+    nonBreakingSpace = 160,
+    enQuad = 8192,
+    emQuad = 8193,
+    enSpace = 8194,
+    emSpace = 8195,
+    threePerEmSpace = 8196,
+    fourPerEmSpace = 8197,
+    sixPerEmSpace = 8198,
+    figureSpace = 8199,
+    punctuationSpace = 8200,
+    thinSpace = 8201,
+    hairSpace = 8202,
+    zeroWidthSpace = 8203,
+    narrowNoBreakSpace = 8239,
+    ideographicSpace = 12288,
+    mathematicalSpace = 8287,
+    ogham = 5760,
+    _ = 95,
+    $ = 36,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    ampersand = 38,
+    asterisk = 42,
+    at = 64,
+    backslash = 92,
+    backtick = 96,
+    bar = 124,
+    caret = 94,
+    closeBrace = 125,
+    closeBracket = 93,
+    closeParen = 41,
+    colon = 58,
+    comma = 44,
+    dot = 46,
+    doubleQuote = 34,
+    equals = 61,
+    exclamation = 33,
+    greaterThan = 62,
+    hash = 35,
+    lessThan = 60,
+    minus = 45,
+    openBrace = 123,
+    openBracket = 91,
+    openParen = 40,
+    percent = 37,
+    plus = 43,
+    question = 63,
+    semicolon = 59,
+    singleQuote = 39,
+    slash = 47,
+    tilde = 126,
+    backspace = 8,
+    formFeed = 12,
+    byteOrderMark = 65279,
+    tab = 9,
+    verticalTab = 11
+}

package/out/typescript/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/out/typescript/utilities.d.ts

@@ -0,0 +1,7 @@
+interface FileSystemEntries {
+    readonly files: readonly string[];
+    readonly directories: readonly string[];
+}
+/** @param path directory of the tsconfig.json */
+export declare function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string): string[];
+export {};