@codingame/monaco-vscode-editor-api 20.1.1 → 20.2.0

package/vscode/src/vs/editor/standalone/browser/standalone-tokens.css

@@ -1,21 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+/* Default standalone editor fonts */
 .monaco-editor.standalone {
 	font-family: -apple-system, BlinkMacSystemFont, "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", system-ui, "Ubuntu", "Droid Sans", sans-serif;
 	--monaco-monospace-font: "SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace;
 }
+
 .monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label {
 	stroke-width: 1.2px;
 }
+
 .monaco-editor.standalone.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,
 .monaco-editor.standalone.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,
 .monaco-editor.standalone.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label {
 	stroke-width: 1.2px;
 }
+
 .monaco-hover p {
 	margin: 0;
 }
+
+/* See https://github.com/microsoft/monaco-editor/issues/2168#issuecomment-780078600 */
 .monaco-aria-container {
 	position: absolute !important;
-	top: 0;
+	top: 0; /* avoid being placed underneath a sibling element */
 	height: 1px;
 	width: 1px;
 	margin: -1px;
@@ -24,6 +36,7 @@
 	clip: rect(1px, 1px, 1px, 1px);
 	clip-path: inset(50%);
 }
+
 .monaco-editor.standalone .synthetic-focus, .monaco-diff-editor.standalone .synthetic-focus,
 .monaco-editor.standalone [tabindex="0"]:focus, .monaco-diff-editor.standalone [tabindex="0"]:focus,
 .monaco-editor.standalone [tabindex="-1"]:focus, .monaco-diff-editor.standalone [tabindex="-1"]:focus,

package/vscode/src/vs/editor/standalone/browser/standaloneEditor.d.ts

@@ -14,60 +14,205 @@ import { IStandaloneThemeData } from "@codingame/monaco-vscode-api/vscode/vs/edi
 import { ICommandHandler } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands";
 import { IMarker, IMarkerData } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers";
 import { MultiDiffEditorWidget } from "@codingame/monaco-vscode-5452e2b7-9081-5f95-839b-4ab3544ce28f-common/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget";
