@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/platform/quickinput/browser/helpQuickAccess.js

@@ -1,65 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../nls.js';
-import { Registry } from '../../registry/common/platform.js';
-import { DisposableStore } from '../../../base/common/lifecycle.js';
-import { IKeybindingService } from '../../keybinding/common/keybinding.js';
-import { Extensions } from '../common/quickAccess.js';
-import { IQuickInputService } from '../common/quickInput.js';
-var HelpQuickAccessProvider_1;
-let HelpQuickAccessProvider = class HelpQuickAccessProvider {
-    static { HelpQuickAccessProvider_1 = this; }
-    static { this.PREFIX = '?'; }
-    constructor(quickInputService, keybindingService) {
-        this.quickInputService = quickInputService;
-        this.keybindingService = keybindingService;
-        this.registry = ( Registry.as(Extensions.Quickaccess));
-    }
-    provide(picker) {
-        const disposables = ( new DisposableStore());
-        disposables.add(picker.onDidAccept(() => {
-            const [item] = picker.selectedItems;
-            if (item) {
-                this.quickInputService.quickAccess.show(item.prefix, { preserveValue: true });
-            }
-        }));
-        disposables.add(picker.onDidChangeValue(value => {
-            const providerDescriptor = this.registry.getQuickAccessProvider(value.substr(HelpQuickAccessProvider_1.PREFIX.length));
-            if (providerDescriptor && providerDescriptor.prefix && providerDescriptor.prefix !== HelpQuickAccessProvider_1.PREFIX) {
-                this.quickInputService.quickAccess.show(providerDescriptor.prefix, { preserveValue: true });
-            }
-        }));
-        picker.items = this.getQuickAccessProviders().filter(p => p.prefix !== HelpQuickAccessProvider_1.PREFIX);
-        return disposables;
-    }
-    getQuickAccessProviders() {
-        const providers = this.registry
-            .getQuickAccessProviders()
-            .sort((providerA, providerB) => providerA.prefix.localeCompare(providerB.prefix))
-            .flatMap(provider => this.createPicks(provider));
-        return providers;
-    }
-    createPicks(provider) {
-        return ( provider.helpEntries.map(helpEntry => {
-            const prefix = helpEntry.prefix || provider.prefix;
-            const label = prefix || '\u2026' ;
-            return {
-                prefix,
-                label,
-                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
-                ariaLabel: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/helpQuickAccess',
-                    'helpPickAriaLabel',
-                    "{0}, {1}",
-                    label,
-                    helpEntry.description
-                )),
-                description: helpEntry.description
-            };
-        }));
-    }
-};
-HelpQuickAccessProvider = HelpQuickAccessProvider_1 = ( __decorate([
-    ( __param(0, IQuickInputService)),
-    ( __param(1, IKeybindingService))
-], HelpQuickAccessProvider));
-export { HelpQuickAccessProvider };

package/vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.js

