@ng-util/monaco-editor 15.0.0 → 16.0.0

package/monaco.d.ts

@@ -308,116 +308,121 @@ declare namespace monaco {
         F17 = 75,
         F18 = 76,
         F19 = 77,
-        NumLock = 78,
-        ScrollLock = 79,
+        F20 = 78,
+        F21 = 79,
+        F22 = 80,
+        F23 = 81,
+        F24 = 82,
+        NumLock = 83,
+        ScrollLock = 84,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ';:' key
          */
-        Semicolon = 80,
+        Semicolon = 85,
         /**
          * For any country/region, the '+' key
          * For the US standard keyboard, the '=+' key
          */
-        Equal = 81,
+        Equal = 86,
         /**
          * For any country/region, the ',' key
          * For the US standard keyboard, the ',<' key
          */
-        Comma = 82,
+        Comma = 87,
         /**
          * For any country/region, the '-' key
          * For the US standard keyboard, the '-_' key
          */
-        Minus = 83,
+        Minus = 88,
         /**
          * For any country/region, the '.' key
          * For the US standard keyboard, the '.>' key
          */
-        Period = 84,
+        Period = 89,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '/?' key
          */
-        Slash = 85,
+        Slash = 90,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '`~' key
          */
-        Backquote = 86,
+        Backquote = 91,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '[{' key
          */
-        BracketLeft = 87,
+        BracketLeft = 92,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the '\|' key
          */
-        Backslash = 88,
+        Backslash = 93,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ']}' key
          */
-        BracketRight = 89,
+        BracketRight = 94,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          * For the US standard keyboard, the ''"' key
          */
-        Quote = 90,
+        Quote = 95,
         /**
          * Used for miscellaneous characters; it can vary by keyboard.
          */
-        OEM_8 = 91,
+        OEM_8 = 96,
         /**
          * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
          */
-        IntlBackslash = 92,
-        Numpad0 = 93,
-        Numpad1 = 94,
-        Numpad2 = 95,
-        Numpad3 = 96,
-        Numpad4 = 97,
-        Numpad5 = 98,
-        Numpad6 = 99,
-        Numpad7 = 100,
-        Numpad8 = 101,
-        Numpad9 = 102,
-        NumpadMultiply = 103,
-        NumpadAdd = 104,
-        NUMPAD_SEPARATOR = 105,
-        NumpadSubtract = 106,
-        NumpadDecimal = 107,
-        NumpadDivide = 108,
+        IntlBackslash = 97,
+        Numpad0 = 98,
+        Numpad1 = 99,
+        Numpad2 = 100,
+        Numpad3 = 101,
+        Numpad4 = 102,
+        Numpad5 = 103,
+        Numpad6 = 104,
+        Numpad7 = 105,
+        Numpad8 = 106,
+        Numpad9 = 107,
+        NumpadMultiply = 108,
+        NumpadAdd = 109,
+        NUMPAD_SEPARATOR = 110,
+        NumpadSubtract = 111,
+        NumpadDecimal = 112,
+        NumpadDivide = 113,
         /**
          * Cover all key codes when IME is processing input.
          */
-        KEY_IN_COMPOSITION = 109,
-        ABNT_C1 = 110,
-        ABNT_C2 = 111,
-        AudioVolumeMute = 112,
-        AudioVolumeUp = 113,
-        AudioVolumeDown = 114,
-        BrowserSearch = 115,
-        BrowserHome = 116,
-        BrowserBack = 117,
-        BrowserForward = 118,
-        MediaTrackNext = 119,
-        MediaTrackPrevious = 120,
-        MediaStop = 121,
-        MediaPlayPause = 122,
-        LaunchMediaPlayer = 123,
-        LaunchMail = 124,
-        LaunchApp2 = 125,
+        KEY_IN_COMPOSITION = 114,
+        ABNT_C1 = 115,
+        ABNT_C2 = 116,
+        AudioVolumeMute = 117,
+        AudioVolumeUp = 118,
+        AudioVolumeDown = 119,
+        BrowserSearch = 120,
+        BrowserHome = 121,
+        BrowserBack = 122,
+        BrowserForward = 123,
+        MediaTrackNext = 124,
+        MediaTrackPrevious = 125,
+        MediaStop = 126,
+        MediaPlayPause = 127,
+        LaunchMediaPlayer = 128,
+        LaunchMail = 129,
+        LaunchApp2 = 130,
         /**
          * VK_CLEAR, 0x0C, CLEAR key
          */
-        Clear = 126,
+        Clear = 131,
         /**
          * Placed last to cover the length of the enum.
          * Please do not depend on this value!
          */
-        MAX_VALUE = 127
+        MAX_VALUE = 132
     }
     export class KeyMod {
         static readonly CtrlCmd: number;
@@ -429,7 +434,7 @@ declare namespace monaco {
 
     export interface IMarkdownString {
         readonly value: string;
-        readonly isTrusted?: boolean;
+        readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
         readonly supportThemeIcons?: boolean;
         readonly supportHtml?: boolean;
         readonly baseUri?: UriComponents;
@@ -438,6 +443,10 @@ declare namespace monaco {
         };
     }
 
+    export interface MarkdownStringTrustedOptions {
+        readonly enabledCommands: readonly string[];
+    }
+
     export interface IKeyboardEvent {
         readonly _standardKeyboardEventBrand: true;
         readonly browserEvent: KeyboardEvent;
@@ -446,6 +455,7 @@ declare namespace monaco {
         readonly shiftKey: boolean;
         readonly altKey: boolean;
         readonly metaKey: boolean;
+        readonly altGraphKey: boolean;
         readonly keyCode: KeyCode;
         readonly code: string;
         equals(keybinding: number): boolean;
@@ -668,11 +678,11 @@ declare namespace monaco {
         /**
          * Test if this range equals other.
          */
-        equalsRange(other: IRange | null): boolean;
+        equalsRange(other: IRange | null | undefined): boolean;
         /**
          * Test if range `a` equals `b`.
          */
-        static equalsRange(a: IRange | null, b: IRange | null): boolean;
+        static equalsRange(a: IRange | null | undefined, b: IRange | null | undefined): boolean;
         /**
          * Return the end position (which will be after or equal to the start position)
          */
@@ -709,6 +719,18 @@ declare namespace monaco {
          * Create a new empty range using this range's start position.
          */
         static collapseToStart(range: IRange): Range;
+        /**
+         * Create a new empty range using this range's end position.
+         */
+        collapseToEnd(): Range;
+        /**
+         * Create a new empty range using this range's end position.
+         */
+        static collapseToEnd(range: IRange): Range;
+        /**
+         * Moves the range by the given amount of lines.
+         */
+        delta(lineCount: number): Range;
         static fromPositions(start: IPosition, end?: IPosition): Range;
         /**
          * Create a `Range` from an `IRange`.
@@ -863,10 +885,10 @@ declare namespace monaco {
     }
 
     export class Token {
-        _tokenBrand: void;
         readonly offset: number;
         readonly type: string;
         readonly language: string;
+        _tokenBrand: void;
         constructor(offset: number, type: string, language: string);
         toString(): string;
     }
@@ -979,7 +1001,7 @@ declare namespace monaco.editor {
     /**
      * Change the language for a model.
      */
-    export function setModelLanguage(model: ITextModel, languageId: string): void;
+    export function setModelLanguage(model: ITextModel, mimeTypeOrLanguageId: string): void;
 
     /**
      * Set the markers for a model.
@@ -1085,6 +1107,43 @@ declare namespace monaco.editor {
      */
     export 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 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 function registerEditorOpener(opener: ICodeEditorOpener): IDisposable;
+
     export type BuiltinTheme = 'vs' | 'vs-dark' | 'hc-black' | 'hc-light';
 
     export interface IStandaloneThemeData {
@@ -1244,7 +1303,7 @@ declare namespace monaco.editor {
          */
         'semanticHighlighting.enabled'?: true | false | 'configuredByTheme';
         /**
-         * Keep peek editors open even when double clicking their content or when hitting `Escape`.
+         * Keep peek editors open even when double-clicking their content or when hitting `Escape`.
          * Defaults to false.
          */
         stablePeek?: boolean;
@@ -1376,6 +1435,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1395,6 +1455,7 @@ declare namespace monaco.editor {
         startColumn: number;
         endLineNumber: number;
         endColumn: number;
+        modelVersionId?: number;
         relatedInformation?: IRelatedInformation[];
         tags?: MarkerTag[];
     }
@@ -1478,6 +1539,14 @@ declare namespace monaco.editor {
         Full = 7
     }
 
+    /**
+     * Vertical Lane in the glyph margin of the editor.
+     */
+    export enum GlyphMarginLane {
+        Left = 1,
+        Right = 2
+    }
+
     /**
      * Position in the minimap to render the decoration.
      */
@@ -1499,6 +1568,13 @@ declare namespace monaco.editor {
         darkColor?: string | ThemeColor;
     }
 
+    export interface IModelDecorationGlyphMarginOptions {
+        /**
+         * The position in the glyph margin.
+         */
+        position: GlyphMarginLane;
+    }
+
     /**
      * Options for rendering a model decoration in the overview ruler.
      */
@@ -1510,11 +1586,11 @@ declare namespace monaco.editor {
     }
 
     /**
-     * Options for rendering a model decoration in the overview ruler.
+     * Options for rendering a model decoration in the minimap.
      */
     export interface IModelDecorationMinimapOptions extends IDecorationOptions {
         /**
-         * The position in the overview ruler.
+         * The position in the minimap.
          */
         position: MinimapPosition;
     }
@@ -1533,6 +1609,13 @@ declare namespace monaco.editor {
          */
         className?: string | null;
         blockClassName?: string | null;
+        /**
+         * Indicates if this block should be rendered after the last line.
+         * In this case, the range must be empty and set to the last line.
+         */
+        blockIsAfterEnd?: boolean | null;
+        blockDoesNotCollapse?: boolean | null;
+        blockPadding?: [top: number, right: number, bottom: number, left: number] | null;
         /**
          * Message to be rendered when hovering over the glyph margin decoration.
          */
@@ -1567,6 +1650,11 @@ declare namespace monaco.editor {
          * If set, the decoration will be rendered in the glyph margin with this CSS class name.
          */
         glyphMarginClassName?: string | null;
+        /**
+         * If set and the decoration has {@link glyphMarginClassName} set, render this decoration
+         * with the specified {@link IModelDecorationGlyphMarginOptions} in the glyph margin.
+         */
+        glyphMargin?: IModelDecorationGlyphMarginOptions | null;
         /**
          * If set, the decoration will be rendered in the lines decorations with this CSS class name.
          */
@@ -1759,6 +1847,7 @@ declare namespace monaco.editor {
         readonly defaultEOL: DefaultEndOfLine;
         readonly trimAutoWhitespace: boolean;
         readonly bracketPairColorizationOptions: BracketPairColorizationOptions;
+        get originalIndentSize(): number | 'tabSize';
     }
 
     export interface BracketPairColorizationOptions {
@@ -1768,7 +1857,7 @@ declare namespace monaco.editor {
 
     export interface ITextModelUpdateOptions {
         tabSize?: number;
-        indentSize?: number;
+        indentSize?: number | 'tabSize';
         insertSpaces?: boolean;
         trimAutoWhitespace?: boolean;
         bracketColorizationOptions?: BracketPairColorizationOptions;
@@ -1861,12 +1950,12 @@ declare namespace monaco.editor {
          * @param range The range describing what text length to get.
          * @return The text length.
          */
-        getValueLengthInRange(range: IRange): number;
+        getValueLengthInRange(range: IRange, eol?: EndOfLinePreference): number;
         /**
          * Get the character count of text in a certain range.
          * @param range The range describing what text length to get.
          */
-        getCharacterCountInRange(range: IRange): number;
+        getCharacterCountInRange(range: IRange, eol?: EndOfLinePreference): number;
         /**
          * Get the number of lines in the model.
          */
@@ -2061,15 +2150,22 @@ declare namespace monaco.editor {
          * @param range The range to search in
          * @param ownerId If set, it will ignore decorations belonging to other owners.
          * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
+         * @param onlyMinimapDecorations If set, it will return only decorations that render in the minimap.
+         * @param onlyMarginDecorations If set, it will return only decorations that render in the glyph margin.
          * @return An array with the decorations
          */
-        getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+        getDecorationsInRange(range: IRange, ownerId?: number, filterOutValidation?: boolean, onlyMinimapDecorations?: boolean, onlyMarginDecorations?: boolean): IModelDecoration[];
         /**
          * Gets all the decorations as an array.
          * @param ownerId If set, it will ignore decorations belonging to other owners.
          * @param filterOutValidation If set, it will ignore decorations specific to validation (i.e. warnings, errors).
          */
         getAllDecorations(ownerId?: number, filterOutValidation?: boolean): IModelDecoration[];
+        /**
+         * Gets all decorations that render in the glyph margin as an array.
+         * @param ownerId If set, it will ignore decorations belonging to other owners.
+         */
+        getAllMarginDecorations(ownerId?: number): IModelDecoration[];
         /**
          * Gets all the decorations that should be rendered in the overview ruler as an array.
          * @param ownerId If set, it will ignore decorations belonging to other owners.
@@ -2225,6 +2321,144 @@ declare namespace monaco.editor {
     export interface ILineChange extends IChange {
         readonly charChanges: ICharChange[] | undefined;
     }
+
+    /**
+     * A document diff provider computes the diff between two text models.
+     */
+    export interface IDocumentDiffProvider {
+        /**
+         * Computes the diff between the text models `original` and `modified`.
+         */
+        computeDiff(original: ITextModel, modified: ITextModel, options: IDocumentDiffProviderOptions): Promise<IDocumentDiff>;
+        /**
+         * Is fired when settings of the diff algorithm change that could alter the result of the diffing computation.
+         * Any user of this provider should recompute the diff when this event is fired.
+         */
+        onDidChange: IEvent<void>;
+    }
+
+    /**
+     * Options for the diff computation.
+     */
+    export interface IDocumentDiffProviderOptions {
+        /**
+         * When set to true, the diff should ignore whitespace changes.i
+         */
+        ignoreTrimWhitespace: boolean;
+        /**
+         * A diff computation should throw if it takes longer than this value.
+         */
+        maxComputationTimeMs: number;
+    }
+
+    /**
+     * Represents a diff between two text models.
+     */
+    export interface IDocumentDiff {
+        /**
+         * If true, both text models are identical (byte-wise).
+         */
+        readonly identical: boolean;
+        /**
+         * If true, the diff computation timed out and the diff might not be accurate.
+         */
+        readonly quitEarly: boolean;
+        /**
+         * Maps all modified line ranges in the original to the corresponding line ranges in the modified text model.
+         */
+        readonly changes: LineRangeMapping[];
+    }
+    /**
+     * A range of lines (1-based).
+     */
+    export class LineRange {
+        /**
+         * @param lineRanges An array of sorted line ranges.
+         */
+        static joinMany(lineRanges: readonly (readonly LineRange[])[]): readonly LineRange[];
+        /**
+         * @param lineRanges1 Must be sorted.
+         * @param lineRanges2 Must be sorted.
+         */
+        static join(lineRanges1: readonly LineRange[], lineRanges2: readonly LineRange[]): readonly LineRange[];
+        /**
+         * The start line number.
+         */
+        readonly startLineNumber: number;
+        /**
+         * The end line number (exclusive).
+         */
+        readonly endLineNumberExclusive: number;
+        constructor(startLineNumber: number, endLineNumberExclusive: number);
+        /**
+         * Indicates if this line range contains the given line number.
+         */
+        contains(lineNumber: number): boolean;
+        /**
+         * Indicates if this line range is empty.
+         */
+        get isEmpty(): boolean;
+        /**
+         * Moves this line range by the given offset of line numbers.
+         */
+        delta(offset: number): LineRange;
+        /**
+         * The number of lines this line range spans.
+         */
+        get length(): number;
+        /**
+         * Creates a line range that combines this and the given line range.
+         */
+        join(other: LineRange): LineRange;
+        toString(): string;
+        /**
+         * The resulting range is empty if the ranges do not intersect, but touch.
+         * If the ranges don't even touch, the result is undefined.
+         */
+        intersect(other: LineRange): LineRange | undefined;
+        overlapOrTouch(other: LineRange): boolean;
+        equals(b: LineRange): boolean;
+    }
+
+    /**
+     * Maps a line range in the original text model to a line range in the modified text model.
+     */
+    export class LineRangeMapping {
+        /**
+         * The line range in the original text model.
+         */
+        readonly originalRange: LineRange;
+        /**
+         * The line range in the modified text model.
+         */
+        readonly modifiedRange: LineRange;
+        /**
+         * If inner changes have not been computed, this is set to undefined.
+         * Otherwise, it represents the character-level diff in this line range.
+         * The original range of each range mapping should be contained in the original line range (same for modified), exceptions are new-lines.
+         * Must not be an empty array.
+         */
+        readonly innerChanges: RangeMapping[] | undefined;
+        constructor(originalRange: LineRange, modifiedRange: LineRange, innerChanges: RangeMapping[] | undefined);
+        toString(): string;
+        get changedLineCount(): any;
+    }
+
+    /**
+     * Maps a range in the original text model to a range in the modified text model.
+     */
+    export class RangeMapping {
+        /**
+         * The original range.
+         */
+        readonly originalRange: Range;
+        /**
+         * The modified range.
+         */
+        readonly modifiedRange: Range;
+        constructor(originalRange: Range, modifiedRange: Range);
+        toString(): string;
+    }
     export interface IDimension {
         width: number;
         height: number;
@@ -2339,7 +2573,7 @@ declare namespace monaco.editor {
         readonly label: string;
         readonly alias: string;
         isSupported(): boolean;
-        run(): Promise<void>;
+        run(args?: unknown): Promise<void>;
     }
 
     export type IEditorModel = ITextModel | IDiffEditorModel;
@@ -2634,7 +2868,7 @@ declare namespace monaco.editor {
         /**
          * Replace all previous decorations with `newDecorations`.
          */
-        set(newDecorations: IModelDeltaDecoration[]): void;
+        set(newDecorations: readonly IModelDeltaDecoration[]): string[];
         /**
          * Remove all previous decorations.
          */
@@ -2679,6 +2913,10 @@ declare namespace monaco.editor {
          * New language
          */
         readonly newLanguage: string;
+        /**
+         * Source of the call that caused the event.
+         */
+        readonly source: string;
     }
 
     /**
@@ -2732,6 +2970,10 @@ declare namespace monaco.editor {
          * The model has been reset to a new value.
          */
         readonly isFlush: boolean;
+        /**
+         * Flag that indicates that this event describes an eol change.
+         */
+        readonly isEolChange: boolean;
     }
 
     /**
@@ -2740,6 +2982,7 @@ declare namespace monaco.editor {
     export interface IModelDecorationsChangedEvent {
         readonly affectsMinimap: boolean;
         readonly affectsOverviewRuler: boolean;
+        readonly affectsGlyphMargin: boolean;
     }
 
     export interface IModelOptionsChangedEvent {
@@ -2886,6 +3129,10 @@ declare namespace monaco.editor {
          * The aria label for the editor's textarea (when it is focused).
          */
         ariaLabel?: string;
+        /**
+         * Control whether a screen reader announces inline suggestion content immediately.
+         */
+        screenReaderAnnounceInlineSuggestion?: boolean;
         /**
          * The `tabindex` property of the editor's textarea
          */
@@ -2926,9 +3173,9 @@ declare namespace monaco.editor {
         cursorSurroundingLinesStyle?: 'default' | 'all';
         /**
          * Render last line number when the file ends with a newline.
-         * Defaults to true.
+         * Defaults to 'on' for Windows and macOS and 'dimmed' for Linux.
         */
-        renderFinalNewline?: boolean;
+        renderFinalNewline?: 'on' | 'off' | 'dimmed';
         /**
          * Remove unusual line terminators like LINE SEPARATOR (LS), PARAGRAPH SEPARATOR (PS).
          * Defaults to 'prompt'.
@@ -3000,9 +3247,9 @@ declare namespace monaco.editor {
          */
         scrollbar?: IEditorScrollbarOptions;
         /**
-         * Control the behavior of experimental options
+         * Control the behavior of sticky scroll options
          */
-        experimental?: IEditorExperimentalOptions;
+        stickyScroll?: IEditorStickyScrollOptions;
         /**
          * Control the behavior and rendering of the minimap.
          */
@@ -3043,9 +3290,9 @@ declare namespace monaco.editor {
         mouseStyle?: 'text' | 'default' | 'copy';
         /**
          * Enable smooth caret animation.
-         * Defaults to false.
+         * Defaults to 'off'.
          */
-        cursorSmoothCaretAnimation?: boolean;
+        cursorSmoothCaretAnimation?: 'off' | 'explicit' | 'on';
         /**
          * Control the cursor style, either 'block' or 'line'.
          * Defaults to 'line'.
@@ -3060,6 +3307,15 @@ declare namespace monaco.editor {
          * Defaults to false.
          */
         fontLigatures?: boolean | string;
+        /**
+         * Enable font variations.
+         * Defaults to false.
+         */
+        fontVariations?: boolean | string;
+        /**
+         * Controls whether to use default color decorations or not using the default document color provider
+         */
+        defaultColorDecorators?: boolean;
         /**
          * Disable the use of `transform: translate3d(0px, 0px, 0px)` for the editor margin and lines layers.
          * The usage of `transform: translate3d(0px, 0px, 0px)` acts as a hint for browsers to create an extra layer.
@@ -3092,8 +3348,7 @@ declare namespace monaco.editor {
          */
         smoothScrolling?: boolean;
         /**
-         * Enable that the editor will install an interval to check if its container dom node size has changed.
-         * Enabling this might have a severe performance impact.
+         * Enable that the editor will install a ResizeObserver to check if its container dom node size has changed.
          * Defaults to false.
          */
         automaticLayout?: boolean;
@@ -3141,6 +3396,12 @@ declare namespace monaco.editor {
          * Configure word wrapping characters. A break will be introduced after these characters.
          */
         wordWrapBreakAfterCharacters?: string;
+        /**
+         * Sets whether line breaks appear wherever the text would otherwise overflow its content box.
+         * When wordBreak = 'normal', Use the default line break rule.
+         * When wordBreak = 'keepAll', Word breaks should not be used for Chinese/Japanese/Korean (CJK) text. Non-CJK text behavior is the same as for normal.
+         */
+        wordBreak?: 'normal' | 'keepAll';
         /**
          * Performance guard: Stop rendering a line after x characters.
          * Defaults to 10000.
@@ -3160,6 +3421,10 @@ declare namespace monaco.editor {
          * Enable inline color decorators and color picker rendering.
          */
         colorDecorators?: boolean;
+        /**
+         * Controls the max number of color decorators that can be rendered in an editor at once.
+         */
+        colorDecoratorsLimit?: number;
         /**
          * Control the behaviour of comments in the editor.
          */
@@ -3204,6 +3469,10 @@ declare namespace monaco.editor {
          * Defaults to 'spread'.
          */
         multiCursorPaste?: 'spread' | 'full';
+        /**
+         * Controls the max number of text cursors that can be in an active editor at once.
+         */
+        multiCursorLimit?: number;
         /**
          * Configure the editor's accessibility support.
          * Defaults to 'auto'. It is best to leave this to 'auto'.
@@ -3408,6 +3677,11 @@ declare namespace monaco.editor {
          * Defaults to 'always'.
          */
         matchBrackets?: 'never' | 'near' | 'always';
+        /**
+         * Enable experimental whitespace rendering.
+         * Defaults to 'svg'.
+         */
+        experimentalWhitespaceRendering?: 'svg' | 'font' | 'off';
         /**
          * Enable rendering of whitespace.
          * Defaults to 'selection'.
@@ -3470,6 +3744,10 @@ declare namespace monaco.editor {
          * Controls strikethrough deprecated variables.
          */
         showDeprecated?: boolean;
+        /**
+         * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
+         */
+        matchOnWordStartOnly?: boolean;
         /**
          * Control the behavior and rendering of the inline hints.
          */
@@ -3497,6 +3775,10 @@ declare namespace monaco.editor {
          * When enabled, this shows a preview of the drop location and triggers an `onDropIntoEditor` event.
          */
         dropIntoEditor?: IDropIntoEditorOptions;
+        /**
+         * Controls whether the editor receives tabs or defers them to the workbench for navigation.
+         */
+        tabFocusMode?: boolean;
     }
 
     export interface IDiffEditorBaseOptions {
@@ -3505,6 +3787,12 @@ declare namespace monaco.editor {
          * Defaults to true.
          */
         enableSplitViewResizing?: boolean;
+        /**
+         * The default ratio when rendering side-by-side editors.
+         * Must be a number between 0 and 1, min sizes apply.
+         * Defaults to 0.5
+         */
+        splitViewDefaultRatio?: number;
         /**
          * Render the differences in two side-by-side editors.
          * Defaults to true.
@@ -3554,6 +3842,14 @@ declare namespace monaco.editor {
          * Control the wrapping of the diff editor.
          */
         diffWordWrap?: 'off' | 'on' | 'inherit';
+        /**
+         * Diff Algorithm
+        */
+        diffAlgorithm?: 'legacy' | 'advanced' | IDocumentDiffProvider;
+        /**
+         * Whether the diff editor aria label should be verbose.
+         */
+        accessibilityVerbose?: boolean;
     }
 
     /**
@@ -3686,7 +3982,7 @@ declare namespace monaco.editor {
         autoFindInSelection?: 'never' | 'always' | 'multiline';
         addExtraSpaceOnTop?: boolean;
         /**
-         * Controls whether the search automatically restarts from the beginning (or the end) when no further matches can be found
+         * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found
          */
         loop?: boolean;
     }
@@ -3784,6 +4080,10 @@ declare namespace monaco.editor {
          * The width of the glyph margin.
          */
         readonly glyphMarginWidth: number;
+        /**
+         * The number of decoration lanes to render in the glyph margin.
+         */
+        readonly glyphMarginDecorationLaneCount: number;
         /**
          * Left position for the line numbers.
          */
@@ -3861,22 +4161,19 @@ declare namespace monaco.editor {
         enabled?: boolean;
     }
 
-    export interface IEditorExperimentalOptions {
+    export interface IEditorStickyScrollOptions {
         /**
-         * Configuration options for editor sticky scroll
+         * Enable the sticky scroll
          */
-        stickyScroll?: {
-            /**
-             * Enable the sticky scroll
-             */
-            enabled?: boolean;
-        };
-    }
-
-    export interface EditorExperimentalOptions {
-        stickyScroll: {
-            enabled: boolean;
-        };
+        enabled?: boolean;
+        /**
+         * Maximum number of sticky lines to show
+         */
+        maxLineCount?: number;
+        /**
+         * Model to choose for sticky scroll by default
+         */
+        defaultModel?: 'outlineModel' | 'foldingProviderModel' | 'indentationModel';
     }
 
     /**
@@ -4159,6 +4456,12 @@ declare namespace monaco.editor {
          * Defaults to `prefix`.
         */
         mode?: 'prefix' | 'subword' | 'subwordSmart';
+        showToolbar?: 'always' | 'onHover';
+        suppressSuggestions?: boolean;
+        /**
+         * Does not clear active inline suggestions when the editor loses focus.
+         */
+        keepOnBlur?: boolean;
     }
 
     export interface IBracketPairColorizationOptions {
@@ -4224,6 +4527,10 @@ declare namespace monaco.editor {
          * Enable using global storage for remembering suggestions.
          */
         shareSuggestSelections?: boolean;
+        /**
+         * Select suggestions when triggered via quick suggest or trigger characters
+         */
+        selectionMode?: 'always' | 'never' | 'whenTriggerCharacter' | 'whenQuickSuggestion';
         /**
          * Enable or disable icons in suggestions. Defaults to true.
          */
@@ -4260,6 +4567,10 @@ declare namespace monaco.editor {
          * Show deprecated-suggestions.
          */
         showDeprecated?: boolean;
+        /**
+         * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
+         */
+        matchOnWordStartOnly?: boolean;
         /**
          * Show field-suggestions.
          */
@@ -4396,10 +4707,15 @@ declare namespace monaco.editor {
      */
     export interface IDropIntoEditorOptions {
         /**
-         * Enable the dropping into editor.
+         * Enable dropping into editor.
          * Defaults to true.
          */
         enabled?: boolean;
+        /**
+         * Controls if a widget is shown after a drop.
+         * Defaults to 'afterDrop'.
+         */
+        showDropSelector?: 'afterDrop' | 'never';
     }
 
     export enum EditorOption {
@@ -4409,135 +4725,142 @@ declare namespace monaco.editor {
         accessibilityPageSize = 3,
         ariaLabel = 4,
         autoClosingBrackets = 5,
-        autoClosingDelete = 6,
-        autoClosingOvertype = 7,
-        autoClosingQuotes = 8,
-        autoIndent = 9,
-        automaticLayout = 10,
-        autoSurround = 11,
-        bracketPairColorization = 12,
-        guides = 13,
-        codeLens = 14,
-        codeLensFontFamily = 15,
-        codeLensFontSize = 16,
-        colorDecorators = 17,
-        columnSelection = 18,
-        comments = 19,
-        contextmenu = 20,
-        copyWithSyntaxHighlighting = 21,
-        cursorBlinking = 22,
-        cursorSmoothCaretAnimation = 23,
-        cursorStyle = 24,
-        cursorSurroundingLines = 25,
-        cursorSurroundingLinesStyle = 26,
-        cursorWidth = 27,
-        disableLayerHinting = 28,
-        disableMonospaceOptimizations = 29,
-        domReadOnly = 30,
-        dragAndDrop = 31,
-        dropIntoEditor = 32,
-        emptySelectionClipboard = 33,
-        experimental = 34,
-        extraEditorClassName = 35,
-        fastScrollSensitivity = 36,
-        find = 37,
-        fixedOverflowWidgets = 38,
-        folding = 39,
-        foldingStrategy = 40,
-        foldingHighlight = 41,
-        foldingImportsByDefault = 42,
-        foldingMaximumRegions = 43,
-        unfoldOnClickAfterEndOfLine = 44,
-        fontFamily = 45,
-        fontInfo = 46,
-        fontLigatures = 47,
-        fontSize = 48,
-        fontWeight = 49,
-        formatOnPaste = 50,
-        formatOnType = 51,
-        glyphMargin = 52,
-        gotoLocation = 53,
-        hideCursorInOverviewRuler = 54,
-        hover = 55,
-        inDiffEditor = 56,
-        inlineSuggest = 57,
-        letterSpacing = 58,
-        lightbulb = 59,
-        lineDecorationsWidth = 60,
-        lineHeight = 61,
-        lineNumbers = 62,
-        lineNumbersMinChars = 63,
-        linkedEditing = 64,
-        links = 65,
-        matchBrackets = 66,
-        minimap = 67,
-        mouseStyle = 68,
-        mouseWheelScrollSensitivity = 69,
-        mouseWheelZoom = 70,
-        multiCursorMergeOverlapping = 71,
-        multiCursorModifier = 72,
-        multiCursorPaste = 73,
-        occurrencesHighlight = 74,
-        overviewRulerBorder = 75,
-        overviewRulerLanes = 76,
-        padding = 77,
-        parameterHints = 78,
-        peekWidgetDefaultFocus = 79,
-        definitionLinkOpensInPeek = 80,
-        quickSuggestions = 81,
-        quickSuggestionsDelay = 82,
-        readOnly = 83,
-        renameOnType = 84,
-        renderControlCharacters = 85,
-        renderFinalNewline = 86,
-        renderLineHighlight = 87,
-        renderLineHighlightOnlyWhenFocus = 88,
-        renderValidationDecorations = 89,
-        renderWhitespace = 90,
-        revealHorizontalRightPadding = 91,
-        roundedSelection = 92,
-        rulers = 93,
-        scrollbar = 94,
-        scrollBeyondLastColumn = 95,
-        scrollBeyondLastLine = 96,
-        scrollPredominantAxis = 97,
-        selectionClipboard = 98,
-        selectionHighlight = 99,
-        selectOnLineNumbers = 100,
-        showFoldingControls = 101,
-        showUnused = 102,
-        snippetSuggestions = 103,
-        smartSelect = 104,
-        smoothScrolling = 105,
-        stickyTabStops = 106,
-        stopRenderingLineAfter = 107,
-        suggest = 108,
-        suggestFontSize = 109,
-        suggestLineHeight = 110,
-        suggestOnTriggerCharacters = 111,
-        suggestSelection = 112,
-        tabCompletion = 113,
-        tabIndex = 114,
-        unicodeHighlighting = 115,
-        unusualLineTerminators = 116,
-        useShadowDOM = 117,
-        useTabStops = 118,
-        wordSeparators = 119,
-        wordWrap = 120,
-        wordWrapBreakAfterCharacters = 121,
-        wordWrapBreakBeforeCharacters = 122,
-        wordWrapColumn = 123,
-        wordWrapOverride1 = 124,
-        wordWrapOverride2 = 125,
-        wrappingIndent = 126,
-        wrappingStrategy = 127,
-        showDeprecated = 128,
-        inlayHints = 129,
-        editorClassName = 130,
-        pixelRatio = 131,
-        tabFocusMode = 132,
-        layoutInfo = 133,
-        wrappingInfo = 134
+        screenReaderAnnounceInlineSuggestion = 6,
+        autoClosingDelete = 7,
+        autoClosingOvertype = 8,
+        autoClosingQuotes = 9,
+        autoIndent = 10,
+        automaticLayout = 11,
+        autoSurround = 12,
+        bracketPairColorization = 13,
+        guides = 14,
+        codeLens = 15,
+        codeLensFontFamily = 16,
+        codeLensFontSize = 17,
+        colorDecorators = 18,
+        colorDecoratorsLimit = 19,
+        columnSelection = 20,
+        comments = 21,
+        contextmenu = 22,
+        copyWithSyntaxHighlighting = 23,
+        cursorBlinking = 24,
+        cursorSmoothCaretAnimation = 25,
+        cursorStyle = 26,
+        cursorSurroundingLines = 27,
+        cursorSurroundingLinesStyle = 28,
+        cursorWidth = 29,
+        disableLayerHinting = 30,
+        disableMonospaceOptimizations = 31,
+        domReadOnly = 32,
+        dragAndDrop = 33,
+        dropIntoEditor = 34,
+        emptySelectionClipboard = 35,
+        experimentalWhitespaceRendering = 36,
+        extraEditorClassName = 37,
+        fastScrollSensitivity = 38,
+        find = 39,
+        fixedOverflowWidgets = 40,
+        folding = 41,
+        foldingStrategy = 42,
+        foldingHighlight = 43,
+        foldingImportsByDefault = 44,
+        foldingMaximumRegions = 45,
+        unfoldOnClickAfterEndOfLine = 46,
+        fontFamily = 47,
+        fontInfo = 48,
+        fontLigatures = 49,
+        fontSize = 50,
+        fontWeight = 51,
+        fontVariations = 52,
+        formatOnPaste = 53,
+        formatOnType = 54,
+        glyphMargin = 55,
+        gotoLocation = 56,
+        hideCursorInOverviewRuler = 57,
+        hover = 58,
+        inDiffEditor = 59,
+        inlineSuggest = 60,
+        letterSpacing = 61,
+        lightbulb = 62,
+        lineDecorationsWidth = 63,
+        lineHeight = 64,
+        lineNumbers = 65,
+        lineNumbersMinChars = 66,
+        linkedEditing = 67,
+        links = 68,
+        matchBrackets = 69,
+        minimap = 70,
+        mouseStyle = 71,
+        mouseWheelScrollSensitivity = 72,
+        mouseWheelZoom = 73,
+        multiCursorMergeOverlapping = 74,
+        multiCursorModifier = 75,
+        multiCursorPaste = 76,
+        multiCursorLimit = 77,
+        occurrencesHighlight = 78,
+        overviewRulerBorder = 79,
+        overviewRulerLanes = 80,
+        padding = 81,
+        parameterHints = 82,
+        peekWidgetDefaultFocus = 83,
+        definitionLinkOpensInPeek = 84,
+        quickSuggestions = 85,
+        quickSuggestionsDelay = 86,
+        readOnly = 87,
+        renameOnType = 88,
+        renderControlCharacters = 89,
+        renderFinalNewline = 90,
+        renderLineHighlight = 91,
+        renderLineHighlightOnlyWhenFocus = 92,
+        renderValidationDecorations = 93,
+        renderWhitespace = 94,
+        revealHorizontalRightPadding = 95,
+        roundedSelection = 96,
+        rulers = 97,
+        scrollbar = 98,
+        scrollBeyondLastColumn = 99,
+        scrollBeyondLastLine = 100,
+        scrollPredominantAxis = 101,
+        selectionClipboard = 102,
+        selectionHighlight = 103,
+        selectOnLineNumbers = 104,
+        showFoldingControls = 105,
+        showUnused = 106,
+        snippetSuggestions = 107,
+        smartSelect = 108,
+        smoothScrolling = 109,
+        stickyScroll = 110,
+        stickyTabStops = 111,
+        stopRenderingLineAfter = 112,
+        suggest = 113,
+        suggestFontSize = 114,
+        suggestLineHeight = 115,
+        suggestOnTriggerCharacters = 116,
+        suggestSelection = 117,
+        tabCompletion = 118,
+        tabIndex = 119,
+        unicodeHighlighting = 120,
+        unusualLineTerminators = 121,
+        useShadowDOM = 122,
+        useTabStops = 123,
+        wordBreak = 124,
+        wordSeparators = 125,
+        wordWrap = 126,
+        wordWrapBreakAfterCharacters = 127,
+        wordWrapBreakBeforeCharacters = 128,
+        wordWrapColumn = 129,
+        wordWrapOverride1 = 130,
+        wordWrapOverride2 = 131,
+        wrappingIndent = 132,
+        wrappingStrategy = 133,
+        showDeprecated = 134,
+        inlayHints = 135,
+        editorClassName = 136,
+        pixelRatio = 137,
+        tabFocusMode = 138,
+        layoutInfo = 139,
+        wrappingInfo = 140,
+        defaultColorDecorators = 141
     }
 
     export const EditorOptions: {
@@ -4546,6 +4869,7 @@ declare namespace monaco.editor {
         accessibilitySupport: IEditorOption<EditorOption.accessibilitySupport, AccessibilitySupport>;
         accessibilityPageSize: IEditorOption<EditorOption.accessibilityPageSize, number>;
         ariaLabel: IEditorOption<EditorOption.ariaLabel, string>;
+        screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
         autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, 'always' | 'languageDefined' | 'beforeWhitespace' | 'never'>;
         autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, 'always' | 'never' | 'auto'>;
         autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, 'always' | 'never' | 'auto'>;
@@ -4560,12 +4884,13 @@ declare namespace monaco.editor {
         codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
         codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
         colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
+        colorDecoratorsLimit: IEditorOption<EditorOption.colorDecoratorsLimit, number>;
         columnSelection: IEditorOption<EditorOption.columnSelection, boolean>;
         comments: IEditorOption<EditorOption.comments, Readonly<Required<IEditorCommentsOptions>>>;
         contextmenu: IEditorOption<EditorOption.contextmenu, boolean>;
         copyWithSyntaxHighlighting: IEditorOption<EditorOption.copyWithSyntaxHighlighting, boolean>;
         cursorBlinking: IEditorOption<EditorOption.cursorBlinking, TextEditorCursorBlinkingStyle>;
-        cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, boolean>;
+        cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, 'on' | 'off' | 'explicit'>;
         cursorStyle: IEditorOption<EditorOption.cursorStyle, TextEditorCursorStyle>;
         cursorSurroundingLines: IEditorOption<EditorOption.cursorSurroundingLines, number>;
         cursorSurroundingLinesStyle: IEditorOption<EditorOption.cursorSurroundingLinesStyle, 'default' | 'all'>;
@@ -4576,7 +4901,8 @@ declare namespace monaco.editor {
         dragAndDrop: IEditorOption<EditorOption.dragAndDrop, boolean>;
         emptySelectionClipboard: IEditorOption<EditorOption.emptySelectionClipboard, boolean>;
         dropIntoEditor: IEditorOption<EditorOption.dropIntoEditor, Readonly<Required<IDropIntoEditorOptions>>>;
-        experimental: IEditorOption<EditorOption.experimental, EditorExperimentalOptions>;
+        stickyScroll: IEditorOption<EditorOption.stickyScroll, Readonly<Required<IEditorStickyScrollOptions>>>;
+        experimentalWhitespaceRendering: IEditorOption<EditorOption.experimentalWhitespaceRendering, 'off' | 'svg' | 'font'>;
         extraEditorClassName: IEditorOption<EditorOption.extraEditorClassName, string>;
         fastScrollSensitivity: IEditorOption<EditorOption.fastScrollSensitivity, number>;
         find: IEditorOption<EditorOption.find, Readonly<Required<IEditorFindOptions>>>;
@@ -4592,6 +4918,7 @@ declare namespace monaco.editor {
         fontLigatures2: IEditorOption<EditorOption.fontLigatures, string>;
         fontSize: IEditorOption<EditorOption.fontSize, number>;
         fontWeight: IEditorOption<EditorOption.fontWeight, string>;
+        fontVariations: IEditorOption<EditorOption.fontVariations, string>;
         formatOnPaste: IEditorOption<EditorOption.formatOnPaste, boolean>;
         formatOnType: IEditorOption<EditorOption.formatOnType, boolean>;
         glyphMargin: IEditorOption<EditorOption.glyphMargin, boolean>;
@@ -4601,7 +4928,7 @@ declare namespace monaco.editor {
         inDiffEditor: IEditorOption<EditorOption.inDiffEditor, boolean>;
         letterSpacing: IEditorOption<EditorOption.letterSpacing, number>;
         lightbulb: IEditorOption<EditorOption.lightbulb, Readonly<Required<IEditorLightbulbOptions>>>;
-        lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, string | number>;
+        lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, number>;
         lineHeight: IEditorOption<EditorOption.lineHeight, number>;
         lineNumbers: IEditorOption<EditorOption.lineNumbers, InternalEditorRenderLineNumbersOptions>;
         lineNumbersMinChars: IEditorOption<EditorOption.lineNumbersMinChars, number>;
@@ -4615,6 +4942,7 @@ declare namespace monaco.editor {
         multiCursorMergeOverlapping: IEditorOption<EditorOption.multiCursorMergeOverlapping, boolean>;
         multiCursorModifier: IEditorOption<EditorOption.multiCursorModifier, 'altKey' | 'metaKey' | 'ctrlKey'>;
         multiCursorPaste: IEditorOption<EditorOption.multiCursorPaste, 'spread' | 'full'>;
+        multiCursorLimit: IEditorOption<EditorOption.multiCursorLimit, number>;
         occurrencesHighlight: IEditorOption<EditorOption.occurrencesHighlight, boolean>;
         overviewRulerBorder: IEditorOption<EditorOption.overviewRulerBorder, boolean>;
         overviewRulerLanes: IEditorOption<EditorOption.overviewRulerLanes, number>;
@@ -4627,7 +4955,7 @@ declare namespace monaco.editor {
         readOnly: IEditorOption<EditorOption.readOnly, boolean>;
         renameOnType: IEditorOption<EditorOption.renameOnType, boolean>;
         renderControlCharacters: IEditorOption<EditorOption.renderControlCharacters, boolean>;
-        renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, boolean>;
+        renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, 'on' | 'off' | 'dimmed'>;
         renderLineHighlight: IEditorOption<EditorOption.renderLineHighlight, 'all' | 'line' | 'none' | 'gutter'>;
         renderLineHighlightOnlyWhenFocus: IEditorOption<EditorOption.renderLineHighlightOnlyWhenFocus, boolean>;
         renderValidationDecorations: IEditorOption<EditorOption.renderValidationDecorations, 'on' | 'off' | 'editable'>;
@@ -4662,6 +4990,7 @@ declare namespace monaco.editor {
         unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, 'auto' | 'off' | 'prompt'>;
         useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
         useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
+        wordBreak: IEditorOption<EditorOption.wordBreak, 'normal' | 'keepAll'>;
         wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
         wordWrap: IEditorOption<EditorOption.wordWrap, 'on' | 'off' | 'wordWrapColumn' | 'bounded'>;
         wordWrapBreakAfterCharacters: IEditorOption<EditorOption.wordWrapBreakAfterCharacters, string>;
@@ -4669,13 +4998,14 @@ declare namespace monaco.editor {
         wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
         wordWrapOverride1: IEditorOption<EditorOption.wordWrapOverride1, 'on' | 'off' | 'inherit'>;
         wordWrapOverride2: IEditorOption<EditorOption.wordWrapOverride2, 'on' | 'off' | 'inherit'>;
-        wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
-        wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, 'simple' | 'advanced'>;
         editorClassName: IEditorOption<EditorOption.editorClassName, string>;
+        defaultColorDecorators: IEditorOption<EditorOption.defaultColorDecorators, boolean>;
         pixelRatio: IEditorOption<EditorOption.pixelRatio, number>;
         tabFocusMode: IEditorOption<EditorOption.tabFocusMode, boolean>;
         layoutInfo: IEditorOption<EditorOption.layoutInfo, EditorLayoutInfo>;
         wrappingInfo: IEditorOption<EditorOption.wrappingInfo, EditorWrappingInfo>;
+        wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
+        wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, 'simple' | 'advanced'>;
     };
 
     type EditorOptionsType = typeof EditorOptions;
@@ -4720,6 +5050,15 @@ declare namespace monaco.editor {
          * If the `afterColumn` has multiple view columns, the affinity specifies which one to use. Defaults to `none`.
         */
         afterColumnAffinity?: PositionAffinity;
+        /**
+         * Render the zone even when its line is hidden.
+         */
+        showInHiddenAreas?: boolean;
+        /**
+         * Tiebreaker that is used when multiple view zones want to be after the same line.
+         * Defaults to `afterColumn` otherwise 10000;
+         */
+        ordinal?: number;
         /**
          * Suppress mouse down events.
          * If set, the editor will attach a mouse down listener to the view zone and .preventDefault on it.
@@ -4806,15 +5145,24 @@ declare namespace monaco.editor {
      */
     export interface IContentWidgetPosition {
         /**
-         * Desired position for the content widget.
-         * `preference` will also affect the placement.
+         * Desired position which serves as an anchor for placing the content widget.
+         * The widget will be placed above, at, or below the specified position, based on the
+         * provided preference. The widget will always touch this position.
+         *
+         * Given sufficient horizontal space, the widget will be placed to the right of the
+         * passed in position. This can be tweaked by providing a `secondaryPosition`.
+         *
+         * @see preference
+         * @see secondaryPosition
          */
         position: IPosition | null;
         /**
-         * Optionally, a range can be provided to further
-         * define the position of the content widget.
+         * Optionally, a secondary position can be provided to further define the placing of
+         * the content widget. The secondary position must have the same line number as the
+         * primary position. If possible, the widget will be placed such that it also touches
+         * the secondary position.
          */
-        range?: IRange | null;
+        secondaryPosition?: IPosition | null;
         /**
          * Placement preference for position, in order of preference.
          */
@@ -5082,6 +5430,8 @@ declare namespace monaco.editor {
 
     export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
         readonly type: MouseTargetType.OUTSIDE_EDITOR;
+        readonly outsidePosition: 'above' | 'below' | 'left' | 'right';
+        readonly outsideDistance: number;
     }
 
     /**
@@ -5371,12 +5721,16 @@ declare namespace monaco.editor {
          * Change the scroll position of the editor's viewport.
          */
         setScrollPosition(position: INewScrollPosition, scrollType?: ScrollType): void;
+        /**
+         * Check if the editor is currently scrolling towards a different scroll position.
+         */
+        hasPendingScrollAnimation(): boolean;
         /**
          * Get an action that is a contribution to this editor.
          * @id Unique identifier of the contribution.
          * @return The action or null if action not found.
          */
-        getAction(id: string): IEditorAction;
+        getAction(id: string): IEditorAction | null;
         /**
          * Execute a command on the editor.
          * The edits will land on the undo-redo stack, but no "undo stop" will be pushed.
@@ -5416,7 +5770,8 @@ declare namespace monaco.editor {
         getDecorationsInRange(range: Range): IModelDecoration[] | null;
         /**
          * All decorations added through this call will get the ownerId of this editor.
-         * @deprecated
+         * @deprecated Use `createDecorationsCollection`
+         * @see createDecorationsCollection
          */
         deltaDecorations(oldDecorations: string[], newDecorations: IModelDeltaDecoration[]): string[];
         /**
@@ -5444,6 +5799,10 @@ declare namespace monaco.editor {
          * Get the vertical position (top offset) for the position w.r.t. to the first line.
          */
         getTopForPosition(lineNumber: number, column: number): number;
+        /**
+         * Write the screen reader content to be the current selection
+         */
+        writeScreenReaderContent(reason: string): void;
         /**
          * Returns the editor's container dom node
          */
@@ -5538,6 +5897,11 @@ declare namespace monaco.editor {
          * @event
          */
         readonly onDidUpdateDiff: IEvent<void>;
+        /**
+         * An event emitted when the diff model is changed (i.e. the diff editor shows new content).
+         * @event
+         */
+        readonly onDidChangeModel: IEvent<void>;
         /**
          * Saves current view state of the editor in a serializable object.
          */
@@ -5608,10 +5972,19 @@ declare namespace monaco.editor {
         readonly fontWeight: string;
         readonly fontSize: number;
         readonly fontFeatureSettings: string;
+        readonly fontVariationSettings: string;
         readonly lineHeight: number;
         readonly letterSpacing: number;
     }
 
+    export const EditorZoom: IEditorZoom;
+
+    export interface IEditorZoom {
+        onDidChangeZoomLevel: IEvent<number>;
+        getZoomLevel(): number;
+        setZoomLevel(zoomLevel: number): void;
+    }
+
     //compatibility:
     export type IReadOnlyModel = ITextModel;
     export type IModel = ITextModel;
@@ -5646,6 +6019,10 @@ declare namespace monaco.languages {
          */
         readonly hasAccessToAllModels?: boolean;
         readonly exclusive?: boolean;
+        /**
+         * This provider comes from a builtin extension.
+         */
+        readonly isBuiltin?: boolean;
     }
 
     /**
@@ -5661,11 +6038,18 @@ declare namespace monaco.languages {
     export function getEncodedLanguageId(languageId: string): number;
 
     /**
-     * An event emitted when a language is needed for the first time (e.g. a model has it set).
+     * An event emitted when a language is associated for the first time with a text model.
      * @event
      */
     export function onLanguage(languageId: string, callback: () => void): IDisposable;
 
+    /**
+     * An event emitted when a language is associated for the first time with a text model or
+     * whena language is encountered during the tokenization of another language.
+     * @event
+     */
+    export function onLanguageEncountered(languageId: string, callback: () => void): IDisposable;
+
     /**
      * Set the editing configuration for a language.
      */
@@ -6293,6 +6677,7 @@ declare namespace monaco.languages {
     }
 
     export enum CompletionItemInsertTextRule {
+        None = 0,
         /**
          * Adjust whitespace/indentation of multiline insert texts to
          * match the current line indentation.
@@ -6477,11 +6862,13 @@ declare namespace monaco.languages {
         readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
     }
 
-    export interface SelectedSuggestionInfo {
-        range: IRange;
-        text: string;
-        isSnippetText: boolean;
-        completionKind: CompletionItemKind;
+    export class SelectedSuggestionInfo {
+        readonly range: IRange;
+        readonly text: string;
+        readonly completionKind: CompletionItemKind;
+        readonly isSnippetText: boolean;
+        constructor(range: IRange, text: string, completionKind: CompletionItemKind, isSnippetText: boolean);
+        equals(other: SelectedSuggestionInfo): boolean;
     }
 
     export interface InlineCompletion {
@@ -6526,14 +6913,24 @@ declare namespace monaco.languages {
          * A list of commands associated with the inline completions of this list.
          */
         readonly commands?: Command[];
+        readonly suppressSuggestions?: boolean | undefined;
+        /**
+         * When set and the user types a suggestion without derivating from it, the inline suggestion is not updated.
+         */
+        readonly enableForwardStability?: boolean | undefined;
     }
 
     export interface InlineCompletionsProvider<T extends InlineCompletions = InlineCompletions> {
         provideInlineCompletions(model: editor.ITextModel, position: Position, context: InlineCompletionContext, token: CancellationToken): ProviderResult<T>;
         /**
          * Will be called when an item is shown.
+         * @param updatedInsertText Is useful to understand bracket completion.
         */
-        handleItemDidShow?(completions: T, item: T['items'][number]): void;
+        handleItemDidShow?(completions: T, item: T['items'][number], updatedInsertText: string): void;
+        /**
+         * Will be called when an item is partially accepted.
+         */
+        handlePartialAccept?(completions: T, item: T['items'][number], acceptedCharacters: number): void;
         /**
          * Will be called when a completions list is no longer in use and can be garbage-collected.
         */
@@ -6909,6 +7306,10 @@ declare namespace monaco.languages {
          * Prefer spaces over tabs.
          */
         insertSpaces: boolean;
+        /**
+         * The list of multiple ranges to format at once, if the provider supports it.
+         */
+        ranges?: Range[];
     }
 
     /**
@@ -6937,6 +7338,7 @@ declare namespace monaco.languages {
          * of the range to full syntax nodes.
          */
         provideDocumentRangeFormattingEdits(model: editor.ITextModel, range: Range, options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
+        provideDocumentRangesFormattingEdits?(model: editor.ITextModel, ranges: Range[], options: FormattingOptions, token: CancellationToken): ProviderResult<TextEdit[]>;
     }
 
     /**
@@ -7110,6 +7512,12 @@ declare namespace monaco.languages {
          * The value of the kind is 'region'.
          */
         static readonly Region: FoldingRangeKind;
+        /**
+         * Returns a {@link FoldingRangeKind} for the given value.
+         *
+         * @param value of the kind.
+         */
+        static fromValue(value: string): FoldingRangeKind;
         /**
          * Creates a new {@link FoldingRangeKind}.
          *
@@ -7387,7 +7795,7 @@ declare namespace monaco.languages {
         log?: string;
     }
 
-    export type IMonarchLanguageAction = IShortMonarchLanguageAction | IExpandedMonarchLanguageAction | IShortMonarchLanguageAction[] | IExpandedMonarchLanguageAction[];
+    export type IMonarchLanguageAction = IShortMonarchLanguageAction | IExpandedMonarchLanguageAction | (IShortMonarchLanguageAction | IExpandedMonarchLanguageAction)[];
 
     /**
      * This interface can be shortened as an array, ie. ['{','}','delimiter.curly']
@@ -8113,6 +8521,60 @@ declare namespace monaco.languages.typescript {
         writeByteOrderMark: boolean;
         text: string;
     }
+    export interface ModeConfiguration {
+        /**
+         * Defines whether the built-in completionItemProvider is enabled.
+         */
+        readonly completionItems?: boolean;
+        /**
+         * Defines whether the built-in hoverProvider is enabled.
+         */
+        readonly hovers?: boolean;
+        /**
+         * Defines whether the built-in documentSymbolProvider is enabled.
+         */
+        readonly documentSymbols?: boolean;
+        /**
+         * Defines whether the built-in definitions provider is enabled.
+         */
+        readonly definitions?: boolean;
+        /**
+         * Defines whether the built-in references provider is enabled.
+         */
+        readonly references?: boolean;
+        /**
+         * Defines whether the built-in references provider is enabled.
+         */
+        readonly documentHighlights?: boolean;
+        /**
+         * Defines whether the built-in rename provider is enabled.
+         */
+        readonly rename?: boolean;
+        /**
+         * Defines whether the built-in diagnostic provider is enabled.
+         */
+        readonly diagnostics?: boolean;
+        /**
+         * Defines whether the built-in document formatting range edit provider is enabled.
+         */
+        readonly documentRangeFormattingEdits?: boolean;
+        /**
+         * Defines whether the built-in signature help provider is enabled.
+         */
+        readonly signatureHelp?: boolean;
+        /**
+         * Defines whether the built-in onType formatting edit provider is enabled.
+         */
+        readonly onTypeFormattingEdits?: boolean;
+        /**
+         * Defines whether the built-in code actions provider is enabled.
+         */
+        readonly codeActions?: boolean;
+        /**
+         * Defines whether the built-in inlay hints provider is enabled.
+         */
+        readonly inlayHints?: boolean;
+    }
     export interface LanguageServiceDefaults {
         /**
          * Event fired when compiler options or diagnostics options are changed.
@@ -8124,6 +8586,8 @@ declare namespace monaco.languages.typescript {
         readonly onDidExtraLibsChange: IEvent<void>;
         readonly workerOptions: WorkerOptions;
         readonly inlayHintsOptions: InlayHintsOptions;
+        readonly modeConfiguration: ModeConfiguration;
+        setModeConfiguration(modeConfiguration: ModeConfiguration): void;
         /**
          * Get the current extra libs registered with the language service.
          */
@@ -8231,11 +8695,7 @@ declare namespace monaco.languages.typescript {
          * @returns `Promise<typescript.QuickInfo | undefined>`
          */
         getQuickInfoAtPosition(fileName: string, position: number): Promise<any | undefined>;
-        /**
-         * Get other ranges which are related to the item at the given position in the file (often used for highlighting).
-         * @returns `Promise<ReadonlyArray<typescript.ReferenceEntry> | undefined>`
-         */
-        getOccurrencesAtPosition(fileName: string, position: number): Promise<ReadonlyArray<any> | undefined>;
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): Promise<ReadonlyArray<any> | undefined>;
         /**
          * Get the definition of the item at the given position in the file.
          * @returns `Promise<ReadonlyArray<typescript.DefinitionInfo> | undefined>`
@@ -8248,9 +8708,9 @@ declare namespace monaco.languages.typescript {
         getReferencesAtPosition(fileName: string, position: number): Promise<any[] | undefined>;
         /**
          * Get outline entries for the item at the given position in the file.
-         * @returns `Promise<typescript.NavigationBarItem[]>`
+         * @returns `Promise<typescript.NavigationTree | undefined>`
          */
-        getNavigationBarItems(fileName: string): Promise<any[]>;
+        getNavigationTree(fileName: string): Promise<any | undefined>;
         /**
          * Get changes which should be applied to format the given file.
          * @param options `typescript.FormatCodeOptions`