@codingame/monaco-vscode-api 5.3.0 → 6.0.0

package/vscode/src/vs/workbench/browser/parts/views/viewPaneContainer.js

@@ -2,10 +2,11 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { DragAndDropObserver, addDisposableListener, EventType, getWindow, isAncestor } from '../../../../base/browser/dom.js';
 import { StandardMouseEvent } from '../../../../base/browser/mouseEvent.js';
 import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+import { Orientation } from '../../../../base/browser/ui/sash/sash.js';
 import { PaneView } from '../../../../base/browser/ui/splitview/paneview.js';
 import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
-import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { KeyChord, KeyCode, KeyMod as KeyMod$1 } from '../../../../base/common/keyCodes.js';
 import { toDisposable, combinedDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { assertIsDefined } from '../../../../base/common/types.js';
 import './media/paneviewlet.css.js';
@@ -17,6 +18,8 @@ import { IConfigurationService } from '../../../../platform/configuration/common
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import { asCssVariable } from '../../../../platform/theme/common/colorUtils.js';
@@ -37,11 +40,12 @@ import { CompositeMenuActions } from '../../actions.js';
 import { CompositeDragAndDropObserver, toggleDropEffect } from '../../dnd.js';
 import { Component } from '../../../common/component.js';
 import { PANEL_SECTION_DRAG_AND_DROP_BACKGROUND, SIDE_BAR_DRAG_AND_DROP_BACKGROUND, PANEL_SECTION_HEADER_FOREGROUND, SIDE_BAR_SECTION_HEADER_FOREGROUND, PANEL_SECTION_HEADER_BACKGROUND, SIDE_BAR_SECTION_HEADER_BACKGROUND, PANEL_SECTION_HEADER_BORDER, SIDE_BAR_SECTION_HEADER_BORDER, PANEL_SECTION_BORDER } from '../../../common/theme.js';
-import { ViewContainerLocationToString, ViewVisibilityState } from '../../../common/views.js';
+import { ViewContainerLocation, ViewContainerLocationToString, ViewVisibilityState } from '../../../common/views.js';
 import { IViewDescriptorService } from '../../../common/views.service.js';
 import { IViewsService } from '../../../services/views/common/viewsService.service.js';
 import { FocusedViewContext } from '../../../common/contextkeys.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { LayoutSettings, Position } from '../../../services/layout/browser/layoutService.js';
 import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.service.js';
 const _moduleId = "vs/workbench/browser/parts/views/viewPaneContainer";
 const ViewsSubMenu = ( (new MenuId('Views')));
@@ -50,6 +54,13 @@ MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
     title: ( localizeWithPath(_moduleId, 0, "Views")),
     order: 1,
 });