@@ -1,108 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { mainWindow } from '../../../base/browser/window.js';
-import { DeferredPromise } from '../../../base/common/async.js';
-import { ErrorNoTelemetry } from '../../../base/common/errors.js';
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { RemoteAuthorities } from '../../../base/common/network.js';
-import { mark } from '../../../base/common/performance.js';
-import { StopWatch } from '../../../base/common/stopwatch.js';
-import { ILogService } from '../../log/common/log.js';
-import { IProductService } from '../../product/common/productService.js';
-import { getRemoteAuthorityPrefix, WebSocketRemoteConnection } from '../common/remoteAuthorityResolver.js';
-import { parseAuthorityWithOptionalPort } from '../common/remoteHosts.js';
-let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extends Disposable {
-    constructor(isWorkbenchOptionsBasedResolution, connectionToken, resourceUriProvider, serverBasePath, productService, _logService) {
-        super();
-        this._logService = _logService;
-        this._onDidChangeConnectionData = this._register(( new Emitter()));
-        this.onDidChangeConnectionData = this._onDidChangeConnectionData.event;
-        this._resolveAuthorityRequests = ( new Map());
-        this._cache = ( new Map());
-        this._connectionToken = connectionToken;
-        this._connectionTokens = ( new Map());
-        this._isWorkbenchOptionsBasedResolution = isWorkbenchOptionsBasedResolution;
-        if (resourceUriProvider) {
-            RemoteAuthorities.setDelegate(resourceUriProvider);
-        }
-        RemoteAuthorities.setServerRootPath(productService, serverBasePath);
-    }
-    async resolveAuthority(authority) {
-        let result = this._resolveAuthorityRequests.get(authority);
-        if (!result) {
-            result = ( new DeferredPromise());
-            this._resolveAuthorityRequests.set(authority, result);
-            if (this._isWorkbenchOptionsBasedResolution) {
-                this._doResolveAuthority(authority).then(v => result.complete(v), (err) => result.error(err));
-            }
-        }
-        return result.p;
-    }
-    async getCanonicalURI(uri) {
-        return uri;
-    }
-    getConnectionData(authority) {
-        if (!( this._cache.has(authority))) {
-            return null;
-        }
-        const resolverResult = this._cache.get(authority);
-        const connectionToken = this._connectionTokens.get(authority) || resolverResult.authority.connectionToken;
-        return {
-            connectTo: resolverResult.authority.connectTo,
-            connectionToken: connectionToken
-        };
-    }
-    async _doResolveAuthority(authority) {
-        const authorityPrefix = getRemoteAuthorityPrefix(authority);
-        const sw = StopWatch.create(false);
-        this._logService.info(`Resolving connection token (${authorityPrefix})...`);
-        mark(`code/willResolveConnectionToken/${authorityPrefix}`);
-        const connectionToken = await Promise.resolve(this._connectionTokens.get(authority) || this._connectionToken);
-        mark(`code/didResolveConnectionToken/${authorityPrefix}`);
-        this._logService.info(`Resolved connection token (${authorityPrefix}) after ${sw.elapsed()} ms`);
-        const defaultPort = (/^https:/.test(mainWindow.location.href) ? 443 : 80);
-        const { host, port } = parseAuthorityWithOptionalPort(authority, defaultPort);
-        const result = { authority: { authority, connectTo: ( new WebSocketRemoteConnection(host, port)), connectionToken } };
-        RemoteAuthorities.set(authority, host, port);
-        this._cache.set(authority, result);
-        this._onDidChangeConnectionData.fire();
-        return result;
-    }
-    _clearResolvedAuthority(authority) {
-        if (( this._resolveAuthorityRequests.has(authority))) {
-            this._resolveAuthorityRequests.get(authority).cancel();
-            this._resolveAuthorityRequests.delete(authority);
-        }
-    }
-    _setResolvedAuthority(resolvedAuthority, options) {
-        if (( this._resolveAuthorityRequests.has(resolvedAuthority.authority))) {
-            const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority);
-            if (resolvedAuthority.connectTo.type === 0 ) {
-                RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
-            }
-            if (resolvedAuthority.connectionToken) {
-                RemoteAuthorities.setConnectionToken(resolvedAuthority.authority, resolvedAuthority.connectionToken);
-            }
-            request.complete({ authority: resolvedAuthority, options });
-            this._onDidChangeConnectionData.fire();
-        }
-    }
-    _setResolvedAuthorityError(authority, err) {
-        if (( this._resolveAuthorityRequests.has(authority))) {
-            const request = this._resolveAuthorityRequests.get(authority);
-            request.error(ErrorNoTelemetry.fromError(err));
-        }
-    }
-    _setAuthorityConnectionToken(authority, connectionToken) {
-        this._connectionTokens.set(authority, connectionToken);
-        RemoteAuthorities.setConnectionToken(authority, connectionToken);
-        this._onDidChangeConnectionData.fire();
-    }
-    _setCanonicalURIProvider(provider) {
-    }
-};
-RemoteAuthorityResolverService = ( __decorate([
-    ( __param(4, IProductService)),
-    ( __param(5, ILogService))
-], RemoteAuthorityResolverService));
-export { RemoteAuthorityResolverService };

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

