@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/editor/common/services/textModelSync/textModelSync.impl.js

@@ -0,0 +1,323 @@
+import { IntervalTimer } from '../../../../base/common/async.js';
+import { Disposable, dispose, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { getWordAtText, ensureValidWordDefinition } from '../../core/wordHelper.js';
+import { MirrorTextModel } from '../../model/mirrorTextModel.js';
+const STOP_SYNC_MODEL_DELTA_TIME_MS = 60 * 1000;
+const WORKER_TEXT_MODEL_SYNC_CHANNEL = 'workerTextModelSync';
+class WorkerTextModelSyncClient extends Disposable {
+    static create(workerClient, modelService) {
+        return ( new WorkerTextModelSyncClient(workerClient.getChannel(WORKER_TEXT_MODEL_SYNC_CHANNEL), modelService));
+    }
+    constructor(proxy, modelService, keepIdleModels = false) {
+        super();
+        this._syncedModels = Object.create(null);
+        this._syncedModelsLastUsedTime = Object.create(null);
+        this._proxy = proxy;
+        this._modelService = modelService;
+        if (!keepIdleModels) {
+            const timer = ( new IntervalTimer());
+            timer.cancelAndSet(() => this._checkStopModelSync(), Math.round(STOP_SYNC_MODEL_DELTA_TIME_MS / 2));
+            this._register(timer);
+        }
+    }
+    dispose() {
+        for (const modelUrl in this._syncedModels) {
+            dispose(this._syncedModels[modelUrl]);
+        }
+        this._syncedModels = Object.create(null);
+        this._syncedModelsLastUsedTime = Object.create(null);
+        super.dispose();
+    }
+    ensureSyncedResources(resources, forceLargeModels = false) {
+        for (const resource of resources) {
+            const resourceStr = ( resource.toString());
+            if (!this._syncedModels[resourceStr]) {
+                this._beginModelSync(resource, forceLargeModels);
+            }
+            if (this._syncedModels[resourceStr]) {
+                this._syncedModelsLastUsedTime[resourceStr] = (( new Date())).getTime();
+            }
+        }
+    }
+    _checkStopModelSync() {
+        const currentTime = (( new Date())).getTime();
+        const toRemove = [];
+        for (const modelUrl in this._syncedModelsLastUsedTime) {
+            const elapsedTime = currentTime - this._syncedModelsLastUsedTime[modelUrl];
+            if (elapsedTime > STOP_SYNC_MODEL_DELTA_TIME_MS) {
+                toRemove.push(modelUrl);
+            }
+        }
+        for (const e of toRemove) {
+            this._stopModelSync(e);
+        }
+    }
+    _beginModelSync(resource, forceLargeModels) {
+        const model = this._modelService.getModel(resource);
+        if (!model) {
+            return;
+        }
+        if (!forceLargeModels && model.isTooLargeForSyncing()) {
+            return;
+        }
+        const modelUrl = ( resource.toString());
+        this._proxy.$acceptNewModel({
+            url: ( model.uri.toString()),
+            lines: model.getLinesContent(),
+            EOL: model.getEOL(),
+            versionId: model.getVersionId()
+        });
+        const toDispose = ( new DisposableStore());
+        toDispose.add(model.onDidChangeContent((e) => {
+            this._proxy.$acceptModelChanged(( modelUrl.toString()), e);
+        }));
+        toDispose.add(model.onWillDispose(() => {
+            this._stopModelSync(modelUrl);
+        }));
+        toDispose.add(toDisposable(() => {
+            this._proxy.$acceptRemovedModel(modelUrl);
+        }));
+        this._syncedModels[modelUrl] = toDispose;
+    }
+    _stopModelSync(modelUrl) {
+        const toDispose = this._syncedModels[modelUrl];
+        delete this._syncedModels[modelUrl];
+        delete this._syncedModelsLastUsedTime[modelUrl];
+        dispose(toDispose);
+    }
+}
+class WorkerTextModelSyncServer {
+    constructor() {
+        this._models = Object.create(null);
+    }
+    bindToServer(workerServer) {
+        workerServer.setChannel(WORKER_TEXT_MODEL_SYNC_CHANNEL, this);
+    }
+    getModel(uri) {
+        return this._models[uri];
+    }
+    getModels() {
+        const all = [];
+        ( Object.keys(this._models)).forEach((key) => all.push(this._models[key]));
+        return all;
+    }
+    $acceptNewModel(data) {
+        this._models[data.url] = ( new MirrorModel(( URI.parse(data.url)), data.lines, data.EOL, data.versionId));
+    }
+    $acceptModelChanged(uri, e) {
+        if (!this._models[uri]) {
+            return;
+        }
+        const model = this._models[uri];
+        model.onEvents(e);
+    }
+    $acceptRemovedModel(uri) {
+        if (!this._models[uri]) {
+            return;
+        }
+        delete this._models[uri];
+    }
+}
+class MirrorModel extends MirrorTextModel {
+    get uri() {
+        return this._uri;
+    }
+    get eol() {
+        return this._eol;
+    }
+    getValue() {
+        return this.getText();
+    }
+    findMatches(regex) {
+        const matches = [];
+        for (let i = 0; i < this._lines.length; i++) {
+            const line = this._lines[i];
+            const offsetToAdd = this.offsetAt(( new Position(i + 1, 1)));
+            const iteratorOverMatches = line.matchAll(regex);
+            for (const match of iteratorOverMatches) {
+                if (match.index || match.index === 0) {
+                    match.index = match.index + offsetToAdd;
+                }
+                matches.push(match);
+            }
+        }
+        return matches;
+    }
+    getLinesContent() {
+        return this._lines.slice(0);
+    }
+    getLineCount() {
+        return this._lines.length;
+    }
+    getLineContent(lineNumber) {
+        return this._lines[lineNumber - 1];
+    }
+    getWordAtPosition(position, wordDefinition) {
+        const wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
+        if (wordAtText) {
+            return ( new Range(
+                position.lineNumber,
+                wordAtText.startColumn,
+                position.lineNumber,
+                wordAtText.endColumn
+            ));
+        }
+        return null;
+    }
+    getWordUntilPosition(position, wordDefinition) {
+        const wordAtPosition = this.getWordAtPosition(position, wordDefinition);
+        if (!wordAtPosition) {
+            return {
+                word: '',
+                startColumn: position.column,
+                endColumn: position.column
+            };
+        }
+        return {
+            word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),
+            startColumn: wordAtPosition.startColumn,
+            endColumn: position.column
+        };
+    }
+    words(wordDefinition) {
+        const lines = this._lines;
+        const wordenize = this._wordenize.bind(this);
+        let lineNumber = 0;
+        let lineText = '';
+        let wordRangesIdx = 0;
+        let wordRanges = [];
+        return {
+            *[Symbol.iterator]() {
+                while (true) {
+                    if (wordRangesIdx < wordRanges.length) {
+                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);
+                        wordRangesIdx += 1;
+                        yield value;
+                    }
+                    else {
+                        if (lineNumber < lines.length) {
+                            lineText = lines[lineNumber];
+                            wordRanges = wordenize(lineText, wordDefinition);
+                            wordRangesIdx = 0;
+                            lineNumber += 1;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    getLineWords(lineNumber, wordDefinition) {
+        const content = this._lines[lineNumber - 1];
+        const ranges = this._wordenize(content, wordDefinition);
+        const words = [];
+        for (const range of ranges) {
+            words.push({
+                word: content.substring(range.start, range.end),
+                startColumn: range.start + 1,
+                endColumn: range.end + 1
+            });
+        }
+        return words;
+    }
+    _wordenize(content, wordDefinition) {
+        const result = [];
+        let match;
+        wordDefinition.lastIndex = 0;
+        while (match = wordDefinition.exec(content)) {
+            if (match[0].length === 0) {
+                break;
+            }
+            result.push({ start: match.index, end: match.index + match[0].length });
+        }
+        return result;
+    }
+    getValueInRange(range) {
+        range = this._validateRange(range);
+        if (range.startLineNumber === range.endLineNumber) {
+            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
+        }
+        const lineEnding = this._eol;
+        const startLineIndex = range.startLineNumber - 1;
+        const endLineIndex = range.endLineNumber - 1;
+        const resultLines = [];
+        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
+        for (let i = startLineIndex + 1; i < endLineIndex; i++) {
+            resultLines.push(this._lines[i]);
+        }
+        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
+        return resultLines.join(lineEnding);
+    }
+    offsetAt(position) {
+        position = this._validatePosition(position);
+        this._ensureLineStarts();
+        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);
+    }
+    positionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        this._ensureLineStarts();
+        const out = this._lineStarts.getIndexOf(offset);
+        const lineLength = this._lines[out.index].length;
+        return {
+            lineNumber: 1 + out.index,
+            column: 1 + Math.min(out.remainder, lineLength)
+        };
+    }
+    _validateRange(range) {
+        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });
+        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });
+        if (start.lineNumber !== range.startLineNumber
+            || start.column !== range.startColumn
+            || end.lineNumber !== range.endLineNumber
+            || end.column !== range.endColumn) {
+            return {
+                startLineNumber: start.lineNumber,
+                startColumn: start.column,
+                endLineNumber: end.lineNumber,
+                endColumn: end.column
+            };
+        }
+        return range;
+    }
+    _validatePosition(position) {
+        if (!Position.isIPosition(position)) {
+            throw ( new Error('bad position'));
+        }
+        let { lineNumber, column } = position;
+        let hasChanged = false;
+        if (lineNumber < 1) {
+            lineNumber = 1;
+            column = 1;
+            hasChanged = true;
+        }
+        else if (lineNumber > this._lines.length) {
+            lineNumber = this._lines.length;
+            column = this._lines[lineNumber - 1].length + 1;
+            hasChanged = true;
+        }
+        else {
+            const maxCharacter = this._lines[lineNumber - 1].length + 1;
+            if (column < 1) {
+                column = 1;
+                hasChanged = true;
+            }
+            else if (column > maxCharacter) {
+                column = maxCharacter;
+                hasChanged = true;
+            }
+        }
+        if (!hasChanged) {
+            return position;
+        }
+        else {
+            return { lineNumber, column };
+        }
+    }
+}
+export { MirrorModel, STOP_SYNC_MODEL_DELTA_TIME_MS, WORKER_TEXT_MODEL_SYNC_CHANNEL, WorkerTextModelSyncClient, WorkerTextModelSyncServer };

