@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/platform/terminal/common/terminalProfiles.js

@@ -0,0 +1,107 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+function createProfileSchemaEnums(detectedProfiles, extensionProfiles) {
+    const result = [{
+            name: null,
+            description: ( localize('terminalAutomaticProfile', 'Automatically detect the default'))
+        }];
+    result.push(...( detectedProfiles.map(e => {
+        return {
+            name: e.profileName,
+            description: createProfileDescription(e)
+        };
+    })));
+    if (extensionProfiles) {
+        result.push(...( extensionProfiles.map(extensionProfile => {
+            return {
+                name: extensionProfile.title,
+                description: createExtensionProfileDescription(extensionProfile)
+            };
+        })));
+    }
+    return {
+        values: ( result.map(e => e.name)),
+        markdownDescriptions: ( result.map(e => e.description))
+    };
+}
+function createProfileDescription(profile) {
+    let description = `$(${ThemeIcon.isThemeIcon(profile.icon) ? profile.icon.id : profile.icon ? profile.icon : Codicon.terminal.id}) ${profile.profileName}\n- path: ${profile.path}`;
+    if (profile.args) {
+        if (typeof profile.args === 'string') {
+            description += `\n- args: "${profile.args}"`;
+        }
+        else {
+            description += `\n- args: [${profile.args.length === 0 ? '' : `'${profile.args.join(`','`)}'`}]`;
+        }
+    }
+    if (profile.overrideName !== undefined) {
+        description += `\n- overrideName: ${profile.overrideName}`;
+    }
+    if (profile.color) {
+        description += `\n- color: ${profile.color}`;
+    }
+    if (profile.env) {
+        description += `\n- env: ${JSON.stringify(profile.env)}`;
+    }
+    return description;
+}
+function createExtensionProfileDescription(profile) {
+    const description = `$(${ThemeIcon.isThemeIcon(profile.icon) ? profile.icon.id : profile.icon ? profile.icon : Codicon.terminal.id}) ${profile.title}\n- extensionIdentifier: ${profile.extensionIdentifier}`;
+    return description;
+}
+function terminalProfileArgsMatch(args1, args2) {
+    if (!args1 && !args2) {
+        return true;
+    }
+    else if (typeof args1 === 'string' && typeof args2 === 'string') {
+        return args1 === args2;
+    }
+    else if (Array.isArray(args1) && Array.isArray(args2)) {
+        if (args1.length !== args2.length) {
+            return false;
+        }
+        for (let i = 0; i < args1.length; i++) {
+            if (args1[i] !== args2[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function terminalIconsEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    else if (!a || !b) {
+        return false;
+    }
+    if (ThemeIcon.isThemeIcon(a) && ThemeIcon.isThemeIcon(b)) {
+        return a.id === b.id && a.color === b.color;
+    }
+    if (typeof a === 'object' && 'light' in a && 'dark' in a
+        && typeof b === 'object' && 'light' in b && 'dark' in b) {
+        const castedA = a;
+        const castedB = b;
+        if ((URI.isUri(castedA.light) || isUriComponents(castedA.light)) && (URI.isUri(castedA.dark) || isUriComponents(castedA.dark))
+            && (URI.isUri(castedB.light) || isUriComponents(castedB.light)) && (URI.isUri(castedB.dark) || isUriComponents(castedB.dark))) {
+            return castedA.light.path === castedB.light.path && castedA.dark.path === castedB.dark.path;
+        }
+    }
+    if ((URI.isUri(a) && URI.isUri(b)) || (isUriComponents(a) || isUriComponents(b))) {
+        const castedA = a;
+        const castedB = b;
+        return castedA.path === castedB.path && castedA.scheme === castedB.scheme;
+    }
+    return false;
+}
+function isUriComponents(thing) {
+    if (!thing) {
+        return false;
+    }
+    return typeof thing.path === 'string' &&
+        typeof thing.scheme === 'string';
+}
+export { createProfileSchemaEnums, isUriComponents, terminalIconsEqual, terminalProfileArgsMatch };

package/dist/vscode/vs/platform/terminal/common/terminalRecorder.js

@@ -0,0 +1,66 @@
+class TerminalRecorder {
+    constructor(cols, rows) {
+        this._totalDataLength = 0;
+        this._entries = [{ cols, rows, data: [] }];
+    }
+    handleResize(cols, rows) {
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.data.length === 0) {
+                this._entries.pop();
+            }
+        }
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.cols === cols && lastEntry.rows === rows) {
+                return;
+            }
+            if (lastEntry.cols === 0 && lastEntry.rows === 0) {
+                lastEntry.cols = cols;
+                lastEntry.rows = rows;
+                return;
+            }
+        }
+        this._entries.push({ cols, rows, data: [] });
+    }
+    handleData(data) {
+        const lastEntry = this._entries[this._entries.length - 1];
+        lastEntry.data.push(data);
+        this._totalDataLength += data.length;
+        while (this._totalDataLength > 1048576 ) {
+            const firstEntry = this._entries[0];
+            const remainingToDelete = this._totalDataLength - 1048576 ;
+            if (remainingToDelete >= firstEntry.data[0].length) {
+                this._totalDataLength -= firstEntry.data[0].length;
+                firstEntry.data.shift();
+                if (firstEntry.data.length === 0) {
+                    this._entries.shift();
+                }
+            }
+            else {
+                firstEntry.data[0] = firstEntry.data[0].substr(remainingToDelete);
+                this._totalDataLength -= remainingToDelete;
+            }
+        }
+    }
+    generateReplayEventSync() {
+        this._entries.forEach((entry) => {
+            if (entry.data.length > 0) {
+                entry.data = [entry.data.join('')];
+            }
+        });
+        return {
+            events: ( this._entries.map(
+                entry => ({ cols: entry.cols, rows: entry.rows, data: entry.data[0] ?? '' })
+            )),
+            commands: {
+                isWindowsPty: false,
+                commands: []
+            }
+        };
+    }
+    async generateReplayEvent() {
+        return this.generateReplayEventSync();
+    }
+}
+export { TerminalRecorder };