@@ -1,96 +0,0 @@
-import { VSBuffer, encodeBase64 } from '../../../base/common/buffer.js';
-import { PauseableEmitter, Emitter } from '../../../base/common/event.js';
-import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { SocketDiagnostics } from '../../../base/parts/ipc/common/ipc.net.js';
-const makeRawSocketHeaders = (path, query, deubgLabel) => {
-    const buffer = ( new Uint8Array(16));
-    for (let i = 0; i < 16; i++) {
-        buffer[i] = Math.round(Math.random() * 256);
-    }
-    const nonce = encodeBase64(VSBuffer.wrap(buffer));
-    const headers = [
-        `GET ws://localhost${path}?${query}&skipWebSocketFrames=true HTTP/1.1`,
-        `Connection: Upgrade`,
-        `Upgrade: websocket`,
-        `Sec-WebSocket-Key: ${nonce}`
-    ];
-    return headers.join('\r\n') + '\r\n\r\n';
-};
-const socketRawEndHeaderSequence = VSBuffer.fromString('\r\n\r\n');
-async function connectManagedSocket(socket, path, query, debugLabel, half) {
-    socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
-    const d = ( new DisposableStore());
-    try {
-        return await ( new Promise((resolve, reject) => {
-            let dataSoFar;
-            d.add(socket.onData(d_1 => {
-                if (!dataSoFar) {
-                    dataSoFar = d_1;
-                }
-                else {
-                    dataSoFar = VSBuffer.concat([dataSoFar, d_1], dataSoFar.byteLength + d_1.byteLength);
-                }
-                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
-                if (index === -1) {
-                    return;
-                }
-                resolve(socket);
-                socket.pauseData();
-                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
-                if (rest.byteLength) {
-                    half.onData.fire(rest);
-                }
-            }));
-            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
-            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
-        }));
-    }
-    catch (e) {
-        socket.dispose();
-        throw e;
-    }
-    finally {
-        d.dispose();
-    }
-}
-class ManagedSocket extends Disposable {
-    constructor(debugLabel, half) {
-        super();
-        this.debugLabel = debugLabel;
-        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
-        this.onData = (...args) => {
-            if (this.pausableDataEmitter.isPaused) {
-                queueMicrotask(() => this.pausableDataEmitter.resume());
-            }
-            return this.pausableDataEmitter.event(...args);
-        };
-        this.didDisposeEmitter = this._register(( new Emitter()));
-        this.onDidDispose = this.didDisposeEmitter.event;
-        this.ended = false;
-        this._register(half.onData);
-        this._register(half.onData.event(data => this.pausableDataEmitter.fire(data)));
-        this.onClose = this._register(half.onClose).event;
-        this.onEnd = this._register(half.onEnd).event;
-    }
-    pauseData() {
-        this.pausableDataEmitter.pause();
-    }
-    drain() {
-        return Promise.resolve();
-    }
-    end() {
-        this.ended = true;
-        this.closeRemote();
-    }
-    traceSocketEvent(type, data) {
-        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
-    }
-    dispose() {
-        if (!this.ended) {
-            this.closeRemote();
-        }
-        this.didDisposeEmitter.fire();
-        super.dispose();
-    }
-}
-export { ManagedSocket, connectManagedSocket, makeRawSocketHeaders, socketRawEndHeaderSequence };

package/vscode/src/vs/platform/request/browser/requestService.js

@@ -1,28 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { request } from '../../../base/parts/request/browser/request.js';
-import { IConfigurationService } from '../../configuration/common/configuration.js';
-import { ILoggerService } from '../../log/common/log.js';
-import { AbstractRequestService } from '../common/request.js';
-let RequestService = class RequestService extends AbstractRequestService {
-    constructor(configurationService, loggerService) {
-        super(loggerService);
-        this.configurationService = configurationService;
-    }
-    async request(options, token) {
-        if (!options.proxyAuthorization) {
-            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
-        }
-        return this.logAndRequest('browser', options, () => request(options, token));
-    }
-    async resolveProxy(url) {
-        return undefined;
-    }
-    async loadCertificates() {
-        return [];
-    }
-};
-RequestService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, ILoggerService))
-], RequestService));
-export { RequestService };

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

