@codingame/monaco-vscode-api 9.0.3 → 10.0.0

package/vscode/src/vs/platform/remote/common/remoteAgentConnection.js

@@ -8,22 +8,16 @@ import { RemoteAuthorities } from '../../../base/common/network.js';
 import { mark } from '../../../base/common/performance.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { generateUuid } from '../../../base/common/uuid.js';
-import { SocketCloseEventType, Client, PersistentProtocol } from '../../../base/parts/ipc/common/ipc.net.js';
+import { Client, PersistentProtocol } from '../../../base/parts/ipc/common/ipc.net.js';
 import { RemoteAuthorityResolverError } from './remoteAuthorityResolver.js';
 const RECONNECT_TIMEOUT = 30 * 1000 ;
-var ConnectionType;
-( (function(ConnectionType) {
-    ConnectionType[ConnectionType["Management"] = 1] = "Management";
-    ConnectionType[ConnectionType["ExtensionHost"] = 2] = "ExtensionHost";
-    ConnectionType[ConnectionType["Tunnel"] = 3] = "Tunnel";
-})(ConnectionType || (ConnectionType = {})));
 function connectionTypeToString(connectionType) {
     switch (connectionType) {
-        case ConnectionType.Management:
+        case 1 :
             return 'Management';
-        case ConnectionType.ExtensionHost:
+        case 2 :
             return 'ExtensionHost';
-        case ConnectionType.Tunnel:
+        case 3 :
             return 'Tunnel';
     }
 }
@@ -246,11 +240,11 @@ async function connectToRemoteExtensionHostAgentAndReadOneMessage(options, conne
     return result.promise;
 }
 async function doConnectRemoteAgentManagement(options, timeoutCancellationToken) {
-    const { protocol } = await connectToRemoteExtensionHostAgentAndReadOneMessage(options, ConnectionType.Management, undefined, timeoutCancellationToken);
+    const { protocol } = await connectToRemoteExtensionHostAgentAndReadOneMessage(options, 1 , undefined, timeoutCancellationToken);
     return { protocol };
 }
 async function doConnectRemoteAgentExtensionHost(options, startArguments, timeoutCancellationToken) {
-    const { protocol, firstMessage } = await connectToRemoteExtensionHostAgentAndReadOneMessage(options, ConnectionType.ExtensionHost, startArguments, timeoutCancellationToken);
+    const { protocol, firstMessage } = await connectToRemoteExtensionHostAgentAndReadOneMessage(options, 2 , startArguments, timeoutCancellationToken);
     const debugPort = firstMessage && firstMessage.debugPort;
     return { protocol, debugPort };
 }
@@ -326,19 +320,11 @@ function sleep(seconds) {
         }));
     });
 }
