@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -1,26 +1,40 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, $ as $$1 } from '../../../../base/browser/dom.js';
-import { asArray } from '../../../../base/common/arrays.js';
-import { AsyncIterableObject } from '../../../../base/common/async.js';
+import { trackFocus, append, $ as $$1 } from '../../../../base/browser/dom.js';
+import { asArray, compareBy, numberComparator } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { MarkdownString, isEmptyMarkdownString } from '../../../../base/common/htmlContent.js';
-import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { MarkdownRenderer } from '../../../browser/widget/markdownRenderer/browser/markdownRenderer.js';
-import { Position } from '../../../common/core/position.js';
+import { INCREASE_HOVER_VERBOSITY_ACTION_ID, DECREASE_HOVER_VERBOSITY_ACTION_ID } from './hoverActionIds.js';
 import { Range } from '../../../common/core/range.js';
 import { ILanguageService } from '../../../common/languages/language.js';
-import { getHover } from './getHover.js';
 import { localizeWithPath } 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 { 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 } 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';
+const _moduleId = "vs/editor/contrib/hover/browser/markdownHoverParticipant";
 const $ = $$1;
+const increaseHoverVerbosityIcon = registerIcon('hover-increase-verbosity', Codicon.add, ( localizeWithPath(_moduleId, 0, 'Icon for increaseing hover verbosity.')));
+const decreaseHoverVerbosityIcon = registerIcon('hover-decrease-verbosity', Codicon.remove, ( localizeWithPath(_moduleId, 1, 'Icon for decreasing hover verbosity.')));
 class MarkdownHover {
-    constructor(owner, range, contents, isBeforeContent, ordinal) {
+    constructor(owner, range, contents, isBeforeContent, ordinal, source = undefined) {
         this.owner = owner;
         this.range = range;
         this.contents = contents;
         this.isBeforeContent = isBeforeContent;
         this.ordinal = ordinal;
+        this.source = source;
     }
     isValidForHoverAnchor(anchor) {
         return (anchor.type === 1
@@ -28,21 +42,42 @@ class MarkdownHover {
             && this.range.endColumn >= anchor.range.endColumn);
     }
 }
+class HoverSource {
+    constructor(hover, hoverProvider, hoverPosition) {
+        this.hover = hover;
+        this.hoverProvider = hoverProvider;
+        this.hoverPosition = hoverPosition;
+    }
+    supportsVerbosityAction(hoverVerbosityAction) {
+        switch (hoverVerbosityAction) {
+            case HoverVerbosityAction.Increase:
+                return this.hover.canIncreaseVerbosity ?? false;
+            case HoverVerbosityAction.Decrease:
+                return this.hover.canDecreaseVerbosity ?? false;
+        }
+    }
+}
 let MarkdownHoverParticipant = class MarkdownHoverParticipant {
-    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService) {
+    constructor(_editor, _languageService, _openerService, _configurationService, _languageFeaturesService, _keybindingService, _hoverService) {
         this._editor = _editor;
         this._languageService = _languageService;
         this._openerService = _openerService;
         this._configurationService = _configurationService;
         this._languageFeaturesService = _languageFeaturesService;
+        this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
         this.hoverOrdinal = 3;
     }
     createLoadingMessage(anchor) {
-        return ( new MarkdownHover(this, anchor.range, [( new MarkdownString()).appendText(( localizeWithPath(
-            'vs/editor/contrib/hover/browser/markdownHoverParticipant',
-            'modesContentHover.loading',
-            "Loading..."
-        )))], false, 2000));
+        return (
+             (new MarkdownHover(
+                this,
+                anchor.range,
+                [( (new MarkdownString())).appendText(( localizeWithPath(_moduleId, 2, "Loading...")))],
+                false,
+                2000
+            ))
+        );
     }
     computeSync(anchor, lineDecorations) {
         if (!this._editor.hasModel() || anchor.type !== 1 ) {
@@ -62,22 +97,22 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
         let stopRenderingMessage = false;
         if (stopRenderingLineAfter >= 0 && lineLength > stopRenderingLineAfter && anchor.range.startColumn >= stopRenderingLineAfter) {
             stopRenderingMessage = true;
-            result.push(( new MarkdownHover(this, anchor.range, [{
+            result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localizeWithPath(
-                        'vs/editor/contrib/hover/browser/markdownHoverParticipant',
-                        'stopped rendering',
+                        _moduleId,
+                        3,
                         "Rendering paused for long line for performance reasons. This can be configured via `editor.stopRenderingLineAfter`."
                     ))
-                }], false, index++)));
+                }], false, index++))));
         }
         if (!stopRenderingMessage && typeof maxTokenizationLineLength === 'number' && lineLength >= maxTokenizationLineLength) {
-            result.push(( new MarkdownHover(this, anchor.range, [{
+            result.push(( (new MarkdownHover(this, anchor.range, [{
                     value: ( localizeWithPath(
-                        'vs/editor/contrib/hover/browser/markdownHoverParticipant',
-                        'too many characters',
+                        _moduleId,
+                        4,
                         "Tokenization is skipped for long lines for performance reasons. This can be configured via `editor.maxTokenizationLineLength`."
                     ))
-                }], false, index++)));
+                }], false, index++))));
         }
         let isBeforeContent = false;
         for (const d of lineDecorations) {
@@ -90,13 +125,13 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             if (d.options.beforeContentClassName) {
                 isBeforeContent = true;
             }
-            const range = ( new Range(
+            const range = ( (new Range(
                 anchor.range.startLineNumber,
                 startColumn,
                 anchor.range.startLineNumber,
                 endColumn
-            ));
-            result.push(( new MarkdownHover(this, range, asArray(hoverMessage), isBeforeContent, index++)));
+            )));
+            result.push(( (new MarkdownHover(this, range, asArray(hoverMessage), isBeforeContent, index++))));
         }
         return result;
     }