+/**
+ * Create a new editor under `domElement`.
+ * `domElement` should be empty (not contain other dom nodes).
+ * The editor will read the size of `domElement`.
+ */
 export declare function create(domElement: HTMLElement, options?: IStandaloneEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneCodeEditor;
+/**
+ * Emitted when an editor is created.
+ * Creating a diff editor might cause this listener to be invoked with the two editors.
+ * @event
+ */
 export declare function onDidCreateEditor(listener: (codeEditor: ICodeEditor) => void): IDisposable;
+/**
+ * Emitted when an diff editor is created.
+ * @event
+ */
 export declare function onDidCreateDiffEditor(listener: (diffEditor: IDiffEditor) => void): IDisposable;
+/**
+ * Get all the created editors.
+ */
 export declare function getEditors(): readonly ICodeEditor[];
+/**
+ * Get all the created diff editors.
+ */
 export declare function getDiffEditors(): readonly IDiffEditor[];
+/**
+ * Create a new diff editor under `domElement`.
+ * `domElement` should be empty (not contain other dom nodes).
+ * The editor will read the size of `domElement`.
+ */
 export declare function createDiffEditor(domElement: HTMLElement, options?: IStandaloneDiffEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneDiffEditor;
 export declare function createMultiFileDiffEditor(domElement: HTMLElement, override?: IEditorOverrideServices): MultiDiffEditorWidget;
+/**
+ * Description of a command contribution
+ */
 export interface ICommandDescriptor {
+    /**
+     * An unique identifier of the contributed command.
+     */
     id: string;
+    /**
+     * Callback that will be executed when the command is triggered.
+     */
     run: ICommandHandler;
 }
+/**
+ * Add a command.
+ */
 export declare function addCommand(descriptor: ICommandDescriptor): IDisposable;
+/**
+ * Add an action to all editors.
+ */
 export declare function addEditorAction(descriptor: IActionDescriptor): IDisposable;
+/**
+ * A keybinding rule.
+ */
 export interface IKeybindingRule {
     keybinding: number;
     command?: string | null;
     commandArgs?: any;
     when?: string | null;
 }
+/**
+ * Add a keybinding rule.
+ */
 export declare function addKeybindingRule(rule: IKeybindingRule): IDisposable;
+/**
+ * Add keybinding rules.
+ */
 export declare function addKeybindingRules(rules: IKeybindingRule[]): IDisposable;
+/**
+ * Create a new editor model.
+ * You can specify the language that should be set for this model or let the language be inferred from the `uri`.
+ */
 export declare function createModel(value: string, language?: string, uri?: URI): ITextModel;
+/**
+ * Change the language for a model.
+ */
 export declare function setModelLanguage(model: ITextModel, mimeTypeOrLanguageId: string): void;
+/**
+ * Set the markers for a model.
+ */
 export declare function setModelMarkers(model: ITextModel, owner: string, markers: IMarkerData[]): void;
+/**
+ * Remove all markers of an owner.
+ */
 export declare function removeAllMarkers(owner: string): void;
+/**
+ * Get markers for owner and/or resource
+ *
+ * @returns list of markers
+ */
 export declare function getModelMarkers(filter: {
     owner?: string;
     resource?: URI;
     take?: number;
 }): IMarker[];
+/**
+ * Emitted when markers change for a model.
+ * @event
+ */
 export declare function onDidChangeMarkers(listener: (e: readonly URI[]) => void): IDisposable;
+/**
+ * Get the model that has `uri` if it exists.
+ */
 export declare function getModel(uri: URI): ITextModel | null;
+/**
+ * Get all the created models.
+ */
 export declare function getModels(): ITextModel[];
+/**
+ * Emitted when a model is created.
+ * @event
+ */
 export declare function onDidCreateModel(listener: (model: ITextModel) => void): IDisposable;
+/**
+ * Emitted right before a model is disposed.
+ * @event
+ */
 export declare function onWillDisposeModel(listener: (model: ITextModel) => void): IDisposable;
+/**
+ * Emitted when a different language is set to a model.
+ * @event
+ */
 export declare function onDidChangeModelLanguage(listener: (e: {
     readonly model: ITextModel;
     readonly oldLanguage: string;
 }) => void): IDisposable;
+/**
+ * Create a new web worker that has model syncing capabilities built in.
+ * Specify an AMD module to load that will `create` an object that will be proxied.
+ */
 export declare function createWebWorker<T extends object>(opts: IInternalWebWorkerOptions): MonacoWebWorker<T>;
+/**
+ * Colorize the contents of `domNode` using attribute `data-lang`.
+ */
 export declare function colorizeElement(domNode: HTMLElement, options: IColorizerElementOptions): Promise<void>;
+/**
+ * Colorize `text` using language `languageId`.
+ */
 export declare function colorize(text: string, languageId: string, options: IColorizerOptions): Promise<string>;
+/**
+ * Colorize a line in a model.
+ */
 export declare function colorizeModelLine(model: ITextModel, lineNumber: number, tabSize?: number): string;
+/**
+ * Tokenize `text` using language `languageId`
+ */
 export declare function tokenize(text: string, languageId: string): languages.Token[][];
+/**
+ * Define a new theme or update an existing theme.
+ */
 export declare function defineTheme(themeName: string, themeData: IStandaloneThemeData): void;
+/**
+ * Switches to a theme.
+ */
 export declare function setTheme(themeName: string): void;
+/**
+ * Clears all cached font measurements and triggers re-measurement.
+ */
 export declare function remeasureFonts(): void;
+/**
+ * Register a command.
+ */
 export declare function registerCommand(id: string, handler: (accessor: any, ...args: any[]) => void): IDisposable;
 export interface ILinkOpener {
     open(resource: URI): boolean | Promise<boolean>;
 }
+/**
+ * Registers a handler that is called when a link is opened in any editor. The handler callback should return `true` if the link was handled and `false` otherwise.
+ * The handler that was registered last will be called first when a link is opened.
+ *
+ * Returns a disposable that can unregister the opener again.
+ */
 export declare function registerLinkOpener(opener: ILinkOpener): IDisposable;
+/**
+ * Represents an object that can handle editor open operations (e.g. when "go to definition" is called
+ * with a resource other than the current model).
+ */
 export interface ICodeEditorOpener {
+    /**
+     * Callback that is invoked when a resource other than the current model should be opened (e.g. when "go to definition" is called).
+     * The callback should return `true` if the request was handled and `false` otherwise.
+     * @param source The code editor instance that initiated the request.
+     * @param resource The URI of the resource that should be opened.
+     * @param selectionOrPosition An optional position or selection inside the model corresponding to `resource` that can be used to set the cursor.
+     */
     openCodeEditor(source: ICodeEditor, resource: URI, selectionOrPosition?: IRange | IPosition): boolean | Promise<boolean>;
 }
+/**
+ * Registers a handler that is called when a resource other than the current model should be opened in the editor (e.g. "go to definition").
+ * The handler callback should return `true` if the request was handled and `false` otherwise.
+ *
+ * Returns a disposable that can unregister the opener again.
+ *
+ * If no handler is registered the default behavior is to do nothing for models other than the currently attached one.
+ */
 export declare function registerEditorOpener(opener: ICodeEditorOpener): IDisposable;
+/**
+ * @internal
+ */
 export declare function createMonacoEditorAPI(): typeof monaco.editor;

package/vscode/src/vs/editor/standalone/browser/standaloneLanguages.d.ts

@@ -10,12 +10,33 @@ import * as model from "@codingame/monaco-vscode-api/vscode/vs/editor/common/mod
 import { IMonarchLanguage } from "../common/monarch/monarchTypes.js";
 import { IStandaloneThemeService } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/common/standaloneTheme.service";
 import { IMarkerData } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers";
+/**
+ * Register information about a new language.
+ */
 export declare function register(language: ILanguageExtensionPoint): void;
+/**
+ * Get the information of all the registered languages.
+ */
 export declare function getLanguages(): ILanguageExtensionPoint[];
 export declare function getEncodedLanguageId(languageId: string): number;
+/**
+ * An event emitted when a language is associated for the first time with a text model.
+ * @event
+ */
 export declare function onLanguage(languageId: string, callback: () => void): IDisposable;
+/**
+ * An event emitted when a language is associated for the first time with a text model or
+ * when a language is encountered during the tokenization of another language.
+ * @event
+ */
 export declare function onLanguageEncountered(languageId: string, callback: () => void): IDisposable;
+/**
+ * Set the editing configuration for a language.
+ */
 export declare function setLanguageConfiguration(languageId: string, configuration: LanguageConfiguration): IDisposable;
+/**
+ * @internal
+ */
 export declare class EncodedTokenizationSupportAdapter implements languages.ITokenizationSupport, IDisposable {
     private readonly _languageId;
     private readonly _actual;
@@ -25,6 +46,9 @@ export declare class EncodedTokenizationSupportAdapter implements languages.ITok
     tokenize(line: string, hasEOL: boolean, state: languages.IState): languages.TokenizationResult;
     tokenizeEncoded(line: string, hasEOL: boolean, state: languages.IState): languages.EncodedTokenizationResult;
 }
+/**
+ * @internal
+ */
 export declare class TokenizationSupportAdapter implements languages.ITokenizationSupport, IDisposable {
     private readonly _languageId;
     private readonly _actual;
@@ -41,74 +65,282 @@ export declare class TokenizationSupportAdapter implements languages.ITokenizati
     private _toBinaryTokens;
     tokenizeEncoded(line: string, hasEOL: boolean, state: languages.IState): languages.EncodedTokenizationResult;
 }
+/**
+ * A token.
+ */
 export interface IToken {
     startIndex: number;
     scopes: string;
 }
+/**
+ * The result of a line tokenization.
+ */
 export interface ILineTokens {
+    /**
+     * The list of tokens on the line.
+     */
     tokens: IToken[];
+    /**
+     * The tokenization end state.
+     * A pointer will be held to this and the object should not be modified by the tokenizer after the pointer is returned.
+     */
     endState: languages.IState;
 }
+/**
+ * The result of a line tokenization.
+ */
 export interface IEncodedLineTokens {
+    /**
+     * The tokens on the line in a binary, encoded format. Each token occupies two array indices. For token i:
+     *  - at offset 2*i => startIndex
+     *  - at offset 2*i + 1 => metadata
+     * Meta data is in binary format:
+     * - -------------------------------------------
+     *     3322 2222 2222 1111 1111 1100 0000 0000
+     *     1098 7654 3210 9876 5432 1098 7654 3210
+     * - -------------------------------------------
+     *     bbbb bbbb bfff ffff ffFF FFTT LLLL LLLL
+     * - -------------------------------------------
+     *  - L = EncodedLanguageId (8 bits): Use `getEncodedLanguageId` to get the encoded ID of a language.
+     *  - T = StandardTokenType (2 bits): Other = 0, Comment = 1, String = 2, RegEx = 3.
+     *  - F = FontStyle (4 bits): None = 0, Italic = 1, Bold = 2, Underline = 4, Strikethrough = 8.
+     *  - f = foreground ColorId (9 bits)
+     *  - b = background ColorId (9 bits)
+     *  - The color value for each colorId is defined in IStandaloneThemeData.customTokenColors:
+     * e.g. colorId = 1 is stored in IStandaloneThemeData.customTokenColors[1]. Color id = 0 means no color,
+     * id = 1 is for the default foreground color, id = 2 for the default background.
+     */
     tokens: Uint32Array;
+    /**
+     * The tokenization end state.
+     * A pointer will be held to this and the object should not be modified by the tokenizer after the pointer is returned.
+     */
     endState: languages.IState;
 }
+/**
+ * A factory for token providers.
+ */
 export interface TokensProviderFactory {
     create(): languages.ProviderResult<TokensProvider | EncodedTokensProvider | IMonarchLanguage>;
 }
+/**
+ * A "manual" provider of tokens.
+ */
 export interface TokensProvider {
+    /**
+     * The initial state of a language. Will be the state passed in to tokenize the first line.
+     */
     getInitialState(): languages.IState;
+    /**
+     * Tokenize a line given the state at the beginning of the line.
+     */
     tokenize(line: string, state: languages.IState): ILineTokens;
 }
+/**
+ * A "manual" provider of tokens, returning tokens in a binary form.
+ */
 export interface EncodedTokensProvider {
+    /**
+     * The initial state of a language. Will be the state passed in to tokenize the first line.
+     */
     getInitialState(): languages.IState;
+    /**
+     * Tokenize a line given the state at the beginning of the line.
+     */
     tokenizeEncoded(line: string, state: languages.IState): IEncodedLineTokens;
+    /**
+     * Tokenize a line given the state at the beginning of the line.
+     */
     tokenize?(line: string, state: languages.IState): ILineTokens;
 }
+/**
+ * Change the color map that is used for token colors.
+ * Supported formats (hex): #RRGGBB, $RRGGBBAA, #RGB, #RGBA
+ */
 export declare function setColorMap(colorMap: string[] | null): void;
+/**
+ * Register a tokens provider factory for a language. This tokenizer will be exclusive with a tokenizer
+ * set using `setTokensProvider` or one created using `setMonarchTokensProvider`, but will work together
+ * with a tokens provider set using `registerDocumentSemanticTokensProvider` or `registerDocumentRangeSemanticTokensProvider`.
+ */
 export declare function registerTokensProviderFactory(languageId: string, factory: TokensProviderFactory): IDisposable;
+/**
+ * Set the tokens provider for a language (manual implementation). This tokenizer will be exclusive
+ * with a tokenizer created using `setMonarchTokensProvider`, or with `registerTokensProviderFactory`,
+ * but will work together with a tokens provider set using `registerDocumentSemanticTokensProvider`
+ * or `registerDocumentRangeSemanticTokensProvider`.
+ */
 export declare function setTokensProvider(languageId: string, provider: TokensProvider | EncodedTokensProvider | Thenable<TokensProvider | EncodedTokensProvider>): IDisposable;
+/**
+ * Set the tokens provider for a language (monarch implementation). This tokenizer will be exclusive
+ * with a tokenizer set using `setTokensProvider`, or with `registerTokensProviderFactory`, but will
+ * work together with a tokens provider set using `registerDocumentSemanticTokensProvider` or
+ * `registerDocumentRangeSemanticTokensProvider`.
+ */
 export declare function setMonarchTokensProvider(languageId: string, languageDef: IMonarchLanguage | Thenable<IMonarchLanguage>): IDisposable;
+/**
+ * Register a reference provider (used by e.g. reference search).
+ */
 export declare function registerReferenceProvider(languageSelector: LanguageSelector, provider: languages.ReferenceProvider): IDisposable;
+/**
+ * Register a rename provider (used by e.g. rename symbol).
+ */
 export declare function registerRenameProvider(languageSelector: LanguageSelector, provider: languages.RenameProvider): IDisposable;
+/**
+ * Register a new symbol-name provider (e.g., when a symbol is being renamed, show new possible symbol-names)
+ */
 export declare function registerNewSymbolNameProvider(languageSelector: LanguageSelector, provider: languages.NewSymbolNamesProvider): IDisposable;
+/**
+ * Register a signature help provider (used by e.g. parameter hints).
+ */
 export declare function registerSignatureHelpProvider(languageSelector: LanguageSelector, provider: languages.SignatureHelpProvider): IDisposable;
+/**
+ * Register a hover provider (used by e.g. editor hover).
+ */
 export declare function registerHoverProvider(languageSelector: LanguageSelector, provider: languages.HoverProvider): IDisposable;
+/**
+ * Register a document symbol provider (used by e.g. outline).
+ */
 export declare function registerDocumentSymbolProvider(languageSelector: LanguageSelector, provider: languages.DocumentSymbolProvider): IDisposable;
+/**
+ * Register a document highlight provider (used by e.g. highlight occurrences).
+ */
 export declare function registerDocumentHighlightProvider(languageSelector: LanguageSelector, provider: languages.DocumentHighlightProvider): IDisposable;
+/**
+ * Register an linked editing range provider.
+ */
 export declare function registerLinkedEditingRangeProvider(languageSelector: LanguageSelector, provider: languages.LinkedEditingRangeProvider): IDisposable;
+/**
+ * Register a definition provider (used by e.g. go to definition).
+ */
 export declare function registerDefinitionProvider(languageSelector: LanguageSelector, provider: languages.DefinitionProvider): IDisposable;
+/**
+ * Register a implementation provider (used by e.g. go to implementation).
+ */
 export declare function registerImplementationProvider(languageSelector: LanguageSelector, provider: languages.ImplementationProvider): IDisposable;
+/**
+ * Register a type definition provider (used by e.g. go to type definition).
+ */
 export declare function registerTypeDefinitionProvider(languageSelector: LanguageSelector, provider: languages.TypeDefinitionProvider): IDisposable;
+/**
+ * Register a code lens provider (used by e.g. inline code lenses).
+ */
 export declare function registerCodeLensProvider(languageSelector: LanguageSelector, provider: languages.CodeLensProvider): IDisposable;
+/**
+ * Register a code action provider (used by e.g. quick fix).
+ */
 export declare function registerCodeActionProvider(languageSelector: LanguageSelector, provider: CodeActionProvider, metadata?: CodeActionProviderMetadata): IDisposable;
+/**
+ * Register a formatter that can handle only entire models.
+ */
 export declare function registerDocumentFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.DocumentFormattingEditProvider): IDisposable;
+/**
+ * Register a formatter that can handle a range inside a model.
+ */
 export declare function registerDocumentRangeFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.DocumentRangeFormattingEditProvider): IDisposable;
