@codingame/monaco-vscode-view-common-service-override 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -17,24 +17,33 @@ import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/te
 import { Barrier } from 'vscode/vscode/vs/base/common/async';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { getZoomLevel } from 'vscode/vscode/vs/base/browser/browser';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
 var BrowserAuxiliaryWindowService_1;
+const _moduleId = "vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService";
+var AuxiliaryWindowMode;
+( ((function(AuxiliaryWindowMode) {
+    AuxiliaryWindowMode[AuxiliaryWindowMode["Maximized"] = 0] = "Maximized";
+    AuxiliaryWindowMode[AuxiliaryWindowMode["Normal"] = 1] = "Normal";
+    AuxiliaryWindowMode[AuxiliaryWindowMode["Fullscreen"] = 2] = "Fullscreen";
+})(AuxiliaryWindowMode || (AuxiliaryWindowMode = {}))));
 let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     constructor(window, container, stylesHaveLoaded, configurationService, hostService, environmentService) {
         super(window, undefined, hostService, environmentService);
         this.window = window;
         this.container = container;
         this.configurationService = configurationService;
-        this._onWillLayout = this._register(( new Emitter()));
+        this._onWillLayout = this._register(( (new Emitter())));
         this.onWillLayout = this._onWillLayout.event;
-        this._onDidLayout = this._register(( new Emitter()));
+        this._onDidLayout = this._register(( (new Emitter())));
         this.onDidLayout = this._onDidLayout.event;
-        this._onBeforeUnload = this._register(( new Emitter()));
+        this._onBeforeUnload = this._register(( (new Emitter())));
         this.onBeforeUnload = this._onBeforeUnload.event;
-        this._onUnload = this._register(( new Emitter()));
+        this._onUnload = this._register(( (new Emitter())));
         this.onUnload = this._onUnload.event;
-        this._onWillDispose = this._register(( new Emitter()));
+        this._onWillDispose = this._register(( (new Emitter())));
         this.onWillDispose = this._onWillDispose.event;
         this.whenStylesHaveLoaded = stylesHaveLoaded.wait().then(() => undefined);
         this.registerListeners();
@@ -83,8 +92,8 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     preventUnload(e) {
         e.preventDefault();
         e.returnValue = ( localizeWithPath(
-            'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
-            'lifecycleVeto',
+            _moduleId,
+            0,
             "Changes that you made may not be saved. Please check press 'Cancel' and try again."
         ));
     }
@@ -99,6 +108,17 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
         this._onWillLayout.fire(dimension);
         this._onDidLayout.fire(dimension);
     }
+    createState() {
+        return {
+            bounds: {
+                x: this.window.screenX,
+                y: this.window.screenY,
+                width: this.window.outerWidth,
+                height: this.window.outerHeight
+            },
+            zoomLevel: getZoomLevel(this.window)
+        };
+    }
     dispose() {
         if (this._store.isDisposed) {
             return;
@@ -107,11 +127,11 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
         super.dispose();
     }
 };