-var PersistentConnectionEventType;
-( (function(PersistentConnectionEventType) {
-    PersistentConnectionEventType[PersistentConnectionEventType["ConnectionLost"] = 0] = "ConnectionLost";
-    PersistentConnectionEventType[PersistentConnectionEventType["ReconnectionWait"] = 1] = "ReconnectionWait";
-    PersistentConnectionEventType[PersistentConnectionEventType["ReconnectionRunning"] = 2] = "ReconnectionRunning";
-    PersistentConnectionEventType[PersistentConnectionEventType["ReconnectionPermanentFailure"] = 3] = "ReconnectionPermanentFailure";
-    PersistentConnectionEventType[PersistentConnectionEventType["ConnectionGain"] = 4] = "ConnectionGain";
-})(PersistentConnectionEventType || (PersistentConnectionEventType = {})));
 class ConnectionLostEvent {
     constructor(reconnectionToken, millisSinceLastIncomingData) {
         this.reconnectionToken = reconnectionToken;
         this.millisSinceLastIncomingData = millisSinceLastIncomingData;
-        this.type = PersistentConnectionEventType.ConnectionLost;
+        this.type = 0 ;
     }
 }
 class ReconnectionWaitEvent {
@@ -347,7 +333,7 @@ class ReconnectionWaitEvent {
         this.millisSinceLastIncomingData = millisSinceLastIncomingData;
         this.durationSeconds = durationSeconds;
         this.cancellableTimer = cancellableTimer;
-        this.type = PersistentConnectionEventType.ReconnectionWait;
+        this.type = 1 ;
     }
     skipWait() {
         this.cancellableTimer.cancel();
@@ -358,7 +344,7 @@ class ReconnectionRunningEvent {
         this.reconnectionToken = reconnectionToken;
         this.millisSinceLastIncomingData = millisSinceLastIncomingData;
         this.attempt = attempt;
-        this.type = PersistentConnectionEventType.ReconnectionRunning;
+        this.type = 2 ;
     }
 }
 class ConnectionGainEvent {
@@ -366,7 +352,7 @@ class ConnectionGainEvent {
         this.reconnectionToken = reconnectionToken;
         this.millisSinceLastIncomingData = millisSinceLastIncomingData;
         this.attempt = attempt;
-        this.type = PersistentConnectionEventType.ConnectionGain;
+        this.type = 4 ;
     }
 }
 class ReconnectionPermanentFailureEvent {
@@ -375,7 +361,7 @@ class ReconnectionPermanentFailureEvent {
         this.millisSinceLastIncomingData = millisSinceLastIncomingData;
         this.attempt = attempt;
         this.handled = handled;
-        this.type = PersistentConnectionEventType.ReconnectionPermanentFailure;
+        this.type = 3 ;
     }
 }
 class PersistentConnection extends Disposable {
@@ -418,7 +404,7 @@ class PersistentConnection extends Disposable {
             if (!e) {
                 this._options.logService.info(`${logPrefix} received socket close event.`);
             }
-            else if (e.type === SocketCloseEventType.NodeSocketCloseEvent) {
+            else if (e.type === 0 ) {
                 this._options.logService.info(`${logPrefix} received socket close event (hadError: ${e.hadError}).`);
                 if (e.error) {
                     this._options.logService.error(e.error);
@@ -571,7 +557,7 @@ class PersistentConnection extends Disposable {
 }
 class ManagementPersistentConnection extends PersistentConnection {
     constructor(options, remoteAuthority, clientId, reconnectionToken, protocol) {
-        super(ConnectionType.Management, options, reconnectionToken, protocol,  true);
+        super(1 , options, reconnectionToken, protocol,  true);
         this.client = this._register(( new Client(protocol, {
             remoteAuthority: remoteAuthority,
             clientId: clientId
@@ -583,7 +569,7 @@ class ManagementPersistentConnection extends PersistentConnection {
 }
 class ExtensionHostPersistentConnection extends PersistentConnection {
     constructor(options, startArguments, reconnectionToken, protocol, debugPort) {
-        super(ConnectionType.ExtensionHost, options, reconnectionToken, protocol,  false);
+        super(2 , options, reconnectionToken, protocol,  false);
         this._startArguments = startArguments;
         this.debugPort = debugPort;
     }
@@ -628,4 +614,4 @@ function connectLogPrefix(options, connectionType) {
 function logElapsed(startTime) {
     return `${Date.now() - startTime} ms`;
 }
-export { ConnectionGainEvent, ConnectionLostEvent, ConnectionType, ExtensionHostPersistentConnection, ManagementPersistentConnection, PersistentConnection, PersistentConnectionEventType, ReconnectionPermanentFailureEvent, ReconnectionRunningEvent, ReconnectionWaitEvent, connectRemoteAgentExtensionHost, connectRemoteAgentManagement };
+export { ConnectionGainEvent, ConnectionLostEvent, ExtensionHostPersistentConnection, ManagementPersistentConnection, PersistentConnection, ReconnectionPermanentFailureEvent, ReconnectionRunningEvent, ReconnectionWaitEvent, connectRemoteAgentExtensionHost, connectRemoteAgentManagement };

package/vscode/src/vs/platform/remote/common/remoteAuthorityResolver.js

@@ -1,13 +1,8 @@
 import { ErrorNoTelemetry } from '../../../base/common/errors.js';
-var RemoteConnectionType;
-( (function(RemoteConnectionType) {
-    RemoteConnectionType[RemoteConnectionType["WebSocket"] = 0] = "WebSocket";
-    RemoteConnectionType[RemoteConnectionType["Managed"] = 1] = "Managed";
-})(RemoteConnectionType || (RemoteConnectionType = {})));
 class ManagedRemoteConnection {
     constructor(id) {
         this.id = id;
-        this.type = RemoteConnectionType.Managed;
+        this.type = 1 ;
     }
     toString() {
         return `Managed(${this.id})`;
@@ -17,7 +12,7 @@ class WebSocketRemoteConnection {
     constructor(host, port) {
         this.host = host;
         this.port = port;
-        this.type = RemoteConnectionType.WebSocket;
+        this.type = 0 ;
     }
     toString() {
         return `WebSocket(${this.host}:${this.port})`;
@@ -65,4 +60,4 @@ function getRemoteAuthorityPrefix(remoteAuthority) {
     }
     return remoteAuthority.substring(0, plusIndex);
 }
-export { ManagedRemoteConnection, RemoteAuthorityResolverError, RemoteAuthorityResolverErrorCode, RemoteConnectionType, WebSocketRemoteConnection, getRemoteAuthorityPrefix };
+export { ManagedRemoteConnection, RemoteAuthorityResolverError, RemoteAuthorityResolverErrorCode, WebSocketRemoteConnection, getRemoteAuthorityPrefix };

package/vscode/src/vs/platform/request/common/request.js

@@ -2,8 +2,7 @@ import { streamToBuffer } from '../../../base/common/buffer.js';
 import { getErrorMessage } from '../../../base/common/errors.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { localize } from '../../../nls.js';
-import { Extensions, ConfigurationScope } from '../../configuration/common/configurationRegistry.js';
-import { CONTEXT_LOG_LEVEL, LogLevelToString, LogLevel } from '../../log/common/log.js';
+import { Extensions } from '../../configuration/common/configurationRegistry.js';
 import { Registry } from '../../registry/common/platform.js';
 class LoggableHeaders {
     constructor(original) {
@@ -26,24 +25,21 @@ class LoggableHeaders {
     }
 }
 class AbstractRequestService extends Disposable {
-    constructor(loggerService) {
+    constructor(logService) {
         super();
+        this.logService = logService;
         this.counter = 0;
-        this.logger = loggerService.createLogger('network', {
-            name: ( localize(4558, "Network Requests")),
-            when: ( (CONTEXT_LOG_LEVEL.isEqualTo(LogLevelToString(LogLevel.Trace)))).serialize()
-        });
     }
-    async logAndRequest(stack, options, request) {
-        const prefix = `${stack} #${++this.counter}: ${options.url}`;
-        this.logger.trace(`${prefix} - begin`, options.type, ( (new LoggableHeaders(options.headers ?? {}))));
+    async logAndRequest(options, request) {
+        const prefix = `[network] #${++this.counter}: ${options.url}`;
+        this.logService.trace(`${prefix} - begin`, options.type, ( (new LoggableHeaders(options.headers ?? {}))));
         try {
             const result = await request();
-            this.logger.trace(`${prefix} - end`, options.type, result.res.statusCode, result.res.headers);
+            this.logService.trace(`${prefix} - end`, options.type, result.res.statusCode, result.res.headers);
             return result;
         }
         catch (error) {
-            this.logger.error(`${prefix} - error`, options.type, getErrorMessage(error));
+            this.logService.error(`${prefix} - error`, options.type, getErrorMessage(error));
             throw error;
         }
     }
@@ -93,7 +89,7 @@ function registerProxyConfigurations(scope) {
     proxyConfiguration = {
         id: 'http',
         order: 15,
-        title: ( localize(4559, "HTTP")),
+        title: ( localize(4585, "HTTP")),
         type: 'object',
         scope,
         properties: {
@@ -101,7 +97,7 @@ function registerProxyConfigurations(scope) {
                 type: 'string',
                 pattern: '^(https?|socks|socks4a?|socks5h?)://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$',
                 markdownDescription: ( localize(
-                    4560,
+                    4586,
                     "The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables."
                 )),
                 restricted: true
@@ -110,7 +106,7 @@ function registerProxyConfigurations(scope) {
                 type: 'boolean',
                 default: true,
                 description: ( localize(
-                    4561,
+                    4587,
                     "Controls whether the proxy server certificate should be verified against the list of supplied CAs."
                 )),
                 restricted: true
@@ -118,7 +114,7 @@ function registerProxyConfigurations(scope) {
             'http.proxyKerberosServicePrincipal': {
                 type: 'string',
                 markdownDescription: ( localize(
-                    4562,
+                    4588,
                     "Overrides the principal service name for Kerberos authentication with the HTTP proxy. A default based on the proxy hostname is used when this is not set."
                 )),
                 restricted: true
@@ -127,7 +123,7 @@ function registerProxyConfigurations(scope) {
                 type: 'array',
                 items: { type: 'string' },
                 markdownDescription: ( localize(
-                    4563,
+                    4589,
                     "Specifies domain names for which proxy settings should be ignored for HTTP/HTTPS requests."
                 )),
                 restricted: true
@@ -136,7 +132,7 @@ function registerProxyConfigurations(scope) {
                 type: ['null', 'string'],
                 default: null,
                 markdownDescription: ( localize(
-                    4564,
+                    4590,
                     "The value to send as the `Proxy-Authorization` header for every network request."
                 )),
                 restricted: true
@@ -145,23 +141,23 @@ function registerProxyConfigurations(scope) {
                 type: 'string',
                 enum: ['off', 'on', 'fallback', 'override'],
                 enumDescriptions: [
-                    ( localize(4565, "Disable proxy support for extensions.")),
-                    ( localize(4566, "Enable proxy support for extensions.")),
+                    ( localize(4591, "Disable proxy support for extensions.")),
+                    ( localize(4592, "Enable proxy support for extensions.")),
                     ( localize(
-                        4567,
+                        4593,
                         "Enable proxy support for extensions, fall back to request options, when no proxy found."
                     )),
-                    ( localize(4568, "Enable proxy support for extensions, override request options.")),
+                    ( localize(4594, "Enable proxy support for extensions, override request options.")),
                 ],
                 default: 'override',
-                description: ( localize(4569, "Use the proxy support for extensions.")),
+                description: ( localize(4595, "Use the proxy support for extensions.")),
                 restricted: true
             },
             'http.systemCertificates': {
                 type: 'boolean',
                 default: true,
                 description: ( localize(
-                    4570,
+                    4596,
                     "Controls whether CA certificates should be loaded from the OS. (On Windows and macOS, a reload of the window is required after turning this off.)"
                 )),
                 restricted: true
@@ -171,14 +167,23 @@ function registerProxyConfigurations(scope) {
                 tags: ['experimental'],
                 default: false,
                 description: ( localize(
-                    4571,
+                    4597,
                     "Controls whether experimental loading of CA certificates from the OS should be enabled. This uses a more general approach than the default implemenation."
                 )),
                 restricted: true
+            },
+            'http.electronFetch': {
+                type: 'boolean',
+                default: false,
+                description: ( localize(
+                    4598,
+                    "Controls whether use of Electron's fetch implementation instead of Node.js' should be enabled. All local extensions will get Electron's fetch implementation for the global fetch API."
+                )),
+                restricted: true
             }
         }
     };
     configurationRegistry.updateConfigurations({ add: [proxyConfiguration], remove: oldProxyConfiguration ? [oldProxyConfiguration] : [] });
 }
-registerProxyConfigurations(ConfigurationScope.APPLICATION);
+registerProxyConfigurations(1 );
 export { AbstractRequestService, asJson, asText, asTextOrError, hasNoContent, isSuccess };

package/vscode/src/vs/platform/storage/common/storage.js

@@ -86,13 +86,13 @@ class AbstractStorageService extends Disposable {
         const { key, external } = event;
         if (key === TARGET_KEY) {
             switch (scope) {
-                case StorageScope.APPLICATION:
+                case -1 :
                     this._applicationKeyTargets = undefined;
                     break;
-                case StorageScope.PROFILE:
+                case 0 :
                     this._profileKeyTargets = undefined;
                     break;
-                case StorageScope.WORKSPACE:
+                case 1 :
                     this._workspaceKeyTargets = undefined;
                     break;
             }
@@ -179,27 +179,27 @@ class AbstractStorageService extends Disposable {
     }
     get workspaceKeyTargets() {
         if (!this._workspaceKeyTargets) {
-            this._workspaceKeyTargets = this.loadKeyTargets(StorageScope.WORKSPACE);
+            this._workspaceKeyTargets = this.loadKeyTargets(1 );
         }
         return this._workspaceKeyTargets;
     }
     get profileKeyTargets() {
         if (!this._profileKeyTargets) {
-            this._profileKeyTargets = this.loadKeyTargets(StorageScope.PROFILE);
+            this._profileKeyTargets = this.loadKeyTargets(0 );
         }
         return this._profileKeyTargets;
     }
     get applicationKeyTargets() {
         if (!this._applicationKeyTargets) {
-            this._applicationKeyTargets = this.loadKeyTargets(StorageScope.APPLICATION);
+            this._applicationKeyTargets = this.loadKeyTargets(-1 );
         }
         return this._applicationKeyTargets;
     }
     getKeyTargets(scope) {
         switch (scope) {
-            case StorageScope.APPLICATION:
+            case -1 :
                 return this.applicationKeyTargets;
-            case StorageScope.PROFILE:
+            case 0 :
                 return this.profileKeyTargets;
             default:
                 return this.workspaceKeyTargets;
@@ -214,9 +214,9 @@ class AbstractStorageService extends Disposable {
     }
     async flush(reason = WillSaveStateReason.NONE) {
         this._onWillSaveState.fire({ reason });
-        const applicationStorage = this.getStorage(StorageScope.APPLICATION);
-        const profileStorage = this.getStorage(StorageScope.PROFILE);
-        const workspaceStorage = this.getStorage(StorageScope.WORKSPACE);
+        const applicationStorage = this.getStorage(-1 );
+        const profileStorage = this.getStorage(0 );
+        const workspaceStorage = this.getStorage(1 );
         switch (reason) {
             case WillSaveStateReason.NONE:
                 await Promises.settled([
@@ -235,10 +235,10 @@ class AbstractStorageService extends Disposable {
         }
     }
     async log() {
-        const applicationItems = this.getStorage(StorageScope.APPLICATION)?.items ?? ( new Map());
-        const profileItems = this.getStorage(StorageScope.PROFILE)?.items ?? ( new Map());
-        const workspaceItems = this.getStorage(StorageScope.WORKSPACE)?.items ?? ( new Map());
-        return logStorage(applicationItems, profileItems, workspaceItems, this.getLogDetails(StorageScope.APPLICATION) ?? '', this.getLogDetails(StorageScope.PROFILE) ?? '', this.getLogDetails(StorageScope.WORKSPACE) ?? '');
+        const applicationItems = this.getStorage(-1 )?.items ?? ( new Map());
+        const profileItems = this.getStorage(0 )?.items ?? ( new Map());
+        const workspaceItems = this.getStorage(1 )?.items ?? ( new Map());
+        return logStorage(applicationItems, profileItems, workspaceItems, this.getLogDetails(-1 ) ?? '', this.getLogDetails(0 ) ?? '', this.getLogDetails(1 ) ?? '');
     }
     async optimize(scope) {
         await this.flush();
@@ -287,15 +287,15 @@ class InMemoryStorageService extends AbstractStorageService {
         this.applicationStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
         this.profileStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
         this.workspaceStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
-        this._register(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.WORKSPACE, e)));
-        this._register(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.PROFILE, e)));
-        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION, e)));
+        this._register(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(1 , e)));
+        this._register(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(-1 , e)));
     }
     getStorage(scope) {
         switch (scope) {
-            case StorageScope.APPLICATION:
+            case -1 :
                 return this.applicationStorage;
-            case StorageScope.PROFILE:
+            case 0 :
                 return this.profileStorage;
             default:
                 return this.workspaceStorage;
@@ -303,9 +303,9 @@ class InMemoryStorageService extends AbstractStorageService {
     }
     getLogDetails(scope) {
         switch (scope) {
-            case StorageScope.APPLICATION:
+            case -1 :
                 return 'inMemory (application)';
-            case StorageScope.PROFILE:
+            case 0 :
                 return 'inMemory (profile)';
             default:
                 return 'inMemory (workspace)';

package/vscode/src/vs/platform/telemetry/common/telemetry.js

@@ -2,18 +2,4 @@ const firstSessionDateStorageKey = 'telemetry.firstSessionDate';
 const TELEMETRY_SETTING_ID = 'telemetry.telemetryLevel';
 const TELEMETRY_CRASH_REPORTER_SETTING_ID = 'telemetry.enableCrashReporter';
 const TELEMETRY_OLD_SETTING_ID = 'telemetry.enableTelemetry';
-var TelemetryLevel;
-( (function(TelemetryLevel) {
-    TelemetryLevel[TelemetryLevel["NONE"] = 0] = "NONE";
-    TelemetryLevel[TelemetryLevel["CRASH"] = 1] = "CRASH";
-    TelemetryLevel[TelemetryLevel["ERROR"] = 2] = "ERROR";
-    TelemetryLevel[TelemetryLevel["USAGE"] = 3] = "USAGE";
-})(TelemetryLevel || (TelemetryLevel = {})));
-var TelemetryConfiguration;
-( (function(TelemetryConfiguration) {
-    TelemetryConfiguration["OFF"] = "off";
-    TelemetryConfiguration["CRASH"] = "crash";
-    TelemetryConfiguration["ERROR"] = "error";
-    TelemetryConfiguration["ON"] = "all";
-})(TelemetryConfiguration || (TelemetryConfiguration = {})));
-export { TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SETTING_ID, TelemetryConfiguration, TelemetryLevel, firstSessionDateStorageKey };
+export { TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SETTING_ID, firstSessionDateStorageKey };

package/vscode/src/vs/platform/telemetry/common/telemetryUtils.js

@@ -2,7 +2,7 @@ import { cloneAndChange } from '../../../base/common/objects.js';
 import { getRemoteName } from '../../remote/common/remoteHosts.js';
 import '../../../base/common/platform.js';
 import '../../../base/common/process.js';
-import { TELEMETRY_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TelemetryLevel, TelemetryConfiguration } from './telemetry.js';
+import { TELEMETRY_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID } from './telemetry.js';
 class TelemetryTrustedValue {
     constructor(value) {
         this.value = value;
@@ -43,17 +43,17 @@ function getTelemetryLevel(configurationService) {
     const crashReporterConfig = configurationService.getValue(TELEMETRY_CRASH_REPORTER_SETTING_ID);
     const oldConfig = configurationService.getValue(TELEMETRY_OLD_SETTING_ID);
     if (oldConfig === false || crashReporterConfig === false) {
-        return TelemetryLevel.NONE;
-    }
-    switch (newConfig ?? TelemetryConfiguration.ON) {
-        case TelemetryConfiguration.ON:
-            return TelemetryLevel.USAGE;
-        case TelemetryConfiguration.ERROR:
-            return TelemetryLevel.ERROR;
-        case TelemetryConfiguration.CRASH:
-            return TelemetryLevel.CRASH;
-        case TelemetryConfiguration.OFF:
-            return TelemetryLevel.NONE;
+        return 0 ;
+    }
+    switch (newConfig ?? "all" ) {
+        case "all" :
+            return 3 ;
+        case "error" :
+            return 2 ;
+        case "crash" :
+            return 1 ;
+        case "off" :
+            return 0 ;
     }
 }
 const telemetryAllowedAuthorities = ( new Set(

package/vscode/src/vs/platform/terminal/common/capabilities/bufferMarkCapability.js

@@ -0,0 +1,41 @@
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+class BufferMarkCapability extends Disposable {
+    constructor(_terminal) {
+        super();
+        this._terminal = _terminal;
+        this.type = 4 ;
+        this._idToMarkerMap = ( new Map());
+        this._anonymousMarkers = ( new Map());
+        this._onMarkAdded = this._register(( new Emitter()));
+        this.onMarkAdded = this._onMarkAdded.event;
+    }
+    *markers() {
+        for (const m of ( this._idToMarkerMap.values())) {
+            yield m;
+        }
+        for (const m of ( this._anonymousMarkers.values())) {
+            yield m;
+        }
+    }
+    addMark(properties) {
+        const marker = properties?.marker || this._terminal.registerMarker();
+        const id = properties?.id;
+        if (!marker) {
+            return;
+        }
+        if (id) {
+            this._idToMarkerMap.set(id, marker);
+            marker.onDispose(() => this._idToMarkerMap.delete(id));
+        }
+        else {
+            this._anonymousMarkers.set(marker.id, marker);
+            marker.onDispose(() => this._anonymousMarkers.delete(marker.id));
+        }
+        this._onMarkAdded.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
+    }
+    getMark(id) {
+        return this._idToMarkerMap.get(id);
+    }
+}
+export { BufferMarkCapability };