@@ -1,18 +0,0 @@
-import { bufferToStream } from '../../../base/common/buffer.js';
-import '../../../base/common/cancellation.js';
-class RequestChannelClient {
-    constructor(channel) {
-        this.channel = channel;
-    }
-    async request(options, token) {
-        const [res, buffer] = await this.channel.call('request', [options], token);
-        return { res, stream: bufferToStream(buffer) };
-    }
-    async resolveProxy(url) {
-        return this.channel.call('resolveProxy', [url]);
-    }
-    async loadCertificates() {
-        return this.channel.call('loadCertificates');
-    }
-}
-export { RequestChannelClient };

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

@@ -1,11 +0,0 @@
-import '../../../base/common/platform.js';
-import { env } from '../../../base/common/process.js';
-function verifyMicrosoftInternalDomain(domainList) {
-    const userDnsDomain = env['USERDNSDOMAIN'];
-    if (!userDnsDomain) {
-        return false;
-    }
-    const domain = userDnsDomain.toLowerCase();
-    return ( domainList.some(msftDomain => domain === msftDomain));
-}
-export { verifyMicrosoftInternalDomain };

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

@@ -1,22 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-class NaiveCwdDetectionCapability {
-    constructor(_process) {
-        this._process = _process;
-        this.type = 1 ;
-        this._cwd = '';
-        this._onDidChangeCwd = ( new Emitter());
-        this.onDidChangeCwd = this._onDidChangeCwd.event;
-    }
-    async getCwd() {
-        if (!this._process) {
-            return Promise.resolve('');
-        }
-        const newCwd = await this._process.getCwd();
-        if (newCwd !== this._cwd) {
-            this._onDidChangeCwd.fire(newCwd);
-        }
-        this._cwd = newCwd;
-        return this._cwd;
-    }
-}
-export { NaiveCwdDetectionCapability };

package/vscode/src/vs/platform/terminal/common/environmentVariable.js

@@ -1,7 +0,0 @@
-var EnvironmentVariableMutatorType;
-( (function(EnvironmentVariableMutatorType) {
-    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Replace"] = 1] = "Replace";
-    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Append"] = 2] = "Append";
-    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
-})(EnvironmentVariableMutatorType || (EnvironmentVariableMutatorType = {})));
-export { EnvironmentVariableMutatorType };

package/vscode/src/vs/platform/terminal/common/environmentVariableCollection.js