+/**
+ * Register a formatter than can do formatting as the user types.
+ */
 export declare function registerOnTypeFormattingEditProvider(languageSelector: LanguageSelector, provider: languages.OnTypeFormattingEditProvider): IDisposable;
+/**
+ * Register a link provider that can find links in text.
+ */
 export declare function registerLinkProvider(languageSelector: LanguageSelector, provider: languages.LinkProvider): IDisposable;
+/**
+ * Register a completion item provider (use by e.g. suggestions).
+ */
 export declare function registerCompletionItemProvider(languageSelector: LanguageSelector, provider: languages.CompletionItemProvider): IDisposable;
+/**
+ * Register a document color provider (used by Color Picker, Color Decorator).
+ */
 export declare function registerColorProvider(languageSelector: LanguageSelector, provider: languages.DocumentColorProvider): IDisposable;
+/**
+ * Register a folding range provider
+ */
 export declare function registerFoldingRangeProvider(languageSelector: LanguageSelector, provider: languages.FoldingRangeProvider): IDisposable;
+/**
+ * Register a declaration provider
+ */
 export declare function registerDeclarationProvider(languageSelector: LanguageSelector, provider: languages.DeclarationProvider): IDisposable;
+/**
+ * Register a selection range provider
+ */
 export declare function registerSelectionRangeProvider(languageSelector: LanguageSelector, provider: languages.SelectionRangeProvider): IDisposable;