+var DropDirection;
+( ((function(DropDirection) {
+    DropDirection[DropDirection["UP"] = 0] = "UP";
+    DropDirection[DropDirection["DOWN"] = 1] = "DOWN";
+    DropDirection[DropDirection["LEFT"] = 2] = "LEFT";
+    DropDirection[DropDirection["RIGHT"] = 3] = "RIGHT";
+})(DropDirection || (DropDirection = {}))));
 class ViewPaneDropOverlay extends Themable {
     static { this.OVERLAY_ID = 'monaco-pane-drop-overlay'; }
     get currentDropOperation() {
@@ -84,7 +95,7 @@ class ViewPaneDropOverlay extends Themable {
         this.updateStyles();
     }
     updateStyles() {
-        this.overlay.style.backgroundColor = this.getColor(this.location === 1  ? PANEL_SECTION_DRAG_AND_DROP_BACKGROUND : SIDE_BAR_DRAG_AND_DROP_BACKGROUND) || '';
+        this.overlay.style.backgroundColor = this.getColor(this.location === ViewContainerLocation.Panel ? PANEL_SECTION_DRAG_AND_DROP_BACKGROUND : SIDE_BAR_DRAG_AND_DROP_BACKGROUND) || '';
         const activeContrastBorderColor = this.getColor(activeContrastBorder);
         this.overlay.style.outlineColor = activeContrastBorderColor || '';
         this.overlay.style.outlineOffset = activeContrastBorderColor ? '-2px' : '';
@@ -120,33 +131,33 @@ class ViewPaneDropOverlay extends Themable {
         const splitWidthThreshold = paneWidth / 2;
         const splitHeightThreshold = paneHeight / 2;
         let dropDirection;
-        if (this.orientation === 0 ) {
+        if (this.orientation === Orientation.VERTICAL) {
             if (mousePosY < splitHeightThreshold) {
-                dropDirection = 0 ;
+                dropDirection = DropDirection.UP;
             }
             else if (mousePosY >= splitHeightThreshold) {
-                dropDirection = 1 ;
+                dropDirection = DropDirection.DOWN;
             }
         }
-        else if (this.orientation === 1 ) {
+        else if (this.orientation === Orientation.HORIZONTAL) {
             if (mousePosX < splitWidthThreshold) {
-                dropDirection = 2 ;
+                dropDirection = DropDirection.LEFT;
             }
             else if (mousePosX >= splitWidthThreshold) {
-                dropDirection = 3 ;
+                dropDirection = DropDirection.RIGHT;
             }
         }
         switch (dropDirection) {
-            case 0 :
+            case DropDirection.UP:
                 this.doPositionOverlay({ top: '0', left: '0', width: '100%', height: '50%' });
                 break;
-            case 1 :
+            case DropDirection.DOWN:
                 this.doPositionOverlay({ bottom: '0', left: '0', width: '100%', height: '50%' });
                 break;
-            case 2 :
+            case DropDirection.LEFT:
                 this.doPositionOverlay({ top: '0', left: '0', width: '50%', height: '100%' });
                 break;
-            case 3 :
+            case DropDirection.RIGHT:
                 this.doPositionOverlay({ top: '0', right: '0', width: '50%', height: '100%' });
                 break;
             default: {
@@ -164,8 +175,8 @@ class ViewPaneDropOverlay extends Themable {
                 this.doPositionOverlay({ top, left, width, height });
             }
         }
-        if ((this.orientation === 0  && paneHeight <= 25) ||
-            (this.orientation === 1  && paneWidth <= 25)) {
+        if ((this.orientation === Orientation.VERTICAL && paneHeight <= 25) ||
+            (this.orientation === Orientation.HORIZONTAL && paneWidth <= 25)) {
             this.doUpdateOverlayBorder(dropDirection);
         }
         else {
@@ -176,10 +187,10 @@ class ViewPaneDropOverlay extends Themable {
         this._currentDropOperation = dropDirection;
     }
     doUpdateOverlayBorder(direction) {
-        this.overlay.style.borderTopWidth = direction === 0  ? '2px' : '0px';
-        this.overlay.style.borderLeftWidth = direction === 2  ? '2px' : '0px';
-        this.overlay.style.borderBottomWidth = direction === 1  ? '2px' : '0px';
-        this.overlay.style.borderRightWidth = direction === 3  ? '2px' : '0px';
+        this.overlay.style.borderTopWidth = direction === DropDirection.UP ? '2px' : '0px';
+        this.overlay.style.borderLeftWidth = direction === DropDirection.LEFT ? '2px' : '0px';
+        this.overlay.style.borderBottomWidth = direction === DropDirection.DOWN ? '2px' : '0px';
+        this.overlay.style.borderRightWidth = direction === DropDirection.RIGHT ? '2px' : '0px';
     }
     doPositionOverlay(options) {
         this.container.style.height = '100%';
@@ -267,7 +278,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
         }
         this.viewContainer = container;
         this.visibleViewsStorageId = `${id}.numberOfVisibleViews`;
-        this.visibleViewsCountFromCache = this.storageService.getNumber(this.visibleViewsStorageId, 1 , undefined);
+        this.visibleViewsCountFromCache = this.storageService.getNumber(this.visibleViewsStorageId, StorageScope.WORKSPACE, undefined);
         this.viewContainerModel = this.viewDescriptorService.getViewContainerModel(container);
     }
     create(parent) {
@@ -289,8 +300,8 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
         const getOverlayBounds = () => {
             const fullSize = parent.getBoundingClientRect();
             const lastPane = this.panes[this.panes.length - 1].element.getBoundingClientRect();
-            const top = this.orientation === 0  ? lastPane.bottom : fullSize.top;
-            const left = this.orientation === 1  ? lastPane.right : fullSize.left;
+            const top = this.orientation === Orientation.VERTICAL ? lastPane.bottom : fullSize.top;
+            const left = this.orientation === Orientation.HORIZONTAL ? lastPane.right : fullSize.left;
             return {
                 top,
                 bottom: fullSize.bottom,
@@ -408,7 +419,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                 this.updateViewHeaders();
             }
             this._register(this.configurationService.onDidChangeConfiguration(e => {
-                if (e.affectsConfiguration("workbench.activityBar.location" )) {
+                if (e.affectsConfiguration(LayoutSettings.ACTIVITY_BAR_LOCATION)) {
                     this.updateViewHeaders();
                 }
             }));
@@ -471,13 +482,13 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
     }
     get orientation() {
         switch (this.viewDescriptorService.getViewContainerLocation(this.viewContainer)) {
-            case 0 :
-            case 2 :
-                return 0 ;
-            case 1 :
-                return this.layoutService.getPanelPosition() === 2  ? 1  : 0 ;
+            case ViewContainerLocation.Sidebar:
+            case ViewContainerLocation.AuxiliaryBar:
+                return Orientation.VERTICAL;
+            case ViewContainerLocation.Panel:
+                return this.layoutService.getPanelPosition() === Position.BOTTOM ? Orientation.HORIZONTAL : Orientation.VERTICAL;
         }
-        return 0 ;
+        return Orientation.VERTICAL;
     }
     layout(dimension) {
         if (this.paneview) {
@@ -562,7 +573,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
         if (this.dimension) {
             const totalWeight = this.viewContainerModel.visibleViewDescriptors.reduce((totalWeight, { weight }) => totalWeight + (weight || 20), 0);
             for (const viewDescriptor of this.viewContainerModel.visibleViewDescriptors) {
-                if (this.orientation === 0 ) {
+                if (this.orientation === Orientation.VERTICAL) {
                     sizes.set(viewDescriptor.id, this.dimension.height * (viewDescriptor.weight || 20) / totalWeight);
                 }
                 else {
@@ -574,7 +585,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
     }
     saveState() {
         this.panes.forEach((view) => view.saveState());
-        this.storageService.store(this.visibleViewsStorageId, this.length, 1 , 1 );
+        this.storageService.store(this.visibleViewsStorageId, this.length, StorageScope.WORKSPACE, StorageTarget.MACHINE);
     }
     onContextMenu(event, viewPane) {
         event.stopPropagation();
@@ -668,7 +679,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                 this.lastFocusedPane = undefined;
             }
         });
-        const isPanel = this.viewDescriptorService.getViewContainerLocation(this.viewContainer) === 1 ;
+        const isPanel = this.viewDescriptorService.getViewContainerLocation(this.viewContainer) === ViewContainerLocation.Panel;
         pane.style({
             headerForeground: asCssVariable(isPanel ? PANEL_SECTION_HEADER_FOREGROUND : SIDE_BAR_SECTION_HEADER_FOREGROUND),
             headerBackground: asCssVariable(isPanel ? PANEL_SECTION_HEADER_BACKGROUND : SIDE_BAR_SECTION_HEADER_BACKGROUND),
@@ -696,7 +707,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                         }
                         overlay = ( (new ViewPaneDropOverlay(
                             pane.dropTargetElement,
-                            this.orientation ?? 0 ,
+                            this.orientation ?? Orientation.VERTICAL,
                             undefined,
                             this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
                             this.themeService
@@ -708,7 +719,7 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                         if (!( (viewsToMove.some(v => !v.canMoveView))) && viewsToMove.length > 0) {
                             overlay = ( (new ViewPaneDropOverlay(
                                 pane.dropTargetElement,
-                                this.orientation ?? 0 ,
+                                this.orientation ?? Orientation.VERTICAL,
                                 undefined,
                                 this.viewDescriptorService.getViewContainerLocation(this.viewContainer),
                                 this.themeService
@@ -751,8 +762,8 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                         this.viewDescriptorService.moveViewsToContainer(viewsToMove, this.viewContainer, undefined, 'dnd');
                     }
                     if (anchorView) {
-                        if (overlay.currentDropOperation === 1  ||
-                            overlay.currentDropOperation === 3 ) {
+                        if (overlay.currentDropOperation === DropDirection.DOWN ||
+                            overlay.currentDropOperation === DropDirection.RIGHT) {
                             const fromIndex = this.panes.findIndex(p => p.id === anchorView.id);
                             let toIndex = this.panes.findIndex(p => p.id === pane.id);
                             if (fromIndex >= 0 && toIndex >= 0) {
@@ -764,8 +775,8 @@ let ViewPaneContainer = class ViewPaneContainer extends Component {
                                 }
                             }
                         }
-                        if (overlay.currentDropOperation === 0  ||
-                            overlay.currentDropOperation === 2 ) {
+                        if (overlay.currentDropOperation === DropDirection.UP ||
+                            overlay.currentDropOperation === DropDirection.LEFT) {
                             const fromIndex = this.panes.findIndex(p => p.id === anchorView.id);
                             let toIndex = this.panes.findIndex(p => p.id === pane.id);
                             if (fromIndex >= 0 && toIndex >= 0) {
@@ -983,8 +994,8 @@ registerAction2(class MoveViewUp extends MoveViewPosition {
             id: 'views.moveViewUp',
             title: ( localizeWithPath(_moduleId, 1, "Move View Up")),
             keybinding: {
-                primary: KeyChord(2048  + 41 , 16 ),
-                weight: 200  + 1,
+                primary: KeyChord(KeyMod$1.CtrlCmd + KeyCode.KeyK, KeyCode.UpArrow),
+                weight: KeybindingWeight.WorkbenchContrib + 1,
                 when: ( (FocusedViewContext.notEqualsTo('')))
             }
         }, -1);
@@ -996,8 +1007,8 @@ registerAction2(class MoveViewLeft extends MoveViewPosition {
             id: 'views.moveViewLeft',
             title: ( localizeWithPath(_moduleId, 2, "Move View Left")),
             keybinding: {
-                primary: KeyChord(2048  + 41 , 15 ),
-                weight: 200  + 1,
+                primary: KeyChord(KeyMod$1.CtrlCmd + KeyCode.KeyK, KeyCode.LeftArrow),
+                weight: KeybindingWeight.WorkbenchContrib + 1,
                 when: ( (FocusedViewContext.notEqualsTo('')))
             }
         }, -1);
@@ -1009,8 +1020,8 @@ registerAction2(class MoveViewDown extends MoveViewPosition {
             id: 'views.moveViewDown',
             title: ( localizeWithPath(_moduleId, 3, "Move View Down")),
             keybinding: {
-                primary: KeyChord(2048  + 41 , 18 ),
-                weight: 200  + 1,
+                primary: KeyChord(KeyMod$1.CtrlCmd + KeyCode.KeyK, KeyCode.DownArrow),
+                weight: KeybindingWeight.WorkbenchContrib + 1,
                 when: ( (FocusedViewContext.notEqualsTo('')))
             }
         }, 1);
@@ -1022,8 +1033,8 @@ registerAction2(class MoveViewRight extends MoveViewPosition {
             id: 'views.moveViewRight',
             title: ( localizeWithPath(_moduleId, 4, "Move View Right")),
             keybinding: {
-                primary: KeyChord(2048  + 41 , 17 ),
-                weight: 200  + 1,
+                primary: KeyChord(KeyMod$1.CtrlCmd + KeyCode.KeyK, KeyCode.RightArrow),
+                weight: KeybindingWeight.WorkbenchContrib + 1,
                 when: ( (FocusedViewContext.notEqualsTo('')))
             }
         }, 1);

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

@@ -0,0 +1,329 @@
+import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
+import { setFullscreen, isSafari } from '../../base/browser/browser.js';
+import { getWindowsCount, getWindows, getWindow, getActiveWindow, getWindowById, addDisposableListener, EventType, EventHelper, windowOpenWithSuccess, windowOpenPopup, windowOpenNoOpener } from '../../base/browser/dom.js';
+import { DomEmitter } from '../../base/browser/event.js';
+import { requestUsbDevice, requestSerialPort, requestHidDevice } from '../../base/browser/deviceAccess.js';
+import { timeout } from '../../base/common/async.js';
+import { Event } from '../../base/common/event.js';
+import { Disposable, dispose, toDisposable } from '../../base/common/lifecycle.js';
+import { matchesScheme, Schemas } from '../../base/common/network.js';
+import { isMacintosh, isIOS } from '../../base/common/platform.js';
+import Severity$1 from '../../base/common/severity.js';
+import { URI } from '../../base/common/uri.js';
+import { localizeWithPath } from '../../nls.js';
+import { CommandsRegistry } from '../../platform/commands/common/commands.js';
+import { IDialogService } from '../../platform/dialogs/common/dialogs.service.js';
+import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
+import { ILabelService } from '../../platform/label/common/label.service.js';
+import { IOpenerService } from '../../platform/opener/common/opener.service.js';
+import { IProductService } from '../../platform/product/common/productService.service.js';
+import { IBrowserWorkbenchEnvironmentService } from '../services/environment/browser/environmentService.service.js';
+import { IWorkbenchLayoutService } from '../services/layout/browser/layoutService.service.js';
+import { ShutdownReason } from '../services/lifecycle/common/lifecycle.js';
+import { ILifecycleService } from '../services/lifecycle/common/lifecycle.service.js';
+import { IHostService } from '../services/host/browser/host.service.js';
+import { registerWindowDriver } from '../services/driver/browser/driver.js';
+import { isAuxiliaryWindow, mainWindow } from '../../base/browser/window.js';
+import { createSingleCallFunction } from '../../base/common/functional.js';
+import { IConfigurationService } from '../../platform/configuration/common/configuration.service.js';
+import { IWorkbenchEnvironmentService } from '../services/environment/common/environmentService.service.js';
+var BaseWindow_1;
+const _moduleId = "vs/workbench/browser/window";
+let BaseWindow = class BaseWindow extends Disposable {
+    static { BaseWindow_1 = this; }
+    static { this.TIMEOUT_HANDLES = Number.MIN_SAFE_INTEGER; }
+    static { this.TIMEOUT_DISPOSABLES = ( (new Map())); }
+    constructor(targetWindow, dom = { getWindowsCount, getWindows }, hostService, environmentService) {
+        super();
+        this.hostService = hostService;
+        this.environmentService = environmentService;
+        this.enableWindowFocusOnElementFocus(targetWindow);
+        this.enableMultiWindowAwareTimeout(targetWindow, dom);
+        this.registerFullScreenListeners(targetWindow.vscodeWindowId);
+    }
+    enableWindowFocusOnElementFocus(targetWindow) {
+        const originalFocus = targetWindow.HTMLElement.prototype.focus;
+        const that = this;
+        targetWindow.HTMLElement.prototype.focus = function (options) {
+            that.onElementFocus(getWindow(this));
+            originalFocus.apply(this, [options]);
+        };
+    }
+    onElementFocus(targetWindow) {
+        const activeWindow = getActiveWindow();
+        if (activeWindow !== targetWindow && activeWindow.document.hasFocus()) {
+            targetWindow.focus();
+            if (!this.environmentService.extensionTestsLocationURI &&
+                !targetWindow.document.hasFocus()) {
+                this.hostService.focus(targetWindow);
+            }
+        }
+    }
+    enableMultiWindowAwareTimeout(targetWindow, dom = { getWindowsCount, getWindows }) {
+        const originalSetTimeout = targetWindow.setTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalSetTimeout', { get: () => originalSetTimeout });
+        const originalClearTimeout = targetWindow.clearTimeout;
+        Object.defineProperty(targetWindow, 'vscodeOriginalClearTimeout', { get: () => originalClearTimeout });
+        targetWindow.setTimeout = function (handler, timeout = 0, ...args) {
+            if (dom.getWindowsCount() === 1 || typeof handler === 'string' || timeout === 0 ) {
+                return originalSetTimeout.apply(this, [handler, timeout, ...args]);
+            }
+            const timeoutDisposables = ( (new Set()));
+            const timeoutHandle = BaseWindow_1.TIMEOUT_HANDLES++;
+            BaseWindow_1.TIMEOUT_DISPOSABLES.set(timeoutHandle, timeoutDisposables);
+            const handlerFn = createSingleCallFunction(handler, () => {
+                dispose(timeoutDisposables);
+                BaseWindow_1.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            });
+            for (const { window, disposables } of dom.getWindows()) {
+                if (isAuxiliaryWindow(window) && window.document.visibilityState === 'hidden') {
+                    continue;
+                }
+                const handle = window.vscodeOriginalSetTimeout.apply(this, [handlerFn, timeout, ...args]);
+                const timeoutDisposable = toDisposable(() => {
+                    window.vscodeOriginalClearTimeout(handle);
+                    timeoutDisposables.delete(timeoutDisposable);
+                });
+                disposables.add(timeoutDisposable);
+                timeoutDisposables.add(timeoutDisposable);
+            }
+            return timeoutHandle;
+        };
+        targetWindow.clearTimeout = function (timeoutHandle) {
+            const timeoutDisposables = typeof timeoutHandle === 'number' ? BaseWindow_1.TIMEOUT_DISPOSABLES.get(timeoutHandle) : undefined;
+            if (timeoutDisposables) {
+                dispose(timeoutDisposables);
+                BaseWindow_1.TIMEOUT_DISPOSABLES.delete(timeoutHandle);
+            }
+            else {
+                originalClearTimeout.apply(this, [timeoutHandle]);
+            }
+        };
+    }
+    registerFullScreenListeners(targetWindowId) {
+        this._register(this.hostService.onDidChangeFullScreen(({ windowId, fullscreen }) => {
+            if (windowId === targetWindowId) {
+                const targetWindow = getWindowById(targetWindowId);
+                if (targetWindow) {
+                    setFullscreen(fullscreen, targetWindow.window);
+                }
+            }
+        }));
+    }
+    static async confirmOnShutdown(accessor, reason) {
+        const dialogService = accessor.get(IDialogService);
+        const configurationService = accessor.get(IConfigurationService);
+        const message = reason === ShutdownReason.QUIT ?
+            (isMacintosh ? ( localizeWithPath(_moduleId, 0, "Are you sure you want to quit?")) : ( localizeWithPath(_moduleId, 1, "Are you sure you want to exit?"))) :
+            ( localizeWithPath(_moduleId, 2, "Are you sure you want to close the window?"));
+        const primaryButton = reason === ShutdownReason.QUIT ?
+            (isMacintosh ? ( localizeWithPath(_moduleId, 3, "&&Quit")) : ( localizeWithPath(_moduleId, 4, "&&Exit"))) :
+            ( localizeWithPath(_moduleId, 5, "&&Close Window"));
+        const res = await dialogService.confirm({
+            message,
+            primaryButton,
+            checkbox: {
+                label: ( localizeWithPath(_moduleId, 6, "Do not ask me again"))
+            }
+        });
+        if (res.confirmed && res.checkboxChecked) {
+            await configurationService.updateValue('window.confirmBeforeClose', 'never');
+        }
+        return res.confirmed;
+    }
+};
+BaseWindow = BaseWindow_1 = ( (__decorate([
+    ( (__param(2, IHostService))),
+    ( (__param(3, IWorkbenchEnvironmentService)))
+], BaseWindow)));
+let BrowserWindow = class BrowserWindow extends BaseWindow {
+    constructor(openerService, lifecycleService, dialogService, labelService, productService, browserEnvironmentService, layoutService, instantiationService, hostService) {
+        super(mainWindow, undefined, hostService, browserEnvironmentService);
+        this.openerService = openerService;
+        this.lifecycleService = lifecycleService;
+        this.dialogService = dialogService;
+        this.labelService = labelService;
+        this.productService = productService;
+        this.browserEnvironmentService = browserEnvironmentService;
+        this.layoutService = layoutService;
+        this.instantiationService = instantiationService;
+        this.registerListeners();
+        this.create();
+    }
+    registerListeners() {
+        this._register(this.lifecycleService.onWillShutdown(() => this.onWillShutdown()));
+        const viewport = isIOS && mainWindow.visualViewport ? mainWindow.visualViewport  : mainWindow ;
+        this._register(addDisposableListener(viewport, EventType.RESIZE, () => {
+            this.layoutService.layout();
+            if (isIOS) {
+                mainWindow.scrollTo(0, 0);
+            }
+        }));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.WHEEL, e => e.preventDefault(), { passive: false }));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.CONTEXT_MENU, e => EventHelper.stop(e, true)));
+        this._register(addDisposableListener(this.layoutService.mainContainer, EventType.DROP, e => EventHelper.stop(e, true)));
+    }
+    onWillShutdown() {
+        Event.toPromise(Event.any(Event.once(( (new DomEmitter(mainWindow.document.body, EventType.KEY_DOWN, true))).event), Event.once(( (new DomEmitter(mainWindow.document.body, EventType.MOUSE_DOWN, true))).event))).then(async () => {
+            await timeout(3000);
+            await this.dialogService.prompt({
+                type: Severity$1.Error,
+                message: ( localizeWithPath(
+                    _moduleId,
+                    7,
+                    "An unexpected error occurred that requires a reload of this page."
+                )),
+                detail: ( localizeWithPath(_moduleId, 8, "The workbench was unexpectedly disposed while running.")),
+                buttons: [
+                    {
+                        label: ( localizeWithPath(_moduleId, 9, "&&Reload")),
+                        run: () => mainWindow.location.reload()
+                    }
+                ]
+            });
+        });
+    }
+    create() {
+        this.setupOpenHandlers();
+        this.registerLabelFormatters();
+        this.registerCommands();
+        this.setupDriver();
+    }
+    setupDriver() {
+        if (this.environmentService.enableSmokeTestDriver) {
+            registerWindowDriver(this.instantiationService);
+        }
+    }
+    setupOpenHandlers() {
+        this.openerService.setDefaultExternalOpener({
+            openExternal: async (href) => {
+                let isAllowedOpener = false;
+                if (this.browserEnvironmentService.options?.openerAllowedExternalUrlPrefixes) {
+                    for (const trustedPopupPrefix of this.browserEnvironmentService.options.openerAllowedExternalUrlPrefixes) {
+                        if (href.startsWith(trustedPopupPrefix)) {
+                            isAllowedOpener = true;
+                            break;
+                        }
+                    }
+                }
+                if (matchesScheme(href, Schemas.http) || matchesScheme(href, Schemas.https)) {
+                    if (isSafari) {
+                        const opened = windowOpenWithSuccess(href, !isAllowedOpener);
+                        if (!opened) {
+                            await this.dialogService.prompt({
+                                type: Severity$1.Warning,
+                                message: ( localizeWithPath(
+                                    _moduleId,
+                                    10,
+                                    "The browser interrupted the opening of a new tab or window. Press 'Open' to open it anyway."
+                                )),
+                                detail: href,
+                                buttons: [
+                                    {
+                                        label: ( localizeWithPath(_moduleId, 11, "&&Open")),
+                                        run: () => isAllowedOpener ? windowOpenPopup(href) : windowOpenNoOpener(href)
+                                    },
+                                    {
+                                        label: ( localizeWithPath(_moduleId, 12, "&&Learn More")),
+                                        run: () => this.openerService.open(( (URI.parse('https://aka.ms/allow-vscode-popup'))))
+                                    }
+                                ],
+                                cancelButton: true
+                            });
+                        }
+                    }
+                    else {
+                        isAllowedOpener
+                            ? windowOpenPopup(href)
+                            : windowOpenNoOpener(href);
+                    }
+                }
+                else {
+                    const invokeProtocolHandler = () => {
+                        this.lifecycleService.withExpectedShutdown({ disableShutdownHandling: true }, () => mainWindow.location.href = href);
+                    };
+                    invokeProtocolHandler();
+                    const showProtocolUrlOpenedDialog = async () => {
+                        const { downloadUrl } = this.productService;
+                        let detail;
+                        const buttons = [
+                            {
+                                label: ( localizeWithPath(_moduleId, 13, "&&Try Again")),
+                                run: () => invokeProtocolHandler()
+                            }
+                        ];
+                        if (downloadUrl !== undefined) {
+                            detail = ( localizeWithPath(
+                                _moduleId,
+                                14,
+                                "We launched {0} on your computer.\n\nIf {1} did not launch, try again or install it below.",
+                                this.productService.nameLong,
+                                this.productService.nameLong
+                            ));
+                            buttons.push({
+                                label: ( localizeWithPath(_moduleId, 15, "&&Install")),
+                                run: async () => {
+                                    await this.openerService.open(( (URI.parse(downloadUrl))));
+                                    showProtocolUrlOpenedDialog();
+                                }
+                            });
+                        }
+                        else {
+                            detail = ( localizeWithPath(
+                                _moduleId,
+                                16,
+                                "We launched {0} on your computer.\n\nIf {1} did not launch, try again below.",
+                                this.productService.nameLong,
+                                this.productService.nameLong
+                            ));
+                        }
+                        await this.hostService.withExpectedShutdown(() => this.dialogService.prompt({
+                            type: Severity$1.Info,
+                            message: ( localizeWithPath(_moduleId, 17, "All done. You can close this tab now.")),
+                            detail,
+                            buttons,
+                            cancelButton: true
+                        }));
+                    };
+                    if (matchesScheme(href, this.productService.urlProtocol)) {
+                        await showProtocolUrlOpenedDialog();
+                    }
+                }
+                return true;
+            }
+        });
+    }
+    registerLabelFormatters() {
+        this._register(this.labelService.registerFormatter({
+            scheme: Schemas.vscodeUserData,
+            priority: true,
+            formatting: {
+                label: '(Settings) ${path}',
+                separator: '/',
+            }
+        }));
+    }
+    registerCommands() {
+        CommandsRegistry.registerCommand('workbench.experimental.requestUsbDevice', async (_accessor, options) => {
+            return requestUsbDevice(options);
+        });
+        CommandsRegistry.registerCommand('workbench.experimental.requestSerialPort', async (_accessor, options) => {
+            return requestSerialPort(options);
+        });
+        CommandsRegistry.registerCommand('workbench.experimental.requestHidDevice', async (_accessor, options) => {
+            return requestHidDevice(options);
+        });
+    }
+};
+BrowserWindow = ( (__decorate([
+    ( (__param(0, IOpenerService))),
+    ( (__param(1, ILifecycleService))),
+    ( (__param(2, IDialogService))),
+    ( (__param(3, ILabelService))),
+    ( (__param(4, IProductService))),
+    ( (__param(5, IBrowserWorkbenchEnvironmentService))),
+    ( (__param(6, IWorkbenchLayoutService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IHostService)))
+], BrowserWindow)));
+export { BaseWindow, BrowserWindow };