@codingame/monaco-vscode-api 9.0.2 → 10.0.0

package/vscode/src/vs/editor/contrib/hover/browser/hoverOperation.js

@@ -1,31 +1,13 @@
-import { RunOnceScheduler, createCancelableAsyncIterable } from '../../../../base/common/async.js';
+import { createCancelableAsyncIterable, RunOnceScheduler } from '../../../../base/common/async.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
-var HoverOperationState;
-( (function(HoverOperationState) {
-    HoverOperationState[HoverOperationState["Idle"] = 0] = "Idle";
-    HoverOperationState[HoverOperationState["FirstWait"] = 1] = "FirstWait";
-    HoverOperationState[HoverOperationState["SecondWait"] = 2] = "SecondWait";
-    HoverOperationState[HoverOperationState["WaitingForAsync"] = 3] = "WaitingForAsync";
-    HoverOperationState[HoverOperationState["WaitingForAsyncShowingLoading"] = 4] = "WaitingForAsyncShowingLoading";
-})(HoverOperationState || (HoverOperationState = {})));
-var HoverStartMode;
-( (function(HoverStartMode) {
-    HoverStartMode[HoverStartMode["Delayed"] = 0] = "Delayed";
-    HoverStartMode[HoverStartMode["Immediate"] = 1] = "Immediate";
-})(HoverStartMode || (HoverStartMode = {})));
-var HoverStartSource;
-( (function(HoverStartSource) {
-    HoverStartSource[HoverStartSource["Mouse"] = 0] = "Mouse";
-    HoverStartSource[HoverStartSource["Keyboard"] = 1] = "Keyboard";
-})(HoverStartSource || (HoverStartSource = {})));
 class HoverResult {
-    constructor(value, isComplete, hasLoadingMessage) {
+    constructor(value, isComplete, hasLoadingMessage, options) {
         this.value = value;
         this.isComplete = isComplete;
         this.hasLoadingMessage = hasLoadingMessage;
+        this.options = options;
     }
 }
 class HoverOperation extends Disposable {
@@ -35,10 +17,10 @@ class HoverOperation extends Disposable {
         this._computer = _computer;
         this._onResult = this._register(( new Emitter()));
         this.onResult = this._onResult.event;
-        this._firstWaitScheduler = this._register(( new RunOnceScheduler(() => this._triggerAsyncComputation(), 0)));
-        this._secondWaitScheduler = this._register(( new RunOnceScheduler(() => this._triggerSyncComputation(), 0)));
-        this._loadingMessageScheduler = this._register(( new RunOnceScheduler(() => this._triggerLoadingMessage(), 0)));
-        this._state = HoverOperationState.Idle;
+        this._asyncComputationScheduler = this._register(( new Debouncer((options) => this._triggerAsyncComputation(options), 0)));
+        this._syncComputationScheduler = this._register(( new Debouncer((options) => this._triggerSyncComputation(options), 0)));
+        this._loadingMessageScheduler = this._register(( new Debouncer((options) => this._triggerLoadingMessage(options), 0)));
+        this._state = 0 ;
         this._asyncIterable = null;
         this._asyncIterableDone = false;
         this._result = [];
@@ -48,10 +30,11 @@ class HoverOperation extends Disposable {
             this._asyncIterable.cancel();
             this._asyncIterable = null;
         }
+        this._options = undefined;
         super.dispose();
     }
     get _hoverTime() {
-        return this._editor.getOption(EditorOption.hover).delay;
+        return this._editor.getOption(62 ).delay;
     }
     get _firstWaitTime() {
         return this._hoverTime / 2;
@@ -62,29 +45,27 @@ class HoverOperation extends Disposable {
     get _loadingMessageTime() {
         return 3 * this._hoverTime;
     }
-    _setState(state, fireResult = true) {
+    _setState(state, options) {
         this._state = state;
-        if (fireResult) {
-            this._fireResult();
-        }
+        this._fireResult(options);
     }
-    _triggerAsyncComputation() {
-        this._setState(HoverOperationState.SecondWait);
-        this._secondWaitScheduler.schedule(this._secondWaitTime);
+    _triggerAsyncComputation(options) {
+        this._setState(2 , options);
+        this._syncComputationScheduler.schedule(options, this._secondWaitTime);
         if (this._computer.computeAsync) {
             this._asyncIterableDone = false;
-            this._asyncIterable = createCancelableAsyncIterable(token => this._computer.computeAsync(token));
+            this._asyncIterable = createCancelableAsyncIterable(token => this._computer.computeAsync(options, token));
             (async () => {
                 try {
                     for await (const item of this._asyncIterable) {
                         if (item) {
                             this._result.push(item);
-                            this._fireResult();
+                            this._fireResult(options);
                         }
                     }
                     this._asyncIterableDone = true;
-                    if (this._state === HoverOperationState.WaitingForAsync || this._state === HoverOperationState.WaitingForAsyncShowingLoading) {
-                        this._setState(HoverOperationState.Idle);
+                    if (this._state === 3  || this._state === 4 ) {
+                        this._setState(0 , options);
                     }
                 }
                 catch (e) {
@@ -96,57 +77,74 @@ class HoverOperation extends Disposable {
             this._asyncIterableDone = true;
         }
     }
-    _triggerSyncComputation() {
+    _triggerSyncComputation(options) {
         if (this._computer.computeSync) {
-            this._result = this._result.concat(this._computer.computeSync());
+            this._result = this._result.concat(this._computer.computeSync(options));
         }
-        this._setState(this._asyncIterableDone ? HoverOperationState.Idle : HoverOperationState.WaitingForAsync);
+        this._setState(this._asyncIterableDone ? 0  : 3 , options);
     }
-    _triggerLoadingMessage() {
-        if (this._state === HoverOperationState.WaitingForAsync) {
-            this._setState(HoverOperationState.WaitingForAsyncShowingLoading);
+    _triggerLoadingMessage(options) {
+        if (this._state === 3 ) {
+            this._setState(4 , options);
         }
     }
-    _fireResult() {
-        if (this._state === HoverOperationState.FirstWait || this._state === HoverOperationState.SecondWait) {
+    _fireResult(options) {
+        if (this._state === 1  || this._state === 2 ) {
             return;
         }
-        const isComplete = (this._state === HoverOperationState.Idle);
-        const hasLoadingMessage = (this._state === HoverOperationState.WaitingForAsyncShowingLoading);
-        this._onResult.fire(( new HoverResult(this._result.slice(0), isComplete, hasLoadingMessage)));
-    }
-    start(mode) {
-        if (mode === HoverStartMode.Delayed) {
-            if (this._state === HoverOperationState.Idle) {
-                this._setState(HoverOperationState.FirstWait);
-                this._firstWaitScheduler.schedule(this._firstWaitTime);
-                this._loadingMessageScheduler.schedule(this._loadingMessageTime);
+        const isComplete = ((this._state === 0) );
+        const hasLoadingMessage = ((this._state === 4) );
+        this._onResult.fire(( new HoverResult(this._result.slice(0), isComplete, hasLoadingMessage, options)));
+    }
+    start(mode, options) {
+        if (mode === 0 ) {
+            if (this._state === 0 ) {
+                this._setState(1 , options);
+                this._asyncComputationScheduler.schedule(options, this._firstWaitTime);
+                this._loadingMessageScheduler.schedule(options, this._loadingMessageTime);
             }
         }
         else {
             switch (this._state) {
-                case HoverOperationState.Idle:
-                    this._triggerAsyncComputation();
-                    this._secondWaitScheduler.cancel();
-                    this._triggerSyncComputation();
+                case 0 :
+                    this._triggerAsyncComputation(options);
+                    this._syncComputationScheduler.cancel();
+                    this._triggerSyncComputation(options);
                     break;
-                case HoverOperationState.SecondWait:
-                    this._secondWaitScheduler.cancel();
-                    this._triggerSyncComputation();
+                case 2 :
+                    this._syncComputationScheduler.cancel();
+                    this._triggerSyncComputation(options);
                     break;
             }
         }
     }
     cancel() {
-        this._firstWaitScheduler.cancel();
-        this._secondWaitScheduler.cancel();
+        this._asyncComputationScheduler.cancel();
+        this._syncComputationScheduler.cancel();
         this._loadingMessageScheduler.cancel();
         if (this._asyncIterable) {
             this._asyncIterable.cancel();
             this._asyncIterable = null;
         }
         this._result = [];
-        this._setState(HoverOperationState.Idle, false);
+        this._options = undefined;
+        this._state = 0 ;
+    }
+    get options() {
+        return this._options;
+    }
+}
+class Debouncer extends Disposable {
+    constructor(runner, debounceTimeMs) {
+        super();
+        this._scheduler = this._register(( new RunOnceScheduler(() => runner(this._options), debounceTimeMs)));
+    }
+    schedule(options, debounceTimeMs) {
+        this._options = options;
+        this._scheduler.schedule(debounceTimeMs);
+    }
+    cancel() {
+        this._scheduler.cancel();
     }
 }
-export { HoverOperation, HoverResult, HoverStartMode, HoverStartSource };
+export { HoverOperation, HoverResult };

package/vscode/src/vs/editor/contrib/hover/browser/hoverTypes.js

@@ -1,21 +1,16 @@
-var HoverAnchorType;
-( (function(HoverAnchorType) {
-    HoverAnchorType[HoverAnchorType["Range"] = 1] = "Range";
-    HoverAnchorType[HoverAnchorType["ForeignElement"] = 2] = "ForeignElement";
-})(HoverAnchorType || (HoverAnchorType = {})));
 class HoverRangeAnchor {
     constructor(priority, range, initialMousePosX, initialMousePosY) {
         this.priority = priority;
         this.range = range;
         this.initialMousePosX = initialMousePosX;
         this.initialMousePosY = initialMousePosY;
-        this.type = HoverAnchorType.Range;
+        this.type = 1 ;
     }
     equals(other) {
-        return (other.type === HoverAnchorType.Range && this.range.equalsRange(other.range));
+        return (other.type === 1  && this.range.equalsRange(other.range));
     }
     canAdoptVisibleHover(lastAnchor, showAtPosition) {
-        return (lastAnchor.type === HoverAnchorType.Range && showAtPosition.lineNumber === this.range.startLineNumber);
+        return (lastAnchor.type === 1  && showAtPosition.lineNumber === this.range.startLineNumber);
     }
 }
 class HoverForeignElementAnchor {
@@ -26,13 +21,13 @@ class HoverForeignElementAnchor {
         this.initialMousePosX = initialMousePosX;
         this.initialMousePosY = initialMousePosY;
         this.supportsMarkerHover = supportsMarkerHover;
-        this.type = HoverAnchorType.ForeignElement;
+        this.type = 2 ;
     }
     equals(other) {
-        return (other.type === HoverAnchorType.ForeignElement && this.owner === other.owner);
+        return (other.type === 2  && this.owner === other.owner);
     }
     canAdoptVisibleHover(lastAnchor, showAtPosition) {
-        return (lastAnchor.type === HoverAnchorType.ForeignElement && this.owner === lastAnchor.owner);
+        return (lastAnchor.type === 2  && this.owner === lastAnchor.owner);
     }
 }
 class RenderedHoverParts {
@@ -56,4 +51,4 @@ const HoverParticipantRegistry = (new (class HoverParticipantRegistry {
         return this._participants;
     }
 })());
-export { HoverAnchorType, HoverForeignElementAnchor, HoverParticipantRegistry, HoverRangeAnchor, RenderedHoverParts };
+export { HoverForeignElementAnchor, HoverParticipantRegistry, HoverRangeAnchor, RenderedHoverParts };

package/vscode/src/vs/editor/contrib/hover/browser/markdownHoverParticipant.js

@@ -8,28 +8,26 @@ import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/brows
 import { DECREASE_HOVER_VERBOSITY_ACTION_ID, INCREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
-import { HoverAnchorType, RenderedHoverParts } from './hoverTypes.js';
+import { RenderedHoverParts } from './hoverTypes.js';
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 import { HoverVerbosityAction } from '../../../common/languages.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
-import { ClickAction, KeyDownAction, HoverPosition } from '../../../../base/browser/ui/hover/hoverWidget.js';
-import { KeyCode } from '../../../../base/common/keyCodes.js';
+import { ClickAction, KeyDownAction } from '../../../../base/browser/ui/hover/hoverWidget.js';
 import { WorkbenchHoverDelegate } from '../../../../platform/hover/browser/hover.js';
 import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { AsyncIterableObject } from '../../../../base/common/async.js';
 import { getHoverProviderResultsAsAsyncIterable } from './getHover.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 const $ = $$1;
-const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localize(5111, 'Icon for increaseing hover verbosity.')));
-const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localize(5112, 'Icon for decreasing hover verbosity.')));
+const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localize(5181, 'Icon for increaseing hover verbosity.')));
+const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localize(5182, 'Icon for decreasing hover verbosity.')));
 class MarkdownHover {
     constructor(owner, range, contents, isBeforeContent, ordinal, source = undefined) {
         this.owner = owner;
@@ -40,7 +38,7 @@ class MarkdownHover {
         this.source = source;
     }
     isValidForHoverAnchor(anchor) {
-        return (anchor.type === HoverAnchorType.Range
+        return (anchor.type === 1
             && this.range.startColumn <= anchor.range.startColumn
             && this.range.endColumn >= anchor.range.endColumn);
     }
@@ -77,14 +75,14 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
              (new MarkdownHover(
                 this,
                 anchor.range,
-                [( (new MarkdownString())).appendText(( localize(5113, "Loading...")))],
+                [( (new MarkdownString())).appendText(( localize(5183, "Loading...")))],
                 false,
                 2000
             ))
         );
     }
     computeSync(anchor, lineDecorations) {
-        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range) {
+        if (!this._editor.hasModel() || anchor.type !== 1 ) {
             return [];
         }
         const model = this._editor.getModel();
@@ -94,7 +92,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         let index = 1000;
         const lineLength = model.getLineLength(lineNumber);
         const languageId = model.getLanguageIdAtPosition(anchor.range.startLineNumber, anchor.range.startColumn);
-        const stopRenderingLineAfter = this._editor.getOption(EditorOption.stopRenderingLineAfter);
+        const stopRenderingLineAfter = this._editor.getOption(120 );
         const maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
             overrideIdentifier: languageId
         });
@@ -103,7 +101,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             stopRenderingMessage = true;
             result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localize(
-                        5114,
+                        5184,
                         "Rendering paused for long line for performance reasons. This can be configured via `editor.stopRenderingLineAfter`."
                     ))
                 }], false, index++))));
@@ -111,7 +109,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         if (!stopRenderingMessage && typeof maxTokenizationLineLength === 'number' && lineLength >= maxTokenizationLineLength) {
             result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localize(
-                        5115,
+                        5185,
                         "Tokenization is skipped for long lines for performance reasons. This can be configured via `editor.maxTokenizationLineLength`."
                     ))
                 }], false, index++))));