-AuxiliaryWindow = ( __decorate([
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchEnvironmentService))
-], AuxiliaryWindow));
+AuxiliaryWindow = ( (__decorate([
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IHostService))),
+    ( (__param(5, IWorkbenchEnvironmentService)))
+], AuxiliaryWindow)));
 let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends Disposable {
     static { BrowserAuxiliaryWindowService_1 = this; }
     static { this.DEFAULT_SIZE = { width: 800, height: 600 }; }
@@ -124,25 +144,25 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         this.telemetryService = telemetryService;
         this.hostService = hostService;
         this.environmentService = environmentService;
-        this._onDidOpenAuxiliaryWindow = this._register(( new Emitter()));
+        this._onDidOpenAuxiliaryWindow = this._register(( (new Emitter())));
         this.onDidOpenAuxiliaryWindow = this._onDidOpenAuxiliaryWindow.event;
-        this.windows = ( new Map());
+        this.windows = ( (new Map()));
     }
     async open(options) {
         mark('code/auxiliaryWindow/willOpen');
         const targetWindow = await this.openWindow(options);
         if (!targetWindow) {
-            throw new Error(localizeWithPath('vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService', 'unableToOpenWindowError', "Unable to open a new window."));
+            throw ( (new Error(localizeWithPath(_moduleId, 1, "Unable to open a new window."))));
         }
         const resolvedWindowId = await this.resolveWindowId(targetWindow);
         ensureCodeWindow(targetWindow, resolvedWindowId);
-        const containerDisposables = ( new DisposableStore());
+        const containerDisposables = ( (new DisposableStore()));
         const { container, stylesLoaded } = this.createContainer(targetWindow, containerDisposables, options);
         const auxiliaryWindow = this.createAuxiliaryWindow(targetWindow, container, stylesLoaded);
-        const registryDisposables = ( new DisposableStore());
+        const registryDisposables = ( (new DisposableStore()));
         this.windows.set(targetWindow.vscodeWindowId, auxiliaryWindow);
         registryDisposables.add(toDisposable(() => this.windows.delete(targetWindow.vscodeWindowId)));
-        const eventDisposables = ( new DisposableStore());
+        const eventDisposables = ( (new DisposableStore()));
         Event.once(auxiliaryWindow.onWillDispose)(() => {
             targetWindow.close();
             containerDisposables.dispose();
@@ -156,14 +176,16 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         return auxiliaryWindow;
     }
     createAuxiliaryWindow(targetWindow, container, stylesLoaded) {
-        return ( new AuxiliaryWindow(
-            targetWindow,
-            container,
-            stylesLoaded,
-            this.configurationService,
-            this.hostService,
-            this.environmentService
-        ));
+        return (
+             (new AuxiliaryWindow(
+                targetWindow,
+                container,
+                stylesLoaded,
+                this.configurationService,
+                this.hostService,
+                this.environmentService
+            ))
+        );
     }
     async openWindow(options) {
         const activeWindow = getActiveWindow();
@@ -181,34 +203,39 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             width,
             height
         };
-        if (newWindowBounds.x === activeWindowBounds.x && newWindowBounds.y === activeWindowBounds.y) {
+        if (!options?.bounds && newWindowBounds.x === activeWindowBounds.x && newWindowBounds.y === activeWindowBounds.y) {
             newWindowBounds = {
                 ...newWindowBounds,
                 x: newWindowBounds.x + 30,
                 y: newWindowBounds.y + 30
             };
         }
-        const auxiliaryWindow = mainWindow.open('about:blank', undefined, `popup=yes,left=${newWindowBounds.x},top=${newWindowBounds.y},width=${newWindowBounds.width},height=${newWindowBounds.height}`);
+        const features = coalesce([
+            'popup=yes',
+            `left=${newWindowBounds.x}`,
+            `top=${newWindowBounds.y}`,
+            `width=${newWindowBounds.width}`,
+            `height=${newWindowBounds.height}`,
+            options?.mode === AuxiliaryWindowMode.Maximized ? 'window-maximized=yes' : undefined,
+            options?.mode === AuxiliaryWindowMode.Fullscreen ? 'window-fullscreen=yes' : undefined
+        ]);
+        const auxiliaryWindow = mainWindow.open('about:blank', undefined, features.join(','));
         if (!auxiliaryWindow && isWeb) {
             return (await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localizeWithPath(
-                    'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
-                    'unableToOpenWindow',
+                    _moduleId,
+                    2,
                     "The browser interrupted the opening of a new window. Press 'Retry' to try again."
                 )),
                 detail: ( localizeWithPath(
-                    'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
-                    'unableToOpenWindowDetail',
+                    _moduleId,
+                    3,
                     "To avoid this problem in the future, please ensure to allow popups for this website."
                 )),
                 buttons: [
                     {
-                        label: ( localizeWithPath(
-                            'vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService',
-                            { key: 'retry', comment: ['&& denotes a mnemonic'] },
-                            "&&Retry"
-                        )),
+                        label: ( localizeWithPath(_moduleId, 4, "&&Retry")),
                         run: () => this.openWindow(options)
                     }
                 ],
@@ -248,10 +275,10 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
     }
     applyCSS(auxiliaryWindow, disposables) {
         mark('code/auxiliaryWindow/willApplyCSS');
-        const mapOriginalToClone = ( new Map());
-        const stylesLoaded = ( new Barrier());
+        const mapOriginalToClone = ( (new Map()));
+        const stylesLoaded = ( (new Barrier()));
         stylesLoaded.wait().then(() => mark('code/auxiliaryWindow/didLoadCSSStyles'));
-        const pendingLinksDisposables = disposables.add(( new DisposableStore()));
+        const pendingLinksDisposables = disposables.add(( (new DisposableStore())));
         let pendingLinksToSettle = 0;
         function onLinkSettled() {
             if (--pendingLinksToSettle === 0) {
@@ -328,14 +355,17 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         mark('code/auxiliaryWindow/didApplyHTML');
         return container;
     }
+    getWindow(windowId) {
+        return this.windows.get(windowId);
+    }
 };
-BrowserAuxiliaryWindowService = BrowserAuxiliaryWindowService_1 = ( __decorate([
-    ( __param(0, IWorkbenchLayoutService)),
-    ( __param(1, IDialogService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IHostService)),
-    ( __param(5, IWorkbenchEnvironmentService))
-], BrowserAuxiliaryWindowService));
+BrowserAuxiliaryWindowService = BrowserAuxiliaryWindowService_1 = ( (__decorate([
+    ( (__param(0, IWorkbenchLayoutService))),
+    ( (__param(1, IDialogService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, ITelemetryService))),
+    ( (__param(4, IHostService))),
+    ( (__param(5, IWorkbenchEnvironmentService)))
+], BrowserAuxiliaryWindowService)));
 
-export { AuxiliaryWindow, BrowserAuxiliaryWindowService };
+export { AuxiliaryWindow, AuxiliaryWindowMode, BrowserAuxiliaryWindowService };

package/vscode/src/vs/workbench/services/driver/browser/driver.js

@@ -51,7 +51,9 @@ let BrowserWindowDriver = class BrowserWindowDriver {
                 chain.unshift(`${tagName}${id}${classes}`);
                 el = el.parentElement;
             }
-            throw new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`);
+            throw ( new Error(
+                `Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`
+            ));
         }
         return true;
     }
@@ -99,7 +101,7 @@ let BrowserWindowDriver = class BrowserWindowDriver {
     async typeInEditor(selector, text) {
         const element = mainWindow.document.querySelector(selector);
         if (!element) {
-            throw new Error(`Editor not found: ${selector}`);
+            throw ( new Error(`Editor not found: ${selector}`));
         }
         const textarea = element;
         const start = textarea.selectionStart;
@@ -114,11 +116,11 @@ let BrowserWindowDriver = class BrowserWindowDriver {
     async getTerminalBuffer(selector) {
         const element = mainWindow.document.querySelector(selector);
         if (!element) {
-            throw new Error(`Terminal not found: ${selector}`);
+            throw ( new Error(`Terminal not found: ${selector}`));
         }
         const xterm = element.xterm;
         if (!xterm) {
-            throw new Error(`Xterm not found: ${selector}`);
+            throw ( new Error(`Xterm not found: ${selector}`));
         }
         const lines = [];
         for (let i = 0; i < xterm.buffer.active.length; i++) {
@@ -129,13 +131,13 @@ let BrowserWindowDriver = class BrowserWindowDriver {
     async writeInTerminal(selector, text) {
         const element = mainWindow.document.querySelector(selector);
         if (!element) {
-            throw new Error(`Element not found: ${selector}`);
+            throw ( new Error(`Element not found: ${selector}`));
         }
         const xterm = element.xterm;
         if (!xterm) {
-            throw new Error(`Xterm not found: ${selector}`);
+            throw ( new Error(`Xterm not found: ${selector}`));
         }
-        xterm._core.coreService.triggerDataEvent(text);
+        xterm.input(text);
     }
     getLocaleInfo() {
         return Promise.resolve({

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

@@ -25,6 +25,7 @@ import { PauseableEmitter } from 'vscode/vscode/vs/base/common/event';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
 var EditorResolverService_1;
+const _moduleId = "vs/workbench/services/editor/browser/editorResolverService";
 let EditorResolverService = class EditorResolverService extends Disposable {
     static { EditorResolverService_1 = this; }
     static { this.configureDefaultID = 'promptOpenWith.configureDefault'; }
@@ -41,14 +42,14 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         this.storageService = storageService;
         this.extensionService = extensionService;
         this.logService = logService;
-        this._onDidChangeEditorRegistrations = this._register(( new PauseableEmitter()));
+        this._onDidChangeEditorRegistrations = this._register(( (new PauseableEmitter())));
         this.onDidChangeEditorRegistrations = this._onDidChangeEditorRegistrations.event;
-        this._editors = ( new Map());
-        this._flattenedEditors = ( new Map());
+        this._editors = ( (new Map()));
+        this._flattenedEditors = ( (new Map()));
         this._shouldReFlattenEditors = true;
-        this.cache = ( new Set(
+        this.cache = ( (new Set(
             JSON.parse(this.storageService.get(EditorResolverService_1.cacheStorageID, 0 , JSON.stringify([])))
-        ));
+        )));
         this.storageService.remove(EditorResolverService_1.cacheStorageID, 0 );
         this._register(this.storageService.onWillSaveState(() => {
             this.cacheEditors();
@@ -93,7 +94,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             await this.extensionService.whenInstalledExtensionsRegistered();
         }
         if (resource === undefined) {
-            resource = ( URI.from({ scheme: Schemas.untitled }));
+            resource = ( (URI.from({ scheme: Schemas.untitled })));
         }
         else if (resource.scheme === undefined || resource === null) {
             return 2 ;
@@ -120,7 +121,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         if (isResourceDiffEditorInput(untypedEditor) && untypedEditor.options?.override === undefined) {
             let resource2 = EditorResourceAccessor.getCanonicalUri(untypedEditor, { supportSideBySide: SideBySideEditor.SECONDARY });
             if (!resource2) {
-                resource2 = ( URI.from({ scheme: Schemas.untitled }));
+                resource2 = ( (URI.from({ scheme: Schemas.untitled })));
             }
             const { editor: selectedEditor2 } = this.getEditor(resource2, undefined);
             if (!selectedEditor2 || selectedEditor.editorInfo.id !== selectedEditor2.editorInfo.id) {
@@ -176,7 +177,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
     registerEditor(globPattern, editorInfo, options, editorFactoryObject) {
         let registeredEditor = this._editors.get(globPattern);
         if (registeredEditor === undefined) {
-            registeredEditor = ( new Map());
+            registeredEditor = ( (new Map()));
             this._editors.set(globPattern, registeredEditor);
         }
         let editorsWithId = registeredEditor.get(editorInfo.id);
@@ -234,10 +235,10 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return this._flattenedEditors;
         }
         this._shouldReFlattenEditors = false;
-        const editors = ( new Map());
+        const editors = ( (new Map()));
         for (const [glob, value] of this._editors) {
             const registeredEditors = [];
-            for (const editors of ( value.values())) {
+            for (const editors of ( (value.values()))) {
                 let registeredEditor = undefined;
                 for (const editor of editors) {
                     if (!registeredEditor) {
@@ -260,7 +261,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         return editors;
     }
     get _registeredEditors() {
-        return flatten(Array.from(( this._flattenedEditors.values())));
+        return flatten(Array.from(( (this._flattenedEditors.values()))));
     }
     updateUserAssociations(globPattern, editorID) {
         const newAssociation = { viewType: editorID, filenamePattern: globPattern };
@@ -298,9 +299,11 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             if (editors.find(e => e.editorInfo.priority === RegisteredEditorPriority.exclusive)) {
                 return [];
             }
-            return ( editors.map(editor => editor.editorInfo));
+            return (
+                 (editors.map(editor => editor.editorInfo))
+            );
         }
-        return distinct(( this._registeredEditors.map(editor => editor.editorInfo)), editor => editor.id);
+        return distinct(( (this._registeredEditors.map(editor => editor.editorInfo))), editor => editor.id);
     }
     getEditor(resource, editorId) {
         const findMatchingEditor = (editors, viewType) => {
@@ -369,7 +372,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return { editor: inputWithOptions.editor, options: inputWithOptions.options ?? options };
         }
         if (isResourceSideBySideEditorInput(editor)) {
-            throw new Error(`Untyped side by side editor input not supported here.`);
+            throw ( (new Error(`Untyped side by side editor input not supported here.`)));
         }
         if (isUntitledResourceEditorInput(editor)) {
             if (!selectedEditor.editorFactoryObject.createUntitledEditorInput) {
@@ -379,7 +382,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return { editor: inputWithOptions.editor, options: inputWithOptions.options ?? options };
         }
         if (resource === undefined) {
-            throw new Error(`Undefined resource on non untitled editor input.`);
+            throw ( (new Error(`Undefined resource on non untitled editor input.`)));
         }
         const singleEditorPerResource = typeof selectedEditor.options?.singlePerResource === 'function' ? selectedEditor.options.singlePerResource() : selectedEditor.options?.singlePerResource;
         if (singleEditorPerResource) {
@@ -447,15 +450,11 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             return;
         }
         const handle = this.notificationService.prompt(Severity$1.Warning, ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'editorResolver.conflictingDefaults',
+            _moduleId,
+            0,
             'There are multiple default editors available for the resource.'
         )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'editorResolver.configureDefault',
-                    'Configure Default'
-                )),
+                label: ( localizeWithPath(_moduleId, 1, 'Configure Default')),
                 run: async () => {
                     const picked = await this.doPickEditor(untypedInput, true);
                     if (!picked) {
@@ -476,12 +475,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             },
             {
-                label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'editorResolver.keepDefault',
-                    'Keep {0}',
-                    editorName
-                )),
+                label: ( localizeWithPath(_moduleId, 2, 'Keep {0}', editorName)),
                 run: writeCurrentEditorsToStorage
             }
         ]);
@@ -507,21 +501,9 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             }
         });
         const quickPickEntries = [];
-        const currentlyActiveLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentlyActive',
-            "Active"
-        ));
-        const currentDefaultLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentDefault',
-            "Default"
-        ));
-        const currentDefaultAndActiveLabel = ( localizeWithPath(
-            'vs/workbench/services/editor/browser/editorResolverService',
-            'promptOpenWith.currentDefaultAndActive',
-            "Active and Default"
-        ));
+        const currentlyActiveLabel = ( localizeWithPath(_moduleId, 3, "Active"));
+        const currentDefaultLabel = ( localizeWithPath(_moduleId, 4, "Default"));
+        const currentDefaultAndActiveLabel = ( localizeWithPath(_moduleId, 5, "Active and Default"));
         let defaultViewType = defaultSetting;
         if (!defaultViewType && registeredEditors.length > 2 && registeredEditors[1]?.editorInfo.priority !== RegisteredEditorPriority.option) {
             defaultViewType = registeredEditors[1]?.editorInfo.id;
@@ -547,8 +529,8 @@ let EditorResolverService = class EditorResolverService extends Disposable {
             const configureDefaultEntry = {
                 id: EditorResolverService_1.configureDefaultID,
                 label: ( localizeWithPath(
-                    'vs/workbench/services/editor/browser/editorResolverService',
-                    'promptOpenWith.configureDefault',
+                    _moduleId,
+                    6,
                     "Configure default editor for '{0}'...",
                     `*${extname(resource)}`
                 )),
@@ -560,23 +542,18 @@ let EditorResolverService = class EditorResolverService extends Disposable {
     async doPickEditor(editor, showDefaultPicker) {
         let resource = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
         if (resource === undefined) {
-            resource = ( URI.from({ scheme: Schemas.untitled }));
+            resource = ( (URI.from({ scheme: Schemas.untitled })));
         }
         const editorPicks = this.mapEditorsToQuickPickEntry(resource, showDefaultPicker);
         const editorPicker = this.quickInputService.createQuickPick();
         const placeHolderMessage = showDefaultPicker ?
             ( localizeWithPath(
-                'vs/workbench/services/editor/browser/editorResolverService',
-                'promptOpenWith.updateDefaultPlaceHolder',
+                _moduleId,
+                7,
                 "Select new default editor for '{0}'",
                 `*${extname(resource)}`
             )) :
-            ( localizeWithPath(
-                'vs/workbench/services/editor/browser/editorResolverService',
-                'promptOpenWith.placeHolder',
-                "Select editor for '{0}'",
-                basename(resource)
-            ));
+            ( localizeWithPath(_moduleId, 8, "Select editor for '{0}'", basename(resource)));
         editorPicker.placeholder = placeHolderMessage;
         editorPicker.canAcceptInBackground = true;
         editorPicker.items = editorPicks;
@@ -584,7 +561,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         if (firstItem) {
             editorPicker.selectedItems = [firstItem];
         }
-        const picked = await ( new Promise(resolve => {
+        const picked = await ( (new Promise(resolve => {
             editorPicker.onDidAccept(e => {
                 let result = undefined;
                 if (editorPicker.selectedItems.length === 1) {
@@ -607,7 +584,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
                 }
             });
             editorPicker.show();
-        }));
+        })));
         editorPicker.dispose();
         if (picked) {
             if (picked.item.id === EditorResolverService_1.configureDefaultID) {
@@ -628,7 +605,7 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         }
     }
     cacheEditors() {
-        const cacheStorage = ( new Set());
+        const cacheStorage = ( (new Set()));
         for (const [globPattern, contribPoint] of this._flattenedEditors) {
             const nonOptional = !!contribPoint.find(c => c.editorInfo.priority !== RegisteredEditorPriority.option && c.editorInfo.id !== DEFAULT_EDITOR_ASSOCIATION.id);
             if (!nonOptional) {
@@ -661,16 +638,16 @@ let EditorResolverService = class EditorResolverService extends Disposable {
         return false;
     }
 };
-EditorResolverService = EditorResolverService_1 = ( __decorate([
-    ( __param(0, IEditorGroupsService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IExtensionService)),
-    ( __param(8, ILogService))
-], EditorResolverService));
+EditorResolverService = EditorResolverService_1 = ( (__decorate([
+    ( (__param(0, IEditorGroupsService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IQuickInputService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, ITelemetryService))),
+    ( (__param(6, IStorageService))),
+    ( (__param(7, IExtensionService))),
+    ( (__param(8, ILogService)))
+], EditorResolverService)));
 
 export { EditorResolverService };