@volar/typescript 1.6.9 → 1.7.1-patch.1

package/out/typescript/core.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startsWith = exports.createGetCanonicalFileName = exports.stringContains = exports.endsWith = exports.getStringComparer = exports.compareStringsCaseSensitive = exports.equateStringsCaseSensitive = exports.equateStringsCaseInsensitive = exports.last = exports.lastOrUndefined = exports.sort = exports.some = exports.flatMap = exports.flatten = exports.map = exports.indexOfAnyCharCode = exports.findIndex = exports.every = void 0;
+const emptyArray = [];
+/**
+ * Iterates through `array` by index and performs the callback on each element of array until the callback
+ * returns a falsey value, then returns false.
+ * If no such value is found, the callback is applied to each element of array and `true` is returned.
+ */
+function every(array, callback) {
+    if (array) {
+        for (let i = 0; i < array.length; i++) {
+            if (!callback(array[i], i)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.every = every;
+/** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
+function findIndex(array, predicate, startIndex) {
+    if (array === undefined)
+        return -1;
+    for (let i = startIndex ?? 0; i < array.length; i++) {
+        if (predicate(array[i], i)) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.findIndex = findIndex;
+function contains(array, value, equalityComparer = equateValues) {
+    if (array) {
+        for (const v of array) {
+            if (equalityComparer(v, value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function indexOfAnyCharCode(text, charCodes, start) {
+    for (let i = start || 0; i < text.length; i++) {
+        if (contains(charCodes, text.charCodeAt(i))) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.indexOfAnyCharCode = indexOfAnyCharCode;
+function map(array, f) {
+    let result;
+    if (array) {
+        result = [];
+        for (let i = 0; i < array.length; i++) {
+            result.push(f(array[i], i));
+        }
+    }
+    return result;
+}
+exports.map = map;
+/**
+ * Flattens an array containing a mix of array or non-array elements.
+ *
+ * @param array The array to flatten.
+ */
+function flatten(array) {
+    const result = [];
+    for (const v of array) {
+        if (v) {
+            if (isArray(v)) {
+                addRange(result, v);
+            }
+            else {
+                result.push(v);
+            }
+        }
+    }
+    return result;
+}
+exports.flatten = flatten;
+/**
+ * Maps an array. If the mapped value is an array, it is spread into the result.
+ *
+ * @param array The array to map.
+ * @param mapfn The callback used to map the result into one or more values.
+ */
+function flatMap(array, mapfn) {
+    let result;
+    if (array) {
+        for (let i = 0; i < array.length; i++) {
+            const v = mapfn(array[i], i);
+            if (v) {
+                if (isArray(v)) {
+                    result = addRange(result, v);
+                }
+                else {
+                    result = append(result, v);
+                }
+            }
+        }
+    }
+    return result || emptyArray;
+}
+exports.flatMap = flatMap;
+function some(array, predicate) {
+    if (array) {
+        if (predicate) {
+            for (const v of array) {
+                if (predicate(v)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            return array.length > 0;
+        }
+    }
+    return false;
+}
+exports.some = some;
+// function append<T>(to: T[] | undefined, value: T): T[];
+// function append<T>(to: T[] | undefined, value: T | undefined): T[] | undefined;
+// function append<T>(to: Push<T>, value: T | undefined): void;
+function append(to, value) {
+    if (value === undefined)
+        return to;
+    if (to === undefined)
+        return [value];
+    to.push(value);
+    return to;
+}
+/**
+ * Gets the actual offset into an array for a relative offset. Negative offsets indicate a
+ * position offset from the end of the array.
+ */
+function toOffset(array, offset) {
+    return offset < 0 ? array.length + offset : offset;
+}
+function addRange(to, from, start, end) {
+    if (from === undefined || from.length === 0)
+        return to;
+    if (to === undefined)
+        return from.slice(start, end);
+    start = start === undefined ? 0 : toOffset(from, start);
+    end = end === undefined ? from.length : toOffset(from, end);
+    for (let i = start; i < end && i < from.length; i++) {
+        if (from[i] !== undefined) {
+            to.push(from[i]);
+        }
+    }
+    return to;
+}
+/**
+ * Returns a new sorted array.
+ */
+function sort(array, comparer) {
+    return (array.length === 0 ? array : array.slice().sort(comparer));
+}
+exports.sort = sort;
+/**
+ * Returns the last element of an array if non-empty, `undefined` otherwise.
+ */
+function lastOrUndefined(array) {
+    return array === undefined || array.length === 0 ? undefined : array[array.length - 1];
+}
+exports.lastOrUndefined = lastOrUndefined;
+function last(array) {
+    // Debug.assert(array.length !== 0);
+    return array[array.length - 1];
+}
+exports.last = last;
+/**
+ * Tests whether a value is an array.
+ */
+function isArray(value) {
+    return Array.isArray ? Array.isArray(value) : value instanceof Array;
+}
+/** Returns its argument. */
+function identity(x) {
+    return x;
+}
+/** Returns lower case string */
+function toLowerCase(x) {
+    return x.toLowerCase();
+}
+// We convert the file names to lower case as key for file name on case insensitive file system
+// While doing so we need to handle special characters (eg \u0130) to ensure that we dont convert
+// it to lower case, fileName with its lowercase form can exist along side it.
+// Handle special characters and make those case sensitive instead
+//
+// |-#--|-Unicode--|-Char code-|-Desc-------------------------------------------------------------------|
+// | 1. | i        | 105       | Ascii i                                                                |
+// | 2. | I        | 73        | Ascii I                                                                |
+// |-------- Special characters ------------------------------------------------------------------------|
+// | 3. | \u0130   | 304       | Upper case I with dot above                                            |
+// | 4. | i,\u0307 | 105,775   | i, followed by 775: Lower case of (3rd item)                           |
+// | 5. | I,\u0307 | 73,775    | I, followed by 775: Upper case of (4th item), lower case is (4th item) |
+// | 6. | \u0131   | 305       | Lower case i without dot, upper case is I (2nd item)                   |
+// | 7. | \u00DF   | 223       | Lower case sharp s                                                     |
+//
+// Because item 3 is special where in its lowercase character has its own
+// upper case form we cant convert its case.
+// Rest special characters are either already in lower case format or
+// they have corresponding upper case character so they dont need special handling
+//
+// But to avoid having to do string building for most common cases, also ignore
+// a-z, 0-9, \u0131, \u00DF, \, /, ., : and space
+const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
+/**
+ * Case insensitive file systems have descripencies in how they handle some characters (eg. turkish Upper case I with dot on top - \u0130)
+ * This function is used in places where we want to make file name as a key on these systems
+ * It is possible on mac to be able to refer to file name with I with dot on top as a fileName with its lower case form
+ * But on windows we cannot. Windows can have fileName with I with dot on top next to its lower case and they can not each be referred with the lowercase forms
+ * Technically we would want this function to be platform sepcific as well but
+ * our api has till now only taken caseSensitive as the only input and just for some characters we dont want to update API and ensure all customers use those api
+ * We could use upper case and we would still need to deal with the descripencies but
+ * we want to continue using lower case since in most cases filenames are lowercasewe and wont need any case changes and avoid having to store another string for the key
+ * So for this function purpose, we go ahead and assume character I with dot on top it as case sensitive since its very unlikely to use lower case form of that special character
+ */
+function toFileNameLowerCase(x) {
+    return fileNameLowerCaseRegExp.test(x) ?
+        x.replace(fileNameLowerCaseRegExp, toLowerCase) :
+        x;
+}
+function equateValues(a, b) {
+    return a === b;
+}
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+function equateStringsCaseInsensitive(a, b) {
+    return a === b
+        || a !== undefined
+            && b !== undefined
+            && a.toUpperCase() === b.toUpperCase();
+}
+exports.equateStringsCaseInsensitive = equateStringsCaseInsensitive;
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the
+ * integer value of each code-point.
+ */
+function equateStringsCaseSensitive(a, b) {
+    return equateValues(a, b);
+}
+exports.equateStringsCaseSensitive = equateStringsCaseSensitive;
+function compareComparableValues(a, b) {
+    return a === b ? 0 /* Comparison.EqualTo */ :
+        a === undefined ? -1 /* Comparison.LessThan */ :
+            b === undefined ? 1 /* Comparison.GreaterThan */ :
+                a < b ? -1 /* Comparison.LessThan */ :
+                    1 /* Comparison.GreaterThan */;
+}
+/**
+ * Compare two strings using a case-insensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-insensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+function compareStringsCaseInsensitive(a, b) {
+    if (a === b)
+        return 0 /* Comparison.EqualTo */;
+    if (a === undefined)
+        return -1 /* Comparison.LessThan */;
+    if (b === undefined)
+        return 1 /* Comparison.GreaterThan */;
+    a = a.toUpperCase();
+    b = b.toUpperCase();
+    return a < b ? -1 /* Comparison.LessThan */ : a > b ? 1 /* Comparison.GreaterThan */ : 0 /* Comparison.EqualTo */;
+}
+/**
+ * Compare two strings using a case-sensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point.
+ */
+function compareStringsCaseSensitive(a, b) {
+    return compareComparableValues(a, b);
+}
+exports.compareStringsCaseSensitive = compareStringsCaseSensitive;
+function getStringComparer(ignoreCase) {
+    return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
+}
+exports.getStringComparer = getStringComparer;
+function endsWith(str, suffix) {
+    const expectedPos = str.length - suffix.length;
+    return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
+}
+exports.endsWith = endsWith;
+function stringContains(str, substring) {
+    return str.indexOf(substring) !== -1;
+}
+exports.stringContains = stringContains;
+function createGetCanonicalFileName(useCaseSensitiveFileNames) {
+    return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
+}
+exports.createGetCanonicalFileName = createGetCanonicalFileName;
+function startsWith(str, prefix) {
+    return str.lastIndexOf(prefix, 0) === 0;
+}
+exports.startsWith = startsWith;
+//# sourceMappingURL=core.js.map

package/out/typescript/corePublic.d.ts

@@ -0,0 +1,91 @@
+export declare const versionMajorMinor = "4.9";
+/** The version of the TypeScript compiler release */
+export declare const version: string;
+/**
+ * Type of objects whose values are all of the same type.
+ * The `in` and `for-in` operators can *not* be safely used,
+ * since `Object.prototype` may be modified by outside code.
+ */
+export interface MapLike<T> {
+    [index: string]: T;
+}
+export interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
+    " __sortedArrayBrand": any;
+}
+export interface SortedArray<T> extends Array<T> {
+    " __sortedArrayBrand": any;
+}
+/** Common read methods for ES6 Map/Set. */
+export interface ReadonlyCollection<K> {
+    readonly size: number;
+    has(key: K): boolean;
+    keys(): Iterator<K>;
+}
+/** Common write methods for ES6 Map/Set. */
+export interface Collection<K> extends ReadonlyCollection<K> {
+    delete(key: K): boolean;
+    clear(): void;
+}
+/** ES6 Map interface, only read methods included. */
+export interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {
+    get(key: K): V | undefined;
+    values(): Iterator<V>;
+    entries(): Iterator<[K, V]>;
+    forEach(action: (value: V, key: K) => void): void;
+}
+/**
+ * ES6 Map interface, only read methods included.
+ */
+export interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
+}
+/** ES6 Map interface. */
+export interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {
+    set(key: K, value: V): this;
+}
+/**
+ * ES6 Map interface.
+ */
+export interface Map<T> extends ESMap<string, T> {
+}
+export interface MapConstructor {
+    new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyESMap<K, V>): ESMap<K, V>;
+}
+/** ES6 Set interface, only read methods included. */
+export interface ReadonlySet<T> extends ReadonlyCollection<T> {
+    has(value: T): boolean;
+    values(): Iterator<T>;
+    entries(): Iterator<[T, T]>;
+    forEach(action: (value: T, key: T) => void): void;
+}
+/** ES6 Set interface. */
+export interface Set<T> extends ReadonlySet<T>, Collection<T> {
+    add(value: T): this;
+    delete(value: T): boolean;
+}
+export interface SetConstructor {
+    new <T>(iterable?: readonly T[] | ReadonlySet<T>): Set<T>;
+}
+/** ES6 Iterator type. */
+export interface Iterator<T> {
+    next(): {
+        value: T;
+        done?: false;
+    } | {
+        value: void;
+        done: true;
+    };
+}
+/** Array that is only intended to be pushed to, never read. */
+export interface Push<T> {
+    push(...values: T[]): void;
+    readonly length: number;
+}
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+export type Comparer<T> = (a: T, b: T) => Comparison;
+export declare const enum Comparison {
+    LessThan = -1,
+    EqualTo = 0,
+    GreaterThan = 1
+}
+export declare const Map: MapConstructor;
+export declare const Set: SetConstructor;

package/out/typescript/corePublic.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Set = exports.Map = exports.version = exports.versionMajorMinor = void 0;
+// WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
+// If changing the text in this section, be sure to test `configurePrerelease` too.
+exports.versionMajorMinor = "4.9";
+// 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
+exports.version = `${exports.versionMajorMinor}.0-dev`;
+/* @internal */
+var NativeCollections;
+(function (NativeCollections) {
+    const globals = typeof globalThis !== "undefined" ? globalThis :
+        typeof global !== "undefined" ? global :
+            typeof self !== "undefined" ? self :
+                undefined;
+    /**
+     * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+     */
+    function tryGetNativeMap() {
+        // Internet Explorer's Map doesn't support iteration, so don't use it.
+        const gMap = globals?.Map;
+        // eslint-disable-next-line local/no-in-operator
+        const constructor = typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined;
+        if (!constructor) {
+            throw new Error("No compatible Map implementation found.");
+        }
+        return constructor;
+    }
+    NativeCollections.tryGetNativeMap = tryGetNativeMap;
+    /**
+     * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
+     */
+    function tryGetNativeSet() {
+        // Internet Explorer's Set doesn't support iteration, so don't use it.
+        const gSet = globals?.Set;
+        // eslint-disable-next-line local/no-in-operator
+        const constructor = typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined;
+        if (!constructor) {
+            throw new Error("No compatible Set implementation found.");
+        }
+        return constructor;
+    }
+    NativeCollections.tryGetNativeSet = tryGetNativeSet;
+})(NativeCollections || (NativeCollections = {}));
+/* @internal */
+exports.Map = NativeCollections.tryGetNativeMap();
+/* @internal */
+exports.Set = NativeCollections.tryGetNativeSet();
+//# sourceMappingURL=corePublic.js.map

package/out/typescript/path.d.ts

@@ -0,0 +1,112 @@
+import { Path } from "./types";
+/**
+ * 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.
+ */
+export declare const directorySeparator = "/";
+/**
+ * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
+ * like `c:`, `c:\` or `c:/`).
+ */
+export declare function isRootedDiskPath(path: string): boolean;
+export declare function hasExtension(fileName: string): boolean;
+export declare function fileExtensionIsOneOf(path: string, extensions: readonly string[]): boolean;
+/**
+ * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
+ * except that we support URLs as well.
+ *
+ * ```ts
+ * // POSIX
+ * getDirectoryPath("/path/to/file.ext") === "/path/to"
+ * getDirectoryPath("/path/to/") === "/path"
+ * getDirectoryPath("/") === "/"
+ * // DOS
+ * getDirectoryPath("c:/path/to/file.ext") === "c:/path/to"
+ * getDirectoryPath("c:/path/to/") === "c:/path"
+ * getDirectoryPath("c:/") === "c:/"
+ * getDirectoryPath("c:") === "c:"
+ * // URL
+ * getDirectoryPath("http://typescriptlang.org/path/to/file.ext") === "http://typescriptlang.org/path/to"
+ * getDirectoryPath("http://typescriptlang.org/path/to") === "http://typescriptlang.org/path"
+ * getDirectoryPath("http://typescriptlang.org/") === "http://typescriptlang.org/"
+ * getDirectoryPath("http://typescriptlang.org") === "http://typescriptlang.org"
+ * ```
+ */
+export declare function getDirectoryPath(path: Path): Path;
+/**
+ * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
+ * except that we support URLs as well.
+ *
+ * ```ts
+ * // POSIX
+ * getDirectoryPath("/path/to/file.ext") === "/path/to"
+ * getDirectoryPath("/path/to/") === "/path"
+ * getDirectoryPath("/") === "/"
+ * // DOS
+ * getDirectoryPath("c:/path/to/file.ext") === "c:/path/to"
+ * getDirectoryPath("c:/path/to/") === "c:/path"
+ * getDirectoryPath("c:/") === "c:/"
+ * getDirectoryPath("c:") === "c:"
+ * // URL
+ * getDirectoryPath("http://typescriptlang.org/path/to/file.ext") === "http://typescriptlang.org/path/to"
+ * getDirectoryPath("http://typescriptlang.org/path/to") === "http://typescriptlang.org/path"
+ * getDirectoryPath("http://typescriptlang.org/") === "http://typescriptlang.org/"
+ * getDirectoryPath("http://typescriptlang.org") === "http://typescriptlang.org"
+ * getDirectoryPath("file://server/path/to/file.ext") === "file://server/path/to"
+ * getDirectoryPath("file://server/path/to") === "file://server/path"
+ * getDirectoryPath("file://server/") === "file://server/"
+ * getDirectoryPath("file://server") === "file://server"
+ * getDirectoryPath("file:///path/to/file.ext") === "file:///path/to"
+ * getDirectoryPath("file:///path/to") === "file:///path"
+ * getDirectoryPath("file:///") === "file:///"
+ * getDirectoryPath("file://") === "file://"
+ * ```
+ */
+export declare function getDirectoryPath(path: string): string;
+/**
+ * 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"
+ * ```
+ */
+export declare function combinePaths(path: string, ...paths: (string | undefined)[]): string;
+/**
+ * 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"]
+ * ```
+ */
+export declare function getNormalizedPathComponents(path: string, currentDirectory: string | undefined): string[];
+export declare function normalizePath(path: string): string;
+/**
+ * Removes a trailing directory separator from a path, if it does not already have one.
+ *
+ * ```ts
+ * removeTrailingDirectorySeparator("/path/to/file.ext") === "/path/to/file.ext"
+ * removeTrailingDirectorySeparator("/path/to/file.ext/") === "/path/to/file.ext"
+ * ```
+ */
+export declare function removeTrailingDirectorySeparator(path: Path): Path;
+export declare function removeTrailingDirectorySeparator(path: string): string;
+/**
+ * Determines whether a `parent` path contains a `child` path using the provide case sensitivity.
+ */
+export declare function containsPath(parent: string, child: string, ignoreCase?: boolean): boolean;
+export declare function containsPath(parent: string, child: string, currentDirectory: string, ignoreCase?: boolean): boolean;