@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/editor/browser/gpu/renderStrategy/viewportRenderStrategy.d.ts

@@ -5,12 +5,22 @@ import type { ViewLineOptions } from "../../viewParts/viewLines/viewLineOptions.
 import { GlyphRasterizer } from "../raster/glyphRasterizer.js";
 import { ViewGpuContext } from "../viewGpuContext.js";
 import { BaseRenderStrategy } from "./baseRenderStrategy.js";
+/**
+ * A render strategy that uploads the content of the entire viewport every frame.
+ */
 export declare class ViewportRenderStrategy extends BaseRenderStrategy {
+    /**
+     * The hard cap for line columns that can be rendered by the GPU renderer.
+     */
     static readonly maxSupportedColumns = 2000;
     readonly type = "viewport";
     readonly wgsl: string;
     private _cellBindBufferLineCapacity;
     private _cellBindBuffer;
+    /**
+     * The cell value buffers, these hold the cells and their glyphs. It's double buffers such that
+     * the thread doesn't block when one is being uploaded to the GPU.
+     */
     private _cellValueBuffers;
     private _activeDoubleBufferIndex;
     private _visibleObjectCount;

package/vscode/src/vs/editor/browser/gpu/taskQueue.d.ts

@@ -1,9 +1,25 @@
 import { Disposable, type IDisposable } from "../../../base/common/lifecycle.js";
 import { IInstantiationService } from "../../../platform/instantiation/common/instantiation.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
+/**
+ * Copyright (c) 2022 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
 export interface ITaskQueue extends IDisposable {
+    /**
+     * Adds a task to the queue which will run in a future idle callback.
+     * To avoid perceivable stalls on the mainthread, tasks with heavy workload
+     * should split their work into smaller pieces and return `true` to get
+     * called again until the work is done (on falsy return value).
+     */
     enqueue(task: () => boolean | void): void;
+    /**
+     * Flushes the queue, running all remaining tasks synchronously.
+     */
     flush(): void;
+    /**
+     * Clears any remaining tasks from the queue, these will not be run.
+     */
     clear(): void;
 }
 interface ITaskDeadline {
@@ -24,6 +40,11 @@ declare abstract class TaskQueue extends Disposable implements ITaskQueue {
     private _start;
     private _process;
 }
+/**
+ * A queue of that runs tasks over several tasks via setTimeout, trying to maintain above 60 frames
+ * per second. The tasks will run in the order they are enqueued, but they will run some time later,
+ * and care should be taken to ensure they're non-urgent and will not introduce race conditions.
+ */
 export declare class PriorityTaskQueue extends TaskQueue {
     protected _requestCallback(callback: CallbackWithDeadline): number;
     protected _cancelCallback(identifier: number): void;
@@ -33,7 +54,19 @@ declare class IdleTaskQueueInternal extends TaskQueue {
     protected _requestCallback(callback: IdleRequestCallback): number;
     protected _cancelCallback(identifier: number): void;
 }
+/**
+ * A queue of that runs tasks over several idle callbacks, trying to respect the idle callback's
+ * deadline given by the environment. The tasks will run in the order they are enqueued, but they
+ * will run some time later, and care should be taken to ensure they're non-urgent and will not
+ * introduce race conditions.
+ *
+ * This reverts to a {@link PriorityTaskQueue} if the environment does not support idle callbacks.
+ */
 export declare const IdleTaskQueue: typeof PriorityTaskQueue | typeof IdleTaskQueueInternal;
+/**
+ * An object that tracks a single debounced task that will run on the next idle frame. When called
+ * multiple times, only the last set task will run.
+ */
 export declare class DebouncedIdleTask {
     private _queue;
     constructor(instantiationService: IInstantiationService);

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.d.ts

@@ -15,6 +15,9 @@ export declare class ViewGpuContext extends Disposable {
     private readonly _instantiationService;
     private readonly _notificationService;
     private readonly configurationService;
+    /**
+     * The hard cap for line columns rendered by the GPU renderer.
+     */
     readonly maxGpuCols = 2000;
     readonly canvas: FastDomNode<HTMLCanvasElement>;
     readonly ctx: GPUCanvasContext;
@@ -26,7 +29,18 @@ export declare class ViewGpuContext extends Disposable {
     private static readonly _decorationStyleCache;
     static get decorationStyleCache(): DecorationStyleCache;
     private static _atlas;
+    /**
+     * The shared texture atlas to use across all views.
+     *
+     * @throws if called before the GPU device is resolved
+     */
     static get atlas(): TextureAtlas;
+    /**
+     * The shared texture atlas to use across all views. This is a convenience alias for
+     * {@link ViewGpuContext.atlas}.
+     *
+     * @throws if called before the GPU device is resolved
+     */
     get atlas(): TextureAtlas;
     readonly canvasDevicePixelDimensions: IObservable<{
         width: number;
@@ -35,6 +49,14 @@ export declare class ViewGpuContext extends Disposable {
     readonly devicePixelRatio: IObservable<number>;
     readonly contentLeft: IObservable<number>;
     constructor(context: ViewContext, _instantiationService: IInstantiationService, _notificationService: INotificationService, configurationService: IConfigurationService);
+    /**
+     * This method determines which lines can be and are allowed to be rendered using the GPU
+     * renderer. Eventually this should trend all lines, except maybe exceptional cases like
+     * decorations that use class names.
+     */
     canRender(options: ViewLineOptions, viewportData: ViewportData, lineNumber: number): boolean;
+    /**
+     * Like {@link canRender} but returns detailed information about why the line cannot be rendered.
+     */
     canRenderDetailed(options: ViewLineOptions, viewportData: ViewportData, lineNumber: number): string[];
 }

package/vscode/src/vs/editor/browser/observableCodeEditor.d.ts

@@ -10,10 +10,16 @@ import { IModelDeltaDecoration, ITextModel } from "../common/model.js";
 import { IModelContentChangedEvent } from "../common/textModelEvents.js";
 import { ICodeEditor, IContentWidgetPosition, IEditorMouseEvent, IOverlayWidgetPosition, IPasteEvent } from "./editorBrowser.js";
 import { Point } from "../common/core/2d/point.js";
+/**
+ * Returns a facade for the code editor that provides observables for various states/events.
+*/
 export declare function observableCodeEditor(editor: ICodeEditor): ObservableCodeEditor;
 export declare class ObservableCodeEditor extends Disposable {
     readonly editor: ICodeEditor;
     private static readonly _map;
+    /**
+     * Make sure that editor is not disposed yet!
+    */
     static get(editor: ICodeEditor): ObservableCodeEditor;
     private _updateCounter;
     private _currentTransaction;

package/vscode/src/vs/editor/browser/services/codeEditorService.service.d.ts

@@ -25,6 +25,9 @@ export interface ICodeEditorService {
     addDiffEditor(editor: IDiffEditor): void;
     removeDiffEditor(editor: IDiffEditor): void;
     listDiffEditors(): readonly IDiffEditor[];
+    /**
+    * Returns the current focused code editor (if the focus is in the editor or in an editor widget) or null.
+    */
     getFocusedCodeEditor(): ICodeEditor | null;
     registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): void;
     listDecorationTypes(): string[];

package/vscode/src/vs/editor/browser/services/hoverService/hover.css

@@ -1,7 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-workbench .workbench-hover {
 	position: relative;
 	font-size: 13px;
 	line-height: 19px;
+	/* Must be higher than sash's z-index and terminal canvases */
 	z-index: 40;
 	overflow: hidden;
 	max-width: 700px;
@@ -11,34 +17,45 @@
 	color: var(--vscode-editorHoverWidget-foreground);
 	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
 }
+
 .monaco-workbench .workbench-hover .monaco-action-bar .action-item .codicon {
+	/* Given our font-size, adjust action icons accordingly */
 	width: 13px;
 	height: 13px;
 }
+
 .monaco-workbench .workbench-hover hr {
 	border-bottom: none;
 }
+
 .monaco-workbench .workbench-hover.compact {
 	font-size: 12px;
 }
+
 .monaco-workbench .workbench-hover.compact .monaco-action-bar .action-item .codicon {
+	/* Given our font-size, adjust action icons accordingly */
 	width: 12px;
 	height: 12px;
 }
+
 .monaco-workbench .workbench-hover.compact .hover-contents {
 	padding: 2px 8px;
 }
+
 .monaco-workbench .workbench-hover-container.locked .workbench-hover {
 	outline: 1px solid var(--vscode-editorHoverWidget-border);
 }
 .monaco-workbench .workbench-hover-container:focus-within.locked .workbench-hover {
 	outline-color: var(--vscode-focusBorder);
 }
+
 .monaco-workbench .workbench-hover-pointer {
 	position: absolute;
+	/* Must be higher than workbench hover z-index */
 	z-index: 41;
 	pointer-events: none;
 }
+
 .monaco-workbench .workbench-hover-pointer:after {
 	content: '';
 	position: absolute;
@@ -58,51 +75,66 @@
 	border-right: 1px solid var(--vscode-focusBorder);
 	border-bottom: 1px solid var(--vscode-focusBorder);
 }
+
 .monaco-workbench .workbench-hover-pointer.left   { left: -3px; }
 .monaco-workbench .workbench-hover-pointer.right  { right: 3px; }
 .monaco-workbench .workbench-hover-pointer.top    { top: -3px; }
 .monaco-workbench .workbench-hover-pointer.bottom { bottom: 3px; }
+
 .monaco-workbench .workbench-hover-pointer.left:after {
 	transform: rotate(135deg);
 }
+
 .monaco-workbench .workbench-hover-pointer.right:after {
 	transform: rotate(315deg);
 }
+
 .monaco-workbench .workbench-hover-pointer.top:after {
 	transform: rotate(225deg);
 }
+
 .monaco-workbench .workbench-hover-pointer.bottom:after {
 	transform: rotate(45deg);
 }
+
 .monaco-workbench .workbench-hover a {
 	color: var(--vscode-textLink-foreground);
 }
+
 .monaco-workbench .workbench-hover a:focus {
 	outline: 1px solid;
 	outline-offset: -1px;
 	text-decoration: underline;
 	outline-color: var(--vscode-focusBorder);
 }
+
 .monaco-workbench .workbench-hover a.codicon:focus,
 .monaco-workbench .workbench-hover a.monaco-button:focus {
 	text-decoration: none;
 }
+
 .monaco-workbench .workbench-hover a:hover,
 .monaco-workbench .workbench-hover a:active {
 	color: var(--vscode-textLink-activeForeground);
 }
+
 .monaco-workbench .workbench-hover code {
 	background: var(--vscode-textCodeBlock-background);
 }
+
 .monaco-workbench .workbench-hover .hover-row .actions {
 	background: var(--vscode-editorHoverWidget-statusBarBackground);
 }
+
 .monaco-workbench .workbench-hover.right-aligned {
+	/* The context view service wraps strangely when it's right up against the edge without this */
 	left: 1px;
 }
+
 .monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions {
 	flex-direction: row-reverse;
 }
+
 .monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container {
 	margin-right: 0;
 	margin-left: 16px;

package/vscode/src/vs/editor/browser/services/hoverService/hoverWidget.d.ts

@@ -41,6 +41,10 @@ export declare class HoverWidget extends Widget implements IHoverWidget {
     get anchor(): AnchorPosition;
     get x(): number;
     get y(): number;
+    /**
+     * Whether the hover is "locked" by holding the alt/option key. When locked, the hover will not
+     * hide and can be hovered regardless of whether the `hideOnHover` hover option is set.
+     */
     get isLocked(): boolean;
     set isLocked(value: boolean);
     constructor(options: IHoverOptions, _keybindingService: IKeybindingService, _configurationService: IConfigurationService, _openerService: IOpenerService, _instantiationService: IInstantiationService, _accessibilityService: IAccessibilityService);

package/vscode/src/vs/editor/browser/services/inlineCompletionsService.service.d.ts

@@ -3,9 +3,25 @@ export declare const IInlineCompletionsService: import("../../../platform/instan
 export interface IInlineCompletionsService {
     readonly _serviceBrand: undefined;
     onDidChangeIsSnoozing: Event<boolean>;
+    /**
+    * Get the remaining time (in ms) for which inline completions should be snoozed,
+    * or 0 if not snoozed.
+    */
     readonly snoozeTimeLeft: number;
+    /**
+    * Snooze inline completions for the specified duration. If already snoozed, extend the snooze time.
+    */
     snooze(durationMs?: number): void;
+    /**
+    * Snooze inline completions for the specified duration. If already snoozed, overwrite the existing snooze time.
+    */
     setSnoozeDuration(durationMs: number): void;
+    /**
+    * Check if inline completions are currently snoozed.
+    */
     isSnoozing(): boolean;
+    /**
+    * Cancel the current snooze.
+    */
     cancelSnooze(): void;
 }

package/vscode/src/vs/editor/browser/view/renderingContext.d.ts

@@ -38,10 +38,23 @@ export declare class LineVisibleRanges {
     readonly outsideRenderedLine: boolean;
     readonly lineNumber: number;
     readonly ranges: HorizontalRange[];
+    /**
+     * Indicates if the requested range does not end in this line, but continues on the next line.
+     */
     readonly continuesOnNextLine: boolean;
+    /**
+     * Returns the element with the smallest `lineNumber`.
+     */
     static firstLine(ranges: LineVisibleRanges[] | null): LineVisibleRanges | null;
+    /**
+     * Returns the element with the largest `lineNumber`.
+     */
     static lastLine(ranges: LineVisibleRanges[] | null): LineVisibleRanges | null;
-    constructor(outsideRenderedLine: boolean, lineNumber: number, ranges: HorizontalRange[], continuesOnNextLine: boolean);
+    constructor(outsideRenderedLine: boolean, lineNumber: number, ranges: HorizontalRange[], 
+    /**
+     * Indicates if the requested range does not end in this line, but continues on the next line.
+     */
+    continuesOnNextLine: boolean);
 }
 export declare class HorizontalRange {
     _horizontalRangeBrand: void;
@@ -61,6 +74,9 @@ export declare class FloatHorizontalRange {
 }
 export declare class HorizontalPosition {
     outsideRenderedLine: boolean;
+    /**
+     * Math.round(this.originalLeft)
+     */
     left: number;
     originalLeft: number;
     constructor(outsideRenderedLine: boolean, left: number);

package/vscode/src/vs/editor/browser/view/viewController.d.ts

@@ -9,6 +9,9 @@ import { IViewModel } from "../../common/viewModel.js";
 import { IMouseWheelEvent } from "../../../base/browser/mouseEvent.js";
 export interface IMouseDispatchData {
     position: Position;
+    /**
+     * Desired mouse column (e.g. when position.column gets clamped to text length -- clicking after text on a line).
+     */
     mouseColumn: number;
     revealType: NavigationCommandRevealType;
     startedOnLineNumbers: boolean;

package/vscode/src/vs/editor/browser/view/viewLayer.d.ts

@@ -3,10 +3,20 @@ import { StringBuilder } from "../../common/core/stringBuilder.js";
 import * as viewEvents from "../../common/viewEvents.js";
 import { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
 import { ViewContext } from "../../common/viewModel/viewContext.js";
+/**
+ * Represents a visible line
+ */
 export interface IVisibleLine extends ILine {
     getDomNode(): HTMLElement | null;
     setDomNode(domNode: HTMLElement): void;
+    /**
+     * Return null if the HTML should not be touched.
+     * Return the new HTML otherwise.
+     */
     renderLine(lineNumber: number, deltaTop: number, lineHeight: number, viewportData: ViewportData, sb: StringBuilder): boolean;
+    /**
+     * Layout the line.
+     */
     layoutLine(lineNumber: number, deltaTop: number, lineHeight: number): void;
 }
 export interface ILine {
@@ -27,10 +37,19 @@ export declare class RenderedLinesCollection<T extends ILine> {
         rendLineNumberStart: number;
         lines: T[];
     };
+    /**
+     * @returns Inclusive line number that is inside this collection
+     */
     getStartLineNumber(): number;
+    /**
+     * @returns Inclusive line number that is inside this collection
+     */
     getEndLineNumber(): number;
     getCount(): number;
     getLine(lineNumber: number): T;
+    /**
+     * @returns Lines that were removed from this collection
+     */
     onLinesDeleted(deleteFromLineNumber: number, deleteToLineNumber: number): T[] | null;
     onLinesChanged(changeFromLineNumber: number, changeCount: number): boolean;
     onLinesInserted(insertFromLineNumber: number, insertToLineNumber: number): T[] | null;

package/vscode/src/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css

@@ -1,8 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .blockDecorations-container {
 	position: absolute;
 	top: 0;
 	pointer-events: none;
 }
+
 .monaco-editor .blockDecorations-block {
 	position: absolute;
 	box-sizing: border-box;

package/vscode/src/vs/editor/browser/viewParts/contentWidgets/contentWidgets.d.ts

@@ -7,6 +7,11 @@ import * as viewEvents from "../../../common/viewEvents.js";
 import { ViewportData } from "../../../common/viewLayout/viewLinesViewportData.js";
 import { PositionAffinity } from "../../../common/model.js";
 import { IPosition } from "../../../common/core/position.js";
+/**
+ * This view part is responsible for rendering the content widgets, which are
+ * used for rendering elements that are associated to an editor position,
+ * such as suggestions or the parameter hints.
+ */
 export declare class ViewContentWidgets extends ViewPart {
     private readonly _viewDomNode;
     private _widgets;

package/vscode/src/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .view-overlays .current-line {
 	display: block;
 	position: absolute;
@@ -6,6 +11,7 @@
 	box-sizing: border-box;
 	height: 100%;
 }
+
 .monaco-editor .margin-view-overlays .current-line {
 	display: block;
 	position: absolute;
@@ -14,6 +20,7 @@
 	box-sizing: border-box;
 	height: 100%;
 }
+
 .monaco-editor
 	.margin-view-overlays
 	.current-line.current-line-margin.current-line-margin-both {

package/vscode/src/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.d.ts

@@ -11,6 +11,9 @@ export declare abstract class AbstractLineHighlightOverlay extends DynamicViewOv
     protected _selectionIsEmpty: boolean;
     protected _renderLineHighlightOnlyWhenFocus: boolean;
     protected _focused: boolean;
+    /**
+     * Unique sorted list of view line numbers which have cursors sitting on them.
+     */
     private _cursorLineNumbers;
     private _selections;
     private _renderData;
@@ -34,11 +37,17 @@ export declare abstract class AbstractLineHighlightOverlay extends DynamicViewOv
     protected abstract _shouldRenderOther(): boolean;
     protected abstract _renderOne(ctx: RenderingContext, exact: boolean): string;
 }
+/**
+ * Emphasizes the current line by drawing a border around it.
+ */
 export declare class CurrentLineHighlightOverlay extends AbstractLineHighlightOverlay {
     protected _renderOne(ctx: RenderingContext, exact: boolean): string;
     protected _shouldRenderThis(): boolean;
     protected _shouldRenderOther(): boolean;
 }
+/**
+ * Emphasizes the current line margin/gutter by drawing a border around it.
+ */
 export declare class CurrentLineMarginHighlightOverlay extends AbstractLineHighlightOverlay {
     protected _renderOne(ctx: RenderingContext, exact: boolean): string;
     protected _shouldRenderThis(): boolean;

package/vscode/src/vs/editor/browser/viewParts/decorations/decorations.css

@@ -1,3 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/*
+	Keeping name short for faster parsing.
+	cdr = core decorations rendering (div)
+*/
 .monaco-editor .lines-content .cdr {
 	position: absolute;
 	height: 100%;

package/vscode/src/vs/editor/browser/viewParts/editorScrollbar/editorScrollbar.d.ts

@@ -5,6 +5,10 @@ import { RenderingContext, RestrictedRenderingContext } from "../../view/renderi
 import { ViewContext } from "../../../common/viewModel/viewContext.js";
 import * as viewEvents from "../../../common/viewEvents.js";
 import { IMouseWheelEvent } from "../../../../base/browser/mouseEvent.js";
+/**
+ * The editor scrollbar built on VS Code's scrollable element that sits beside
+ * the minimap.
+ */
 export declare class EditorScrollbar extends ViewPart {
     private readonly scrollbar;
     private readonly scrollbarDomNode;

package/vscode/src/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css

@@ -1,13 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .glyph-margin {
 	position: absolute;
 	top: 0;
 }
+
+/*
+	Keeping name short for faster parsing.
+	cgmr = core glyph margin rendering (div)
+*/
 .monaco-editor .glyph-margin-widgets .cgmr {
 	position: absolute;
 	display: flex;
 	align-items: center;
 	justify-content: center;
 }
+
+/*
+	Ensure spinning icons are pixel-perfectly centered and avoid wobble.
+	This is only applied to icons that spin to avoid unnecessary
+	GPU layers and blurry subpixel AA.
+*/
 .monaco-editor .glyph-margin-widgets .cgmr.codicon-modifier-spin::before  {
 	position: absolute;
 	top: 50%;

package/vscode/src/vs/editor/browser/viewParts/glyphMargin/glyphMargin.d.ts

@@ -5,6 +5,10 @@ import { RenderingContext, RestrictedRenderingContext } from "../../view/renderi
 import { ViewPart } from "../../view/viewPart.js";
 import * as viewEvents from "../../../common/viewEvents.js";
 import { ViewContext } from "../../../common/viewModel/viewContext.js";
+/**
+ * Represents a decoration that should be shown along the lines from `startLineNumber` to `endLineNumber`.
+ * This can end up producing multiple `LineDecorationToRender`.
+ */
 export declare class DecorationToRender {
     readonly startLineNumber: number;
     readonly endLineNumber: number;
@@ -14,18 +18,27 @@ export declare class DecorationToRender {
     readonly zIndex: number;
     constructor(startLineNumber: number, endLineNumber: number, className: string, tooltip: string | null, zIndex: number | undefined);
 }
+/**
+ * A decoration that should be shown along a line.
+ */
 export declare class LineDecorationToRender {
     readonly className: string;
     readonly zIndex: number;
     readonly tooltip: string | null;
     constructor(className: string, zIndex: number, tooltip: string | null);
 }
+/**
+ * Decorations to render on a visible line.
+ */
 export declare class VisibleLineDecorationsToRender {
     private readonly decorations;
     add(decoration: LineDecorationToRender): void;
     getDecorations(): LineDecorationToRender[];
 }
 export declare abstract class DedupOverlay extends DynamicViewOverlay {
+    /**
+     * Returns an array with an element for each visible line number.
+     */
     protected _render(visibleStartLineNumber: number, visibleEndLineNumber: number, decorations: DecorationToRender[]): VisibleLineDecorationsToRender[];
 }
 export declare class GlyphMarginWidgets extends ViewPart {
@@ -55,6 +68,9 @@ export declare class GlyphMarginWidgets extends ViewPart {
     private _collectDecorationBasedGlyphRenderRequest;
     private _collectWidgetBasedGlyphRenderRequest;
     private _collectSortedGlyphRenderRequests;
+    /**
+     * Will store render information in each widget's renderInfo and in `_decorationGlyphsToRender`.
+     */
     prepareRender(ctx: RenderingContext): void;
     render(ctx: RestrictedRenderingContext): void;
 }
@@ -62,6 +78,10 @@ export interface IWidgetData {
     widget: IGlyphMarginWidget;
     preference: IGlyphMarginWidgetPosition;
     domNode: FastDomNode<HTMLElement>;
+    /**
+     * it will contain the location where to render the widget
+     * or null if the widget is not visible
+     */
     renderInfo: IRenderInfo | null;
 }
 export interface IRenderInfo {

package/vscode/src/vs/editor/browser/viewParts/gpuMark/gpuMark.css

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .margin-view-overlays .gpu-mark {
 	position: absolute;
 	top: 0;
@@ -9,6 +14,7 @@
 	opacity: 0.2;
 	transition: background-color 0.1s linear;
 }
+
 .monaco-editor .margin-view-overlays .gpu-mark:hover {
 	background-color: var(--vscode-editorWarning-foreground)
 }

package/vscode/src/vs/editor/browser/viewParts/gpuMark/gpuMark.d.ts

@@ -3,6 +3,9 @@ import { ViewContext } from "../../../common/viewModel/viewContext.js";
 import { ViewGpuContext } from "../../gpu/viewGpuContext.js";
 import { DynamicViewOverlay } from "../../view/dynamicViewOverlay.js";
 import { RenderingContext } from "../../view/renderingContext.js";
+/**
+ * A mark on lines to make identification of GPU-rendered lines vs DOM easier.
+ */
 export declare class GpuMarkOverlay extends DynamicViewOverlay {
     private readonly _viewGpuContext;
     static readonly CLASS_NAME = "gpu-mark";

package/vscode/src/vs/editor/browser/viewParts/indentGuides/indentGuides.css

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-editor .lines-content .core-guide {
 	position: absolute;
 	box-sizing: border-box;

package/vscode/src/vs/editor/browser/viewParts/indentGuides/indentGuides.d.ts

@@ -2,6 +2,10 @@ import { DynamicViewOverlay } from "../../view/dynamicViewOverlay.js";
 import { RenderingContext } from "../../view/renderingContext.js";
 import { ViewContext } from "../../../common/viewModel/viewContext.js";
 import * as viewEvents from "../../../common/viewEvents.js";
+/**
+ * Indent guides are vertical lines that help identify the indentation level of
+ * the code.
+ */
 export declare class IndentGuidesOverlay extends DynamicViewOverlay {
     private readonly _context;
     private _primaryPosition;