@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "20.1.1",
+  "version": "20.2.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -15,13 +15,13 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-base-service-override": "20.1.1",
-    "@codingame/monaco-vscode-environment-service-override": "20.1.1",
-    "@codingame/monaco-vscode-extensions-service-override": "20.1.1",
-    "@codingame/monaco-vscode-files-service-override": "20.1.1",
-    "@codingame/monaco-vscode-host-service-override": "20.1.1",
-    "@codingame/monaco-vscode-layout-service-override": "20.1.1",
-    "@codingame/monaco-vscode-quickaccess-service-override": "20.1.1",
+    "@codingame/monaco-vscode-base-service-override": "20.2.1",
+    "@codingame/monaco-vscode-environment-service-override": "20.2.1",
+    "@codingame/monaco-vscode-extensions-service-override": "20.2.1",
+    "@codingame/monaco-vscode-files-service-override": "20.2.1",
+    "@codingame/monaco-vscode-host-service-override": "20.2.1",
+    "@codingame/monaco-vscode-layout-service-override": "20.2.1",
+    "@codingame/monaco-vscode-quickaccess-service-override": "20.2.1",
     "@vscode/iconv-lite-umd": "0.7.0",
     "dompurify": "3.2.6",
     "jschardet": "3.1.4",

package/services.js

@@ -392,10 +392,10 @@ export { IAuthenticationQueryService } from './vscode/src/vs/workbench/services/
 export { ICoreExperimentationService } from './vscode/src/vs/workbench/services/coreExperimentation/common/coreExperimentationService.service.js';
 export { IWorkbenchMcpManagementService } from './vscode/src/vs/workbench/services/mcp/common/mcpWorkbenchManagementService.service.js';
 
