@codingame/monaco-vscode-extensions-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { ExtHostContext, CandidatePortSource, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { TunnelDtoConverter } from 'vscode/vscode/vs/workbench/api/common/extHostTunnelService';
@@ -17,7 +18,7 @@ import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { TunnelSource, TunnelCloseReason, makeAddress, forwardedPortsFeaturesEnabled } from 'vscode/vscode/vs/workbench/services/remote/common/tunnelModel';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     constructor(extHostContext, remoteExplorerService, tunnelService, notificationService, configurationService, logService, remoteAgentService, contextKeyService) {
@@ -30,9 +31,9 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         this.remoteAgentService = remoteAgentService;
         this.contextKeyService = contextKeyService;
         this.elevateionRetry = false;
-        this.portsAttributesProviders = ( (new Map()));
+        this.portsAttributesProviders = ( new Map());
         this._alreadyRegistered = false;
-        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostTunnelService)));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTunnelService));
         this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
         this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
     }
@@ -73,13 +74,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         if (this.portsAttributesProviders.size === 0) {
             return [];
         }
-        const appropriateHandles = ( (Array.from(this.portsAttributesProviders.entries()).filter(entry => {
+        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
             const selector = entry[1];
             const portRange = (typeof selector.portRange === 'number') ? [selector.portRange, selector.portRange + 1] : selector.portRange;
-            const portInRange = portRange ? ( (ports.some(port => portRange[0] <= port && port < portRange[1]))) : true;
+            const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
             const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
             return portInRange && commandMatches;
-        }).map(entry => entry[0])));
+        }).map(entry => entry[0]));
         if (appropriateHandles.length === 0) {
             return [];
         }
