@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/base/common/strings.d.ts

@@ -1,14 +1,55 @@
 export declare function isFalsyOrWhitespace(str: string | undefined): boolean;
+/**
+ * Helper to produce a string with a variable number of arguments. Insert variable segments
+ * into the string using the {n} notation where N is the index of the argument following the string.
+ * @param value string to which formatting is applied
+ * @param args replacements for {n}-entries
+ */
 export declare function format(value: string, ...args: any[]): string;
+/**
+ * Helper to create a string from a template and a string record.
+ * Similar to `format` but with objects instead of positional arguments.
+ */
 export declare function format2(template: string, values: Record<string, unknown>): string;
+/**
+ * Encodes the given value so that it can be used as literal value in html attributes.
+ *
+ * In other words, computes `$val`, such that `attr` in `<div attr="$val" />` has the runtime value `value`.
+ * This prevents XSS injection.
+ */
 export declare function htmlAttributeEncodeValue(value: string): string;
+/**
+ * Converts HTML characters inside the string to use entities instead. Makes the string safe from
+ * being used e.g. in HTMLElement.innerHTML.
+ */
 export declare function escape(html: string): string;
+/**
+ * Escapes regular expression characters in a given string
+ */
 export declare function escapeRegExpCharacters(value: string): string;
+/**
+ * Counts how often `substr` occurs inside `value`.
+ */
 export declare function count(value: string, substr: string): number;
 export declare function truncate(value: string, maxLength: number, suffix?: string): string;
 export declare function truncateMiddle(value: string, maxLength: number, suffix?: string): string;
+/**
+ * Removes all occurrences of needle from the beginning and end of haystack.
+ * @param haystack string to trim
+ * @param needle the thing to trim (default is a blank)
+ */
 export declare function trim(haystack: string, needle?: string): string;
+/**
+ * Removes all occurrences of needle from the beginning of haystack.
+ * @param haystack string to trim
+ * @param needle the thing to trim
+ */
 export declare function ltrim(haystack: string, needle: string): string;
+/**
+ * Removes all occurrences of needle from the end of haystack.
+ * @param haystack string to trim
+ * @param needle the thing to trim
+ */
 export declare function rtrim(haystack: string, needle: string): string;
 export declare function convertSimple2RegExpPattern(pattern: string): string;
 export declare function stripWildcards(pattern: string): string;
