@codingame/monaco-vscode-api 2.2.2 → 3.1.0

package/vscode/src/vs/editor/contrib/inlineEdit/browser/inlineEditController.js

@@ -0,0 +1,309 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { EditOperation } from '../../../common/core/editOperation.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { GhostTextWidget } from './ghostTextWidget.js';
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { InlineEditTriggerKind } from '../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { GhostText, GhostTextPart } from '../../inlineCompletions/browser/ghostText.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
+import { InlineEditHintsWidget } from './inlineEditHintsWidget.js';
+import { createStyleSheet2 } from '../../../../base/browser/dom.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { disposableObservableValue } from '../../../../base/common/observableInternal/base.js';
+import { observableFromEvent, constObservable, observableSignalFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+var InlineEditController_1;
+class InlineEditWidget {
+    constructor(widget, edit) {
+        this.widget = widget;
+        this.edit = edit;
+    }
+    dispose() {
+        this.widget.dispose();
+    }
+}
+let InlineEditController = class InlineEditController extends Disposable {
+    static { InlineEditController_1 = this; }
+    static { this.ID = 'editor.contrib.inlineEditController'; }
+    static { this.inlineEditVisibleKey = 'inlineEditVisible'; }
+    static { this.inlineEditVisibleContext = ( new RawContextKey(InlineEditController_1.inlineEditVisibleKey, false)); }
+    static { this.cursorAtInlineEditKey = 'cursorAtInlineEdit'; }
+    static { this.cursorAtInlineEditContext = ( new RawContextKey(InlineEditController_1.cursorAtInlineEditKey, false)); }
+    static get(editor) {
+        return editor.getContribution(InlineEditController_1.ID);
+    }
+    constructor(editor, instantiationService, contextKeyService, languageFeaturesService, _commandService, _configurationService) {
+        super();
+        this.editor = editor;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.languageFeaturesService = languageFeaturesService;
+        this._commandService = _commandService;
+        this._configurationService = _configurationService;
+        this._isVisibleContext = InlineEditController_1.inlineEditVisibleContext.bindTo(this.contextKeyService);
+        this._isCursorAtInlineEditContext = InlineEditController_1.cursorAtInlineEditContext.bindTo(this.contextKeyService);
+        this._currentEdit = this._register(disposableObservableValue(this, undefined));
+        this._isAccepting = false;
+        this._enabled = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(63 ).enabled);
+        this._fontFamily = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(63 ).fontFamily);
+        this._backgroundColoring = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(63 ).backgroundColoring);
+        const modelChangedSignal = observableSignalFromEvent('InlineEditController.modelContentChangedSignal', editor.onDidChangeModelContent);
+        this._register(autorun(reader => {
+            if (!this._enabled.read(reader)) {
+                return;
+            }
+            modelChangedSignal.read(reader);
+            this.getInlineEdit(editor, true);
+        }));
+        const cursorPosition = observableFromEvent(editor.onDidChangeCursorPosition, () => editor.getPosition());
+        this._register(autorun(reader => {
+            if (!this._enabled.read(reader)) {
+                return;
+            }
+            const pos = cursorPosition.read(reader);
+            if (pos) {
+                this.checkCursorPosition(pos);
+            }
+        }));
+        this._register(autorun((reader) => {
+            const currentEdit = this._currentEdit.read(reader);
+            this._isCursorAtInlineEditContext.set(false);
+            if (!currentEdit) {
+                this._isVisibleContext.set(false);
+                return;
+            }
+            this._isVisibleContext.set(true);
+            const pos = editor.getPosition();
+            if (pos) {
+                this.checkCursorPosition(pos);
+            }
+        }));
+        const editorBlurSingal = observableSignalFromEvent('InlineEditController.editorBlurSignal', editor.onDidBlurEditorWidget);
+        this._register(autorun(reader => {
+            if (!this._enabled.read(reader)) {
+                return;
+            }
+            editorBlurSingal.read(reader);
+            if (this._configurationService.getValue('editor.experimentalInlineEdit.keepOnBlur') || editor.getOption(63 ).keepOnBlur) {
+                return;
+            }
+            this._currentRequestCts?.dispose();
+            this._currentRequestCts = undefined;
+            this.clear(false);
+        }));
+        const editorFocusSignal = observableSignalFromEvent('InlineEditController.editorFocusSignal', editor.onDidFocusEditorText);
+        this._register(autorun(reader => {
+            if (!this._enabled.read(reader)) {
+                return;
+            }
+            editorFocusSignal.read(reader);
+            this.getInlineEdit(editor, true);
+        }));
+        const styleElement = this._register(createStyleSheet2());
+        this._register(autorun(reader => {
+            const fontFamily = this._fontFamily.read(reader);
+            styleElement.setStyle(fontFamily === '' || fontFamily === 'default' ? `` : `
+.monaco-editor .inline-edit-decoration,
+.monaco-editor .inline-edit-decoration-preview,
+.monaco-editor .inline-edit {
+	font-family: ${fontFamily};
+}`);
+        }));
+        this._register(( new InlineEditHintsWidget(this.editor, this._currentEdit, this.instantiationService)));
+    }
+    checkCursorPosition(position) {
+        if (!this._currentEdit) {
+            this._isCursorAtInlineEditContext.set(false);
+            return;
+        }
+        const gt = this._currentEdit.get()?.edit;
+        if (!gt) {
+            this._isCursorAtInlineEditContext.set(false);
+            return;
+        }
+        this._isCursorAtInlineEditContext.set(Range.containsPosition(gt.range, position));
+    }
+    validateInlineEdit(editor, edit) {
+        if (edit.text.includes('\n') && edit.range.startLineNumber !== edit.range.endLineNumber && edit.range.startColumn !== edit.range.endColumn) {
+            const firstColumn = edit.range.startColumn;
+            if (firstColumn !== 1) {
+                return false;
+            }
+            const lastLine = edit.range.endLineNumber;
+            const lastColumn = edit.range.endColumn;
+            const lineLength = editor.getModel()?.getLineLength(lastLine) ?? 0;
+            if (lastColumn !== lineLength + 1) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async fetchInlineEdit(editor, auto) {
+        if (this._currentRequestCts) {
+            this._currentRequestCts.dispose(true);
+        }
+        const model = editor.getModel();
+        if (!model) {
+            return;
+        }
+        const modelVersion = model.getVersionId();
+        const providers = this.languageFeaturesService.inlineEditProvider.all(model);
+        if (providers.length === 0) {
+            return;
+        }
+        const provider = providers[0];
+        this._currentRequestCts = ( new CancellationTokenSource());
+        const token = this._currentRequestCts.token;
+        const triggerKind = auto ? InlineEditTriggerKind.Automatic : InlineEditTriggerKind.Invoke;
+        const shouldDebounce = auto;
+        if (shouldDebounce) {
+            await wait(50, token);
+        }
+        if (token.isCancellationRequested || model.isDisposed() || model.getVersionId() !== modelVersion) {
+            return;
+        }
+        const edit = await provider.provideInlineEdit(model, { triggerKind }, token);
+        if (!edit) {
+            return;
+        }
+        if (token.isCancellationRequested || model.isDisposed() || model.getVersionId() !== modelVersion) {
+            return;
+        }
+        if (!this.validateInlineEdit(editor, edit)) {
+            return;
+        }
+        return edit;
+    }
+    async getInlineEdit(editor, auto) {
+        this._isCursorAtInlineEditContext.set(false);
+        this.clear();
+        this._isAccepting = false;
+        const edit = await this.fetchInlineEdit(editor, auto);
+        if (!edit) {
+            return;
+        }
+        const line = edit.range.endLineNumber;
+        const column = edit.range.endColumn;
+        const ghostText = ( new GhostText(line, [( new GhostTextPart(column, edit.text, false))]));
+        const instance = this.instantiationService.createInstance(GhostTextWidget, this.editor, {
+            ghostText: constObservable(ghostText),
+            minReservedLineCount: constObservable(0),
+            targetTextModel: constObservable(this.editor.getModel() ?? undefined),
+            range: constObservable(edit.range),
+            backgroundColoring: this._backgroundColoring
+        });
+        this._currentEdit.set(( new InlineEditWidget(instance, edit)), undefined);
+    }
+    async trigger() {
+        await this.getInlineEdit(this.editor, false);
+    }
+    async jumpBack() {
+        if (!this._jumpBackPosition) {
+            return;
+        }
+        this.editor.setPosition(this._jumpBackPosition);
+        this.editor.revealPositionInCenterIfOutsideViewport(this._jumpBackPosition);
+    }
+    accept() {
+        this._isAccepting = true;
+        const data = this._currentEdit.get()?.edit;
+        if (!data) {
+            return;
+        }
+        let text = data.text;
+        if (data.text.startsWith('\n')) {
+            text = data.text.substring(1);
+        }
+        this.editor.pushUndoStop();
+        this.editor.executeEdits('acceptCurrent', [EditOperation.replace(Range.lift(data.range), text)]);
+        if (data.accepted) {
+            this._commandService.executeCommand(data.accepted.id, ...(data.accepted.arguments || []));
+        }
+        this.freeEdit(data);
+        this._currentEdit.set(undefined, undefined);
+    }
+    jumpToCurrent() {
+        this._jumpBackPosition = this.editor.getSelection()?.getStartPosition();
+        const data = this._currentEdit.get()?.edit;
+        if (!data) {
+            return;
+        }
+        const position = Position.lift({ lineNumber: data.range.startLineNumber, column: data.range.startColumn });
+        this.editor.setPosition(position);
+        this.editor.revealPositionInCenterIfOutsideViewport(position);
+    }
+    clear(sendRejection = true) {
+        const edit = this._currentEdit.get()?.edit;
+        if (edit && edit?.rejected && !this._isAccepting && sendRejection) {
+            this._commandService.executeCommand(edit.rejected.id, ...(edit.rejected.arguments || []));
+        }
+        if (edit) {
+            this.freeEdit(edit);
+        }
+        this._currentEdit.set(undefined, undefined);
+    }
+    freeEdit(edit) {
+        const model = this.editor.getModel();
+        if (!model) {
+            return;
+        }
+        const providers = this.languageFeaturesService.inlineEditProvider.all(model);
+        if (providers.length === 0) {
+            return;
+        }
+        providers[0].freeInlineEdit(edit);
+    }
+    shouldShowHoverAt(range) {
+        const currentEdit = this._currentEdit.get();
+        if (!currentEdit) {
+            return false;
+        }
+        const edit = currentEdit.edit;
+        const model = currentEdit.widget.model;
+        const overReplaceRange = Range.containsPosition(edit.range, range.getStartPosition()) || Range.containsPosition(edit.range, range.getEndPosition());
+        if (overReplaceRange) {
+            return true;
+        }
+        const ghostText = model.ghostText.get();
+        if (ghostText) {
+            return ( ghostText.parts.some(p => range.containsPosition(( new Position(ghostText.lineNumber, p.column)))));
+        }
+        return false;
+    }
+    shouldShowHoverAtViewZone(viewZoneId) {
+        return this._currentEdit.get()?.widget.ownsViewZone(viewZoneId) ?? false;
+    }
+};
+InlineEditController = InlineEditController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IConfigurationService))
+], InlineEditController));
+function wait(ms, cancellationToken) {
+    return ( new Promise(resolve => {
+        let d = undefined;
+        const handle = setTimeout(() => {
+            if (d) {
+                d.dispose();
+            }
+            resolve();
+        }, ms);
+        if (cancellationToken) {
+            d = cancellationToken.onCancellationRequested(() => {
+                clearTimeout(handle);
+                if (d) {
+                    d.dispose();
+                }
+                resolve();
+            });
+        }
+    }));
+}
+export { InlineEditController, InlineEditWidget };