+/**
+ * Register a document semantic tokens provider. A semantic tokens provider will complement and enhance a
+ * simple top-down tokenizer. Simple top-down tokenizers can be set either via `setMonarchTokensProvider`
+ * or `setTokensProvider`.
+ *
+ * For the best user experience, register both a semantic tokens provider and a top-down tokenizer.
+ */
 export declare function registerDocumentSemanticTokensProvider(languageSelector: LanguageSelector, provider: languages.DocumentSemanticTokensProvider): IDisposable;
+/**
+ * Register a document range semantic tokens provider. A semantic tokens provider will complement and enhance a
+ * simple top-down tokenizer. Simple top-down tokenizers can be set either via `setMonarchTokensProvider`
+ * or `setTokensProvider`.
+ *
+ * For the best user experience, register both a semantic tokens provider and a top-down tokenizer.
+ */
 export declare function registerDocumentRangeSemanticTokensProvider(languageSelector: LanguageSelector, provider: languages.DocumentRangeSemanticTokensProvider): IDisposable;
+/**
+ * Register an inline completions provider.
+ */
 export declare function registerInlineCompletionsProvider(languageSelector: LanguageSelector, provider: languages.InlineCompletionsProvider): IDisposable;
+/**
+ * Register an inlay hints provider.
+ */
 export declare function registerInlayHintsProvider(languageSelector: LanguageSelector, provider: languages.InlayHintsProvider): IDisposable;
