@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/contrib/debug/common/debugModel.js

@@ -373,7 +373,7 @@ class StackFrame {
                         let id = 0;
                         do {
                             id = stringHash(`${rs.name}:${rs.line}:${rs.column}`, id);
-                        } while (usedIds.has(id));
+                        } while (( (usedIds.has(id))));
                         usedIds.add(id);
                         return (
                              (new Scope(
@@ -923,7 +923,7 @@ class ExceptionBreakpoint extends BaseBreakpoint {
         return true;
     }
     isSupportedSession(sessionId) {
-        return sessionId ? this.supportedSessions.has(sessionId) : this.fallback;
+        return sessionId ? ( (this.supportedSessions.has(sessionId))) : this.fallback;
     }
     matches(filter) {
         return this.filter === filter.filter && this.label === filter.label && this.supportsCondition === !!filter.supportsCondition && this.conditionDescription === filter.conditionDescription && this.description === filter.description;
@@ -955,6 +955,15 @@ class InstructionBreakpoint extends BaseBreakpoint {
         return this.instructionReference;
     }
 }
+class ThreadAndSessionIds {
+    constructor(sessionId, threadId) {
+        this.sessionId = sessionId;
+        this.threadId = threadId;
+    }
+    getId() {
+        return `${this.sessionId}:${this.threadId}`;
+    }
+}
 let DebugModel = class DebugModel {
     constructor(debugStorage, textFileService, uriIdentityService, logService) {
         this.textFileService = textFileService;
@@ -1056,7 +1065,7 @@ let DebugModel = class DebugModel {
             let topCallStack = Promise.resolve();
             const wholeCallStack = ( (new Promise((c, e) => {
                 topCallStack = thread.fetchCallStack(1).then(() => {
-                    if (!this.schedulers.has(thread.getId())) {
+                    if (!( (this.schedulers.has(thread.getId())))) {
                         this.schedulers.set(thread.getId(), ( (new RunOnceScheduler(() => {
                             thread.fetchCallStack(19).then(() => {
                                 const stale = thread.getStaleCallStack();
@@ -1448,4 +1457,4 @@ DebugModel = ( (__decorate([
     ( (__param(2, IUriIdentityService))),
     ( (__param(3, ILogService)))
 ], DebugModel)));
-export { BaseBreakpoint, Breakpoint, DataBreakpoint, DebugModel, Enablement, ErrorScope, ExceptionBreakpoint, Expression, ExpressionContainer, FunctionBreakpoint, InstructionBreakpoint, MemoryRegion, Scope, StackFrame, Thread, Variable, getUriForDebugMemory };
+export { BaseBreakpoint, Breakpoint, DataBreakpoint, DebugModel, Enablement, ErrorScope, ExceptionBreakpoint, Expression, ExpressionContainer, FunctionBreakpoint, InstructionBreakpoint, MemoryRegion, Scope, StackFrame, Thread, ThreadAndSessionIds, Variable, getUriForDebugMemory };

package/dist/vscode/vs/workbench/contrib/debug/common/debugUtils.js

@@ -77,7 +77,7 @@ function getExactExpressionStartAndEnd(lineContent, looseStart, looseEnd) {
         { start: 0, end: 0 };
 }
 async function getEvaluatableExpressionAtPosition(languageFeaturesService, model, position, token) {
-    if (languageFeaturesService.evaluatableExpressionProvider.has(model)) {
+    if (( (languageFeaturesService.evaluatableExpressionProvider.has(model)))) {
         const supports = languageFeaturesService.evaluatableExpressionProvider.ordered(model);
         const results = coalesce(await Promise.all(( (supports.map(async (support) => {
             try {

package/dist/vscode/vs/workbench/contrib/debug/common/replModel.js

@@ -1,5 +1,6 @@
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { isObject, isString } from 'monaco-editor/esm/vs/base/common/types.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { ExpressionContainer } from './debugModel.js';
@@ -63,6 +64,55 @@ class ReplVariableElement {
         return this.id;
     }
 }
+class RawObjectReplElement {
+    constructor(id, name, valueObj, sourceData, annotation) {
+        this.id = id;
+        this.name = name;
+        this.valueObj = valueObj;
+        this.sourceData = sourceData;
+        this.annotation = annotation;
+    }
+    getId() {
+        return this.id;
+    }
+    get value() {
+        if (this.valueObj === null) {
+            return 'null';
+        }
+        else if (Array.isArray(this.valueObj)) {
+            return `Array[${this.valueObj.length}]`;
+        }
+        else if (isObject(this.valueObj)) {
+            return 'Object';
+        }
+        else if (isString(this.valueObj)) {
+            return `"${this.valueObj}"`;
+        }
+        return String(this.valueObj) || '';
+    }
+    get hasChildren() {
+        return (Array.isArray(this.valueObj) && this.valueObj.length > 0) || (isObject(this.valueObj) && Object.getOwnPropertyNames(this.valueObj).length > 0);
+    }
+    evaluateLazy() {
+        throw new Error('Method not implemented.');
+    }
+    getChildren() {
+        let result = [];
+        if (Array.isArray(this.valueObj)) {
+            result = ( this.valueObj.slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((v, index) => ( new RawObjectReplElement(`${this.id}:${index}`, String(index), v))));
+        }
+        else if (isObject(this.valueObj)) {
+            result = ( Object.getOwnPropertyNames(this.valueObj).slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((key, index) => ( new RawObjectReplElement(`${this.id}:${index}`, key, this.valueObj[key]))));
+        }
+        return Promise.resolve(result);
+    }
+    toString() {
+        return `${this.name}\n${this.value}`;
+    }
+}
+RawObjectReplElement.MAX_CHILDREN = 1000;
 class ReplEvaluationInput {
     constructor(value) {
         this.value = value;
@@ -227,4 +277,4 @@ class ReplModel {
         return newRepl;
     }
 }
-export { ReplEvaluationInput, ReplEvaluationResult, ReplGroup, ReplModel, ReplOutputElement, ReplVariableElement };
+export { RawObjectReplElement, ReplEvaluationInput, ReplEvaluationResult, ReplGroup, ReplModel, ReplOutputElement, ReplVariableElement };

package/dist/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExternalUriOpenerService = ( createDecorator('externalUriOpenerService'));
+export { IExternalUriOpenerService };

package/dist/vscode/vs/workbench/contrib/files/browser/explorerViewlet.js

@@ -0,0 +1,254 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/explorerviewlet.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { VIEWLET_ID, OpenEditorsVisibleContext, VIEW_ID, ExplorerViewletVisibleContext } from '../common/files.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ExplorerView } from './views/explorerView.js';
+import { EmptyView } from './views/emptyView.js';
+import { OpenEditorsView } from '../../../../../../override/vs/workbench/contrib/files/browser/views/openEditorsView.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ViewContentGroups, Extensions, IViewDescriptorService } from '../../../common/views.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { WorkbenchStateContext, RemoteNameContext } from '../../../common/contextkeys.js';
+import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { OpenFileFolderAction, OpenFolderAction } from '../../../browser/actions/workspaceActions.js';
+import { isMacintosh, isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const explorerViewIcon = ( registerIcon('explorer-view-icon', Codicon.files, ( localize('explorerViewIcon', 'View icon of the explorer view.'))));
+const openEditorsViewIcon = ( registerIcon('open-editors-view-icon', Codicon.book, ( localize('openEditorsIcon', 'View icon of the open editors view.'))));
+let ExplorerViewletViewsContribution = class ExplorerViewletViewsContribution extends Disposable {
+    constructor(workspaceContextService, configurationService, contextKeyService, progressService) {
+        super();
+        this.workspaceContextService = workspaceContextService;
+        this.configurationService = configurationService;
+        progressService.withProgress({ location: 1  }, () => workspaceContextService.getCompleteWorkspace()).finally(() => {
+            this.registerViews();
+            this.openEditorsVisibleContextKey = OpenEditorsVisibleContext.bindTo(contextKeyService);
+            this.updateOpenEditorsVisibility();
+            this._register(workspaceContextService.onDidChangeWorkbenchState(() => this.registerViews()));
+            this._register(workspaceContextService.onDidChangeWorkspaceFolders(() => this.registerViews()));
+            this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        });
+    }
+    registerViews() {
+        mark('code/willRegisterExplorerViews');
+        const viewDescriptors = viewsRegistry.getViews(VIEW_CONTAINER);
+        const viewDescriptorsToRegister = [];
+        const viewDescriptorsToDeregister = [];
+        const explorerViewDescriptor = this.createExplorerViewDescriptor();
+        const registeredExplorerViewDescriptor = viewDescriptors.find(v => v.id === explorerViewDescriptor.id);
+        const emptyViewDescriptor = this.createEmptyViewDescriptor();
+        const registeredEmptyViewDescriptor = viewDescriptors.find(v => v.id === emptyViewDescriptor.id);
+        if (this.workspaceContextService.getWorkbenchState() === 1  || this.workspaceContextService.getWorkspace().folders.length === 0) {
+            if (registeredExplorerViewDescriptor) {
+                viewDescriptorsToDeregister.push(registeredExplorerViewDescriptor);
+            }
+            if (!registeredEmptyViewDescriptor) {
+                viewDescriptorsToRegister.push(emptyViewDescriptor);
+            }
+        }
+        else {
+            if (registeredEmptyViewDescriptor) {
+                viewDescriptorsToDeregister.push(registeredEmptyViewDescriptor);
+            }
+            if (!registeredExplorerViewDescriptor) {
+                viewDescriptorsToRegister.push(explorerViewDescriptor);
+            }
+        }
+        if (viewDescriptorsToRegister.length) {
+            viewsRegistry.registerViews(viewDescriptorsToRegister, VIEW_CONTAINER);
+        }
+        if (viewDescriptorsToDeregister.length) {
+            viewsRegistry.deregisterViews(viewDescriptorsToDeregister, VIEW_CONTAINER);
+        }
+        mark('code/didRegisterExplorerViews');
+    }
+    createOpenEditorsViewDescriptor() {
+        return {
+            id: OpenEditorsView.ID,
+            name: OpenEditorsView.NAME,
+            ctorDescriptor: ( new SyncDescriptor(OpenEditorsView)),
+            containerIcon: openEditorsViewIcon,
+            order: 0,
+            when: OpenEditorsVisibleContext,
+            canToggleVisibility: true,
+            canMoveView: true,
+            collapsed: false,
+            hideByDefault: true,
+            focusCommand: {
+                id: 'workbench.files.action.focusOpenEditorsView',
+                keybindings: { primary: KeyChord(2048  | 41 , 35 ) }
+            }
+        };
+    }
+    createEmptyViewDescriptor() {
+        return {
+            id: EmptyView.ID,
+            name: EmptyView.NAME,
+            containerIcon: explorerViewIcon,
+            ctorDescriptor: ( new SyncDescriptor(EmptyView)),
+            order: 1,
+            canToggleVisibility: true,
+            focusCommand: {
+                id: 'workbench.explorer.fileView.focus'
+            }
+        };
+    }
+    createExplorerViewDescriptor() {
+        return {
+            id: VIEW_ID,
+            name: ( localize('folders', "Folders")),
+            containerIcon: explorerViewIcon,
+            ctorDescriptor: ( new SyncDescriptor(ExplorerView)),
+            order: 1,
+            canMoveView: true,
+            canToggleVisibility: false,
+            focusCommand: {
+                id: 'workbench.explorer.fileView.focus'
+            }
+        };
+    }
+    onConfigurationUpdated(e) {
+        if (e.affectsConfiguration('explorer.openEditors.visible')) {
+            this.updateOpenEditorsVisibility();
+        }
+    }
+    updateOpenEditorsVisibility() {
+        this.openEditorsVisibleContextKey.set(this.workspaceContextService.getWorkbenchState() === 1  || this.configurationService.getValue('explorer.openEditors.visible') !== 0);
+    }
+};
+ExplorerViewletViewsContribution = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IProgressService))
+], ExplorerViewletViewsContribution));
+let ExplorerViewPaneContainer = class ExplorerViewPaneContainer extends ViewPaneContainer {
+    constructor(layoutService, telemetryService, contextService, storageService, configurationService, instantiationService, contextKeyService, themeService, contextMenuService, extensionService, viewDescriptorService) {
+        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
+        this.viewletVisibleContextKey = ExplorerViewletVisibleContext.bindTo(contextKeyService);
+        this._register(this.contextService.onDidChangeWorkspaceName(e => this.updateTitleArea()));
+    }
+    create(parent) {
+        super.create(parent);
+        parent.classList.add('explorer-viewlet');
+    }
+    createView(viewDescriptor, options) {
+        if (viewDescriptor.id === VIEW_ID) {
+            return this.instantiationService.createInstance(ExplorerView, {
+                ...options, delegate: {
+                    willOpenElement: e => {
+                        if (!(e instanceof MouseEvent)) {
+                            return;
+                        }
+                        const openEditorsView = this.getOpenEditorsView();
+                        if (openEditorsView) {
+                            let delay = 0;
+                            const config = this.configurationService.getValue();
+                            if (!!config.workbench?.editor?.enablePreview) {
+                                delay = 250;
+                            }
+                            openEditorsView.setStructuralRefreshDelay(delay);
+                        }
+                    },
+                    didOpenElement: e => {
+                        if (!(e instanceof MouseEvent)) {
+                            return;
+                        }
+                        const openEditorsView = this.getOpenEditorsView();
+                        openEditorsView?.setStructuralRefreshDelay(0);
+                    }
+                }
+            });
+        }
+        return super.createView(viewDescriptor, options);
+    }
+    getExplorerView() {
+        return this.getView(VIEW_ID);
+    }
+    getOpenEditorsView() {
+        return this.getView(OpenEditorsView.ID);
+    }
+    setVisible(visible) {
+        this.viewletVisibleContextKey.set(visible);
+        super.setVisible(visible);
+    }
+    focus() {
+        const explorerView = this.getView(VIEW_ID);
+        if (explorerView && this.panes.every(p => !p.isExpanded())) {
+            explorerView.setExpanded(true);
+        }
+        if (explorerView?.isExpanded()) {
+            explorerView.focus();
+        }
+        else {
+            super.focus();
+        }
+    }
+};
+ExplorerViewPaneContainer = ( __decorate([
+    ( __param(0, IWorkbenchLayoutService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IExtensionService)),
+    ( __param(10, IViewDescriptorService))
+], ExplorerViewPaneContainer));
+const viewContainerRegistry = ( Registry.as(Extensions.ViewContainersRegistry));
+const VIEW_CONTAINER = viewContainerRegistry.registerViewContainer({
+    id: VIEWLET_ID,
+    title: ( localize('explore', "Explorer")),
+    ctorDescriptor: ( new SyncDescriptor(ExplorerViewPaneContainer)),
+    storageId: 'workbench.explorer.views.state',
+    icon: explorerViewIcon,
+    alwaysUseContainerInfo: true,
+    hideIfEmpty: true,
+    order: 0,
+    openCommandActionDescriptor: {
+        id: VIEWLET_ID,
+        title: { value: ( localize('explore', "Explorer")), original: 'Explorer' },
+        mnemonicTitle: ( localize(
+            { key: 'miViewExplorer', comment: ['&& denotes a mnemonic'] },
+            "&&Explorer"
+        )),
+        keybindings: { primary: 2048  | 1024  | 35  },
+        order: 0
+    },
+}, 0 , { isDefault: true });
+const openFolder = ( localize('openFolder', "Open Folder"));
+const openFolderButton = `[${openFolder}](command:${(isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFolderAction.ID})`;
+const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+( viewsRegistry.registerViewWelcomeContent(EmptyView.ID, {
+    content: ( localize(
+        { key: 'noFolderHelp', comment: ['Please do not translate the word "commmand", it is part of our internal syntax which must not change'] },
+        "You have not yet opened a folder.\n{0}",
+        openFolderButton
+    )),
+    when: ( ContextKeyExpr.and(
+    ( ContextKeyExpr.has('editorIsOpen'))?.negate(), ( ContextKeyExpr.or((
+    ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('workspace')), ( RemoteNameContext.isEqualTo('')))), (
+    ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('workspace')), IsWebContext)))))),
+    group: ViewContentGroups.Open,
+    order: 1
+}));
+export { ExplorerViewPaneContainer, ExplorerViewletViewsContribution, VIEW_CONTAINER };

package/dist/vscode/vs/workbench/contrib/files/browser/fileActions.contribution.js

@@ -0,0 +1,207 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { renameHandler, moveFileToTrashHandler, deleteFileHandler, cutFileHandler, copyFileHandler, pasteFileHandler, openFilePreserveFocusHandler, NEW_FILE_COMMAND_ID, NEW_FILE_LABEL, NEW_FOLDER_COMMAND_ID, NEW_FOLDER_LABEL, COPY_FILE_LABEL, PASTE_FILE_LABEL, FileCopiedContext, TRIGGER_RENAME_LABEL } from './fileActions.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import './fileCommands.js';
+import { NEW_UNTITLED_FILE_COMMAND_ID, COPY_PATH_COMMAND_ID, COPY_RELATIVE_PATH_COMMAND_ID, REVEAL_IN_EXPLORER_COMMAND_ID } from './fileConstants.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
+import { FilesExplorerFocusCondition, ExplorerRootContext, ExplorerResourceNotReadonlyContext, ExplorerResourceMoveableToTrash, ExplorerResourceCut, ExplorerFolderContext } from '../common/files.js';
+import { ResourceContextKey } from '../../../common/contextkeys.js';
+import { IExplorerService } from './files.js';
+const explorerCommandsWeightBonus = 10;
+const RENAME_ID = 'renameFile';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: RENAME_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ( ExplorerRootContext.toNegated()), ExplorerResourceNotReadonlyContext)),
+    primary: 60 ,
+    mac: {
+        primary: 3
+    },
+    handler: renameHandler
+});
+const MOVE_FILE_TO_TRASH_ID = 'moveFileToTrash';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: MOVE_FILE_TO_TRASH_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerResourceNotReadonlyContext,
+        ExplorerResourceMoveableToTrash
+    )),
+    primary: 20 ,
+    mac: {
+        primary: 2048  | 1 ,
+        secondary: [20 ]
+    },
+    handler: moveFileToTrashHandler
+});
+const DELETE_FILE_ID = 'deleteFile';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: DELETE_FILE_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerResourceNotReadonlyContext)),
+    primary: 1024  | 20 ,
+    mac: {
+        primary: 2048  | 512  | 1
+    },
+    handler: deleteFileHandler
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: DELETE_FILE_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(
+        FilesExplorerFocusCondition,
+        ExplorerResourceNotReadonlyContext,
+        ( ExplorerResourceMoveableToTrash.toNegated())
+    )),
+    primary: 20 ,
+    mac: {
+        primary: 2048  | 1
+    },
+    handler: deleteFileHandler
+});
+const CUT_FILE_ID = 'filesExplorer.cut';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: CUT_FILE_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ( ExplorerRootContext.toNegated()), ExplorerResourceNotReadonlyContext)),
+    primary: 2048  | 54 ,
+    handler: cutFileHandler,
+});
+const COPY_FILE_ID = 'filesExplorer.copy';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: COPY_FILE_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ( ExplorerRootContext.toNegated()))),
+    primary: 2048  | 33 ,
+    handler: copyFileHandler,
+});
+const PASTE_FILE_ID = 'filesExplorer.paste';
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: PASTE_FILE_ID,
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerResourceNotReadonlyContext)),
+    primary: 2048  | 52 ,
+    handler: pasteFileHandler
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'filesExplorer.cancelCut',
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ExplorerResourceCut)),
+    primary: 9 ,
+    handler: async (accessor) => {
+        const explorerService = accessor.get(IExplorerService);
+        await explorerService.setToCopy([], true);
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'filesExplorer.openFilePreserveFocus',
+    weight: 200  + explorerCommandsWeightBonus,
+    when: ( ContextKeyExpr.and(FilesExplorerFocusCondition, ( ExplorerFolderContext.toNegated()))),
+    primary: 10 ,
+    handler: openFilePreserveFocusHandler
+});
+const copyPathCommand = {
+    id: COPY_PATH_COMMAND_ID,
+    title: ( nls.localize('copyPath', "Copy Path"))
+};
+const copyRelativePathCommand = {
+    id: COPY_RELATIVE_PATH_COMMAND_ID,
+    title: ( nls.localize('copyRelativePath', "Copy Relative Path"))
+};
+appendEditorTitleContextMenuItem(COPY_PATH_COMMAND_ID, copyPathCommand.title, ResourceContextKey.IsFileSystemResource, '1_cutcopypaste');
+appendEditorTitleContextMenuItem(COPY_RELATIVE_PATH_COMMAND_ID, copyRelativePathCommand.title, ResourceContextKey.IsFileSystemResource, '1_cutcopypaste');
+appendEditorTitleContextMenuItem(REVEAL_IN_EXPLORER_COMMAND_ID, ( nls.localize('revealInSideBar', "Reveal in Explorer View")), ResourceContextKey.IsFileSystemResource, '2_files', 1);
+function appendEditorTitleContextMenuItem(id, title, when, group, order) {
+    MenuRegistry.appendMenuItem(MenuId.EditorTitleContext, {
+        command: { id, title },
+        when,
+        group,
+        order
+    });
+}
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: 'navigation',
+    order: 4,
+    command: {
+        id: NEW_FILE_COMMAND_ID,
+        title: NEW_FILE_LABEL,
+        precondition: ExplorerResourceNotReadonlyContext
+    },
+    when: ExplorerFolderContext
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: 'navigation',
+    order: 6,
+    command: {
+        id: NEW_FOLDER_COMMAND_ID,
+        title: NEW_FOLDER_LABEL,
+        precondition: ExplorerResourceNotReadonlyContext
+    },
+    when: ExplorerFolderContext
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '5_cutcopypaste',
+    order: 8,
+    command: {
+        id: CUT_FILE_ID,
+        title: ( nls.localize('cut', "Cut"))
+    },
+    when: ( ContextKeyExpr.and(( ExplorerRootContext.toNegated()), ExplorerResourceNotReadonlyContext))
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '5_cutcopypaste',
+    order: 10,
+    command: {
+        id: COPY_FILE_ID,
+        title: COPY_FILE_LABEL
+    },
+    when: ( ExplorerRootContext.toNegated())
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '5_cutcopypaste',
+    order: 20,
+    command: {
+        id: PASTE_FILE_ID,
+        title: PASTE_FILE_LABEL,
+        precondition: ( ContextKeyExpr.and(ExplorerResourceNotReadonlyContext, FileCopiedContext))
+    },
+    when: ExplorerFolderContext
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '6_copypath',
+    order: 10,
+    command: copyPathCommand,
+    when: ResourceContextKey.IsFileSystemResource
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '6_copypath',
+    order: 20,
+    command: copyRelativePathCommand,
+    when: ResourceContextKey.IsFileSystemResource
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '7_modification',
+    order: 10,
+    command: {
+        id: RENAME_ID,
+        title: TRIGGER_RENAME_LABEL,
+        precondition: ExplorerResourceNotReadonlyContext
+    },
+    when: ( ExplorerRootContext.toNegated())
+});
+MenuRegistry.appendMenuItem(MenuId.ExplorerContext, {
+    group: '7_modification',
+    order: 20,
+    command: {
+        id: DELETE_FILE_ID,
+        title: ( nls.localize('deleteFile', "Delete Permanently")),
+        precondition: ExplorerResourceNotReadonlyContext
+    },
+    when: ( ContextKeyExpr.and(( ExplorerRootContext.toNegated()), ( ExplorerResourceMoveableToTrash.toNegated())))
+});
+for (const menuId of [MenuId.EmptyEditorGroupContext, MenuId.EditorTabsBarContext]) {
+    MenuRegistry.appendMenuItem(menuId, { command: { id: NEW_UNTITLED_FILE_COMMAND_ID, title: ( nls.localize('newFile', "New Text File")) }, group: '1_file', order: 10 });
+}
+export { appendEditorTitleContextMenuItem };