@@ -138,7 +136,7 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         return result;
     }
     computeAsync(anchor, lineDecorations, token) {
-        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range) {
+        if (!this._editor.hasModel() || anchor.type !== 1 ) {
             return AsyncIterableObject.EMPTY;
         }
         const model = this._editor.getModel();
@@ -281,7 +279,7 @@ class MarkdownRenderedHoverParts {
         const hoverDelegate = ( (new WorkbenchHoverDelegate(
             'mouse',
             false,
-            { target: container, position: { hoverPosition: HoverPosition.LEFT } },
+            { target: container, position: { hoverPosition: 0  } },
             this._configurationService,
             this._hoverService
         )));
@@ -293,7 +291,11 @@ class MarkdownRenderedHoverParts {
         actionElement.classList.add('enabled');
         const actionFunction = () => this._commandService.executeCommand(action === HoverVerbosityAction.Increase ? INCREASE_HOVER_VERBOSITY_ACTION_ID : DECREASE_HOVER_VERBOSITY_ACTION_ID);
         store.add(( (new ClickAction(actionElement, actionFunction))));
-        store.add(( (new KeyDownAction(actionElement, actionFunction, [KeyCode.Enter, KeyCode.Space]))));
+        store.add(( (new KeyDownAction(
+            actionElement,
+            actionFunction,
+            [3 , 10 ]
+        ))));
         return store;
     }
     async updateMarkdownHoverPartVerbosityLevel(action, index, focus = true) {
@@ -440,14 +442,14 @@ function labelForHoverVerbosityAction(keybindingService, action) {
         case HoverVerbosityAction.Increase: {
             const kb = keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
             return kb ?
-                ( localize(5116, "Increase Hover Verbosity ({0})", kb.getLabel())) :
-                ( localize(5117, "Increase Hover Verbosity"));
+                ( localize(5186, "Increase Hover Verbosity ({0})", kb.getLabel())) :
+                ( localize(5187, "Increase Hover Verbosity"));
         }
         case HoverVerbosityAction.Decrease: {
             const kb = keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
             return kb ?
-                ( localize(5118, "Decrease Hover Verbosity ({0})", kb.getLabel())) :
-                ( localize(5119, "Decrease Hover Verbosity"));
+                ( localize(5188, "Decrease Hover Verbosity ({0})", kb.getLabel())) :
+                ( localize(5189, "Decrease Hover Verbosity"));
         }
     }
 }

package/vscode/src/vs/editor/contrib/hover/browser/markerHoverParticipant.js

@@ -5,16 +5,14 @@ import { disposableTimeout, createCancelablePromise } from '../../../../base/com
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { basename } from '../../../../base/common/resources.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
-import { CodeActionTriggerType } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { IMarkerDecorationsService } from '../../../common/services/markerDecorations.js';
 import { quickFixCommandId, getCodeActions } from '../../codeAction/browser/codeAction.js';
 import { CodeActionController } from '../../codeAction/browser/codeActionController.js';
 import { CodeActionKind, CodeActionTriggerSource } from '../../codeAction/common/types.js';
 import { MarkerController, NextMarkerAction } from '../../gotoError/browser/gotoError.js';
-import { HoverAnchorType, RenderedHoverParts } from './hoverTypes.js';
+import { RenderedHoverParts } from './hoverTypes.js';
 import { localize } from '../../../../nls.js';
 import { MarkerSeverity, IMarkerData } from '../../../../platform/markers/common/markers.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
@@ -27,13 +25,13 @@ class MarkerHover {
         this.marker = marker;
     }
     isValidForHoverAnchor(anchor) {
-        return (anchor.type === HoverAnchorType.Range
+        return (anchor.type === 1
             && this.range.startColumn <= anchor.range.startColumn
             && this.range.endColumn >= anchor.range.endColumn);
     }
 }
 const markerCodeActionTrigger = {
-    type: CodeActionTriggerType.Invoke,
+    type: 1 ,
     filter: { include: CodeActionKind.QuickFix },
     triggerAction: CodeActionTriggerSource.QuickFixHover
 };
@@ -47,7 +45,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
         this.recentMarkerCodeActionsInfo = undefined;
     }
     computeSync(anchor, lineDecorations) {
-        if (!this._editor.hasModel() || anchor.type !== HoverAnchorType.Range && !anchor.supportsMarkerHover) {
+        if (!this._editor.hasModel() || anchor.type !== 1  && !anchor.supportsMarkerHover) {
             return [];
         }
         const model = this._editor.getModel();
@@ -110,7 +108,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                     sourceElement.innerText = source;
                 }
                 const codeLink = append(sourceAndCodeElement, $('a.code-link'));
-                codeLink.setAttribute('href', ( (code.target.toString())));
+                codeLink.setAttribute('href', ( (code.target.toString(true))));
                 disposables.add(addDisposableListener(codeLink, 'click', (e) => {
                     this._openerService.open(code.target, { allowCommands: true });
                     e.preventDefault();
@@ -164,7 +162,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             const markerController = MarkerController.get(this._editor);
             if (markerController) {
                 context.statusBar.addAction({
-                    label: ( localize(5120, "View Problem")),
+                    label: ( localize(5190, "View Problem")),
                     commandId: NextMarkerAction.ID,
                     run: () => {
                         context.hide();
@@ -174,19 +172,19 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 });
             }
         }
-        if (!this._editor.getOption(EditorOption.readOnly)) {
+        if (!this._editor.getOption(94 )) {
             const quickfixPlaceholderElement = context.statusBar.append($('div'));
             if (this.recentMarkerCodeActionsInfo) {
                 if (IMarkerData.makeKey(this.recentMarkerCodeActionsInfo.marker) === IMarkerData.makeKey(markerHover.marker)) {
                     if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
-                        quickfixPlaceholderElement.textContent = ( localize(5121, "No quick fixes available"));
+                        quickfixPlaceholderElement.textContent = ( localize(5191, "No quick fixes available"));
                     }
                 }
                 else {
                     this.recentMarkerCodeActionsInfo = undefined;
                 }
             }
-            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localize(5122, "Checking for quick fixes...")), 200, disposables);
+            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localize(5192, "Checking for quick fixes...")), 200, disposables);
             if (!quickfixPlaceholderElement.textContent) {
                 quickfixPlaceholderElement.textContent = String.fromCharCode(0xA0);
             }
@@ -197,7 +195,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 this.recentMarkerCodeActionsInfo = { marker: markerHover.marker, hasCodeActions: actions.validActions.length > 0 };
                 if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
                     actions.dispose();
-                    quickfixPlaceholderElement.textContent = ( localize(5121, "No quick fixes available"));
+                    quickfixPlaceholderElement.textContent = ( localize(5191, "No quick fixes available"));
                     return;
                 }
                 quickfixPlaceholderElement.style.display = 'none';
@@ -208,7 +206,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                     }
                 }));
                 context.statusBar.addAction({
-                    label: ( localize(5123, "Quick Fix...")),
+                    label: ( localize(5193, "Quick Fix...")),
                     commandId: quickFixCommandId,
                     run: (target) => {
                         showing = true;

package/vscode/src/vs/editor/contrib/hover/browser/resizableContentWidget.js

@@ -1,7 +1,5 @@
 import { ResizableHTMLElement } from '../../../../base/browser/ui/resizable/resizable.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { ContentWidgetPositionPreference } from '../../../browser/editorBrowser.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Position } from '../../../common/core/position.js';
 import { Dimension, getDomNodePagePosition, getClientArea } from '../../../../base/browser/dom.js';
 const TOP_HEIGHT = 30;
@@ -67,13 +65,13 @@ class ResizableContentWidget extends Disposable {
         const maxHeight = Math.min(Math.max(maxHeightAbove, maxHeightBelow), widgetHeight);
         const height = Math.min(widgetHeight, maxHeight);
         let renderingAbove;
-        if (this._editor.getOption(EditorOption.hover).above) {
-            renderingAbove = height <= maxHeightAbove ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW;
+        if (this._editor.getOption(62 ).above) {
+            renderingAbove = height <= maxHeightAbove ? 1  : 2 ;
         }
         else {
-            renderingAbove = height <= maxHeightBelow ? ContentWidgetPositionPreference.BELOW : ContentWidgetPositionPreference.ABOVE;
+            renderingAbove = height <= maxHeightBelow ? 2  : 1 ;
         }
-        if (renderingAbove === ContentWidgetPositionPreference.ABOVE) {
+        if (renderingAbove === 1 ) {
             this._resizableNode.enableSashes(true, true, false, false);
         }
         else {

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

@@ -1,16 +1,14 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { createCancelablePromise, timeout } from '../../../../base/common/async.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
-import { EditorState, CodeEditorStateFlag } from '../../editorState/browser/editorState.js';
-import { registerEditorContribution, registerEditorAction, EditorContributionInstantiation, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorState } from '../../editorState/browser/editorState.js';
+import { registerEditorContribution, registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
 import { Range } from '../../../common/core/range.js';
 import { Selection } from '../../../common/core/selection.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { IEditorWorkerService } from '../../../common/services/editorWorker.js';
 import { localize } from '../../../../nls.js';
-import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { InPlaceReplaceCommand } from './inPlaceReplaceCommand.js';
 import './inPlaceReplace.css.js';
 var InPlaceReplaceController_1;
@@ -42,7 +40,10 @@ let InPlaceReplaceController = class InPlaceReplaceController {
         if (selection.startLineNumber !== selection.endLineNumber) {
             return undefined;
         }
-        const state = ( (new EditorState(this.editor, CodeEditorStateFlag.Value | CodeEditorStateFlag.Position)));
+        const state = ( (new EditorState(
+            this.editor,
+            1  | 4
+        )));
         const modelURI = model.uri;
         if (!this.editorWorkerService.canNavigateValueSet(modelURI)) {
             return Promise.resolve(undefined);
@@ -93,13 +94,13 @@ class InPlaceReplaceUp extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.up',
-            label: ( localize(1346, "Replace with Previous Value")),
+            label: ( localize(1494, "Replace with Previous Value")),
             alias: 'Replace with Previous Value',
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Comma,
-                weight: KeybindingWeight.EditorContrib
+                primary: 2048  | 1024  | 87 ,
+                weight: 100
             }
         });
     }
@@ -115,13 +116,13 @@ class InPlaceReplaceDown extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.down',
-            label: ( localize(1347, "Replace with Next Value")),
+            label: ( localize(1495, "Replace with Next Value")),
             alias: 'Replace with Next Value',
             precondition: EditorContextKeys.writable,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Period,
-                weight: KeybindingWeight.EditorContrib
+                primary: 2048  | 1024  | 89 ,
+                weight: 100
             }
         });
     }
@@ -133,6 +134,6 @@ class InPlaceReplaceDown extends EditorAction {
         return controller.run(this.id, true);
     }
 }
-registerEditorContribution(InPlaceReplaceController.ID, InPlaceReplaceController, EditorContributionInstantiation.Lazy);
+registerEditorContribution(InPlaceReplaceController.ID, InPlaceReplaceController, 4 );
 registerEditorAction(InPlaceReplaceUp);
 registerEditorAction(InPlaceReplaceDown);