@codingame/monaco-vscode-api 4.5.1 → 5.0.0

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

@@ -21,24 +21,27 @@ import { Schemas } from '../../../../base/common/network.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { score } from '../../../common/languageSelector.js';
 var WordHighlighter_1, WordHighlighterContribution_1;
-const ctxHasWordHighlights = ( new RawContextKey('hasWordHighlights', false));
+const _moduleId = "vs/editor/contrib/wordHighlighter/browser/wordHighlighter";
+const ctxHasWordHighlights = ( (new RawContextKey('hasWordHighlights', false)));
 function getOccurrencesAtPosition(registry, model, position, token) {
     const orderedByScore = registry.ordered(model);
-    return first(( orderedByScore.map(provider => () => {
+    return first(( (orderedByScore.map(provider => () => {
         return Promise.resolve(provider.provideDocumentHighlights(model, position, token))
             .then(undefined, onUnexpectedExternalError);
-    })), isNonEmptyArray).then(result => {
+    }))), isNonEmptyArray).then(result => {
         if (result) {
-            const map = ( new ResourceMap());
+            const map = ( (new ResourceMap()));
             map.set(model.uri, result);
             return map;
         }
-        return ( new ResourceMap());
+        return (
+             (new ResourceMap())
+        );
     });
 }
 function getOccurrencesAcrossMultipleModels(registry, model, position, wordSeparators, token, otherModels) {
     const orderedByScore = registry.ordered(model);
-    return first(( orderedByScore.map(provider => () => {
+    return first(( (orderedByScore.map(provider => () => {
         const filteredModels = otherModels.filter(otherModel => {
             return shouldSynchronizeModel(otherModel);
         }).filter(otherModel => {
@@ -46,7 +49,7 @@ function getOccurrencesAcrossMultipleModels(registry, model, position, wordSepar
         });
         return Promise.resolve(provider.provideMultiDocumentHighlights(model, position, filteredModels, token))
             .then(undefined, onUnexpectedExternalError);
-    })), (t) => t instanceof ResourceMap && t.size > 0);
+    }))), (t) => t instanceof ResourceMap && t.size > 0);
 }
 class OccurenceAtPositionRequest {
     constructor(_model, _selection, _wordSeparators) {
@@ -65,12 +68,14 @@ class OccurenceAtPositionRequest {
     _getCurrentWordRange(model, selection) {
         const word = model.getWordAtPosition(selection.getPosition());
         if (word) {
-            return ( new Range(
-                selection.startLineNumber,
-                word.startColumn,
-                selection.startLineNumber,
-                word.endColumn
-            ));
+            return (
+                 (new Range(
+                    selection.startLineNumber,
+                    word.startColumn,
+                    selection.startLineNumber,
+                    word.endColumn
+                ))
+            );
         }
         return null;
     }
@@ -102,7 +107,9 @@ class SemanticOccurenceAtPositionRequest extends OccurenceAtPositionRequest {
     _compute(model, selection, wordSeparators, token) {
         return getOccurrencesAtPosition(this._providers, model, selection.getPosition(), token).then(value => {
             if (!value) {
-                return ( new ResourceMap());
+                return (
+                     (new ResourceMap())
+                );
             }
             return value;
         });
@@ -117,7 +124,9 @@ class MultiModelOccurenceRequest extends OccurenceAtPositionRequest {
     _compute(model, selection, wordSeparators, token) {
         return getOccurrencesAcrossMultipleModels(this._providers, model, selection.getPosition(), wordSeparators, token, this._otherModels).then(value => {
             if (!value) {
-                return ( new ResourceMap());
+                return (
+                     (new ResourceMap())
+                );
             }
             return value;
         });
@@ -132,7 +141,7 @@ class TextualOccurenceRequest extends OccurenceAtPositionRequest {
     }
     _compute(model, selection, wordSeparators, token) {
         return timeout(250, token).then(() => {
-            const result = ( new ResourceMap());
+            const result = ( (new ResourceMap()));
             let wordResult;
             if (this._word) {
                 wordResult = this._word;
@@ -141,7 +150,9 @@ class TextualOccurenceRequest extends OccurenceAtPositionRequest {
                 wordResult = model.getWordAtPosition(selection.getPosition());
             }
             if (!wordResult) {
-                return ( new ResourceMap());
+                return (
+                     (new ResourceMap())
+                );
             }
             const allModels = [model, ...this._otherModels];
             for (const otherModel of allModels) {
@@ -149,10 +160,10 @@ class TextualOccurenceRequest extends OccurenceAtPositionRequest {
                     continue;
                 }
                 const matches = otherModel.findMatches(wordResult.word, true, false, true, wordSeparators, false);
-                const highlights = ( matches.map(m => ({
+                const highlights = ( (matches.map(m => ({
                     range: m.range,
                     kind: DocumentHighlightKind.Text
-                })));
+                }))));
                 if (highlights) {
                     result.set(otherModel.uri, highlights);
                 }
@@ -169,16 +180,24 @@ class TextualOccurenceRequest extends OccurenceAtPositionRequest {
     }
 }
 function computeOccurencesAtPosition(registry, model, selection, word, wordSeparators) {
-    if (( registry.has(model))) {
-        return ( new SemanticOccurenceAtPositionRequest(model, selection, wordSeparators, registry));
-    }
-    return ( new TextualOccurenceRequest(model, selection, word, wordSeparators, []));
+    if (( (registry.has(model)))) {
+        return (
+             (new SemanticOccurenceAtPositionRequest(model, selection, wordSeparators, registry))
+        );
+    }
+    return (
+         (new TextualOccurenceRequest(model, selection, word, wordSeparators, []))
+    );
 }
 function computeOccurencesMultiModel(registry, model, selection, word, wordSeparators, otherModels) {
-    if (( registry.has(model))) {
-        return ( new MultiModelOccurenceRequest(model, selection, wordSeparators, registry, otherModels));
-    }
-    return ( new TextualOccurenceRequest(model, selection, word, wordSeparators, otherModels));
+    if (( (registry.has(model)))) {
+        return (
+             (new MultiModelOccurenceRequest(model, selection, wordSeparators, registry, otherModels))
+        );
+    }
+    return (
+         (new TextualOccurenceRequest(model, selection, word, wordSeparators, otherModels))
+    );
 }
 registerModelAndPositionCommand('_executeDocumentHighlights', async (accessor, model, position) => {
     const languageFeaturesService = accessor.get(ILanguageFeaturesService);
@@ -187,13 +206,13 @@ registerModelAndPositionCommand('_executeDocumentHighlights', async (accessor, m
 });
 let WordHighlighter = class WordHighlighter {
     static { WordHighlighter_1 = this; }
-    static { this.storedDecorations = ( new ResourceMap()); }
+    static { this.storedDecorations = ( (new ResourceMap())); }
     static { this.query = null; }
     constructor(editor, providers, multiProviders, contextKeyService, codeEditorService) {
-        this.toUnhook = ( new DisposableStore());
+        this.toUnhook = ( (new DisposableStore()));
         this.workerRequestTokenId = 0;
         this.workerRequestCompleted = false;
-        this.workerRequestValue = ( new ResourceMap());
+        this.workerRequestValue = ( (new ResourceMap()));
         this.lastCursorPositionChangeTime = 0;
         this.renderDecorationsTimer = -1;
         this.editor = editor;
@@ -491,7 +510,7 @@ let WordHighlighter = class WordHighlighter {
                 word: word
             };
         }
-        this.lastCursorPositionChangeTime = (( new Date())).getTime();
+        this.lastCursorPositionChangeTime = (( (new Date()))).getTime();
         if (workerRequestIsValid) {
             if (this.workerRequestCompleted && this.renderDecorationsTimer !== -1) {
                 clearTimeout(this.renderDecorationsTimer);
@@ -526,7 +545,7 @@ let WordHighlighter = class WordHighlighter {
         }
     }
     _beginRenderDecorations() {
-        const currentTime = (( new Date())).getTime();
+        const currentTime = (( (new Date()))).getTime();
         const minimumRenderTime = this.lastCursorPositionChangeTime + 250;
         if (currentTime >= minimumRenderTime) {
             this.renderDecorationsTimer = -1;
@@ -548,7 +567,7 @@ let WordHighlighter = class WordHighlighter {
             }
             const newDecorations = [];
             const uri = editor.getModel()?.uri;
-            if (uri && ( this.workerRequestValue.has(uri))) {
+            if (uri && ( (this.workerRequestValue.has(uri)))) {
                 const oldDecorationIDs = WordHighlighter_1.storedDecorations.get(uri);
                 const newDocumentHighlights = this.workerRequestValue.get(uri);
                 if (newDocumentHighlights) {
@@ -579,9 +598,9 @@ let WordHighlighter = class WordHighlighter {
         this.toUnhook.dispose();
     }
 };
-WordHighlighter = WordHighlighter_1 = ( __decorate([
-    ( __param(4, ICodeEditorService))
-], WordHighlighter));
+WordHighlighter = WordHighlighter_1 = ( (__decorate([
+    ( (__param(4, ICodeEditorService)))
+], WordHighlighter)));
 let WordHighlighterContribution = class WordHighlighterContribution extends Disposable {
     static { WordHighlighterContribution_1 = this; }
     static { this.ID = 'editor.contrib.wordHighlighter'; }
@@ -593,13 +612,13 @@ let WordHighlighterContribution = class WordHighlighterContribution extends Disp
         this._wordHighlighter = null;
         const createWordHighlighterIfPossible = () => {
             if (editor.hasModel() && !editor.getModel().isTooLargeForTokenization()) {
-                this._wordHighlighter = ( new WordHighlighter(
+                this._wordHighlighter = ( (new WordHighlighter(
                     editor,
                     languageFeaturesService.documentHighlightProvider,
                     languageFeaturesService.multiDocumentHighlightProvider,
                     contextKeyService,
                     codeEditorService
-                ));
+                )));
             }
         };
         this._register(editor.onDidChangeModel((e) => {
@@ -642,11 +661,11 @@ let WordHighlighterContribution = class WordHighlighterContribution extends Disp
         super.dispose();
     }
 };
-WordHighlighterContribution = WordHighlighterContribution_1 = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, ILanguageFeaturesService)),
-    ( __param(3, ICodeEditorService))
-], WordHighlighterContribution));
+WordHighlighterContribution = WordHighlighterContribution_1 = ( (__decorate([
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, ILanguageFeaturesService))),
+    ( (__param(3, ICodeEditorService)))
+], WordHighlighterContribution)));
 class WordHighlightNavigationAction extends EditorAction {
     constructor(next, opts) {
         super(opts);
@@ -669,11 +688,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/wordHighlighter/browser/wordHighlighter',
-                'wordHighlight.next.label',
-                "Go to Next Symbol Highlight"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Go to Next Symbol Highlight")),
             alias: 'Go to Next Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -688,11 +703,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/wordHighlighter/browser/wordHighlighter',
-                'wordHighlight.previous.label',
-                "Go to Previous Symbol Highlight"
-            )),
+            label: ( localizeWithPath(_moduleId, 1, "Go to Previous Symbol Highlight")),
             alias: 'Go to Previous Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -707,13 +718,9 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/wordHighlighter/browser/wordHighlighter',
-                'wordHighlight.trigger.label',
-                "Trigger Symbol Highlight"
-            )),
+            label: ( localizeWithPath(_moduleId, 2, "Trigger Symbol Highlight")),
             alias: 'Trigger Symbol Highlight',
-            precondition: ( ctxHasWordHighlights.toNegated()),
+            precondition: ( (ctxHasWordHighlights.toNegated())),
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
                 primary: 0,

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

@@ -13,6 +13,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '../../../../platform/accessibility/common/accessibility.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { IsWindowsContext } from '../../../../platform/contextkey/common/contextkeys.js';
+const _moduleId = "vs/editor/contrib/wordOperations/browser/wordOperations";
 class MoveWordCommand extends EditorCommand {
     constructor(opts) {
         super(opts);
@@ -26,29 +27,33 @@ class MoveWordCommand extends EditorCommand {
         const wordSeparators = getMapForWordSeparators(editor.getOption(131 ), editor.getOption(130 ));
         const model = editor.getModel();
         const selections = editor.getSelections();
-        const result = ( selections.map((sel) => {
-            const inPosition = ( new Position(sel.positionLineNumber, sel.positionColumn));
+        const result = ( (selections.map((sel) => {
+            const inPosition = ( (new Position(sel.positionLineNumber, sel.positionColumn)));
             const outPosition = this._move(wordSeparators, model, inPosition, this._wordNavigationType);
             return this._moveTo(sel, outPosition, this._inSelectionMode);
-        }));
+        })));
         model.pushStackElement();
-        editor._getViewModel().setCursorStates('moveWordCommand', 3 , ( result.map(r => CursorState.fromModelSelection(r))));
+        editor._getViewModel().setCursorStates('moveWordCommand', 3 , ( (result.map(r => CursorState.fromModelSelection(r)))));
         if (result.length === 1) {
-            const pos = ( new Position(result[0].positionLineNumber, result[0].positionColumn));
+            const pos = ( (new Position(result[0].positionLineNumber, result[0].positionColumn)));
             editor.revealPosition(pos, 0 );
         }
     }
     _moveTo(from, to, inSelectionMode) {
         if (inSelectionMode) {
-            return ( new Selection(
-                from.selectionStartLineNumber,
-                from.selectionStartColumn,
-                to.lineNumber,
-                to.column
-            ));
+            return (
+                 (new Selection(
+                    from.selectionStartLineNumber,
+                    from.selectionStartColumn,
+                    to.lineNumber,
+                    to.column
+                ))
+            );
         }
         else {
-            return ( new Selection(to.lineNumber, to.column, to.lineNumber, to.column));
+            return (
+                 (new Selection(to.lineNumber, to.column, to.lineNumber, to.column))
+            );
         }
     }
 }
@@ -90,7 +95,10 @@ class CursorWordLeft extends WordLeftCommand {
             id: 'cursorWordLeft',
             precondition: undefined,
             kbOpts: {
-                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext))?.negate())),
+                kbExpr: ( (ContextKeyExpr.and(
+                    EditorContextKeys.textInputFocus,
+                    ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext)))?.negate()
+                ))),
                 primary: 2048  | 15 ,
                 mac: { primary: 512  | 15  },
                 weight: 100
@@ -126,7 +134,10 @@ class CursorWordLeftSelect extends WordLeftCommand {
             id: 'cursorWordLeftSelect',
             precondition: undefined,
             kbOpts: {
-                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext))?.negate())),
+                kbExpr: ( (ContextKeyExpr.and(
+                    EditorContextKeys.textInputFocus,
+                    ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext)))?.negate()
+                ))),
                 primary: 2048  | 1024  | 15 ,
                 mac: { primary: 512  | 1024  | 15  },
                 weight: 100
@@ -178,7 +189,10 @@ class CursorWordEndRight extends WordRightCommand {
             id: 'cursorWordEndRight',
             precondition: undefined,
             kbOpts: {
-                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext))?.negate())),
+                kbExpr: ( (ContextKeyExpr.and(
+                    EditorContextKeys.textInputFocus,
+                    ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext)))?.negate()
+                ))),
                 primary: 2048  | 17 ,
                 mac: { primary: 512  | 17  },
                 weight: 100
