@codingame/monaco-vscode-api 24.3.0 → 25.0.1

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

@@ -31,7 +31,7 @@ import { isModelDecorationVisible, isModelDecorationInString, isModelDecorationI
 import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.service.js';
 
 registerCss(unicodeHighlighter);
-const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1629, 'Icon shown with a warning message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1634, 'Icon shown with a warning message in the extensions editor.')));
 let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
     static { this.ID = 'editor.contrib.unicodeHighlighter'; }
     constructor(_editor, _editorWorkerService, _workspaceTrustService, instantiationService) {
@@ -50,19 +50,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1630, 'This document contains many non-basic ASCII unicode characters')),
+                        message: ( localize(1635, 'This document contains many non-basic ASCII unicode characters')),
                         command: ( new DisableHighlightingOfNonBasicAsciiCharactersAction()),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localize(1631, 'This document contains many ambiguous unicode characters')),
+                        message: ( localize(1636, 'This document contains many ambiguous unicode characters')),
                         command: ( new DisableHighlightingOfAmbiguousCharactersAction()),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localize(1632, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1637, 'This document contains many invisible unicode characters')),
                         command: ( new DisableHighlightingOfInvisibleCharactersAction()),
                     };
                 }
@@ -329,7 +329,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1633, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1638, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _markdownRendererService) {
         this._editor = _editor;
@@ -361,7 +361,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case UnicodeHighlighterReasonKind.Ambiguous: {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1634,
+                            1639,
                             'The character {0} could be confused with the ASCII character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -369,7 +369,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1635,
+                            1640,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -378,10 +378,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case UnicodeHighlighterReasonKind.Invisible:
-                    reason = ( localize(1636, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1641, 'The character {0} is invisible.', codePointStr));
                     break;
                 case UnicodeHighlighterReasonKind.NonBasicAscii:
-                    reason = ( localize(1637, 'The character {0} is not a basic ASCII character.', codePointStr));
+                    reason = ( localize(1642, 'The character {0} is not a basic ASCII character.', codePointStr));
                     break;
             }
             if (( existedReason.has(reason))) {
@@ -394,7 +394,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1638, 'Adjust settings'));
+            const adjustSettings = ( localize(1643, 'Adjust settings'));
             const uri = createCommandUri(ShowExcludeOptions.ID, adjustSettingsArgs);
             const markdown = ( new MarkdownString('', true))
                 .appendMarkdown(reason)
@@ -465,10 +465,10 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1639, "Disable highlighting of characters in comments")),
+            label: ( localize2(1644, "Disable highlighting of characters in comments")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1640, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1645, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor) {
         const configurationService = accessor.get(IConfigurationService);
@@ -485,10 +485,10 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize2(1641, "Disable highlighting of characters in strings")),
+            label: ( localize2(1646, "Disable highlighting of characters in strings")),
             precondition: undefined
         });