package/vscode/src/vs/editor/common/services/treeSitterParserService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+const ITreeSitterParserService = ( createDecorator('treeSitterParserService'));
+export { ITreeSitterParserService };

package/vscode/src/vs/editor/common/standaloneStrings.js

@@ -1,90 +1,119 @@
 import { localize } from '../../nls.js';
 var AccessibilityHelpNLS;
 ( ((function(AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(1447, "Accessibility Help"));
-    AccessibilityHelpNLS.openingDocs = ( localize(1448, "Opening the Accessibility documentation page."));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(1449, "You are in a read-only pane of a diff editor."));
-    AccessibilityHelpNLS.editableDiffEditor = ( localize(1450, "You are in a pane of a diff editor."));
-    AccessibilityHelpNLS.readonlyEditor = ( localize(1451, "You are in a read-only code editor."));
-    AccessibilityHelpNLS.editableEditor = ( localize(1452, "You are in a code editor."));
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(733, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localize(734, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(735, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localize(736, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localize(737, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localize(738, "You are in a code editor."));
     AccessibilityHelpNLS.changeConfigToOnMac = ( localize(
-        1453,
+        739,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
     AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localize(
-        1454,
+        740,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
     AccessibilityHelpNLS.auto_on = ( localize(
-        1455,
+        741,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
     AccessibilityHelpNLS.auto_off = ( localize(
-        1456,
+        742,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(1457, "Screen Reader Optimized Mode enabled."));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(1458, "Screen Reader Optimized Mode disabled."));
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(743, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(744, "Screen Reader Optimized Mode disabled."));
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localize(
-        1459,
+        745,
         "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.tabFocusModeOffMsg = ( localize(
-        1460,
-        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}",
+        746,
+        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.stickScroll = ( localize(
-        1461,
+        747,
         "Focus Sticky Scroll{0} to focus the currently nested scopes.",
         '<keybinding:editor.action.focusStickyDebugConsole>'
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(1462, "Show Accessibility Help"));
+    AccessibilityHelpNLS.codeFolding = ( localize(
+        748,
+        "Use code folding to collapse blocks of code and focus on the code you're interested in via the Toggle Folding Command{0}.",
+        '<keybinding:editor.toggleFold>'
+    ));
+    AccessibilityHelpNLS.intellisense = ( localize(
+        749,
+        "Use Intellisense to improve coding efficiency and reduce errors. Trigger suggestions{0}.",
+        '<keybinding:editor.action.triggerSuggest>'
+    ));
+    AccessibilityHelpNLS.showOrFocusHover = ( localize(
+        750,
+        "Show or focus the hover{0} to read information about the current symbol.",
+        '<keybinding:editor.action.showHover>'
+    ));
+    AccessibilityHelpNLS.goToSymbol = ( localize(
+        751,
+        "Go to Symbol{0} to quickly navigate between symbols in the current file.",
+        '<keybinding:workbench.action.gotoSymbol>'
+    ));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(752, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localize(
-        1463,
+        753,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localize(
-        1464,
+        754,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
     AccessibilityHelpNLS.quickChat = ( localize(
-        1465,
+        755,
         "Toggle quick chat{0} to open or close a chat session.",
         '<keybinding:workbench.action.quickchat.toggle>'
     ));
     AccessibilityHelpNLS.startInlineChat = ( localize(
-        1466,
+        756,
         "Start inline chat{0} to create an in editor chat session.",
         '<keybinding:inlineChat.start>'
     ));
+    AccessibilityHelpNLS.startDebugging = ( localize(
+        757,
+        "The Debug: Start Debugging command{0} will start a debug session.",
+        '<keybinding:workbench.action.debug.start>'
+    ));
     AccessibilityHelpNLS.setBreakpoint = ( localize(
-        1467,
+        758,
         "The Debug: Inline Breakpoint command{0} will set or unset a breakpoint at the current cursor position in the active editor.",
         '<keybinding:editor.debug.action.toggleInlineBreakpoint>'
     ));
+    AccessibilityHelpNLS.addToWatch = ( localize(
+        759,
+        "The Debug: Add to Watch command{0} will add the selected text to the watch view.",
+        '<keybinding:editor.debug.action.selectionToWatch>'
+    ));
     AccessibilityHelpNLS.debugExecuteSelection = ( localize(
-        1468,
+        760,
         "The Debug: Execute Selection command{0} will execute the selected text in the debug console.",
         '<keybinding:editor.debug.action.selectionToRepl>'
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}))));
 var InspectTokensNLS;
 ( ((function(InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localize(1469, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localize(761, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}))));
 var StandaloneCodeEditorNLS;
 ( ((function(StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(1476, "Editor content"));
-    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localize(1477, "Press Alt+F1 for Accessibility Options."));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(768, "Editor content"));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}))));
 var ToggleHighContrastNLS;
 ( ((function(ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localize(1478, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localize(769, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}))));
 var StandaloneServicesNLS;
 ( ((function(StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(1479, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(770, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}))));
 export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -893,7 +893,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localize(9360, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(9821, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
@@ -906,7 +906,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return ( localize(9361, "{0} chars", n));
+        return ( localize(9822, "{0} chars", n));
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

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

@@ -34,12 +34,12 @@ let SelectionAnchorController = class SelectionAnchorController {
                 this.decorationId = accessor.addDecoration(Selection.fromPositions(position, position), {
                     description: 'selection-anchor',
                     stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
-                    hoverMessage: ( (new MarkdownString())).appendText(( localize(1167, "Selection Anchor"))),
+                    hoverMessage: ( (new MarkdownString())).appendText(( localize(1340, "Selection Anchor"))),
                     className: 'selection-anchor'
                 });
             });
             this.selectionAnchorSetContextKey.set(!!this.decorationId);
-            alert(( localize(1168, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
+            alert(( localize(1341, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
         }
     }
     goToSelectionAnchor() {
@@ -82,7 +82,7 @@ class SetSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.setSelectionAnchor',
-            label: ( localize(1169, "Set Selection Anchor")),
+            label: ( localize(1342, "Set Selection Anchor")),
             alias: 'Set Selection Anchor',
             precondition: undefined,
             kbOpts: {
@@ -100,7 +100,7 @@ class GoToSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.goToSelectionAnchor',
-            label: ( localize(1170, "Go to Selection Anchor")),
+            label: ( localize(1343, "Go to Selection Anchor")),
             alias: 'Go to Selection Anchor',
             precondition: SelectionAnchorSet,
         });
@@ -113,7 +113,7 @@ class SelectFromAnchorToCursor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.selectFromAnchorToCursor',
-            label: ( localize(1171, "Select from Anchor to Cursor")),
+            label: ( localize(1344, "Select from Anchor to Cursor")),
             alias: 'Select from Anchor to Cursor',
             precondition: SelectionAnchorSet,
             kbOpts: {
@@ -131,7 +131,7 @@ class CancelSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.cancelSelectionAnchor',
-            label: ( localize(1172, "Cancel Selection Anchor")),
+            label: ( localize(1345, "Cancel Selection Anchor")),
             alias: 'Cancel Selection Anchor',
             precondition: SelectionAnchorSet,
             kbOpts: {

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

@@ -25,12 +25,12 @@ import '../../../../platform/theme/common/colors/miscColors.js';
 import '../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
-const overviewRulerBracketMatchForeground = registerColor('editorOverviewRuler.bracketMatchForeground', '#A0A0A0', ( localize(1173, 'Overview ruler marker color for matching brackets.')));
+const overviewRulerBracketMatchForeground = registerColor('editorOverviewRuler.bracketMatchForeground', '#A0A0A0', ( localize(1346, 'Overview ruler marker color for matching brackets.')));
 class JumpToBracketAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.jumpToBracket',
-            label: ( localize(1174, "Go to Bracket")),
+            label: ( localize(1347, "Go to Bracket")),
             alias: 'Go to Bracket',
             precondition: undefined,
             kbOpts: {
@@ -48,11 +48,11 @@ class SelectToBracketAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.selectToBracket',
-            label: ( localize(1175, "Select to Bracket")),
+            label: ( localize(1348, "Select to Bracket")),
             alias: 'Select to Bracket',
             precondition: undefined,
             metadata: {
-                description: ( localize2(1176, "Select the text inside and including the brackets or curly braces")),
+                description: ( localize2(1349, "Select the text inside and including the brackets or curly braces")),
                 args: [{
                         name: 'args',
                         schema: {
@@ -80,7 +80,7 @@ class RemoveBracketsAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.removeBrackets',
-            label: ( localize(1177, "Remove Brackets")),
+            label: ( localize(1350, "Remove Brackets")),
             alias: 'Remove Brackets',
             precondition: undefined,
             kbOpts: {
@@ -353,7 +353,7 @@ MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
     group: '5_infile_nav',
     command: {
         id: 'editor.action.jumpToBracket',
-        title: ( localize(1178, "Go to &&Bracket"))
+        title: ( localize(1351, "Go to &&Bracket"))
     },
     order: 2
 });

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

@@ -25,7 +25,7 @@ class MoveCaretLeftAction extends MoveCaretAction {
     constructor() {
         super(true, {
             id: 'editor.action.moveCarretLeftAction',
-            label: ( localize(1179, "Move Selected Text Left")),
+            label: ( localize(1353, "Move Selected Text Left")),
             alias: 'Move Selected Text Left',
             precondition: EditorContextKeys.writable
         });
@@ -35,7 +35,7 @@ class MoveCaretRightAction extends MoveCaretAction {
     constructor() {
         super(false, {
             id: 'editor.action.moveCarretRightAction',
-            label: ( localize(1180, "Move Selected Text Right")),
+            label: ( localize(1354, "Move Selected Text Right")),
             alias: 'Move Selected Text Right',
             precondition: EditorContextKeys.writable
         });

package/vscode/src/vs/editor/contrib/caretOperations/browser/transpose.js

@@ -10,7 +10,7 @@ class TransposeLettersAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.transposeLetters',
-            label: ( localize(1183, "Transpose Letters")),
+            label: ( localize(1352, "Transpose Letters")),
             alias: 'Transpose Letters',
             precondition: EditorContextKeys.writable,
             kbOpts: {