@codingame/monaco-vscode-api 4.5.1 → 4.5.2

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

@@ -16,6 +16,7 @@ import { localizeWithPath } from '../../../../nls.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';
 import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+const _moduleId = "vs/editor/contrib/linesOperations/browser/linesOperations";
 class AbstractCopyLinesAction extends EditorAction {
     constructor(down, opts) {
         super(opts);
@@ -25,7 +26,7 @@ class AbstractCopyLinesAction extends EditorAction {
         if (!editor.hasModel()) {
             return;
         }
-        const selections = ( editor.getSelections().map((selection, index) => ({ selection, index, ignore: false })));
+        const selections = ( (editor.getSelections().map((selection, index) => ({ selection, index, ignore: false }))));
         selections.sort((a, b) => Range.compareRangesUsingStarts(a.selection, b.selection));
         let prev = selections[0];
         for (let i = 1; i < selections.length; i++) {
@@ -42,7 +43,7 @@ class AbstractCopyLinesAction extends EditorAction {
         }
         const commands = [];
         for (const selection of selections) {
-            commands.push(( new CopyLinesCommand(selection.selection, this.down, selection.ignore)));
+            commands.push(( (new CopyLinesCommand(selection.selection, this.down, selection.ignore))));
         }
         editor.pushUndoStop();
         editor.executeCommands(this.id, commands);
@@ -53,11 +54,7 @@ class CopyLinesUpAction extends AbstractCopyLinesAction {
     constructor() {
         super(false, {
             id: 'editor.action.copyLinesUpAction',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.copyUp',
-                "Copy Line Up"
-            )),
+            label: ( localizeWithPath(_moduleId, 0, "Copy Line Up")),
             alias: 'Copy Line Up',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -69,11 +66,7 @@ class CopyLinesUpAction extends AbstractCopyLinesAction {
             menuOpts: {
                 menuId: MenuId.MenubarSelectionMenu,
                 group: '2_line',
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/linesOperations/browser/linesOperations',
-                    { key: 'miCopyLinesUp', comment: ['&& denotes a mnemonic'] },
-                    "&&Copy Line Up"
-                )),
+                title: ( localizeWithPath(_moduleId, 1, "&&Copy Line Up")),
                 order: 1
             }
         });
@@ -83,11 +76,7 @@ class CopyLinesDownAction extends AbstractCopyLinesAction {
     constructor() {
         super(true, {
             id: 'editor.action.copyLinesDownAction',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.copyDown',
-                "Copy Line Down"
-            )),
+            label: ( localizeWithPath(_moduleId, 2, "Copy Line Down")),
             alias: 'Copy Line Down',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -99,11 +88,7 @@ class CopyLinesDownAction extends AbstractCopyLinesAction {
             menuOpts: {
                 menuId: MenuId.MenubarSelectionMenu,
                 group: '2_line',
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/linesOperations/browser/linesOperations',
-                    { key: 'miCopyLinesDown', comment: ['&& denotes a mnemonic'] },
-                    "Co&&py Line Down"
-                )),
+                title: ( localizeWithPath(_moduleId, 3, "Co&&py Line Down")),
                 order: 2
             }
         });
@@ -113,21 +98,13 @@ class DuplicateSelectionAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.duplicateSelection',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'duplicateSelection',
-                "Duplicate Selection"
-            )),
+            label: ( localizeWithPath(_moduleId, 4, "Duplicate Selection")),
             alias: 'Duplicate Selection',
             precondition: EditorContextKeys.writable,
             menuOpts: {
                 menuId: MenuId.MenubarSelectionMenu,
                 group: '2_line',
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/linesOperations/browser/linesOperations',
-                    { key: 'miDuplicateSelection', comment: ['&& denotes a mnemonic'] },
-                    "&&Duplicate Selection"
-                )),
+                title: ( localizeWithPath(_moduleId, 5, "&&Duplicate Selection")),
                 order: 5
             }
         });