+/**
+ * Contains additional diagnostic information about the context in which
+ * a [code action](#CodeActionProvider.provideCodeActions) is run.
+ */
 export interface CodeActionContext {
+    /**
+     * An array of diagnostics.
+     */
     readonly markers: IMarkerData[];
+    /**
+     * Requested kind of actions to return.
+     */
     readonly only?: string;
+    /**
+     * The reason why code actions were requested.
+     */
     readonly trigger: languages.CodeActionTriggerType;
 }
+/**
+ * The code action interface defines the contract between extensions and
+ * the [light bulb](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) feature.
+ */
 export interface CodeActionProvider {
+    /**
+     * Provide commands for the given document and range.
+     */
     provideCodeActions(model: model.ITextModel, range: Range, context: CodeActionContext, token: CancellationToken): languages.ProviderResult<languages.CodeActionList>;
+    /**
+     * Given a code action fill in the edit. Will only invoked when missing.
+     */
     resolveCodeAction?(codeAction: languages.CodeAction, token: CancellationToken): languages.ProviderResult<languages.CodeAction>;
 }
+/**
+ * Metadata about the type of code actions that a {@link CodeActionProvider} provides.
+ */
 export interface CodeActionProviderMetadata {
+    /**
+     * List of code action kinds that a {@link CodeActionProvider} may return.
+     *
+     * This list is used to determine if a given `CodeActionProvider` should be invoked or not.
+     * To avoid unnecessary computation, every `CodeActionProvider` should list use `providedCodeActionKinds`. The
+     * list of kinds may either be generic, such as `["quickfix", "refactor", "source"]`, or list out every kind provided,
+     * such as `["quickfix.removeLine", "source.fixAll" ...]`.
+     */
     readonly providedCodeActionKinds?: readonly string[];
     readonly documentation?: ReadonlyArray<{
         readonly kind: string;
         readonly command: languages.Command;
     }>;
 }
