@codingame/monaco-vscode-api 20.1.1 → 20.2.1

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

@@ -1,7 +1,20 @@
 export interface IDisposableTracker {
+    /**
+     * Is called on construction of a disposable.
+    */
     trackDisposable(disposable: IDisposable): void;
+    /**
+     * Is called when a disposable is registered as child of another disposable (e.g. {@link DisposableStore}).
+     * If parent is `null`, the disposable is removed from its former parent.
+    */
     setParent(child: IDisposable, parent: IDisposable | null): void;
+    /**
+     * Is called after a disposable is disposed.
+    */
     markAsDisposed(disposable: IDisposable): void;
+    /**
+     * Indicates that the given object is a singleton which does not need to be disposed.
+    */
     markAsSingleton(disposable: IDisposable): void;
 }
 export declare class GCBasedDisposableTracker implements IDisposableTracker {
@@ -36,48 +49,132 @@ export declare class DisposableTracker implements IDisposableTracker {
 export declare function setDisposableTracker(tracker: IDisposableTracker | null): void;
 export declare function trackDisposable<T extends IDisposable>(x: T): T;
 export declare function markAsDisposed(disposable: IDisposable): void;
+/**
+ * Indicates that the given object is a singleton which does not need to be disposed.
+*/
 export declare function markAsSingleton<T extends IDisposable>(singleton: T): T;
+/**
+ * An object that performs a cleanup operation when `.dispose()` is called.
+ *
+ * Some examples of how disposables are used:
+ *
+ * - An event listener that removes itself when `.dispose()` is called.
+ * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
+ * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
+ */
 export interface IDisposable {
     dispose(): void;
 }
+/**
+ * Check if `thing` is {@link IDisposable disposable}.
+ */
 export declare function isDisposable<E extends any>(thing: E): thing is E & IDisposable;
+/**
+ * Disposes of the value(s) passed in.
+ */
 export declare function dispose<T extends IDisposable>(disposable: T): T;
 export declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
 export declare function dispose<T extends IDisposable, A extends Iterable<T> = Iterable<T>>(disposables: A): A;
 export declare function dispose<T extends IDisposable>(disposables: Array<T>): Array<T>;
 export declare function dispose<T extends IDisposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function disposeIfDisposable<T extends IDisposable | object>(disposables: Array<T>): Array<T>;
+/**
+ * Combine multiple disposable values into a single {@link IDisposable}.
+ */
 export declare function combinedDisposable(...disposables: IDisposable[]): IDisposable;
+/**
+ * Turn a function that implements dispose into an {@link IDisposable}.
+ *
+ * @param fn Clean up function, guaranteed to be called only **once**.
+ */
 export declare function toDisposable(fn: () => void): IDisposable;
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
 export declare class DisposableStore implements IDisposable {
     static DISABLE_DISPOSED_WARNING: boolean;
     private readonly _toDispose;
     private _isDisposed;
     constructor();
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
     dispose(): void;
+    /**
+     * @return `true` if this object has been disposed of.
+     */
     get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
     clear(): void;
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
     add<T extends IDisposable>(o: T): T;
+    /**
+     * Deletes a disposable from store and disposes of it. This will not throw or warn and proceed to dispose the
+     * disposable even when the disposable is not part in the store.
+     */
     delete<T extends IDisposable>(o: T): void;
+    /**
+     * Deletes the value from the store, but does not dispose it.
+     */
     deleteAndLeak<T extends IDisposable>(o: T): void;
 }
+/**
+ * Abstract base class for a {@link IDisposable disposable} object.
+ *
+ * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.
+ */
 export declare abstract class Disposable implements IDisposable {
+    /**
+     * A disposable that does nothing when it is disposed of.
+     *
+     * TODO: This should not be a static property.
+     */
     static readonly None: Readonly<IDisposable>;
     protected readonly _store: DisposableStore;
     constructor();
     dispose(): void;
+    /**
+     * Adds `o` to the collection of disposables managed by this object.
+     */
     protected _register<T extends IDisposable>(o: T): T;
 }
+/**
+ * Manages the lifecycle of a disposable value that may be changed.
+ *
+ * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
+ * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
+ */
 export declare class MutableDisposable<T extends IDisposable> implements IDisposable {
     private _value?;
     private _isDisposed;
     constructor();
     get value(): T | undefined;
     set value(value: T | undefined);
+    /**
+     * Resets the stored value and disposed of the previously stored value.
+     */
     clear(): void;
     dispose(): void;
+    /**
+     * Clears the value, but does not dispose it.
+     * The old value is returned.
+    */
     clearAndLeak(): T | undefined;
 }
+/**
+ * Manages the lifecycle of a disposable value that may be changed like {@link MutableDisposable}, but the value must
+ * exist and cannot be undefined.
+ */
 export declare class MandatoryMutableDisposable<T extends IDisposable> implements IDisposable {
     private readonly _disposable;
     private _isDisposed;
@@ -93,6 +190,10 @@ export declare class RefCountedDisposable {
     acquire(): this;
     release(): this;
 }
+/**
+ * A safe disposable can be `unset` so that a leaked reference (listener)
+ * can be cut-off.
+ */
 export declare class SafeDisposable implements IDisposable {
     dispose: () => void;
     unset: () => void;
@@ -109,6 +210,10 @@ export declare abstract class ReferenceCollection<T> {
     protected abstract createReferencedObject(key: string, ...args: any[]): T;
     protected abstract destroyReferencedObject(key: string, object: T): void;
 }
+/**
+ * Unwraps a reference collection of promised values. Makes sure
+ * references are disposed whenever promises get rejected.
+ */
 export declare class AsyncReferenceCollection<T> {
     private referenceCollection;
     constructor(referenceCollection: ReferenceCollection<Promise<T>>);
@@ -120,17 +225,35 @@ export declare class ImmortalReference<T> implements IReference<T> {
     dispose(): void;
 }
 export declare function disposeOnReturn(fn: (store: DisposableStore) => void): void;
+/**
+ * A map the manages the lifecycle of the values that it stores.
+ */
 export declare class DisposableMap<K, V extends IDisposable = IDisposable> implements IDisposable {
     private readonly _store;
     private _isDisposed;
     constructor();
+    /**
+     * Disposes of all stored values and mark this object as disposed.
+     *
+     * Trying to use this object after it has been disposed of is an error.
+     */
     dispose(): void;
+    /**
+     * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.
+     */
     clearAndDisposeAll(): void;
     has(key: K): boolean;
     get size(): number;
     get(key: K): V | undefined;
     set(key: K, value: V, skipDisposeOnOverwrite?: boolean): void;
+    /**
+     * Delete the value stored for `key` from this map and also dispose of it.
+     */
     deleteAndDispose(key: K): void;
+    /**
+     * Delete the value stored for `key` from this map but return it. The caller is
+     * responsible for disposing of the value.
+     */
     deleteAndLeak(key: K): V | undefined;
     keys(): IterableIterator<K>;
     values(): IterableIterator<V>;
@@ -139,4 +262,7 @@ export declare class DisposableMap<K, V extends IDisposable = IDisposable> imple
         V
     ]>;
 }
+/**
+ * Call `then` on a Promise, unless the returned disposable is disposed.
+ */
 export declare function thenIfNotDisposed<T>(promise: Promise<T>, then: (result: T) => void): IDisposable;

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

@@ -10,8 +10,22 @@ export declare class ResourceMap<T> implements Map<URI, T> {
     readonly [Symbol.toStringTag] = "ResourceMap";
     private readonly map;
     private readonly toKey;
+    /**
+     *
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
     constructor(toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
     constructor(other?: ResourceMap<T>, toKey?: ResourceMapKeyFn);
+    /**
+     *
+     * @param other Another resource which this maps is created from
+     * @param toKey Custom uri identity function, e.g use an existing `IExtUri#getComparison`-util
+     */
     constructor(entries?: readonly (readonly [
         URI,
         T
@@ -133,6 +147,10 @@ export declare class CounterSet<T> {
     delete(value: T): boolean;
     has(value: T): boolean;
 }
+/**
+ * A map that allows access both by keys and values.
+ * **NOTE**: values need to be unique.
+ */
 export declare class BidirectionalMap<K, V> {
     private readonly _m1;
     private readonly _m2;
@@ -157,8 +175,20 @@ export declare class SetMap<K, V> {
     get(key: K): ReadonlySet<V>;
 }
 export declare function mapsStrictEqualIgnoreOrder(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean;
+/**
+ * A map that is addressable with an arbitrary number of keys. This is useful in high performance
+ * scenarios where creating a composite key whenever the data is accessed is too expensive. For
+ * example for a very hot function, constructing a string like `first-second-third` for every call
+ * will cause a significant hit to performance.
+ */
 export declare class NKeyMap<TValue, TKeys extends (string | boolean | number)[]> {
     private _data;
+    /**
+     * Sets a value on the map. Note that unlike a standard `Map`, the first argument is the value.
+     * This is because the spread operator is used for the keys and must be last..
+     * @param value The value to set.
+     * @param keys The keys for the value.
+     */
     set(value: TValue, ...keys: [
         ...TKeys
     ]): void;
@@ -167,6 +197,9 @@ export declare class NKeyMap<TValue, TKeys extends (string | boolean | number)[]
     ]): TValue | undefined;
     clear(): void;
     values(): IterableIterator<TValue>;
+    /**
+     * Get a textual representation of the map for debugging purposes.
+     */
     toString(): string;
 }
 export {};

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

@@ -1,3 +1,4 @@
+// Generated by dts-bundle-generator v9.5.1
 export type MarkedToken = (Tokens.Space | Tokens.Code | Tokens.Heading | Tokens.Table | Tokens.Hr | Tokens.Blockquote | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.HTML | Tokens.Text | Tokens.Def | Tokens.Escape | Tokens.Tag | Tokens.Image | Tokens.Link | Tokens.Strong | Tokens.Em | Tokens.Codespan | Tokens.Br | Tokens.Del);
 export type Token = (MarkedToken | Tokens.Generic);
 export declare namespace Tokens {
@@ -159,6 +160,9 @@ export type Links = Record<string, Pick<Tokens.Link | Tokens.Image, "href" | "ti
 export type TokensList = Token[] & {
     links: Links;
 };
+/**
+ * Renderer
+ */
 declare class _Renderer {
     options: MarkedOptions;
     parser: _Parser;
@@ -176,6 +180,9 @@ declare class _Renderer {
     table(token: Tokens.Table): string;
     tablerow({ text }: Tokens.TableRow): string;
     tablecell(token: Tokens.TableCell): string;
+    /**
+     * span level renderer
+     */
     strong({ tokens }: Tokens.Strong): string;
     em({ tokens }: Tokens.Em): string;
     codespan({ text }: Tokens.Codespan): string;
@@ -185,6 +192,10 @@ declare class _Renderer {
     image({ href, title, text }: Tokens.Image): string;
     text(token: Tokens.Text | Tokens.Escape | Tokens.Tag): string;
 }
+/**
+ * TextRenderer
+ * returns only the textual part of the token
+ */
 declare class _TextRenderer {
     strong({ text }: Tokens.Strong): string;
     em({ text }: Tokens.Em): string;
@@ -196,14 +207,29 @@ declare class _TextRenderer {
     image({ text }: Tokens.Image): string;
     br(): string;
 }
+/**
+ * Parsing & Compiling
+ */
 declare class _Parser {
     options: MarkedOptions;
     renderer: _Renderer;
     textRenderer: _TextRenderer;
     constructor(options?: MarkedOptions);
+    /**
+     * Static Parse Method
+     */
     static parse(tokens: Token[], options?: MarkedOptions): string;
+    /**
+     * Static Parse Inline Method
+     */
     static parseInline(tokens: Token[], options?: MarkedOptions): string;
+    /**
+     * Parse Loop
+     */
     parse(tokens: Token[], top?: boolean): string;
+    /**
+     * Parse Inline Tokens
+     */
     parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): string;
 }
 declare const blockNormal: {
@@ -244,6 +270,9 @@ declare const inlineNormal: {
     url: RegExp;
 };
 export type InlineKeys = keyof typeof inlineNormal;
+/**
+ * exports
+ */
 export declare const block: {
     normal: {
         blockquote: RegExp;
@@ -293,6 +322,9 @@ export interface Rules {
     block: Record<BlockKeys, RegExp>;
     inline: Record<InlineKeys, RegExp>;
 }
+/**
+ * Tokenizer
+ */
 declare class _Tokenizer {
     options: MarkedOptions;
     rules: Rules;
@@ -327,8 +359,17 @@ declare class _Hooks {
     options: MarkedOptions;
     constructor(options?: MarkedOptions);
     static passThroughHooks: Set<string>;
+    /**
+     * Process markdown before marked
+     */
     preprocess(markdown: string): string;
+    /**
+     * Process HTML after marked is finished
+     */
     postprocess(html: string): string;
+    /**
+     * Process all tokens before walk tokens
+     */
     processAllTokens(tokens: Token[] | TokensList): Token[] | TokensList;
 }
 export interface TokenizerThis {
@@ -365,21 +406,73 @@ export type TokenizerObject = {
     [K in keyof TokenizerApi]?: (this: _Tokenizer, ...args: Parameters<TokenizerApi[K]>) => ReturnType<TokenizerApi[K]> | false;
 };
 export interface MarkedExtension {
+    /**
+     * True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string.
+     */
     async?: boolean;
+    /**
+     * Enable GFM line breaks. This option requires the gfm option to be true.
+     */
     breaks?: boolean | undefined;
+    /**
+     * Add tokenizers and renderers to marked
+     */
     extensions?: TokenizerAndRendererExtension[] | undefined | null;
+    /**
+     * Enable GitHub flavored markdown.
+     */
     gfm?: boolean | undefined;
+    /**
+     * Hooks are methods that hook into some part of marked.
+     * preprocess is called to process markdown before sending it to marked.
+     * processAllTokens is called with the TokensList before walkTokens.
+     * postprocess is called to process html after marked has finished parsing.
+     */
     hooks?: HooksObject | undefined | null;
+    /**
+     * Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.
+     */
     pedantic?: boolean | undefined;
+    /**
+     * Type: object Default: new Renderer()
+     *
+     * An object containing functions to render tokens to HTML.
+     */
     renderer?: RendererObject | undefined | null;
+    /**
+     * Shows an HTML error message when rendering fails.
+     */
     silent?: boolean | undefined;
+    /**
+     * The tokenizer defines how to turn markdown text into tokens.
+     */
     tokenizer?: TokenizerObject | undefined | null;
+    /**
+     * The walkTokens function gets called with every token.
+     * Child tokens are called before moving on to sibling tokens.
+     * Each token is passed by reference so updates are persisted when passed to the parser.
+     * The return value of the function is ignored.
+     */
     walkTokens?: ((token: Token) => void | Promise<void>) | undefined | null;
 }
 export interface MarkedOptions extends Omit<MarkedExtension, "hooks" | "renderer" | "tokenizer" | "extensions" | "walkTokens"> {
+    /**
+     * Hooks are methods that hook into some part of marked.
+     */
     hooks?: _Hooks | undefined | null;
+    /**
+     * Type: object Default: new Renderer()
+     *
+     * An object containing functions to render tokens to HTML.
+     */
     renderer?: _Renderer | undefined | null;
+    /**
+     * The tokenizer defines how to turn markdown text into tokens.
+     */
     tokenizer?: _Tokenizer | undefined | null;
+    /**
+     * Custom extensions
+     */
     extensions?: null | {
         renderers: {
             [name: string]: RendererExtensionFunction;
@@ -392,8 +485,14 @@ export interface MarkedOptions extends Omit<MarkedExtension, "hooks" | "renderer
         startInline?: TokenizerStartFunction[];
         startBlock?: TokenizerStartFunction[];
     };
+    /**
+     * walkTokens function returns array of values for Promise.all
+     */
     walkTokens?: null | ((token: Token) => void | Promise<void> | (void | Promise<void>)[]);
 }
+/**
+ * Block Lexer
+ */
 declare class _Lexer {
     tokens: TokensList;
     options: MarkedOptions;
@@ -405,6 +504,9 @@ declare class _Lexer {
     private tokenizer;
     private inlineQueue;
     constructor(options?: MarkedOptions);
+    /**
+     * Expose Rules
+     */
     static get rules(): {
         block: {
             normal: {
@@ -452,14 +554,32 @@ declare class _Lexer {
             pedantic: Record<"link" | "code" | "url" | "br" | "del" | "text" | "escape" | "tag" | "reflink" | "autolink" | "nolink" | "_backpedal" | "anyPunctuation" | "blockSkip" | "emStrongLDelim" | "emStrongRDelimAst" | "emStrongRDelimUnd" | "punctuation" | "reflinkSearch", RegExp>;
         };
     };
+    /**
+     * Static Lex Method
+     */
     static lex(src: string, options?: MarkedOptions): TokensList;
+    /**
+     * Static Lex Inline Method
+     */
     static lexInline(src: string, options?: MarkedOptions): Token[];
+    /**
+     * Preprocessing
+     */
     lex(src: string): TokensList;
+    /**
+     * Lexing
+     */
     blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];
     blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList;
     inline(src: string, tokens?: Token[]): Token[];
+    /**
+     * Lexing/Compiling
+     */
     inlineTokens(src: string, tokens?: Token[]): Token[];
 }
+/**
+ * Gets the original marked default options.
+ */
 declare function _getDefaults(): MarkedOptions;
 declare let _defaults: MarkedOptions;
 export type MaybePromise = void | Promise<void>;
@@ -491,6 +611,9 @@ export declare class Marked {
     Tokenizer: typeof _Tokenizer;
     Hooks: typeof _Hooks;
     constructor(...args: MarkedExtension[]);
+    /**
+     * Run callback for every token
+     */
     walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]): MaybePromise[];
     use(...args: MarkedExtension[]): this;
     setOptions(opt: MarkedOptions): this;
@@ -499,9 +622,23 @@ export declare class Marked {
     private parseMarkdown;
     private onError;
 }
+/**
+ * Compiles markdown to HTML asynchronously.
+ *
+ * @param src String of markdown source to be compiled
+ * @param options Hash of options, having async: true
+ * @return Promise of string of compiled HTML
+ */
 export declare function marked(src: string, options: MarkedOptions & {
     async: true;
 }): Promise<string>;
+/**
+ * Compiles markdown to HTML.
+ *
+ * @param src String of markdown source to be compiled
+ * @param options Optional hash of options
+ * @return String of compiled HTML. Will be a Promise of string if async is set to true by any extensions.
+ */
 export declare function marked(src: string, options: MarkedOptions & {
     async: false;
 }): string;

package/vscode/src/vs/base/common/naturalLanguage/korean.d.ts

@@ -1 +1,9 @@
+/**
+ * Gets alternative Korean characters for the character code. This will return the ascii
+ * character code(s) that a Hangul character may have been input with using a qwerty layout.
+ *
+ * This only aims to cover modern (not archaic) Hangul syllables.
+ *
+ * @param code The character code to get alternate characters for
+ */
 export declare function getKoreanAltChars(code: number): ArrayLike<number> | undefined;

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

@@ -1,10 +1,26 @@
 import { URI } from "./uri.js";
 import { IDisposable } from "./lifecycle.js";
 export declare namespace Schemas {
+    /**
+     * A schema that is used for models that exist in memory
+     * only and that have no correspondence on a server or such.
+     */
     const inMemory = "inmemory";
+    /**
+     * A schema that is used for setting files
+     */
     const vscode = "vscode";
+    /**
+     * A schema that is used for internal private files
+     */
     const internal = "private";
+    /**
+     * A walk-through document.
+     */
     const walkThrough = "walkThrough";
+    /**
+     * An embedded code snippet.
+     */
     const walkThroughSnippet = "walkThroughSnippet";
     const http = "http";
     const https = "https";
@@ -28,21 +44,60 @@ export declare namespace Schemas {
     const vscodeSettings = "vscode-settings";
     const vscodeWorkspaceTrust = "vscode-workspace-trust";
     const vscodeTerminal = "vscode-terminal";
+    /** Scheme used for code blocks in chat. */
     const vscodeChatCodeBlock = "vscode-chat-code-block";
+    /** Scheme used for LHS of code compare (aka diff) blocks in chat. */
     const vscodeChatCodeCompareBlock = "vscode-chat-code-compare-block";
+    /** Scheme used for the chat input editor. */
     const vscodeChatEditor = "vscode-chat-editor";
+    /** Scheme used for the chat input part */
     const vscodeChatInput = "chatSessionInput";
+    /** Scheme for chat session content */
     const vscodeChatSession = "vscode-chat-session";
+    /**
+     * Scheme used internally for webviews that aren't linked to a resource (i.e. not custom editors)
+     */
     const webviewPanel = "webview-panel";
+    /**
+     * Scheme used for loading the wrapper html and script in webviews.
+     */
     const vscodeWebview = "vscode-webview";
+    /**
+     * Scheme used for extension pages
+     */
     const extension = "extension";
+    /**
+     * Scheme used as a replacement of `file` scheme to load
+     * files with our custom protocol handler (desktop only).
+     */
     const vscodeFileResource = "vscode-file";
+    /**
+     * Scheme used for temporary resources
+     */
     const tmp = "tmp";
+    /**
+     * Scheme used vs live share
+     */
     const vsls = "vsls";
+    /**
+     * Scheme used for the Source Control commit input's text document
+     */
     const vscodeSourceControl = "vscode-scm";
+    /**
+     * Scheme used for input box for creating comments.
+     */
     const commentsInput = "comment";
+    /**
+     * Scheme used for special rendering of settings in the release notes
+     */
     const codeSetting = "code-setting";
+    /**
+     * Scheme used for output panel resources
+     */
     const outputChannel = "output";
+    /**
+     * Scheme used for the accessible view
+     */
     const accessibleView = "accessible-view";
 }
 export declare function matchesScheme(target: URI | string, scheme: string): boolean;
@@ -74,6 +129,9 @@ export declare function getServerProductSegment(product: {
     quality?: string;
     commit?: string;
 }): string;
+/**
+ * A string pointing to a path inside the app. It should not begin with ./ or ../
+ */
 export type AppResourcePath = (`a${string}` | `b${string}` | `c${string}` | `d${string}` | `e${string}` | `f${string}` | `g${string}` | `h${string}` | `i${string}` | `j${string}` | `k${string}` | `l${string}` | `m${string}` | `n${string}` | `o${string}` | `p${string}` | `q${string}` | `r${string}` | `s${string}` | `t${string}` | `u${string}` | `v${string}` | `w${string}` | `x${string}` | `y${string}` | `z${string}`);
 export declare const builtinExtensionsPath: AppResourcePath;
 export declare const nodeModulesPath: AppResourcePath;
@@ -86,9 +144,29 @@ declare class FileAccessImpl {
     private appResourcePathUrls;
     registerAppResourcePathUrl(moduleId: string, url: string | (() => string)): void;
     private toUrl;
+    /**
+     * Returns a URI to use in contexts where the browser is responsible
+     * for loading (e.g. fetch()) or when used within the DOM.
+     *
+     * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
+     */
     asBrowserUri(resourcePath: AppResourcePath | ""): URI;
+    /**
+     * Returns a URI to use in contexts where the browser is responsible
+     * for loading (e.g. fetch()) or when used within the DOM.
+     *
+     * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
+     */
     uriToBrowserUri(uri: URI): URI;
+    /**
+     * Returns the `file` URI to use in contexts where node.js
+     * is responsible for loading.
+     */
     asFileUri(resourcePath: AppResourcePath | ""): URI;
+    /**
+     * Returns the `file` URI to use in contexts where node.js
+     * is responsible for loading.
+     */
     uriToFileUri(uri: URI): URI;
     private toUri;
     registerStaticBrowserUri(uri: URI, browserUri: URI): IDisposable;
@@ -99,7 +177,14 @@ export declare const CacheControlheaders: Record<string, string>;
 export declare const DocumentPolicyheaders: Record<string, string>;
 export declare namespace COI {
     const CoopAndCoep: Readonly<Record<string, string> | undefined>;
+    /**
+     * Extract desired headers from `vscode-coi` invocation
+     */
     function getHeadersFromQuery(url: string | URI | URL): Record<string, string> | undefined;
+    /**
+     * Add the `vscode-coi` query attribute based on wanting `COOP` and `COEP`. Will be a noop when `crossOriginIsolated`
+     * isn't enabled the current context
+     */
     function addSearchParam(urlOrSearch: URLSearchParams | Record<string, string>, coop: boolean, coep: boolean): void;
 }
 export {};