@@ -141,16 +118,16 @@ class DuplicateSelectionAction extends EditorAction {
         const model = editor.getModel();
         for (const selection of selections) {
             if (selection.isEmpty()) {
-                commands.push(( new CopyLinesCommand(selection, true)));
+                commands.push(( (new CopyLinesCommand(selection, true))));
             }
             else {
-                const insertSelection = ( new Selection(
+                const insertSelection = ( (new Selection(
                     selection.endLineNumber,
                     selection.endColumn,
                     selection.endLineNumber,
                     selection.endColumn
-                ));
-                commands.push(( new ReplaceCommandThatSelectsText(insertSelection, model.getValueInRange(selection))));
+                )));
+                commands.push(( (new ReplaceCommandThatSelectsText(insertSelection, model.getValueInRange(selection)))));
             }
         }
         editor.pushUndoStop();
@@ -169,7 +146,7 @@ class AbstractMoveLinesAction extends EditorAction {
         const selections = editor.getSelections() || [];
         const autoIndent = editor.getOption(12 );
         for (const selection of selections) {
-            commands.push(( new MoveLinesCommand(selection, this.down, autoIndent, languageConfigurationService)));
+            commands.push(( (new MoveLinesCommand(selection, this.down, autoIndent, languageConfigurationService))));
         }
         editor.pushUndoStop();
         editor.executeCommands(this.id, commands);
@@ -180,11 +157,7 @@ class MoveLinesUpAction extends AbstractMoveLinesAction {
     constructor() {
         super(false, {
             id: 'editor.action.moveLinesUpAction',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.moveUp',
-                "Move Line Up"
-            )),
+            label: ( localizeWithPath(_moduleId, 6, "Move Line Up")),
             alias: 'Move Line Up',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -196,11 +169,7 @@ class MoveLinesUpAction extends AbstractMoveLinesAction {
             menuOpts: {
                 menuId: MenuId.MenubarSelectionMenu,
                 group: '2_line',
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/linesOperations/browser/linesOperations',
-                    { key: 'miMoveLinesUp', comment: ['&& denotes a mnemonic'] },
-                    "Mo&&ve Line Up"
-                )),
+                title: ( localizeWithPath(_moduleId, 7, "Mo&&ve Line Up")),
                 order: 3
             }
         });
@@ -210,11 +179,7 @@ class MoveLinesDownAction extends AbstractMoveLinesAction {
     constructor() {
         super(true, {
             id: 'editor.action.moveLinesDownAction',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.moveDown',
-                "Move Line Down"
-            )),
+            label: ( localizeWithPath(_moduleId, 8, "Move Line Down")),
             alias: 'Move Line Down',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -226,11 +191,7 @@ class MoveLinesDownAction extends AbstractMoveLinesAction {
             menuOpts: {
                 menuId: MenuId.MenubarSelectionMenu,
                 group: '2_line',
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/linesOperations/browser/linesOperations',
-                    { key: 'miMoveLinesDown', comment: ['&& denotes a mnemonic'] },
-                    "Move &&Line Down"
-                )),
+                title: ( localizeWithPath(_moduleId, 9, "Move &&Line Down")),
                 order: 4
             }
         });
@@ -248,7 +209,7 @@ class AbstractSortLinesAction extends EditorAction {
         const model = editor.getModel();
         let selections = editor.getSelections();
         if (selections.length === 1 && selections[0].isEmpty()) {
-            selections = [( new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount())))];
+            selections = [( (new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount()))))];
         }
         for (const selection of selections) {
             if (!SortLinesCommand.canRun(editor.getModel(), selection, this.descending)) {
@@ -257,7 +218,7 @@ class AbstractSortLinesAction extends EditorAction {
         }
         const commands = [];
         for (let i = 0, len = selections.length; i < len; i++) {
-            commands[i] = ( new SortLinesCommand(selections[i], this.descending));
+            commands[i] = ( (new SortLinesCommand(selections[i], this.descending)));
         }
         editor.pushUndoStop();
         editor.executeCommands(this.id, commands);
@@ -268,11 +229,7 @@ class SortLinesAscendingAction extends AbstractSortLinesAction {
     constructor() {
         super(false, {
             id: 'editor.action.sortLinesAscending',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.sortAscending',
-                "Sort Lines Ascending"
-            )),
+            label: ( localizeWithPath(_moduleId, 10, "Sort Lines Ascending")),
             alias: 'Sort Lines Ascending',
             precondition: EditorContextKeys.writable
         });
@@ -282,11 +239,7 @@ class SortLinesDescendingAction extends AbstractSortLinesAction {
     constructor() {
         super(true, {
             id: 'editor.action.sortLinesDescending',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.sortDescending',
-                "Sort Lines Descending"
-            )),
+            label: ( localizeWithPath(_moduleId, 11, "Sort Lines Descending")),
             alias: 'Sort Lines Descending',
             precondition: EditorContextKeys.writable
         });
@@ -296,11 +249,7 @@ class DeleteDuplicateLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.removeDuplicateLines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.deleteDuplicates',
-                "Delete Duplicate Lines"
-            )),
+            label: ( localizeWithPath(_moduleId, 12, "Delete Duplicate Lines")),
             alias: 'Delete Duplicate Lines',
             precondition: EditorContextKeys.writable
         });