+/**
+ * @internal
+ */
 export declare function createMonacoLanguagesAPI(): typeof monaco.languages;

package/vscode/src/vs/editor/standalone/browser/standaloneWebWorker.d.ts

@@ -1,13 +1,40 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+/**
+ * Create a new web worker that has model syncing capabilities built in.
+ * Specify an AMD module to load that will `create` an object that will be proxied.
+ */
 export declare function createWebWorker<T extends object>(modelService: IModelService, opts: IInternalWebWorkerOptions): MonacoWebWorker<T>;
+/**
+ * A web worker that can provide a proxy to an arbitrary file.
+ */
 export interface MonacoWebWorker<T> {
+    /**
+     * Terminate the web worker, thus invalidating the returned proxy.
+     */
     dispose(): void;
+    /**
+     * Get a proxy to the arbitrary loaded code.
+     */
     getProxy(): Promise<T>;
+    /**
+     * Synchronize (send) the models at `resources` to the web worker,
+     * making them available in the monaco.worker.getMirrorModels().
+     */
     withSyncedResources(resources: URI[]): Promise<T>;
 }
 export interface IInternalWebWorkerOptions {
+    /**
+     * The worker.
+     */
     worker: Worker | Promise<Worker>;
+    /**
+     * An object that can be used by the web worker to make calls back to the main thread.
+     */
     host?: any;
+    /**
+     * Keep idle models.
+     * Defaults to false, which means that idle models will stop syncing after a while.
+     */
     keepIdleModels?: boolean;
 }

