@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyService.js

@@ -0,0 +1,112 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+const IWorkingCopyService = ( createDecorator('workingCopyService'));
+class WorkingCopyService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidRegister = this._register(( new Emitter()));
+        this.onDidRegister = this._onDidRegister.event;
+        this._onDidUnregister = this._register(( new Emitter()));
+        this.onDidUnregister = this._onDidUnregister.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._workingCopies = ( new Set());
+        this.mapResourceToWorkingCopies = ( new ResourceMap());
+    }
+    get workingCopies() { return Array.from(( this._workingCopies.values())); }
+    registerWorkingCopy(workingCopy) {
+        let workingCopiesForResource = this.mapResourceToWorkingCopies.get(workingCopy.resource);
+        if (workingCopiesForResource?.has(workingCopy.typeId)) {
+            throw new Error(`Cannot register more than one working copy with the same resource ${workingCopy.resource.toString()} and type ${workingCopy.typeId}.`);
+        }
+        this._workingCopies.add(workingCopy);
+        if (!workingCopiesForResource) {
+            workingCopiesForResource = ( new Map());
+            this.mapResourceToWorkingCopies.set(workingCopy.resource, workingCopiesForResource);
+        }
+        workingCopiesForResource.set(workingCopy.typeId, workingCopy);
+        const disposables = ( new DisposableStore());
+        disposables.add(workingCopy.onDidChangeContent(() => this._onDidChangeContent.fire(workingCopy)));
+        disposables.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
+        disposables.add(workingCopy.onDidSave(e => this._onDidSave.fire({ workingCopy, ...e })));
+        this._onDidRegister.fire(workingCopy);
+        if (workingCopy.isDirty()) {
+            this._onDidChangeDirty.fire(workingCopy);
+        }
+        return toDisposable(() => {
+            this.unregisterWorkingCopy(workingCopy);
+            dispose(disposables);
+            this._onDidUnregister.fire(workingCopy);
+        });
+    }
+    unregisterWorkingCopy(workingCopy) {
+        this._workingCopies.delete(workingCopy);
+        const workingCopiesForResource = this.mapResourceToWorkingCopies.get(workingCopy.resource);
+        if (workingCopiesForResource?.delete(workingCopy.typeId) && workingCopiesForResource.size === 0) {
+            this.mapResourceToWorkingCopies.delete(workingCopy.resource);
+        }
+        if (workingCopy.isDirty()) {
+            this._onDidChangeDirty.fire(workingCopy);
+        }
+    }
+    has(resourceOrIdentifier) {
+        if (URI.isUri(resourceOrIdentifier)) {
+            return this.mapResourceToWorkingCopies.has(resourceOrIdentifier);
+        }
+        return this.mapResourceToWorkingCopies.get(resourceOrIdentifier.resource)?.has(resourceOrIdentifier.typeId) ?? false;
+    }
+    get(identifier) {
+        return this.mapResourceToWorkingCopies.get(identifier.resource)?.get(identifier.typeId);
+    }
+    getAll(resource) {
+        const workingCopies = this.mapResourceToWorkingCopies.get(resource);
+        if (!workingCopies) {
+            return undefined;
+        }
+        return Array.from(( workingCopies.values()));
+    }
+    get hasDirty() {
+        for (const workingCopy of this._workingCopies) {
+            if (workingCopy.isDirty()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get dirtyCount() {
+        let totalDirtyCount = 0;
+        for (const workingCopy of this._workingCopies) {
+            if (workingCopy.isDirty()) {
+                totalDirtyCount++;
+            }
+        }
+        return totalDirtyCount;
+    }
+    get dirtyWorkingCopies() {
+        return this.workingCopies.filter(workingCopy => workingCopy.isDirty());
+    }
+    isDirty(resource, typeId) {
+        const workingCopies = this.mapResourceToWorkingCopies.get(resource);
+        if (workingCopies) {
+            if (typeof typeId === 'string') {
+                return workingCopies.get(typeId)?.isDirty() ?? false;
+            }
+            else {
+                for (const [, workingCopy] of workingCopies) {
+                    if (workingCopy.isDirty()) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+export { IWorkingCopyService, WorkingCopyService };

package/dist/vscode/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js

@@ -0,0 +1,325 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { WORKSPACE_FILTER, hasWorkspaceFileExtension, WORKSPACE_EXTENSION, isSavedWorkspace, isUntitledWorkspace, toWorkspaceIdentifier, isWorkspaceIdentifier, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IJSONEditingService } from '../../configuration/common/jsonEditing.js';
+import { rewriteWorkspaceFileForNewLocation, IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { firstOrDefault, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { joinPath, basename, isEqualAuthority, isEqual, removeTrailingPathSeparator } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IFileDialogService, IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { mnemonicButtonLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { IHostService } from '../../host/browser/host.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IWorkbenchConfigurationService } from '../../configuration/common/configuration.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
+let AbstractWorkspaceEditingService = class AbstractWorkspaceEditingService {
+    constructor(jsonEditingService, contextService, configurationService, notificationService, commandService, fileService, textFileService, workspacesService, environmentService, fileDialogService, dialogService, hostService, uriIdentityService, workspaceTrustManagementService, userDataProfilesService, userDataProfileService) {
+        this.jsonEditingService = jsonEditingService;
+        this.contextService = contextService;
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.commandService = commandService;
+        this.fileService = fileService;
+        this.textFileService = textFileService;
+        this.workspacesService = workspacesService;
+        this.environmentService = environmentService;
+        this.fileDialogService = fileDialogService;
+        this.dialogService = dialogService;
+        this.hostService = hostService;
+        this.uriIdentityService = uriIdentityService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.userDataProfileService = userDataProfileService;
+    }
+    async pickNewWorkspacePath() {
+        const availableFileSystems = [Schemas.file];
+        if (this.environmentService.remoteAuthority) {
+            availableFileSystems.unshift(Schemas.vscodeRemote);
+        }
+        let workspacePath = await this.fileDialogService.showSaveDialog({
+            saveLabel: mnemonicButtonLabel(( localize('save', "Save"))),
+            title: ( localize('saveWorkspace', "Save Workspace")),
+            filters: WORKSPACE_FILTER,
+            defaultUri: joinPath(await this.fileDialogService.defaultWorkspacePath(), this.getNewWorkspaceName()),
+            availableFileSystems
+        });
+        if (!workspacePath) {
+            return;
+        }
+        if (!hasWorkspaceFileExtension(workspacePath)) {
+            workspacePath = workspacePath.with({ path: `${workspacePath.path}.${WORKSPACE_EXTENSION}` });
+        }
+        return workspacePath;
+    }
+    getNewWorkspaceName() {
+        const configPathURI = this.getCurrentWorkspaceIdentifier()?.configPath;
+        if (configPathURI && isSavedWorkspace(configPathURI, this.environmentService)) {
+            return basename(configPathURI);
+        }
+        const folder = firstOrDefault(this.contextService.getWorkspace().folders);
+        if (folder) {
+            return `${basename(folder.uri)}.${WORKSPACE_EXTENSION}`;
+        }
+        return `workspace.${WORKSPACE_EXTENSION}`;
+    }
+    async updateFolders(index, deleteCount, foldersToAddCandidates, donotNotifyError) {
+        const folders = this.contextService.getWorkspace().folders;
+        let foldersToDelete = [];
+        if (typeof deleteCount === 'number') {
+            foldersToDelete = ( folders.slice(index, index + deleteCount).map(folder => folder.uri));
+        }
+        let foldersToAdd = [];
+        if (Array.isArray(foldersToAddCandidates)) {
+            foldersToAdd = ( foldersToAddCandidates.map(
+                folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
+            ));
+        }
+        const wantsToDelete = foldersToDelete.length > 0;
+        const wantsToAdd = foldersToAdd.length > 0;
+        if (!wantsToAdd && !wantsToDelete) {
+            return;
+        }
+        if (wantsToAdd && !wantsToDelete) {
+            return this.doAddFolders(foldersToAdd, index, donotNotifyError);
+        }
+        if (wantsToDelete && !wantsToAdd) {
+            return this.removeFolders(foldersToDelete);
+        }
+        else {
+            if (this.includesSingleFolderWorkspace(foldersToDelete)) {
+                return this.createAndEnterWorkspace(foldersToAdd);
+            }
+            if (this.contextService.getWorkbenchState() !== 3 ) {
+                return this.doAddFolders(foldersToAdd, index, donotNotifyError);
+            }
+            return this.doUpdateFolders(foldersToAdd, foldersToDelete, index, donotNotifyError);
+        }
+    }
+    async doUpdateFolders(foldersToAdd, foldersToDelete, index, donotNotifyError = false) {
+        try {
+            await this.contextService.updateFolders(foldersToAdd, foldersToDelete, index);
+        }
+        catch (error) {
+            if (donotNotifyError) {
+                throw error;
+            }
+            this.handleWorkspaceConfigurationEditingError(error);
+        }
+    }
+    addFolders(foldersToAddCandidates, donotNotifyError = false) {
+        const foldersToAdd = ( foldersToAddCandidates.map(
+            folderToAdd => ({ uri: removeTrailingPathSeparator(folderToAdd.uri), name: folderToAdd.name })
+        ));
+        return this.doAddFolders(foldersToAdd, undefined, donotNotifyError);
+    }
+    async doAddFolders(foldersToAdd, index, donotNotifyError = false) {
+        const state = this.contextService.getWorkbenchState();
+        const remoteAuthority = this.environmentService.remoteAuthority;
+        if (remoteAuthority) {
+            foldersToAdd = foldersToAdd.filter(folder => folder.uri.scheme !== Schemas.file && (folder.uri.scheme !== Schemas.vscodeRemote || isEqualAuthority(folder.uri.authority, remoteAuthority)));
+        }
+        if (state !== 3 ) {
+            let newWorkspaceFolders = ( this.contextService.getWorkspace().folders.map(folder => ({ uri: folder.uri })));
+            newWorkspaceFolders.splice(typeof index === 'number' ? index : newWorkspaceFolders.length, 0, ...foldersToAdd);
+            newWorkspaceFolders = distinct(newWorkspaceFolders, folder => this.uriIdentityService.extUri.getComparisonKey(folder.uri));
+            if (state === 1  && newWorkspaceFolders.length === 0 || state === 2  && newWorkspaceFolders.length === 1) {
+                return;
+            }
+            return this.createAndEnterWorkspace(newWorkspaceFolders);
+        }
+        try {
+            await this.contextService.addFolders(foldersToAdd, index);
+        }
+        catch (error) {
+            if (donotNotifyError) {
+                throw error;
+            }
+            this.handleWorkspaceConfigurationEditingError(error);
+        }
+    }
+    async removeFolders(foldersToRemove, donotNotifyError = false) {
+        if (this.includesSingleFolderWorkspace(foldersToRemove)) {
+            return this.createAndEnterWorkspace([]);
+        }
+        try {
+            await this.contextService.removeFolders(foldersToRemove);
+        }
+        catch (error) {
+            if (donotNotifyError) {
+                throw error;
+            }
+            this.handleWorkspaceConfigurationEditingError(error);
+        }
+    }
+    includesSingleFolderWorkspace(folders) {
+        if (this.contextService.getWorkbenchState() === 2 ) {
+            const workspaceFolder = this.contextService.getWorkspace().folders[0];
+            return ( folders.some(
+                folder => this.uriIdentityService.extUri.isEqual(folder, workspaceFolder.uri)
+            ));
+        }
+        return false;
+    }
+    async createAndEnterWorkspace(folders, path) {
+        if (path && !(await this.isValidTargetWorkspacePath(path))) {
+            return;
+        }
+        const remoteAuthority = this.environmentService.remoteAuthority;
+        const untitledWorkspace = await this.workspacesService.createUntitledWorkspace(folders, remoteAuthority);
+        if (path) {
+            try {
+                await this.saveWorkspaceAs(untitledWorkspace, path);
+            }
+            finally {
+                await this.workspacesService.deleteUntitledWorkspace(untitledWorkspace);
+            }
+        }
+        else {
+            path = untitledWorkspace.configPath;
+            if (!this.userDataProfileService.currentProfile.isDefault) {
+                await this.userDataProfilesService.setProfileForWorkspace(untitledWorkspace, this.userDataProfileService.currentProfile);
+            }
+        }
+        return this.enterWorkspace(path);
+    }
+    async saveAndEnterWorkspace(workspaceUri) {
+        const workspaceIdentifier = this.getCurrentWorkspaceIdentifier();
+        if (!workspaceIdentifier) {
+            return;
+        }
+        if (isEqual(workspaceIdentifier.configPath, workspaceUri)) {
+            return this.saveWorkspace(workspaceIdentifier);
+        }
+        if (!(await this.isValidTargetWorkspacePath(workspaceUri))) {
+            return;
+        }
+        await this.saveWorkspaceAs(workspaceIdentifier, workspaceUri);
+        return this.enterWorkspace(workspaceUri);
+    }
+    async isValidTargetWorkspacePath(workspaceUri) {
+        return true;
+    }
+    async saveWorkspaceAs(workspace, targetConfigPathURI) {
+        const configPathURI = workspace.configPath;
+        const isNotUntitledWorkspace = !isUntitledWorkspace(targetConfigPathURI, this.environmentService);
+        if (isNotUntitledWorkspace && !this.userDataProfileService.currentProfile.isDefault) {
+            const newWorkspace = await this.workspacesService.getWorkspaceIdentifier(targetConfigPathURI);
+            await this.userDataProfilesService.setProfileForWorkspace(newWorkspace, this.userDataProfileService.currentProfile);
+        }
+        if (this.uriIdentityService.extUri.isEqual(configPathURI, targetConfigPathURI)) {
+            return;
+        }
+        const isFromUntitledWorkspace = isUntitledWorkspace(configPathURI, this.environmentService);
+        const raw = await this.fileService.readFile(configPathURI);
+        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(( raw.value.toString()), configPathURI, isFromUntitledWorkspace, targetConfigPathURI, this.uriIdentityService.extUri);
+        await this.textFileService.create([{ resource: targetConfigPathURI, value: newRawWorkspaceContents, options: { overwrite: true } }]);
+        await this.trustWorkspaceConfiguration(targetConfigPathURI);
+    }
+    async saveWorkspace(workspace) {
+        const configPathURI = workspace.configPath;
+        const existingModel = this.textFileService.files.get(configPathURI);
+        if (existingModel) {
+            await existingModel.save({ force: true, reason: 1  });
+            return;
+        }
+        const workspaceFileExists = await this.fileService.exists(configPathURI);
+        if (workspaceFileExists) {
+            return;
+        }
+        const newWorkspace = { folders: [] };
+        const newRawWorkspaceContents = rewriteWorkspaceFileForNewLocation(JSON.stringify(newWorkspace, null, '\t'), configPathURI, false, configPathURI, this.uriIdentityService.extUri);
+        await this.textFileService.create([{ resource: configPathURI, value: newRawWorkspaceContents }]);
+    }
+    handleWorkspaceConfigurationEditingError(error) {
+        switch (error.code) {
+            case 0 :
+                this.onInvalidWorkspaceConfigurationFileError();
+                break;
+            default:
+                this.notificationService.error(error.message);
+        }
+    }
+    onInvalidWorkspaceConfigurationFileError() {
+        const message = ( localize(
+            'errorInvalidTaskConfiguration',
+            "Unable to write into workspace configuration file. Please open the file to correct errors/warnings in it and try again."
+        ));
+        this.askToOpenWorkspaceConfigurationFile(message);
+    }
+    askToOpenWorkspaceConfigurationFile(message) {
+        this.notificationService.prompt(Severity.Error, message, [{
+                label: ( localize('openWorkspaceConfigurationFile', "Open Workspace Configuration")),
+                run: () => this.commandService.executeCommand('workbench.action.openWorkspaceConfigFile')
+            }]);
+    }
+    async doEnterWorkspace(workspaceUri) {
+        if (!!this.environmentService.extensionTestsLocationURI) {
+            throw new Error('Entering a new workspace is not possible in tests.');
+        }
+        const workspace = await this.workspacesService.getWorkspaceIdentifier(workspaceUri);
+        if (this.contextService.getWorkbenchState() === 2 ) {
+            await this.migrateWorkspaceSettings(workspace);
+        }
+        await this.configurationService.initialize(workspace);
+        return this.workspacesService.enterWorkspace(workspaceUri);
+    }
+    migrateWorkspaceSettings(toWorkspace) {
+        return this.doCopyWorkspaceSettings(toWorkspace, setting => setting.scope === 3 );
+    }
+    copyWorkspaceSettings(toWorkspace) {
+        return this.doCopyWorkspaceSettings(toWorkspace);
+    }
+    doCopyWorkspaceSettings(toWorkspace, filter) {
+        const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+        const targetWorkspaceConfiguration = {};
+        for (const key of ( this.configurationService.keys()).workspace) {
+            if (configurationProperties[key]) {
+                if (filter && !filter(configurationProperties[key])) {
+                    continue;
+                }
+                targetWorkspaceConfiguration[key] = this.configurationService.inspect(key).workspaceValue;
+            }
+        }
+        return this.jsonEditingService.write(toWorkspace.configPath, [{ path: ['settings'], value: targetWorkspaceConfiguration }], true);
+    }
+    async trustWorkspaceConfiguration(configPathURI) {
+        if (this.contextService.getWorkbenchState() !== 1  && this.workspaceTrustManagementService.isWorkspaceTrusted()) {
+            await this.workspaceTrustManagementService.setUrisTrust([configPathURI], true);
+        }
+    }
+    getCurrentWorkspaceIdentifier() {
+        const identifier = toWorkspaceIdentifier(this.contextService.getWorkspace());
+        if (isWorkspaceIdentifier(identifier)) {
+            return identifier;
+        }
+        return undefined;
+    }
+};
+AbstractWorkspaceEditingService = ( __decorate([
+    ( __param(0, IJSONEditingService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IWorkbenchConfigurationService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IFileService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, IWorkspacesService)),
+    ( __param(8, IWorkbenchEnvironmentService)),
+    ( __param(9, IFileDialogService)),
+    ( __param(10, IDialogService)),
+    ( __param(11, IHostService)),
+    ( __param(12, IUriIdentityService)),
+    ( __param(13, IWorkspaceTrustManagementService)),
+    ( __param(14, IUserDataProfilesService)),
+    ( __param(15, IUserDataProfileService))
+], AbstractWorkspaceEditingService));
+export { AbstractWorkspaceEditingService };

package/dist/vscode/vs/workbench/services/workspaces/browser/workspaces.js

@@ -0,0 +1,11 @@
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+function getWorkspaceIdentifier(workspaceUri) {
+    return {
+        id: getWorkspaceId(workspaceUri),
+        configPath: workspaceUri
+    };
+}
+function getWorkspaceId(uri) {
+    return ( hash(( uri.toString())).toString(16));
+}
+export { getWorkspaceIdentifier };

package/dist/vscode/vs/workbench/services/workspaces/browser/workspacesService.js

@@ -0,0 +1,154 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { restoreRecentlyOpened, isRecentFolder, isRecentWorkspace, isRecentFile, toStoreData, getStoredWorkspaceFolder } from '../../../../platform/workspaces/common/workspaces.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { isTemporaryWorkspace, WORKSPACE_EXTENSION, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getWorkspaceIdentifier } from './workspaces.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable {
+    constructor(storageService, contextService, logService, fileService, environmentService, uriIdentityService) {
+        super();
+        this.storageService = storageService;
+        this.contextService = contextService;
+        this.logService = logService;
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.uriIdentityService = uriIdentityService;
+        this._onRecentlyOpenedChange = this._register(( new Emitter()));
+        this.onDidChangeRecentlyOpened = this._onRecentlyOpenedChange.event;
+        this.addWorkspaceToRecentlyOpened();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.storageService.onDidChangeValue(e => this.onDidChangeStorage(e)));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(e => this.onDidChangeWorkspaceFolders(e)));
+    }
+    onDidChangeStorage(e) {
+        if (e.key === BrowserWorkspacesService.RECENTLY_OPENED_KEY && e.scope === -1 ) {
+            this._onRecentlyOpenedChange.fire();
+        }
+    }
+    onDidChangeWorkspaceFolders(e) {
+        if (!isTemporaryWorkspace(this.contextService.getWorkspace())) {
+            return;
+        }
+        for (const folder of e.added) {
+            this.addRecentlyOpened([{ folderUri: folder.uri }]);
+        }
+    }
+    addWorkspaceToRecentlyOpened() {
+        const workspace = this.contextService.getWorkspace();
+        const remoteAuthority = this.environmentService.remoteAuthority;
+        switch (this.contextService.getWorkbenchState()) {
+            case 2 :
+                this.addRecentlyOpened([{ folderUri: workspace.folders[0].uri, remoteAuthority }]);
+                break;
+            case 3 :
+                this.addRecentlyOpened([{ workspace: { id: workspace.id, configPath: workspace.configuration }, remoteAuthority }]);
+                break;
+        }
+    }
+    async getRecentlyOpened() {
+        const recentlyOpenedRaw = this.storageService.get(BrowserWorkspacesService.RECENTLY_OPENED_KEY, -1 );
+        if (recentlyOpenedRaw) {
+            const recentlyOpened = restoreRecentlyOpened(JSON.parse(recentlyOpenedRaw), this.logService);
+            recentlyOpened.workspaces = recentlyOpened.workspaces.filter(recent => {
+                if (isRecentFolder(recent) && recent.folderUri.scheme === Schemas.file && !isTemporaryWorkspace(this.contextService.getWorkspace())) {
+                    return false;
+                }
+                if (isRecentWorkspace(recent) && isTemporaryWorkspace(recent.workspace.configPath)) {
+                    return false;
+                }
+                return true;
+            });
+            return recentlyOpened;
+        }
+        return { workspaces: [], files: [] };
+    }
+    async addRecentlyOpened(recents) {
+        const recentlyOpened = await this.getRecentlyOpened();
+        for (const recent of recents) {
+            if (isRecentFile(recent)) {
+                this.doRemoveRecentlyOpened(recentlyOpened, [recent.fileUri]);
+                recentlyOpened.files.unshift(recent);
+            }
+            else if (isRecentFolder(recent)) {
+                this.doRemoveRecentlyOpened(recentlyOpened, [recent.folderUri]);
+                recentlyOpened.workspaces.unshift(recent);
+            }
+            else {
+                this.doRemoveRecentlyOpened(recentlyOpened, [recent.workspace.configPath]);
+                recentlyOpened.workspaces.unshift(recent);
+            }
+        }
+        return this.saveRecentlyOpened(recentlyOpened);
+    }
+    async removeRecentlyOpened(paths) {
+        const recentlyOpened = await this.getRecentlyOpened();
+        this.doRemoveRecentlyOpened(recentlyOpened, paths);
+        return this.saveRecentlyOpened(recentlyOpened);
+    }
+    doRemoveRecentlyOpened(recentlyOpened, paths) {
+        recentlyOpened.files = recentlyOpened.files.filter(file => {
+            return !( paths.some(path => ( path.toString()) === ( file.fileUri.toString())));
+        });
+        recentlyOpened.workspaces = recentlyOpened.workspaces.filter(workspace => {
+            return !( paths.some(path => ( path.toString()) === (isRecentFolder(workspace) ? ( workspace.folderUri.toString()) : ( workspace.workspace.configPath.toString()))));
+        });
+    }
+    async saveRecentlyOpened(data) {
+        return this.storageService.store(BrowserWorkspacesService.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), -1 , 0 );
+    }
+    async clearRecentlyOpened() {
+        this.storageService.remove(BrowserWorkspacesService.RECENTLY_OPENED_KEY, -1 );
+    }
+    async enterWorkspace(workspaceUri) {
+        return { workspace: await this.getWorkspaceIdentifier(workspaceUri) };
+    }
+    async createUntitledWorkspace(folders, remoteAuthority) {
+        const randomId = ( (Date.now() + Math.round(Math.random() * 1000)).toString());
+        const newUntitledWorkspacePath = joinPath(this.environmentService.untitledWorkspacesHome, `Untitled-${randomId}.${WORKSPACE_EXTENSION}`);
+        const storedWorkspaceFolder = [];
+        if (folders) {
+            for (const folder of folders) {
+                storedWorkspaceFolder.push(getStoredWorkspaceFolder(folder.uri, true, folder.name, this.environmentService.untitledWorkspacesHome, this.uriIdentityService.extUri));
+            }
+        }
+        const storedWorkspace = { folders: storedWorkspaceFolder, remoteAuthority };
+        await this.fileService.writeFile(newUntitledWorkspacePath, VSBuffer.fromString(JSON.stringify(storedWorkspace, null, '\t')));
+        return this.getWorkspaceIdentifier(newUntitledWorkspacePath);
+    }
+    async deleteUntitledWorkspace(workspace) {
+        try {
+            await this.fileService.del(workspace.configPath);
+        }
+        catch (error) {
+            if (error.fileOperationResult !== 1 ) {
+                throw error;
+            }
+        }
+    }
+    async getWorkspaceIdentifier(workspaceUri) {
+        return getWorkspaceIdentifier(workspaceUri);
+    }
+    async getDirtyWorkspaces() {
+        return [];
+    }
+};
+BrowserWorkspacesService.RECENTLY_OPENED_KEY = 'recently.opened';
+BrowserWorkspacesService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, IUriIdentityService))
+], BrowserWorkspacesService));
+export { BrowserWorkspacesService };

package/dist/vscode/vs/workbench/services/workspaces/common/workspaceEditing.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IWorkspaceEditingService = ( createDecorator('workspaceEditingService'));
+export { IWorkspaceEditingService };

package/dist/vscode-default-extensions/bat/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"bat",displayName:"Windows Bat Language Basics",description:"Provides snippets, syntax highlighting, bracket matching and folding in Windows batch files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"^1.52.0"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin mmims/language-batchfile grammars/batchfile.cson ./syntaxes/batchfile.tmLanguage.json"},contributes:{languages:[{id:"bat",extensions:[".bat",".cmd"],aliases:["Batch","bat"],configuration:"./language-configuration.json"}],grammars:[{language:"bat",scopeName:"source.batchfile",path:"./syntaxes/batchfile.tmLanguage.json"}],snippets:[{language:"bat",path:"./snippets/batchfile.code-snippets"}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/clojure/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"clojure",displayName:"Clojure Language Basics",description:"Provides syntax highlighting and bracket matching in Clojure files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"*"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin atom/language-clojure grammars/clojure.cson ./syntaxes/clojure.tmLanguage.json"},contributes:{languages:[{id:"clojure",aliases:["Clojure","clojure"],extensions:[".clj",".cljs",".cljc",".cljx",".clojure",".edn"],configuration:"./language-configuration.json"}],grammars:[{language:"clojure",scopeName:"source.clojure",path:"./syntaxes/clojure.tmLanguage.json"}],configurationDefaults:{"[clojure]":{"diffEditor.ignoreTrimWhitespace":false}}},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/coffeescript/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"coffeescript",displayName:"CoffeeScript Language Basics",description:"Provides snippets, syntax highlighting, bracket matching and folding in CoffeeScript files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"*"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin atom/language-coffee-script grammars/coffeescript.cson ./syntaxes/coffeescript.tmLanguage.json"},contributes:{languages:[{id:"coffeescript",extensions:[".coffee",".cson",".iced"],aliases:["CoffeeScript","coffeescript","coffee"],configuration:"./language-configuration.json"}],grammars:[{language:"coffeescript",scopeName:"source.coffee",path:"./syntaxes/coffeescript.tmLanguage.json"}],breakpoints:[{language:"coffeescript"}],snippets:[{language:"coffeescript",path:"./snippets/coffeescript.code-snippets"}],configurationDefaults:{"[coffeescript]":{"diffEditor.ignoreTrimWhitespace":false}}},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/cpp/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"cpp",displayName:"C/C++ Language Basics",description:"Provides snippets, syntax highlighting, bracket matching and folding in C/C++ files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"*"},scripts:{"update-grammar":"node ./build/update-grammars.js"},contributes:{languages:[{id:"c",extensions:[".c",".i"],aliases:["C","c"],configuration:"./language-configuration.json"},{id:"cpp",extensions:[".cpp",".cc",".cxx",".c++",".hpp",".hh",".hxx",".h++",".h",".ii",".ino",".inl",".ipp",".ixx",".tpp",".txx",".hpp.in",".h.in"],aliases:["C++","Cpp","cpp"],configuration:"./language-configuration.json"},{id:"cuda-cpp",extensions:[".cu",".cuh"],aliases:["CUDA C++"],configuration:"./language-configuration.json"}],grammars:[{language:"c",scopeName:"source.c",path:"./syntaxes/c.tmLanguage.json"},{language:"cpp",scopeName:"source.cpp.embedded.macro",path:"./syntaxes/cpp.embedded.macro.tmLanguage.json"},{language:"cpp",scopeName:"source.cpp",path:"./syntaxes/cpp.tmLanguage.json"},{scopeName:"source.c.platform",path:"./syntaxes/platform.tmLanguage.json"},{language:"cuda-cpp",scopeName:"source.cuda-cpp",path:"./syntaxes/cuda-cpp.tmLanguage.json"}],problemPatterns:[{name:"nvcc-location",regexp:"^(.*)\\((\\d+)\\):\\s+(warning|error):\\s+(.*)",kind:"location",file:1,location:2,severity:3,message:4}],problemMatchers:[{name:"nvcc",owner:"cuda-cpp",fileLocation:["relative","${workspaceFolder}"],pattern:"$nvcc-location"}],snippets:[{language:"c",path:"./snippets/c.code-snippets"},{language:"cpp",path:"./snippets/cpp.code-snippets"}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/csharp/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"csharp",displayName:"C# Language Basics",description:"Provides snippets, syntax highlighting, bracket matching and folding in C# files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"0.10.x"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin dotnet/csharp-tmLanguage grammars/csharp.tmLanguage ./syntaxes/csharp.tmLanguage.json"},contributes:{configurationDefaults:{"[csharp]":{"editor.maxTokenizationLineLength":2500}},languages:[{id:"csharp",extensions:[".cs",".csx",".cake"],aliases:["C#","csharp"],configuration:"./language-configuration.json"}],grammars:[{language:"csharp",scopeName:"source.cs",path:"./syntaxes/csharp.tmLanguage.json"}],snippets:[{language:"csharp",path:"./snippets/csharp.code-snippets"}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/css/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"css",displayName:"CSS Language Basics",description:"Provides syntax highlighting and bracket matching for CSS, LESS and SCSS files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"0.10.x"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin microsoft/vscode-css grammars/css.cson ./syntaxes/css.tmLanguage.json"},contributes:{languages:[{id:"css",aliases:["CSS","css"],extensions:[".css"],mimetypes:["text/css"],configuration:"./language-configuration.json"}],grammars:[{language:"css",scopeName:"source.css",path:"./syntaxes/css.tmLanguage.json",tokenTypes:{"meta.function.url string.quoted":"other"}}]},repository:{type:"git",url:"https://github.com/microsoft/vscode.git"}};
+export { manifest as default };

package/dist/vscode-default-extensions/dart/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"dart",displayName:"Dart Language Basics",description:"Provides syntax highlighting & bracket matching in Dart files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"0.10.x"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin dart-lang/dart-syntax-highlight grammars/dart.json ./syntaxes/dart.tmLanguage.json"},contributes:{languages:[{id:"dart",extensions:[".dart"],aliases:["Dart"],configuration:"./language-configuration.json"}],grammars:[{language:"dart",scopeName:"source.dart",path:"./syntaxes/dart.tmLanguage.json"}]}};
+export { manifest as default };

package/dist/vscode-default-extensions/diff/package.json.js

@@ -0,0 +1,2 @@
+var manifest = {name:"diff",displayName:"Diff Language Basics",description:"Provides syntax highlighting & bracket matching in Diff files.",version:"1.0.0",publisher:"vscode",license:"MIT",engines:{vscode:"0.10.x"},scripts:{"update-grammar":"node ../node_modules/vscode-grammar-updater/bin textmate/diff.tmbundle Syntaxes/Diff.plist ./syntaxes/diff.tmLanguage.json"},contributes:{languages:[{id:"diff",aliases:["Diff","diff"],extensions:[".diff",".patch",".rej"],configuration:"./language-configuration.json"}],grammars:[{language:"diff",scopeName:"source.diff",path:"./syntaxes/diff.tmLanguage.json"}]}};
+export { manifest as default };