@@ -319,33 +268,33 @@ class DeleteDuplicateLinesAction extends EditorAction {
         let updateSelection = true;
         let selections = editor.getSelections();
         if (selections.length === 1 && selections[0].isEmpty()) {
-            selections = [( new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount())))];
+            selections = [( (new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount()))))];
             updateSelection = false;
         }
         for (const selection of selections) {
-            const uniqueLines = ( new Set());
+            const uniqueLines = ( (new Set()));
             const lines = [];
             for (let i = selection.startLineNumber; i <= selection.endLineNumber; i++) {
                 const line = model.getLineContent(i);
-                if (( uniqueLines.has(line))) {
+                if (( (uniqueLines.has(line)))) {
                     continue;
                 }
                 lines.push(line);
                 uniqueLines.add(line);
             }
-            const selectionToReplace = ( new Selection(
+            const selectionToReplace = ( (new Selection(
                 selection.startLineNumber,
                 1,
                 selection.endLineNumber,
                 model.getLineMaxColumn(selection.endLineNumber)
-            ));
+            )));
             const adjustedSelectionStart = selection.startLineNumber - linesDeleted;
-            const finalSelection = ( new Selection(
+            const finalSelection = ( (new Selection(
                 adjustedSelectionStart,
                 1,
                 adjustedSelectionStart + lines.length - 1,
                 lines[lines.length - 1].length
-            ));
+            )));
             edits.push(EditOperation.replace(selectionToReplace, lines.join('\n')));
             endCursorState.push(finalSelection);
             linesDeleted += (selection.endLineNumber - selection.startLineNumber + 1) - lines.length;
@@ -360,11 +309,7 @@ class TrimTrailingWhitespaceAction extends EditorAction {
     constructor() {
         super({
             id: TrimTrailingWhitespaceAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.trimTrailingWhitespace',
-                "Trim Trailing Whitespace"
-            )),
+            label: ( localizeWithPath(_moduleId, 13, "Trim Trailing Whitespace")),
             alias: 'Trim Trailing Whitespace',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -377,7 +322,9 @@ class TrimTrailingWhitespaceAction extends EditorAction {
     run(_accessor, editor, args) {
         let cursors = [];
         if (args.reason === 'auto-save') {
-            cursors = ( (editor.getSelections() || []).map(s => ( new Position(s.positionLineNumber, s.positionColumn))));
+            cursors = ( ((editor.getSelections() || []).map(
+                s => ( (new Position(s.positionLineNumber, s.positionColumn)))
+            )));
         }
         const selection = editor.getSelection();
         if (selection === null) {
@@ -386,7 +333,7 @@ class TrimTrailingWhitespaceAction extends EditorAction {
         const config = _accessor.get(IConfigurationService);
         const model = editor.getModel();
         const trimInRegexAndStrings = config.getValue('files.trimTrailingWhitespaceInRegexAndStrings', { overrideIdentifier: model?.getLanguageId(), resource: model?.uri });
-        const command = ( new TrimTrailingWhitespaceCommand(selection, cursors, trimInRegexAndStrings));
+        const command = ( (new TrimTrailingWhitespaceCommand(selection, cursors, trimInRegexAndStrings)));
         editor.pushUndoStop();
         editor.executeCommands(this.id, [command]);
         editor.pushUndoStop();
@@ -396,11 +343,7 @@ class DeleteLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.deleteLines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.delete',
-                "Delete Line"
-            )),
+            label: ( localizeWithPath(_moduleId, 14, "Delete Line")),
             alias: 'Delete Line',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -436,13 +379,13 @@ class DeleteLinesAction extends EditorAction {
                 startLineNumber -= 1;
                 startColumn = model.getLineMaxColumn(startLineNumber);
             }
-            edits.push(EditOperation.replace(( new Selection(startLineNumber, startColumn, endLineNumber, endColumn)), ''));
-            cursorState.push(( new Selection(
+            edits.push(EditOperation.replace(( (new Selection(startLineNumber, startColumn, endLineNumber, endColumn))), ''));
+            cursorState.push(( (new Selection(
                 startLineNumber - linesDeleted,
                 op.positionColumn,
                 startLineNumber - linesDeleted,
                 op.positionColumn
-            )));
+            ))));
             linesDeleted += (op.endLineNumber - op.startLineNumber + 1);
         }
         editor.pushUndoStop();
@@ -450,7 +393,7 @@ class DeleteLinesAction extends EditorAction {
         editor.pushUndoStop();
     }
     _getLinesToRemove(editor) {
-        const operations = ( editor.getSelections().map((s) => {
+        const operations = ( (editor.getSelections().map((s) => {
             let endLineNumber = s.endLineNumber;
             if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {
                 endLineNumber -= 1;
@@ -461,7 +404,7 @@ class DeleteLinesAction extends EditorAction {
                 endLineNumber: endLineNumber,
                 positionColumn: s.positionColumn
             };
-        }));
+        })));
         operations.sort((a, b) => {
             if (a.startLineNumber === b.startLineNumber) {
                 return a.endLineNumber - b.endLineNumber;
@@ -487,11 +430,7 @@ class IndentLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.indentLines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.indent',
-                "Indent Line"
-            )),
+            label: ( localizeWithPath(_moduleId, 15, "Indent Line")),
             alias: 'Indent Line',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -515,11 +454,7 @@ class OutdentLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.outdentLines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.outdent',
-                "Outdent Line"
-            )),
+            label: ( localizeWithPath(_moduleId, 16, "Outdent Line")),
             alias: 'Outdent Line',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -537,11 +472,7 @@ class InsertLineBeforeAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.insertLineBefore',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.insertBefore',
-                "Insert Line Above"
-            )),
+            label: ( localizeWithPath(_moduleId, 17, "Insert Line Above")),
             alias: 'Insert Line Above',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -564,11 +495,7 @@ class InsertLineAfterAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.insertLineAfter',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.insertAfter',
-                "Insert Line Below"
-            )),
+            label: ( localizeWithPath(_moduleId, 18, "Insert Line Below")),
             alias: 'Insert Line Below',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -607,9 +534,9 @@ class AbstractDeleteAllToBoundaryAction extends EditorAction {
         }
         effectiveRanges.push(rangesToDelete[rangesToDelete.length - 1]);
         const endCursorState = this._getEndCursorState(primaryCursor, effectiveRanges);
-        const edits = ( effectiveRanges.map(range => {
+        const edits = ( (effectiveRanges.map(range => {
             return EditOperation.replace(range, '');
-        }));
+        })));
         editor.pushUndoStop();
         editor.executeEdits(this.id, edits, endCursorState);
         editor.pushUndoStop();
@@ -619,11 +546,7 @@ class DeleteAllLeftAction extends AbstractDeleteAllToBoundaryAction {
     constructor() {
         super({
             id: 'deleteAllLeft',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.deleteAllLeft',
-                "Delete All Left"
-            )),
+            label: ( localizeWithPath(_moduleId, 19, "Delete All Left")),
             alias: 'Delete All Left',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -642,15 +565,15 @@ class DeleteAllLeftAction extends AbstractDeleteAllToBoundaryAction {
             let endCursor;
             if (range.endColumn === 1 && deletedLines > 0) {
                 const newStartLine = range.startLineNumber - deletedLines;
-                endCursor = ( new Selection(newStartLine, range.startColumn, newStartLine, range.startColumn));
+                endCursor = ( (new Selection(newStartLine, range.startColumn, newStartLine, range.startColumn)));
             }
             else {
-                endCursor = ( new Selection(
+                endCursor = ( (new Selection(
                     range.startLineNumber,
                     range.startColumn,
                     range.startLineNumber,
                     range.startColumn
-                ));
+                )));
             }
             deletedLines += range.endLineNumber - range.startLineNumber;
             if (range.intersectRanges(primaryCursor)) {
@@ -676,26 +599,32 @@ class DeleteAllLeftAction extends AbstractDeleteAllToBoundaryAction {
             return [];
         }
         rangesToDelete.sort(Range.compareRangesUsingStarts);
-        rangesToDelete = ( rangesToDelete.map(selection => {
+        rangesToDelete = ( (rangesToDelete.map(selection => {
             if (selection.isEmpty()) {
                 if (selection.startColumn === 1) {
                     const deleteFromLine = Math.max(1, selection.startLineNumber - 1);
                     const deleteFromColumn = selection.startLineNumber === 1 ? 1 : model.getLineLength(deleteFromLine) + 1;
-                    return ( new Range(deleteFromLine, deleteFromColumn, selection.startLineNumber, 1));
+                    return (
+                         (new Range(deleteFromLine, deleteFromColumn, selection.startLineNumber, 1))
+                    );
                 }
                 else {
-                    return ( new Range(
-                        selection.startLineNumber,
-                        1,
-                        selection.startLineNumber,
-                        selection.startColumn
-                    ));
+                    return (
+                         (new Range(
+                            selection.startLineNumber,
+                            1,
+                            selection.startLineNumber,
+                            selection.startColumn
+                        ))
+                    );
                 }
             }
             else {
-                return ( new Range(selection.startLineNumber, 1, selection.endLineNumber, selection.endColumn));
+                return (
+                     (new Range(selection.startLineNumber, 1, selection.endLineNumber, selection.endColumn))
+                );
             }
-        }));
+        })));
         return rangesToDelete;
     }
 }
@@ -703,11 +632,7 @@ class DeleteAllRightAction extends AbstractDeleteAllToBoundaryAction {
     constructor() {
         super({
             id: 'deleteAllRight',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.deleteAllRight',
-                "Delete All Right"
-            )),
+            label: ( localizeWithPath(_moduleId, 20, "Delete All Right")),
             alias: 'Delete All Right',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -723,12 +648,12 @@ class DeleteAllRightAction extends AbstractDeleteAllToBoundaryAction {
         const endCursorState = [];
         for (let i = 0, len = rangesToDelete.length, offset = 0; i < len; i++) {
             const range = rangesToDelete[i];
-            const endCursor = ( new Selection(
+            const endCursor = ( (new Selection(
                 range.startLineNumber - offset,
                 range.startColumn,
                 range.startLineNumber - offset,
                 range.startColumn
-            ));
+            )));
             if (range.intersectRanges(primaryCursor)) {
                 endPrimaryCursor = endCursor;
             }
@@ -750,18 +675,22 @@ class DeleteAllRightAction extends AbstractDeleteAllToBoundaryAction {
         if (selections === null) {
             return [];
         }
-        const rangesToDelete = ( selections.map((sel) => {
+        const rangesToDelete = ( (selections.map((sel) => {
             if (sel.isEmpty()) {
                 const maxColumn = model.getLineMaxColumn(sel.startLineNumber);
                 if (sel.startColumn === maxColumn) {
-                    return ( new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber + 1, 1));
+                    return (
+                         (new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber + 1, 1))
+                    );
                 }
                 else {
-                    return ( new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber, maxColumn));
+                    return (
+                         (new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber, maxColumn))
+                    );
                 }
             }
             return sel;
-        }));
+        })));
         rangesToDelete.sort(Range.compareRangesUsingStarts);
         return rangesToDelete;
     }
@@ -770,11 +699,7 @@ class JoinLinesAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.joinLines',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'lines.joinLines',
-                "Join Lines"
-            )),
+            label: ( localizeWithPath(_moduleId, 21, "Join Lines")),
             alias: 'Join Lines',
             precondition: EditorContextKeys.writable,
             kbOpts: {
@@ -809,12 +734,14 @@ class JoinLinesAction extends EditorAction {
                     return currentValue;
                 }
                 else {
-                    return ( new Selection(
-                        previousValue.startLineNumber,
-                        previousValue.startColumn,
-                        currentValue.endLineNumber,
-                        currentValue.endColumn
-                    ));
+                    return (
+                         (new Selection(
+                            previousValue.startLineNumber,
+                            previousValue.startColumn,
+                            currentValue.endLineNumber,
+                            currentValue.endColumn
+                        ))
+                    );
                 }
             }
             else {
@@ -823,12 +750,14 @@ class JoinLinesAction extends EditorAction {
                     return currentValue;
                 }
                 else {
-                    return ( new Selection(
-                        previousValue.startLineNumber,
-                        previousValue.startColumn,
-                        currentValue.endLineNumber,
-                        currentValue.endColumn
-                    ));
+                    return (
+                         (new Selection(
+                            previousValue.startLineNumber,
+                            previousValue.startColumn,
+                            currentValue.endLineNumber,
+                            currentValue.endColumn
+                        ))
+                    );
                 }
             }
         });