@@ -105,47 +140,230 @@ let MarkdownHoverParticipant = class MarkdownHoverParticipant {
             return AsyncIterableObject.EMPTY;
         }
         const model = this._editor.getModel();
-        if (!( this._languageFeaturesService.hoverProvider.has(model))) {
+        const hoverProviderRegistry = this._languageFeaturesService.hoverProvider;
+        if (!( (hoverProviderRegistry.has(model)))) {
             return AsyncIterableObject.EMPTY;
         }
-        const position = ( new Position(anchor.range.startLineNumber, anchor.range.startColumn));
-        return ( getHover(this._languageFeaturesService.hoverProvider, model, position, token)
-            .filter(item => !isEmptyMarkdownString(item.hover.contents))
+        const markdownHovers = this._getMarkdownHovers(hoverProviderRegistry, model, anchor, token);
+        return markdownHovers;
+    }
+    _getMarkdownHovers(hoverProviderRegistry, model, anchor, token) {
+        const position = anchor.range.getStartPosition();
+        const hoverProviderResults = getHoverProviderResultsAsAsyncIterable(hoverProviderRegistry, model, position, token);
+        const markdownHovers = ( (hoverProviderResults.filter(item => !isEmptyMarkdownString(item.hover.contents))
             .map(item => {
-            const rng = item.hover.range ? Range.lift(item.hover.range) : anchor.range;
-            return ( new MarkdownHover(this, rng, item.hover.contents, false, item.ordinal));
-        }));
+            const range = item.hover.range ? Range.lift(item.hover.range) : anchor.range;
+            const hoverSource = ( (new HoverSource(item.hover, item.provider, position)));
+            return (
+                 (new MarkdownHover(this, range, item.hover.contents, false, item.ordinal, hoverSource))
+            );
+        })));
+        return markdownHovers;
     }
     renderHoverParts(context, hoverParts) {
-        return renderMarkdownHovers(context, hoverParts, this._editor, this._languageService, this._openerService);
+        this._renderedHoverParts = ( (new MarkdownRenderedHoverParts(
+            hoverParts,
+            context.fragment,
+            this._editor,
+            this._languageService,
+            this._openerService,
+            this._keybindingService,
+            this._hoverService,
+            this._configurationService,
+            context.onContentsChanged
+        )));
+        return this._renderedHoverParts;
+    }
+    updateFocusedMarkdownHoverPartVerbosityLevel(action) {
+        this._renderedHoverParts?.updateFocusedHoverPartVerbosityLevel(action);
     }
 };
