@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,1222 @@
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { CoreEditingCommands } from '../../../browser/coreCommands.js';
+import { EditorAction, registerEditorAction } from '../../../browser/editorExtensions.js';
+import { ReplaceCommandThatSelectsText, ReplaceCommand, ReplaceCommandThatPreservesSelection } from '../../../common/commands/replaceCommand.js';
+import { TrimTrailingWhitespaceCommand } from '../../../common/commands/trimTrailingWhitespaceCommand.js';
+import { TypeOperations } from '../../../common/cursor/cursorTypeOperations.js';
+import { EditOperation } from '../../../common/core/editOperation.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { CopyLinesCommand } from './copyLinesCommand.js';
+import { MoveLinesCommand } from './moveLinesCommand.js';
+import { SortLinesCommand } from './sortLinesCommand.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
+class AbstractCopyLinesAction extends EditorAction {
+    constructor(down, opts) {
+        super(opts);
+        this.down = down;
+    }
+    run(_accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        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++) {
+            const curr = selections[i];
+            if (prev.selection.endLineNumber === curr.selection.startLineNumber) {
+                if (prev.index < curr.index) {
+                    curr.ignore = true;
+                }
+                else {
+                    prev.ignore = true;
+                    prev = curr;
+                }
+            }
+        }
+        const commands = [];
+        for (const selection of selections) {
+            commands.push(( new CopyLinesCommand(selection.selection, this.down, selection.ignore)));
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class CopyLinesUpAction extends AbstractCopyLinesAction {
+    constructor() {
+        super(false, {
+            id: 'editor.action.copyLinesUpAction',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.copyUp',
+                "Copy Line Up"
+            )),
+            alias: 'Copy Line Up',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 512  | 1024  | 16 ,
+                linux: { primary: 2048  | 512  | 1024  | 16  },
+                weight: 100
+            },
+            menuOpts: {
+                menuId: MenuId.MenubarSelectionMenu,
+                group: '2_line',
+                title: ( localizeWithPath(
+                    'vs/editor/contrib/linesOperations/browser/linesOperations',
+                    { key: 'miCopyLinesUp', comment: ['&& denotes a mnemonic'] },
+                    "&&Copy Line Up"
+                )),
+                order: 1
+            }
+        });
+    }
+}
+class CopyLinesDownAction extends AbstractCopyLinesAction {
+    constructor() {
+        super(true, {
+            id: 'editor.action.copyLinesDownAction',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.copyDown',
+                "Copy Line Down"
+            )),
+            alias: 'Copy Line Down',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 512  | 1024  | 18 ,
+                linux: { primary: 2048  | 512  | 1024  | 18  },
+                weight: 100
+            },
+            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"
+                )),
+                order: 2
+            }
+        });
+    }
+}
+class DuplicateSelectionAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.duplicateSelection',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'duplicateSelection',
+                "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"
+                )),
+                order: 5
+            }
+        });
+    }
+    run(accessor, editor, args) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const commands = [];
+        const selections = editor.getSelections();
+        const model = editor.getModel();
+        for (const selection of selections) {
+            if (selection.isEmpty()) {
+                commands.push(( new CopyLinesCommand(selection, true)));
+            }
+            else {
+                const insertSelection = ( new Selection(
+                    selection.endLineNumber,
+                    selection.endColumn,
+                    selection.endLineNumber,
+                    selection.endColumn
+                ));
+                commands.push(( new ReplaceCommandThatSelectsText(insertSelection, model.getValueInRange(selection))));
+            }
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class AbstractMoveLinesAction extends EditorAction {
+    constructor(down, opts) {
+        super(opts);
+        this.down = down;
+    }
+    run(accessor, editor) {
+        const languageConfigurationService = accessor.get(ILanguageConfigurationService);
+        const commands = [];
+        const selections = editor.getSelections() || [];
+        const autoIndent = editor.getOption(12 );
+        for (const selection of selections) {
+            commands.push(( new MoveLinesCommand(selection, this.down, autoIndent, languageConfigurationService)));
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class MoveLinesUpAction extends AbstractMoveLinesAction {
+    constructor() {
+        super(false, {
+            id: 'editor.action.moveLinesUpAction',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.moveUp',
+                "Move Line Up"
+            )),
+            alias: 'Move Line Up',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 512  | 16 ,
+                linux: { primary: 512  | 16  },
+                weight: 100
+            },
+            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"
+                )),
+                order: 3
+            }
+        });
+    }
+}
+class MoveLinesDownAction extends AbstractMoveLinesAction {
+    constructor() {
+        super(true, {
+            id: 'editor.action.moveLinesDownAction',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.moveDown',
+                "Move Line Down"
+            )),
+            alias: 'Move Line Down',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 512  | 18 ,
+                linux: { primary: 512  | 18  },
+                weight: 100
+            },
+            menuOpts: {
+                menuId: MenuId.MenubarSelectionMenu,
+                group: '2_line',
+                title: ( localizeWithPath(
+                    'vs/editor/contrib/linesOperations/browser/linesOperations',
+                    { key: 'miMoveLinesDown', comment: ['&& denotes a mnemonic'] },
+                    "Move &&Line Down"
+                )),
+                order: 4
+            }
+        });
+    }
+}
+class AbstractSortLinesAction extends EditorAction {
+    constructor(descending, opts) {
+        super(opts);
+        this.descending = descending;
+    }
+    run(_accessor, editor) {
+        const selections = editor.getSelections() || [];
+        for (const selection of selections) {
+            if (!SortLinesCommand.canRun(editor.getModel(), selection, this.descending)) {
+                return;
+            }
+        }
+        const commands = [];
+        for (let i = 0, len = selections.length; i < len; i++) {
+            commands[i] = ( new SortLinesCommand(selections[i], this.descending));
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class SortLinesAscendingAction extends AbstractSortLinesAction {
+    constructor() {
+        super(false, {
+            id: 'editor.action.sortLinesAscending',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.sortAscending',
+                "Sort Lines Ascending"
+            )),
+            alias: 'Sort Lines Ascending',
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+class SortLinesDescendingAction extends AbstractSortLinesAction {
+    constructor() {
+        super(true, {
+            id: 'editor.action.sortLinesDescending',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.sortDescending',
+                "Sort Lines Descending"
+            )),
+            alias: 'Sort Lines Descending',
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+class DeleteDuplicateLinesAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.removeDuplicateLines',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.deleteDuplicates',
+                "Delete Duplicate Lines"
+            )),
+            alias: 'Delete Duplicate Lines',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    run(_accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const model = editor.getModel();
+        if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
+            return;
+        }
+        const edits = [];
+        const endCursorState = [];
+        let linesDeleted = 0;
+        for (const selection of editor.getSelections()) {
+            const uniqueLines = ( new Set());
+            const lines = [];
+            for (let i = selection.startLineNumber; i <= selection.endLineNumber; i++) {
+                const line = model.getLineContent(i);
+                if (( uniqueLines.has(line))) {
+                    continue;
+                }
+                lines.push(line);
+                uniqueLines.add(line);
+            }
+            const selectionToReplace = ( new Selection(
+                selection.startLineNumber,
+                1,
+                selection.endLineNumber,
+                model.getLineMaxColumn(selection.endLineNumber)
+            ));
+            const adjustedSelectionStart = selection.startLineNumber - linesDeleted;
+            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;
+        }
+        editor.pushUndoStop();
+        editor.executeEdits(this.id, edits, endCursorState);
+        editor.pushUndoStop();
+    }
+}
+class TrimTrailingWhitespaceAction extends EditorAction {
+    static { this.ID = 'editor.action.trimTrailingWhitespace'; }
+    constructor() {
+        super({
+            id: TrimTrailingWhitespaceAction.ID,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.trimTrailingWhitespace',
+                "Trim Trailing Whitespace"
+            )),
+            alias: 'Trim Trailing Whitespace',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 54 ),
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor, args) {
+        let cursors = [];
+        if (args.reason === 'auto-save') {
+            cursors = ( (editor.getSelections() || []).map(s => ( new Position(s.positionLineNumber, s.positionColumn))));
+        }
+        const selection = editor.getSelection();
+        if (selection === null) {
+            return;
+        }
+        const command = ( new TrimTrailingWhitespaceCommand(selection, cursors));
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, [command]);
+        editor.pushUndoStop();
+    }
+}
+class DeleteLinesAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.deleteLines',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.delete',
+                "Delete Line"
+            )),
+            alias: 'Delete Line',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048  | 1024  | 41 ,
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const ops = this._getLinesToRemove(editor);
+        const model = editor.getModel();
+        if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
+            return;
+        }
+        let linesDeleted = 0;
+        const edits = [];
+        const cursorState = [];
+        for (let i = 0, len = ops.length; i < len; i++) {
+            const op = ops[i];
+            let startLineNumber = op.startLineNumber;
+            let endLineNumber = op.endLineNumber;
+            let startColumn = 1;
+            let endColumn = model.getLineMaxColumn(endLineNumber);
+            if (endLineNumber < model.getLineCount()) {
+                endLineNumber += 1;
+                endColumn = 1;
+            }
+            else if (startLineNumber > 1) {
+                startLineNumber -= 1;
+                startColumn = model.getLineMaxColumn(startLineNumber);
+            }
+            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();
+        editor.executeEdits(this.id, edits, cursorState);
+        editor.pushUndoStop();
+    }
+    _getLinesToRemove(editor) {
+        const operations = ( editor.getSelections().map((s) => {
+            let endLineNumber = s.endLineNumber;
+            if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {
+                endLineNumber -= 1;
+            }
+            return {
+                startLineNumber: s.startLineNumber,
+                selectionStartColumn: s.selectionStartColumn,
+                endLineNumber: endLineNumber,
+                positionColumn: s.positionColumn
+            };
+        }));
+        operations.sort((a, b) => {
+            if (a.startLineNumber === b.startLineNumber) {
+                return a.endLineNumber - b.endLineNumber;
+            }
+            return a.startLineNumber - b.startLineNumber;
+        });
+        const mergedOperations = [];
+        let previousOperation = operations[0];
+        for (let i = 1; i < operations.length; i++) {
+            if (previousOperation.endLineNumber + 1 >= operations[i].startLineNumber) {
+                previousOperation.endLineNumber = operations[i].endLineNumber;
+            }
+            else {
+                mergedOperations.push(previousOperation);
+                previousOperation = operations[i];
+            }
+        }
+        mergedOperations.push(previousOperation);
+        return mergedOperations;
+    }
+}
+class IndentLinesAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.indentLines',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.indent',
+                "Indent Line"
+            )),
+            alias: 'Indent Line',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 94 ,
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        const viewModel = editor._getViewModel();
+        if (!viewModel) {
+            return;
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, TypeOperations.indent(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
+        editor.pushUndoStop();
+    }
+}
+class OutdentLinesAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.outdentLines',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.outdent',
+                "Outdent Line"
+            )),
+            alias: 'Outdent Line',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 92 ,
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        CoreEditingCommands.Outdent.runEditorCommand(_accessor, editor, null);
+    }
+}
+class InsertLineBeforeAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.insertLineBefore',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.insertBefore',
+                "Insert Line Above"
+            )),
+            alias: 'Insert Line Above',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 1024  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        const viewModel = editor._getViewModel();
+        if (!viewModel) {
+            return;
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, TypeOperations.lineInsertBefore(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
+    }
+}
+class InsertLineAfterAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.insertLineAfter',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.insertAfter',
+                "Insert Line Below"
+            )),
+            alias: 'Insert Line Below',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        const viewModel = editor._getViewModel();
+        if (!viewModel) {
+            return;
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, TypeOperations.lineInsertAfter(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));
+    }
+}
+class AbstractDeleteAllToBoundaryAction extends EditorAction {
+    run(_accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const primaryCursor = editor.getSelection();
+        const rangesToDelete = this._getRangesToDelete(editor);
+        const effectiveRanges = [];
+        for (let i = 0, count = rangesToDelete.length - 1; i < count; i++) {
+            const range = rangesToDelete[i];
+            const nextRange = rangesToDelete[i + 1];
+            if (Range.intersectRanges(range, nextRange) === null) {
+                effectiveRanges.push(range);
+            }
+            else {
+                rangesToDelete[i + 1] = Range.plusRange(range, nextRange);
+            }
+        }
+        effectiveRanges.push(rangesToDelete[rangesToDelete.length - 1]);
+        const endCursorState = this._getEndCursorState(primaryCursor, effectiveRanges);
+        const edits = ( effectiveRanges.map(range => {
+            return EditOperation.replace(range, '');
+        }));
+        editor.pushUndoStop();
+        editor.executeEdits(this.id, edits, endCursorState);
+        editor.pushUndoStop();
+    }
+}
+class DeleteAllLeftAction extends AbstractDeleteAllToBoundaryAction {
+    constructor() {
+        super({
+            id: 'deleteAllLeft',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.deleteAllLeft',
+                "Delete All Left"
+            )),
+            alias: 'Delete All Left',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 0,
+                mac: { primary: 2048  | 1  },
+                weight: 100
+            }
+        });
+    }
+    _getEndCursorState(primaryCursor, rangesToDelete) {
+        let endPrimaryCursor = null;
+        const endCursorState = [];
+        let deletedLines = 0;
+        rangesToDelete.forEach(range => {
+            let endCursor;
+            if (range.endColumn === 1 && deletedLines > 0) {
+                const newStartLine = range.startLineNumber - deletedLines;
+                endCursor = ( new Selection(newStartLine, range.startColumn, newStartLine, range.startColumn));
+            }
+            else {
+                endCursor = ( new Selection(
+                    range.startLineNumber,
+                    range.startColumn,
+                    range.startLineNumber,
+                    range.startColumn
+                ));
+            }
+            deletedLines += range.endLineNumber - range.startLineNumber;
+            if (range.intersectRanges(primaryCursor)) {
+                endPrimaryCursor = endCursor;
+            }
+            else {
+                endCursorState.push(endCursor);
+            }
+        });
+        if (endPrimaryCursor) {
+            endCursorState.unshift(endPrimaryCursor);
+        }
+        return endCursorState;
+    }
+    _getRangesToDelete(editor) {
+        const selections = editor.getSelections();
+        if (selections === null) {
+            return [];
+        }
+        let rangesToDelete = selections;
+        const model = editor.getModel();
+        if (model === null) {
+            return [];
+        }
+        rangesToDelete.sort(Range.compareRangesUsingStarts);
+        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));
+                }
+                else {
+                    return ( new Range(
+                        selection.startLineNumber,
+                        1,
+                        selection.startLineNumber,
+                        selection.startColumn
+                    ));
+                }
+            }
+            else {
+                return ( new Range(selection.startLineNumber, 1, selection.endLineNumber, selection.endColumn));
+            }
+        }));
+        return rangesToDelete;
+    }
+}
+class DeleteAllRightAction extends AbstractDeleteAllToBoundaryAction {
+    constructor() {
+        super({
+            id: 'deleteAllRight',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.deleteAllRight',
+                "Delete All Right"
+            )),
+            alias: 'Delete All Right',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 0,
+                mac: { primary: 256  | 41 , secondary: [2048  | 20 ] },
+                weight: 100
+            }
+        });
+    }
+    _getEndCursorState(primaryCursor, rangesToDelete) {
+        let endPrimaryCursor = null;
+        const endCursorState = [];
+        for (let i = 0, len = rangesToDelete.length, offset = 0; i < len; i++) {
+            const range = rangesToDelete[i];
+            const endCursor = ( new Selection(
+                range.startLineNumber - offset,
+                range.startColumn,
+                range.startLineNumber - offset,
+                range.startColumn
+            ));
+            if (range.intersectRanges(primaryCursor)) {
+                endPrimaryCursor = endCursor;
+            }
+            else {
+                endCursorState.push(endCursor);
+            }
+        }
+        if (endPrimaryCursor) {
+            endCursorState.unshift(endPrimaryCursor);
+        }
+        return endCursorState;
+    }
+    _getRangesToDelete(editor) {
+        const model = editor.getModel();
+        if (model === null) {
+            return [];
+        }
+        const selections = editor.getSelections();
+        if (selections === null) {
+            return [];
+        }
+        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));
+                }
+                else {
+                    return ( new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber, maxColumn));
+                }
+            }
+            return sel;
+        }));
+        rangesToDelete.sort(Range.compareRangesUsingStarts);
+        return rangesToDelete;
+    }
+}
+class JoinLinesAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.joinLines',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'lines.joinLines',
+                "Join Lines"
+            )),
+            alias: 'Join Lines',
+            precondition: EditorContextKeys.writable,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 0,
+                mac: { primary: 256  | 40  },
+                weight: 100
+            }
+        });
+    }
+    run(_accessor, editor) {
+        const selections = editor.getSelections();
+        if (selections === null) {
+            return;
+        }
+        let primaryCursor = editor.getSelection();
+        if (primaryCursor === null) {
+            return;
+        }
+        selections.sort(Range.compareRangesUsingStarts);
+        const reducedSelections = [];
+        const lastSelection = selections.reduce((previousValue, currentValue) => {
+            if (previousValue.isEmpty()) {
+                if (previousValue.endLineNumber === currentValue.startLineNumber) {
+                    if (primaryCursor.equalsSelection(previousValue)) {
+                        primaryCursor = currentValue;
+                    }
+                    return currentValue;
+                }
+                if (currentValue.startLineNumber > previousValue.endLineNumber + 1) {
+                    reducedSelections.push(previousValue);
+                    return currentValue;
+                }
+                else {
+                    return ( new Selection(
+                        previousValue.startLineNumber,
+                        previousValue.startColumn,
+                        currentValue.endLineNumber,
+                        currentValue.endColumn
+                    ));
+                }
+            }
+            else {
+                if (currentValue.startLineNumber > previousValue.endLineNumber) {
+                    reducedSelections.push(previousValue);
+                    return currentValue;
+                }
+                else {
+                    return ( new Selection(
+                        previousValue.startLineNumber,
+                        previousValue.startColumn,
+                        currentValue.endLineNumber,
+                        currentValue.endColumn
+                    ));
+                }
+            }
+        });
+        reducedSelections.push(lastSelection);
+        const model = editor.getModel();
+        if (model === null) {
+            return;
+        }
+        const edits = [];
+        const endCursorState = [];
+        let endPrimaryCursor = primaryCursor;
+        let lineOffset = 0;
+        for (let i = 0, len = reducedSelections.length; i < len; i++) {
+            const selection = reducedSelections[i];
+            const startLineNumber = selection.startLineNumber;
+            const startColumn = 1;
+            let columnDeltaOffset = 0;
+            let endLineNumber, endColumn;
+            const selectionEndPositionOffset = model.getLineLength(selection.endLineNumber) - selection.endColumn;
+            if (selection.isEmpty() || selection.startLineNumber === selection.endLineNumber) {
+                const position = selection.getStartPosition();
+                if (position.lineNumber < model.getLineCount()) {
+                    endLineNumber = startLineNumber + 1;
+                    endColumn = model.getLineMaxColumn(endLineNumber);
+                }
+                else {
+                    endLineNumber = position.lineNumber;
+                    endColumn = model.getLineMaxColumn(position.lineNumber);
+                }
+            }
+            else {
+                endLineNumber = selection.endLineNumber;
+                endColumn = model.getLineMaxColumn(endLineNumber);
+            }
+            let trimmedLinesContent = model.getLineContent(startLineNumber);
+            for (let i = startLineNumber + 1; i <= endLineNumber; i++) {
+                const lineText = model.getLineContent(i);
+                const firstNonWhitespaceIdx = model.getLineFirstNonWhitespaceColumn(i);
+                if (firstNonWhitespaceIdx >= 1) {
+                    let insertSpace = true;
+                    if (trimmedLinesContent === '') {
+                        insertSpace = false;
+                    }
+                    if (insertSpace && (trimmedLinesContent.charAt(trimmedLinesContent.length - 1) === ' ' ||
+                        trimmedLinesContent.charAt(trimmedLinesContent.length - 1) === '\t')) {
+                        insertSpace = false;
+                        trimmedLinesContent = trimmedLinesContent.replace(/[\s\uFEFF\xA0]+$/g, ' ');
+                    }
+                    const lineTextWithoutIndent = lineText.substr(firstNonWhitespaceIdx - 1);
+                    trimmedLinesContent += (insertSpace ? ' ' : '') + lineTextWithoutIndent;
+                    if (insertSpace) {
+                        columnDeltaOffset = lineTextWithoutIndent.length + 1;
+                    }
+                    else {
+                        columnDeltaOffset = lineTextWithoutIndent.length;
+                    }
+                }
+                else {
+                    columnDeltaOffset = 0;
+                }
+            }
+            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(
+                        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(
+                            selection.startLineNumber - lineOffset,
+                            selection.startColumn,
+                            selection.endLineNumber - lineOffset,
+                            selection.endColumn
+                        ));
+                    }
+                    else {
+                        edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));
+                        resultSelection = ( new Selection(
+                            selection.startLineNumber - lineOffset,
+                            selection.startColumn,
+                            selection.startLineNumber - lineOffset,
+                            trimmedLinesContent.length - selectionEndPositionOffset
+                        ));
+                    }
+                }
+                if (Range.intersectRanges(deleteSelection, primaryCursor) !== null) {
+                    endPrimaryCursor = resultSelection;
+                }
+                else {
+                    endCursorState.push(resultSelection);
+                }
+            }
+            lineOffset += deleteSelection.endLineNumber - deleteSelection.startLineNumber;
+        }
+        endCursorState.unshift(endPrimaryCursor);
+        editor.pushUndoStop();
+        editor.executeEdits(this.id, edits, endCursorState);
+        editor.pushUndoStop();
+    }
+}
+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"
+            )),
+            alias: 'Transpose Characters around the Cursor',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    run(_accessor, editor) {
+        const selections = editor.getSelections();
+        if (selections === null) {
+            return;
+        }
+        const model = editor.getModel();
+        if (model === null) {
+            return;
+        }
+        const commands = [];
+        for (let i = 0, len = selections.length; i < len; i++) {
+            const selection = selections[i];
+            if (!selection.isEmpty()) {
+                continue;
+            }
+            const cursor = selection.getStartPosition();
+            const maxColumn = model.getLineMaxColumn(cursor.lineNumber);
+            if (cursor.column >= maxColumn) {
+                if (cursor.lineNumber === model.getLineCount()) {
+                    continue;
+                }
+                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(
+                    cursor.lineNumber,
+                    Math.max(1, cursor.column - 1),
+                    cursor.lineNumber + 1,
+                    1
+                )), chars)));
+            }
+            else {
+                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)))));
+            }
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class AbstractCaseAction extends EditorAction {
+    run(_accessor, editor) {
+        const selections = editor.getSelections();
+        if (selections === null) {
+            return;
+        }
+        const model = editor.getModel();
+        if (model === null) {
+            return;
+        }
+        const wordSeparators = editor.getOption(129 );
+        const textEdits = [];
+        for (const selection of selections) {
+            if (selection.isEmpty()) {
+                const cursor = selection.getStartPosition();
+                const word = editor.getConfiguredWordAtPosition(cursor);
+                if (!word) {
+                    continue;
+                }
+                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)));
+            }
+            else {
+                const text = model.getValueInRange(selection);
+                textEdits.push(EditOperation.replace(selection, this._modifyText(text, wordSeparators)));
+            }
+        }
+        editor.pushUndoStop();
+        editor.executeEdits(this.id, textEdits);
+        editor.pushUndoStop();
+    }
+}
+class UpperCaseAction extends AbstractCaseAction {
+    constructor() {
+        super({
+            id: 'editor.action.transformToUppercase',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'editor.transformToUppercase',
+                "Transform to Uppercase"
+            )),
+            alias: 'Transform to Uppercase',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, wordSeparators) {
+        return text.toLocaleUpperCase();
+    }
+}
+class LowerCaseAction extends AbstractCaseAction {
+    constructor() {
+        super({
+            id: 'editor.action.transformToLowercase',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'editor.transformToLowercase',
+                "Transform to Lowercase"
+            )),
+            alias: 'Transform to Lowercase',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, wordSeparators) {
+        return text.toLocaleLowerCase();
+    }
+}
+class BackwardsCompatibleRegExp {
+    constructor(_pattern, _flags) {
+        this._pattern = _pattern;
+        this._flags = _flags;
+        this._actual = null;
+        this._evaluated = false;
+    }
+    get() {
+        if (!this._evaluated) {
+            this._evaluated = true;
+            try {
+                this._actual = ( new RegExp(this._pattern, this._flags));
+            }
+            catch (err) {
+            }
+        }
+        return this._actual;
+    }
+    isSupported() {
+        return (this.get() !== null);
+    }
+}
+class TitleCaseAction extends AbstractCaseAction {
+    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"
+            )),
+            alias: 'Transform to Title Case',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, wordSeparators) {
+        const titleBoundary = TitleCaseAction.titleBoundary.get();
+        if (!titleBoundary) {
+            return text;
+        }
+        return text
+            .toLocaleLowerCase()
+            .replace(titleBoundary, (b) => b.toLocaleUpperCase());
+    }
+}
+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')); }
+    constructor() {
+        super({
+            id: 'editor.action.transformToSnakecase',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'editor.transformToSnakecase',
+                "Transform to Snake Case"
+            )),
+            alias: 'Transform to Snake Case',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, wordSeparators) {
+        const caseBoundary = SnakeCaseAction.caseBoundary.get();
+        const singleLetters = SnakeCaseAction.singleLetters.get();
+        if (!caseBoundary || !singleLetters) {
+            return text;
+        }
+        return (text
+            .replace(caseBoundary, '$1_$2')
+            .replace(singleLetters, '$1_$2$3')
+            .toLocaleLowerCase());
+    }
+}
+class CamelCaseAction extends AbstractCaseAction {
+    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"
+            )),
+            alias: 'Transform to Camel Case',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, wordSeparators) {
+        const wordBoundary = CamelCaseAction.wordBoundary.get();
+        if (!wordBoundary) {
+            return text;
+        }
+        const words = text.split(wordBoundary);
+        const firstWord = words.shift();
+        return firstWord + ( words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1)))
+            .join('');
+    }
+}
+class KebabCaseAction extends AbstractCaseAction {
+    static isSupported() {
+        const areAllRegexpsSupported = [
+            this.caseBoundary,
+            this.singleLetters,
+            this.underscoreBoundary,
+        ].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')); }
+    constructor() {
+        super({
+            id: 'editor.action.transformToKebabcase',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/linesOperations/browser/linesOperations',
+                'editor.transformToKebabcase',
+                'Transform to Kebab Case'
+            )),
+            alias: 'Transform to Kebab Case',
+            precondition: EditorContextKeys.writable
+        });
+    }
+    _modifyText(text, _) {
+        const caseBoundary = KebabCaseAction.caseBoundary.get();
+        const singleLetters = KebabCaseAction.singleLetters.get();
+        const underscoreBoundary = KebabCaseAction.underscoreBoundary.get();
+        if (!caseBoundary || !singleLetters || !underscoreBoundary) {
+            return text;
+        }
+        return text
+            .replace(underscoreBoundary, '$1-$3')
+            .replace(caseBoundary, '$1-$2')
+            .replace(singleLetters, '$1-$2')
+            .toLocaleLowerCase();
+    }
+}
+registerEditorAction(CopyLinesUpAction);
+registerEditorAction(CopyLinesDownAction);
+registerEditorAction(DuplicateSelectionAction);
+registerEditorAction(MoveLinesUpAction);
+registerEditorAction(MoveLinesDownAction);
+registerEditorAction(SortLinesAscendingAction);
+registerEditorAction(SortLinesDescendingAction);
+registerEditorAction(DeleteDuplicateLinesAction);
+registerEditorAction(TrimTrailingWhitespaceAction);
+registerEditorAction(DeleteLinesAction);
+registerEditorAction(IndentLinesAction);
+registerEditorAction(OutdentLinesAction);
+registerEditorAction(InsertLineBeforeAction);
+registerEditorAction(InsertLineAfterAction);
+registerEditorAction(DeleteAllLeftAction);
+registerEditorAction(DeleteAllRightAction);
+registerEditorAction(JoinLinesAction);
+registerEditorAction(TransposeAction);
+registerEditorAction(UpperCaseAction);
+registerEditorAction(LowerCaseAction);
+if (SnakeCaseAction.caseBoundary.isSupported() && SnakeCaseAction.singleLetters.isSupported()) {
+    registerEditorAction(SnakeCaseAction);
+}
+if (CamelCaseAction.wordBoundary.isSupported()) {
+    registerEditorAction(CamelCaseAction);
+}
+if (TitleCaseAction.titleBoundary.isSupported()) {
+    registerEditorAction(TitleCaseAction);
+}
+if (KebabCaseAction.isSupported()) {
+    registerEditorAction(KebabCaseAction);
+}
+export { AbstractCaseAction, AbstractDeleteAllToBoundaryAction, AbstractSortLinesAction, CamelCaseAction, DeleteAllLeftAction, DeleteAllRightAction, DeleteDuplicateLinesAction, DeleteLinesAction, DuplicateSelectionAction, IndentLinesAction, InsertLineAfterAction, InsertLineBeforeAction, JoinLinesAction, KebabCaseAction, LowerCaseAction, SnakeCaseAction, SortLinesAscendingAction, SortLinesDescendingAction, TitleCaseAction, TransposeAction, TrimTrailingWhitespaceAction, UpperCaseAction };