@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/common/extHostLanguages.js

@@ -0,0 +1,164 @@
+import { MainContext } from './extHost.protocol.js';
+import { Position, Range as Range$1, TokenType, DocumentSelector } from './extHostTypeConverters.js';
+import { StandardTokenType, Range, LanguageStatusSeverity } from './extHostTypes.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class ExtHostLanguages {
+    constructor(mainContext, _documents, _commands, _uriTransformer) {
+        this._documents = _documents;
+        this._commands = _commands;
+        this._uriTransformer = _uriTransformer;
+        this._languageIds = [];
+        this._handlePool = 0;
+        this._ids = ( new Set());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadLanguages));
+    }
+    $acceptLanguageIds(ids) {
+        this._languageIds = ids;
+    }
+    async getLanguages() {
+        return this._languageIds.slice(0);
+    }
+    async changeLanguage(uri, languageId) {
+        await this._proxy.$changeLanguage(uri, languageId);
+        const data = this._documents.getDocumentData(uri);
+        if (!data) {
+            throw new Error(`document '${uri.toString()}' NOT found`);
+        }
+        return data.document;
+    }
+    async tokenAtPosition(document, position) {
+        const versionNow = document.version;
+        const pos = Position.from(position);
+        const info = await this._proxy.$tokensAtPosition(document.uri, pos);
+        const defaultRange = {
+            type: StandardTokenType.Other,
+            range: document.getWordRangeAtPosition(position) ?? ( new Range(position.line, position.character, position.line, position.character))
+        };
+        if (!info) {
+            return defaultRange;
+        }
+        const result = {
+            range: Range$1.to(info.range),
+            type: TokenType.to(info.type)
+        };
+        if (!result.range.contains(position)) {
+            return defaultRange;
+        }
+        if (versionNow !== document.version) {
+            return defaultRange;
+        }
+        return result;
+    }
+    createLanguageStatusItem(extension, id, selector) {
+        const handle = this._handlePool++;
+        const proxy = this._proxy;
+        const ids = this._ids;
+        const fullyQualifiedId = `${extension.identifier.value}/${id}`;
+        if (ids.has(fullyQualifiedId)) {
+            throw new Error(`LanguageStatusItem with id '${id}' ALREADY exists`);
+        }
+        ids.add(fullyQualifiedId);
+        const data = {
+            selector,
+            id,
+            name: extension.displayName ?? extension.name,
+            severity: LanguageStatusSeverity.Information,
+            command: undefined,
+            text: '',
+            detail: '',
+            busy: false
+        };
+        let soonHandle;
+        const commandDisposables = ( new DisposableStore());
+        const updateAsync = () => {
+            soonHandle?.dispose();
+            soonHandle = disposableTimeout(() => {
+                commandDisposables.clear();
+                this._proxy.$setLanguageStatus(handle, {
+                    id: fullyQualifiedId,
+                    name: data.name ?? extension.displayName ?? extension.name,
+                    source: extension.displayName ?? extension.name,
+                    selector: DocumentSelector.from(data.selector, this._uriTransformer),
+                    label: data.text,
+                    detail: data.detail ?? '',
+                    severity: data.severity === LanguageStatusSeverity.Error ? Severity.Error : data.severity === LanguageStatusSeverity.Warning ? Severity.Warning : Severity.Info,
+                    command: data.command && this._commands.toInternal(data.command, commandDisposables),
+                    accessibilityInfo: data.accessibilityInformation,
+                    busy: data.busy
+                });
+            }, 0);
+        };
+        const result = {
+            dispose() {
+                commandDisposables.dispose();
+                soonHandle?.dispose();
+                proxy.$removeLanguageStatus(handle);
+                ids.delete(fullyQualifiedId);
+            },
+            get id() {
+                return data.id;
+            },
+            get name() {
+                return data.name;
+            },
+            set name(value) {
+                data.name = value;
+                updateAsync();
+            },
+            get selector() {
+                return data.selector;
+            },
+            set selector(value) {
+                data.selector = value;
+                updateAsync();
+            },
+            get text() {
+                return data.text;
+            },
+            set text(value) {
+                data.text = value;
+                updateAsync();
+            },
+            get detail() {
+                return data.detail;
+            },
+            set detail(value) {
+                data.detail = value;
+                updateAsync();
+            },
+            get severity() {
+                return data.severity;
+            },
+            set severity(value) {
+                data.severity = value;
+                updateAsync();
+            },
+            get accessibilityInformation() {
+                return data.accessibilityInformation;
+            },
+            set accessibilityInformation(value) {
+                data.accessibilityInformation = value;
+                updateAsync();
+            },
+            get command() {
+                return data.command;
+            },
+            set command(value) {
+                data.command = value;
+                updateAsync();
+            },
+            get busy() {
+                return data.busy;
+            },
+            set busy(value) {
+                data.busy = value;
+                updateAsync();
+            }
+        };
+        updateAsync();
+        return result;
+    }
+}
+export { ExtHostLanguages };

