@codingame/monaco-vscode-extension-gallery-service-override 4.4.1 → 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -0,0 +1,339 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url.service';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Action2, MenuId, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IsWebContext } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { disposableWindowInterval } from 'vscode/vscode/vs/base/browser/dom';
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+var ExtensionUrlBootstrapHandler_1;
+const FIVE_MINUTES = 5 * 60 * 1000;
+const THIRTY_SECONDS = 30 * 1000;
+const URL_TO_HANDLE = 'extensionUrlHandler.urlToHandle';
+const USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY = 'extensions.confirmedUriHandlerExtensionIds';
+const USER_TRUSTED_EXTENSIONS_STORAGE_KEY = 'extensionUrlHandler.confirmedExtensions';
+function isExtensionId(value) {
+    return /^[a-z0-9][a-z0-9\-]*\.[a-z0-9][a-z0-9\-]*$/i.test(value);
+}
+class UserTrustedExtensionIdStorage {
+    get extensions() {
+        const userTrustedExtensionIdsJson = this.storageService.get(USER_TRUSTED_EXTENSIONS_STORAGE_KEY, 0 , '[]');
+        try {
+            return JSON.parse(userTrustedExtensionIdsJson);
+        }
+        catch {
+            return [];
+        }
+    }
+    constructor(storageService) {
+        this.storageService = storageService;
+    }
+    has(id) {
+        return this.extensions.indexOf(id) > -1;
+    }
+    add(id) {
+        this.set([...this.extensions, id]);
+    }
+    set(ids) {
+        this.storageService.store(USER_TRUSTED_EXTENSIONS_STORAGE_KEY, JSON.stringify(ids), 0 , 1 );
+    }
+}
+let ExtensionUrlHandler = class ExtensionUrlHandler {
+    constructor(urlService, extensionService, dialogService, commandService, hostService, storageService, configurationService, telemetryService, notificationService, productService, workbenchEnvironmentService) {
+        this.extensionService = extensionService;
+        this.dialogService = dialogService;
+        this.commandService = commandService;
+        this.hostService = hostService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this.notificationService = notificationService;
+        this.productService = productService;
+        this.workbenchEnvironmentService = workbenchEnvironmentService;
+        this.extensionHandlers = ( new Map());
+        this.uriBuffer = ( new Map());
+        this.userTrustedExtensionsStorage = ( new UserTrustedExtensionIdStorage(storageService));
+        const interval = disposableWindowInterval(mainWindow, () => this.garbageCollect(), THIRTY_SECONDS);
+        const urlToHandleValue = this.storageService.get(URL_TO_HANDLE, 1 );
+        if (urlToHandleValue) {
+            this.storageService.remove(URL_TO_HANDLE, 1 );
+            this.handleURL(URI.revive(JSON.parse(urlToHandleValue)), { trusted: true });
+        }
+        this.disposable = combinedDisposable(urlService.registerHandler(this), interval);
+        const cache = ExtensionUrlBootstrapHandler.cache;
+        setTimeout(() => cache.forEach(([uri, option]) => this.handleURL(uri, option)));
+    }
+    async handleURL(uri, options) {
+        if (!isExtensionId(uri.authority)) {
+            return false;
+        }
+        const extensionId = uri.authority;
+        this.telemetryService.publicLog2('uri_invoked/start', { extensionId });
+        const initialHandler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        let extensionDisplayName;
+        if (!initialHandler) {
+            const extension = await this.extensionService.getExtension(extensionId);
+            if (!extension) {
+                await this.handleUnhandledURL(uri, extensionId, options);
+                return true;
+            }
+            else {
+                extensionDisplayName = extension.displayName ?? '';
+            }
+        }
+        else {
+            extensionDisplayName = initialHandler.extensionDisplayName;
+        }
+        const trusted = options?.trusted
+            || this.productService.trustedExtensionProtocolHandlers?.includes(extensionId)
+            || this.didUserTrustExtension(ExtensionIdentifier.toKey(extensionId));
+        if (!trusted) {
+            let uriString = ( uri.toString(false));
+            if (uriString.length > 40) {
+                uriString = `${uriString.substring(0, 30)}...${uriString.substring(uriString.length - 5)}`;
+            }
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'confirmUrl',
+                    "Allow '{0}' extension to open this URI?",
+                    extensionDisplayName
+                )),
+                checkbox: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'rememberConfirmUrl',
+                        "Do not ask me again for this extension"
+                    )),
+                },
+                detail: uriString,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'open', comment: ['&& denotes a mnemonic'] },
+                    "&&Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/cancel', { extensionId });
+                return true;
+            }
+            if (result.checkboxChecked) {
+                this.userTrustedExtensionsStorage.add(ExtensionIdentifier.toKey(extensionId));
+            }
+        }
+        const handler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        if (handler) {
+            if (!initialHandler) {
+                return await this.handleURLByExtension(extensionId, handler, uri, options);
+            }
+            return false;
+        }
+        const timestamp = ( new Date()).getTime();
+        let uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId));
+        if (!uris) {
+            uris = [];
+            this.uriBuffer.set(ExtensionIdentifier.toKey(extensionId), uris);
+        }
+        uris.push({ timestamp, uri });
+        await this.extensionService.activateByEvent(`onUri:${ExtensionIdentifier.toKey(extensionId)}`, 1 );
+        return true;
+    }
+    registerExtensionHandler(extensionId, handler) {
+        this.extensionHandlers.set(ExtensionIdentifier.toKey(extensionId), handler);
+        const uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId)) || [];
+        for (const { uri } of uris) {
+            this.handleURLByExtension(extensionId, handler, uri);
+        }
+        this.uriBuffer.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    unregisterExtensionHandler(extensionId) {
+        this.extensionHandlers.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    async handleURLByExtension(extensionId, handler, uri, options) {
+        this.telemetryService.publicLog2('uri_invoked/end', { extensionId: ExtensionIdentifier.toKey(extensionId) });
+        return await handler.handleURL(uri, options);
+    }
+    async handleUnhandledURL(uri, extensionId, options) {
+        this.telemetryService.publicLog2('uri_invoked/install_extension/start', { extensionId });
+        try {
+            await this.commandService.executeCommand('workbench.extensions.installExtension', extensionId, {
+                justification: {
+                    reason: `${( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'installDetail',
+                        "This extension wants to open a URI:"
+                    ))}\n${( uri.toString())}`,
+                    action: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'openUri',
+                        "Open URI"
+                    ))
+                },
+                enable: true
+            });
+            this.telemetryService.publicLog2('uri_invoked/install_extension/accept', { extensionId });
+        }
+        catch (error) {
+            if (isCancellationError(error)) {
+                this.telemetryService.publicLog2('uri_invoked/install_extension/cancel', { extensionId });
+            }
+            else {
+                this.telemetryService.publicLog2('uri_invoked/install_extension/error', { extensionId });
+                this.notificationService.error(error);
+            }
+            return;
+        }
+        const extension = await this.extensionService.getExtension(extensionId);
+        if (extension) {
+            await this.handleURL(uri, { ...options, trusted: true });
+        }
+        else {
+            this.telemetryService.publicLog2('uri_invoked/install_extension/reload', { extensionId, isRemote: !!this.workbenchEnvironmentService.remoteAuthority });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'reloadAndHandle',
+                    "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?",
+                    extensionId
+                )),
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'reloadAndOpen', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                return;
+            }
+            this.storageService.store(URL_TO_HANDLE, JSON.stringify(uri.toJSON()), 1 , 1 );
+            await this.hostService.reload();
+        }
+    }
+    garbageCollect() {
+        const now = ( new Date()).getTime();
+        const uriBuffer = ( new Map());
+        this.uriBuffer.forEach((uris, extensionId) => {
+            uris = uris.filter(({ timestamp }) => now - timestamp < FIVE_MINUTES);
+            if (uris.length > 0) {
+                uriBuffer.set(extensionId, uris);
+            }
+        });
+        this.uriBuffer = uriBuffer;
+    }
+    didUserTrustExtension(id) {
+        if (( this.userTrustedExtensionsStorage.has(id))) {
+            return true;
+        }
+        return this.getConfirmedTrustedExtensionIdsFromConfiguration().indexOf(id) > -1;
+    }
+    getConfirmedTrustedExtensionIdsFromConfiguration() {
+        const trustedExtensionIds = this.configurationService.getValue(USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY);
+        if (!Array.isArray(trustedExtensionIds)) {
+            return [];
+        }
+        return trustedExtensionIds;
+    }
+    dispose() {
+        this.disposable.dispose();
+        this.extensionHandlers.clear();
+        this.uriBuffer.clear();
+    }
+};
+ExtensionUrlHandler = ( __decorate([
+    ( __param(0, IURLService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IHostService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, INotificationService)),
+    ( __param(9, IProductService)),
+    ( __param(10, IWorkbenchEnvironmentService))
+], ExtensionUrlHandler));
+let ExtensionUrlBootstrapHandler = class ExtensionUrlBootstrapHandler {
+    static { ExtensionUrlBootstrapHandler_1 = this; }
+    static { this.ID = 'workbench.contrib.extensionUrlBootstrapHandler'; }
+    static { this._cache = []; }
+    static get cache() {
+        ExtensionUrlBootstrapHandler_1.disposable.dispose();
+        const result = ExtensionUrlBootstrapHandler_1._cache;
+        ExtensionUrlBootstrapHandler_1._cache = [];
+        return result;
+    }
+    constructor(urlService) {
+        ExtensionUrlBootstrapHandler_1.disposable = urlService.registerHandler(this);
+    }
+    async handleURL(uri, options) {
+        if (!isExtensionId(uri.authority)) {
+            return false;
+        }
+        ExtensionUrlBootstrapHandler_1._cache.push([uri, options]);
+        return true;
+    }
+};
+ExtensionUrlBootstrapHandler = ExtensionUrlBootstrapHandler_1 = ( __decorate([
+    ( __param(0, IURLService))
+], ExtensionUrlBootstrapHandler));
+registerWorkbenchContribution2(ExtensionUrlBootstrapHandler.ID, ExtensionUrlBootstrapHandler, 2 );
+class ManageAuthorizedExtensionURIsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.extensions.action.manageAuthorizedExtensionURIs',
+            title: ( localize2WithPath(
+                'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                'manage',
+                'Manage Authorized Extension URIs...'
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                'extensions',
+                'Extensions'
+            )),
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( IsWebContext.toNegated())
+            }
+        });
+    }
+    async run(accessor) {
+        const storageService = accessor.get(IStorageService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const storage = ( new UserTrustedExtensionIdStorage(storageService));
+        const items = ( storage.extensions.map(label => ({ label, picked: true })));
+        if (items.length === 0) {
+            await quickInputService.pick([{ label: ( localizeWithPath(
+                'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                'no',
+                'There are currently no authorized extension URIs.'
+            )) }]);
+            return;
+        }
+        const result = await quickInputService.pick(items, { canPickMany: true });
+        if (!result) {
+            return;
+        }
+        storage.set(( result.map(item => item.label)));
+    }
+}
+registerAction2(ManageAuthorizedExtensionURIsAction);
+
+export { ExtensionUrlHandler };

