@codingame/monaco-vscode-api 18.3.1 → 19.0.0

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -19,7 +19,6 @@ import { Event } from '../../../base/common/event.js';
 import { EditorOption } from '../../common/config/editorOptions.js';
 import { InlineDecorationType } from '../../common/viewModel.js';
 import { DecorationStyleCache } from './css/decorationStyleCache.js';
-import { ViewportRenderStrategy } from './renderStrategy/viewportRenderStrategy.js';
 import Severity$1 from '../../../base/common/severity.js';
 import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
 import { runOnChange } from '../../../base/common/observableInternal/utils/runOnChange.js';
@@ -49,7 +48,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         this._instantiationService = _instantiationService;
         this._notificationService = _notificationService;
         this.configurationService = configurationService;
-        this.maxGpuCols = ViewportRenderStrategy.maxSupportedColumns;
+        this.maxGpuCols = 2000;
         this.canvas = createFastDomNode(document.createElement('canvas'));
         this.canvas.setClassName('editorCanvas');
         this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
@@ -70,7 +69,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
             }).then(ref => {
                 ViewGpuContext_1.deviceSync = ref.object;
                 if (!ViewGpuContext_1._atlas) {
-                    ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, ref.object.limits.maxTextureDimension2D, undefined);
+                    ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, ref.object.limits.maxTextureDimension2D, undefined, ViewGpuContext_1.decorationStyleCache);
                 }
                 return ref.object;
             });

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

@@ -52,6 +52,7 @@ export declare class ObservableCodeEditor extends Disposable {
     readonly layoutInfoVerticalScrollbarWidth: IObservable<number>;
     readonly contentWidth: IObservable<number>;
     readonly contentHeight: IObservable<number>;
+    readonly domNode: IObservableWithChange<HTMLElement | null, void>;
     getOption<T extends EditorOption>(id: T): IObservable<FindComputedEditorOptionValueById<T>>;
     setDecorations(decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
     private _widgetCounter;
@@ -61,6 +62,11 @@ export declare class ObservableCodeEditor extends Disposable {
     observePosition(position: IObservable<Position | null>, store: DisposableStore): IObservable<Point | null>;
     readonly openedPeekWidgets: import("../../base/common/observable.js").ISettableObservable<number, void>;
     isTargetHovered(predicate: (target: IEditorMouseEvent) => boolean, store: DisposableStore): IObservable<boolean>;
+    observeLineHeightForPosition(position: IObservable<Position> | Position): IObservable<number>;
+    observeLineHeightForPosition(position: IObservable<null>): IObservable<null>;
+    observeLineHeightForLine(lineNumber: IObservable<number> | number): IObservable<number>;
+    observeLineHeightForLine(lineNumber: IObservable<null>): IObservable<null>;
+    observeLineHeightsForLineRange(lineNumber: IObservable<LineRange> | LineRange): IObservable<number[]>;
 }
 interface IObservableOverlayWidget {
     get domNode(): HTMLElement;

package/vscode/src/vs/editor/browser/observableCodeEditor.js

@@ -3,16 +3,17 @@ import { equalsIfDefined, itemsEquals } from '../../base/common/equals.js';
 import { Disposable, DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
 import '../../base/common/observableInternal/index.js';
 import { EditorOption } from '../common/config/editorOptions.js';
+import { LineRange } from '../common/core/ranges/lineRange.js';
 import { OffsetRange } from '../common/core/ranges/offsetRange.js';
 import { Position } from '../common/core/position.js';
 import { Selection } from '../common/core/selection.js';
 import { ContentWidgetPositionPreference } from './editorBrowser.js';
 import { Point } from '../common/core/2d/point.js';
 import { TransactionImpl } from '../../base/common/observableInternal/transaction.js';
+import { observableFromEvent } from '../../base/common/observableInternal/observables/observableFromEvent.js';
 import { derivedOpts, derivedWithSetter, derived } from '../../base/common/observableInternal/observables/derived.js';
 import { autorunOpts, autorun } from '../../base/common/observableInternal/reactions/autorun.js';
 import { observableValue } from '../../base/common/observableInternal/observables/observableValue.js';
-import { observableFromEvent } from '../../base/common/observableInternal/observables/observableFromEvent.js';
 import { observableValueOpts } from '../../base/common/observableInternal/observables/observableValueOpts.js';
 import { observableSignal } from '../../base/common/observableInternal/observables/observableSignal.js';
 
@@ -178,6 +179,10 @@ class ObservableCodeEditor extends Disposable {
                 this._endUpdate();
             }
         }));
+        this.domNode = derived(reader => {
+            this.model.read(reader);
+            return this.editor.getDomNode();
+        });
     }
     forceUpdate(cb) {
         this._beginUpdate();
@@ -324,6 +329,38 @@ class ObservableCodeEditor extends Disposable {
         }));
         return isHovered;
     }