package/vscode/src/vs/editor/contrib/inlineEdit/browser/inlineEditHintsWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .inlineEditHints.withBorder{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);color:var(--vscode-editorHoverWidget-foreground);z-index:39}.monaco-editor .inlineEditHints a,.monaco-editor .inlineEditHints a:hover{color:var(--vscode-foreground)}.monaco-editor .inlineEditHints .keybinding{display:flex;margin-left:4px;opacity:.6}.monaco-editor .inlineEditHints .keybinding .monaco-keybinding-key{font-size:8px;padding:2px 3px}.monaco-editor .inlineEditStatusBarItemLabel{margin-right:2px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/editor/contrib/inlineEdit/browser/inlineEditHintsWidget.js

@@ -0,0 +1,193 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { h } from '../../../../base/browser/dom.js';
+import { KeybindingLabel, unthemedKeybindingLabelOptions } from '../../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { Separator } from '../../../../base/common/actions.js';
+import { equals } from '../../../../base/common/arrays.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { OS } from '../../../../base/common/platform.js';
+import './inlineEditHintsWidget.css.js';
+import { Position } from '../../../common/core/position.js';
+import { MenuEntryActionViewItem, createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { WorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { autorun, autorunWithStore } from '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+var InlineEditHintsContentWidget_1;
+let InlineEditHintsWidget = class InlineEditHintsWidget extends Disposable {
+    constructor(editor, model, instantiationService) {
+        super();
+        this.editor = editor;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        this.alwaysShowToolbar = observableFromEvent(this.editor.onDidChangeConfiguration, () => this.editor.getOption(63 ).showToolbar === 'always');
+        this.sessionPosition = undefined;
+        this.position = derived(this, reader => {
+            const ghostText = this.model.read(reader)?.widget.model.ghostText.read(reader);
+            if (!this.alwaysShowToolbar.read(reader) || !ghostText || ghostText.parts.length === 0) {
+                this.sessionPosition = undefined;
+                return null;
+            }
+            const firstColumn = ghostText.parts[0].column;
+            if (this.sessionPosition && this.sessionPosition.lineNumber !== ghostText.lineNumber) {
+                this.sessionPosition = undefined;
+            }
+            const position = ( new Position(
+                ghostText.lineNumber,
+                Math.min(firstColumn, this.sessionPosition?.column ?? Number.MAX_SAFE_INTEGER)
+            ));
+            this.sessionPosition = position;
+            return position;
+        });
+        this._register(autorunWithStore((reader, store) => {
+            const model = this.model.read(reader);
+            if (!model || !this.alwaysShowToolbar.read(reader)) {
+                return;
+            }
+            const contentWidget = store.add(this.instantiationService.createInstance(InlineEditHintsContentWidget, this.editor, true, this.position));
+            editor.addContentWidget(contentWidget);
+            store.add(toDisposable(() => editor.removeContentWidget(contentWidget)));
+        }));
+    }
+};
+InlineEditHintsWidget = ( __decorate([
+    ( __param(2, IInstantiationService))
+], InlineEditHintsWidget));
+let InlineEditHintsContentWidget = class InlineEditHintsContentWidget extends Disposable {
+    static { InlineEditHintsContentWidget_1 = this; }
+    static { this._dropDownVisible = false; }
+    static get dropDownVisible() { return this._dropDownVisible; }
+    static { this.id = 0; }
+    constructor(editor, withBorder, _position, instantiationService, _contextKeyService, _menuService) {
+        super();
+        this.editor = editor;
+        this.withBorder = withBorder;
+        this._position = _position;
+        this._contextKeyService = _contextKeyService;
+        this._menuService = _menuService;
+        this.id = `InlineEditHintsContentWidget${InlineEditHintsContentWidget_1.id++}`;
+        this.allowEditorOverflow = true;
+        this.suppressMouseDown = false;
+        this.nodes = h('div.inlineEditHints', { className: this.withBorder ? '.withBorder' : '' }, [
+            h('div@toolBar'),
+        ]);
+        this.inlineCompletionsActionsMenus = this._register(this._menuService.createMenu(MenuId.InlineEditActions, this._contextKeyService));
+        this.toolBar = this._register(instantiationService.createInstance(CustomizedMenuWorkbenchToolBar, this.nodes.toolBar, this.editor, MenuId.InlineEditToolbar, {
+            menuOptions: { renderShortTitle: true },
+            toolbarOptions: { primaryGroup: g => g.startsWith('primary') },
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction) {
+                    return instantiationService.createInstance(StatusBarViewItem, action, undefined);
+                }
+                return undefined;
+            },
+            telemetrySource: 'InlineEditToolbar',
+        }));
+        this._register(this.toolBar.onDidChangeDropdownVisibility(e => {
+            InlineEditHintsContentWidget_1._dropDownVisible = e;
+        }));
+        this._register(autorun(reader => {
+            this._position.read(reader);
+            this.editor.layoutContentWidget(this);
+        }));
+        this._register(autorun(reader => {
+            const extraActions = [];
+            for (const [_, group] of this.inlineCompletionsActionsMenus.getActions()) {
+                for (const action of group) {
+                    if (action instanceof MenuItemAction) {
+                        extraActions.push(action);
+                    }
+                }
+            }
+            if (extraActions.length > 0) {
+                extraActions.unshift(( new Separator()));
+            }
+            this.toolBar.setAdditionalSecondaryActions(extraActions);
+        }));
+    }
+    getId() { return this.id; }
+    getDomNode() {
+        return this.nodes.root;
+    }
+    getPosition() {
+        return {
+            position: this._position.get(),
+            preference: [1 , 2 ],
+            positionAffinity: 3 ,
+        };
+    }
+};
+InlineEditHintsContentWidget = InlineEditHintsContentWidget_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IMenuService))
+], InlineEditHintsContentWidget));
+class StatusBarViewItem extends MenuEntryActionViewItem {
+    updateLabel() {
+        const kb = this._keybindingService.lookupKeybinding(this._action.id, this._contextKeyService);
+        if (!kb) {
+            return super.updateLabel();
+        }
+        if (this.label) {
+            const div = h('div.keybinding').root;
+            const k = ( new KeybindingLabel(div, OS, { disableTitle: true, ...unthemedKeybindingLabelOptions }));
+            k.set(kb);
+            this.label.textContent = this._action.label;
+            this.label.appendChild(div);
+            this.label.classList.add('inlineEditStatusBarItemLabel');
+        }
+    }
+    updateTooltip() {
+    }
+}
+let CustomizedMenuWorkbenchToolBar = class CustomizedMenuWorkbenchToolBar extends WorkbenchToolBar {
+    constructor(container, editor, menuId, options2, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
+        super(container, { resetMenu: menuId, ...options2 }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
+        this.editor = editor;
+        this.menuId = menuId;
+        this.options2 = options2;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.menu = this._store.add(this.menuService.createMenu(this.menuId, this.contextKeyService, { emitEventsForSubmenuChanges: true }));
+        this.additionalActions = [];
+        this.prependedPrimaryActions = [];
+        this._store.add(this.menu.onDidChange(() => this.updateToolbar()));
+        this._store.add(this.editor.onDidChangeCursorPosition(() => this.updateToolbar()));
+        this.updateToolbar();
+    }
+    updateToolbar() {
+        const primary = [];
+        const secondary = [];
+        createAndFillInActionBarActions(this.menu, this.options2?.menuOptions, { primary, secondary }, this.options2?.toolbarOptions?.primaryGroup, this.options2?.toolbarOptions?.shouldInlineSubmenu, this.options2?.toolbarOptions?.useSeparatorsInPrimaryActions);
+        secondary.push(...this.additionalActions);
+        primary.unshift(...this.prependedPrimaryActions);
+        this.setActions(primary, secondary);
+    }
+    setPrependedPrimaryActions(actions) {
+        if (equals(this.prependedPrimaryActions, actions, (a, b) => a === b)) {
+            return;
+        }
+        this.prependedPrimaryActions = actions;
+        this.updateToolbar();
+    }
+    setAdditionalSecondaryActions(actions) {
+        if (equals(this.additionalActions, actions, (a, b) => a === b)) {
+            return;
+        }
+        this.additionalActions = actions;
+        this.updateToolbar();
+    }
+};
+CustomizedMenuWorkbenchToolBar = ( __decorate([
+    ( __param(4, IMenuService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, ITelemetryService))
+], CustomizedMenuWorkbenchToolBar));
+export { CustomizedMenuWorkbenchToolBar, InlineEditHintsContentWidget, InlineEditHintsWidget };

package/vscode/src/vs/editor/contrib/inlineProgress/browser/inlineProgress.js

@@ -41,13 +41,13 @@ class InlineProgressWidget extends Disposable {
         this.domNode.append(iconElement);
         iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.loading), 'codicon-modifier-spin');
         const updateSize = () => {
-            const lineHeight = this.editor.getOption(66 );
+            const lineHeight = this.editor.getOption(67 );
             this.domNode.style.height = `${lineHeight}px`;
             this.domNode.style.width = `${Math.ceil(0.8 * lineHeight)}px`;
         };
         updateSize();
         this._register(this.editor.onDidChangeConfiguration(c => {
-            if (c.hasChanged(52 ) || c.hasChanged(66 )) {
+            if (c.hasChanged(52 ) || c.hasChanged(67 )) {
                 updateSize();
             }
         }));

package/vscode/src/vs/editor/contrib/linesOperations/browser/linesOperations.js

@@ -994,7 +994,7 @@ class AbstractCaseAction extends EditorAction {
         if (model === null) {
             return;
         }
-        const wordSeparators = editor.getOption(129 );
+        const wordSeparators = editor.getOption(130 );
         const textEdits = [];
         for (const selection of selections) {
             if (selection.isEmpty()) {

package/vscode/src/vs/editor/contrib/linkedEditing/browser/linkedEditing.js

@@ -58,7 +58,7 @@ let LinkedEditingContribution = class LinkedEditingContribution extends Disposab
         this._currentRequestModelVersion = null;
         this._register(this._editor.onDidChangeModel(() => this.reinitialize(true)));
         this._register(this._editor.onDidChangeConfiguration(e => {
-            if (e.hasChanged(69 ) || e.hasChanged(92 )) {
+            if (e.hasChanged(70 ) || e.hasChanged(93 )) {
                 this.reinitialize(false);
             }
         }));
@@ -68,7 +68,7 @@ let LinkedEditingContribution = class LinkedEditingContribution extends Disposab
     }
     reinitialize(forceRefresh) {
         const model = this._editor.getModel();
-        const isEnabled = model !== null && (this._editor.getOption(69 ) || this._editor.getOption(92 )) && ( this._providers.has(model));
+        const isEnabled = model !== null && (this._editor.getOption(70 ) || this._editor.getOption(93 )) && ( this._providers.has(model));
         if (isEnabled === this._enabled && !forceRefresh) {
             return;
         }

package/vscode/src/vs/editor/contrib/links/browser/links.js

@@ -50,7 +50,7 @@ let LinkDetector = class LinkDetector extends Disposable {
             this.cleanUpActiveLinkDecoration();
         }));
         this._register(editor.onDidChangeConfiguration((e) => {
-            if (!e.hasChanged(70 )) {
+            if (!e.hasChanged(71 )) {
                 return;
             }
             this.updateDecorations([]);
@@ -80,7 +80,7 @@ let LinkDetector = class LinkDetector extends Disposable {
         this.computeLinks.schedule(0);
     }
     async computeLinksNow() {
-        if (!this.editor.hasModel() || !this.editor.getOption(70 )) {
+        if (!this.editor.hasModel() || !this.editor.getOption(71 )) {
             return;
         }
         const model = this.editor.getModel();
@@ -112,7 +112,7 @@ let LinkDetector = class LinkDetector extends Disposable {
         }
     }
     updateDecorations(links) {
-        const useMetaKey = (this.editor.getOption(77 ) === 'altKey');
+        const useMetaKey = (this.editor.getOption(78 ) === 'altKey');
         const oldDecorations = [];
         const keys = ( Object.keys(this.currentOccurrences));
         for (const decorationId of keys) {
@@ -136,7 +136,7 @@ let LinkDetector = class LinkDetector extends Disposable {
         });
     }
     _onEditorMouseMove(mouseEvent, withKey) {
-        const useMetaKey = (this.editor.getOption(77 ) === 'altKey');
+        const useMetaKey = (this.editor.getOption(78 ) === 'altKey');
         if (this.isEnabled(mouseEvent, withKey)) {
             this.cleanUpActiveLinkDecoration();
             const occurrence = this.getLinkOccurrence(mouseEvent.target.position);
@@ -152,7 +152,7 @@ let LinkDetector = class LinkDetector extends Disposable {
         }
     }
     cleanUpActiveLinkDecoration() {
-        const useMetaKey = (this.editor.getOption(77 ) === 'altKey');
+        const useMetaKey = (this.editor.getOption(78 ) === 'altKey');
         if (this.activeLinkDecorationId) {
             const occurrence = this.currentOccurrences[this.activeLinkDecorationId];
             if (occurrence) {

package/vscode/src/vs/editor/contrib/longLinesHelper/browser/longLinesHelper.js

@@ -9,7 +9,7 @@ class LongLinesHelper extends Disposable {
         super();
         this._editor = _editor;
         this._register(this._editor.onMouseDown((e) => {
-            const stopRenderingLineAfter = this._editor.getOption(116 );
+            const stopRenderingLineAfter = this._editor.getOption(117 );
             if (stopRenderingLineAfter >= 0 && e.target.type === 6  && e.target.position.column >= stopRenderingLineAfter) {
                 this._editor.updateOptions({
                     stopRenderingLineAfter: -1