@@ -890,36 +819,36 @@ class JoinLinesAction extends EditorAction {
                     columnDeltaOffset = 0;
                 }
             }
-            const deleteSelection = ( new Range(startLineNumber, startColumn, endLineNumber, endColumn));
+            const deleteSelection = ( (new Range(startLineNumber, startColumn, endLineNumber, endColumn)));
             if (!deleteSelection.isEmpty()) {
                 let resultSelection;
                 if (selection.isEmpty()) {
                     edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));
-                    resultSelection = ( new Selection(
+                    resultSelection = ( (new Selection(
                         deleteSelection.startLineNumber - lineOffset,
                         trimmedLinesContent.length - columnDeltaOffset + 1,
                         startLineNumber - lineOffset,
                         trimmedLinesContent.length - columnDeltaOffset + 1
-                    ));
+                    )));
                 }
                 else {
                     if (selection.startLineNumber === selection.endLineNumber) {
                         edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));
-                        resultSelection = ( new Selection(
+                        resultSelection = ( (new Selection(
                             selection.startLineNumber - lineOffset,
                             selection.startColumn,
                             selection.endLineNumber - lineOffset,
                             selection.endColumn
-                        ));
+                        )));
                     }
                     else {
                         edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));
-                        resultSelection = ( new Selection(
+                        resultSelection = ( (new Selection(
                             selection.startLineNumber - lineOffset,
                             selection.startColumn,
                             selection.startLineNumber - lineOffset,
                             trimmedLinesContent.length - selectionEndPositionOffset
-                        ));
+                        )));
                     }
                 }
                 if (Range.intersectRanges(deleteSelection, primaryCursor) !== null) {
@@ -941,11 +870,7 @@ class TransposeAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.transpose',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transpose',
-                "Transpose Characters around the Cursor"
-            )),
+            label: ( localizeWithPath(_moduleId, 22, "Transpose Characters around the Cursor")),
             alias: 'Transpose Characters around the Cursor',
             precondition: EditorContextKeys.writable
         });