-if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "360a4e4fd251bfce169a4ddf857c7d25d1ad40da-5c7c78fd-79be-449c-98e9-c6acc6d05a7d") {
-    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"360a4e4fd251bfce169a4ddf857c7d25d1ad40da-5c7c78fd-79be-449c-98e9-c6acc6d05a7d"}, ${window.monacoVscodeApiBuildId} is already loaded`);
+if (window.monacoVscodeApiBuildId != null && window.monacoVscodeApiBuildId !== "360a4e4fd251bfce169a4ddf857c7d25d1ad40da-db078df8-9687-4b3b-bdc4-ac131c2a7858") {
+    throw new Error(`Another version of monaco-vscode-api has already been loaded. Trying to load ${"360a4e4fd251bfce169a4ddf857c7d25d1ad40da-db078df8-9687-4b3b-bdc4-ac131c2a7858"}, ${window.monacoVscodeApiBuildId} is already loaded`);
 }
-window.monacoVscodeApiBuildId = "360a4e4fd251bfce169a4ddf857c7d25d1ad40da-5c7c78fd-79be-449c-98e9-c6acc6d05a7d";
+window.monacoVscodeApiBuildId = "360a4e4fd251bfce169a4ddf857c7d25d1ad40da-db078df8-9687-4b3b-bdc4-ac131c2a7858";
 async function initialize(overrides, container = document.body, configuration = {}, env) {
     checkServicesNotInitialized();
     injectCss(container);

package/vscode/src/vs/base/browser/browser.d.ts

@@ -1,7 +1,9 @@
 export declare function addMatchMediaChangeListener(targetWindow: Window, query: string | MediaQueryList, callback: (this: MediaQueryList, ev: MediaQueryListEvent) => unknown): void;
+/** A zoom index, e.g. 1, 2, 3 */
 export declare function setZoomLevel(zoomLevel: number, targetWindow: Window): void;
 export declare function getZoomLevel(targetWindow: Window): number;
 export declare const onDidChangeZoomLevel: import("../common/event.js").Event<number>;
+/** The zoom scale for an index, e.g. 1, 1.2, 1.4 */
 export declare function getZoomFactor(targetWindow: Window): number;
 export declare function setZoomFactor(zoomFactor: number, targetWindow: Window): void;
 export declare function setFullscreen(fullscreen: boolean, targetWindow: Window): void;

package/vscode/src/vs/base/browser/canIUse.d.ts

@@ -3,6 +3,9 @@ export declare enum KeyboardSupport {
     FullScreen = 1,
     None = 2
 }
+/**
+ * Browser feature we can support in current platform, browser and environment.
+ */
 export declare const BrowserFeatures: {
     clipboard: {
         writeText: true;

package/vscode/src/vs/base/browser/contextmenu.d.ts

@@ -11,10 +11,21 @@ export interface IContextMenuEvent {
     readonly altKey?: boolean;
     readonly metaKey?: boolean;
 }
+/**
+ * A specific context menu location to position the menu at.
+ * Uses some TypeScript type tricks to prevent allowing to
+ * pass in a `MouseEvent` and force people to use `StandardMouseEvent`.
+ */
 type ContextMenuLocation = OmitOptional<IAnchor> & {
     getModifierState?: never;
 };
 export interface IContextMenuDelegate {
+    /**
+     * The anchor where to position the context view.
+     * Use a `HTMLElement` to position the view at the element,
+     * a `StandardMouseEvent` to position it at the mouse position
+     * or an `ContextMenuLocation` to position it at a specific location.
+     */
     getAnchor(): HTMLElement | StandardMouseEvent | ContextMenuLocation;
     getActions(): readonly IAction[];
     getCheckedActionsRepresentation?(action: IAction): "radio" | "checkbox";
@@ -29,6 +40,9 @@ export interface IContextMenuDelegate {
     anchorAlignment?: AnchorAlignment;
     anchorAxisAlignment?: AnchorAxisAlignment;
     domForShadowRoot?: HTMLElement;
+    /**
+     * custom context menus with higher layers are rendered higher in z-index order
+     */
     layer?: number;
 }
 export interface IContextMenuProvider {

package/vscode/src/vs/base/browser/cssValue.d.ts

@@ -8,9 +8,17 @@ export declare function sizeValue(value: string): CssFragment;
 export declare function hexColorValue(value: string): CssFragment;
 export declare function identValue(value: string): CssFragment;
 export declare function stringValue(value: string): CssFragment;
+/**
+ * returns url('...')
+ */
 export declare function asCSSUrl(uri: URI | null | undefined): CssFragment;
 export declare function className(value: string, escapingExpected?: boolean): CssFragment;
 type InlineCssTemplateValue = CssFragment | Color;
+/**
+ * Template string tag that that constructs a CSS fragment.
+ *
+ * All expressions in the template must be css safe values.
+ */
 export declare function inline(strings: TemplateStringsArray, ...values: InlineCssTemplateValue[]): CssFragment;
 export declare class Builder {
     private readonly _parts;

package/vscode/src/vs/base/browser/dnd.d.ts

@@ -1,4 +1,8 @@
 import { Disposable } from "../common/lifecycle.js";
+/**
+ * A helper that will execute a provided function when the provided HTMLElement receives
+ *  dragover event for 800ms. If the drag is aborted before, the callback will not be triggered.
+ */
 export declare class DelayedDragHandler extends Disposable {
     private timeout;
     constructor(container: HTMLElement, callback: () => void);
@@ -6,10 +10,27 @@ export declare class DelayedDragHandler extends Disposable {
     dispose(): void;
 }
 export declare const DataTransfers: {
+    /**
+     * Application specific resource transfer type
+     */
     RESOURCES: string;
+    /**
+     * Browser specific transfer type to download
+     */
     DOWNLOAD_URL: string;
+    /**
+     * Browser specific transfer type for files
+     */
     FILES: string;
+    /**
+     * Typically transfer type for copy/paste transfers.
+     */
     TEXT: "text/plain";
+    /**
+     * Internal type used to pass around text/uri-list data.
+     *
+     * This is needed to work around https://bugs.chromium.org/p/chromium/issues/detail?id=239745.
+     */
     INTERNAL_URI_LIST: string;
 };
 export interface IDragAndDropData {

package/vscode/src/vs/base/browser/dom.d.ts

@@ -35,20 +35,62 @@ export declare const addStandardDisposableGenericMouseUpListener: (node: HTMLEle
 export declare function addDisposableGenericMouseDownListener(node: EventTarget, handler: (event: any) => void, useCapture?: boolean): IDisposable;
 export declare function addDisposableGenericMouseMoveListener(node: EventTarget, handler: (event: any) => void, useCapture?: boolean): IDisposable;
 export declare function addDisposableGenericMouseUpListener(node: EventTarget, handler: (event: any) => void, useCapture?: boolean): IDisposable;
+/**
+ * Execute the callback the next time the browser is idle, returning an
+ * {@link IDisposable} that will cancel the callback when disposed. This wraps
+ * [requestIdleCallback] so it will fallback to [setTimeout] if the environment
+ * doesn't support it.
+ *
+ * @param targetWindow The window for which to run the idle callback
+ * @param callback The callback to run when idle, this includes an
+ * [IdleDeadline] that provides the time alloted for the idle callback by the
+ * browser. Not respecting this deadline will result in a degraded user
+ * experience.
+ * @param timeout A timeout at which point to queue no longer wait for an idle
+ * callback but queue it on the regular event loop (like setTimeout). Typically
+ * this should not be used.
+ *
+ * [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline
+ * [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback
+ * [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout
+ */
 export declare function runWhenWindowIdle(targetWindow: Window | typeof globalThis, callback: (idle: IdleDeadline) => void, timeout?: number): IDisposable;
+/**
+ * An implementation of the "idle-until-urgent"-strategy as introduced
+ * here: https://philipwalton.com/articles/idle-until-urgent/
+ */
 export declare class WindowIdleValue<T> extends AbstractIdleValue<T> {
     constructor(targetWindow: Window | typeof globalThis, executor: () => T);
 }
+/**
+ * Schedule a callback to be run at the next animation frame.
+ * This allows multiple parties to register callbacks that should run at the next animation frame.
+ * If currently in an animation frame, `runner` will be executed immediately.
+ * @return token that can be used to cancel the scheduled runner (only if `runner` was not executed immediately).
+ */
 export declare let runAtThisOrScheduleAtNextAnimationFrame: (targetWindow: Window, runner: () => void, priority?: number) => IDisposable;
+/**
+ * Schedule a callback to be run at the next animation frame.
+ * This allows multiple parties to register callbacks that should run at the next animation frame.
+ * If currently in an animation frame, `runner` will be executed at the next animation frame.
+ * @return token that can be used to cancel the scheduled runner.
+ */
 export declare let scheduleAtNextAnimationFrame: (targetWindow: Window, runner: () => void, priority?: number) => IDisposable;
 export declare function disposableWindowInterval(targetWindow: Window, handler: () => void | boolean | Promise<unknown>, interval: number, iterations?: number): IDisposable;
 export declare class WindowIntervalTimer extends IntervalTimer {
     private readonly defaultTarget?;
+    /**
+     *
+     * @param node The optional node from which the target window is determined
+     */
     constructor(node?: Node);
     cancelAndSet(runner: () => void, interval: number, targetWindow?: Window & typeof globalThis): void;
 }
 export declare function measure(targetWindow: Window, callback: () => void): IDisposable;
 export declare function modify(targetWindow: Window, callback: () => void): IDisposable;
+/**
+ * Add a throttled listener. `handler` is fired at most every 8.33333ms or with the next animation frame (if browser supports it).
+ */
 export interface IEventMerger<R, E> {
     (lastEvent: R | null, currentEvent: E): R;
 }
@@ -82,8 +124,21 @@ export interface IDomNodePagePosition {
 }
 export declare function size(element: HTMLElement, width: number | null, height: number | null): void;
 export declare function position(element: HTMLElement, top: number, right?: number, bottom?: number, left?: number, position?: string): void;
+/**
+ * Returns the position of a dom node relative to the entire page.
+ */
 export declare function getDomNodePagePosition(domNode: HTMLElement): IDomNodePagePosition;
+/**
+ * Returns whether the element is in the bottom right quarter of the container.
+ *
+ * @param element the element to check for being in the bottom right quarter
+ * @param container the container to check against
+ * @returns true if the element is in the bottom right quarter of the container
+ */
 export declare function isElementInBottomRightQuarter(element: HTMLElement, container: HTMLElement): boolean;
+/**
+ * Returns the effective zoom on a given element before window zoom level is applied
+ */
 export declare function getDomNodeZoomLevel(domNode: HTMLElement): number;
 export declare function getTotalWidth(element: HTMLElement): number;
 export declare function getContentWidth(element: HTMLElement): number;
@@ -92,19 +147,55 @@ export declare function getContentHeight(element: HTMLElement): number;
 export declare function getTotalHeight(element: HTMLElement): number;
 export declare function getLargestChildWidth(parent: HTMLElement, children: HTMLElement[]): number;
 export declare function isAncestor(testChild: Node | null, testAncestor: Node | null): boolean;
+/**
+ * Set an explicit parent to use for nodes that are not part of the
+ * regular dom structure.
+ */
 export declare function setParentFlowTo(fromChildElement: HTMLElement, toParentElement: Element): void;
+/**
+ * Check if `testAncestor` is an ancestor of `testChild`, observing the explicit
+ * parents set by `setParentFlowTo`.
+ */
 export declare function isAncestorUsingFlowTo(testChild: Node, testAncestor: Node): boolean;
 export declare function findParentWithClass(node: HTMLElement, clazz: string, stopAtClazzOrNode?: string | HTMLElement): HTMLElement | null;
 export declare function hasParentWithClass(node: HTMLElement, clazz: string, stopAtClazzOrNode?: string | HTMLElement): boolean;
 export declare function isShadowRoot(node: Node): node is ShadowRoot;
 export declare function isInShadowDOM(domNode: Node): boolean;
 export declare function getShadowRoot(domNode: Node): ShadowRoot | null;
+/**
+ * Returns the active element across all child windows
+ * based on document focus. Falls back to the main
+ * window if no window has focus.
+ */
 export declare function getActiveElement(_document?: Document): Element | null;
 export declare function getRootContainer(element: Element): Node;
+/**
+ * Returns true if the focused window active element matches
+ * the provided element. Falls back to the main window if no
+ * window has focus.
+ */
 export declare function isActiveElement(element: Element): boolean;
+/**
+ * Returns true if the focused window active element is contained in
+ * `ancestor`. Falls back to the main window if no window has focus.
+ */
 export declare function isAncestorOfActiveElement(ancestor: Element): boolean;
+/**
+ * Returns whether the element is in the active `document`. The active
+ * document has focus or will be the main windows document.
+ */
 export declare function isActiveDocument(element: Element): boolean;
+/**
+ * Returns the active document across main and child windows.
+ * Prefers the window with focus, otherwise falls back to
+ * the main windows document.
+ */
 export declare function getActiveDocument(): Document;
+/**
+ * Returns the active window across main and child windows.
+ * Prefers the window with focus, otherwise falls back to
+ * the main window.
+ */
 export declare function getActiveWindow(): CodeWindow;
 interface IMutationObserver {
     users: number;
@@ -209,11 +300,20 @@ export interface IFocusTracker extends Disposable {
 }
 export declare function saveParentsScrollTop(node: Element): number[];
 export declare function restoreParentsScrollTop(node: Element, state: number[]): void;
+/**
+ * Creates a new `IFocusTracker` instance that tracks focus changes on the given `element` and its descendants.
+ *
+ * @param element The `HTMLElement` or `Window` to track focus changes on.
+ * @returns An `IFocusTracker` instance.
+ */
 export declare function trackFocus(element: HTMLElement | Window): IFocusTracker;
 export declare function after<T extends Node>(sibling: HTMLElement, child: T): T;
 export declare function append<T extends Node>(parent: HTMLElement, child: T): T;
 export declare function append<T extends Node>(parent: HTMLElement, ...children: (T | string)[]): void;
 export declare function prepend<T extends Node>(parent: HTMLElement, child: T): T;
+/**
+ * Removes all children from `parent` and appends `children`
+ */
 export declare function reset(parent: HTMLElement, ...children: Array<Node | string>): void;
 export declare enum Namespace {
     HTML = "http://www.w3.org/1999/xhtml",
@@ -234,9 +334,43 @@ export declare function hide(...elements: HTMLElement[]): void;
 export declare function removeTabIndexAndUpdateFocus(node: HTMLElement): void;
 export declare function finalHandler<T extends Event>(fn: (event: T) => unknown): (event: T) => unknown;
 export declare function domContentLoaded(targetWindow: Window): Promise<void>;
+/**
+ * Find a value usable for a dom node size such that the likelihood that it would be
+ * displayed with constant screen pixels size is as high as possible.
+ *
+ * e.g. We would desire for the cursors to be 2px (CSS px) wide. Under a devicePixelRatio
+ * of 1.25, the cursor will be 2.5 screen pixels wide. Depending on how the dom node aligns/"snaps"
+ * with the screen pixels, it will sometimes be rendered with 2 screen pixels, and sometimes with 3 screen pixels.
+ */
 export declare function computeScreenAwareSize(window: Window, cssPx: number): number;
+/**
+ * Open safely a new window. This is the best way to do so, but you cannot tell
+ * if the window was opened or if it was blocked by the browser's popup blocker.
+ * If you want to tell if the browser blocked the new window, use {@link windowOpenWithSuccess}.
+ *
+ * See https://github.com/microsoft/monaco-editor/issues/601
+ * To protect against malicious code in the linked site, particularly phishing attempts,
+ * the window.opener should be set to null to prevent the linked site from having access
+ * to change the location of the current page.
+ * See https://mathiasbynens.github.io/rel-noopener/
+ */
 export declare function windowOpenNoOpener(url: string): void;
 export declare function windowOpenPopup(url: string): void;
+/**
+ * Attempts to open a window and returns whether it succeeded. This technique is
+ * not appropriate in certain contexts, like for example when the JS context is
+ * executing inside a sandboxed iframe. If it is not necessary to know if the
+ * browser blocked the new window, use {@link windowOpenNoOpener}.
+ *
+ * See https://github.com/microsoft/monaco-editor/issues/601
+ * See https://github.com/microsoft/monaco-editor/issues/2474
+ * See https://mathiasbynens.github.io/rel-noopener/
+ *
+ * @param url the url to open
+ * @param noOpener whether or not to set the {@link window.opener} to null. You should leave the default
+ * (true) unless you trust the url that is being opened.
+ * @returns boolean indicating if the {@link window.open} call succeeded
+ */
 export declare function windowOpenWithSuccess(url: string, noOpener?: boolean): boolean;
 export declare function animate(targetWindow: Window, fn: () => void): IDisposable;
 export declare function triggerDownload(dataOrUri: Uint8Array | URI, name: string): void;
@@ -249,11 +383,26 @@ export declare function triggerNotification(message: string, options?: {
     sticky?: boolean;
 }): Promise<INotification | undefined>;
 export declare enum DetectedFullscreenMode {
+    /**
+     * The document is fullscreen, e.g. because an element
+     * in the document requested to be fullscreen.
+     */
     DOCUMENT = 1,
+    /**
+     * The browser is fullscreen, e.g. because the user enabled
+     * native window fullscreen for it.
+     */
     BROWSER = 2
 }
 export interface IDetectedFullscreen {
+    /**
+     * Figure out if the document is fullscreen or the browser.
+     */
     mode: DetectedFullscreenMode;
+    /**
+     * Whether we know for sure that we are in fullscreen mode or
+     * it is a guess.
+     */
     guess: boolean;
 }
 export declare function detectFullscreen(targetWindow: Window, containerElement: Element): IDetectedFullscreen | null;
@@ -275,6 +424,9 @@ export declare class ModifierKeyEmitter extends event.Emitter<IModifierKeyStatus
     private registerListeners;
     get keyStatus(): IModifierKeyStatus;
     get isModifierPressed(): boolean;
+    /**
+     * Allows to explicitly reset the key status based on more knowledge (#109062)
+     */
     resetKeyStatus(): void;
     private doResetKeyStatus;
     static getInstance(): ModifierKeyEmitter;
@@ -322,6 +474,21 @@ type TagToRecord<TTag> = TagToElementAndId<TTag> extends {
     id: infer TId;
 } ? Record<(TId extends string ? TId : never) | "root", TElement> : never;
 type Child = HTMLElement | string | Record<string, HTMLElement>;
+/**
+ * A helper function to create nested dom nodes.
+ *
+ *
+ * ```ts
+ * const elements = h('div.code-view', [
+ * 	h('div.title@title'),
+ * 	h('div.container', [
+ * 		h('div.gutter@gutterDiv'),
+ * 		h('div@editor'),
+ * 	]),
+ * ]);
+ * const editor = createEditor(elements.editor);
+ * ```
+*/
 export declare function h<TTag extends string>(tag: TTag): TagToRecord<TTag> extends infer Y ? {
     [TKey in keyof Y]: Y[TKey];
 } : never;
@@ -338,17 +505,21 @@ export declare function h<TTag extends string, T extends Child[]>(tag: TTag, att
 ]): (ArrayToObj<T> & TagToRecord<TTag>) extends infer Y ? {
     [TKey in keyof Y]: Y[TKey];
 } : never;
+/** @deprecated This is a duplication of the h function. Needs cleanup. */
 export declare function svgElem<TTag extends string>(tag: TTag): TagToRecord<TTag> extends infer Y ? {
     [TKey in keyof Y]: Y[TKey];
 } : never;
+/** @deprecated This is a duplication of the h function. Needs cleanup. */
 export declare function svgElem<TTag extends string, T extends Child[]>(tag: TTag, children: [
     ...T
 ]): (ArrayToObj<T> & TagToRecord<TTag>) extends infer Y ? {
     [TKey in keyof Y]: Y[TKey];
 } : never;
+/** @deprecated This is a duplication of the h function. Needs cleanup. */
 export declare function svgElem<TTag extends string>(tag: TTag, attributes: Partial<ElementAttributes<TagToElement<TTag>>>): TagToRecord<TTag> extends infer Y ? {
     [TKey in keyof Y]: Y[TKey];
 } : never;
+/** @deprecated This is a duplication of the h function. Needs cleanup. */
 export declare function svgElem<TTag extends string, T extends Child[]>(tag: TTag, attributes: Partial<ElementAttributes<TagToElement<TTag>>>, children: [
     ...T
 ]): (ArrayToObj<T> & TagToRecord<TTag>) extends infer Y ? {
@@ -357,6 +528,10 @@ export declare function svgElem<TTag extends string, T extends Child[]>(tag: TTa
 export declare function copyAttributes(from: Element, to: Element, filter?: string[]): void;
 export declare function trackAttributes(from: Element, to: Element, filter?: string[]): IDisposable;
 export declare function isEditableElement(element: Element): boolean;
+/**
+ * Helper for calculating the "safe triangle" occluded by hovers to avoid early dismissal.
+ * @see https://www.smashingmagazine.com/2023/08/better-context-menus-safe-triangles/ for example
+ */
 export declare class SafeTriangle {
     private readonly originX;
     private readonly originY;
@@ -426,6 +601,9 @@ export declare abstract class ObserverNode<T extends HTMLOrSVGElement = HTMLOrSV
     constructor(tag: string, ref: IRef<T> | undefined, obsRef: IRef<ObserverNodeWithElement<T> | null> | undefined, ns: string | undefined, className: ValueOrList<string | undefined | false> | undefined, attributes: ElementAttributeKeys<T>, children: ChildNode);
     readEffect(reader: IReader | undefined): void;
     keepUpdated(store: DisposableStore): ObserverNodeWithElement<T>;
+    /**
+     * Creates a live element that will keep the element updated as long as the returned object is not disposed.
+    */
     toDisposableLiveElement(): LiveElement<T>;
 }
 export declare class LiveElement<T extends HTMLOrSVGElement = HTMLElement> {

package/vscode/src/vs/base/browser/domSanitize.d.ts

@@ -1,20 +1,35 @@
 import dompurify from "./dompurify/dompurify.js";
+/**
+ * List of safe, non-input html tags.
+ */
 export declare const basicMarkupHtmlTags: readonly string[];
 export declare const defaultAllowedAttrs: readonly string[];
 type UponSanitizeElementCb = (currentNode: Element, data: dompurify.SanitizeElementHookEvent, config: dompurify.Config) => void;
 type UponSanitizeAttributeCb = (currentNode: Element, data: dompurify.SanitizeAttributeHookEvent, config: dompurify.Config) => void;
 export interface DomSanitizerConfig {
+    /**
+     * Configured the allowed html tags.
+     */
     readonly allowedTags?: {
         readonly override?: readonly string[];
         readonly augment?: readonly string[];
     };
+    /**
+     * Configured the allowed html attributes.
+     */
     readonly allowedAttributes?: {
         readonly override?: readonly string[];
         readonly augment?: readonly string[];
     };
+    /**
+     * List of allowed protocols for `href` attributes.
+     */
     readonly allowedLinkProtocols?: {
         readonly override?: readonly string[] | "*";
     };
+    /**
+     * List of allowed protocols for `src` attributes.
+     */
     readonly allowedMediaProtocols?: {
         readonly override?: readonly string[];
     };
@@ -23,6 +38,17 @@ export interface DomSanitizerConfig {
         readonly uponSanitizeAttribute?: UponSanitizeAttributeCb;
     };
 }
+/**
+ * Sanitizes an html string.
+ *
+ * @param untrusted The HTML string to sanitize.
+ * @param config Optional configuration for sanitization. If not provided, defaults to a safe configuration.
+ *
+ * @returns A sanitized string of html.
+ */
 export declare function sanitizeHtml(untrusted: string, config?: DomSanitizerConfig): TrustedHTML;
+/**
+ * Sanitizes the given `value` and reset the given `node` with it.
+ */
 export declare function safeSetInnerHtml(node: HTMLElement, untrusted: string, config?: DomSanitizerConfig): void;
 export {};

package/vscode/src/vs/base/browser/domStylesheets.d.ts

@@ -1,6 +1,9 @@
 import { DisposableStore, IDisposable } from "../common/lifecycle.js";
 import { IObservable } from "../common/observable.js";
 export declare function isGlobalStylesheet(node: Node): boolean;
+/**
+ * A version of createStyleSheet which has a unified API to initialize/set the style content.
+ */
 export declare function createStyleSheet2(): WrappedStyleElement;
 declare class WrappedStyleElement {
     private _currentCssStyle;

package/vscode/src/vs/base/browser/dompurify/dompurify.d.ts

@@ -1,3 +1,13 @@
+// Type definitions for DOM Purify 3.0
+// Project: https://github.com/cure53/DOMPurify
+// Definitions by: Dave Taylor https://github.com/davetayls
+//                 Samira Bazuzi <https://github.com/bazuzi>
+//                 FlowCrypt <https://github.com/FlowCrypt>
+//                 Exigerr <https://github.com/Exigerr>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+//                 Nicholas Ellul <https://github.com/NicholasEllul>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 4.5
 export default DOMPurify;
 declare const DOMPurify: createDOMPurifyI;
 type WindowLike = Pick<typeof globalThis, "NodeFilter" | "Node" | "Element" | "HTMLTemplateElement" | "DocumentFragment" | "HTMLFormElement" | "DOMParser" | "NamedNodeMap">;
@@ -53,14 +63,23 @@ declare namespace DOMPurify {
         FORCE_BODY?: boolean | undefined;
         IN_PLACE?: boolean | undefined;
         KEEP_CONTENT?: boolean | undefined;
+        /**
+         * change the default namespace from HTML to something different
+         */
         NAMESPACE?: string | undefined;
         PARSER_MEDIA_TYPE?: string | undefined;
         RETURN_DOM_FRAGMENT?: boolean | undefined;
+        /**
+         * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false`
+         * might cause XSS from attacks hidden in closed shadowroots in case the browser
+         * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/
+         */
         RETURN_DOM_IMPORT?: boolean | undefined;
         RETURN_DOM?: boolean | undefined;
         RETURN_TRUSTED_TYPE?: boolean | undefined;
         SAFE_FOR_TEMPLATES?: boolean | undefined;
         SANITIZE_DOM?: boolean | undefined;