@@ -1,196 +0,0 @@
-import { isWindows } from '../../../base/common/platform.js';
-import { EnvironmentVariableMutatorType } from './environmentVariable.js';
-const mutatorTypeToLabelMap = ( new Map([
-    [EnvironmentVariableMutatorType.Append, 'APPEND'],
-    [EnvironmentVariableMutatorType.Prepend, 'PREPEND'],
-    [EnvironmentVariableMutatorType.Replace, 'REPLACE']
-]));
-class MergedEnvironmentVariableCollection {
-    constructor(collections) {
-        this.collections = collections;
-        this.map = ( new Map());
-        this.descriptionMap = ( new Map());
-        collections.forEach((collection, extensionIdentifier) => {
-            this.populateDescriptionMap(collection, extensionIdentifier);
-            const it = collection.map.entries();
-            let next = it.next();
-            while (!next.done) {
-                const mutator = next.value[1];
-                const key = next.value[0];
-                let entry = this.map.get(key);
-                if (!entry) {
-                    entry = [];
-                    this.map.set(key, entry);
-                }
-                if (entry.length > 0 && entry[0].type === EnvironmentVariableMutatorType.Replace) {
-                    next = it.next();
-                    continue;
-                }
-                const extensionMutator = {
-                    extensionIdentifier,
-                    value: mutator.value,
-                    type: mutator.type,
-                    scope: mutator.scope,
-                    variable: mutator.variable,
-                    options: mutator.options
-                };
-                if (!extensionMutator.scope) {
-                    delete extensionMutator.scope;
-                }
-                entry.unshift(extensionMutator);
-                next = it.next();
-            }
-        });
-    }
-    async applyToProcessEnvironment(env, scope, variableResolver) {
-        let lowerToActualVariableNames;
-        if (isWindows) {
-            lowerToActualVariableNames = {};
-            ( Object.keys(env)).forEach(e => lowerToActualVariableNames[e.toLowerCase()] = e);
-        }
-        for (const [variable, mutators] of this.getVariableMap(scope)) {
-            const actualVariable = isWindows ? lowerToActualVariableNames[variable.toLowerCase()] || variable : variable;
-            for (const mutator of mutators) {
-                const value = variableResolver ? await variableResolver(mutator.value) : mutator.value;
-                if (mutator.options?.applyAtProcessCreation ?? true) {
-                    switch (mutator.type) {
-                        case EnvironmentVariableMutatorType.Append:
-                            env[actualVariable] = (env[actualVariable] || '') + value;
-                            break;
-                        case EnvironmentVariableMutatorType.Prepend:
-                            env[actualVariable] = value + (env[actualVariable] || '');
-                            break;
-                        case EnvironmentVariableMutatorType.Replace:
-                            env[actualVariable] = value;
-                            break;
-                    }
-                }
-                if (mutator.options?.applyAtShellIntegration ?? false) {
-                    const key = `VSCODE_ENV_${mutatorTypeToLabelMap.get(mutator.type)}`;
-                    env[key] = (env[key] ? env[key] + ':' : '') + variable + '=' + this._encodeColons(value);
-                }
-            }
-        }
-    }
-    _encodeColons(value) {
-        return value.replaceAll(':', '\\x3a');
-    }
-    diff(other, scope) {
-        const added = ( new Map());
-        const changed = ( new Map());
-        const removed = ( new Map());
-        other.getVariableMap(scope).forEach((otherMutators, variable) => {
-            const currentMutators = this.getVariableMap(scope).get(variable);
-            const result = getMissingMutatorsFromArray(otherMutators, currentMutators);
-            if (result) {
-                added.set(variable, result);
-            }
-        });
-        this.getVariableMap(scope).forEach((currentMutators, variable) => {
-            const otherMutators = other.getVariableMap(scope).get(variable);
-            const result = getMissingMutatorsFromArray(currentMutators, otherMutators);
-            if (result) {
-                removed.set(variable, result);
-            }
-        });
-        this.getVariableMap(scope).forEach((currentMutators, variable) => {
-            const otherMutators = other.getVariableMap(scope).get(variable);
-            const result = getChangedMutatorsFromArray(currentMutators, otherMutators);
-            if (result) {
-                changed.set(variable, result);
-            }
-        });
-        if (added.size === 0 && changed.size === 0 && removed.size === 0) {
-            return undefined;
-        }
-        return { added, changed, removed };
-    }
-    getVariableMap(scope) {
-        const result = ( new Map());
-        for (const mutators of ( this.map.values())) {
-            const filteredMutators = mutators.filter(m => filterScope(m, scope));
-            if (filteredMutators.length > 0) {
-                result.set(filteredMutators[0].variable, filteredMutators);
-            }
-        }
-        return result;
-    }
-    getDescriptionMap(scope) {
-        const result = ( new Map());
-        for (const mutators of ( this.descriptionMap.values())) {
-            const filteredMutators = mutators.filter(m => filterScope(m, scope, true));
-            for (const mutator of filteredMutators) {
-                result.set(mutator.extensionIdentifier, mutator.description);
-            }
-        }
-        return result;
-    }
-    populateDescriptionMap(collection, extensionIdentifier) {
-        if (!collection.descriptionMap) {
-            return;
-        }
-        const it = collection.descriptionMap.entries();
-        let next = it.next();
-        while (!next.done) {
-            const mutator = next.value[1];
-            const key = next.value[0];
-            let entry = this.descriptionMap.get(key);
-            if (!entry) {
-                entry = [];
-                this.descriptionMap.set(key, entry);
-            }
-            const extensionMutator = {
-                extensionIdentifier,
-                scope: mutator.scope,
-                description: mutator.description
-            };
-            if (!extensionMutator.scope) {
-                delete extensionMutator.scope;
-            }
-            entry.push(extensionMutator);
-            next = it.next();
-        }
-    }
-}
-function filterScope(mutator, scope, strictFilter = false) {
-    if (!mutator.scope) {
-        if (strictFilter) {
-            return scope === mutator.scope;
-        }
-        return true;
-    }
-    if (mutator.scope.workspaceFolder && scope?.workspaceFolder && mutator.scope.workspaceFolder.index === scope.workspaceFolder.index) {
-        return true;
-    }
-    return false;
-}
-function getMissingMutatorsFromArray(current, other) {
-    if (!other) {
-        return current;
-    }
-    const otherMutatorExtensions = ( new Set());
-    other.forEach(m => otherMutatorExtensions.add(m.extensionIdentifier));
-    const result = [];
-    current.forEach(mutator => {
-        if (!( otherMutatorExtensions.has(mutator.extensionIdentifier))) {
-            result.push(mutator);
-        }
-    });
-    return result.length === 0 ? undefined : result;
-}
-function getChangedMutatorsFromArray(current, other) {
-    if (!other) {
-        return undefined;
-    }
-    const otherMutatorExtensions = ( new Map());
-    other.forEach(m => otherMutatorExtensions.set(m.extensionIdentifier, m));
-    const result = [];
-    current.forEach(mutator => {
-        const otherMutator = otherMutatorExtensions.get(mutator.extensionIdentifier);
-        if (otherMutator && (mutator.type !== otherMutator.type || mutator.value !== otherMutator.value || mutator.scope?.workspaceFolder?.index !== otherMutator.scope?.workspaceFolder?.index)) {
-            result.push(otherMutator);
-        }
-    });
-    return result.length === 0 ? undefined : result;
-}
-export { MergedEnvironmentVariableCollection };