@@ -214,7 +228,10 @@ class CursorWordEndRightSelect extends WordRightCommand {
             id: 'cursorWordEndRightSelect',
             precondition: undefined,
             kbOpts: {
-                kbExpr: ( ContextKeyExpr.and(EditorContextKeys.textInputFocus, ( ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext))?.negate())),
+                kbExpr: ( (ContextKeyExpr.and(
+                    EditorContextKeys.textInputFocus,
+                    ( (ContextKeyExpr.and(CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext)))?.negate()
+                ))),
                 primary: 2048  | 1024  | 17 ,
                 mac: { primary: 512  | 1024  | 17  },
                 weight: 100
@@ -276,7 +293,7 @@ class DeleteWordCommand extends EditorCommand {
         const autoClosingQuotes = editor.getOption(11 );
         const autoClosingPairs = languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getAutoClosingPairs();
         const viewModel = editor._getViewModel();
-        const commands = ( selections.map((sel) => {
+        const commands = ( (selections.map((sel) => {
             const deleteRange = this._delete({
                 wordSeparators,
                 model,
@@ -288,8 +305,10 @@ class DeleteWordCommand extends EditorCommand {
                 autoClosingPairs,
                 autoClosedCharacters: viewModel.getCursorAutoClosedCharacters(),
             }, this._wordNavigationType);
-            return ( new ReplaceCommand(deleteRange, ''));
-        }));
+            return (
+                 (new ReplaceCommand(deleteRange, ''))
+            );
+        })));
         editor.pushUndoStop();
         editor.executeCommands(this.id, commands);
         editor.pushUndoStop();
@@ -301,7 +320,9 @@ class DeleteWordLeftCommand extends DeleteWordCommand {
         if (r) {
             return r;
         }
-        return ( new Range(1, 1, 1, 1));
+        return (
+             (new Range(1, 1, 1, 1))
+        );
     }
 }
 class DeleteWordRightCommand extends DeleteWordCommand {
@@ -312,7 +333,9 @@ class DeleteWordRightCommand extends DeleteWordCommand {
         }
         const lineCount = ctx.model.getLineCount();
         const maxColumn = ctx.model.getLineMaxColumn(lineCount);
-        return ( new Range(lineCount, maxColumn, lineCount, maxColumn));
+        return (
+             (new Range(lineCount, maxColumn, lineCount, maxColumn))
+        );
     }
 }
 class DeleteWordStartLeft extends DeleteWordLeftCommand {
@@ -392,11 +415,7 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/wordOperations/browser/wordOperations',
-                'deleteInsideWord',
-                "Delete Word"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Delete Word")),
             alias: 'Delete Word'
         });
     }