package/dist/vscode/vs/platform/terminal/common/terminalStrings.js

@@ -0,0 +1,16 @@
+function formatMessageForTerminal(message, options = {}) {
+    let result = '';
+    if (!options.excludeLeadingNewLine) {
+        result += '\r\n';
+    }
+    result += '\x1b[0m\x1b[7m * ';
+    if (options.loudFormatting) {
+        result += '\x1b[0;104m';
+    }
+    else {
+        result += '\x1b[0m';
+    }
+    result += ` ${message} \x1b[0m\n\r`;
+    return result;
+}
+export { formatMessageForTerminal };

package/dist/vscode/vs/platform/terminal/common/xterm/shellIntegrationAddon.js

@@ -0,0 +1,321 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TerminalCapabilityStore } from '../capabilities/terminalCapabilityStore.js';
+import { CommandDetectionCapability } from '../capabilities/commandDetectionCapability.js';
+import { CwdDetectionCapability } from '../capabilities/cwdDetectionCapability.js';
+import { PartialCommandDetectionCapability } from '../capabilities/partialCommandDetectionCapability.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { BufferMarkCapability } from '../capabilities/bufferMarkCapability.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { sanitizeCwd } from '../terminalEnvironment.js';
+let ShellIntegrationAddon = class ShellIntegrationAddon extends Disposable {
+    get status() { return this._status; }
+    constructor(_nonce, _disableTelemetry, _telemetryService, _logService) {
+        super();
+        this._nonce = _nonce;
+        this._disableTelemetry = _disableTelemetry;
+        this._telemetryService = _telemetryService;
+        this._logService = _logService;
+        this.capabilities = ( new TerminalCapabilityStore());
+        this._hasUpdatedTelemetry = false;
+        this._commonProtocolDisposables = [];
+        this._status = 0 ;
+        this._onDidChangeStatus = ( new Emitter());
+        this.onDidChangeStatus = this._onDidChangeStatus.event;
+        this._register(toDisposable(() => {
+            this._clearActivationTimeout();
+            this._disposeCommonProtocol();
+        }));
+    }
+    _disposeCommonProtocol() {
+        dispose(this._commonProtocolDisposables);
+        this._commonProtocolDisposables.length = 0;
+    }
+    activate(xterm) {
+        this._terminal = xterm;
+        this.capabilities.add(3 , ( new PartialCommandDetectionCapability(this._terminal)));
+        this._register(xterm.parser.registerOscHandler(633 , data => this._handleVSCodeSequence(data)));
+        this._register(xterm.parser.registerOscHandler(1337 , data => this._doHandleITermSequence(data)));
+        this._commonProtocolDisposables.push(xterm.parser.registerOscHandler(133 , data => this._handleFinalTermSequence(data)));
+        this._register(xterm.parser.registerOscHandler(7 , data => this._doHandleSetCwd(data)));
+        this._register(xterm.parser.registerOscHandler(9 , data => this._doHandleSetWindowsFriendlyCwd(data)));
+        this._ensureCapabilitiesOrAddFailureTelemetry();
+    }
+    _handleFinalTermSequence(data) {
+        const didHandle = this._doHandleFinalTermSequence(data);
+        if (this._status === 0 ) {
+            this._status = 1 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    _doHandleFinalTermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case 'A':
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case 'B':
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart({ ignoreCommandLine: true });
+                return true;
+            case 'C':
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case 'D': {
+                const exitCode = args.length === 1 ? parseInt(args[0]) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+        }
+        return false;
+    }
+    _handleVSCodeSequence(data) {
+        const didHandle = this._doHandleVSCodeSequence(data);
+        if (!this._hasUpdatedTelemetry && didHandle) {
+            this._telemetryService?.publicLog2('terminal/shellIntegrationActivationSucceeded');
+            this._hasUpdatedTelemetry = true;
+            this._clearActivationTimeout();
+        }
+        if (this._status !== 2 ) {
+            this._status = 2 ;
+            this._onDidChangeStatus.fire(this._status);
+        }
+        return didHandle;
+    }
+    async _ensureCapabilitiesOrAddFailureTelemetry() {
+        if (!this._telemetryService || this._disableTelemetry) {
+            return;
+        }
+        this._activationTimeout = setTimeout(() => {
+            if (!this.capabilities.get(2 ) && !this.capabilities.get(0 )) {
+                this._telemetryService?.publicLog2('terminal/shellIntegrationActivationTimeout');
+                this._logService.warn('Shell integration failed to add capabilities within 10 seconds');
+            }
+            this._hasUpdatedTelemetry = true;
+        }, 10000);
+    }
+    _clearActivationTimeout() {
+        if (this._activationTimeout !== undefined) {
+            clearTimeout(this._activationTimeout);
+            this._activationTimeout = undefined;
+        }
+    }
+    _doHandleVSCodeSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const argsIndex = data.indexOf(';');
+        const sequenceCommand = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        const args = argsIndex === -1 ? [] : data.substring(argsIndex + 1).split(';');
+        switch (sequenceCommand) {
+            case "A" :
+                this._createOrGetCommandDetection(this._terminal).handlePromptStart();
+                return true;
+            case "B" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandStart();
+                return true;
+            case "C" :
+                this._createOrGetCommandDetection(this._terminal).handleCommandExecuted();
+                return true;
+            case "D" : {
+                const arg0 = args[0];
+                const exitCode = arg0 !== undefined ? parseInt(arg0) : undefined;
+                this._createOrGetCommandDetection(this._terminal).handleCommandFinished(exitCode);
+                return true;
+            }
+            case "E" : {
+                const arg0 = args[0];
+                const arg1 = args[1];
+                let commandLine;
+                if (arg0 !== undefined) {
+                    commandLine = deserializeMessage(arg0);
+                }
+                else {
+                    commandLine = '';
+                }
+                this._createOrGetCommandDetection(this._terminal).setCommandLine(commandLine, arg1 === this._nonce);
+                return true;
+            }
+            case "F" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationStart();
+                return true;
+            }
+            case "G" : {
+                this._createOrGetCommandDetection(this._terminal).handleContinuationEnd();
+                return true;
+            }
+            case "H" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptStart();
+                return true;
+            }
+            case "I" : {
+                this._createOrGetCommandDetection(this._terminal).handleRightPromptEnd();
+                return true;
+            }
+            case "P" : {
+                const arg0 = args[0];
+                const deserialized = arg0 !== undefined ? deserializeMessage(arg0) : '';
+                const { key, value } = parseKeyValueAssignment(deserialized);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case 'Cwd': {
+                        this._updateCwd(value);
+                        return true;
+                    }
+                    case 'IsWindows': {
+                        this._createOrGetCommandDetection(this._terminal).setIsWindowsPty(value === 'True' ? true : false);
+                        return true;
+                    }
+                    case 'Task': {
+                        this._createOrGetBufferMarkDetection(this._terminal);
+                        this.capabilities.get(2 )?.setIsCommandStorageDisabled();
+                        return true;
+                    }
+                }
+            }
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark(parseMarkSequence(args));
+                return true;
+            }
+        }
+        return false;
+    }
+    _updateCwd(value) {
+        value = sanitizeCwd(value);
+        this._createOrGetCwdDetection().updateCwd(value);
+        const commandDetection = this.capabilities.get(2 );
+        commandDetection?.setCwd(value);
+    }
+    _doHandleITermSequence(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        switch (command) {
+            case "SetMark" : {
+                this._createOrGetBufferMarkDetection(this._terminal).addMark();
+            }
+            default: {
+                const { key, value } = parseKeyValueAssignment(command);
+                if (value === undefined) {
+                    return true;
+                }
+                switch (key) {
+                    case "CurrentDir" :
+                        this._updateCwd(value);
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    _doHandleSetWindowsFriendlyCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command, ...args] = data.split(';');
+        switch (command) {
+            case '9':
+                if (args.length) {
+                    this._updateCwd(args[0]);
+                }
+                return true;
+        }
+        return false;
+    }
+    _doHandleSetCwd(data) {
+        if (!this._terminal) {
+            return false;
+        }
+        const [command] = data.split(';');
+        if (command.match(/^file:\/\/.*\//)) {
+            const uri = ( URI.parse(command));
+            if (uri.path && uri.path.length > 0) {
+                this._updateCwd(uri.path);
+                return true;
+            }
+        }
+        return false;
+    }
+    serialize() {
+        if (!this._terminal || !( this.capabilities.has(2 ))) {
+            return {
+                isWindowsPty: false,
+                commands: []
+            };
+        }
+        const result = this._createOrGetCommandDetection(this._terminal).serialize();
+        return result;
+    }
+    deserialize(serialized) {
+        if (!this._terminal) {
+            throw new Error('Cannot restore commands before addon is activated');
+        }
+        this._createOrGetCommandDetection(this._terminal).deserialize(serialized);
+    }
+    _createOrGetCwdDetection() {
+        let cwdDetection = this.capabilities.get(0 );
+        if (!cwdDetection) {
+            cwdDetection = ( new CwdDetectionCapability());
+            this.capabilities.add(0 , cwdDetection);
+        }
+        return cwdDetection;
+    }
+    _createOrGetCommandDetection(terminal) {
+        let commandDetection = this.capabilities.get(2 );
+        if (!commandDetection) {
+            commandDetection = ( new CommandDetectionCapability(terminal, this._logService));
+            this.capabilities.add(2 , commandDetection);
+        }
+        return commandDetection;
+    }
+    _createOrGetBufferMarkDetection(terminal) {
+        let bufferMarkDetection = this.capabilities.get(4 );
+        if (!bufferMarkDetection) {
+            bufferMarkDetection = ( new BufferMarkCapability(terminal));
+            this.capabilities.add(4 , bufferMarkDetection);
+        }
+        return bufferMarkDetection;
+    }
+};
+ShellIntegrationAddon = ( __decorate([
+    ( __param(3, ILogService))
+], ShellIntegrationAddon));
+function deserializeMessage(message) {
+    return message.replaceAll(
+    /\\(\\|x([0-9a-f]{2}))/gi,
+    (_match, op, hex) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
+}
+function parseKeyValueAssignment(message) {
+    const separatorIndex = message.indexOf('=');
+    if (separatorIndex === -1) {
+        return { key: message, value: undefined };
+    }
+    return {
+        key: message.substring(0, separatorIndex),
+        value: message.substring(1 + separatorIndex)
+    };
+}
+function parseMarkSequence(sequence) {
+    let id = undefined;
+    let hidden = false;
+    for (const property of sequence) {
+        if (property === undefined) {
+            continue;
+        }
+        if (property === 'Hidden') {
+            hidden = true;
+        }
+        if (property.startsWith('Id=')) {
+            id = property.substring(3);
+        }
+    }
+    return { id, hidden };
+}
+export { ShellIntegrationAddon, deserializeMessage, parseKeyValueAssignment, parseMarkSequence };

package/dist/vscode/vs/platform/userDataSync/common/settingsMerge.js

@@ -1,7 +1,45 @@
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { parse, visit } from 'monaco-editor/esm/vs/base/common/json.js';
 import { setProperty, applyEdits, withFormatting } from '../../../base/common/jsonEdit.js';
 import { getEOL } from '../../../base/common/jsonFormatter.js';
 import { edit } from './content.js';
+import { getDisallowedIgnoredSettings } from './userDataSync.js';
+function getIgnoredSettings(defaultIgnoredSettings, configurationService, settingsContent) {
+    let value = [];
+    if (settingsContent) {
+        value = getIgnoredSettingsFromContent(settingsContent);
+    }
+    else {
+        value = getIgnoredSettingsFromConfig(configurationService);
+    }
+    const added = [], removed = [...getDisallowedIgnoredSettings()];
+    if (Array.isArray(value)) {
+        for (const key of value) {
+            if (key.startsWith('-')) {
+                removed.push(key.substring(1));
+            }
+            else {
+                added.push(key);
+            }
+        }
+    }
+    return distinct([...defaultIgnoredSettings, ...added,].filter(setting => !removed.includes(setting)));
+}
+function getIgnoredSettingsFromConfig(configurationService) {
+    let userValue = configurationService.inspect('settingsSync.ignoredSettings').userValue;
+    if (userValue !== undefined) {
+        return userValue;
+    }
+    userValue = configurationService.inspect('sync.ignoredSettings').userValue;
+    if (userValue !== undefined) {
+        return userValue;
+    }
+    return configurationService.getValue('settingsSync.ignoredSettings') || [];
+}
+function getIgnoredSettingsFromContent(settingsContent) {
+    const parsed = parse(settingsContent);
+    return parsed ? parsed['settingsSync.ignoredSettings'] || parsed['sync.ignoredSettings'] || [] : [];
+}
 function updateIgnoredSettings(targetContent, sourceContent, ignoredSettings, formattingOptions) {
     if (ignoredSettings.length) {
         const sourceTree = parseSettings(sourceContent);
@@ -296,4 +334,4 @@ function parseSettings(content) {
     visit(content, visitor);
     return nodes;
 }
-export { addSetting, updateIgnoredSettings };
+export { addSetting, getIgnoredSettings, updateIgnoredSettings };

package/dist/vscode/vs/platform/userDataSync/common/userDataSync.js

@@ -0,0 +1,19 @@
+import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+const CONFIGURATION_SYNC_STORE_KEY = 'configurationSync.store';
+function getDisallowedIgnoredSettings() {
+    const allSettings = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+    return ( Object.keys(allSettings)).filter(setting => !!allSettings[setting].disallowSyncIgnore);
+}
+function getDefaultIgnoredSettings() {
+    const allSettings = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
+    const ignoreSyncSettings = ( Object.keys(allSettings)).filter(setting => !!allSettings[setting].ignoreSync);
+    const machineSettings = ( Object.keys(allSettings)).filter(setting => allSettings[setting].scope === 2  || allSettings[setting].scope === 6 );
+    const disallowedSettings = getDisallowedIgnoredSettings();
+    return distinct([CONFIGURATION_SYNC_STORE_KEY, ...ignoreSyncSettings, ...machineSettings, ...disallowedSettings]);
+}
+const IUserDataSyncEnablementService = ( createDecorator('IUserDataSyncEnablementService'));
+const IUserDataSyncService = ( createDecorator('IUserDataSyncService'));
+export { CONFIGURATION_SYNC_STORE_KEY, IUserDataSyncEnablementService, IUserDataSyncService, getDefaultIgnoredSettings, getDisallowedIgnoredSettings };

package/dist/vscode/vs/platform/window/common/window.js

@@ -1,4 +1,10 @@
 import { isMacintosh, isNative, isWeb, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
+function isWorkspaceToOpen(uriToOpen) {
+    return !!uriToOpen.workspaceUri;
+}
+function isFileToOpen(uriToOpen) {
+    return !!uriToOpen.fileUri;
+}
 function getMenuBarVisibility(configurationService) {
     const titleBarStyle = getTitleBarStyle(configurationService);
     const menuBarVisibility = configurationService.getValue('window.menuBarVisibility');
@@ -30,4 +36,4 @@ function getTitleBarStyle(configurationService) {
     }
     return isLinux ? 'native' : 'custom';
 }
-export { getMenuBarVisibility, getTitleBarStyle };
+export { getMenuBarVisibility, getTitleBarStyle, isFileToOpen, isWorkspaceToOpen };

package/dist/vscode/vs/platform/workspace/common/canonicalUri.js

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

package/dist/vscode/vs/platform/workspace/common/virtualWorkspace.js

@@ -14,4 +14,7 @@ function getVirtualWorkspaceLocation(workspace) {
 function getVirtualWorkspaceScheme(workspace) {
     return getVirtualWorkspaceLocation(workspace)?.scheme;
 }
-export { getVirtualWorkspaceLocation, getVirtualWorkspaceScheme, isVirtualResource };
+function isVirtualWorkspace(workspace) {
+    return getVirtualWorkspaceLocation(workspace) !== undefined;
+}
+export { getVirtualWorkspaceLocation, getVirtualWorkspaceScheme, isVirtualResource, isVirtualWorkspace };

package/dist/vscode/vs/platform/workspaces/common/workspaces.js

@@ -1,5 +1,5 @@
 import { isUNC, toSlashes } from 'monaco-editor/esm/vs/base/common/extpath.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { setProperty, applyEdits, removeProperty } from '../../../base/common/jsonEdit.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
@@ -127,7 +127,7 @@ function rewriteWorkspaceFileForNewLocation(rawWorkspaceContents, configPathURI,
     return newContent;
 }
 function doParseStoredWorkspace(path, contents) {
-    const storedWorkspace = Json.parse(contents);
+    const storedWorkspace = json.parse(contents);
     if (storedWorkspace && Array.isArray(storedWorkspace.folders)) {
         storedWorkspace.folders = storedWorkspace.folders.filter(folder => isStoredWorkspaceFolder(folder));
     }

package/dist/vscode/vs/workbench/api/browser/mainThreadCommands.js

@@ -2,11 +2,10 @@ import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6
 import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IExtensionService } from '../../services/extensions/common/extensions.js';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IExtensionService } from '../../services/extensions/common/extensions.js';
 import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
 let MainThreadCommands = class MainThreadCommands {
     constructor(extHostContext, _commandService, _extensionService) {
         this._commandService = _commandService;
@@ -37,7 +36,7 @@ let MainThreadCommands = class MainThreadCommands {
         this._commandRegistrations.set(id, CommandsRegistry.registerCommand(id, (accessor, ...args) => {
             return this._proxy.$executeContributedCommand(id, ...args).then(result => {
                 return revive(result);
-            }, onUnexpectedExternalError);
+            });
         }));
     }
     $unregisterCommand(id) {