@codingame/monaco-vscode-api 5.3.0 → 6.0.0

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

@@ -0,0 +1,370 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { mark } from '../../../../base/common/performance.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { getWindowId, registerWindow, getActiveWindow, createMetaElement, copyAttributes, createLinkElement, cloneGlobalStylesheets, sharedMutationObserver, isHTMLElement, position, trackAttributes, addDisposableListener, EventType, EventHelper, ModifierKeyEmitter, getClientArea, isGlobalStylesheet } from '../../../../base/browser/dom.js';
+import { mainWindow, ensureCodeWindow } from '../../../../base/browser/window.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../platform/instantiation/common/extensions.js';
+import { IWorkbenchLayoutService } from '../../layout/browser/layoutService.service.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { isFirefox, isWeb } from '../../../../base/common/platform.js';
+import { WindowMinimumSize } from '../../../../platform/window/common/window.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { BaseWindow } from '../../../browser/window.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { Barrier } from '../../../../base/common/async.js';
+import { IHostService } from '../../host/browser/host.service.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.service.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { getZoomLevel } from '../../../../base/browser/browser.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+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(isFirefox ? ''  : '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 (isHTMLElement(node) && (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/configuration/common/configuration.js

@@ -1,3 +1,4 @@
+import { ConfigurationScope } from '../../../../platform/configuration/common/configurationRegistry.js';
 const FOLDER_CONFIG_FOLDER_NAME = '.vscode';
 const FOLDER_SETTINGS_NAME = 'settings';
 const FOLDER_SETTINGS_PATH = `${FOLDER_CONFIG_FOLDER_NAME}/${FOLDER_SETTINGS_NAME}.json`;
@@ -9,13 +10,13 @@ const workspaceSettingsSchemaId = 'vscode://schemas/settings/workspace';
 const folderSettingsSchemaId = 'vscode://schemas/settings/folder';
 const launchSchemaId = 'vscode://schemas/launch';
 const tasksSchemaId = 'vscode://schemas/tasks';
-const APPLICATION_SCOPES = [1 ];
-const PROFILE_SCOPES = [2 , 3 , 4 , 5 , 6 ];
-const LOCAL_MACHINE_PROFILE_SCOPES = [3 , 4 , 5 ];
-const LOCAL_MACHINE_SCOPES = [1 , ...LOCAL_MACHINE_PROFILE_SCOPES];
-const REMOTE_MACHINE_SCOPES = [2 , 3 , 4 , 5 , 6 ];
-const WORKSPACE_SCOPES = [3 , 4 , 5 , 6 ];
-const FOLDER_SCOPES = [4 , 5 , 6 ];
+const APPLICATION_SCOPES = [ConfigurationScope.APPLICATION];
+const PROFILE_SCOPES = [ConfigurationScope.MACHINE, ConfigurationScope.WINDOW, ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE, ConfigurationScope.MACHINE_OVERRIDABLE];
+const LOCAL_MACHINE_PROFILE_SCOPES = [ConfigurationScope.WINDOW, ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE];
+const LOCAL_MACHINE_SCOPES = [ConfigurationScope.APPLICATION, ...LOCAL_MACHINE_PROFILE_SCOPES];
+const REMOTE_MACHINE_SCOPES = [ConfigurationScope.MACHINE, ConfigurationScope.WINDOW, ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE, ConfigurationScope.MACHINE_OVERRIDABLE];
+const WORKSPACE_SCOPES = [ConfigurationScope.WINDOW, ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE, ConfigurationScope.MACHINE_OVERRIDABLE];
+const FOLDER_SCOPES = [ConfigurationScope.RESOURCE, ConfigurationScope.LANGUAGE_OVERRIDABLE, ConfigurationScope.MACHINE_OVERRIDABLE];
 const TASKS_CONFIGURATION_KEY = 'tasks';
 const LAUNCH_CONFIGURATION_KEY = 'launch';
 const WORKSPACE_STANDALONE_CONFIGURATIONS = Object.create(null);

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

@@ -0,0 +1,187 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getTopLeftOffset, getClientArea } from '../../../../base/browser/dom.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { language, locale } from '../../../../base/common/platform.js';
+import { IEnvironmentService } from '../../../../platform/environment/common/environment.service.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import localizedStrings from '../../../../platform/languagePacks/common/localizedStrings.js';
+import { getLogs } from '../../../../platform/log/browser/log.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { LifecyclePhase } from '../../lifecycle/common/lifecycle.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.service.js';
+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(LifecyclePhase.Restored);
+        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 };

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

@@ -1,10 +1,12 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { isCodeEditor, isDiffEditor, isCompositeEditor, getCodeEditor } from '../../../../editor/browser/editorBrowser.js';
 import { AbstractCodeEditorService } from '../../../../editor/browser/services/abstractCodeEditorService.js';
+import { ScrollType } from '../../../../editor/common/editorCommon.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { SIDE_GROUP, ACTIVE_GROUP } from '../common/editorService.js';
 import { IEditorService } from '../common/editorService.service.js';
 import '../../../../platform/instantiation/common/instantiation.js';
+import '../../../../platform/instantiation/common/extensions.js';
 import { isEqual } from '../../../../base/common/resources.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
@@ -41,7 +43,7 @@ let CodeEditorService = class CodeEditorService extends AbstractCodeEditorServic
             isEqual(input.resource, activeTextEditorControl.getModel()?.modified.uri)
         ) {
             const targetEditor = activeTextEditorControl.getModifiedEditor();
-            applyTextEditorOptions(input.options, targetEditor, 0 );
+            applyTextEditorOptions(input.options, targetEditor, ScrollType.Smooth);
             return targetEditor;
         }
         return null;