@@ -971,29 +896,33 @@ class TransposeAction extends EditorAction {
                 if (cursor.lineNumber === model.getLineCount()) {
                     continue;
                 }
-                const deleteSelection = ( new Range(
+                const deleteSelection = ( (new Range(
                     cursor.lineNumber,
                     Math.max(1, cursor.column - 1),
                     cursor.lineNumber + 1,
                     1
-                ));
+                )));
                 const chars = model.getValueInRange(deleteSelection).split('').reverse().join('');
-                commands.push(( new ReplaceCommand(( new Selection(
+                commands.push(( (new ReplaceCommand( (new Selection(
                     cursor.lineNumber,
                     Math.max(1, cursor.column - 1),
                     cursor.lineNumber + 1,
                     1
-                )), chars)));
+                )), chars))));
             }
             else {
-                const deleteSelection = ( new Range(
+                const deleteSelection = ( (new Range(
                     cursor.lineNumber,
                     Math.max(1, cursor.column - 1),
                     cursor.lineNumber,
                     cursor.column + 1
-                ));
+                )));
                 const chars = model.getValueInRange(deleteSelection).split('').reverse().join('');
-                commands.push(( new ReplaceCommandThatPreservesSelection(deleteSelection, chars, ( new Selection(cursor.lineNumber, cursor.column + 1, cursor.lineNumber, cursor.column + 1)))));
+                commands.push(( (new ReplaceCommandThatPreservesSelection(
+                    deleteSelection,
+                    chars,
+                     (new Selection(cursor.lineNumber, cursor.column + 1, cursor.lineNumber, cursor.column + 1))
+                ))));
             }
         }
         editor.pushUndoStop();