@@ -110,14 +111,14 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return TunnelDtoConverter.fromServiceTunnel(tunnel);
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
-        return this.notificationService.prompt(Severity$1.Info, ( localize(
-            4556,
+        return this.notificationService.prompt(Severity.Info, ( localize(
+            2300,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-                label: ( localize(4557, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
+                label: ( localize(2301, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
                 run: async () => {
                     this.elevateionRetry = true;
                     await this.remoteExplorerService.close({ host: tunnel.tunnelRemoteHost, port: tunnel.tunnelRemotePort }, TunnelCloseReason.Other);
@@ -139,16 +140,14 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
     }
     async $getTunnels() {
-        return (
-             ((await this.tunnelService.tunnels).map(tunnel => {
-                return {
-                    remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
-                    localAddress: tunnel.localAddress,
-                    privacy: tunnel.privacy,
-                    protocol: tunnel.protocol
-                };
-            }))
-        );
+        return ( (await this.tunnelService.tunnels).map(tunnel => {
+            return {
+                remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+                localAddress: tunnel.localAddress,
+                privacy: tunnel.privacy,
+                protocol: tunnel.protocol
+            };
+        }));
     }
     async $onFoundNewCandidates(candidates) {
         this.remoteExplorerService.onFoundNewCandidates(candidates);
@@ -199,17 +198,17 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         this.remoteAgentService.getEnvironment().then(() => {
             switch (source) {
                 case CandidatePortSource.None: {
-                    ( (Registry.as(Extensions.Configuration)))
+                    ( Registry.as(Extensions.Configuration))
                         .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPorts': false } }]);
                     break;
                 }
                 case CandidatePortSource.Output: {
-                    ( (Registry.as(Extensions.Configuration)))
+                    ( Registry.as(Extensions.Configuration))
                         .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_OUTPUT } }]);
                     break;
                 }
                 case CandidatePortSource.Hybrid: {
-                    ( (Registry.as(Extensions.Configuration)))
+                    ( Registry.as(Extensions.Configuration))
                         .registerDefaultConfigurations([{ overrides: { 'remote.autoForwardPortsSource': PORT_AUTO_SOURCE_SETTING_HYBRID } }]);
                     break;
                 }
@@ -220,13 +219,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
 };
 MainThreadTunnelService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadTunnelService),
-    ( (__param(1, IRemoteExplorerService))),
-    ( (__param(2, ITunnelService))),
-    ( (__param(3, INotificationService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, ILogService))),
-    ( (__param(6, IRemoteAgentService))),
-    ( (__param(7, IContextKeyService)))
+    ( __param(1, IRemoteExplorerService)),
+    ( __param(2, ITunnelService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IRemoteAgentService)),
+    ( __param(7, IContextKeyService))
 ], MainThreadTunnelService);
 
 export { MainThreadTunnelService };

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.d.ts

@@ -0,0 +1,25 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { INotificationService } from "vscode/vscode/vs/platform/notification/common/notification.service";
+import { IOpenerService } from "vscode/vscode/vs/platform/opener/common/opener.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { MainThreadUriOpenersShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExternalOpenerProvider, IExternalUriOpener } from "@codingame/monaco-vscode-1b4486de-4fe4-59c4-9e6d-34f265ff6625-common/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService";
+import { IExternalUriOpenerService } from "vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadUriOpeners extends Disposable implements MainThreadUriOpenersShape, IExternalOpenerProvider {
+    private readonly extensionService;
+    private readonly openerService;
+    private readonly notificationService;
+    private readonly proxy;
+    private readonly _registeredOpeners;
+    private readonly _contributedExternalUriOpenersStore;
+    constructor(context: IExtHostContext, storageService: IStorageService, externalUriOpenerService: IExternalUriOpenerService, extensionService: IExtensionService, openerService: IOpenerService, notificationService: INotificationService);
+    getOpeners(targetUri: URI): AsyncIterable<IExternalUriOpener>;
+    private createOpener;
+    $registerUriOpener(id: string, schemes: readonly string[], extensionId: ExtensionIdentifier, label: string): Promise<void>;
+    $unregisterUriOpener(id: string): Promise<void>;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Action } from 'vscode/vscode/vs/base/common/actions';
 import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -9,12 +10,12 @@ import { INotificationService } from 'vscode/vscode/vs/platform/notification/com
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { defaultExternalUriOpenerId } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import { defaultExternalUriOpenerId } from '@codingame/monaco-vscode-2a94c04a-b85b-5669-b06b-89c1bfa11cb9-common/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
 import { ContributedExternalUriOpenersStore } from '../../contrib/externalUriOpener/common/contributedOpeners.js';
 import { IExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 
 let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
     constructor(context, storageService, externalUriOpenerService, extensionService, openerService, notificationService) {
@@ -22,10 +23,10 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         this.extensionService = extensionService;
         this.openerService = openerService;
         this.notificationService = notificationService;
-        this._registeredOpeners = ( (new Map()));
-        this.proxy = ( (context.getProxy(ExtHostContext.ExtHostUriOpeners)));
+        this._registeredOpeners = ( new Map());
+        this.proxy = ( context.getProxy(ExtHostContext.ExtHostUriOpeners));
         this._register(externalUriOpenerService.registerExternalOpenerProvider(this));
-        this._contributedExternalUriOpenersStore = this._register(( (new ContributedExternalUriOpenersStore(storageService, extensionService))));
+        this._contributedExternalUriOpenersStore = this._register(( new ContributedExternalUriOpenersStore(storageService, extensionService)));
     }
     async *getOpeners(targetUri) {
         if (targetUri.scheme !== Schemas.http && targetUri.scheme !== Schemas.https) {
@@ -33,7 +34,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         }
         await this.extensionService.activateByEvent(`onOpenExternalUri:${targetUri.scheme}`);
         for (const [id, openerMetadata] of this._registeredOpeners) {
-            if (( (openerMetadata.schemes.has(targetUri.scheme)))) {
+            if (( openerMetadata.schemes.has(targetUri.scheme))) {
                 yield this.createOpener(id, openerMetadata);
             }
         }
@@ -51,21 +52,16 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                 }
                 catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( (new Action('default', ( localize(4546, "Open using default opener")), undefined, undefined, async () => {
+                        const openDefaultAction = ( new Action('default', ( localize(2302, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
                                 allowContributedOpeners: defaultExternalUriOpenerId,
                             });
-                        })));
-                        openDefaultAction.tooltip = ( (uri.toString()));
+                        }));
+                        openDefaultAction.tooltip = ( uri.toString());
                         this.notificationService.notify({
-                            severity: Severity$1.Error,
-                            message: ( localize(
-                                4547,
-                                'Could not open uri with \'{0}\': {1}',
-                                id,
-                                 (e.toString())
-                            )),
+                            severity: Severity.Error,
+                            message: ( localize(2303, 'Could not open uri with \'{0}\': {1}', id, (e.toString()))),
                             actions: {
                                 primary: [
                                     openDefaultAction
@@ -79,11 +75,11 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
         };
     }
     async $registerUriOpener(id, schemes, extensionId, label) {
-        if (( (this._registeredOpeners.has(id)))) {
-            throw ( (new Error(`Opener with id '${id}' already registered`)));
+        if (( this._registeredOpeners.has(id))) {
+            throw ( new Error(`Opener with id '${id}' already registered`));
         }
         this._registeredOpeners.set(id, {
-            schemes: ( (new Set(schemes))),
+            schemes: ( new Set(schemes)),
             label,
             extensionId,
         });
@@ -100,11 +96,11 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
 };
 MainThreadUriOpeners = __decorate([
     extHostNamedCustomer(MainContext.MainThreadUriOpeners),
-    ( (__param(1, IStorageService))),
-    ( (__param(2, IExternalUriOpenerService))),
-    ( (__param(3, IExtensionService))),
-    ( (__param(4, IOpenerService))),
-    ( (__param(5, INotificationService)))
+    ( __param(1, IStorageService)),
+    ( __param(2, IExternalUriOpenerService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, INotificationService))
 ], MainThreadUriOpeners);
 
 export { MainThreadUriOpeners };

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.d.ts

@@ -0,0 +1,17 @@
+import { MainThreadUrlsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IURLService } from "vscode/vscode/vs/platform/url/common/url.service";
+import { URI, UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IExtensionUrlHandler } from "vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler.service";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+export declare class MainThreadUrls implements MainThreadUrlsShape {
+    private readonly urlService;
+    private readonly extensionUrlHandler;
+    private readonly proxy;
+    private handlers;
+    constructor(context: IExtHostContext, urlService: IURLService, extensionUrlHandler: IExtensionUrlHandler);
+    $registerUriHandler(handle: number, extensionId: ExtensionIdentifier, extensionDisplayName: string): Promise<void>;
+    $unregisterUriHandler(handle: number): Promise<void>;
+    $createAppUri(uri: UriComponents): Promise<URI>;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadUrls.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IURLService } from 'vscode/vscode/vs/platform/url/common/url.service';

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewManager.d.ts

@@ -0,0 +1,6 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadWebviewManager extends Disposable {
+    constructor(context: IExtHostContext, instantiationService: IInstantiationService);
+}

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewManager.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { MainThreadCustomEditors } from './mainThreadCustomEditors.js';

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.d.ts

@@ -0,0 +1,42 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { MainThreadWebviews } from "./mainThreadWebviews.js";
+import * as extHostProtocol from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { WebviewInput } from "@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput";
+import { IWebviewWorkbenchService } from "vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service";
+import { IEditorGroupsService } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadWebviewPanels extends Disposable implements extHostProtocol.MainThreadWebviewPanelsShape {
+    private readonly _mainThreadWebviews;
+    private readonly _configurationService;
+    private readonly _editorGroupService;
+    private readonly _editorService;
+    private readonly _telemetryService;
+    private readonly _webviewWorkbenchService;
+    private readonly webviewPanelViewType;
+    private readonly _proxy;
+    private readonly _webviewInputs;
+    private readonly _revivers;
+    private readonly webviewOriginStore;
+    constructor(context: IExtHostContext, _mainThreadWebviews: MainThreadWebviews, _configurationService: IConfigurationService, _editorGroupService: IEditorGroupsService, _editorService: IEditorService, extensionService: IExtensionService, storageService: IStorageService, _telemetryService: ITelemetryService, _webviewWorkbenchService: IWebviewWorkbenchService);
+    get webviewInputs(): Iterable<WebviewInput>;
+    addWebviewInput(handle: extHostProtocol.WebviewHandle, input: WebviewInput, options: {
+        serializeBuffersForPostMessage: boolean;
+    }): void;
+    $createWebviewPanel(extensionData: extHostProtocol.WebviewExtensionDescription, handle: extHostProtocol.WebviewHandle, viewType: string, initData: extHostProtocol.IWebviewInitData, showOptions: extHostProtocol.WebviewPanelShowOptions): void;
+    $disposeWebview(handle: extHostProtocol.WebviewHandle): void;
+    $setTitle(handle: extHostProtocol.WebviewHandle, value: string): void;
+    $setIconPath(handle: extHostProtocol.WebviewHandle, value: extHostProtocol.IWebviewIconPath | undefined): void;
+    $reveal(handle: extHostProtocol.WebviewHandle, showOptions: extHostProtocol.WebviewPanelShowOptions): void;
+    private getTargetGroupFromShowOptions;
+    $registerSerializer(viewType: string, options: {
+        serializeBuffersForPostMessage: boolean;
+    }): void;
+    $unregisterSerializer(viewType: string): void;
+    private updateWebviewViewStates;
+    private tryGetWebviewInput;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewPanels.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -9,12 +10,12 @@ import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storag
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { reviveWebviewExtension, reviveWebviewContentOptions } from './mainThreadWebviews.js';
 import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
-import { ExtensionKeyedWebviewOriginStore } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
-import { WebviewInput } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
+import { DiffEditorInput } from '@codingame/monaco-vscode-5108c2c9-4ada-52d8-8c4b-fe03b3160e71-common/vscode/vs/workbench/common/editor/diffEditorInput';
+import { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/vscode/vs/workbench/contrib/webview/browser/webview';
+import { WebviewInput } from '@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
 import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
-import { editorGroupToColumn } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupColumn';
-import { preferredSideBySideGroupDirection } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { editorGroupToColumn } from '@codingame/monaco-vscode-f48982c4-9e82-55e2-b800-20e6d1e6096f-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { GroupsOrder, GroupLocation, preferredSideBySideGroupDirection } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { ACTIVE_GROUP, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -160,11 +161,11 @@ let MainThreadWebviewPanels = class MainThreadWebviewPanels extends Disposable {
             return SIDE_GROUP;
         }
         if (showOptions.viewColumn >= 0) {
-            const groupInColumn = this._editorGroupService.getGroups(2 )[showOptions.viewColumn];
+            const groupInColumn = this._editorGroupService.getGroups(GroupsOrder.GRID_APPEARANCE)[showOptions.viewColumn];
             if (groupInColumn) {
                 return groupInColumn.id;
             }
-            const newGroup = this._editorGroupService.findGroup({ location: 1  });
+            const newGroup = this._editorGroupService.findGroup({ location: GroupLocation.LAST });
             if (newGroup) {
                 const direction = preferredSideBySideGroupDirection(this._configurationService);
                 return this._editorGroupService.addGroup(newGroup, direction);

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewViews.d.ts

@@ -0,0 +1,26 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { MainThreadWebviews } from "./mainThreadWebviews.js";
+import * as extHostProtocol from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IViewBadge } from "vscode/vscode/vs/workbench/common/views";
+import { IWebviewViewService } from "vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadWebviewsViews extends Disposable implements extHostProtocol.MainThreadWebviewViewsShape {
+    private readonly mainThreadWebviews;
+    private readonly _telemetryService;
+    private readonly _webviewViewService;
+    private readonly _proxy;
+    private readonly _webviewViews;
+    private readonly _webviewViewProviders;
+    constructor(context: IExtHostContext, mainThreadWebviews: MainThreadWebviews, _telemetryService: ITelemetryService, _webviewViewService: IWebviewViewService);
+    $setWebviewViewTitle(handle: extHostProtocol.WebviewHandle, value: string | undefined): void;
+    $setWebviewViewDescription(handle: extHostProtocol.WebviewHandle, value: string | undefined): void;
+    $setWebviewViewBadge(handle: string, badge: IViewBadge | undefined): void;
+    $show(handle: extHostProtocol.WebviewHandle, preserveFocus: boolean): void;
+    $registerWebviewViewProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: {
+        retainContextWhenHidden?: boolean;
+        serializeBuffersForPostMessage: boolean;
+    }): void;
+    $unregisterWebviewViewProvider(viewType: string): void;
+    private getWebviewView;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadWebviewViews.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
 import { Disposable, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.d.ts

@@ -0,0 +1,29 @@
+import { VSBuffer } from "vscode/vscode/vs/base/common/buffer";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IOpenerService } from "vscode/vscode/vs/platform/opener/common/opener.service";
+import { IProductService } from "vscode/vscode/vs/platform/product/common/productService.service";
+import * as extHostProtocol from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IOverlayWebview, WebviewContentOptions, WebviewExtensionDescription } from "@codingame/monaco-vscode-22790577-4553-50b6-978d-0acc75c394cc-common/vscode/vs/workbench/contrib/webview/browser/webview";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadWebviews extends Disposable implements extHostProtocol.MainThreadWebviewsShape {
+    private readonly _openerService;
+    private readonly _productService;
+    private static readonly standardSupportedLinkSchemes;
+    private readonly _proxy;
+    private readonly _webviews;
+    constructor(context: IExtHostContext, _openerService: IOpenerService, _productService: IProductService);
+    addWebview(handle: extHostProtocol.WebviewHandle, webview: IOverlayWebview, options: {
+        serializeBuffersForPostMessage: boolean;
+    }): void;
+    $setHtml(handle: extHostProtocol.WebviewHandle, value: string): void;
+    $setOptions(handle: extHostProtocol.WebviewHandle, options: extHostProtocol.IWebviewContentOptions): void;
+    $postMessage(handle: extHostProtocol.WebviewHandle, jsonMessage: string, ...buffers: VSBuffer[]): Promise<boolean>;
+    private hookupWebviewEventDelegate;
+    private onDidClickLink;
+    private isSupportedLink;
+    private tryGetWebview;
+    private getWebview;
+    getWebviewResolvedFailedContent(viewType: string): string;
+}
+export declare function reviveWebviewExtension(extensionData: extHostProtocol.WebviewExtensionDescription): WebviewExtensionDescription;
+export declare function reviveWebviewContentOptions(webviewOptions: extHostProtocol.IWebviewContentOptions): WebviewContentOptions;

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { isWeb } from 'vscode/vscode/vs/base/common/platform';
@@ -14,23 +15,23 @@ import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/servic
 var MainThreadWebviews_1;
 let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( (new Set([
+    static { this.standardSupportedLinkSchemes = ( new Set([
         Schemas.http,
         Schemas.https,
         Schemas.mailto,
         Schemas.vscode,
         'vscode-insider',
-    ]))); }
+    ])); }
     constructor(context, _openerService, _productService) {
         super();
         this._openerService = _openerService;
         this._productService = _productService;
-        this._webviews = ( (new Map()));
-        this._proxy = ( (context.getProxy(ExtHostContext.ExtHostWebviews)));
+        this._webviews = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
     }
     addWebview(handle, webview, options) {
-        if (( (this._webviews.has(handle)))) {
-            throw ( (new Error('Webview already registered')));
+        if (( this._webviews.has(handle))) {
+            throw ( new Error('Webview already registered'));
         }
         this._webviews.set(handle, webview);
         this.hookupWebviewEventDelegate(handle, webview, options);
@@ -53,11 +54,11 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
         return webview.postMessage(message, arrayBuffers);
     }
     hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
         disposables.add(webview.onMessage((message) => {
             const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( (new SerializableObjectWithBuffers(serialized.buffers))));
+            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
         }));
         disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
         disposables.add(webview.onDidDispose(() => {
@@ -67,12 +68,12 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     }
     onDidClickLink(handle, link) {
         const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( (URI.parse(link))))) {
+        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
             this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
         }
     }
     isSupportedLink(webview, link) {
-        if (( (MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme)))) {
+        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
             return true;
         }
         if (!isWeb && this._productService.urlProtocol === link.scheme) {
@@ -92,7 +93,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     getWebview(handle) {
         const webview = this.tryGetWebview(handle);
         if (!webview) {
-            throw ( (new Error(`Unknown webview handle:${handle}`)));
+            throw ( new Error(`Unknown webview handle:${handle}`));
         }
         return webview;
     }
@@ -103,14 +104,14 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
 				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
 			</head>
-			<body>${( localize(9984, "An error occurred while loading view: {0}", escape(viewType)))}</body>
+			<body>${( localize(2304, "An error occurred while loading view: {0}", escape(viewType)))}</body>
 		</html>`;
     }
 };
-MainThreadWebviews = MainThreadWebviews_1 = ( (__decorate([
-    ( (__param(1, IOpenerService))),
-    ( (__param(2, IProductService)))
-], MainThreadWebviews)));
+MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
+    ( __param(1, IOpenerService)),
+    ( __param(2, IProductService))
+], MainThreadWebviews));
 function reviveWebviewExtension(extensionData) {
     return {
         id: extensionData.id,
@@ -122,7 +123,7 @@ function reviveWebviewContentOptions(webviewOptions) {
         allowScripts: webviewOptions.enableScripts,
         allowForms: webviewOptions.enableForms,
         enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( (webviewOptions.localResourceRoots.map(r => URI.revive(r)))) : undefined,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
         portMapping: webviewOptions.portMapping,
     };
 }

package/vscode/src/vs/workbench/api/browser/mainThreadWindow.d.ts

@@ -0,0 +1,22 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IOpenerService } from "vscode/vscode/vs/platform/opener/common/opener.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IOpenUriOptions, MainThreadWindowShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IHostService } from "vscode/vscode/vs/workbench/services/host/browser/host.service";
+import { IUserActivityService } from "vscode/vscode/vs/workbench/services/userActivity/common/userActivityService.service";
+export declare class MainThreadWindow implements MainThreadWindowShape {
+    private readonly hostService;
+    private readonly openerService;
+    private readonly userActivityService;
+    private readonly proxy;
+    private readonly disposables;
+    constructor(extHostContext: IExtHostContext, hostService: IHostService, openerService: IOpenerService, userActivityService: IUserActivityService);
+    dispose(): void;
+    registerNativeHandle(): void;
+    $getInitialState(): Promise<{
+        isFocused: boolean;
+        isActive: boolean;
+    }>;
+    $openUri(uriComponents: UriComponents, uriString: string | undefined, options: IOpenUriOptions): Promise<boolean>;
+    $asExternalUri(uriComponents: UriComponents, options: IOpenUriOptions): Promise<UriComponents>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadWindow.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -7,6 +8,7 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService.service';
+import { encodeBase64 } from 'vscode/vscode/vs/base/common/buffer';
 
 let MainThreadWindow = class MainThreadWindow {
     constructor(extHostContext, hostService, openerService, userActivityService) {
@@ -17,10 +19,17 @@ let MainThreadWindow = class MainThreadWindow {
         this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
         Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
         userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
+        this.registerNativeHandle();
     }
     dispose() {
         this.disposables.dispose();
     }
+    registerNativeHandle() {
+        Event.latch(this.hostService.onDidChangeActiveWindow)(async (windowId) => {
+            const handle = await this.hostService.getNativeWindowHandle(windowId);
+            this.proxy.$onDidChangeActiveNativeWindowHandle(handle ? encodeBase64(handle) : undefined);
+        }, this, this.disposables);
+    }
     $getInitialState() {
         return Promise.resolve({
             isFocused: this.hostService.hasFocus,