@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/workbench/browser/actions/workspaceActions.js

@@ -15,25 +15,18 @@ import { IWorkbenchEnvironmentService } from '../../services/environment/common/
 import { IWorkspacesService } from '../../../platform/workspaces/common/workspaces.service.js';
 import { IsMacNativeContext } from '../../../platform/contextkey/common/contextkeys.js';
 import { Categories } from '../../../platform/action/common/actionCommonCategories.js';
-const workspacesCategory = ( localize2WithPath(
-    'vs/workbench/browser/actions/workspaceActions',
-    'workspaces',
-    'Workspaces'
-));
+const _moduleId = "vs/workbench/browser/actions/workspaceActions";
+const workspacesCategory = ( localize2WithPath(_moduleId, 0, 'Workspaces'));
 class OpenFileAction extends Action2 {
     static { this.ID = 'workbench.action.files.openFile'; }
     constructor() {
         super({
             id: OpenFileAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'openFile',
-                'Open File...'
-            )),
+            title: ( localize2WithPath(_moduleId, 1, 'Open File...')),
             category: Categories.File,
             f1: true,
             keybinding: {
-                when: ( IsMacNativeContext.toNegated()),
+                when: ( (IsMacNativeContext.toNegated())),
                 weight: 200 ,
                 primary: 2048  | 45
             }
@@ -49,11 +42,7 @@ class OpenFolderAction extends Action2 {
     constructor() {
         super({
             id: OpenFolderAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'openFolder',
-                'Open Folder...'
-            )),
+            title: ( localize2WithPath(_moduleId, 2, 'Open Folder...')),
             category: Categories.File,
             f1: true,
             precondition: OpenFolderWorkspaceSupportContext,
@@ -79,14 +68,13 @@ class OpenFolderViaWorkspaceAction extends Action2 {
     constructor() {
         super({
             id: OpenFolderViaWorkspaceAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'openFolder',
-                'Open Folder...'
-            )),
+            title: ( localize2WithPath(_moduleId, 2, 'Open Folder...')),
             category: Categories.File,
             f1: true,
-            precondition: ( ContextKeyExpr.and(( OpenFolderWorkspaceSupportContext.toNegated()), ( WorkbenchStateContext.isEqualTo('workspace')))),
+            precondition: ( (ContextKeyExpr.and(
+                 (OpenFolderWorkspaceSupportContext.toNegated()),
+                 (WorkbenchStateContext.isEqualTo('workspace'))
+            ))),
             keybinding: {
                 weight: 200 ,
                 primary: 2048  | 45
@@ -100,18 +88,14 @@ class OpenFolderViaWorkspaceAction extends Action2 {
 }
 class OpenFileFolderAction extends Action2 {
     static { this.ID = 'workbench.action.files.openFileFolder'; }
-    static { this.LABEL = ( localize2WithPath(
-        'vs/workbench/browser/actions/workspaceActions',
-        'openFileFolder',
-        'Open...'
-    )); }
+    static { this.LABEL = ( localize2WithPath(_moduleId, 3, 'Open...')); }
     constructor() {
         super({
             id: OpenFileFolderAction.ID,
             title: OpenFileFolderAction.LABEL,
             category: Categories.File,
             f1: true,
-            precondition: ( ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext)),
+            precondition: ( (ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext))),
             keybinding: {
                 weight: 200 ,
                 primary: 2048  | 45
@@ -128,11 +112,7 @@ class OpenWorkspaceAction extends Action2 {
     constructor() {
         super({
             id: OpenWorkspaceAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'openWorkspaceAction',
-                'Open Workspace from File...'
-            )),
+            title: ( localize2WithPath(_moduleId, 4, 'Open Workspace from File...')),
             category: Categories.File,
             f1: true,
             precondition: EnterMultiRootWorkspaceSupportContext
@@ -148,14 +128,13 @@ class CloseWorkspaceAction extends Action2 {
     constructor() {
         super({
             id: CloseWorkspaceAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'closeWorkspace',
-                'Close Workspace'
-            )),
+            title: ( localize2WithPath(_moduleId, 5, 'Close Workspace')),
             category: workspacesCategory,
             f1: true,
-            precondition: ( ContextKeyExpr.and(( WorkbenchStateContext.notEqualsTo('empty')), EmptyWorkspaceSupportContext)),
+            precondition: ( (ContextKeyExpr.and(
+                 (WorkbenchStateContext.notEqualsTo('empty')),
+                EmptyWorkspaceSupportContext
+            ))),
             keybinding: {
                 weight: 200 ,
                 primary: KeyChord(2048  | 41 , 36 )
@@ -173,14 +152,10 @@ class OpenWorkspaceConfigFileAction extends Action2 {
     constructor() {
         super({
             id: OpenWorkspaceConfigFileAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'openWorkspaceConfigFile',
-                'Open Workspace Configuration File'
-            )),
+            title: ( localize2WithPath(_moduleId, 6, 'Open Workspace Configuration File')),
             category: workspacesCategory,
             f1: true,
-            precondition: ( WorkbenchStateContext.isEqualTo('workspace'))
+            precondition: ( (WorkbenchStateContext.isEqualTo('workspace')))
         });
     }
     async run(accessor) {
@@ -200,7 +175,10 @@ class AddRootFolderAction extends Action2 {
             title: ADD_ROOT_FOLDER_LABEL,
             category: workspacesCategory,
             f1: true,
-            precondition: ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace'))))
+            precondition: ( (ContextKeyExpr.or(
+                EnterMultiRootWorkspaceSupportContext,
+                 (WorkbenchStateContext.isEqualTo('workspace'))
+            )))
         });
     }
     run(accessor) {
@@ -213,14 +191,16 @@ class RemoveRootFolderAction extends Action2 {
     constructor() {
         super({
             id: RemoveRootFolderAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'globalRemoveFolderFromWorkspace',
-                'Remove Folder from Workspace...'
-            )),
+            title: ( localize2WithPath(_moduleId, 7, 'Remove Folder from Workspace...')),
             category: workspacesCategory,
             f1: true,
-            precondition: ( ContextKeyExpr.and(( WorkspaceFolderCountContext.notEqualsTo('0')), ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace'))))))
+            precondition: ( (ContextKeyExpr.and(
+                 (WorkspaceFolderCountContext.notEqualsTo('0')),
+                 (ContextKeyExpr.or(
+                    EnterMultiRootWorkspaceSupportContext,
+                     (WorkbenchStateContext.isEqualTo('workspace'))
+                ))
+            )))
         });
     }
     async run(accessor) {
@@ -237,11 +217,7 @@ class SaveWorkspaceAsAction extends Action2 {
     constructor() {
         super({
             id: SaveWorkspaceAsAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'saveWorkspaceAsAction',
-                'Save Workspace As...'
-            )),
+            title: ( localize2WithPath(_moduleId, 8, 'Save Workspace As...')),
             category: workspacesCategory,
             f1: true,
             precondition: EnterMultiRootWorkspaceSupportContext
@@ -255,7 +231,7 @@ class SaveWorkspaceAsAction extends Action2 {
             switch (contextService.getWorkbenchState()) {
                 case 1 :
                 case 2 : {
-                    const folders = ( contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri })));
+                    const folders = ( (contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri }))));
                     return workspaceEditingService.createAndEnterWorkspace(folders, configPathUri);
                 }
                 case 3 :
@@ -269,11 +245,7 @@ class DuplicateWorkspaceInNewWindowAction extends Action2 {
     constructor() {
         super({
             id: DuplicateWorkspaceInNewWindowAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/browser/actions/workspaceActions',
-                'duplicateWorkspaceInNewWindow',
-                'Duplicate As Workspace in New Window'
-            )),
+            title: ( localize2WithPath(_moduleId, 9, 'Duplicate As Workspace in New Window')),
             category: workspacesCategory,
             f1: true,
             precondition: EnterMultiRootWorkspaceSupportContext
@@ -307,24 +279,16 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '2_open',
     command: {
         id: OpenFileAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miOpenFile', comment: ['&& denotes a mnemonic'] },
-            "&&Open File..."
-        ))
+        title: ( localizeWithPath(_moduleId, 10, "&&Open File..."))
     },
     order: 1,
-    when: ( IsMacNativeContext.toNegated())
+    when: ( (IsMacNativeContext.toNegated()))
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '2_open',
     command: {
         id: OpenFolderAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] },
-            "Open &&Folder..."
-        ))
+        title: ( localizeWithPath(_moduleId, 11, "Open &&Folder..."))
     },
     order: 2,
     when: OpenFolderWorkspaceSupportContext
@@ -333,37 +297,28 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '2_open',
     command: {
         id: OpenFolderViaWorkspaceAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miOpenFolder', comment: ['&& denotes a mnemonic'] },
-            "Open &&Folder..."
-        ))
+        title: ( localizeWithPath(_moduleId, 11, "Open &&Folder..."))
     },
     order: 2,
-    when: ( ContextKeyExpr.and(( OpenFolderWorkspaceSupportContext.toNegated()), ( WorkbenchStateContext.isEqualTo('workspace'))))
+    when: ( (ContextKeyExpr.and(
+         (OpenFolderWorkspaceSupportContext.toNegated()),
+         (WorkbenchStateContext.isEqualTo('workspace'))
+    )))
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '2_open',
     command: {
         id: OpenFileFolderAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miOpen', comment: ['&& denotes a mnemonic'] },
-            "&&Open..."
-        ))
+        title: ( localizeWithPath(_moduleId, 12, "&&Open..."))
     },
     order: 1,
-    when: ( ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext))
+    when: ( (ContextKeyExpr.and(IsMacNativeContext, OpenFolderWorkspaceSupportContext)))
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '2_open',
     command: {
         id: OpenWorkspaceAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miOpenWorkspace', comment: ['&& denotes a mnemonic'] },
-            "Open Wor&&kspace from File..."
-        ))
+        title: ( localizeWithPath(_moduleId, 13, "Open Wor&&kspace from File..."))
     },
     order: 3,
     when: EnterMultiRootWorkspaceSupportContext
@@ -372,24 +327,19 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '3_workspace',
     command: {
         id: ADD_ROOT_FOLDER_COMMAND_ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miAddFolderToWorkspace', comment: ['&& denotes a mnemonic'] },
-            "A&&dd Folder to Workspace..."
-        ))
+        title: ( localizeWithPath(_moduleId, 14, "A&&dd Folder to Workspace..."))
     },
-    when: ( ContextKeyExpr.or(EnterMultiRootWorkspaceSupportContext, ( WorkbenchStateContext.isEqualTo('workspace')))),
+    when: ( (ContextKeyExpr.or(
+        EnterMultiRootWorkspaceSupportContext,
+         (WorkbenchStateContext.isEqualTo('workspace'))
+    ))),
     order: 1
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '3_workspace',
     command: {
         id: SaveWorkspaceAsAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            'miSaveWorkspaceAs',
-            "Save Workspace As..."
-        ))
+        title: ( localizeWithPath(_moduleId, 15, "Save Workspace As..."))
     },
     order: 2,
     when: EnterMultiRootWorkspaceSupportContext