-MarkdownHoverParticipant = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, ILanguageFeaturesService))
-], MarkdownHoverParticipant));
-function renderMarkdownHovers(context, hoverParts, editor, languageService, openerService) {
-    hoverParts.sort((a, b) => a.ordinal - b.ordinal);
-    const disposables = ( new DisposableStore());
-    for (const hoverPart of hoverParts) {
-        for (const contents of hoverPart.contents) {
-            if (isEmptyMarkdownString(contents)) {
-                continue;
+MarkdownHoverParticipant = ( (__decorate([
+    ( (__param(1, ILanguageService))),
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, ILanguageFeaturesService))),
+    ( (__param(5, IKeybindingService))),
+    ( (__param(6, IHoverService)))
+], MarkdownHoverParticipant)));
+class MarkdownRenderedHoverParts extends Disposable {
+    constructor(hoverParts,
+    hoverPartsContainer, _editor, _languageService, _openerService, _keybindingService, _hoverService, _configurationService, _onFinishedRendering) {
+        super();
+        this._editor = _editor;
+        this._languageService = _languageService;
+        this._openerService = _openerService;
+        this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
+        this._configurationService = _configurationService;
+        this._onFinishedRendering = _onFinishedRendering;
+        this._hoverFocusInfo = { hoverPartIndex: -1, focusRemains: false };
+        this._renderedHoverParts = this._renderHoverParts(hoverParts, hoverPartsContainer, this._onFinishedRendering);
+        this._register(toDisposable(() => {
+            this._renderedHoverParts.forEach(renderedHoverPart => {
+                renderedHoverPart.disposables.dispose();
+            });
+        }));
+    }
+    _renderHoverParts(hoverParts, hoverPartsContainer, onFinishedRendering) {
+        hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
+        return (
+             (hoverParts.map((hoverPart, hoverIndex) => {
+                const renderedHoverPart = this._renderHoverPart(hoverIndex, hoverPart.contents, hoverPart.source, onFinishedRendering);
+                hoverPartsContainer.appendChild(renderedHoverPart.renderedMarkdown);
+                return renderedHoverPart;
+            }))
+        );
+    }
+    _renderHoverPart(hoverPartIndex, hoverContents, hoverSource, onFinishedRendering) {
+        const { renderedMarkdown, disposables } = this._renderMarkdownContent(hoverContents, onFinishedRendering);
+        if (!hoverSource) {
+            return { renderedMarkdown, disposables };
+        }
+        const canIncreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Increase);
+        const canDecreaseVerbosity = hoverSource.supportsVerbosityAction(HoverVerbosityAction.Decrease);
+        if (!canIncreaseVerbosity && !canDecreaseVerbosity) {
+            return { renderedMarkdown, disposables, hoverSource };
+        }
+        const actionsContainer = $('div.verbosity-actions');
+        renderedMarkdown.prepend(actionsContainer);
+        disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Increase, canIncreaseVerbosity));
+        disposables.add(this._renderHoverExpansionAction(actionsContainer, HoverVerbosityAction.Decrease, canDecreaseVerbosity));
+        const focusTracker = disposables.add(trackFocus(renderedMarkdown));
+        disposables.add(focusTracker.onDidFocus(() => {
+            this._hoverFocusInfo = {
+                hoverPartIndex,
+                focusRemains: true
+            };
+        }));
+        disposables.add(focusTracker.onDidBlur(() => {
+            if (this._hoverFocusInfo?.focusRemains) {
+                this._hoverFocusInfo.focusRemains = false;
+                return;
             }
-            const markdownHoverElement = $('div.hover-row.markdown-hover');
-            const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-            const renderer = disposables.add(( new MarkdownRenderer({ editor }, languageService, openerService)));
-            disposables.add(renderer.onDidRenderAsync(() => {
-                hoverContentsElement.className = 'hover-contents code-hover-contents';
-                context.onContentsChanged();
-            }));
-            const renderedContents = disposables.add(renderer.render(contents));
-            hoverContentsElement.appendChild(renderedContents.element);
-            context.fragment.appendChild(markdownHoverElement);
+        }));
+        return { renderedMarkdown, disposables, hoverSource };
+    }
+    _renderMarkdownContent(markdownContent, onFinishedRendering) {
+        const renderedMarkdown = $('div.hover-row');
+        renderedMarkdown.tabIndex = 0;
+        const renderedMarkdownContents = $('div.hover-row-contents');
+        renderedMarkdown.appendChild(renderedMarkdownContents);
+        const disposables = ( (new DisposableStore()));
+        disposables.add(renderMarkdownInContainer(this._editor, renderedMarkdownContents, markdownContent, this._languageService, this._openerService, onFinishedRendering));
+        return { renderedMarkdown, disposables };
+    }
+    _renderHoverExpansionAction(container, action, actionEnabled) {
+        const store = ( (new DisposableStore()));
+        const isActionIncrease = action === HoverVerbosityAction.Increase;
+        const actionElement = append(container, $(ThemeIcon.asCSSSelector(isActionIncrease ? increaseHoverVerbosityIcon : decreaseHoverVerbosityIcon)));
+        actionElement.tabIndex = 0;
+        const hoverDelegate = ( (new WorkbenchHoverDelegate(
+            'mouse',
+            false,
+            { target: container, position: { hoverPosition: 0  } },
+            this._configurationService,
+            this._hoverService
+        )));
+        if (isActionIncrease) {
+            const kb = this._keybindingService.lookupKeybinding(INCREASE_HOVER_VERBOSITY_ACTION_ID);
+            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
+                ( localizeWithPath(_moduleId, 5, "Increase Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 6, "Increase Verbosity"))));
+        }
+        else {
+            const kb = this._keybindingService.lookupKeybinding(DECREASE_HOVER_VERBOSITY_ACTION_ID);
+            store.add(this._hoverService.setupUpdatableHover(hoverDelegate, actionElement, kb ?
+                ( localizeWithPath(_moduleId, 7, "Decrease Verbosity ({0})", kb.getLabel())) :
+                ( localizeWithPath(_moduleId, 8, "Decrease Verbosity"))));
+        }
+        if (!actionEnabled) {
+            actionElement.classList.add('disabled');
+            return store;
+        }
+        actionElement.classList.add('enabled');
+        const actionFunction = () => this.updateFocusedHoverPartVerbosityLevel(action);
+        store.add(( (new ClickAction(actionElement, actionFunction))));
+        store.add(( (new KeyDownAction(
+            actionElement,
+            actionFunction,
+            [3 , 10 ]
+        ))));
+        return store;
+    }
+    async updateFocusedHoverPartVerbosityLevel(action) {
+        const model = this._editor.getModel();
+        if (!model) {
+            return;
+        }
+        const hoverFocusedPartIndex = this._hoverFocusInfo.hoverPartIndex;
+        const hoverRenderedPart = this._getRenderedHoverPartAtIndex(hoverFocusedPartIndex);
+        if (!hoverRenderedPart || !hoverRenderedPart.hoverSource?.supportsVerbosityAction(action)) {
+            return;
+        }
+        const hoverPosition = hoverRenderedPart.hoverSource.hoverPosition;
+        const hoverProvider = hoverRenderedPart.hoverSource.hoverProvider;
+        const hover = hoverRenderedPart.hoverSource.hover;
+        const hoverContext = { verbosityRequest: { action, previousHover: hover } };
+        let newHover;
+        try {
+            newHover = await Promise.resolve(hoverProvider.provideHover(model, hoverPosition, CancellationToken.None, hoverContext));
         }
+        catch (e) {
+            onUnexpectedExternalError(e);
+        }
+        if (!newHover) {
+            return;
+        }
+        const hoverSource = ( (new HoverSource(newHover, hoverProvider, hoverPosition)));
+        const renderedHoverPart = this._renderHoverPart(hoverFocusedPartIndex, newHover.contents, hoverSource, this._onFinishedRendering);
+        this._replaceRenderedHoverPartAtIndex(hoverFocusedPartIndex, renderedHoverPart);
+        this._focusOnHoverPartWithIndex(hoverFocusedPartIndex);
+        this._onFinishedRendering();
+    }
+    _replaceRenderedHoverPartAtIndex(index, renderedHoverPart) {
+        if (index >= this._renderHoverParts.length || index < 0) {
+            return;
+        }
+        const currentRenderedHoverPart = this._renderedHoverParts[index];
+        const currentRenderedMarkdown = currentRenderedHoverPart.renderedMarkdown;
+        currentRenderedMarkdown.replaceWith(renderedHoverPart.renderedMarkdown);
+        currentRenderedHoverPart.disposables.dispose();
+        this._renderedHoverParts[index] = renderedHoverPart;
+    }
+    _focusOnHoverPartWithIndex(index) {
+        this._renderedHoverParts[index].renderedMarkdown.focus();
+        this._hoverFocusInfo.focusRemains = true;
+    }
+    _getRenderedHoverPartAtIndex(index) {
+        return this._renderedHoverParts[index];
+    }
+}
+function renderMarkdownHovers(context, hoverParts, editor, languageService, openerService) {
+    hoverParts.sort(compareBy(hover => hover.ordinal, numberComparator));
+    const disposables = ( (new DisposableStore()));
+    for (const hoverPart of hoverParts) {
+        disposables.add(renderMarkdownInContainer(editor, context.fragment, hoverPart.contents, languageService, openerService, context.onContentsChanged));
     }
     return disposables;
 }
+function renderMarkdownInContainer(editor, container, markdownStrings, languageService, openerService, onFinishedRendering) {
+    const store = ( (new DisposableStore()));
+    for (const contents of markdownStrings) {
+        if (isEmptyMarkdownString(contents)) {
+            continue;
+        }
+        const markdownHoverElement = $('div.markdown-hover');
+        const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
+        const renderer = store.add(( (new MarkdownRenderer({ editor }, languageService, openerService))));
+        store.add(renderer.onDidRenderAsync(() => {
+            hoverContentsElement.className = 'hover-contents code-hover-contents';
+            onFinishedRendering();
+        }));
+        const renderedContents = store.add(renderer.render(contents));
+        hoverContentsElement.appendChild(renderedContents.element);
+        container.appendChild(markdownHoverElement);
+    }
+    return store;
+}
 export { MarkdownHover, MarkdownHoverParticipant, renderMarkdownHovers };

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

@@ -16,6 +16,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { MarkerSeverity, IMarkerData } from '../../../../platform/markers/common/markers.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { Progress } from '../../../../platform/progress/common/progress.js';
+const _moduleId = "vs/editor/contrib/hover/browser/markerHoverParticipant";
 const $ = $$1;
 class MarkerHover {
     constructor(owner, range, marker) {
@@ -58,13 +59,13 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             if (!marker) {
                 continue;
             }
-            const range = ( new Range(
+            const range = ( (new Range(
                 anchor.range.startLineNumber,
                 startColumn,
                 anchor.range.startLineNumber,
                 endColumn
-            ));
-            result.push(( new MarkerHover(this, range, marker)));
+            )));
+            result.push(( (new MarkerHover(this, range, marker))));
         }
         return result;
     }
@@ -72,7 +73,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
         if (!hoverParts.length) {
             return Disposable.None;
         }
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         hoverParts.forEach(msg => context.fragment.appendChild(this.renderMarkerHover(msg, disposables)));
         const markerHoverForStatusbar = hoverParts.length === 1 ? hoverParts[0] : hoverParts.sort((a, b) => MarkerSeverity.compare(a.marker.severity, b.marker.severity))[0];
         this.renderMarkerStatusbar(context, markerHoverForStatusbar, disposables);
@@ -80,6 +81,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
     }
     renderMarkerHover(markerHover, disposables) {
         const hoverElement = $('div.hover-row');
+        hoverElement.tabIndex = 0;
         const markerElement = append(hoverElement, $('div.marker.hover-contents'));
         const { source, message, code, relatedInformation } = markerHover.marker;
         this._editor.applyFontInfo(markerElement);
@@ -94,7 +96,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())));
                 disposables.add(addDisposableListener(codeLink, 'click', (e) => {
                     this._openerService.open(code.target, { allowCommands: true });
                     e.preventDefault();
@@ -142,11 +144,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             const markerController = MarkerController.get(this._editor);
             if (markerController) {
                 context.statusBar.addAction({
-                    label: ( localizeWithPath(
-                        'vs/editor/contrib/hover/browser/markerHoverParticipant',
-                        'view problem',
-                        "View Problem"
-                    )),
+                    label: ( localizeWithPath(_moduleId, 0, "View Problem")),
                     commandId: NextMarkerAction.ID,
                     run: () => {
                         context.hide();
@@ -161,22 +159,14 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
             if (this.recentMarkerCodeActionsInfo) {
                 if (IMarkerData.makeKey(this.recentMarkerCodeActionsInfo.marker) === IMarkerData.makeKey(markerHover.marker)) {
                     if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
-                        quickfixPlaceholderElement.textContent = ( localizeWithPath(
-                            'vs/editor/contrib/hover/browser/markerHoverParticipant',
-                            'noQuickFixes',
-                            "No quick fixes available"
-                        ));
+                        quickfixPlaceholderElement.textContent = ( localizeWithPath(_moduleId, 1, "No quick fixes available"));
                     }
                 }
                 else {
                     this.recentMarkerCodeActionsInfo = undefined;
                 }
             }
-            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localizeWithPath(
-                'vs/editor/contrib/hover/browser/markerHoverParticipant',
-                'checkingForQuickFixes',
-                "Checking for quick fixes..."
-            )), 200, disposables);
+            const updatePlaceholderDisposable = this.recentMarkerCodeActionsInfo && !this.recentMarkerCodeActionsInfo.hasCodeActions ? Disposable.None : disposableTimeout(() => quickfixPlaceholderElement.textContent = ( localizeWithPath(_moduleId, 2, "Checking for quick fixes...")), 200, disposables);
             if (!quickfixPlaceholderElement.textContent) {
                 quickfixPlaceholderElement.textContent = String.fromCharCode(0xA0);
             }
@@ -187,11 +177,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                 this.recentMarkerCodeActionsInfo = { marker: markerHover.marker, hasCodeActions: actions.validActions.length > 0 };
                 if (!this.recentMarkerCodeActionsInfo.hasCodeActions) {
                     actions.dispose();
-                    quickfixPlaceholderElement.textContent = ( localizeWithPath(
-                        'vs/editor/contrib/hover/browser/markerHoverParticipant',
-                        'noQuickFixes',
-                        "No quick fixes available"
-                    ));
+                    quickfixPlaceholderElement.textContent = ( localizeWithPath(_moduleId, 1, "No quick fixes available"));
                     return;
                 }
                 quickfixPlaceholderElement.style.display = 'none';
@@ -202,11 +188,7 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
                     }
                 }));
                 context.statusBar.addAction({
-                    label: ( localizeWithPath(
-                        'vs/editor/contrib/hover/browser/markerHoverParticipant',
-                        'quick fixes',
-                        "Quick Fix..."
-                    )),
+                    label: ( localizeWithPath(_moduleId, 3, "Quick Fix...")),
                     commandId: quickFixCommandId,
                     run: (target) => {
                         showing = true;
@@ -226,18 +208,18 @@ let MarkerHoverParticipant = class MarkerHoverParticipant {
     }
     getCodeActions(marker) {
         return createCancelablePromise(cancellationToken => {
-            return getCodeActions(this._languageFeaturesService.codeActionProvider, this._editor.getModel(), ( new Range(
+            return getCodeActions(this._languageFeaturesService.codeActionProvider, this._editor.getModel(), ( (new Range(
                 marker.startLineNumber,
                 marker.startColumn,
                 marker.endLineNumber,
                 marker.endColumn
-            )), markerCodeActionTrigger, Progress.None, cancellationToken);
+            ))), markerCodeActionTrigger, Progress.None, cancellationToken);
         });
     }
 };
-MarkerHoverParticipant = ( __decorate([
-    ( __param(1, IMarkerDecorationsService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, ILanguageFeaturesService))
-], MarkerHoverParticipant));
+MarkerHoverParticipant = ( (__decorate([
+    ( (__param(1, IMarkerDecorationsService))),
+    ( (__param(2, IOpenerService))),
+    ( (__param(3, ILanguageFeaturesService)))
+], MarkerHoverParticipant)));
 export { MarkerHover, MarkerHoverParticipant };

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

@@ -12,6 +12,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { InPlaceReplaceCommand } from './inPlaceReplaceCommand.js';
 import './inPlaceReplace.css.js';
 var InPlaceReplaceController_1;
+const _moduleId = "vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace";
 let InPlaceReplaceController = class InPlaceReplaceController {
     static { InPlaceReplaceController_1 = this; }
     static { this.ID = 'editor.contrib.inPlaceReplaceController'; }
@@ -40,10 +41,10 @@ let InPlaceReplaceController = class InPlaceReplaceController {
         if (selection.startLineNumber !== selection.endLineNumber) {
             return undefined;
         }
-        const state = ( new EditorState(
+        const state = ( (new EditorState(
             this.editor,
             1  | 4
-        ));
+        )));
         const modelURI = model.uri;
         if (!this.editorWorkerService.canNavigateValueSet(modelURI)) {
             return Promise.resolve(undefined);
@@ -66,14 +67,14 @@ let InPlaceReplaceController = class InPlaceReplaceController {
                 endColumn: highlightRange.startColumn + result.value.length
             };
             if (diff > 1) {
-                selection = ( new Selection(
+                selection = ( (new Selection(
                     selection.startLineNumber,
                     selection.startColumn,
                     selection.endLineNumber,
                     selection.endColumn + diff - 1
-                ));
+                )));
             }
-            const command = ( new InPlaceReplaceCommand(editRange, selection, result.value));
+            const command = ( (new InPlaceReplaceCommand(editRange, selection, result.value)));
             this.editor.pushUndoStop();
             this.editor.executeCommand(source, command);
             this.editor.pushUndoStop();
@@ -87,18 +88,14 @@ let InPlaceReplaceController = class InPlaceReplaceController {
         }).catch(onUnexpectedError);
     }
 };
-InPlaceReplaceController = InPlaceReplaceController_1 = ( __decorate([
-    ( __param(1, IEditorWorkerService))
-], InPlaceReplaceController));
+InPlaceReplaceController = InPlaceReplaceController_1 = ( (__decorate([
+    ( (__param(1, IEditorWorkerService)))
+], InPlaceReplaceController)));
 class InPlaceReplaceUp extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.up',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace',
-                'InPlaceReplaceAction.previous.label',
-                "Replace with Previous Value"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Replace with Previous Value")),
             alias: 'Replace with Previous Value',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -120,11 +117,7 @@ class InPlaceReplaceDown extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.inPlaceReplace.down',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace',
-                'InPlaceReplaceAction.next.label',
-                "Replace with Next Value"
-            )),
+            label: ( localizeWithPath(_moduleId, 1, "Replace with Next Value")),
             alias: 'Replace with Next Value',
             precondition: EditorContextKeys.writable,
             kbOpts: {