@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,322 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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, 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 '../../../../../../../override/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';
-import { IFileDialogService, IDialogService } from '../../../../platform/dialogs/common/dialogs.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();
-        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/vscode/src/vs/workbench/services/workspaces/browser/workspaceTrustEditorInput.js

@@ -1,27 +0,0 @@
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { EditorInput } from '../../../common/editor/editorInput.js';
-class WorkspaceTrustEditorInput extends EditorInput {
-    constructor() {
-        super(...arguments);
-        this.resource = ( URI.from({
-            scheme: Schemas.vscodeWorkspaceTrust,
-            path: `workspaceTrustEditor`
-        }));
-    }
-    static { this.ID = 'workbench.input.workspaceTrust'; }
-    get capabilities() {
-        return 2  | 8 ;
-    }
-    get typeId() {
-        return WorkspaceTrustEditorInput.ID;
-    }
-    matches(otherInput) {
-        return super.matches(otherInput) || otherInput instanceof WorkspaceTrustEditorInput;
-    }
-    getName() {
-        return ( localize('workspaceTrustEditorInputName', "Workspace Trust"));
-    }
-}
-export { WorkspaceTrustEditorInput };

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

@@ -1,151 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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, DisposableStore } 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';
-var BrowserWorkspacesService_1;
-let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable {
-    static { BrowserWorkspacesService_1 = this; }
-    static { this.RECENTLY_OPENED_KEY = 'recently.opened'; }
-    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(-1 , BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, this._register(( new DisposableStore())))(() => this._onRecentlyOpenedChange.fire()));
-        this._register(this.contextService.onDidChangeWorkspaceFolders(e => this.onDidChangeWorkspaceFolders(e)));
-    }
-    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_1.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_1.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), -1 , 0 );
-    }
-    async clearRecentlyOpened() {
-        this.storageService.remove(BrowserWorkspacesService_1.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 = BrowserWorkspacesService_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IFileService)),
-    ( __param(4, IWorkbenchEnvironmentService)),
-    ( __param(5, IUriIdentityService))
-], BrowserWorkspacesService));
-export { BrowserWorkspacesService };

package/workers/languageDetection.worker.js

@@ -1,8 +0,0 @@
-import { create } from '../vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.js';
-import { SimpleWorkerServer } from 'monaco-editor/esm/vs/base/common/worker/simpleWorker.js';
-const simpleWorker = new SimpleWorkerServer((msg) => {
-    globalThis.postMessage(msg);
-}, create);
-globalThis.onmessage = (e) => {
-    simpleWorker.onmessage(e.data);
-};

package/workers/outputLinkComputer.worker.js

@@ -1,3 +0,0 @@
-import { initialize } from 'monaco-editor/esm/vs/editor/editor.worker.js';
-import { OutputLinkComputer } from '../vscode/src/vs/workbench/contrib/output/common/outputLinkComputer.js';
-initialize((ctx, createData) => new OutputLinkComputer(ctx, createData));

package/workers/textmate.worker.js

@@ -1,3 +0,0 @@
-import { TextMateTokenizationWorker } from '../vscode/src/vs/workbench/services/textMate/browser/backgroundTokenization/worker/textMateTokenizationWorker.worker.js';
-import { initialize } from 'monaco-editor/esm/vs/editor/editor.worker.js';
-initialize((ctx, createData) => new TextMateTokenizationWorker(ctx, createData));