package/vscode/src/vs/editor/standalone/common/monarch/monarchCommon.d.ts

@@ -62,12 +62,46 @@ export interface IBranch {
     value: FuzzyAction;
     test?: (id: string, matches: string[], state: string, eos: boolean) => boolean;
 }
+/**
+ * Is a string null, undefined, or empty?
+ */
 export declare function empty(s: string): boolean;
+/**
+ * Puts a string to lower case if 'ignoreCase' is set.
+ */
 export declare function fixCase(lexer: ILexerMin, str: string): string;
+/**
+ * Ensures there are no bad characters in a CSS token class.
+ */
 export declare function sanitize(s: string): string;
+/**
+ * Logs a message.
+ */
 export declare function log(lexer: ILexerMin, msg: string): void;
 export declare function createError(lexer: ILexerMin, msg: string): Error;
+/**
+ * substituteMatches is used on lexer strings and can substitutes predefined patterns:
+ * 		$$  => $
+ * 		$#  => id
+ * 		$n  => matched entry n
+ * 		@attr => contents of lexer[attr]
+ *
+ * See documentation for more info
+ */
 export declare function substituteMatches(lexer: ILexerMin, str: string, id: string, matches: string[], state: string): string;
+/**
+ * substituteMatchesRe is used on lexer regex rules and can substitutes predefined patterns:
+ * 		$Sn => n'th part of state
+ *
+ */
 export declare function substituteMatchesRe(lexer: ILexerMin, str: string, state: string): string;
+/**
+ * Find the tokenizer rules for a specific state (i.e. next action)
+ */
 export declare function findRules(lexer: ILexer, inState: string): IRule[] | null;
+/**
+ * Is a certain state defined? In contrast to 'findRules' this works on a ILexerMin.
+ * This is used during compilation where we may know the defined states
+ * but not yet whether the corresponding rules are correct.
+ */
 export declare function stateExists(lexer: ILexerMin, inState: string): boolean;

package/vscode/src/vs/editor/standalone/common/monarch/monarchCompile.d.ts

@@ -1,3 +1,12 @@
 import * as monarchCommon from "./monarchCommon.js";
 import { IMonarchLanguage } from "./monarchTypes.js";
+/**
+ * Compiles a json description function into json where all regular expressions,
+ * case matches etc, are compiled and all include rules are expanded.
+ * We also compile the bracket definitions, supply defaults, and do many sanity checks.
+ * If the 'jsonStrict' parameter is 'false', we allow at certain locations
+ * regular expression objects and functions that get called during lexing.
+ * (Currently we have no samples that need this so perhaps we should always have
+ * jsonStrict to true).
+ */
 export declare function compile(languageId: string, json: IMonarchLanguage): monarchCommon.ILexer;