@@ -407,36 +426,38 @@ class DeleteInsideWord extends EditorAction {
         const wordSeparators = getMapForWordSeparators(editor.getOption(131 ), editor.getOption(130 ));
         const model = editor.getModel();
         const selections = editor.getSelections();
-        const commands = ( selections.map((sel) => {
+        const commands = ( (selections.map((sel) => {
             const deleteRange = WordOperations.deleteInsideWord(wordSeparators, model, sel);
-            return ( new ReplaceCommand(deleteRange, ''));
-        }));
+            return (
+                 (new ReplaceCommand(deleteRange, ''))
+            );
+        })));
         editor.pushUndoStop();
         editor.executeCommands(this.id, commands);
         editor.pushUndoStop();
     }
 }
-registerEditorCommand(( new CursorWordStartLeft()));
-registerEditorCommand(( new CursorWordEndLeft()));
-registerEditorCommand(( new CursorWordLeft()));
-registerEditorCommand(( new CursorWordStartLeftSelect()));
-registerEditorCommand(( new CursorWordEndLeftSelect()));
-registerEditorCommand(( new CursorWordLeftSelect()));
-registerEditorCommand(( new CursorWordStartRight()));
-registerEditorCommand(( new CursorWordEndRight()));
-registerEditorCommand(( new CursorWordRight()));
-registerEditorCommand(( new CursorWordStartRightSelect()));
-registerEditorCommand(( new CursorWordEndRightSelect()));
-registerEditorCommand(( new CursorWordRightSelect()));
-registerEditorCommand(( new CursorWordAccessibilityLeft()));
-registerEditorCommand(( new CursorWordAccessibilityLeftSelect()));
-registerEditorCommand(( new CursorWordAccessibilityRight()));
-registerEditorCommand(( new CursorWordAccessibilityRightSelect()));
-registerEditorCommand(( new DeleteWordStartLeft()));
-registerEditorCommand(( new DeleteWordEndLeft()));
-registerEditorCommand(( new DeleteWordLeft()));
-registerEditorCommand(( new DeleteWordStartRight()));
-registerEditorCommand(( new DeleteWordEndRight()));
-registerEditorCommand(( new DeleteWordRight()));
+registerEditorCommand(( (new CursorWordStartLeft())));
+registerEditorCommand(( (new CursorWordEndLeft())));
+registerEditorCommand(( (new CursorWordLeft())));
+registerEditorCommand(( (new CursorWordStartLeftSelect())));
+registerEditorCommand(( (new CursorWordEndLeftSelect())));
+registerEditorCommand(( (new CursorWordLeftSelect())));
+registerEditorCommand(( (new CursorWordStartRight())));
+registerEditorCommand(( (new CursorWordEndRight())));
+registerEditorCommand(( (new CursorWordRight())));
+registerEditorCommand(( (new CursorWordStartRightSelect())));
+registerEditorCommand(( (new CursorWordEndRightSelect())));
+registerEditorCommand(( (new CursorWordRightSelect())));
+registerEditorCommand(( (new CursorWordAccessibilityLeft())));
+registerEditorCommand(( (new CursorWordAccessibilityLeftSelect())));
+registerEditorCommand(( (new CursorWordAccessibilityRight())));
+registerEditorCommand(( (new CursorWordAccessibilityRightSelect())));
+registerEditorCommand(( (new DeleteWordStartLeft())));
+registerEditorCommand(( (new DeleteWordEndLeft())));
+registerEditorCommand(( (new DeleteWordLeft())));
+registerEditorCommand(( (new DeleteWordStartRight())));
+registerEditorCommand(( (new DeleteWordEndRight())));
+registerEditorCommand(( (new DeleteWordRight())));
 registerEditorAction(DeleteInsideWord);
 export { CursorWordAccessibilityLeft, CursorWordAccessibilityLeftSelect, CursorWordAccessibilityRight, CursorWordAccessibilityRightSelect, CursorWordEndLeft, CursorWordEndLeftSelect, CursorWordEndRight, CursorWordEndRightSelect, CursorWordLeft, CursorWordLeftSelect, CursorWordRight, CursorWordRightSelect, CursorWordStartLeft, CursorWordStartLeftSelect, CursorWordStartRight, CursorWordStartRightSelect, DeleteInsideWord, DeleteWordCommand, DeleteWordEndLeft, DeleteWordEndRight, DeleteWordLeft, DeleteWordLeftCommand, DeleteWordRight, DeleteWordRightCommand, DeleteWordStartLeft, DeleteWordStartRight, MoveWordCommand, WordLeftCommand, WordRightCommand };