package/dist/vscode/vs/workbench/api/common/extHostLocalizationService.js

@@ -0,0 +1,85 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { LANGUAGE_DEFAULT } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { format2 } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { MainContext } from './extHost.protocol.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+let ExtHostLocalizationService = class ExtHostLocalizationService {
+    constructor(initData, rpc, logService) {
+        this.logService = logService;
+        this.bundleCache = ( new Map());
+        this._proxy = ( rpc.getProxy(MainContext.MainThreadLocalization));
+        this.currentLanguage = initData.environment.appLanguage;
+        this.isDefaultLanguage = this.currentLanguage === LANGUAGE_DEFAULT;
+    }
+    getMessage(extensionId, details) {
+        const { message, args, comment } = details;
+        if (this.isDefaultLanguage) {
+            return format2(message, (args ?? {}));
+        }
+        let key = message;
+        if (comment && comment.length > 0) {
+            key += `/${Array.isArray(comment) ? comment.join('') : comment}`;
+        }
+        const str = this.bundleCache.get(extensionId)?.contents[key];
+        if (!str) {
+            this.logService.warn(`Using default string since no string found in i18n bundle that has the key: ${key}`);
+        }
+        return format2(str ?? message, (args ?? {}));
+    }
+    getBundle(extensionId) {
+        return this.bundleCache.get(extensionId)?.contents;
+    }
+    getBundleUri(extensionId) {
+        return this.bundleCache.get(extensionId)?.uri;
+    }
+    async initializeLocalizedMessages(extension) {
+        if (this.isDefaultLanguage
+            || (!extension.l10n && !extension.isBuiltin)) {
+            return;
+        }
+        if (this.bundleCache.has(extension.identifier.value)) {
+            return;
+        }
+        let contents;
+        const bundleUri = await this.getBundleLocation(extension);
+        if (!bundleUri) {
+            this.logService.error(`No bundle location found for extension ${extension.identifier.value}`);
+            return;
+        }
+        try {
+            const response = await this._proxy.$fetchBundleContents(bundleUri);
+            const result = JSON.parse(response);
+            contents = extension.isBuiltin ? result.contents?.bundle : result;
+        }
+        catch (e) {
+            this.logService.error(`Failed to load translations for ${extension.identifier.value} from ${bundleUri}: ${e.message}`);
+            return;
+        }
+        if (contents) {
+            this.bundleCache.set(extension.identifier.value, {
+                contents,
+                uri: bundleUri
+            });
+        }
+    }
+    async getBundleLocation(extension) {
+        if (extension.isBuiltin) {
+            const uri = await this._proxy.$fetchBuiltInBundleUri(extension.identifier.value, this.currentLanguage);
+            return URI.revive(uri);
+        }
+        return extension.l10n
+            ? URI.joinPath(extension.extensionLocation, extension.l10n, `bundle.l10n.${this.currentLanguage}.json`)
+            : undefined;
+    }
+};
+ExtHostLocalizationService = ( __decorate([
+    ( __param(0, IExtHostInitDataService)),
+    ( __param(1, IExtHostRpcService)),
+    ( __param(2, ILogService))
+], ExtHostLocalizationService));
+const IExtHostLocalizationService = ( createDecorator('IExtHostLocalizationService'));
+export { ExtHostLocalizationService, IExtHostLocalizationService };

package/dist/vscode/vs/workbench/api/common/extHostMemento.js

