claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/bracketMatching/browser/bracketMatching.js

@@ -0,0 +1,351 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import './bracketMatching.css';
+import { EditorAction, registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.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 { OverviewRulerLane } from '../../../common/model.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import * as nls from '../../../../nls.js';
+import { MenuId, MenuRegistry } from '../../../../platform/actions/common/actions.js';
+import { registerColor } from '../../../../platform/theme/common/colorRegistry.js';
+import { themeColorFromId } from '../../../../platform/theme/common/themeService.js';
+const overviewRulerBracketMatchForeground = registerColor('editorOverviewRuler.bracketMatchForeground', { dark: '#A0A0A0', light: '#A0A0A0', hcDark: '#A0A0A0', hcLight: '#A0A0A0' }, nls.localize('overviewRulerBracketMatchForeground', 'Overview ruler marker color for matching brackets.'));
+class JumpToBracketAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.jumpToBracket',
+            label: nls.localize('smartSelect.jumpBracket', "Go to Bracket"),
+            alias: 'Go to Bracket',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 93 /* KeyCode.Backslash */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(accessor, editor) {
+        var _a;
+        (_a = BracketMatchingController.get(editor)) === null || _a === void 0 ? void 0 : _a.jumpToBracket();
+    }
+}
+class SelectToBracketAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.selectToBracket',
+            label: nls.localize('smartSelect.selectToBracket', "Select to Bracket"),
+            alias: 'Select to Bracket',
+            precondition: undefined,
+            metadata: {
+                description: nls.localize2('smartSelect.selectToBracketDescription', "Select the text inside and including the brackets or curly braces"),
+                args: [{
+                        name: 'args',
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                'selectBrackets': {
+                                    type: 'boolean',
+                                    default: true
+                                }
+                            },
+                        }
+                    }]
+            }
+        });
+    }
+    run(accessor, editor, args) {
+        var _a;
+        let selectBrackets = true;
+        if (args && args.selectBrackets === false) {
+            selectBrackets = false;
+        }
+        (_a = BracketMatchingController.get(editor)) === null || _a === void 0 ? void 0 : _a.selectToBracket(selectBrackets);
+    }
+}
+class RemoveBracketsAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.removeBrackets',
+            label: nls.localize('smartSelect.removeBrackets', "Remove Brackets"),
+            alias: 'Remove Brackets',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 1 /* KeyCode.Backspace */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(accessor, editor) {
+        var _a;
+        (_a = BracketMatchingController.get(editor)) === null || _a === void 0 ? void 0 : _a.removeBrackets(this.id);
+    }
+}
+class BracketsData {
+    constructor(position, brackets, options) {
+        this.position = position;
+        this.brackets = brackets;
+        this.options = options;
+    }
+}
+export class BracketMatchingController extends Disposable {
+    static get(editor) {
+        return editor.getContribution(BracketMatchingController.ID);
+    }
+    constructor(editor) {
+        super();
+        this._editor = editor;
+        this._lastBracketsData = [];
+        this._lastVersionId = 0;
+        this._decorations = this._editor.createDecorationsCollection();
+        this._updateBracketsSoon = this._register(new RunOnceScheduler(() => this._updateBrackets(), 50));
+        this._matchBrackets = this._editor.getOption(71 /* EditorOption.matchBrackets */);
+        this._updateBracketsSoon.schedule();
+        this._register(editor.onDidChangeCursorPosition((e) => {
+            if (this._matchBrackets === 'never') {
+                // Early exit if nothing needs to be done!
+                // Leave some form of early exit check here if you wish to continue being a cursor position change listener ;)
+                return;
+            }
+            this._updateBracketsSoon.schedule();
+        }));
+        this._register(editor.onDidChangeModelContent((e) => {
+            this._updateBracketsSoon.schedule();
+        }));
+        this._register(editor.onDidChangeModel((e) => {
+            this._lastBracketsData = [];
+            this._updateBracketsSoon.schedule();
+        }));
+        this._register(editor.onDidChangeModelLanguageConfiguration((e) => {
+            this._lastBracketsData = [];
+            this._updateBracketsSoon.schedule();
+        }));
+        this._register(editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(71 /* EditorOption.matchBrackets */)) {
+                this._matchBrackets = this._editor.getOption(71 /* EditorOption.matchBrackets */);
+                this._decorations.clear();
+                this._lastBracketsData = [];
+                this._lastVersionId = 0;
+                this._updateBracketsSoon.schedule();
+            }
+        }));
+        this._register(editor.onDidBlurEditorWidget(() => {
+            this._updateBracketsSoon.schedule();
+        }));
+        this._register(editor.onDidFocusEditorWidget(() => {
+            this._updateBracketsSoon.schedule();
+        }));
+    }
+    jumpToBracket() {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        const newSelections = this._editor.getSelections().map(selection => {
+            const position = selection.getStartPosition();
+            // find matching brackets if position is on a bracket
+            const brackets = model.bracketPairs.matchBracket(position);
+            let newCursorPosition = null;
+            if (brackets) {
+                if (brackets[0].containsPosition(position) && !brackets[1].containsPosition(position)) {
+                    newCursorPosition = brackets[1].getStartPosition();
+                }
+                else if (brackets[1].containsPosition(position)) {
+                    newCursorPosition = brackets[0].getStartPosition();
+                }
+            }
+            else {
+                // find the enclosing brackets if the position isn't on a matching bracket
+                const enclosingBrackets = model.bracketPairs.findEnclosingBrackets(position);
+                if (enclosingBrackets) {
+                    newCursorPosition = enclosingBrackets[1].getStartPosition();
+                }
+                else {
+                    // no enclosing brackets, try the very first next bracket
+                    const nextBracket = model.bracketPairs.findNextBracket(position);
+                    if (nextBracket && nextBracket.range) {
+                        newCursorPosition = nextBracket.range.getStartPosition();
+                    }
+                }
+            }
+            if (newCursorPosition) {
+                return new Selection(newCursorPosition.lineNumber, newCursorPosition.column, newCursorPosition.lineNumber, newCursorPosition.column);
+            }
+            return new Selection(position.lineNumber, position.column, position.lineNumber, position.column);
+        });
+        this._editor.setSelections(newSelections);
+        this._editor.revealRange(newSelections[0]);
+    }
+    selectToBracket(selectBrackets) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        const newSelections = [];
+        this._editor.getSelections().forEach(selection => {
+            const position = selection.getStartPosition();
+            let brackets = model.bracketPairs.matchBracket(position);
+            if (!brackets) {
+                brackets = model.bracketPairs.findEnclosingBrackets(position);
+                if (!brackets) {
+                    const nextBracket = model.bracketPairs.findNextBracket(position);
+                    if (nextBracket && nextBracket.range) {
+                        brackets = model.bracketPairs.matchBracket(nextBracket.range.getStartPosition());
+                    }
+                }
+            }
+            let selectFrom = null;
+            let selectTo = null;
+            if (brackets) {
+                brackets.sort(Range.compareRangesUsingStarts);
+                const [open, close] = brackets;
+                selectFrom = selectBrackets ? open.getStartPosition() : open.getEndPosition();
+                selectTo = selectBrackets ? close.getEndPosition() : close.getStartPosition();
+                if (close.containsPosition(position)) {
+                    // select backwards if the cursor was on the closing bracket
+                    const tmp = selectFrom;
+                    selectFrom = selectTo;
+                    selectTo = tmp;
+                }
+            }
+            if (selectFrom && selectTo) {
+                newSelections.push(new Selection(selectFrom.lineNumber, selectFrom.column, selectTo.lineNumber, selectTo.column));
+            }
+        });
+        if (newSelections.length > 0) {
+            this._editor.setSelections(newSelections);
+            this._editor.revealRange(newSelections[0]);
+        }
+    }
+    removeBrackets(editSource) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        this._editor.getSelections().forEach((selection) => {
+            const position = selection.getPosition();
+            let brackets = model.bracketPairs.matchBracket(position);
+            if (!brackets) {
+                brackets = model.bracketPairs.findEnclosingBrackets(position);
+            }
+            if (brackets) {
+                this._editor.pushUndoStop();
+                this._editor.executeEdits(editSource, [
+                    { range: brackets[0], text: '' },
+                    { range: brackets[1], text: '' }
+                ]);
+                this._editor.pushUndoStop();
+            }
+        });
+    }
+    _updateBrackets() {
+        if (this._matchBrackets === 'never') {
+            return;
+        }
+        this._recomputeBrackets();
+        const newDecorations = [];
+        let newDecorationsLen = 0;
+        for (const bracketData of this._lastBracketsData) {
+            const brackets = bracketData.brackets;
+            if (brackets) {
+                newDecorations[newDecorationsLen++] = { range: brackets[0], options: bracketData.options };
+                newDecorations[newDecorationsLen++] = { range: brackets[1], options: bracketData.options };
+            }
+        }
+        this._decorations.set(newDecorations);
+    }
+    _recomputeBrackets() {
+        if (!this._editor.hasModel() || !this._editor.hasWidgetFocus()) {
+            // no model or no focus => no brackets!
+            this._lastBracketsData = [];
+            this._lastVersionId = 0;
+            return;
+        }
+        const selections = this._editor.getSelections();
+        if (selections.length > 100) {
+            // no bracket matching for high numbers of selections
+            this._lastBracketsData = [];
+            this._lastVersionId = 0;
+            return;
+        }
+        const model = this._editor.getModel();
+        const versionId = model.getVersionId();
+        let previousData = [];
+        if (this._lastVersionId === versionId) {
+            // use the previous data only if the model is at the same version id
+            previousData = this._lastBracketsData;
+        }
+        const positions = [];
+        let positionsLen = 0;
+        for (let i = 0, len = selections.length; i < len; i++) {
+            const selection = selections[i];
+            if (selection.isEmpty()) {
+                // will bracket match a cursor only if the selection is collapsed
+                positions[positionsLen++] = selection.getStartPosition();
+            }
+        }
+        // sort positions for `previousData` cache hits
+        if (positions.length > 1) {
+            positions.sort(Position.compare);
+        }
+        const newData = [];
+        let newDataLen = 0;
+        let previousIndex = 0;
+        const previousLen = previousData.length;
+        for (let i = 0, len = positions.length; i < len; i++) {
+            const position = positions[i];
+            while (previousIndex < previousLen && previousData[previousIndex].position.isBefore(position)) {
+                previousIndex++;
+            }
+            if (previousIndex < previousLen && previousData[previousIndex].position.equals(position)) {
+                newData[newDataLen++] = previousData[previousIndex];
+            }
+            else {
+                let brackets = model.bracketPairs.matchBracket(position, 20 /* give at most 20ms to compute */);
+                let options = BracketMatchingController._DECORATION_OPTIONS_WITH_OVERVIEW_RULER;
+                if (!brackets && this._matchBrackets === 'always') {
+                    brackets = model.bracketPairs.findEnclosingBrackets(position, 20 /* give at most 20ms to compute */);
+                    options = BracketMatchingController._DECORATION_OPTIONS_WITHOUT_OVERVIEW_RULER;
+                }
+                newData[newDataLen++] = new BracketsData(position, brackets, options);
+            }
+        }
+        this._lastBracketsData = newData;
+        this._lastVersionId = versionId;
+    }
+}
+BracketMatchingController.ID = 'editor.contrib.bracketMatchingController';
+BracketMatchingController._DECORATION_OPTIONS_WITH_OVERVIEW_RULER = ModelDecorationOptions.register({
+    description: 'bracket-match-overview',
+    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+    className: 'bracket-match',
+    overviewRuler: {
+        color: themeColorFromId(overviewRulerBracketMatchForeground),
+        position: OverviewRulerLane.Center
+    }
+});
+BracketMatchingController._DECORATION_OPTIONS_WITHOUT_OVERVIEW_RULER = ModelDecorationOptions.register({
+    description: 'bracket-match-no-overview',
+    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+    className: 'bracket-match'
+});
+registerEditorContribution(BracketMatchingController.ID, BracketMatchingController, 1 /* EditorContributionInstantiation.AfterFirstRender */);
+registerEditorAction(SelectToBracketAction);
+registerEditorAction(JumpToBracketAction);
+registerEditorAction(RemoveBracketsAction);
+// Go to menu
+MenuRegistry.appendMenuItem(MenuId.MenubarGoMenu, {
+    group: '5_infile_nav',
+    command: {
+        id: 'editor.action.jumpToBracket',
+        title: nls.localize({ key: 'miGoToBracket', comment: ['&& denotes a mnemonic'] }, "Go to &&Bracket")
+    },
+    order: 2
+});

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/caretOperations/browser/caretOperations.js

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { EditorAction, registerEditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { MoveCaretCommand } from './moveCaretCommand.js';
+import * as nls from '../../../../nls.js';
+class MoveCaretAction extends EditorAction {
+    constructor(left, opts) {
+        super(opts);
+        this.left = left;
+    }
+    run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const commands = [];
+        const selections = editor.getSelections();
+        for (const selection of selections) {
+            commands.push(new MoveCaretCommand(selection, this.left));
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class MoveCaretLeftAction extends MoveCaretAction {
+    constructor() {
+        super(true, {
+            id: 'editor.action.moveCarretLeftAction',
+            label: nls.localize('caret.moveLeft', "Move Selected Text Left"),
+            alias: 'Move Selected Text Left',
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+class MoveCaretRightAction extends MoveCaretAction {
+    constructor() {
+        super(false, {
+            id: 'editor.action.moveCarretRightAction',
+            label: nls.localize('caret.moveRight', "Move Selected Text Right"),
+            alias: 'Move Selected Text Right',
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+registerEditorAction(MoveCaretLeftAction);
+registerEditorAction(MoveCaretRightAction);

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/clipboard/browser/clipboard.js

@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as browser from '../../../../base/browser/browser.js';
+import { getActiveDocument } from '../../../../base/browser/dom.js';
+import * as platform from '../../../../base/common/platform.js';
+import { CopyOptions, InMemoryClipboardMetadataManager } from '../../../browser/controller/textAreaInput.js';
+import { EditorAction, MultiCommand, registerEditorAction } from '../../../browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import * as nls from '../../../../nls.js';
+import { MenuId, MenuRegistry } from '../../../../platform/actions/common/actions.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+const CLIPBOARD_CONTEXT_MENU_GROUP = '9_cutcopypaste';
+const supportsCut = (platform.isNative || document.queryCommandSupported('cut'));
+const supportsCopy = (platform.isNative || document.queryCommandSupported('copy'));
+// Firefox only supports navigator.clipboard.readText() in browser extensions.
+// See https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/readText#Browser_compatibility
+// When loading over http, navigator.clipboard can be undefined. See https://github.com/microsoft/monaco-editor/issues/2313
+const supportsPaste = (typeof navigator.clipboard === 'undefined' || browser.isFirefox) ? document.queryCommandSupported('paste') : true;
+function registerCommand(command) {
+    command.register();
+    return command;
+}
+export const CutAction = supportsCut ? registerCommand(new MultiCommand({
+    id: 'editor.action.clipboardCutAction',
+    precondition: undefined,
+    kbOpts: (
+    // Do not bind cut keybindings in the browser,
+    // since browsers do that for us and it avoids security prompts
+    platform.isNative ? {
+        primary: 2048 /* KeyMod.CtrlCmd */ | 54 /* KeyCode.KeyX */,
+        win: { primary: 2048 /* KeyMod.CtrlCmd */ | 54 /* KeyCode.KeyX */, secondary: [1024 /* KeyMod.Shift */ | 20 /* KeyCode.Delete */] },
+        weight: 100 /* KeybindingWeight.EditorContrib */
+    } : undefined),
+    menuOpts: [{
+            menuId: MenuId.MenubarEditMenu,
+            group: '2_ccp',
+            title: nls.localize({ key: 'miCut', comment: ['&& denotes a mnemonic'] }, "Cu&&t"),
+            order: 1
+        }, {
+            menuId: MenuId.EditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.cutLabel', "Cut"),
+            when: EditorContextKeys.writable,
+            order: 1,
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: nls.localize('actions.clipboard.cutLabel', "Cut"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.cutLabel', "Cut"),
+            when: EditorContextKeys.writable,
+            order: 1,
+        }]
+})) : undefined;
+export const CopyAction = supportsCopy ? registerCommand(new MultiCommand({
+    id: 'editor.action.clipboardCopyAction',
+    precondition: undefined,
+    kbOpts: (
+    // Do not bind copy keybindings in the browser,
+    // since browsers do that for us and it avoids security prompts
+    platform.isNative ? {
+        primary: 2048 /* KeyMod.CtrlCmd */ | 33 /* KeyCode.KeyC */,
+        win: { primary: 2048 /* KeyMod.CtrlCmd */ | 33 /* KeyCode.KeyC */, secondary: [2048 /* KeyMod.CtrlCmd */ | 19 /* KeyCode.Insert */] },
+        weight: 100 /* KeybindingWeight.EditorContrib */
+    } : undefined),
+    menuOpts: [{
+            menuId: MenuId.MenubarEditMenu,
+            group: '2_ccp',
+            title: nls.localize({ key: 'miCopy', comment: ['&& denotes a mnemonic'] }, "&&Copy"),
+            order: 2
+        }, {
+            menuId: MenuId.EditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.copyLabel', "Copy"),
+            order: 2,
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: nls.localize('actions.clipboard.copyLabel', "Copy"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.copyLabel', "Copy"),
+            order: 2,
+        }]
+})) : undefined;
+MenuRegistry.appendMenuItem(MenuId.MenubarEditMenu, { submenu: MenuId.MenubarCopy, title: { value: nls.localize('copy as', "Copy As"), original: 'Copy As', }, group: '2_ccp', order: 3 });
+MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextCopy, title: { value: nls.localize('copy as', "Copy As"), original: 'Copy As', }, group: CLIPBOARD_CONTEXT_MENU_GROUP, order: 3 });
+MenuRegistry.appendMenuItem(MenuId.EditorContext, { submenu: MenuId.EditorContextShare, title: { value: nls.localize('share', "Share"), original: 'Share', }, group: '11_share', order: -1, when: ContextKeyExpr.and(ContextKeyExpr.notEquals('resourceScheme', 'output'), EditorContextKeys.editorTextFocus) });
+MenuRegistry.appendMenuItem(MenuId.EditorTitleContext, { submenu: MenuId.EditorTitleContextShare, title: { value: nls.localize('share', "Share"), original: 'Share', }, group: '11_share', order: -1 });
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, { submenu: MenuId.ExplorerContextShare, title: { value: nls.localize('share', "Share"), original: 'Share', }, group: '11_share', order: -1 });
+export const PasteAction = supportsPaste ? registerCommand(new MultiCommand({
+    id: 'editor.action.clipboardPasteAction',
+    precondition: undefined,
+    kbOpts: (
+    // Do not bind paste keybindings in the browser,
+    // since browsers do that for us and it avoids security prompts
+    platform.isNative ? {
+        primary: 2048 /* KeyMod.CtrlCmd */ | 52 /* KeyCode.KeyV */,
+        win: { primary: 2048 /* KeyMod.CtrlCmd */ | 52 /* KeyCode.KeyV */, secondary: [1024 /* KeyMod.Shift */ | 19 /* KeyCode.Insert */] },
+        linux: { primary: 2048 /* KeyMod.CtrlCmd */ | 52 /* KeyCode.KeyV */, secondary: [1024 /* KeyMod.Shift */ | 19 /* KeyCode.Insert */] },
+        weight: 100 /* KeybindingWeight.EditorContrib */
+    } : undefined),
+    menuOpts: [{
+            menuId: MenuId.MenubarEditMenu,
+            group: '2_ccp',
+            title: nls.localize({ key: 'miPaste', comment: ['&& denotes a mnemonic'] }, "&&Paste"),
+            order: 4
+        }, {
+            menuId: MenuId.EditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.pasteLabel', "Paste"),
+            when: EditorContextKeys.writable,
+            order: 4,
+        }, {
+            menuId: MenuId.CommandPalette,
+            group: '',
+            title: nls.localize('actions.clipboard.pasteLabel', "Paste"),
+            order: 1
+        }, {
+            menuId: MenuId.SimpleEditorContext,
+            group: CLIPBOARD_CONTEXT_MENU_GROUP,
+            title: nls.localize('actions.clipboard.pasteLabel', "Paste"),
+            when: EditorContextKeys.writable,
+            order: 4,
+        }]
+})) : undefined;
+class ExecCommandCopyWithSyntaxHighlightingAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.clipboardCopyWithSyntaxHighlightingAction',
+            label: nls.localize('actions.clipboard.copyWithSyntaxHighlightingLabel', "Copy With Syntax Highlighting"),
+            alias: 'Copy With Syntax Highlighting',
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 0,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const emptySelectionClipboard = editor.getOption(37 /* EditorOption.emptySelectionClipboard */);
+        if (!emptySelectionClipboard && editor.getSelection().isEmpty()) {
+            return;
+        }
+        CopyOptions.forceCopyWithSyntaxHighlighting = true;
+        editor.focus();
+        editor.getContainerDomNode().ownerDocument.execCommand('copy');
+        CopyOptions.forceCopyWithSyntaxHighlighting = false;
+    }
+}
+function registerExecCommandImpl(target, browserCommand) {
+    if (!target) {
+        return;
+    }
+    // 1. handle case when focus is in editor.
+    target.addImplementation(10000, 'code-editor', (accessor, args) => {
+        // Only if editor text focus (i.e. not if editor has widget focus).
+        const focusedEditor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
+        if (focusedEditor && focusedEditor.hasTextFocus()) {
+            // Do not execute if there is no selection and empty selection clipboard is off
+            const emptySelectionClipboard = focusedEditor.getOption(37 /* EditorOption.emptySelectionClipboard */);
+            const selection = focusedEditor.getSelection();
+            if (selection && selection.isEmpty() && !emptySelectionClipboard) {
+                return true;
+            }
+            focusedEditor.getContainerDomNode().ownerDocument.execCommand(browserCommand);
+            return true;
+        }
+        return false;
+    });
+    // 2. (default) handle case when focus is somewhere else.
+    target.addImplementation(0, 'generic-dom', (accessor, args) => {
+        getActiveDocument().execCommand(browserCommand);
+        return true;
+    });
+}
+registerExecCommandImpl(CutAction, 'cut');
+registerExecCommandImpl(CopyAction, 'copy');
+if (PasteAction) {
+    // 1. Paste: handle case when focus is in editor.
+    PasteAction.addImplementation(10000, 'code-editor', (accessor, args) => {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const clipboardService = accessor.get(IClipboardService);
+        // Only if editor text focus (i.e. not if editor has widget focus).
+        const focusedEditor = codeEditorService.getFocusedCodeEditor();
+        if (focusedEditor && focusedEditor.hasTextFocus()) {
+            const result = focusedEditor.getContainerDomNode().ownerDocument.execCommand('paste');
+            // Use the clipboard service if document.execCommand('paste') was not successful
+            if (!result && platform.isWeb) {
+                return (async () => {
+                    const clipboardText = await clipboardService.readText();
+                    if (clipboardText !== '') {
+                        const metadata = InMemoryClipboardMetadataManager.INSTANCE.get(clipboardText);
+                        let pasteOnNewLine = false;
+                        let multicursorText = null;
+                        let mode = null;
+                        if (metadata) {
+                            pasteOnNewLine = (focusedEditor.getOption(37 /* EditorOption.emptySelectionClipboard */) && !!metadata.isFromEmptySelection);
+                            multicursorText = (typeof metadata.multicursorText !== 'undefined' ? metadata.multicursorText : null);
+                            mode = metadata.mode;
+                        }
+                        focusedEditor.trigger('keyboard', "paste" /* Handler.Paste */, {
+                            text: clipboardText,
+                            pasteOnNewLine,
+                            multicursorText,
+                            mode
+                        });
+                    }
+                })();
+            }
+            return true;
+        }
+        return false;
+    });
+    // 2. Paste: (default) handle case when focus is somewhere else.
+    PasteAction.addImplementation(0, 'generic-dom', (accessor, args) => {
+        getActiveDocument().execCommand('paste');
+        return true;
+    });
+}
+if (supportsCopy) {
+    registerEditorAction(ExecCommandCopyWithSyntaxHighlightingAction);
+}