@codingame/monaco-vscode-view-common-service-override 5.3.0 → 6.0.0

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

@@ -1,371 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { mark } from 'vscode/vscode/vs/base/common/performance';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { addDisposableListener, EventType, EventHelper, ModifierKeyEmitter, getClientArea, getWindowId, registerWindow, getActiveWindow, createMetaElement, copyAttributes, createLinkElement, isGlobalStylesheet, cloneGlobalStylesheets, sharedMutationObserver, position, trackAttributes } from 'vscode/vscode/vs/base/browser/dom';
-import { mainWindow, ensureCodeWindow } from 'vscode/vscode/vs/base/browser/window';
-import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
-import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { WindowMinimumSize } from 'vscode/vscode/vs/platform/window/common/window';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
-import { BaseWindow } from '../../../browser/window.js';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-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._onWillLayout.event;
-        this._onDidLayout = this._register(( (new Emitter())));
-        this.onDidLayout = this._onDidLayout.event;
-        this._onBeforeUnload = this._register(( (new Emitter())));
-        this.onBeforeUnload = this._onBeforeUnload.event;
-        this._onUnload = this._register(( (new Emitter())));
-        this.onUnload = this._onUnload.event;
-        this._onWillDispose = this._register(( (new Emitter())));
-        this.onWillDispose = this._onWillDispose.event;
-        this.whenStylesHaveLoaded = stylesHaveLoaded.wait().then(() => undefined);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(addDisposableListener(this.window, EventType.BEFORE_UNLOAD, (e) => this.handleBeforeUnload(e)));
-        this._register(addDisposableListener(this.window, EventType.UNLOAD, () => this.handleUnload()));
-        this._register(addDisposableListener(this.window, 'unhandledrejection', e => {
-            onUnexpectedError(e.reason);
-            e.preventDefault();
-        }));
-        this._register(addDisposableListener(this.window, EventType.RESIZE, () => this.layout()));
-        this._register(addDisposableListener(this.container, EventType.SCROLL, () => this.container.scrollTop = 0));
-        if (isWeb) {
-            this._register(addDisposableListener(this.container, EventType.DROP, e => EventHelper.stop(e, true)));
-            this._register(addDisposableListener(this.container, EventType.WHEEL, e => e.preventDefault(), { passive: false }));
-            this._register(addDisposableListener(this.container, EventType.CONTEXT_MENU, e => EventHelper.stop(e, true)));
-        }
-        else {
-            this._register(addDisposableListener(this.window.document.body, EventType.DRAG_OVER, (e) => EventHelper.stop(e)));
-            this._register(addDisposableListener(this.window.document.body, EventType.DROP, (e) => EventHelper.stop(e)));
-        }
-    }
-    handleBeforeUnload(e) {
-        let veto;
-        this._onBeforeUnload.fire({
-            veto(reason) {
-                if (reason) {
-                    veto = reason;
-                }
-            }
-        });
-        if (veto) {
-            this.handleVetoBeforeClose(e, veto);
-            return;
-        }
-        const confirmBeforeCloseSetting = this.configurationService.getValue('window.confirmBeforeClose');
-        const confirmBeforeClose = confirmBeforeCloseSetting === 'always' || (confirmBeforeCloseSetting === 'keyboardOnly' && ModifierKeyEmitter.getInstance().isModifierPressed);
-        if (confirmBeforeClose) {
-            this.confirmBeforeClose(e);
-        }
-    }
-    handleVetoBeforeClose(e, reason) {
-        this.preventUnload(e);
-    }
-    preventUnload(e) {
-        e.preventDefault();
-        e.returnValue = ( localizeWithPath(
-            _moduleId,
-            0,
-            "Changes that you made may not be saved. Please check press 'Cancel' and try again."
-        ));
-    }
-    confirmBeforeClose(e) {
-        this.preventUnload(e);
-    }
-    handleUnload() {
-        this._onUnload.fire();
-    }
-    layout() {
-        const dimension = getClientArea(this.window.document.body, this.container);
-        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;
-        }
-        this._onWillDispose.fire();
-        super.dispose();
-    }
-};
-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 }; }
-    static { this.WINDOW_IDS = getWindowId(mainWindow) + 1; }
-    constructor(layoutService, dialogService, configurationService, telemetryService, hostService, environmentService) {
-        super();
-        this.layoutService = layoutService;
-        this.dialogService = dialogService;
-        this.configurationService = configurationService;
-        this.telemetryService = telemetryService;
-        this.hostService = hostService;
-        this.environmentService = environmentService;
-        this._onDidOpenAuxiliaryWindow = this._register(( (new Emitter())));
-        this.onDidOpenAuxiliaryWindow = this._onDidOpenAuxiliaryWindow.event;
-        this.windows = ( (new Map()));
-    }
-    async open(options) {
-        mark('code/auxiliaryWindow/willOpen');
-        const targetWindow = await this.openWindow(options);
-        if (!targetWindow) {
-            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 { container, stylesLoaded } = this.createContainer(targetWindow, containerDisposables, options);
-        const auxiliaryWindow = this.createAuxiliaryWindow(targetWindow, container, stylesLoaded);
-        const registryDisposables = ( (new DisposableStore()));
-        this.windows.set(targetWindow.vscodeWindowId, auxiliaryWindow);
-        registryDisposables.add(toDisposable(() => this.windows.delete(targetWindow.vscodeWindowId)));
-        const eventDisposables = ( (new DisposableStore()));
-        Event.once(auxiliaryWindow.onWillDispose)(() => {
-            targetWindow.close();
-            containerDisposables.dispose();
-            registryDisposables.dispose();
-            eventDisposables.dispose();
-        });
-        registryDisposables.add(registerWindow(targetWindow));
-        this._onDidOpenAuxiliaryWindow.fire({ window: auxiliaryWindow, disposables: eventDisposables });
-        mark('code/auxiliaryWindow/didOpen');
-        this.telemetryService.publicLog2('auxiliaryWindowOpen', { bounds: !!options?.bounds });
-        return auxiliaryWindow;
-    }
-    createAuxiliaryWindow(targetWindow, container, stylesLoaded) {
-        return (
-             (new AuxiliaryWindow(
-                targetWindow,
-                container,
-                stylesLoaded,
-                this.configurationService,
-                this.hostService,
-                this.environmentService
-            ))
-        );
-    }
-    async openWindow(options) {
-        const activeWindow = getActiveWindow();
-        const activeWindowBounds = {
-            x: activeWindow.screenX,
-            y: activeWindow.screenY,
-            width: activeWindow.outerWidth,
-            height: activeWindow.outerHeight
-        };
-        const width = Math.max(options?.bounds?.width ?? BrowserAuxiliaryWindowService_1.DEFAULT_SIZE.width, WindowMinimumSize.WIDTH);
-        const height = Math.max(options?.bounds?.height ?? BrowserAuxiliaryWindowService_1.DEFAULT_SIZE.height, WindowMinimumSize.HEIGHT);
-        let newWindowBounds = {
-            x: options?.bounds?.x ?? Math.max(activeWindowBounds.x + activeWindowBounds.width / 2 - width / 2, 0),
-            y: options?.bounds?.y ?? Math.max(activeWindowBounds.y + activeWindowBounds.height / 2 - height / 2, 0),
-            width,
-            height
-        };
-        if (!options?.bounds && newWindowBounds.x === activeWindowBounds.x && newWindowBounds.y === activeWindowBounds.y) {
-            newWindowBounds = {
-                ...newWindowBounds,
-                x: newWindowBounds.x + 30,
-                y: newWindowBounds.y + 30
-            };
-        }
-        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(
-                    _moduleId,
-                    2,
-                    "The browser interrupted the opening of a new window. Press 'Retry' to try again."
-                )),
-                detail: ( localizeWithPath(
-                    _moduleId,
-                    3,
-                    "To avoid this problem in the future, please ensure to allow popups for this website."
-                )),
-                buttons: [
-                    {
-                        label: ( localizeWithPath(_moduleId, 4, "&&Retry")),
-                        run: () => this.openWindow(options)
-                    }
-                ],
-                cancelButton: true
-            })).result;
-        }
-        return auxiliaryWindow?.window;
-    }
-    async resolveWindowId(auxiliaryWindow) {
-        return BrowserAuxiliaryWindowService_1.WINDOW_IDS++;
-    }
-    createContainer(auxiliaryWindow, disposables, options) {
-        this.applyMeta(auxiliaryWindow);
-        const { stylesLoaded } = this.applyCSS(auxiliaryWindow, disposables);
-        const container = this.applyHTML(auxiliaryWindow, disposables);
-        return { stylesLoaded, container };
-    }
-    applyMeta(auxiliaryWindow) {
-        for (const metaTag of ['meta[charset="utf-8"]', 'meta[http-equiv="Content-Security-Policy"]', 'meta[name="viewport"]', 'meta[name="theme-color"]']) {
-            const metaElement = mainWindow.document.querySelector(metaTag);
-            if (metaElement) {
-                const clonedMetaElement = createMetaElement(auxiliaryWindow.document.head);
-                copyAttributes(metaElement, clonedMetaElement);
-                if (metaTag === 'meta[http-equiv="Content-Security-Policy"]') {
-                    const content = clonedMetaElement.getAttribute('content');
-                    if (content) {
-                        clonedMetaElement.setAttribute('content', content.replace(/(script-src[^\;]*)/, `script-src 'none'`));
-                    }
-                }
-            }
-        }
-        const originalIconLinkTag = mainWindow.document.querySelector('link[rel="icon"]');
-        if (originalIconLinkTag) {
-            const icon = createLinkElement(auxiliaryWindow.document.head);
-            copyAttributes(originalIconLinkTag, icon);
-        }
-    }
-    applyCSS(auxiliaryWindow, disposables) {
-        mark('code/auxiliaryWindow/willApplyCSS');
-        const mapOriginalToClone = ( (new Map()));
-        const stylesLoaded = ( (new Barrier()));
-        stylesLoaded.wait().then(() => mark('code/auxiliaryWindow/didLoadCSSStyles'));
-        const pendingLinksDisposables = disposables.add(( (new DisposableStore())));
-        let pendingLinksToSettle = 0;
-        function onLinkSettled() {
-            if (--pendingLinksToSettle === 0) {
-                pendingLinksDisposables.dispose();
-                stylesLoaded.open();
-            }
-        }
-        function cloneNode(originalNode) {
-            if (isGlobalStylesheet(originalNode)) {
-                return;
-            }
-            const clonedNode = auxiliaryWindow.document.head.appendChild(originalNode.cloneNode(true));
-            if (originalNode.tagName.toLowerCase() === 'link') {
-                pendingLinksToSettle++;
-                pendingLinksDisposables.add(addDisposableListener(clonedNode, 'load', onLinkSettled));
-                pendingLinksDisposables.add(addDisposableListener(clonedNode, 'error', onLinkSettled));
-            }
-            mapOriginalToClone.set(originalNode, clonedNode);
-        }
-        pendingLinksToSettle++;
-        try {
-            for (const originalNode of mainWindow.document.head.querySelectorAll('link[rel="stylesheet"], style')) {
-                cloneNode(originalNode);
-            }
-        }
-        finally {
-            onLinkSettled();
-        }
-        disposables.add(cloneGlobalStylesheets(auxiliaryWindow));
-        disposables.add(sharedMutationObserver.observe(mainWindow.document.head, disposables, { childList: true, subtree: true })(mutations => {
-            for (const mutation of mutations) {
-                if (mutation.type !== 'childList' ||
-                    mutation.target.nodeName.toLowerCase() === 'title' ||
-                    mutation.target.nodeName.toLowerCase() === 'script' ||
-                    mutation.target.nodeName.toLowerCase() === 'meta'
-                ) {
-                    continue;
-                }
-                for (const node of mutation.addedNodes) {
-                    if (node instanceof HTMLElement && (node.tagName.toLowerCase() === 'style' || node.tagName.toLowerCase() === 'link')) {
-                        cloneNode(node);
-                    }
-                    else if (node.nodeType === Node.TEXT_NODE && node.parentNode) {
-                        const clonedNode = mapOriginalToClone.get(node.parentNode);
-                        if (clonedNode) {
-                            clonedNode.textContent = node.textContent;
-                        }
-                    }
-                }
-                for (const node of mutation.removedNodes) {
-                    const clonedNode = mapOriginalToClone.get(node);
-                    if (clonedNode) {
-                        clonedNode.parentNode?.removeChild(clonedNode);
-                        mapOriginalToClone.delete(node);
-                    }
-                }
-            }
-        }));
-        mark('code/auxiliaryWindow/didApplyCSS');
-        return { stylesLoaded };
-    }
-    applyHTML(auxiliaryWindow, disposables) {
-        mark('code/auxiliaryWindow/willApplyHTML');
-        const container = document.createElement('div');
-        container.setAttribute('role', 'application');
-        position(container, 0, 0, 0, 0, 'relative');
-        container.style.display = 'flex';
-        container.style.height = '100%';
-        container.style.flexDirection = 'column';
-        auxiliaryWindow.document.body.append(container);
-        disposables.add(trackAttributes(mainWindow.document.documentElement, auxiliaryWindow.document.documentElement));
-        disposables.add(trackAttributes(mainWindow.document.body, auxiliaryWindow.document.body));
-        disposables.add(trackAttributes(this.layoutService.mainContainer, container, ['class']));
-        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)));
-
-export { AuxiliaryWindow, AuxiliaryWindowMode, BrowserAuxiliaryWindowService };

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