+    observeLineHeightForPosition(position) {
+        return derived(reader => {
+            const pos = position instanceof Position ? position : position.read(reader);
+            if (pos === null) {
+                return null;
+            }
+            this.getOption(EditorOption.lineHeight).read(reader);
+            return this.editor.getLineHeightForPosition(pos);
+        });
+    }
+    observeLineHeightForLine(lineNumber) {
+        if (typeof lineNumber === 'number') {
+            return this.observeLineHeightForPosition(( new Position(lineNumber, 1)));
+        }
+        return derived(reader => {
+            const line = lineNumber.read(reader);
+            if (line === null) {
+                return null;
+            }
+            return this.observeLineHeightForPosition(( new Position(line, 1))).read(reader);
+        });
+    }
+    observeLineHeightsForLineRange(lineNumber) {
+        return derived(reader => {
+            const range = lineNumber instanceof LineRange ? lineNumber : lineNumber.read(reader);
+            const heights = [];
+            for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
+                heights.push(this.observeLineHeightForLine(i).read(reader));
+            }
+            return heights;
+        });
+    }
 }
 
 export { ObservableCodeEditor, observableCodeEditor };

package/vscode/src/vs/editor/browser/services/abstractCodeEditorService.js

@@ -389,6 +389,10 @@ class DecorationTypeOptionsProvider {
         const options = providerArgs.options;
         this.isWholeLine = Boolean(options.isWholeLine);
         this.lineHeight = options.lineHeight;
+        this.fontFamily = options.fontFamily;
+        this.fontSize = options.fontSize;
+        this.fontWeight = options.fontWeight;
+        this.fontStyle = options.fontStyle;
         this.stickiness = options.rangeBehavior;
         const lightOverviewRulerColor = options.light && options.light.overviewRulerColor || options.overviewRulerColor;
         const darkOverviewRulerColor = options.dark && options.dark.overviewRulerColor || options.overviewRulerColor;
@@ -414,6 +418,10 @@ class DecorationTypeOptionsProvider {
             glyphMarginClassName: this.glyphMarginClassName,
             isWholeLine: this.isWholeLine,
             lineHeight: this.lineHeight,
+            fontFamily: this.fontFamily,
+            fontSize: this.fontSize,
+            fontWeight: this.fontWeight,
+            fontStyle: this.fontStyle,
             overviewRuler: this.overviewRuler,
             stickiness: this.stickiness,
             before: this.beforeInjectedText,
@@ -580,7 +588,7 @@ class DecorationCSSRules {
             return '';
         }
         const cssTextArr = [];
-        this.collectCSSText(opts, ['fontStyle', 'fontWeight', 'textDecoration', 'cursor', 'color', 'opacity', 'letterSpacing'], cssTextArr);
+        this.collectCSSText(opts, ['fontStyle', 'fontWeight', 'fontFamily', 'fontSize', 'textDecoration', 'cursor', 'color', 'opacity', 'letterSpacing'], cssTextArr);
         if (opts.letterSpacing) {
             this._hasLetterSpacing = true;
         }

package/vscode/src/vs/editor/browser/services/bulkEditService.d.ts

@@ -4,6 +4,7 @@ import { IProgress, IProgressStep } from "../../../platform/progress/common/prog
 import { URI } from "../../../base/common/uri.js";
 import { UndoRedoSource } from "../../../platform/undoRedo/common/undoRedo.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
+import { TextModelEditReason } from "../../common/textModelEditReason.js";
 export declare class ResourceEdit {
     readonly metadata?: WorkspaceEditMetadata | undefined;
     protected constructor(metadata?: WorkspaceEditMetadata | undefined);
@@ -43,6 +44,7 @@ export interface IBulkEditOptions {
     undoRedoGroupId?: number;
     confirmBeforeUndo?: boolean;
     respectAutoSaveConfig?: boolean;
+    reason?: TextModelEditReason;
 }
 export interface IBulkEditResult {
     ariaSummary: string;

package/vscode/src/vs/editor/browser/services/editorWorkerService.d.ts

@@ -16,6 +16,7 @@ import { ILanguageFeaturesService } from "../../common/services/languageFeatures
 import { IChange } from "../../common/diff/legacyLinesDiffComputer.js";
 import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { SectionHeader, FindSectionHeaderOptions } from "../../common/services/findSectionHeaders.js";
+import { StringEdit } from "../../common/core/edits/stringEdit.js";
 export declare abstract class EditorWorkerService extends Disposable implements IEditorWorkerService {
     private readonly _languageConfigurationService;
     readonly _serviceBrand: undefined;
@@ -31,6 +32,9 @@ export declare abstract class EditorWorkerService extends Disposable implements
     computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
     computeMoreMinimalEdits(resource: URI, edits: languages.TextEdit[] | null | undefined, pretty?: boolean): Promise<languages.TextEdit[] | undefined>;
     computeHumanReadableDiff(resource: URI, edits: languages.TextEdit[] | null | undefined): Promise<languages.TextEdit[] | undefined>;
+    computeStringEditFromDiff(original: string, modified: string, options: {
+        maxComputationTimeMs: number;
+    }, algorithm: DiffAlgorithmName): Promise<StringEdit>;
     canNavigateValueSet(resource: URI): boolean;
     navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<languages.IInplaceReplaceSupportResult | null>;
     canComputeWordRanges(resource: URI): boolean;

package/vscode/src/vs/editor/browser/services/editorWorkerService.js

@@ -22,6 +22,8 @@ import { mainWindow } from '../../../base/browser/window.js';
 import { WindowIntervalTimer } from '../../../base/browser/dom.js';
 import { WorkerTextModelSyncClient } from '../../common/services/textModelSync/textModelSync.impl.js';
 import { EditorWorkerHost } from '../../common/services/editorWorkerHost.js';
+import { StringEdit } from '../../common/core/edits/stringEdit.js';
+import { OffsetRange } from '../../common/core/ranges/offsetRange.js';
 
 const STOP_WORKER_DELTA_TIME_MS = 5 * 60 * 1000;
 function canSyncModel(modelService, resource) {
@@ -55,7 +57,8 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
             this._workerManager,
             configurationService,
             this._modelService,
-            this._languageConfigurationService
+            this._languageConfigurationService,
+            this._logService
         ))));
     }
     dispose() {
@@ -126,6 +129,17 @@ let EditorWorkerService = class EditorWorkerService extends Disposable {
             return Promise.resolve(undefined);
         }
     }
+    async computeStringEditFromDiff(original, modified, options, algorithm) {
+        try {
+            const worker = await this._workerWithResources([]);
+            const edit = await worker.$computeStringDiff(original, modified, options, algorithm);
+            return StringEdit.fromJson(edit);
+        }
+        catch (e) {
+            onUnexpectedError(e);
+            return StringEdit.replace(OffsetRange.ofLength(original.length), modified);
+        }
+    }
     canNavigateValueSet(resource) {
         return (canSyncModel(this._modelService, resource));
     }
@@ -175,8 +189,9 @@ EditorWorkerService = ( __decorate([
     ( __param(5, ILanguageFeaturesService))
 ], EditorWorkerService));
 class WordBasedCompletionItemProvider {
-    constructor(workerManager, configurationService, modelService, languageConfigurationService) {
+    constructor(workerManager, configurationService, modelService, languageConfigurationService, logService) {
         this.languageConfigurationService = languageConfigurationService;
+        this.logService = logService;
         this._debugDisplayName = 'wordbasedCompletions';
         this._workerManager = workerManager;
         this._configurationService = configurationService;
@@ -213,6 +228,7 @@ class WordBasedCompletionItemProvider {
         const word = model.getWordAtPosition(position);
         const replace = !word ? Range.fromPositions(position) : ( new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn));
         const insert = replace.setEndPosition(position.lineNumber, position.column);
+        this.logService.trace('[WordBasedCompletionItemProvider]', `word: "${word?.word || ''}", wordDef: "${wordDefRegExp}", replace: [${( replace.toString())}], insert: [${( insert.toString())}]`);
         const client = await this._workerManager.withWorker();
         const data = await client.textualSuggest(models, word?.word, wordDefRegExp);
         if (!data) {

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

@@ -0,0 +1,32 @@
+import { Event } from "../../../base/common/event.js";
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { Action2 } from "../../../platform/actions/common/actions.js";
+import { IContextKeyService } from "../../../platform/contextkey/common/contextkey.service.js";
+import { ServicesAccessor } from "../../../platform/instantiation/common/instantiation.js";
+import { IInlineCompletionsService } from "./inlineCompletionsService.service.js";
+export declare class InlineCompletionsService extends Disposable implements IInlineCompletionsService {
+    private _contextKeyService;
+    readonly _serviceBrand: undefined;
+    private _onDidChangeIsSnoozing;
+    readonly onDidChangeIsSnoozing: Event<boolean>;
+    private static readonly SNOOZE_DURATION;
+    private _snoozeTimeEnd;
+    get snoozeTimeLeft(): number;
+    private _timer;
+    constructor(_contextKeyService: IContextKeyService);
+    snooze(durationMs?: number): void;
+    setSnoozeDuration(durationMs: number): void;
+    isSnoozing(): boolean;
+    cancelSnooze(): void;
+}
+export declare class SnoozeInlineCompletion extends Action2 {
+    static ID: string;
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+    private getDurationFromUser;
+}
+export declare class CancelSnoozeInlineCompletion extends Action2 {
+    static ID: string;
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}

package/vscode/src/vs/editor/browser/services/inlineCompletionsService.js

@@ -0,0 +1,141 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { WindowIntervalTimer } from '../../../base/browser/dom.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { localize, localize2 } from '../../../nls.js';
+import { Action2 } from '../../../platform/actions/common/actions.js';
+import { RawContextKey, ContextKeyExpr } from '../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.service.js';
+import '../../../platform/instantiation/common/extensions.js';
+import { IQuickInputService } from '../../../platform/quickinput/common/quickInput.service.js';
+import { StorageScope, StorageTarget } from '../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../platform/storage/common/storage.service.js';
+import { IInlineCompletionsService } from './inlineCompletionsService.service.js';
+
+var InlineCompletionsService_1;
+const InlineCompletionsSnoozing = ( new RawContextKey('inlineCompletions.snoozed', false, ( localize(147, "Whether inline completions are currently snoozed"))));
+let InlineCompletionsService = class InlineCompletionsService extends Disposable {
+    static { InlineCompletionsService_1 = this; }
+    static { this.SNOOZE_DURATION = 300_000; }
+    get snoozeTimeLeft() {
+        if (this._snoozeTimeEnd === undefined) {
+            return 0;
+        }
+        return Math.max(0, this._snoozeTimeEnd - Date.now());
+    }
+    constructor(_contextKeyService) {
+        super();
+        this._contextKeyService = _contextKeyService;
+        this._onDidChangeIsSnoozing = this._register(( new Emitter()));
+        this.onDidChangeIsSnoozing = this._onDidChangeIsSnoozing.event;
+        this._snoozeTimeEnd = undefined;
+        this._timer = this._register(( new WindowIntervalTimer()));
+        const inlineCompletionsSnoozing = InlineCompletionsSnoozing.bindTo(this._contextKeyService);
+        this._register(this.onDidChangeIsSnoozing(() => inlineCompletionsSnoozing.set(this.isSnoozing())));
+    }
+    snooze(durationMs = InlineCompletionsService_1.SNOOZE_DURATION) {
+        this.setSnoozeDuration(durationMs + this.snoozeTimeLeft);
+    }
+    setSnoozeDuration(durationMs) {
+        if (durationMs < 0) {
+            throw ( new BugIndicatingError(`Invalid snooze duration: ${durationMs}. Duration must be non-negative.`));
+        }
+        if (durationMs === 0) {
+            this.cancelSnooze();
+            return;
+        }
+        const wasSnoozing = this.isSnoozing();
+        this._snoozeTimeEnd = Date.now() + durationMs;
+        if (!wasSnoozing) {
+            this._onDidChangeIsSnoozing.fire(true);
+        }
+        this._timer.cancelAndSet(() => {
+            if (!this.isSnoozing()) {
+                this._onDidChangeIsSnoozing.fire(false);
+            }
+            else {
+                throw ( new BugIndicatingError('Snooze timer did not fire as expected'));
+            }
+        }, this.snoozeTimeLeft + 1);
+    }
+    isSnoozing() {
+        return this.snoozeTimeLeft > 0;
+    }
+    cancelSnooze() {
+        if (this.isSnoozing()) {
+            this._snoozeTimeEnd = undefined;
+            this._timer.cancel();
+            this._onDidChangeIsSnoozing.fire(false);
+        }
+    }
+};
+InlineCompletionsService = InlineCompletionsService_1 = ( __decorate([
+    ( __param(0, IContextKeyService))
+], InlineCompletionsService));
+const snoozeInlineSuggestId = 'editor.action.inlineSuggest.snooze';
+const cancelSnoozeInlineSuggestId = 'editor.action.inlineSuggest.cancelSnooze';
+const LAST_SNOOZE_DURATION_KEY = 'inlineCompletions.lastSnoozeDuration';
+class SnoozeInlineCompletion extends Action2 {
+    static { this.ID = snoozeInlineSuggestId; }
+    constructor() {
+        super({
+            id: SnoozeInlineCompletion.ID,
+            title: ( localize2(148, "Snooze Inline Suggestions")),
+            precondition: ContextKeyExpr.true(),
+            f1: true,
+        });
+    }
+    async run(accessor, ...args) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const inlineCompletionsService = accessor.get(IInlineCompletionsService);
+        const storageService = accessor.get(IStorageService);
+        let durationMinutes;
+        if (args.length > 0 && typeof args[0] === 'number') {
+            durationMinutes = args[0];
+        }
+        if (!durationMinutes) {
+            durationMinutes = await this.getDurationFromUser(quickInputService, storageService);
+        }
+        if (durationMinutes) {
+            inlineCompletionsService.setSnoozeDuration(durationMinutes);
+        }
+    }
+    async getDurationFromUser(quickInputService, storageService) {
+        const lastSelectedDuration = storageService.getNumber(LAST_SNOOZE_DURATION_KEY, StorageScope.PROFILE, 300_000);
+        const items = [
+            { label: '1 minute', id: '1', value: 60_000 },
+            { label: '5 minutes', id: '5', value: 300_000 },
+            { label: '10 minutes', id: '10', value: 600_000 },
+            { label: '15 minutes', id: '15', value: 900_000 },
+            { label: '30 minutes', id: '30', value: 1_800_000 },
+            { label: '60 minutes', id: '60', value: 3_600_000 }
+        ];
+        const picked = await quickInputService.pick(items, {
+            placeHolder: ( localize(149, "Select snooze duration for Code completions and NES")),
+            activeItem: items.find(item => item.value === lastSelectedDuration),
+        });
+        if (picked) {
+            storageService.store(LAST_SNOOZE_DURATION_KEY, picked.value, StorageScope.PROFILE, StorageTarget.USER);
+            return picked.value;
+        }
+        return undefined;
+    }
+}
+class CancelSnoozeInlineCompletion extends Action2 {
+    static { this.ID = cancelSnoozeInlineSuggestId; }
+    constructor() {
+        super({
+            id: CancelSnoozeInlineCompletion.ID,
+            title: ( localize2(150, "Cancel Snooze Inline Suggestions")),
+            precondition: InlineCompletionsSnoozing,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        accessor.get(IInlineCompletionsService).cancelSnooze();
+    }
+}
+
+export { CancelSnoozeInlineCompletion, InlineCompletionsService, SnoozeInlineCompletion };

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

@@ -0,0 +1,11 @@
+import { Event } from "../../../base/common/event.js";
+export declare const IInlineCompletionsService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IInlineCompletionsService>;
+export interface IInlineCompletionsService {
+    readonly _serviceBrand: undefined;
+    onDidChangeIsSnoozing: Event<boolean>;
+    readonly snoozeTimeLeft: number;
+    snooze(durationMs?: number): void;
+    setSnoozeDuration(durationMs: number): void;
+    isSnoozing(): boolean;
+    cancelSnooze(): void;
+}

package/vscode/src/vs/editor/browser/services/inlineCompletionsService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+const IInlineCompletionsService = ( createDecorator('IInlineCompletionsService'));
+
+export { IInlineCompletionsService };

package/vscode/src/vs/editor/browser/view/domLineBreaksComputer.js

@@ -2,7 +2,7 @@
 import { createTrustedTypesPolicy } from '../../../base/browser/trustedTypes.js';
 import { CharCode } from '../../../base/common/charCode.js';
 import { firstNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
-import { assertIsDefined } from '../../../base/common/types.js';
+import { assertReturnsDefined } from '../../../base/common/types.js';
 import { applyFontInfo } from '../config/domFontInfo.js';
 import { WrappingIndent } from '../../common/config/editorOptions.js';
 import { StringBuilder } from '../../common/core/stringBuilder.js';
@@ -26,7 +26,7 @@ class DOMLineBreaksComputerFactory {
                 injectedTexts.push(injectedText);
             },
             finalize: () => {
-                return createLineBreaks(assertIsDefined(this.targetWindow.deref()), requests, fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, injectedTexts);
+                return createLineBreaks(assertReturnsDefined(this.targetWindow.deref()), requests, fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, injectedTexts);
             }
         };
     }

package/vscode/src/vs/editor/browser/view/viewController.js

@@ -70,8 +70,12 @@ class ViewController {
         const options = this.configuration.options;
         const selectionClipboardIsOn = (isLinux && options.get(EditorOption.selectionClipboard));
         const columnSelection = options.get(EditorOption.columnSelection);
+        const scrollOnMiddleClick = options.get(EditorOption.scrollOnMiddleClick);
         if (data.middleButton && !selectionClipboardIsOn) {
-            this._columnSelect(data.position, data.mouseColumn, data.inSelectionMode);
+            if (scrollOnMiddleClick) ;
+            else {
+                this._columnSelect(data.position, data.mouseColumn, data.inSelectionMode);
+            }
         }
         else if (data.startedOnLineNumbers) {
             if (this._hasMulticursorModifier(data)) {

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

@@ -38,7 +38,7 @@ export declare class View extends ViewEventHandler {
     private readonly _viewCursors;
     private readonly _viewParts;
     private readonly _viewController;
-    private _experimentalEditContextEnabled;
+    private _editContextEnabled;
     private _accessibilitySupport;
     private _editContext;
     private readonly _pointerHandler;

package/vscode/src/vs/editor/browser/view.js

@@ -72,7 +72,7 @@ let View = class View extends ViewEventHandler {
         this._context = ( new ViewContext(configuration, colorTheme, model));
         this._context.addEventHandler(this);
         this._viewParts = [];
-        this._experimentalEditContextEnabled = this._context.configuration.options.get(EditorOption.effectiveExperimentalEditContextEnabled);
+        this._editContextEnabled = this._context.configuration.options.get(EditorOption.effectiveEditContext);
         this._accessibilitySupport = this._context.configuration.options.get(EditorOption.accessibilitySupport);
         this._editContext = this._instantiateEditContext();
         this._viewParts.push(this._editContext);
@@ -173,7 +173,7 @@ let View = class View extends ViewEventHandler {
         this._pointerHandler = this._register(( new PointerHandler(this._context, this._viewController, this._createPointerHandlerHelper())));
     }
     _instantiateEditContext() {
-        const usingExperimentalEditContext = this._context.configuration.options.get(EditorOption.effectiveExperimentalEditContextEnabled);
+        const usingExperimentalEditContext = this._context.configuration.options.get(EditorOption.effectiveEditContext);
         if (usingExperimentalEditContext) {
             return this._instantiationService.createInstance(NativeEditContext, this._ownerID, this._context, this._overflowGuardContainer, this._viewController, this._createTextAreaHandlerHelper());
         }
@@ -182,12 +182,12 @@ let View = class View extends ViewEventHandler {
         }
     }
     _updateEditContext() {
-        const experimentalEditContextEnabled = this._context.configuration.options.get(EditorOption.effectiveExperimentalEditContextEnabled);
+        const editContextEnabled = this._context.configuration.options.get(EditorOption.effectiveEditContext);
         const accessibilitySupport = this._context.configuration.options.get(EditorOption.accessibilitySupport);
-        if (this._experimentalEditContextEnabled === experimentalEditContextEnabled && this._accessibilitySupport === accessibilitySupport) {
+        if (this._editContextEnabled === editContextEnabled && this._accessibilitySupport === accessibilitySupport) {
             return;
         }
-        this._experimentalEditContextEnabled = experimentalEditContextEnabled;
+        this._editContextEnabled = editContextEnabled;
         this._accessibilitySupport = accessibilitySupport;
         const isEditContextFocused = this._editContext.isFocused();
         const indexOfEditContext = this._viewParts.indexOf(this._editContext);

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

@@ -10,7 +10,7 @@ export declare class ViewCursors extends ViewPart {
     private _cursorBlinking;
     private _cursorStyle;
     private _cursorSmoothCaretAnimation;
-    private _experimentalEditContextEnabled;
+    private _editContextEnabled;
     private _selectionIsEmpty;
     private _isComposingInput;
     private _isVisible;

package/vscode/src/vs/editor/browser/viewParts/viewCursors/viewCursors.js

@@ -22,7 +22,7 @@ class ViewCursors extends ViewPart {
         this._cursorBlinking = options.get(EditorOption.cursorBlinking);
         this._cursorStyle = options.get(EditorOption.effectiveCursorStyle);
         this._cursorSmoothCaretAnimation = options.get(EditorOption.cursorSmoothCaretAnimation);
-        this._experimentalEditContextEnabled = options.get(EditorOption.effectiveExperimentalEditContextEnabled);
+        this._editContextEnabled = options.get(EditorOption.effectiveEditContext);
         this._selectionIsEmpty = true;
         this._isComposingInput = false;
         this._isVisible = false;
@@ -64,7 +64,7 @@ class ViewCursors extends ViewPart {
         this._cursorBlinking = options.get(EditorOption.cursorBlinking);
         this._cursorStyle = options.get(EditorOption.effectiveCursorStyle);
         this._cursorSmoothCaretAnimation = options.get(EditorOption.cursorSmoothCaretAnimation);
-        this._experimentalEditContextEnabled = options.get(EditorOption.effectiveExperimentalEditContextEnabled);
+        this._editContextEnabled = options.get(EditorOption.effectiveEditContext);
         this._updateBlinking();
         this._updateDomClassName();
         this._primaryCursor.onConfigurationChanged(e);
@@ -157,7 +157,7 @@ class ViewCursors extends ViewPart {
         return true;
     }
     _getCursorBlinking() {
-        if (this._isComposingInput && !this._experimentalEditContextEnabled) {
+        if (this._isComposingInput && !this._editContextEnabled) {
             return TextEditorCursorBlinkingStyle.Hidden;
         }
         if (!this._editorHasFocus) {

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLine.js

@@ -5,7 +5,7 @@ import { isNative, isLinux } from '../../../../base/common/platform.js';
 import { RangeUtil } from './rangeUtil.js';
 import { VisibleRanges, FloatHorizontalRange } from '../../view/renderingContext.js';
 import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
-import { RenderLineInput, renderViewLine, ForeignElementType, DomPosition } from '../../../common/viewLayout/viewLineRenderer.js';
+import { RenderWhitespace, RenderLineInput, renderViewLine, ForeignElementType, DomPosition } from '../../../common/viewLayout/viewLineRenderer.js';
 import { InlineDecorationType } from '../../../common/viewModel.js';
 import { isHighContrast } from '../../../../platform/theme/common/theme.js';
 import { EditorFontLigatures } from '../../../common/config/editorOptions.js';
@@ -57,7 +57,7 @@ class ViewLine {
         this._options = newOptions;
     }
     onSelectionChanged() {
-        if (isHighContrast(this._options.themeType) || this._options.renderWhitespace === 'selection') {
+        if (isHighContrast(this._options.themeType) || this._renderedViewLine?.getRenderWhitespace() === RenderWhitespace.Selection) {
             this._isMaybeInvalid = true;
             return true;
         }
@@ -76,8 +76,10 @@ class ViewLine {
         const lineData = viewportData.getViewLineRenderingData(lineNumber);
         const options = this._options;
         const actualInlineDecorations = LineDecoration.filter(lineData.inlineDecorations, lineNumber, lineData.minColumn, lineData.maxColumn);
+        const renderWhitespace = (lineData.hasVariableFonts || options.experimentalWhitespaceRendering === 'off') ? options.renderWhitespace : 'none';
+        const allowFastRendering = !lineData.hasVariableFonts;
         let selectionsOnLine = null;
-        if (isHighContrast(options.themeType) || this._options.renderWhitespace === 'selection') {
+        if (isHighContrast(options.themeType) || renderWhitespace === 'selection') {
             const selections = viewportData.selections;
             for (const selection of selections) {
                 if (selection.endLineNumber < lineNumber || selection.startLineNumber > lineNumber) {
@@ -94,7 +96,7 @@ class ViewLine {
                             InlineDecorationType.Regular
                         )));
                     }
-                    if (this._options.renderWhitespace === 'selection') {
+                    if (renderWhitespace === 'selection') {
                         if (!selectionsOnLine) {
                             selectionsOnLine = [];
                         }
@@ -119,7 +121,7 @@ class ViewLine {
             options.middotWidth,
             options.wsmiddotWidth,
             options.stopRenderingLineAfter,
-            options.renderWhitespace,
+            renderWhitespace,
             options.renderControlCharacters,
             options.fontLigatures !== EditorFontLigatures.OFF,
             selectionsOnLine
@@ -139,7 +141,7 @@ class ViewLine {
         const output = renderViewLine(renderLineInput, sb);
         sb.appendString('</div>');
         let renderedViewLine = null;
-        if (monospaceAssumptionsAreValid && canUseFastRenderedViewLine && lineData.isBasicASCII && options.useMonospaceOptimizations && output.containsForeignElements === ForeignElementType.None) {
+        if (allowFastRendering && monospaceAssumptionsAreValid && canUseFastRenderedViewLine && lineData.isBasicASCII && options.useMonospaceOptimizations && output.containsForeignElements === ForeignElementType.None) {
             renderedViewLine = ( new FastRenderedViewLine(
                 this._renderedViewLine ? this._renderedViewLine.domNode : null,
                 renderLineInput,
@@ -242,6 +244,9 @@ class FastRenderedViewLine {
         this._characterMapping = characterMapping;
         this._charWidth = renderLineInput.spaceWidth;
     }
+    getRenderWhitespace() {
+        return this.input.renderWhitespace;
+    }
     getWidth(context) {
         if (!this.domNode || this.input.lineContent.length < Constants.MaxMonospaceDistance) {
             const horizontalOffset = this._characterMapping.getHorizontalOffset(this._characterMapping.length);
@@ -338,6 +343,9 @@ class RenderedViewLine {
     _getReadingTarget(myDomNode) {
         return myDomNode.domNode.firstChild;
     }
+    getRenderWhitespace() {
+        return this.input.renderWhitespace;
+    }
     getWidth(context) {
         if (!this.domNode) {
             return 0;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLineOptions.d.ts

@@ -3,6 +3,7 @@ import type { IEditorConfiguration } from "../../../common/config/editorConfigur
 export declare class ViewLineOptions {
     readonly themeType: ColorScheme;
     readonly renderWhitespace: "none" | "boundary" | "selection" | "trailing" | "all";
+    readonly experimentalWhitespaceRendering: "svg" | "font" | "off";
     readonly renderControlCharacters: boolean;
     readonly spaceWidth: number;
     readonly middotWidth: number;