@@ -1020,7 +949,7 @@ class AbstractCaseAction extends EditorAction {
                 if (!word) {
                     continue;
                 }
-                const wordRange = ( new Range(cursor.lineNumber, word.startColumn, cursor.lineNumber, word.endColumn));
+                const wordRange = ( (new Range(cursor.lineNumber, word.startColumn, cursor.lineNumber, word.endColumn)));
                 const text = model.getValueInRange(wordRange);
                 textEdits.push(EditOperation.replace(wordRange, this._modifyText(text, wordSeparators)));
             }
@@ -1038,11 +967,7 @@ class UpperCaseAction extends AbstractCaseAction {
     constructor() {
         super({
             id: 'editor.action.transformToUppercase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToUppercase',
-                "Transform to Uppercase"
-            )),
+            label: ( localizeWithPath(_moduleId, 23, "Transform to Uppercase")),
             alias: 'Transform to Uppercase',
             precondition: EditorContextKeys.writable
         });
@@ -1055,11 +980,7 @@ class LowerCaseAction extends AbstractCaseAction {
     constructor() {
         super({
             id: 'editor.action.transformToLowercase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToLowercase',
-                "Transform to Lowercase"
-            )),
+            label: ( localizeWithPath(_moduleId, 24, "Transform to Lowercase")),
             alias: 'Transform to Lowercase',
             precondition: EditorContextKeys.writable
         });
