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

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

@@ -1,19 +1,22 @@
-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 { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { transformErrorFromSerialization } from 'vscode/vscode/vs/base/common/errors';
 import { FileAccess } from 'vscode/vscode/vs/base/common/network';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localize } from 'vscode/vscode/vs/nls';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
-import { WebSocketRemoteConnection, ManagedRemoteConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { RemoteConnectionType, WebSocketRemoteConnection, ManagedRemoteConnection } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { EnablementState } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
 import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement.service';
+import { ExtensionHostKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
@@ -32,10 +35,8 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         this._extensionHostKind = extHostContext.extensionHostKind;
         const internalExtHostContext = extHostContext;
         this._internalExtensionService = internalExtHostContext.internalExtensionService;
-        internalExtHostContext._setExtensionHostProxy(( (new ExtensionHostProxy(
-             (extHostContext.getProxy(ExtHostContext.ExtHostExtensionService))
-        ))));
-        internalExtHostContext._setAllMainProxyIdentifiers(( (( (Object.keys(MainContext))).map((key) => MainContext[key]))));
+        internalExtHostContext._setExtensionHostProxy(( new ExtensionHostProxy(( extHostContext.getProxy(ExtHostContext.ExtHostExtensionService)))));
+        internalExtHostContext._setAllMainProxyIdentifiers(( ( Object.keys(MainContext)).map((key) => MainContext[key])));
     }
     dispose() {
     }
@@ -86,65 +87,65 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         const extName = extension.displayName || extension.name;
         if (this._extensionEnablementService.isEnabled(missingInstalledDependency)) {
             this._notificationService.notify({
-                severity: Severity$1.Error,
+                severity: Severity.Error,
                 message: ( localize(
-                    4907,
+                    2259,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                 )),
                 actions: {
-                    primary: [( (new Action('reload', ( localize(4908, "Reload Window")), '', true, () => this._hostService.reload())))]
+                    primary: [( new Action('reload', ( localize(2260, "Reload Window")), '', true, () => this._hostService.reload()))]
                 }
             });
         }
         else {
             const enablementState = this._extensionEnablementService.getEnablementState(missingInstalledDependency);
-            if (enablementState === 4 ) {
+            if (enablementState === EnablementState.DisabledByVirtualWorkspace) {
                 this._notificationService.notify({
-                    severity: Severity$1.Error,
+                    severity: Severity.Error,
                     message: ( localize(
-                        4909,
+                        2261,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                 });
             }
-            else if (enablementState === 0 ) {
+            else if (enablementState === EnablementState.DisabledByTrustRequirement) {
                 this._notificationService.notify({
-                    severity: Severity$1.Error,
+                    severity: Severity.Error,
                     message: ( localize(
-                        4910,
+                        2262,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( (new Action('manageWorkspaceTrust', ( localize(4911, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage'))))]
+                        primary: [( new Action('manageWorkspaceTrust', ( localize(2263, "Manage Workspace Trust")), '', true, () => this._commandService.executeCommand('workbench.trust.manage')))]
                     }
                 });
             }
             else if (this._extensionEnablementService.canChangeEnablement(missingInstalledDependency)) {
                 this._notificationService.notify({
-                    severity: Severity$1.Error,
+                    severity: Severity.Error,
                     message: ( localize(
-                        4912,
+                        2264,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
                     )),
                     actions: {
-                        primary: [( (new Action('enable', ( localize(4913, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === 7  ? 9  : 10 )
-                                .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
+                        primary: [( new Action('enable', ( localize(2265, "Enable and Reload")), '', true, () => this._extensionEnablementService.setEnablement([missingInstalledDependency], enablementState === EnablementState.DisabledGlobally ? EnablementState.EnabledGlobally : EnablementState.EnabledWorkspace)
+                                .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
                     }
                 });
             }
             else {
                 this._notificationService.notify({
-                    severity: Severity$1.Error,
+                    severity: Severity.Error,
                     message: ( localize(
-                        4914,
+                        2266,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -163,23 +164,23 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         }
         if (dependencyExtension) {
             this._notificationService.notify({
-                severity: Severity$1.Error,
+                severity: Severity.Error,
                 message: ( localize(
-                    4915,
+                    2267,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
                     dependencyExtension.publisherDisplayName
                 )),
                 actions: {
-                    primary: [( (new Action('install', ( localize(4916, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
-                            .then(() => this._hostService.reload(), e => this._notificationService.error(e)))))]
+                    primary: [( new Action('install', ( localize(2268, "Install and Reload")), '', true, () => this._extensionsWorkbenchService.install(dependencyExtension)
+                            .then(() => this._hostService.reload(), e => this._notificationService.error(e))))]
                 }
             });
         }
         else {
             this._notificationService.error(( localize(
-                4917,
+                2269,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency
@@ -187,10 +188,10 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         }
     }
     async $setPerformanceMarks(marks) {
-        if (this._extensionHostKind === 1 ) {
+        if (this._extensionHostKind === ExtensionHostKind.LocalProcess) {
             this._timerService.setPerformanceMarks('localExtHost', marks);
         }
-        else if (this._extensionHostKind === 2 ) {
+        else if (this._extensionHostKind === ExtensionHostKind.LocalWebWorker) {
             this._timerService.setPerformanceMarks('workerExtHost', marks);
         }
         else {
@@ -209,14 +210,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
 };
 MainThreadExtensionService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadExtensionService),
-    ( (__param(1, IExtensionService))),
-    ( (__param(2, INotificationService))),
-    ( (__param(3, IExtensionsWorkbenchService))),
-    ( (__param(4, IHostService))),
-    ( (__param(5, IWorkbenchExtensionEnablementService))),
-    ( (__param(6, ITimerService))),
-    ( (__param(7, ICommandService))),
-    ( (__param(8, IWorkbenchEnvironmentService)))
+    ( __param(1, IExtensionService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IExtensionsWorkbenchService)),
+    ( __param(4, IHostService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, ITimerService)),
+    ( __param(7, ICommandService)),
+    ( __param(8, IWorkbenchEnvironmentService))
 ], MainThreadExtensionService);
 class ExtensionHostProxy {
     constructor(_actual) {
@@ -282,14 +283,10 @@ function reviveResolvedAuthority(resolvedAuthority) {
     };
 }
 function reviveConnection(connection) {
-    if (connection.type === 0 ) {
-        return (
-             (new WebSocketRemoteConnection(connection.host, connection.port))
-        );
+    if (connection.type === RemoteConnectionType.WebSocket) {
+        return ( new WebSocketRemoteConnection(connection.host, connection.port));
     }
-    return (
-         (new ManagedRemoteConnection(connection.id))
-    );
+    return ( new ManagedRemoteConnection(connection.id));
 }
 
 export { MainThreadExtensionService };

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

@@ -0,0 +1,32 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, IStat, FileType, IFileOverwriteOptions, IFileDeleteOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IFileChangeDto, MainThreadFileSystemShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { VSBuffer } from "vscode/vscode/vs/base/common/buffer";
+import { IMarkdownString } from "vscode/vscode/vs/base/common/htmlContent";
+export declare class MainThreadFileSystem implements MainThreadFileSystemShape {
+    private readonly _fileService;
+    private readonly _proxy;
+    private readonly _fileProvider;
+    private readonly _disposables;
+    constructor(extHostContext: IExtHostContext, _fileService: IFileService);
+    dispose(): void;
+    $registerFileSystemProvider(handle: number, scheme: string, capabilities: FileSystemProviderCapabilities, readonlyMessage?: IMarkdownString): Promise<void>;
+    $unregisterProvider(handle: number): void;
+    $onFileSystemChange(handle: number, changes: IFileChangeDto[]): void;
+    $stat(uri: UriComponents): Promise<IStat>;
+    $readdir(uri: UriComponents): Promise<[
+        string,
+        FileType
+    ][]>;
+    private static _asFileType;
+    $readFile(uri: UriComponents): Promise<VSBuffer>;
+    $writeFile(uri: UriComponents, content: VSBuffer): Promise<void>;
+    $rename(source: UriComponents, target: UriComponents, opts: IFileOverwriteOptions): Promise<void>;
+    $copy(source: UriComponents, target: UriComponents, opts: IFileOverwriteOptions): Promise<void>;
+    $mkdir(uri: UriComponents): Promise<void>;
+    $delete(uri: UriComponents, opts: IFileDeleteOptions): Promise<void>;
+    private static _handleError;
+    $ensureActivation(scheme: string): Promise<void>;
+}

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

@@ -1,8 +1,9 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { DisposableMap, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, toFileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
+import { FilePermission, FileSystemProviderErrorCode, FileType, FileOperationError, FileOperationResult, toFileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -105,16 +106,16 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
     static _handleError(err) {
         if (err instanceof FileOperationError) {
             switch (err.fileOperationResult) {
-                case 1 :
+                case FileOperationResult.FILE_NOT_FOUND:
                     err.name = FileSystemProviderErrorCode.FileNotFound;
                     break;
-                case 0 :
+                case FileOperationResult.FILE_IS_DIRECTORY:
                     err.name = FileSystemProviderErrorCode.FileIsADirectory;
                     break;
-                case 6 :
+                case FileOperationResult.FILE_PERMISSION_DENIED:
                     err.name = FileSystemProviderErrorCode.NoPermissions;
                     break;
-                case 4 :
+                case FileOperationResult.FILE_MOVE_CONFLICT:
                     err.name = FileSystemProviderErrorCode.FileExists;
                     break;
             }

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

@@ -0,0 +1,25 @@
+import { IWatchOptions } from "vscode/vscode/vs/platform/files/common/files";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { MainThreadFileSystemEventServiceShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IBulkEditService } from "vscode/vscode/vs/editor/browser/services/bulkEditService";
+import { IProgressService } from "vscode/vscode/vs/platform/progress/common/progress.service";
+import { IDialogService } from "vscode/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+export declare class MainThreadFileSystemEventService implements MainThreadFileSystemEventServiceShape {
+    private readonly _fileService;
+    private readonly _logService;
+    static readonly MementoKeyAdditionalEdits = "file.particpants.additionalEdits";
+    private readonly _proxy;
+    private readonly _listener;
+    private readonly _watches;
+    constructor(extHostContext: IExtHostContext, _fileService: IFileService, workingCopyFileService: IWorkingCopyFileService, bulkEditService: IBulkEditService, progressService: IProgressService, dialogService: IDialogService, storageService: IStorageService, logService: ILogService, envService: IEnvironmentService, uriIdentService: IUriIdentityService, _logService: ILogService);
+    $watch(extensionId: string, session: number, resource: UriComponents, unvalidatedOpts: IWatchOptions, correlate: boolean): Promise<void>;
+    $unwatch(session: number): void;
+    dispose(): void;
+}

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

@@ -1,16 +1,20 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { DisposableStore, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
+import { ProgressLocation } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
 import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+import Severity from 'vscode/vscode/vs/base/common/severity';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -26,9 +30,9 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
     constructor(extHostContext, _fileService, workingCopyFileService, bulkEditService, progressService, dialogService, storageService, logService, envService, uriIdentService, _logService) {
         this._fileService = _fileService;
         this._logService = _logService;
-        this._listener = ( (new DisposableStore()));
-        this._watches = ( (new DisposableMap()));
-        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService)));
+        this._listener = ( new DisposableStore());
+        this._watches = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService));
         this._listener.add(_fileService.onDidFilesChange(event => {
             this._proxy.$onFileEvent({
                 created: event.rawAdded,
@@ -42,10 +46,10 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (undoInfo?.isUndoing) {
                     return;
                 }
-                const cts = ( (new CancellationTokenSource(token)));
+                const cts = ( new CancellationTokenSource(token));
                 const timer = setTimeout(() => cts.cancel(), timeout);
                 const data = await progressService.withProgress({
-                    location: 15 ,
+                    location: ProgressLocation.Notification,
                     title: this._progressLabel(operation),
                     cancellable: true,
                     delay: Math.min(timeout / 2, 3000)
@@ -61,68 +65,68 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 if (!data || data.edit.edits.length === 0) {
                     return;
                 }
-                const needsConfirmation = ( (data.edit.edits.some(edit => edit.metadata?.needsConfirmation)));
-                let showPreview = storageService.getBoolean(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, 0 );
+                const needsConfirmation = ( data.edit.edits.some(edit => edit.metadata?.needsConfirmation));
+                let showPreview = storageService.getBoolean(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, StorageScope.PROFILE);
                 if (envService.extensionTestsLocationURI) {
                     showPreview = false;
                 }
                 if (showPreview === undefined) {
                     let message;
                     if (data.extensionNames.length === 1) {
-                        if (operation === 0 ) {
+                        if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                4918,
+                                2270,
                                 "Extension '{0}' wants to make refactoring changes with this file creation",
                                 data.extensionNames[0]
                             ));
                         }
-                        else if (operation === 3 ) {
+                        else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                4919,
+                                2271,
                                 "Extension '{0}' wants to make refactoring changes with this file copy",
                                 data.extensionNames[0]
                             ));
                         }
-                        else if (operation === 2 ) {
+                        else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                4920,
+                                2272,
                                 "Extension '{0}' wants to make refactoring changes with this file move",
                                 data.extensionNames[0]
                             ));
                         }
                         else  {
                             message = ( localize(
-                                4921,
+                                2273,
                                 "Extension '{0}' wants to make refactoring changes with this file deletion",
                                 data.extensionNames[0]
                             ));
                         }
                     }
                     else {
-                        if (operation === 0 ) {
+                        if (operation === FileOperation.CREATE) {
                             message = ( localize(
-                                4922,
+                                2274,
                                 "{0} extensions want to make refactoring changes with this file creation",
                                 data.extensionNames.length
                             ));
                         }
-                        else if (operation === 3 ) {
+                        else if (operation === FileOperation.COPY) {
                             message = ( localize(
-                                4923,
+                                2275,
                                 "{0} extensions want to make refactoring changes with this file copy",
                                 data.extensionNames.length
                             ));
                         }
-                        else if (operation === 2 ) {
+                        else if (operation === FileOperation.MOVE) {
                             message = ( localize(
-                                4924,
+                                2276,
                                 "{0} extensions want to make refactoring changes with this file move",
                                 data.extensionNames.length
                             ));
                         }
                         else  {
                             message = ( localize(
-                                4925,
+                                2277,
                                 "{0} extensions want to make refactoring changes with this file deletion",
                                 data.extensionNames.length
                             ));
@@ -130,10 +134,10 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                     if (needsConfirmation) {
                         const { confirmed } = await dialogService.confirm({
-                            type: Severity$1.Info,
+                            type: Severity.Info,
                             message,
-                            primaryButton: ( localize(4926, "Show &&Preview")),
-                            cancelButton: ( localize(4927, "Skip Changes"))
+                            primaryButton: ( localize(2278, "Show &&Preview")),
+                            cancelButton: ( localize(2279, "Skip Changes"))
                         });
                         showPreview = true;
                         if (!confirmed) {
@@ -142,36 +146,36 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                     }
                     else {
                         let Choice;
-                        ( ((function(Choice) {
+                        (function (Choice) {
                             Choice[Choice["OK"] = 0] = "OK";
                             Choice[Choice["Preview"] = 1] = "Preview";
                             Choice[Choice["Cancel"] = 2] = "Cancel";
-                        })(Choice || (Choice = {}))));
+                        })(Choice || (Choice = {}));
                         const { result, checkboxChecked } = await dialogService.prompt({
-                            type: Severity$1.Info,
+                            type: Severity.Info,
                             message,
                             buttons: [
                                 {
-                                    label: ( localize(4928, "&&OK")),
+                                    label: ( localize(2280, "&&OK")),
                                     run: () => Choice.OK
                                 },
                                 {
-                                    label: ( localize(4926, "Show &&Preview")),
+                                    label: ( localize(2278, "Show &&Preview")),
                                     run: () => Choice.Preview
                                 }
                             ],
                             cancelButton: {
-                                label: ( localize(4927, "Skip Changes")),
+                                label: ( localize(2279, "Skip Changes")),
                                 run: () => Choice.Cancel
                             },
-                            checkbox: { label: ( localize(4929, "Do not ask me again")) }
+                            checkbox: { label: ( localize(2281, "Do not ask me again")) }
                         });
                         if (result === Choice.Cancel) {
                             return;
                         }
                         showPreview = result === Choice.Preview;
                         if (checkboxChecked) {
-                            storageService.store(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, showPreview, 0 , 0 );
+                            storageService.store(MainThreadFileSystemEventService_1.MementoKeyAdditionalEdits, showPreview, StorageScope.PROFILE, StorageTarget.USER);
                         }
                     }
                 }
@@ -180,16 +184,16 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             }
             _progressLabel(operation) {
                 switch (operation) {
-                    case 0 :
-                        return ( localize(4930, "Running 'File Create' participants..."));
-                    case 2 :
-                        return ( localize(4931, "Running 'File Rename' participants..."));
-                    case 3 :
-                        return ( localize(4932, "Running 'File Copy' participants..."));
-                    case 1 :
-                        return ( localize(4933, "Running 'File Delete' participants..."));
-                    case 4 :
-                        return ( localize(4934, "Running 'File Write' participants..."));
+                    case FileOperation.CREATE:
+                        return localize(2282, "Running 'File Create' participants...");
+                    case FileOperation.MOVE:
+                        return localize(2283, "Running 'File Rename' participants...");
+                    case FileOperation.COPY:
+                        return localize(2284, "Running 'File Copy' participants...");
+                    case FileOperation.DELETE:
+                        return localize(2285, "Running 'File Delete' participants...");
+                    case FileOperation.WRITE:
+                        return localize(2286, "Running 'File Write' participants...");
                 }
             }
         });
@@ -212,8 +216,8 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             }
         }
         if (correlate) {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session}, excludes: ${JSON.stringify(opts.excludes)}, includes: ${JSON.stringify(opts.includes)})`);
-            const watcherDisposables = ( (new DisposableStore()));
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching correlated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}, excludes: ${JSON.stringify(opts.excludes)}, includes: ${JSON.stringify(opts.includes)})`);
+            const watcherDisposables = ( new DisposableStore());
             const subscription = watcherDisposables.add(this._fileService.createWatcher(uri, opts));
             watcherDisposables.add(subscription.onDidChange(event => {
                 this._proxy.$onFileEvent({
@@ -226,13 +230,13 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
             this._watches.set(session, watcherDisposables);
         }
         else {
-            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( (uri.toString(true)))}, recursive: ${opts.recursive}, session: ${session}, excludes: ${JSON.stringify(opts.excludes)}, includes: ${JSON.stringify(opts.includes)})`);
+            this._logService.trace(`MainThreadFileSystemEventService#$watch(): request to start watching uncorrelated (extension: ${extensionId}, path: ${( uri.toString(true))}, recursive: ${opts.recursive}, session: ${session}, excludes: ${JSON.stringify(opts.excludes)}, includes: ${JSON.stringify(opts.includes)})`);
             const subscription = this._fileService.watch(uri, opts);
             this._watches.set(session, subscription);
         }
     }
     $unwatch(session) {
-        if (( (this._watches.has(session)))) {
+        if (( this._watches.has(session))) {
             this._logService.trace(`MainThreadFileSystemEventService#$unwatch(): request to stop watching (session: ${session})`);
             this._watches.deleteAndDispose(session);
         }
@@ -244,30 +248,30 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
 };
 MainThreadFileSystemEventService = MainThreadFileSystemEventService_1 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadFileSystemEventService),
-    ( (__param(1, IFileService))),
-    ( (__param(2, IWorkingCopyFileService))),
-    ( (__param(3, IBulkEditService))),
-    ( (__param(4, IProgressService))),
-    ( (__param(5, IDialogService))),
-    ( (__param(6, IStorageService))),
-    ( (__param(7, ILogService))),
-    ( (__param(8, IEnvironmentService))),
-    ( (__param(9, IUriIdentityService))),
-    ( (__param(10, ILogService)))
+    ( __param(1, IFileService)),
+    ( __param(2, IWorkingCopyFileService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, IProgressService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, ILogService)),
+    ( __param(8, IEnvironmentService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, ILogService))
 ], MainThreadFileSystemEventService);
 registerAction2(class ResetMemento extends Action2 {
     constructor() {
         super({
             id: 'files.participants.resetChoice',
             title: {
-                value: ( localize(4935, "Reset choice for 'File operation needs preview'")),
+                value: ( localize(2287, "Reset choice for 'File operation needs preview'")),
                 original: `Reset choice for 'File operation needs preview'`
             },
             f1: true
         });
     }
     run(accessor) {
-        accessor.get(IStorageService).remove(MainThreadFileSystemEventService.MementoKeyAdditionalEdits, 0 );
+        accessor.get(IStorageService).remove(MainThreadFileSystemEventService.MementoKeyAdditionalEdits, StorageScope.PROFILE);
     }
 });
 

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

@@ -0,0 +1,9 @@
+import { MainThreadInteractiveShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IInteractiveDocumentService } from "vscode/vscode/vs/workbench/contrib/interactive/browser/interactiveDocumentService.service";
+export declare class MainThreadInteractive implements MainThreadInteractiveShape {
+    private readonly _proxy;
+    private readonly _disposables;
+    constructor(extHostContext: IExtHostContext, interactiveDocumentService: IInteractiveDocumentService);
+    dispose(): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadInteractive.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 { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';

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

@@ -0,0 +1,12 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ResourceLabelFormatter } from "@codingame/monaco-vscode-82e231ca-6ed7-5920-b2b8-1874ccc0be07-common/vscode/vs/platform/label/common/label";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { MainThreadLabelServiceShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadLabelService extends Disposable implements MainThreadLabelServiceShape {
+    private readonly _labelService;
+    private readonly _resourceLabelFormatters;
+    constructor(_: IExtHostContext, _labelService: ILabelService);
+    $registerResourceLabelFormatter(handle: number, formatter: ResourceLabelFormatter): void;
+    $unregisterResourceLabelFormatter(handle: number): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadLabelService.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, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
 import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';