package/vscode/src/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js

@@ -59,7 +59,7 @@ let StandaloneQuickInputService = class StandaloneQuickInputService {
     get activeService() {
         const editor = this.codeEditorService.getFocusedCodeEditor();
         if (!editor) {
-            throw new Error('Quick input service needs a focused editor to work.');
+            throw ( new Error('Quick input service needs a focused editor to work.'));
         }
         let quickInputService = this.mapEditorToService.get(editor);
         if (!quickInputService) {

package/vscode/src/vs/editor/standalone/browser/standaloneCodeEditor.js

@@ -32,6 +32,8 @@ import { IAccessibilitySignalService } from '../../../platform/accessibilitySign
 import { mainWindow } from '../../../base/browser/window.js';
 import { setHoverDelegateFactory } from '../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { WorkbenchHoverDelegate } from '../../../platform/hover/browser/hover.js';
+import { IHoverService } from '../../../platform/hover/browser/hover.service.js';
+import { setBaseLayerHoverDelegate } from '../../../base/browser/ui/hover/hoverDelegate2.js';
 let LAST_GENERATED_COMMAND_ID = 0;
 let ariaDomNodeCreated = false;
 function createAriaDomNode(parent) {
@@ -44,7 +46,7 @@ function createAriaDomNode(parent) {
     setARIAContainer(parent || mainWindow.document.body);
 }
 let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
-    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService) {
+    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService) {
         const options = { ..._options };
         options.ariaLabel = options.ariaLabel || StandaloneCodeEditorNLS.editorViewAccessibleLabel;
         options.ariaLabel = options.ariaLabel + ';' + (StandaloneCodeEditorNLS.accessibilityHelpMessage);
@@ -57,6 +59,7 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
         }
         createAriaDomNode(options.ariaContainerElement);
         setHoverDelegateFactory((placement, enableInstantHover) => instantiationService.createInstance(WorkbenchHoverDelegate, placement, enableInstantHover, {}));
+        setBaseLayerHoverDelegate(hoverService);
     }
     addCommand(keybinding, handler, context) {
         if (!this._standaloneKeybindingService) {
@@ -73,7 +76,9 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
     }
     addAction(_descriptor) {
         if ((typeof _descriptor.id !== 'string') || (typeof _descriptor.label !== 'string') || (typeof _descriptor.run !== 'function')) {
-            throw new Error('Invalid action descriptor, `id`, `label` and `run` are required properties!');
+            throw ( new Error(
+                'Invalid action descriptor, `id`, `label` and `run` are required properties!'
+            ));
         }
         if (!this._standaloneKeybindingService) {
             console.warn('Cannot add keybinding because the editor is configured with an unrecognized KeybindingService');
@@ -144,15 +149,16 @@ StandaloneCodeEditor = ( __decorate([
     ( __param(3, ICodeEditorService)),
     ( __param(4, ICommandService)),
     ( __param(5, IContextKeyService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, IThemeService)),
-    ( __param(8, INotificationService)),
-    ( __param(9, IAccessibilityService)),
-    ( __param(10, ILanguageConfigurationService)),
-    ( __param(11, ILanguageFeaturesService))
+    ( __param(6, IHoverService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IAccessibilityService)),
+    ( __param(11, ILanguageConfigurationService)),
+    ( __param(12, ILanguageFeaturesService))
 ], StandaloneCodeEditor));
 let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
-    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService) {
+    constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService) {
         const options = { ..._options };
         updateConfigurationService(configurationService, options, false);
         const themeDomRegistration = themeService.registerEditorContainer(domElement);
@@ -164,7 +170,7 @@ let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
         }
         const _model = options.model;
         delete options.model;
-        super(domElement, options, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+        super(domElement, options, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
         this._configurationService = configurationService;
         this._standaloneThemeService = themeService;
         this._register(themeDomRegistration);
@@ -213,15 +219,16 @@ StandaloneEditor = ( __decorate([
     ( __param(3, ICodeEditorService)),
     ( __param(4, ICommandService)),
     ( __param(5, IContextKeyService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, IStandaloneThemeService)),
-    ( __param(8, INotificationService)),
-    ( __param(9, IConfigurationService)),
-    ( __param(10, IAccessibilityService)),
-    ( __param(11, IModelService)),
-    ( __param(12, ILanguageService)),
-    ( __param(13, ILanguageConfigurationService)),
-    ( __param(14, ILanguageFeaturesService))
+    ( __param(6, IHoverService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, IStandaloneThemeService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IAccessibilityService)),
+    ( __param(12, IModelService)),
+    ( __param(13, ILanguageService)),
+    ( __param(14, ILanguageConfigurationService)),
+    ( __param(15, ILanguageFeaturesService))
 ], StandaloneEditor));
 let StandaloneDiffEditor2 = class StandaloneDiffEditor2 extends DiffEditorWidget {
     constructor(domElement, _options, instantiationService, contextKeyService, codeEditorService, themeService, notificationService, configurationService, contextMenuService, editorProgressService, clipboardService, accessibilitySignalService) {