package/vscode/src/vs/platform/terminal/common/terminalLogService.js

@@ -1,49 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../base/common/lifecycle.js';
-import { Event } from '../../../base/common/event.js';
-import { localizeWithPath } from '../../../nls.js';
-import { LogLevel, ILoggerService } from '../../log/common/log.js';
-import { IWorkspaceContextService } from '../../workspace/common/workspace.js';
-import { IEnvironmentService } from '../../environment/common/environment.js';
-import { joinPath } from '../../../base/common/resources.js';
-let TerminalLogService = class TerminalLogService extends Disposable {
-    get onDidChangeLogLevel() { return this._logger.onDidChangeLogLevel; }
-    constructor(_loggerService, workspaceContextService, environmentService) {
-        super();
-        this._loggerService = _loggerService;
-        this._logger = this._loggerService.createLogger(joinPath(environmentService.logsHome, 'terminal.log'), { id: 'terminal', name: ( localizeWithPath(
-            'vs/platform/terminal/common/terminalLogService',
-            'terminalLoggerName',
-            'Terminal'
-        )) });
-        this._register(Event.runAndSubscribe(workspaceContextService.onDidChangeWorkspaceFolders, () => {
-            this._workspaceId = workspaceContextService.getWorkspace().id.substring(0, 7);
-        }));
-    }
-    getLevel() { return this._logger.getLevel(); }
-    setLevel(level) { this._logger.setLevel(level); }
-    flush() { this._logger.flush(); }
-    trace(message, ...args) { this._logger.trace(this._formatMessage(message), args); }
-    debug(message, ...args) { this._logger.debug(this._formatMessage(message), args); }
-    info(message, ...args) { this._logger.info(this._formatMessage(message), args); }
-    warn(message, ...args) { this._logger.warn(this._formatMessage(message), args); }
-    error(message, ...args) {
-        if (message instanceof Error) {
-            this._logger.error(this._formatMessage(''), message, args);
-            return;
-        }
-        this._logger.error(this._formatMessage(message), args);
-    }
-    _formatMessage(message) {
-        if (this._logger.getLevel() === LogLevel.Trace) {
-            return `[${this._workspaceId}] ${message}`;
-        }
-        return message;
-    }
-};
-TerminalLogService = ( __decorate([
-    ( __param(0, ILoggerService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IEnvironmentService))
-], TerminalLogService));
-export { TerminalLogService };