@@ -25,10 +66,26 @@ export declare function joinStrings(items: (string | undefined | null | false)[]
 export declare function splitLines(str: string): string[];
 export declare function splitLinesIncludeSeparators(str: string): string[];
 export declare function indexOfPattern(str: string, re: RegExp): number;
+/**
+ * Returns first index of the string that is not whitespace.
+ * If string is empty or contains only whitespaces, returns -1
+ */
 export declare function firstNonWhitespaceIndex(str: string): number;
+/**
+ * Returns the leading whitespace of the string.
+ * If the string contains only whitespaces, returns entire string
+ */
 export declare function getLeadingWhitespace(str: string, start?: number, end?: number): string;
+/**
+ * Returns last index of the string that is not whitespace.
+ * If string is empty or contains only whitespaces, returns -1
+ */
 export declare function lastNonWhitespaceIndex(str: string, startIndex?: number): number;
 export declare function getIndentationLength(str: string): number;
+/**
+ * Function that works identically to String.prototype.replace, except, the
+ * replace function is allowed to be async and return a Promise.
+ */
 export declare function replaceAsync(str: string, search: RegExp, replacer: (match: string, ...args: any[]) => Promise<string>): Promise<string>;
 export declare function compare(a: string, b: string): number;
 export declare function compareSubstring(a: string, b: string, aStart?: number, aEnd?: number, bStart?: number, bEnd?: number): number;
@@ -39,11 +96,29 @@ export declare function isLowerAsciiLetter(code: number): boolean;
 export declare function isUpperAsciiLetter(code: number): boolean;
 export declare function equalsIgnoreCase(a: string, b: string): boolean;
 export declare function startsWithIgnoreCase(str: string, candidate: string): boolean;
+/**
+ * @returns the length of the common prefix of the two strings.
+ */
 export declare function commonPrefixLength(a: string, b: string): number;
+/**
+ * @returns the length of the common suffix of the two strings.
+ */
 export declare function commonSuffixLength(a: string, b: string): number;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
 export declare function isHighSurrogate(charCode: number): boolean;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
 export declare function isLowSurrogate(charCode: number): boolean;
+/**
+ * See http://en.wikipedia.org/wiki/Surrogate_pair
+ */
 export declare function computeCodePoint(highSurrogate: number, lowSurrogate: number): number;
+/**
+ * get the code point that begins at offset `offset`
+ */
 export declare function getNextCodePoint(str: string, len: number, offset: number): number;
 export declare class CodePointIterator {
     private readonly _str;
@@ -71,27 +146,74 @@ export declare function getCharContainingOffset(str: string, offset: number): [
     number
 ];
 export declare function charCount(str: string): number;
+/**
+ * Returns true if `str` contains any Unicode character that is classified as "R" or "AL".
+ */
 export declare function containsRTL(str: string): boolean;
+/**
+ * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t
+ */
 export declare function isBasicASCII(str: string): boolean;
 export declare const UNUSUAL_LINE_TERMINATORS: RegExp;
+/**
+ * Returns true if `str` contains unusual line terminators, like LS or PS
+ */
 export declare function containsUnusualLineTerminators(str: string): boolean;
 export declare function isFullWidthCharacter(charCode: number): boolean;
+/**
+ * A fast function (therefore imprecise) to check if code points are emojis.
+ * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js
+ */
 export declare function isEmojiImprecise(x: number): boolean;
+/**
+ * Given a string and a max length returns a shorted version. Shorting
+ * happens at favorable positions - such as whitespace or punctuation characters.
+ * The return value can be longer than the given value of `n`. Leading whitespace is always trimmed.
+ */
 export declare function lcut(text: string, n: number, prefix?: string): string;
+/**
+ * Given a string and a max length returns a shorted version. Shorting
+ * happens at favorable positions - such as whitespace or punctuation characters.
+ * The return value can be longer than the given value of `n`. Trailing whitespace is always trimmed.
+ */
 export declare function rcut(text: string, n: number, suffix?: string): string;
+/** Iterates over parts of a string with CSI sequences */
 export declare function forAnsiStringParts(str: string): Generator<{
     isCode: boolean;
     str: string;
 }, void, unknown>;
+/**
+ * Strips ANSI escape sequences from a string.
+ * @param str The dastringa stringo strip the ANSI escape sequences from.
+ *
+ * @example
+ * removeAnsiEscapeCodes('\u001b[31mHello, World!\u001b[0m');
+ * // 'Hello, World!'
+ */
 export declare function removeAnsiEscapeCodes(str: string): string;
+/**
+ * Strips ANSI escape sequences from a UNIX-style prompt string (eg. `$PS1`).
+ * @param str The string to strip the ANSI escape sequences from.
+ *
+ * @example
+ * removeAnsiEscapeCodesFromPrompt('\n\\[\u001b[01;34m\\]\\w\\[\u001b[00m\\]\n\\[\u001b[1;32m\\]> \\[\u001b[0m\\]');
+ * // '\n\\w\n> '
+ */
 export declare function removeAnsiEscapeCodesFromPrompt(str: string): string;
 export declare const UTF8_BOM_CHARACTER: string;
 export declare function startsWithUTF8BOM(str: string): boolean;
 export declare function stripUTF8BOM(str: string): string;
+/**
+ * Checks if the characters of the provided query string are included in the
+ * target string. The characters do not have to be contiguous within the string.
+ */
 export declare function fuzzyContains(target: string, query: string): boolean;
 export declare function containsUppercaseCharacter(target: string, ignoreEscapedChars?: boolean): boolean;
 export declare function uppercaseFirstLetter(str: string): string;
 export declare function getNLines(str: string, n?: number): string;
+/**
+ * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.
+ */
 export declare function singleLetterHash(n: number): string;
 export declare function getGraphemeBreakType(codePoint: number): GraphemeBreakType;
 export declare enum GraphemeBreakType {
@@ -111,6 +233,10 @@ export declare enum GraphemeBreakType {
     ZWJ = 13,
     Extended_Pictographic = 14
 }
+/**
+ * Computes the offset after performing a left delete on the given string,
+ * while considering unicode grapheme/emoji rules.
+*/
 export declare function getLeftDeleteOffset(offset: number, str: string): number;
 export declare const noBreakWhitespace = "\u00A0";
 export declare class AmbiguousCharacters {
@@ -123,6 +249,10 @@ export declare class AmbiguousCharacters {
     private constructor();
     isAmbiguous(codePoint: number): boolean;
     containsAmbiguousCharacter(str: string): boolean;
+    /**
+     * Returns the non basic ASCII code point that the given code point can be confused,
+     * or undefined if such code point does note exist.
+     */
     getPrimaryConfusable(codePoint: number): number | undefined;
     getConfusableCodePoints(): ReadonlySet<number>;
 }
@@ -135,4 +265,8 @@ export declare class InvisibleCharacters {
     static get codePoints(): ReadonlySet<number>;
 }
 export declare const Ellipsis = "\u2026";
+/**
+ * Version of the global `btoa` function that handles multi-byte characters instead
+ * of throwing an exception.
+ */
 export declare function multibyteAwareBtoa(str: string): string;

package/vscode/src/vs/base/common/symbols.d.ts

@@ -1 +1,4 @@
+/**
+ * Can be passed into the Delayed to defer using a microtask
+ * */
 export declare const MicrotaskDelay: unique symbol;

package/vscode/src/vs/base/common/ternarySearchTree.d.ts

@@ -64,7 +64,13 @@ export declare class TernarySearchTree<K, V> {
     private _root;
     constructor(segments: IKeyIterator<K>);
     clear(): void;
+    /**
+     * Fill the tree with the same value of the given keys
+     */
     fill(element: V, keys: readonly K[]): void;
+    /**
+     * Fill the tree with given [key,value]-tuples
+     */
     fill(values: readonly [
         K,
         V

package/vscode/src/vs/base/common/types.d.ts

@@ -1,17 +1,86 @@
+/**
+ * @returns whether the provided parameter is a JavaScript String or not.
+ */
 export declare function isString(str: unknown): str is string;
+/**
+ * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
+ */
 export declare function isStringArray(value: unknown): value is string[];
+/**
+ * @returns whether the provided parameter is of type `object` but **not**
+ *	`null`, an `array`, a `regexp`, nor a `date`.
+ */
 export declare function isObject(obj: unknown): obj is Object;
+/**
+ * @returns whether the provided parameter is of type `Buffer` or Uint8Array dervived type
+ */
 export declare function isTypedArray(obj: unknown): obj is Object;
+/**
+ * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
+ * @returns whether the provided parameter is a JavaScript Number or not.
+ */
 export declare function isNumber(obj: unknown): obj is number;
+/**
+ * @returns whether the provided parameter is an Iterable, casting to the given generic
+ */
 export declare function isIterable<T>(obj: unknown): obj is Iterable<T>;
+/**
+ * @returns whether the provided parameter is an Iterable, casting to the given generic
+ */
 export declare function isAsyncIterable<T>(obj: unknown): obj is AsyncIterable<T>;
+/**
+ * @returns whether the provided parameter is a JavaScript Boolean or not.
+ */
 export declare function isBoolean(obj: unknown): obj is boolean;
+/**
+ * @returns whether the provided parameter is undefined.
+ */
 export declare function isUndefined(obj: unknown): obj is undefined;
+/**
+ * @returns whether the provided parameter is defined.
+ */
 export declare function isDefined<T>(arg: T | null | undefined): arg is T;
+/**
+ * @returns whether the provided parameter is undefined or null.
+ */
 export declare function isUndefinedOrNull(obj: unknown): obj is undefined | null;
 export declare function assertType(condition: unknown, type?: string): asserts condition;
+/**
+ * Asserts that the argument passed in is neither undefined nor null.
+ *
+ * @see {@link assertDefined} for a similar utility that leverages TS assertion functions to narrow down the type of `arg` to be non-nullable.
+ */
 export declare function assertReturnsDefined<T>(arg: T | null | undefined): NonNullable<T>;
+/**
+ * Asserts that a provided `value` is `defined` - not `null` or `undefined`,
+ * throwing an error with the provided error or error message, while also
+ * narrowing down the type of the `value` to be `NonNullable` using TS
+ * assertion functions.
+ *
+ * @throws if the provided `value` is `null` or `undefined`.
+ *
+ * ## Examples
+ *
+ * ```typescript
+ * // an assert with an error message
+ * assertDefined('some value', 'String constant is not defined o_O.');
+ *
+ * // `throws!` the provided error
+ * assertDefined(null, new Error('Should throw this error.'));
+ *
+ * // narrows down the type of `someValue` to be non-nullable
+ * const someValue: string | undefined | null = blackbox();
+ * assertDefined(someValue, 'Some value must be defined.');
+ * console.log(someValue.length); // now type of `someValue` is `string`
+ * ```
+ *
+ * @see {@link assertReturnsDefined} for a similar utility but without assertion.
+ * @see {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions typescript-3-7.html#assertion-functions}
+ */
 export declare function assertDefined<T>(value: T, error: string | NonNullable<Error>): asserts value is NonNullable<T>;
+/**
+ * Asserts that each argument passed in is neither undefined nor null.
+ */
 export declare function assertReturnsAllDefined<T1, T2>(t1: T1 | null | undefined, t2: T2 | null | undefined): [
     T1,
     T2
@@ -27,34 +96,100 @@ export declare function assertReturnsAllDefined<T1, T2, T3, T4>(t1: T1 | null |
     T3,
     T4
 ];
+/**
+ * Checks if the provided value is one of the vales in the provided list.
+ *
+ * ## Examples
+ *
+ * ```typescript
+ * // note! item type is a `subset of string`
+ * type TItem = ':' | '.' | '/';
+ *
+ * // note! item is type of `string` here
+ * const item: string = ':';
+ * // list of the items to check against
+ * const list: TItem[] = [':', '.'];
+ *
+ * // ok
+ * assert(
+ *   isOneOf(item, list),
+ *   'Must succeed.',
+ * );
+ *
+ * // `item` is of `TItem` type now
+ * ```
+ */
 export declare const isOneOf: <TType, TSubtype extends TType>(value: TType, validValues: readonly TSubtype[]) => value is TSubtype;
+/**
+ * Compile-time type check of a variable.
+ */
 export declare function typeCheck<T = never>(_thing: NoInfer<T>): void;
+/**
+ * @returns whether the provided parameter is an empty JavaScript Object or not.
+ */
 export declare function isEmptyObject(obj: unknown): obj is object;
+/**
+ * @returns whether the provided parameter is a JavaScript Function or not.
+ */
 export declare function isFunction(obj: unknown): obj is Function;
+/**
+ * @returns whether the provided parameters is are JavaScript Function or not.
+ */
 export declare function areFunctions(...objects: unknown[]): boolean;
 export type TypeConstraint = string | Function;
 export declare function validateConstraints(args: unknown[], constraints: Array<TypeConstraint | undefined>): void;
 export declare function validateConstraint(arg: unknown, constraint: TypeConstraint | undefined): void;
+/**
+ * Helper type assertion that safely upcasts a type to a supertype.
+ *
+ * This can be used to make sure the argument correctly conforms to the subtype while still being able to pass it
+ * to contexts that expects the supertype.
+ */
 export declare function upcast<Base, Sub extends Base = Base>(x: Sub): Base;
 type AddFirstParameterToFunction<T, TargetFunctionsReturnType, FirstParameter> = T extends (...args: any[]) => TargetFunctionsReturnType ? (firstArg: FirstParameter, ...args: Parameters<T>) => ReturnType<T> : T;
+/**
+ * Allows to add a first parameter to functions of a type.
+ */
 export type AddFirstParameterToFunctions<Target, TargetFunctionsReturnType, FirstParameter> = {
     [K in keyof Target]: AddFirstParameterToFunction<Target[K], TargetFunctionsReturnType, FirstParameter>;
 };
+/**
+ * Given an object with all optional properties, requires at least one to be defined.
+ * i.e. AtLeastOne<MyObject>;
+ */
 export type AtLeastOne<T, U = {
     [K in keyof T]: Pick<T, K>;
 }> = Partial<T> & U[keyof U];
+/**
+ * Only picks the non-optional properties of a type.
+ */
 export type OmitOptional<T> = {
     [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
 };
+/**
+ * A type that removed readonly-less from all properties of `T`
+ */
 export type Mutable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+/**
+ * A single object or an array of the objects.
+ */
 export type SingleOrMany<T> = T | T[];
+/**
+ * A type that recursively makes all properties of `T` required
+ */
 export type DeepRequiredNonNullable<T> = {
     [P in keyof T]-?: T[P] extends object ? DeepRequiredNonNullable<T[P]> : Required<NonNullable<T[P]>>;
 };
+/**
+ * Represents a type that is a partial version of a given type `T`, where all properties are optional and can be deeply nested.
+ */
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : Partial<T[P]>;
 };
+/**
+ * Represents a type that is a partial version of a given type `T`, except a subset.
+ */
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
 export {};

package/vscode/src/vs/base/common/uint.d.ts

@@ -1,9 +1,30 @@
 export declare enum Constants {
+    /**
+     * MAX SMI (SMall Integer) as defined in v8.
+     * one bit is lost for boxing/unboxing flag.
+     * one bit is lost for sign flag.
+     * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
+     */
     MAX_SAFE_SMALL_INTEGER = 1073741824,
+    /**
+     * MIN SMI (SMall Integer) as defined in v8.
+     * one bit is lost for boxing/unboxing flag.
+     * one bit is lost for sign flag.
+     * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
+     */
     MIN_SAFE_SMALL_INTEGER = -1073741824,
-    MAX_UINT_8 = 255,
-    MAX_UINT_16 = 65535,
-    MAX_UINT_32 = 4294967295,
+    /**
+     * Max unsigned integer that fits on 8 bits.
+     */
+    MAX_UINT_8 = 255,// 2^8 - 1
+    /**
+     * Max unsigned integer that fits on 16 bits.
+     */
+    MAX_UINT_16 = 65535,// 2^16 - 1
+    /**
+     * Max unsigned integer that fits on 32 bits.
+     */
+    MAX_UINT_32 = 4294967295,// 2^32 - 1
     UNICODE_SUPPLEMENTARY_PLANE_BEGIN = 65536
 }
 export declare function toUint8(v: number): number;

package/vscode/src/vs/base/common/uri.d.ts

@@ -1,12 +1,75 @@
+/**
+ * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
+ * This class is a simple parser which creates the basic component parts
+ * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
+ * and encoding.
+ *
+ * ```txt
+ *       foo://example.com:8042/over/there?name=ferret#nose
+ *       \_/   \______________/\_________/ \_________/ \__/
+ *        |           |            |            |        |
+ *     scheme     authority       path        query   fragment
+ *        |   _____________________|__
+ *       / \ /                        \
+ *       urn:example:animal:ferret:nose
+ * ```
+ */
 export declare class URI implements UriComponents {
     static isUri(thing: unknown): thing is URI;
+    /**
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
+     */
     readonly scheme: string;
+    /**
+     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part between the first double slashes and the next slash.
+     */
     readonly authority: string;
+    /**
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
+     */
     readonly path: string;
+    /**
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
+     */
     readonly query: string;
+    /**
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
+     */
     readonly fragment: string;
+    /**
+     * @internal
+     */
     protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
+    /**
+     * @internal
+     */
     protected constructor(components: UriComponents);
+    /**
+     * Returns a string representing the corresponding file system path of this URI.
+     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+     * platform specific path separator.
+     *
+     * * Will *not* validate the path for invalid characters and semantics.
+     * * Will *not* look at the scheme of this URI.
+     * * The result shall *not* be used for display purposes but for accessing a file on disk.
+     *
+     *
+     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+     *
+     * ```ts
+        const u = URI.parse('file://server/c$/folder/file.txt')
+        u.authority === 'server'
+        u.path === '/shares/c$/file.txt'
+        u.fsPath === '\\server\c$\folder\file.txt'
+    ```
+     *
+     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+     * with URIs that represent files on disk (`file` scheme).
+     */
     get fsPath(): string;
     with(change: {
         scheme?: string;
@@ -15,12 +78,74 @@ export declare class URI implements UriComponents {
         query?: string | null;
         fragment?: string | null;
     }): URI;
+    /**
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
+     *
+     * @param value A string which represents an URI (see `URI#toString`).
+     */
     static parse(value: string, _strict?: boolean): URI;
+    /**
+     * Creates a new URI from a file system path, e.g. `c:\my\files`,
+     * `/usr/home`, or `\\server\share\some\path`.
+     *
+     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+     * `URI.parse('file://' + path)` because the path might contain characters that are
+     * interpreted (# and ?). See the following sample:
+     * ```ts
+    const good = URI.file('/coding/c#/project1');
+    good.scheme === 'file';
+    good.path === '/coding/c#/project1';
+    good.fragment === '';
+    const bad = URI.parse('file://' + '/coding/c#/project1');
+    bad.scheme === 'file';
+    bad.path === '/coding/c'; // path is now broken
+    bad.fragment === '/project1';
+    ```
+     *
+     * @param path A file system path (see `URI#fsPath`)
+     */
     static file(path: string): URI;
+    /**
+     * Creates new URI from uri components.
+     *
+     * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
+     * validation and should be used for untrusted uri components retrieved from storage,
+     * user input, command arguments etc
+     */
     static from(components: UriComponents, strict?: boolean): URI;
+    /**
+     * Join a URI path with path fragments and normalizes the resulting path.
+     *
+     * @param uri The input URI.
+     * @param pathFragment The path fragment to add to the URI path.
+     * @returns The resulting URI.
+     */
     static joinPath(uri: URI, ...pathFragment: string[]): URI;
+    /**
+     * Creates a string representation for this URI. It's guaranteed that calling
+     * `URI.parse` with the result of this function creates an URI which is equal
+     * to this URI.
+     *
+     * * The result shall *not* be used for display purposes but for externalization or transport.
+     * * The result will be encoded using the percentage encoding and encoding happens mostly
+     * ignore the scheme-specific encoding rules.
+     *
+     * @param skipEncoding Do not encode the result, default is `false`
+     */
     toString(skipEncoding?: boolean): string;
     toJSON(): UriComponents;
+    /**
+     * A helper function to revive URIs.
+     *
+     * **Note** that this function should only be used when receiving URI#toJSON generated data
+     * and that it doesn't do any validation. Use {@link URI.from} when received "untrusted"
+     * uri components such as command arguments or data from storage.
+     *
+     * @param data The URI components or URI to revive.
+     * @returns The revived URI or undefined or null.
+     */
     static revive(data: UriComponents | URI): URI;
     static revive(data: UriComponents | URI | undefined): URI | undefined;
     static revive(data: UriComponents | URI | null): URI | null;
@@ -34,7 +159,13 @@ export interface UriComponents {
     fragment?: string;
 }
 export declare function isUriComponents(thing: unknown): thing is UriComponents;
+/**
+ * Compute `fsPath` for the given uri
+ */
 export declare function uriToFsPath(uri: URI, keepDriveLetterCasing: boolean): string;
+/**
+ * Mapped-type that replaces all occurrences of URI with UriComponents
+ */
 export type UriDto<T> = {
     [K in keyof T]: T[K] extends URI ? UriComponents : UriDto<T[K]>;
 };

package/vscode/src/vs/base/common/worker/webWorker.d.ts

@@ -68,6 +68,9 @@ export interface IWebWorkerServer {
     setChannel<T extends object>(channel: string, handler: T): void;
     getChannel<T extends object>(channel: string): Proxied<T>;
 }
+/**
+ * Main thread side
+ */
 export declare class WebWorkerClient<W extends object> extends Disposable implements IWebWorkerClient<W> {
     private readonly _worker;
     private readonly _onModuleLoaded;
@@ -89,6 +92,9 @@ export interface IWebWorkerServerRequestHandler {
 export interface IWebWorkerServerRequestHandlerFactory<T extends IWebWorkerServerRequestHandler> {
     (workerServer: IWebWorkerServer): T;
 }
+/**
+ * Worker side
+ */
 export declare class WebWorkerServer<T extends IWebWorkerServerRequestHandler> implements IWebWorkerServer {
     readonly requestHandler: T;
     private _protocol;