package/vscode/src/vs/workbench/services/extensions/browser/extensionsScannerService.js

@@ -1,14 +1,14 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { IExtensionsProfileScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsProfileScannerService';
-import { AbstractExtensionsScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsScannerService';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { IExtensionsProfileScannerService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionsProfileScannerService.service';
+import { AbstractExtensionsScannerService } from '../../../../platform/extensionManagement/common/extensionsScannerService.js';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
 
 let ExtensionsScannerService = class ExtensionsScannerService extends AbstractExtensionsScannerService {
     constructor(userDataProfileService, userDataProfilesService, extensionsProfileScannerService, fileService, logService, environmentService, productService, uriIdentityService, instantiationService) {

package/vscode/src/vs/workbench/services/userDataProfile/common/remoteUserDataProfiles.js

@@ -0,0 +1,151 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile.service';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { distinct } from 'vscode/vscode/vs/base/common/arrays';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { UserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfileIpc.js';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+const associatedRemoteProfilesKey = 'associatedRemoteProfiles';
+let RemoteUserDataProfilesService = class RemoteUserDataProfilesService extends Disposable {
+    constructor(environmentService, remoteAgentService, userDataProfilesService, userDataProfileService, storageService, logService) {
+        super();
+        this.environmentService = environmentService;
+        this.remoteAgentService = remoteAgentService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileService = userDataProfileService;
+        this.storageService = storageService;
+        this.logService = logService;
+        this.initPromise = this.init();
+    }
+    async init() {
+        const connection = this.remoteAgentService.getConnection();
+        if (!connection) {
+            return;
+        }
+        const environment = await this.remoteAgentService.getEnvironment();
+        if (!environment) {
+            return;
+        }
+        this.remoteUserDataProfilesService = ( new UserDataProfilesService(
+            environment.profiles.all,
+            environment.profiles.home,
+            connection.getChannel('userDataProfiles')
+        ));
+        this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeLocalProfiles(e)));
+        const remoteProfile = await this.getAssociatedRemoteProfile(this.userDataProfileService.currentProfile, this.remoteUserDataProfilesService);
+        if (!remoteProfile.isDefault) {
+            this.setAssociatedRemoteProfiles([...this.getAssociatedRemoteProfiles(), remoteProfile.id]);
+        }
+        this.cleanUp();
+    }
+    async onDidChangeLocalProfiles(e) {
+        for (const profile of e.removed) {
+            const remoteProfile = this.remoteUserDataProfilesService?.profiles.find(p => p.id === profile.id);
+            if (remoteProfile) {
+                await this.remoteUserDataProfilesService?.removeProfile(remoteProfile);
+            }
+        }
+    }
+    async getRemoteProfiles() {
+        await this.initPromise;
+        if (!this.remoteUserDataProfilesService) {
+            throw new Error('Remote profiles service not available in the current window');
+        }
+        return this.remoteUserDataProfilesService.profiles;
+    }
+    async getRemoteProfile(localProfile) {
+        await this.initPromise;
+        if (!this.remoteUserDataProfilesService) {
+            throw new Error('Remote profiles service not available in the current window');
+        }
+        return this.getAssociatedRemoteProfile(localProfile, this.remoteUserDataProfilesService);
+    }
+    async getAssociatedRemoteProfile(localProfile, remoteUserDataProfilesService) {
+        if (localProfile.isDefault) {
+            return remoteUserDataProfilesService.defaultProfile;
+        }
+        let profile = remoteUserDataProfilesService.profiles.find(p => p.id === localProfile.id);
+        if (!profile) {
+            profile = await remoteUserDataProfilesService.createProfile(localProfile.id, localProfile.name, {
+                shortName: localProfile.shortName,
+                transient: localProfile.isTransient,
+                useDefaultFlags: localProfile.useDefaultFlags,
+            });
+            this.setAssociatedRemoteProfiles([...this.getAssociatedRemoteProfiles(), this.userDataProfileService.currentProfile.id]);
+        }
+        return profile;
+    }
+    getAssociatedRemoteProfiles() {
+        if (this.environmentService.remoteAuthority) {
+            const remotes = this.parseAssociatedRemoteProfiles();
+            return remotes[this.environmentService.remoteAuthority] ?? [];
+        }
+        return [];
+    }
+    setAssociatedRemoteProfiles(profiles) {
+        if (this.environmentService.remoteAuthority) {
+            const remotes = this.parseAssociatedRemoteProfiles();
+            profiles = distinct(profiles);
+            if (profiles.length) {
+                remotes[this.environmentService.remoteAuthority] = profiles;
+            }
+            else {
+                delete remotes[this.environmentService.remoteAuthority];
+            }
+            if (( Object.keys(remotes)).length) {
+                this.storageService.store(associatedRemoteProfilesKey, JSON.stringify(remotes), -1 , 1 );
+            }
+            else {
+                this.storageService.remove(associatedRemoteProfilesKey, -1 );
+            }
+        }
+    }
+    parseAssociatedRemoteProfiles() {
+        if (this.environmentService.remoteAuthority) {
+            const value = this.storageService.get(associatedRemoteProfilesKey, -1 );
+            try {
+                return value ? JSON.parse(value) : {};
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return {};
+    }
+    async cleanUp() {
+        const associatedRemoteProfiles = [];
+        for (const profileId of this.getAssociatedRemoteProfiles()) {
+            const remoteProfile = this.remoteUserDataProfilesService?.profiles.find(p => p.id === profileId);
+            if (!remoteProfile) {
+                continue;
+            }
+            const localProfile = this.userDataProfilesService.profiles.find(p => p.id === profileId);
+            if (localProfile) {
+                if (localProfile.name !== remoteProfile.name || localProfile.shortName !== remoteProfile.shortName) {
+                    await this.remoteUserDataProfilesService?.updateProfile(remoteProfile, { name: localProfile.name, shortName: localProfile.shortName });
+                }
+                associatedRemoteProfiles.push(profileId);
+                continue;
+            }
+            if (remoteProfile) {
+                await this.remoteUserDataProfilesService?.removeProfile(remoteProfile);
+            }
+        }
+        this.setAssociatedRemoteProfiles(associatedRemoteProfiles);
+    }
+};
+RemoteUserDataProfilesService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IRemoteAgentService)),
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ILogService))
+], RemoteUserDataProfilesService));
+
+export { RemoteUserDataProfilesService };

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,10 +0,0 @@
-export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var ConfirmResult;
-( (function(ConfirmResult) {
-    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
-    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
-    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
-})(ConfirmResult || (ConfirmResult = {})));
-
-export { ConfirmResult };