@@ -398,11 +348,7 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '3_workspace',
     command: {
         id: DuplicateWorkspaceInNewWindowAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            'duplicateWorkspace',
-            "Duplicate Workspace"
-        ))
+        title: ( localizeWithPath(_moduleId, 16, "Duplicate Workspace"))
     },
     order: 3,
     when: EnterMultiRootWorkspaceSupportContext
@@ -411,26 +357,24 @@ MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '6_close',
     command: {
         id: CloseWorkspaceAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miCloseFolder', comment: ['&& denotes a mnemonic'] },
-            "Close &&Folder"
-        ))
+        title: ( localizeWithPath(_moduleId, 17, "Close &&Folder"))
     },
     order: 3,
-    when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('folder')), EmptyWorkspaceSupportContext))
+    when: ( (ContextKeyExpr.and(
+         (WorkbenchStateContext.isEqualTo('folder')),
+        EmptyWorkspaceSupportContext
+    )))
 });
 MenuRegistry.appendMenuItem(MenuId.MenubarFileMenu, {
     group: '6_close',
     command: {
         id: CloseWorkspaceAction.ID,
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceActions',
-            { key: 'miCloseWorkspace', comment: ['&& denotes a mnemonic'] },
-            "Close &&Workspace"
-        ))
+        title: ( localizeWithPath(_moduleId, 18, "Close &&Workspace"))
     },
     order: 3,