@@ -0,0 +1,74 @@
+import { RunOnceScheduler, DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+class ExtensionMemento {
+    constructor(id, global, storage) {
+        this._deferredPromises = ( new Map());
+        this._id = id;
+        this._shared = global;
+        this._storage = storage;
+        this._init = this._storage.initializeExtensionStorage(this._shared, this._id, Object.create(null)).then(value => {
+            this._value = value;
+            return this;
+        });
+        this._storageListener = this._storage.onDidChangeStorage(e => {
+            if (e.shared === this._shared && e.key === this._id) {
+                this._value = e.value;
+            }
+        });
+        this._scheduler = ( new RunOnceScheduler(() => {
+            const records = this._deferredPromises;
+            this._deferredPromises = ( new Map());
+            (async () => {
+                try {
+                    await this._storage.setValue(this._shared, this._id, this._value);
+                    for (const value of ( records.values())) {
+                        value.complete();
+                    }
+                }
+                catch (e) {
+                    for (const value of ( records.values())) {
+                        value.error(e);
+                    }
+                }
+            })();
+        }, 0));
+    }
+    keys() {
+        return ( Object.entries(this._value ?? {}).filter(([, value]) => value !== undefined).map(([key]) => key));
+    }
+    get whenReady() {
+        return this._init;
+    }
+    get(key, defaultValue) {
+        let value = this._value[key];
+        if (typeof value === 'undefined') {
+            value = defaultValue;
+        }
+        return value;
+    }
+    update(key, value) {
+        this._value[key] = value;
+        const record = this._deferredPromises.get(key);
+        if (record !== undefined) {
+            return record.p;
+        }
+        const promise = ( new DeferredPromise());
+        this._deferredPromises.set(key, promise);
+        if (!this._scheduler.isScheduled()) {
+            this._scheduler.schedule();
+        }
+        return promise.p;
+    }
+    dispose() {
+        this._storageListener.dispose();
+    }
+}
+class ExtensionGlobalMemento extends ExtensionMemento {
+    setKeysForSync(keys) {
+        this._storage.registerExtensionStorageKeysToSync({ id: this._id, version: this._extension.version }, keys);
+    }
+    constructor(extensionDescription, storage) {
+        super(extensionDescription.identifier.value, true, storage);
+        this._extension = extensionDescription;
+    }
+}
+export { ExtensionGlobalMemento, ExtensionMemento };

package/dist/vscode/vs/workbench/api/common/extHostMessageService.js

@@ -0,0 +1,55 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { MainContext } from './extHost.protocol.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+function isMessageItem(item) {
+    return item && item.title;
+}
+let ExtHostMessageService = class ExtHostMessageService {
+    constructor(mainContext, _logService) {
+        this._logService = _logService;
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadMessageService));
+    }
+    showMessage(extension, severity, message, optionsOrFirstItem, rest) {
+        const options = {
+            source: { identifier: extension.identifier, label: extension.displayName || extension.name }
+        };
+        let items;
+        if (typeof optionsOrFirstItem === 'string' || isMessageItem(optionsOrFirstItem)) {
+            items = [optionsOrFirstItem, ...rest];
+        }
+        else {
+            options.modal = optionsOrFirstItem?.modal;
+            options.useCustom = optionsOrFirstItem?.useCustom;
+            options.detail = optionsOrFirstItem?.detail;
+            items = rest;
+        }
+        if (options.useCustom) {
+            checkProposedApiEnabled(extension, 'resolvers');
+        }
+        const commands = [];
+        for (let handle = 0; handle < items.length; handle++) {
+            const command = items[handle];
+            if (typeof command === 'string') {
+                commands.push({ title: command, handle, isCloseAffordance: false });
+            }
+            else if (typeof command === 'object') {
+                const { title, isCloseAffordance } = command;
+                commands.push({ title, isCloseAffordance: !!isCloseAffordance, handle });
+            }
+            else {
+                this._logService.warn('Invalid message item:', command);
+            }
+        }
+        return this._proxy.$showMessage(severity, message, options, commands).then(handle => {
+            if (typeof handle === 'number') {
+                return items[handle];
+            }
+            return undefined;
+        });
+    }
+};
+ExtHostMessageService = ( __decorate([
+    ( __param(1, ILogService))
+], ExtHostMessageService));
+export { ExtHostMessageService };

package/dist/vscode/vs/workbench/api/common/extHostOutput.js