@@ -1,188 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { getTopLeftOffset, getClientArea } from 'vscode/vscode/vs/base/browser/dom';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { language, locale } from 'vscode/vscode/vs/base/common/platform';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import localizedStrings from '../../../../platform/languagePacks/common/localizedStrings.js';
-import { getLogs } from 'vscode/vscode/vs/platform/log/browser/log';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-
-let BrowserWindowDriver = class BrowserWindowDriver {
-    constructor(fileService, environmentService, lifecycleService, logService) {
-        this.fileService = fileService;
-        this.environmentService = environmentService;
-        this.lifecycleService = lifecycleService;
-        this.logService = logService;
-    }
-    async getLogs() {
-        return getLogs(this.fileService, this.environmentService);
-    }
-    async whenWorkbenchRestored() {
-        this.logService.info('[driver] Waiting for restored lifecycle phase...');
-        await this.lifecycleService.when(3 );
-        this.logService.info('[driver] Restored lifecycle phase reached. Waiting for contributions...');
-        await ( Registry.as(Extensions.Workbench)).whenRestored;
-        this.logService.info('[driver] Workbench contributions created.');
-    }
-    async setValue(selector, text) {
-        const element = mainWindow.document.querySelector(selector);
-        if (!element) {
-            return Promise.reject(( new Error(`Element not found: ${selector}`)));
-        }
-        const inputElement = element;
-        inputElement.value = text;
-        const event = ( new Event('input', { bubbles: true, cancelable: true }));
-        inputElement.dispatchEvent(event);
-    }
-    async isActiveElement(selector) {
-        const element = mainWindow.document.querySelector(selector);
-        if (element !== mainWindow.document.activeElement) {
-            const chain = [];
-            let el = mainWindow.document.activeElement;
-            while (el) {
-                const tagName = el.tagName;
-                const id = el.id ? `#${el.id}` : '';
-                const classes = ( coalesce(( el.className.split(/\s+/g).map(c => c.trim()))).map(c => `.${c}`)).join('');
-                chain.unshift(`${tagName}${id}${classes}`);
-                el = el.parentElement;
-            }
-            throw ( new Error(
-                `Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`
-            ));
-        }
-        return true;
-    }
-    async getElements(selector, recursive) {
-        const query = mainWindow.document.querySelectorAll(selector);
-        const result = [];
-        for (let i = 0; i < query.length; i++) {
-            const element = query.item(i);
-            result.push(this.serializeElement(element, recursive));
-        }
-        return result;
-    }
-    serializeElement(element, recursive) {
-        const attributes = Object.create(null);
-        for (let j = 0; j < element.attributes.length; j++) {
-            const attr = element.attributes.item(j);
-            if (attr) {
-                attributes[attr.name] = attr.value;
-            }
-        }
-        const children = [];
-        if (recursive) {
-            for (let i = 0; i < element.children.length; i++) {
-                const child = element.children.item(i);
-                if (child) {
-                    children.push(this.serializeElement(child, true));
-                }
-            }
-        }
-        const { left, top } = getTopLeftOffset(element);
-        return {
-            tagName: element.tagName,
-            className: element.className,
-            textContent: element.textContent || '',
-            attributes,
-            children,
-            left,
-            top
-        };
-    }
-    async getElementXY(selector, xoffset, yoffset) {
-        const offset = typeof xoffset === 'number' && typeof yoffset === 'number' ? { x: xoffset, y: yoffset } : undefined;
-        return this._getElementXY(selector, offset);
-    }
-    async typeInEditor(selector, text) {
-        const element = mainWindow.document.querySelector(selector);
-        if (!element) {
-            throw ( new Error(`Editor not found: ${selector}`));
-        }
-        const textarea = element;
-        const start = textarea.selectionStart;
-        const newStart = start + text.length;
-        const value = textarea.value;
-        const newValue = value.substr(0, start) + text + value.substr(start);
-        textarea.value = newValue;
-        textarea.setSelectionRange(newStart, newStart);
-        const event = ( new Event('input', { 'bubbles': true, 'cancelable': true }));
-        textarea.dispatchEvent(event);
-    }
-    async getTerminalBuffer(selector) {
-        const element = mainWindow.document.querySelector(selector);
-        if (!element) {
-            throw ( new Error(`Terminal not found: ${selector}`));
-        }
-        const xterm = element.xterm;
-        if (!xterm) {
-            throw ( new Error(`Xterm not found: ${selector}`));
-        }
-        const lines = [];
-        for (let i = 0; i < xterm.buffer.active.length; i++) {
-            lines.push(xterm.buffer.active.getLine(i).translateToString(true));
-        }
-        return lines;
-    }
-    async writeInTerminal(selector, text) {
-        const element = mainWindow.document.querySelector(selector);
-        if (!element) {
-            throw ( new Error(`Element not found: ${selector}`));
-        }
-        const xterm = element.xterm;
-        if (!xterm) {
-            throw ( new Error(`Xterm not found: ${selector}`));
-        }
-        xterm.input(text);
-    }
-    getLocaleInfo() {
-        return Promise.resolve({
-            language: language,
-            locale: locale
-        });
-    }
-    getLocalizedStrings() {
-        return Promise.resolve({
-            open: localizedStrings.open,
-            close: localizedStrings.close,
-            find: localizedStrings.find
-        });
-    }
-    async _getElementXY(selector, offset) {
-        const element = mainWindow.document.querySelector(selector);
-        if (!element) {
-            return Promise.reject(( new Error(`Element not found: ${selector}`)));
-        }
-        const { left, top } = getTopLeftOffset(element);
-        const { width, height } = getClientArea(element);
-        let x, y;
-        if (offset) {
-            x = left + offset.x;
-            y = top + offset.y;
-        }
-        else {
-            x = left + (width / 2);
-            y = top + (height / 2);
-        }
-        x = Math.round(x);
-        y = Math.round(y);
-        return { x, y };
-    }
-    async exitApplication() {
-    }
-};
-BrowserWindowDriver = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IEnvironmentService)),
-    ( __param(2, ILifecycleService)),
-    ( __param(3, ILogService))
-], BrowserWindowDriver));
-function registerWindowDriver(instantiationService) {
-    Object.assign(mainWindow, { driver: instantiationService.createInstance(BrowserWindowDriver) });
-}
-
-export { BrowserWindowDriver, registerWindowDriver };