@@ -1079,7 +1000,7 @@ class BackwardsCompatibleRegExp {
         if (!this._evaluated) {
             this._evaluated = true;
             try {
-                this._actual = ( new RegExp(this._pattern, this._flags));
+                this._actual = ( (new RegExp(this._pattern, this._flags)));
             }
             catch (err) {
             }
@@ -1091,15 +1012,11 @@ class BackwardsCompatibleRegExp {
     }
 }
 class TitleCaseAction extends AbstractCaseAction {
-    static { this.titleBoundary = ( new BackwardsCompatibleRegExp('(^|[^\\p{L}\\p{N}\']|((^|\\P{L})\'))\\p{L}', 'gmu')); }
+    static { this.titleBoundary = ( (new BackwardsCompatibleRegExp('(^|[^\\p{L}\\p{N}\']|((^|\\P{L})\'))\\p{L}', 'gmu'))); }
     constructor() {
         super({
             id: 'editor.action.transformToTitlecase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToTitlecase',
-                "Transform to Title Case"
-            )),
+            label: ( localizeWithPath(_moduleId, 25, "Transform to Title Case")),
             alias: 'Transform to Title Case',
             precondition: EditorContextKeys.writable
         });
@@ -1115,16 +1032,12 @@ class TitleCaseAction extends AbstractCaseAction {
     }
 }
 class SnakeCaseAction extends AbstractCaseAction {
-    static { this.caseBoundary = ( new BackwardsCompatibleRegExp('(\\p{Ll})(\\p{Lu})', 'gmu')); }
-    static { this.singleLetters = ( new BackwardsCompatibleRegExp('(\\p{Lu}|\\p{N})(\\p{Lu})(\\p{Ll})', 'gmu')); }
+    static { this.caseBoundary = ( (new BackwardsCompatibleRegExp('(\\p{Ll})(\\p{Lu})', 'gmu'))); }
+    static { this.singleLetters = ( (new BackwardsCompatibleRegExp('(\\p{Lu}|\\p{N})(\\p{Lu})(\\p{Ll})', 'gmu'))); }
     constructor() {
         super({
             id: 'editor.action.transformToSnakecase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToSnakecase',
-                "Transform to Snake Case"
-            )),
+            label: ( localizeWithPath(_moduleId, 26, "Transform to Snake Case")),
             alias: 'Transform to Snake Case',
             precondition: EditorContextKeys.writable
         });