@@ -0,0 +1,257 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { MainContext } from './extHost.protocol.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { parseLogLevel, AbstractMessageLogger, log, ILoggerService, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { OutputChannelUpdateMode } from '../../services/output/common/output.js';
+import { IExtHostConsumerFileSystem } from './extHostFileSystemConsumer.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostFileSystemInfo } from './extHostFileSystemInfo.js';
+import { toLocalISOString } from '../../../base/common/date.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { toFileSystemProviderErrorCode, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+class ExtHostOutputChannel extends AbstractMessageLogger {
+    get disposed() { return this._disposed; }
+    constructor(id, name, logger, proxy, extension) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.logger = logger;
+        this.proxy = proxy;
+        this.extension = extension;
+        this.offset = 0;
+        this._disposed = false;
+        this.visible = false;
+        this.setLevel(logger.getLevel());
+        this._register(logger.onDidChangeLogLevel(level => this.setLevel(level)));
+    }
+    get logLevel() {
+        return this.getLevel();
+    }
+    appendLine(value) {
+        this.append(value + '\n');
+    }
+    append(value) {
+        this.info(value);
+    }
+    clear() {
+        const till = this.offset;
+        this.logger.flush();
+        this.proxy.$update(this.id, OutputChannelUpdateMode.Clear, till);
+    }
+    replace(value) {
+        const till = this.offset;
+        this.info(value);
+        this.proxy.$update(this.id, OutputChannelUpdateMode.Replace, till);
+        if (this.visible) {
+            this.logger.flush();
+        }
+    }
+    show(columnOrPreserveFocus, preserveFocus) {
+        this.logger.flush();
+        this.proxy.$reveal(this.id, !!(typeof columnOrPreserveFocus === 'boolean' ? columnOrPreserveFocus : preserveFocus));
+    }
+    hide() {
+        this.proxy.$close(this.id);
+    }
+    log(level, message) {
+        this.offset += VSBuffer.fromString(message).byteLength;
+        log(this.logger, level, message);
+        if (this.visible) {
+            this.logger.flush();
+            this.proxy.$update(this.id, OutputChannelUpdateMode.Append);
+        }
+    }
+    dispose() {
+        super.dispose();
+        if (!this._disposed) {
+            this.proxy.$dispose(this.id);
+            this._disposed = true;
+        }
+    }
+}
+class ExtHostLogOutputChannel extends ExtHostOutputChannel {
+    appendLine(value) {
+        this.append(value);
+    }
+}
+let ExtHostOutputService = class ExtHostOutputService {
+    constructor(extHostRpc, initData, extHostFileSystem, extHostFileSystemInfo, loggerService, logService) {
+        this.initData = initData;
+        this.extHostFileSystem = extHostFileSystem;
+        this.extHostFileSystemInfo = extHostFileSystemInfo;
+        this.loggerService = loggerService;
+        this.logService = logService;
+        this.extensionLogDirectoryPromise = ( new Map());
+        this.namePool = 1;
+        this.channels = ( new Map());
+        this.visibleChannelId = null;
+        this.proxy = ( extHostRpc.getProxy(MainContext.MainThreadOutputService));
+        this.outputsLocation = this.extHostFileSystemInfo.extUri.joinPath(initData.logsLocation, `output_logging_${toLocalISOString(( new Date())).replace(/-|:|\.\d+Z$/g, '')}`);
+    }
+    $setVisibleChannel(visibleChannelId) {
+        this.visibleChannelId = visibleChannelId;
+        for (const [id, channel] of this.channels) {
+            channel.visible = id === this.visibleChannelId;
+        }
+    }
+    createOutputChannel(name, options, extension) {
+        name = name.trim();
+        if (!name) {
+            throw new Error('illegal argument `name`. must not be falsy');
+        }
+        const log = typeof options === 'object' && options.log;
+        const languageId = isString(options) ? options : undefined;
+        if (isString(languageId) && !languageId.trim()) {
+            throw new Error('illegal argument `languageId`. must not be empty');
+        }
+        let logLevel;
+        const logLevelValue = this.initData.environment.extensionLogLevel?.find(([identifier]) => ExtensionIdentifier.equals(extension.identifier, identifier))?.[1];
+        if (logLevelValue) {
+            logLevel = parseLogLevel(logLevelValue);
+        }
+        const extHostOutputChannel = log ? this.doCreateLogOutputChannel(name, logLevel, extension) : this.doCreateOutputChannel(name, languageId, extension);
+        extHostOutputChannel.then(channel => {
+            this.channels.set(channel.id, channel);
+            channel.visible = channel.id === this.visibleChannelId;
+        });
+        return log ? this.createExtHostLogOutputChannel(name, logLevel ?? this.logService.getLevel(), extHostOutputChannel) : this.createExtHostOutputChannel(name, extHostOutputChannel);
+    }
+    async doCreateOutputChannel(name, languageId, extension) {
+        if (!this.outputDirectoryPromise) {
+            this.outputDirectoryPromise = this.extHostFileSystem.value.createDirectory(this.outputsLocation).then(() => this.outputsLocation);
+        }
+        const outputDir = await this.outputDirectoryPromise;
+        const file = this.extHostFileSystemInfo.extUri.joinPath(outputDir, `${this.namePool++}-${name.replace(/[\\/:\*\?"<>\|]/g, '')}.log`);
+        const logger = this.loggerService.createLogger(file, { logLevel: 'always', donotRotate: true, donotUseFormatters: true, hidden: true });
+        const id = await this.proxy.$register(name, file, languageId, extension.identifier.value);
+        return ( new ExtHostOutputChannel(id, name, logger, this.proxy, extension));
+    }
+    async doCreateLogOutputChannel(name, logLevel, extension) {
+        const extensionLogDir = await this.createExtensionLogDirectory(extension);
+        const fileName = name.replace(/[\\/:\*\?"<>\|]/g, '');
+        const file = this.extHostFileSystemInfo.extUri.joinPath(extensionLogDir, `${fileName}.log`);
+        const id = `${extension.identifier.value}.${fileName}`;
+        const logger = this.loggerService.createLogger(file, { id, name, logLevel, extensionId: extension.identifier.value });
+        return ( new ExtHostLogOutputChannel(id, name, logger, this.proxy, extension));
+    }
+    createExtensionLogDirectory(extension) {
+        let extensionLogDirectoryPromise = this.extensionLogDirectoryPromise.get(extension.identifier.value);
+        if (!extensionLogDirectoryPromise) {
+            const extensionLogDirectory = this.extHostFileSystemInfo.extUri.joinPath(this.initData.logsLocation, extension.identifier.value);
+            this.extensionLogDirectoryPromise.set(extension.identifier.value, extensionLogDirectoryPromise = (async () => {
+                try {
+                    await this.extHostFileSystem.value.createDirectory(extensionLogDirectory);
+                }
+                catch (err) {
+                    if (toFileSystemProviderErrorCode(err) !== FileSystemProviderErrorCode.FileExists) {
+                        throw err;
+                    }
+                }
+                return extensionLogDirectory;
+            })());
+        }
+        return extensionLogDirectoryPromise;
+    }
+    createExtHostOutputChannel(name, channelPromise) {
+        let disposed = false;
+        const validate = () => {
+            if (disposed) {
+                throw new Error('Channel has been closed');
+            }
+        };
+        return {
+            get name() { return name; },
+            append(value) {
+                validate();
+                channelPromise.then(channel => channel.append(value));
+            },
+            appendLine(value) {
+                validate();
+                channelPromise.then(channel => channel.appendLine(value));
+            },
+            clear() {
+                validate();
+                channelPromise.then(channel => channel.clear());
+            },
+            replace(value) {
+                validate();
+                channelPromise.then(channel => channel.replace(value));
+            },
+            show(columnOrPreserveFocus, preserveFocus) {
+                validate();
+                channelPromise.then(channel => channel.show(columnOrPreserveFocus, preserveFocus));
+            },
+            hide() {
+                validate();
+                channelPromise.then(channel => channel.hide());
+            },
+            dispose() {
+                disposed = true;
+                channelPromise.then(channel => channel.dispose());
+            }
+        };
+    }
+    createExtHostLogOutputChannel(name, logLevel, channelPromise) {
+        const disposables = ( new DisposableStore());
+        const validate = () => {
+            if (disposables.isDisposed) {
+                throw new Error('Channel has been closed');
+            }
+        };
+        const onDidChangeLogLevel = disposables.add(( new Emitter()));
+        function setLogLevel(newLogLevel) {
+            logLevel = newLogLevel;
+            onDidChangeLogLevel.fire(newLogLevel);
+        }
+        channelPromise.then(channel => {
+            disposables.add(channel);
+            if (channel.logLevel !== logLevel) {
+                setLogLevel(channel.logLevel);
+            }
+            disposables.add(channel.onDidChangeLogLevel(e => setLogLevel(e)));
+        });
+        return {
+            ...this.createExtHostOutputChannel(name, channelPromise),
+            get logLevel() { return logLevel; },
+            onDidChangeLogLevel: onDidChangeLogLevel.event,
+            trace(value, ...args) {
+                validate();
+                channelPromise.then(channel => channel.trace(value, ...args));
+            },
+            debug(value, ...args) {
+                validate();
+                channelPromise.then(channel => channel.debug(value, ...args));
+            },
+            info(value, ...args) {
+                validate();
+                channelPromise.then(channel => channel.info(value, ...args));
+            },
+            warn(value, ...args) {
+                validate();
+                channelPromise.then(channel => channel.warn(value, ...args));
+            },
+            error(value, ...args) {
+                validate();
+                channelPromise.then(channel => channel.error(value, ...args));
+            },
+            dispose() {
+                disposables.dispose();
+            }
+        };
+    }
+};
+ExtHostOutputService = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService)),
+    ( __param(2, IExtHostConsumerFileSystem)),
+    ( __param(3, IExtHostFileSystemInfo)),
+    ( __param(4, ILoggerService)),
+    ( __param(5, ILogService))
+], ExtHostOutputService));
+const IExtHostOutputService = ( createDecorator('IExtHostOutputService'));
+export { ExtHostOutputService, IExtHostOutputService };