+        /** @default false */
         SANITIZE_NAMED_PROPS?: boolean | undefined;
         USE_PROFILES?: false | {
             mathMl?: boolean | undefined;

package/vscode/src/vs/base/browser/fonts.d.ts

@@ -1,4 +1,12 @@
 import type { IJSONSchemaSnippet } from "../common/jsonSchema.js";
+/**
+ * The best font-family to be used in CSS based on the platform:
+ * - Windows: Segoe preferred, fallback to sans-serif
+ * - macOS: standard system font, fallback to sans-serif
+ * - Linux: standard system font preferred, fallback to Ubuntu fonts
+ *
+ * Note: this currently does not adjust for different locales.
+ */
 export declare const DEFAULT_FONT_FAMILY: string;
 export declare const getFonts: () => Promise<string[]>;
 export declare const getFontSnippets: () => Promise<IJSONSchemaSnippet[]>;

package/vscode/src/vs/base/browser/iframe.d.ts

@@ -1,8 +1,18 @@
 export declare class IframeUtils {
+    /**
+     * Returns a chain of embedded windows with the same origin (which can be accessed programmatically).
+     * Having a chain of length 1 might mean that the current execution environment is running outside of an iframe or inside an iframe embedded in a window with a different origin.
+     */
     private static getSameOriginWindowChain;
+    /**
+     * Returns the position of `childWindow` relative to `ancestorWindow`
+     */
     static getPositionOfChildWindowRelativeToAncestorWindow(childWindow: Window, ancestorWindow: Window | null): {
         top: number;
         left: number;
     };
 }
+/**
+ * Returns a sha-256 composed of `parentOrigin` and `salt` converted to base 32
+ */
 export declare function parentOriginHash(parentOrigin: string, salt: string): Promise<string>;

package/vscode/src/vs/base/browser/keyboardEvent.d.ts

@@ -11,6 +11,9 @@ export interface IKeyboardEvent {
     readonly altGraphKey: boolean;
     readonly keyCode: KeyCode;
     readonly code: string;
+    /**
+     * @internal
+     */
     toKeyCodeChord(): KeyCodeChord;
     equals(keybinding: number): boolean;
     preventDefault(): void;

package/vscode/src/vs/base/browser/markdownRenderer.d.ts

@@ -2,6 +2,9 @@ import { IMarkdownString } from "../common/htmlContent.js";
 import * as marked from "../common/marked/marked.js";
 import { URI } from "../common/uri.js";
 import { FormattedTextRenderOptions } from "./formattedTextRenderer.js";
+/**
+ * Options for the rendering of markdown with {@link renderMarkdown}.
+ */
 export interface MarkdownRenderOptions extends FormattedTextRenderOptions {
     readonly codeBlockRenderer?: (languageId: string, value: string) => Promise<HTMLElement>;
     readonly codeBlockRendererSync?: (languageId: string, value: string, raw?: string) => HTMLElement;
@@ -11,6 +14,9 @@ export interface MarkdownRenderOptions extends FormattedTextRenderOptions {
     readonly markedOptions?: MarkdownRendererMarkedOptions;
     readonly markedExtensions?: marked.MarkedExtension[];
 }
+/**
+ * Subset of options passed to `Marked` for rendering markdown.
+ */
 export interface MarkdownRendererMarkedOptions {
     readonly gfm?: boolean;
     readonly breaks?: boolean;
@@ -26,13 +32,25 @@ export interface MarkdownSanitizerConfig {
     };
     readonly remoteImageIsAllowed?: (uri: URI) => boolean;
 }
+/**
+ * Low-level way create a html element from a markdown string.
+ *
+ * **Note** that for most cases you should be using {@link import('../../editor/browser/widget/markdownRenderer/browser/markdownRenderer.js').MarkdownRenderer MarkdownRenderer}
+ * which comes with support for pretty code block rendering and which uses the default way of handling links.
+ */
 export declare function renderMarkdown(markdown: IMarkdownString, options?: MarkdownRenderOptions, target?: HTMLElement): {
     element: HTMLElement;
     dispose: () => void;
 };
 export declare const allowedMarkdownHtmlTags: readonly string[];
 export declare const allowedMarkdownHtmlAttributes: string[];
+/**
+ * Renders `str` as plaintext, stripping out Markdown syntax if it's a {@link IMarkdownString}.
+ *
+ * For example `# Header` would be output as `Header`.
+ */
 export declare function renderAsPlaintext(str: IMarkdownString | string, options?: {
+    /** Controls if the ``` of code blocks should be preserved in the output or not */
     readonly includeCodeBlocksFences?: boolean;
 }): string;
 export declare function fillInIncompleteTokens(tokens: marked.TokensList): marked.TokensList;