@@ -1142,15 +1055,11 @@ class SnakeCaseAction extends AbstractCaseAction {
     }
 }
 class CamelCaseAction extends AbstractCaseAction {
-    static { this.wordBoundary = ( new BackwardsCompatibleRegExp('[_\\s-]', 'gm')); }
+    static { this.wordBoundary = ( (new BackwardsCompatibleRegExp('[_\\s-]', 'gm'))); }
     constructor() {
         super({
             id: 'editor.action.transformToCamelcase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToCamelcase',
-                "Transform to Camel Case"
-            )),
+            label: ( localizeWithPath(_moduleId, 27, "Transform to Camel Case")),
             alias: 'Transform to Camel Case',
             precondition: EditorContextKeys.writable
         });
@@ -1162,21 +1071,17 @@ class CamelCaseAction extends AbstractCaseAction {
         }
         const words = text.split(wordBoundary);
         const firstWord = words.shift();
-        return firstWord + ( words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1)))
+        return firstWord + ( (words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1))))
             .join('');
     }
 }
 class PascalCaseAction extends AbstractCaseAction {
-    static { this.wordBoundary = ( new BackwardsCompatibleRegExp('[_\\s-]', 'gm')); }
-    static { this.wordBoundaryToMaintain = ( new BackwardsCompatibleRegExp('(?<=\\.)', 'gm')); }
+    static { this.wordBoundary = ( (new BackwardsCompatibleRegExp('[_\\s-]', 'gm'))); }
+    static { this.wordBoundaryToMaintain = ( (new BackwardsCompatibleRegExp('(?<=\\.)', 'gm'))); }
     constructor() {
         super({
             id: 'editor.action.transformToPascalcase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToPascalcase',
-                "Transform to Pascal Case"
-            )),
+            label: ( localizeWithPath(_moduleId, 28, "Transform to Pascal Case")),
             alias: 'Transform to Pascal Case',
             precondition: EditorContextKeys.writable
         });
@@ -1188,8 +1093,8 @@ class PascalCaseAction extends AbstractCaseAction {
             return text;
         }
         const wordsWithMaintainBoundaries = text.split(wordBoundaryToMaintain);
-        const words = ( wordsWithMaintainBoundaries.map((word) => word.split(wordBoundary))).flat();
-        return ( words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1)))
+        const words = ( (wordsWithMaintainBoundaries.map((word) => word.split(wordBoundary)))).flat();
+        return ( (words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1))))
             .join('');
     }
 }
@@ -1202,17 +1107,13 @@ class KebabCaseAction extends AbstractCaseAction {
         ].every((regexp) => regexp.isSupported());
         return areAllRegexpsSupported;
     }
-    static { this.caseBoundary = ( new BackwardsCompatibleRegExp('(\\p{Ll})(\\p{Lu})', 'gmu')); }
-    static { this.singleLetters = ( new BackwardsCompatibleRegExp('(\\p{Lu}|\\p{N})(\\p{Lu}\\p{Ll})', 'gmu')); }
-    static { this.underscoreBoundary = ( new BackwardsCompatibleRegExp('(\\S)(_)(\\S)', 'gm')); }
+    static { this.caseBoundary = ( (new BackwardsCompatibleRegExp('(\\p{Ll})(\\p{Lu})', 'gmu'))); }
+    static { this.singleLetters = ( (new BackwardsCompatibleRegExp('(\\p{Lu}|\\p{N})(\\p{Lu}\\p{Ll})', 'gmu'))); }
+    static { this.underscoreBoundary = ( (new BackwardsCompatibleRegExp('(\\S)(_)(\\S)', 'gm'))); }
     constructor() {
         super({
             id: 'editor.action.transformToKebabcase',
-            label: ( localizeWithPath(
-                'vs/editor/contrib/linesOperations/browser/linesOperations',
-                'editor.transformToKebabcase',
-                'Transform to Kebab Case'
-            )),
+            label: ( localizeWithPath(_moduleId, 29, 'Transform to Kebab Case')),
             alias: 'Transform to Kebab Case',
             precondition: EditorContextKeys.writable
         });