-    when: ( ContextKeyExpr.and(( WorkbenchStateContext.isEqualTo('workspace')), EmptyWorkspaceSupportContext))
+    when: ( (ContextKeyExpr.and(
+         (WorkbenchStateContext.isEqualTo('workspace')),
+        EmptyWorkspaceSupportContext
+    )))
 });
 export { AddRootFolderAction, OpenFileAction, OpenFileFolderAction, OpenFolderAction, OpenFolderViaWorkspaceAction, RemoveRootFolderAction };

package/vscode/src/vs/workbench/browser/actions/workspaceCommands.js

@@ -18,12 +18,9 @@ import { URI } from '../../../base/common/uri.js';
 import { Schemas } from '../../../base/common/network.js';
 import { IWorkspacesService } from '../../../platform/workspaces/common/workspaces.service.js';
 import { IPathService } from '../../services/path/common/pathService.service.js';
+const _moduleId = "vs/workbench/browser/actions/workspaceCommands";
 const ADD_ROOT_FOLDER_COMMAND_ID = 'addRootFolder';
-const ADD_ROOT_FOLDER_LABEL = ( localize2WithPath(
-    'vs/workbench/browser/actions/workspaceCommands',
-    'addFolderToWorkspace',
-    'Add Folder to Workspace...'
-));
+const ADD_ROOT_FOLDER_LABEL = ( localize2WithPath(_moduleId, 0, 'Add Folder to Workspace...'));
 const SET_ROOT_FOLDER_COMMAND_ID = 'setRootFolder';
 const PICK_WORKSPACE_FOLDER_COMMAND_ID = '_workbench.pickWorkspaceFolder';
 CommandsRegistry.registerCommand({
@@ -54,7 +51,7 @@ CommandsRegistry.registerCommand({
         if (!folders || !folders.length) {
             return;
         }
-        await workspaceEditingService.addFolders(( folders.map(folder => ({ uri: folder }))));
+        await workspaceEditingService.addFolders(( (folders.map(folder => ({ uri: folder })))));
     }
 });
 CommandsRegistry.registerCommand({
@@ -66,23 +63,15 @@ CommandsRegistry.registerCommand({
         if (!folders || !folders.length) {
             return;
         }
-        await workspaceEditingService.updateFolders(0, contextService.getWorkspace().folders.length, ( folders.map(folder => ({ uri: folder }))));
+        await workspaceEditingService.updateFolders(0, contextService.getWorkspace().folders.length, ( (folders.map(folder => ({ uri: folder })))));
     }
 });
 async function selectWorkspaceFolders(accessor) {
     const dialogsService = accessor.get(IFileDialogService);
     const pathService = accessor.get(IPathService);
     const folders = await dialogsService.showOpenDialog({
-        openLabel: mnemonicButtonLabel(( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceCommands',
-            { key: 'add', comment: ['&& denotes a mnemonic'] },
-            "&&Add"
-        ))),
-        title: ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceCommands',
-            'addFolderToWorkspaceTitle',
-            "Add Folder to Workspace"
-        )),
+        openLabel: mnemonicButtonLabel(( localizeWithPath(_moduleId, 1, "&&Add"))),
+        title: ( localizeWithPath(_moduleId, 2, "Add Folder to Workspace")),
         canSelectFolders: true,
         canSelectMany: true,
         defaultUri: await dialogsService.defaultFolderPath(),
@@ -100,7 +89,7 @@ CommandsRegistry.registerCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, async functio
     if (!folders.length) {
         return;
     }
-    const folderPicks = ( folders.map(folder => {
+    const folderPicks = ( (folders.map(folder => {
         const label = folder.name;
         const description = labelService.getUriLabel(dirname(folder.uri), { relative: true });
         return {
@@ -109,17 +98,13 @@ CommandsRegistry.registerCommand(PICK_WORKSPACE_FOLDER_COMMAND_ID, async functio
             folder,
             iconClasses: getIconClasses(modelService, languageService, folder.uri, FileKind.ROOT_FOLDER)
         };
-    }));
+    })));
     const options = (args ? args[0] : undefined) || Object.create(null);
     if (!options.activeItem) {
         options.activeItem = folderPicks[0];
     }
     if (!options.placeHolder) {
-        options.placeHolder = ( localizeWithPath(
-            'vs/workbench/browser/actions/workspaceCommands',
-            'workspaceFolderPickerPlaceholder',
-            "Select workspace folder"
-        ));
+        options.placeHolder = ( localizeWithPath(_moduleId, 3, "Select workspace folder"));
     }
     if (typeof options.matchOnDescription !== 'boolean') {
         options.matchOnDescription = true;
@@ -148,7 +133,7 @@ CommandsRegistry.registerCommand({
             }
             return commandService.executeCommand('_files.pickFolderAndOpen', options);
         }
-        const uri = ( URI.from(uriComponents, true));
+        const uri = ( (URI.from(uriComponents, true)));
         const options = {
             forceNewWindow: arg?.forceNewWindow,
             forceReuseWindow: arg?.forceReuseWindow,
@@ -210,7 +195,7 @@ CommandsRegistry.registerCommand({
     handler: (accessor, path) => {
         const workspacesService = accessor.get(IWorkspacesService);
         if (typeof path === 'string') {
-            path = path.match(/^[^:/?#]+:\/\//) ? ( URI.parse(path)) : URI.file(path);
+            path = path.match(/^[^:/?#]+:\/\//) ? ( (URI.parse(path))) : URI.file(path);
         }
         else {
             path = URI.revive(path);

package/vscode/src/vs/workbench/browser/dnd.d.ts

@@ -0,0 +1,14 @@
+import { IDragAndDropData } from '../../base/browser/dnd.js';
+import '../../editor/editor.api.js';
+
+type Before2D = {
+    readonly verticallyBefore: boolean;
+    readonly horizontallyBefore: boolean;
+};
+interface ICompositeDragAndDrop {
+    drop(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent, before?: Before2D): void;
+    onDragOver(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
+    onDragEnter(data: IDragAndDropData, target: string | undefined, originalEvent: DragEvent): boolean;
+}
+
+export type { Before2D, ICompositeDragAndDrop };

package/vscode/src/vs/workbench/browser/editor.js

@@ -9,15 +9,20 @@ import { IWorkingCopyService } from '../services/workingCopy/common/workingCopyS
 import { Schemas } from '../../base/common/network.js';
 import { Iterable } from '../../base/common/iterator.js';
 import { Emitter } from '../../base/common/event.js';
+const _moduleId = "vs/workbench/browser/editor";
 class EditorPaneDescriptor {
-    static { this.instantiatedEditorPanes = ( new Set()); }
+    static { this.instantiatedEditorPanes = ( (new Set())); }
     static didInstantiateEditorPane(typeId) {
-        return ( EditorPaneDescriptor.instantiatedEditorPanes.has(typeId));
+        return (
+             (EditorPaneDescriptor.instantiatedEditorPanes.has(typeId))
+        );
     }
-    static { this._onWillInstantiateEditorPane = ( new Emitter()); }
+    static { this._onWillInstantiateEditorPane = ( (new Emitter())); }
     static { this.onWillInstantiateEditorPane = EditorPaneDescriptor._onWillInstantiateEditorPane.event; }
     static create(ctor, typeId, name) {
-        return ( new EditorPaneDescriptor(ctor, typeId, name));
+        return (
+             (new EditorPaneDescriptor(ctor, typeId, name))
+        );
     }
     constructor(ctor, typeId, name) {
         this.ctor = ctor;
@@ -36,7 +41,7 @@ class EditorPaneDescriptor {
 }
 class EditorPaneRegistry {
     constructor() {
-        this.mapEditorPanesToEditors = ( new Map());
+        this.mapEditorPanesToEditors = ( (new Map()));
     }
     registerEditorPane(editorPaneDescriptor, editorDescriptors) {
         this.mapEditorPanesToEditors.set(editorPaneDescriptor, editorDescriptors);
@@ -56,7 +61,7 @@ class EditorPaneRegistry {
     }
     findEditorPaneDescriptors(editor, byInstanceOf) {
         const matchingEditorPaneDescriptors = [];
-        for (const editorPane of ( this.mapEditorPanesToEditors.keys())) {
+        for (const editorPane of ( (this.mapEditorPanesToEditors.keys()))) {
             const editorDescriptors = this.mapEditorPanesToEditors.get(editorPane) || [];
             for (const editorDescriptor of editorDescriptors) {
                 const editorClass = editorDescriptor.ctor;
@@ -76,85 +81,87 @@ class EditorPaneRegistry {
         return matchingEditorPaneDescriptors;
     }
     getEditorPaneByType(typeId) {
-        return Iterable.find(( this.mapEditorPanesToEditors.keys()), editor => editor.typeId === typeId);
+        return Iterable.find(( (this.mapEditorPanesToEditors.keys())), editor => editor.typeId === typeId);
     }
     getEditorPanes() {
-        return Array.from(( this.mapEditorPanesToEditors.keys()));
+        return Array.from(( (this.mapEditorPanesToEditors.keys())));
     }
     getEditors() {
         const editorClasses = [];
-        for (const editorPane of ( this.mapEditorPanesToEditors.keys())) {
+        for (const editorPane of ( (this.mapEditorPanesToEditors.keys()))) {
             const editorDescriptors = this.mapEditorPanesToEditors.get(editorPane);
             if (editorDescriptors) {
-                editorClasses.push(...( editorDescriptors.map(editorDescriptor => editorDescriptor.ctor)));
+                editorClasses.push(...( (editorDescriptors.map(editorDescriptor => editorDescriptor.ctor))));
             }
         }
         return editorClasses;
     }
 }
-Registry.add(EditorExtensions.EditorPane, ( new EditorPaneRegistry()));
+Registry.add(EditorExtensions.EditorPane, ( (new EditorPaneRegistry())));
 function whenEditorClosed(accessor, resources) {
     const editorService = accessor.get(IEditorService);
     const uriIdentityService = accessor.get(IUriIdentityService);
     const workingCopyService = accessor.get(IWorkingCopyService);
-    return ( new Promise(resolve => {
-        let remainingResources = [...resources];
-        const listener = editorService.onDidCloseEditor(async (event) => {
-            if (event.context === EditorCloseContext.MOVE) {
-                return;
-            }
-            let primaryResource = EditorResourceAccessor.getOriginalUri(event.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
-            let secondaryResource = EditorResourceAccessor.getOriginalUri(event.editor, { supportSideBySide: SideBySideEditor.SECONDARY });
-            if (event.context === EditorCloseContext.REPLACE) {
-                const newPrimaryResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-                const newSecondaryResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.SECONDARY });
-                if (uriIdentityService.extUri.isEqual(primaryResource, newPrimaryResource)) {
-                    primaryResource = undefined;
-                }
-                if (uriIdentityService.extUri.isEqual(secondaryResource, newSecondaryResource)) {
-                    secondaryResource = undefined;
+    return (
+         (new Promise(resolve => {
+            let remainingResources = [...resources];
+            const listener = editorService.onDidCloseEditor(async (event) => {
+                if (event.context === EditorCloseContext.MOVE) {
+                    return;
                 }
-            }
-            remainingResources = remainingResources.filter(resource => {
-                if (uriIdentityService.extUri.isEqual(resource, primaryResource) || uriIdentityService.extUri.isEqual(resource, secondaryResource)) {
-                    return false;
+                let primaryResource = EditorResourceAccessor.getOriginalUri(event.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+                let secondaryResource = EditorResourceAccessor.getOriginalUri(event.editor, { supportSideBySide: SideBySideEditor.SECONDARY });
+                if (event.context === EditorCloseContext.REPLACE) {
+                    const newPrimaryResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+                    const newSecondaryResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.SECONDARY });
+                    if (uriIdentityService.extUri.isEqual(primaryResource, newPrimaryResource)) {
+                        primaryResource = undefined;
+                    }
+                    if (uriIdentityService.extUri.isEqual(secondaryResource, newSecondaryResource)) {
+                        secondaryResource = undefined;
+                    }
                 }
-                if (event.context !== EditorCloseContext.REPLACE) {
-                    if ((primaryResource?.scheme === Schemas.untitled && uriIdentityService.extUri.isEqual(resource, primaryResource.with({ scheme: resource.scheme }))) ||
-                        (secondaryResource?.scheme === Schemas.untitled && uriIdentityService.extUri.isEqual(resource, secondaryResource.with({ scheme: resource.scheme })))) {
+                remainingResources = remainingResources.filter(resource => {
+                    if (uriIdentityService.extUri.isEqual(resource, primaryResource) || uriIdentityService.extUri.isEqual(resource, secondaryResource)) {
                         return false;
                     }
-                }
-                return true;
-            });
-            if (remainingResources.length === 0) {
-                const dirtyResources = resources.filter(resource => workingCopyService.isDirty(resource));
-                if (dirtyResources.length > 0) {
-                    await Promises.settled(( dirtyResources.map(async (resource) => await ( new Promise(resolve => {
-                        if (!workingCopyService.isDirty(resource)) {
-                            return resolve();
+                    if (event.context !== EditorCloseContext.REPLACE) {
+                        if ((primaryResource?.scheme === Schemas.untitled && uriIdentityService.extUri.isEqual(resource, primaryResource.with({ scheme: resource.scheme }))) ||
+                            (secondaryResource?.scheme === Schemas.untitled && uriIdentityService.extUri.isEqual(resource, secondaryResource.with({ scheme: resource.scheme })))) {
+                            return false;
                         }
-                        const listener = workingCopyService.onDidChangeDirty(workingCopy => {
-                            if (!workingCopy.isDirty() && uriIdentityService.extUri.isEqual(resource, workingCopy.resource)) {
-                                listener.dispose();
+                    }
+                    return true;
+                });
+                if (remainingResources.length === 0) {
+                    const dirtyResources = resources.filter(resource => workingCopyService.isDirty(resource));
+                    if (dirtyResources.length > 0) {
+                        await Promises.settled(( (dirtyResources.map(async (resource) => await ( (new Promise(resolve => {
+                            if (!workingCopyService.isDirty(resource)) {
                                 return resolve();
                             }
-                        });
-                    })))));
+                            const listener = workingCopyService.onDidChangeDirty(workingCopy => {
+                                if (!workingCopy.isDirty() && uriIdentityService.extUri.isEqual(resource, workingCopy.resource)) {
+                                    listener.dispose();
+                                    return resolve();
+                                }
+                            });
+                        })))))));
+                    }
+                    listener.dispose();
+                    return resolve();
                 }
-                listener.dispose();
-                return resolve();
-            }
-        });
-    }));
+            });
+        }))
+    );
 }
 function computeEditorAriaLabel(input, index, group, groupCount) {
     let ariaLabel = input.getAriaLabel();
     if (group && !group.isPinned(input)) {
-        ariaLabel = ( localizeWithPath('vs/workbench/browser/editor', 'preview', "{0}, preview", ariaLabel));
+        ariaLabel = ( localizeWithPath(_moduleId, 0, "{0}, preview", ariaLabel));
     }
     if (group?.isSticky(index ?? input)) {
-        ariaLabel = ( localizeWithPath('vs/workbench/browser/editor', 'pinned', "{0}, pinned", ariaLabel));
+        ariaLabel = ( localizeWithPath(_moduleId, 1, "{0}, pinned", ariaLabel));
     }
     if (group && typeof groupCount === 'number' && groupCount > 1) {
         ariaLabel = `${ariaLabel}, ${group.ariaLabel}`;