-        this.shortLabel = ( localize(1642, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1647, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor) {
         const configurationService = accessor.get(IConfigurationService);
@@ -505,11 +505,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            title: ( localize2(1643, "Disable highlighting of ambiguous characters")),
+            title: ( localize2(1648, "Disable highlighting of ambiguous characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1644, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1649, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor) {
         const configurationService = accessor.get(IConfigurationService);
@@ -526,11 +526,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            title: ( localize2(1645, "Disable highlighting of invisible characters")),
+            title: ( localize2(1650, "Disable highlighting of invisible characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1646, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1651, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor) {
         const configurationService = accessor.get(IConfigurationService);
@@ -547,11 +547,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            title: ( localize2(1647, "Disable highlighting of non basic ASCII characters")),
+            title: ( localize2(1652, "Disable highlighting of non basic ASCII characters")),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = ( localize(1648, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1653, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor) {
         const configurationService = accessor.get(IConfigurationService);
@@ -568,7 +568,7 @@ class ShowExcludeOptions extends Action2 {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            title: ( localize2(1649, "Show Exclude Options")),
+            title: ( localize2(1654, "Show Exclude Options")),
             precondition: undefined,
             f1: false,
         });
@@ -581,13 +581,13 @@ class ShowExcludeOptions extends Action2 {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return localize(
-                    1650,
+                    1655,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 );
             }
             return localize(
-                1651,
+                1656,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             );
@@ -597,7 +597,7 @@ class ShowExcludeOptions extends Action2 {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1652,
+                        1657,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),

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

@@ -70,15 +70,15 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: ( localize(1653, "Unusual Line Terminators")),
-                message: ( localize(1654, "Detected unusual line terminators")),
+                title: ( localize(1658, "Unusual Line Terminators")),
+                message: ( localize(1659, "Detected unusual line terminators")),
                 detail: ( localize(
-                    1655,
+                    1660,
                     "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.",
                     basename(model.uri)
                 )),
-                primaryButton: ( localize(1656, "&&Remove Unusual Line Terminators")),
-                cancelButton: ( localize(1657, "Ignore"))
+                primaryButton: ( localize(1661, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localize(1662, "Ignore"))
             });
         }
         finally {

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

@@ -20,36 +20,36 @@ import { themeColorFromId, registerThemingParticipant } from '../../../../platfo
 
 registerCss(highlightDecorations);
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localize(
-    1658,
+    1663,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localize(
-    1659,
+    1664,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', wordHighlightBackground, ( localize(
-    1660,
+    1665,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1661,
+    1666,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    1662,
+    1667,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1663, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(1668, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    1664,
+    1669,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', '#C0A0C0CC', ( localize(
-    1665,
+    1670,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', overviewRulerSelectionHighlightForeground, ( localize(
-    1666,
+    1671,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({

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

@@ -175,16 +175,14 @@ let WordHighlighter = class WordHighlighter {
             if (this.occurrencesHighlightEnablement === 'off') {
                 return;
             }
-            this.runDelayer.trigger(() => { this._onPositionChanged(e); }).catch(err => {
-            });
+            this.runDelayer.trigger(() => { this._onPositionChanged(e); }).catch(onUnexpectedError);
         }));
         this.toUnhook.add(editor.onDidFocusEditorText((e) => {
             if (this.occurrencesHighlightEnablement === 'off') {
                 return;
             }
             if (!this.workerRequest) {
-                this.runDelayer.trigger(() => { this._run(); }).catch(err => {
-                });
+                this.runDelayer.trigger(() => { this._run(); }).catch(onUnexpectedError);
             }
         }));
         this.toUnhook.add(editor.onDidChangeModelContent((e) => {
@@ -257,8 +255,7 @@ let WordHighlighter = class WordHighlighter {
             return;
         }
         this.runDelayer.cancel();
-        this.runDelayer.trigger(() => { this._run(false, delay); }).catch(err => {
-        });
+        this.runDelayer.trigger(() => { this._run(false, delay); }).catch(onUnexpectedError);
     }
     trigger() {
         this.runDelayer.cancel();
@@ -718,7 +715,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize2(1667, "Go to Next Symbol Highlight")),
+            label: ( localize2(1672, "Go to Next Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -732,7 +729,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize2(1668, "Go to Previous Symbol Highlight")),
+            label: ( localize2(1673, "Go to Previous Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -746,7 +743,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize2(1669, "Trigger Symbol Highlight")),
+            label: ( localize2(1674, "Trigger Symbol Highlight")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

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

@@ -1,6 +1,6 @@
 
 import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
-import { localize2 } from '../../../../nls.js';
+import { localize, localize2 } 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';
@@ -399,18 +399,35 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: ( localize2(1670, "Delete Word")),
+            label: ( localize2(1675, "Delete Word")),
+            metadata: {
+                description: ( localize2(1676, "Delete the word at the cursor")),
+                args: [{
+                        name: 'args',
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                'onlyWord': {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: ( localize(1677, "Delete only the word and leave surrounding whitespace"))
+                                }
+                            }
+                        }
+                    }]
+            }
         });
     }
     run(accessor, editor, args) {
         if (!editor.hasModel()) {
             return;
         }
+        const onlyWord = !!(args && typeof args === 'object' && args.onlyWord);
         const wordSeparators = getMapForWordSeparators(editor.getOption(EditorOption.wordSeparators), editor.getOption(EditorOption.wordSegmenterLocales));
         const model = editor.getModel();
         const selections = editor.getSelections();
         const commands = ( selections.map((sel) => {
-            const deleteRange = WordOperations.deleteInsideWord(wordSeparators, model, sel);
+            const deleteRange = WordOperations.deleteInsideWord(wordSeparators, model, sel, onlyWord);
             return ( new ReplaceCommand(deleteRange, ''));
         }));
         editor.pushUndoStop();

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

@@ -161,6 +161,9 @@ class StandaloneTheme {
     get tokenColorMap() {
         return [];
     }
+    get tokenFontMap() {
+        return [];
+    }
 }
 function isBuiltinTheme(themeName) {
     return (themeName === VS_LIGHT_THEME_NAME