@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/contrib/files/common/explorerModel.js

@@ -0,0 +1,369 @@
+import { __decorate } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { equalsIgnoreCase, startsWithIgnoreCase, rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { basenameOrAuthority, isEqualOrParent, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ExplorerFileNestingTrie } from './explorerFileNestingTrie.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+class ExplorerModel {
+    constructor(contextService, uriIdentityService, fileService, configService) {
+        this.contextService = contextService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidChangeRoots = ( new Emitter());
+        const setRoots = () => this._roots = ( this.contextService.getWorkspace().folders
+            .map(folder => ( new ExplorerItem(
+            folder.uri,
+            fileService,
+            configService,
+            undefined,
+            true,
+            false,
+            false,
+            folder.name
+        ))));
+        setRoots();
+        this._listener = this.contextService.onDidChangeWorkspaceFolders(() => {
+            setRoots();
+            this._onDidChangeRoots.fire();
+        });
+    }
+    get roots() {
+        return this._roots;
+    }
+    get onDidChangeRoots() {
+        return this._onDidChangeRoots.event;
+    }
+    findAll(resource) {
+        return coalesce(( this.roots.map(root => root.find(resource))));
+    }
+    findClosest(resource) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        if (folder) {
+            const root = this.roots.find(r => this.uriIdentityService.extUri.isEqual(r.resource, folder.uri));
+            if (root) {
+                return root.find(resource);
+            }
+        }
+        return null;
+    }
+    dispose() {
+        dispose(this._listener);
+    }
+}
+class ExplorerItem {
+    constructor(resource, fileService, configService, _parent, _isDirectory, _isSymbolicLink, _readonly, _name = basenameOrAuthority(resource), _mtime, _unknown = false) {
+        this.resource = resource;
+        this.fileService = fileService;
+        this.configService = configService;
+        this._parent = _parent;
+        this._isDirectory = _isDirectory;
+        this._isSymbolicLink = _isSymbolicLink;
+        this._readonly = _readonly;
+        this._name = _name;
+        this._mtime = _mtime;
+        this._unknown = _unknown;
+        this.error = undefined;
+        this._isExcluded = false;
+        this._isDirectoryResolved = false;
+    }
+    get isExcluded() {
+        if (this._isExcluded) {
+            return true;
+        }
+        if (!this._parent) {
+            return false;
+        }
+        return this._parent.isExcluded;
+    }
+    set isExcluded(value) {
+        this._isExcluded = value;
+    }
+    hasChildren(filter) {
+        if (this.hasNests) {
+            return this.nestedChildren?.some(c => filter(c)) ?? false;
+        }
+        else {
+            return this.isDirectory;
+        }
+    }
+    get hasNests() {
+        return !!(this.nestedChildren?.length);
+    }
+    get isDirectoryResolved() {
+        return this._isDirectoryResolved;
+    }
+    get isSymbolicLink() {
+        return !!this._isSymbolicLink;
+    }
+    get isDirectory() {
+        return !!this._isDirectory;
+    }
+    get isReadonly() {
+        return this._readonly || this.fileService.hasCapability(this.resource, 2048 );
+    }
+    get mtime() {
+        return this._mtime;
+    }
+    get name() {
+        return this._name;
+    }
+    get isUnknown() {
+        return this._unknown;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get root() {
+        if (!this._parent) {
+            return this;
+        }
+        return this._parent.root;
+    }
+    get children() {
+        return ( new Map());
+    }
+    updateName(value) {
+        this._parent?.removeChild(this);
+        this._name = value;
+        this._parent?.addChild(this);
+    }
+    getId() {
+        return ( this.root.resource.toString()) + '::' + ( this.resource.toString());
+    }
+    toString() {
+        return `ExplorerItem: ${this.name}`;
+    }
+    get isRoot() {
+        return this === this.root;
+    }
+    static create(fileService, configService, raw, parent, resolveTo) {
+        const stat = ( new ExplorerItem(
+            raw.resource,
+            fileService,
+            configService,
+            parent,
+            raw.isDirectory,
+            raw.isSymbolicLink,
+            raw.readonly,
+            raw.name,
+            raw.mtime,
+            !raw.isFile && !raw.isDirectory
+        ));
+        if (stat.isDirectory) {
+            stat._isDirectoryResolved = !!raw.children || (!!resolveTo && ( resolveTo.some((r) => {
+                return isEqualOrParent(r, stat.resource);
+            })));
+            if (raw.children) {
+                for (let i = 0, len = raw.children.length; i < len; i++) {
+                    const child = ExplorerItem.create(fileService, configService, raw.children[i], stat, resolveTo);
+                    stat.addChild(child);
+                }
+            }
+        }
+        return stat;
+    }
+    static mergeLocalWithDisk(disk, local) {
+        if (( disk.resource.toString()) !== ( local.resource.toString())) {
+            return;
+        }
+        const mergingDirectories = disk.isDirectory || local.isDirectory;
+        if (mergingDirectories && local._isDirectoryResolved && !disk._isDirectoryResolved) {
+            return;
+        }
+        local.resource = disk.resource;
+        if (!local.isRoot) {
+            local.updateName(disk.name);
+        }
+        local._isDirectory = disk.isDirectory;
+        local._mtime = disk.mtime;
+        local._isDirectoryResolved = disk._isDirectoryResolved;
+        local._isSymbolicLink = disk.isSymbolicLink;
+        local.error = disk.error;
+        if (mergingDirectories && disk._isDirectoryResolved) {
+            const oldLocalChildren = ( new ResourceMap());
+            local.children.forEach(child => {
+                oldLocalChildren.set(child.resource, child);
+            });
+            local.children.clear();
+            disk.children.forEach(diskChild => {
+                const formerLocalChild = oldLocalChildren.get(diskChild.resource);
+                if (formerLocalChild) {
+                    ExplorerItem.mergeLocalWithDisk(diskChild, formerLocalChild);
+                    local.addChild(formerLocalChild);
+                    oldLocalChildren.delete(diskChild.resource);
+                }
+                else {
+                    local.addChild(diskChild);
+                }
+            });
+            oldLocalChildren.forEach(oldChild => {
+                if (oldChild instanceof NewExplorerItem) {
+                    local.addChild(oldChild);
+                }
+            });
+        }
+    }
+    addChild(child) {
+        child._parent = this;
+        child.updateResource(false);
+        this.children.set(this.getPlatformAwareName(child.name), child);
+    }
+    getChild(name) {
+        return this.children.get(this.getPlatformAwareName(name));
+    }
+    fetchChildren(sortOrder) {
+        const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
+        if (nestingConfig.enabled && this.nestedChildren) {
+            return this.nestedChildren;
+        }
+        return (async () => {
+            if (!this._isDirectoryResolved) {
+                const resolveMetadata = sortOrder === "modified" ;
+                this.error = undefined;
+                try {
+                    const stat = await this.fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
+                    const resolved = ExplorerItem.create(this.fileService, this.configService, stat, this);
+                    ExplorerItem.mergeLocalWithDisk(resolved, this);
+                }
+                catch (e) {
+                    this.error = e;
+                    throw e;
+                }
+                this._isDirectoryResolved = true;
+            }
+            const items = [];
+            if (nestingConfig.enabled) {
+                const fileChildren = [];
+                const dirChildren = [];
+                for (const child of this.children.entries()) {
+                    child[1].nestedParent = undefined;
+                    if (child[1].isDirectory) {
+                        dirChildren.push(child);
+                    }
+                    else {
+                        fileChildren.push(child);
+                    }
+                }
+                const nested = this.fileNester.nest(( fileChildren.map(([name]) => name)), this.getPlatformAwareName(this.name));
+                for (const [fileEntryName, fileEntryItem] of fileChildren) {
+                    const nestedItems = nested.get(fileEntryName);
+                    if (nestedItems !== undefined) {
+                        fileEntryItem.nestedChildren = [];
+                        for (const name of ( nestedItems.keys())) {
+                            const child = assertIsDefined(this.children.get(name));
+                            fileEntryItem.nestedChildren.push(child);
+                            child.nestedParent = fileEntryItem;
+                        }
+                        items.push(fileEntryItem);
+                    }
+                    else {
+                        fileEntryItem.nestedChildren = undefined;
+                    }
+                }
+                for (const [_, dirEntryItem] of ( dirChildren.values())) {
+                    items.push(dirEntryItem);
+                }
+            }
+            else {
+                this.children.forEach(child => {
+                    items.push(child);
+                });
+            }
+            return items;
+        })();
+    }
+    get fileNester() {
+        if (!this.root._fileNester) {
+            const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
+            const patterns = ( Object.entries(nestingConfig.patterns)
+                .filter(entry => typeof (entry[0]) === 'string' && typeof (entry[1]) === 'string' && entry[0] && entry[1])
+                .map(([parentPattern, childrenPatterns]) => [
+                this.getPlatformAwareName(parentPattern.trim()),
+                ( childrenPatterns.split(',').map(p => this.getPlatformAwareName(p.trim().replace(/\u200b/g, ''))))
+            ]));
+            this.root._fileNester = ( new ExplorerFileNestingTrie(patterns));
+        }
+        return this.root._fileNester;
+    }
+    removeChild(child) {
+        this.nestedChildren = undefined;
+        this.children.delete(this.getPlatformAwareName(child.name));
+    }
+    forgetChildren() {
+        this.children.clear();
+        this.nestedChildren = undefined;
+        this._isDirectoryResolved = false;
+        this._fileNester = undefined;
+    }
+    getPlatformAwareName(name) {
+        return this.fileService.hasCapability(this.resource, 1024 ) ? name : name.toLowerCase();
+    }
+    move(newParent) {
+        this.nestedParent?.removeChild(this);
+        this._parent?.removeChild(this);
+        newParent.removeChild(this);
+        newParent.addChild(this);
+        this.updateResource(true);
+    }
+    updateResource(recursive) {
+        if (this._parent) {
+            this.resource = joinPath(this._parent.resource, this.name);
+        }
+        if (recursive) {
+            if (this.isDirectory) {
+                this.children.forEach(child => {
+                    child.updateResource(true);
+                });
+            }
+        }
+    }
+    rename(renamedStat) {
+        this.updateName(renamedStat.name);
+        this._mtime = renamedStat.mtime;
+        this.updateResource(true);
+    }
+    find(resource) {
+        const ignoreCase = !this.fileService.hasCapability(resource, 1024 );
+        if (resource && this.resource.scheme === resource.scheme && equalsIgnoreCase(this.resource.authority, resource.authority) &&
+            (ignoreCase ? startsWithIgnoreCase(resource.path, this.resource.path) : resource.path.startsWith(this.resource.path))) {
+            return this.findByPath(rtrim(resource.path, posix.sep), this.resource.path.length, ignoreCase);
+        }
+        return null;
+    }
+    findByPath(path, index, ignoreCase) {
+        if (isEqual(rtrim(this.resource.path, posix.sep), path, ignoreCase)) {
+            return this;
+        }
+        if (this.isDirectory) {
+            while (index < path.length && path[index] === posix.sep) {
+                index++;
+            }
+            let indexOfNextSep = path.indexOf(posix.sep, index);
+            if (indexOfNextSep === -1) {
+                indexOfNextSep = path.length;
+            }
+            const name = path.substring(index, indexOfNextSep);
+            const child = this.children.get(this.getPlatformAwareName(name));
+            if (child) {
+                return child.findByPath(path, indexOfNextSep, ignoreCase);
+            }
+        }
+        return null;
+    }
+}
+ExplorerItem.__decorator = ( __decorate([
+    memoize
+], ExplorerItem.prototype, "children", null));
+class NewExplorerItem extends ExplorerItem {
+    constructor(fileService, configService, parent, isDirectory) {
+        super(URI.file(''), fileService, configService, parent, isDirectory);
+        this._isDirectoryResolved = true;
+    }
+}
+export { ExplorerItem, ExplorerModel, NewExplorerItem };

package/dist/{files2.js → vscode/vs/workbench/contrib/files/common/files.js}

@@ -29,4 +29,4 @@ const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
 const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
 const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
 const BINARY_TEXT_FILE_MODE = 'code-text-binary';
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, FILE_EDITOR_INPUT_ID, TEXT_FILE_EDITOR_ID, VIEWLET_ID };
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerFocusedContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusedContext, FoldersViewVisibleContext, TEXT_FILE_EDITOR_ID, VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/markers/common/markers.js

@@ -0,0 +1,20 @@
+var Markers;
+( (function(Markers) {
+    Markers.MARKERS_CONTAINER_ID = 'workbench.panel.markers';
+    Markers.MARKERS_VIEW_ID = 'workbench.panel.markers.view';
+    Markers.MARKERS_VIEW_STORAGE_ID = 'workbench.panel.markers';
+    Markers.MARKER_COPY_ACTION_ID = 'problems.action.copy';
+    Markers.MARKER_COPY_MESSAGE_ACTION_ID = 'problems.action.copyMessage';
+    Markers.RELATED_INFORMATION_COPY_MESSAGE_ACTION_ID = 'problems.action.copyRelatedInformationMessage';
+    Markers.FOCUS_PROBLEMS_FROM_FILTER = 'problems.action.focusProblemsFromFilter';
+    Markers.MARKERS_VIEW_FOCUS_FILTER = 'problems.action.focusFilter';
+    Markers.MARKERS_VIEW_CLEAR_FILTER_TEXT = 'problems.action.clearFilterText';
+    Markers.MARKERS_VIEW_SHOW_MULTILINE_MESSAGE = 'problems.action.showMultilineMessage';
+    Markers.MARKERS_VIEW_SHOW_SINGLELINE_MESSAGE = 'problems.action.showSinglelineMessage';
+    Markers.MARKER_OPEN_ACTION_ID = 'problems.action.open';
+    Markers.MARKER_OPEN_SIDE_ACTION_ID = 'problems.action.openToSide';
+    Markers.MARKER_SHOW_PANEL_ID = 'workbench.action.showErrorsWarnings';
+    Markers.MARKER_SHOW_QUICK_FIX = 'problems.action.showQuickFixes';
+    Markers.TOGGLE_MARKERS_VIEW_ACTION_ID = 'workbench.actions.view.toggleProblems';
+})(Markers || (Markers = {})));
+export { Markers };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookCommon.js

@@ -0,0 +1,9 @@
+var CellKind;
+( (function(CellKind) {
+    CellKind[CellKind["Markup"] = 1] = "Markup";
+    CellKind[CellKind["Code"] = 2] = "Code";
+})(CellKind || (CellKind = {})));
+function isTextStreamMime(mimeType) {
+    return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
+}
+export { CellKind, isTextStreamMime };

package/dist/vscode/vs/workbench/contrib/output/browser/outputLinkProvider.js

@@ -0,0 +1,74 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { OUTPUT_MODE_ID, LOG_MODE_ID } from '../../../services/output/common/output.js';
+import { createWebWorker } from 'monaco-editor/esm/vs/editor/browser/services/webWorker.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+let OutputLinkProvider = class OutputLinkProvider {
+    constructor(contextService, modelService, languageConfigurationService, languageFeaturesService) {
+        this.contextService = contextService;
+        this.modelService = modelService;
+        this.languageConfigurationService = languageConfigurationService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.disposeWorkerScheduler = ( new RunOnceScheduler(() => this.disposeWorker(), OutputLinkProvider.DISPOSE_WORKER_TIME));
+        this.registerListeners();
+        this.updateLinkProviderWorker();
+    }
+    registerListeners() {
+        this.contextService.onDidChangeWorkspaceFolders(() => this.updateLinkProviderWorker());
+    }
+    updateLinkProviderWorker() {
+        const folders = this.contextService.getWorkspace().folders;
+        if (folders.length > 0) {
+            if (!this.linkProviderRegistration) {
+                this.linkProviderRegistration = this.languageFeaturesService.linkProvider.register([{ language: OUTPUT_MODE_ID, scheme: '*' }, { language: LOG_MODE_ID, scheme: '*' }], {
+                    provideLinks: async (model) => {
+                        const links = await this.provideLinks(model.uri);
+                        return links && { links };
+                    }
+                });
+            }
+        }
+        else {
+            dispose(this.linkProviderRegistration);
+            this.linkProviderRegistration = undefined;
+        }
+        this.disposeWorker();
+        this.disposeWorkerScheduler.cancel();
+    }
+    getOrCreateWorker() {
+        this.disposeWorkerScheduler.schedule();
+        if (!this.worker) {
+            const createData = {
+                workspaceFolders: ( this.contextService.getWorkspace().folders.map(folder => ( folder.uri.toString())))
+            };
+            this.worker = createWebWorker(this.modelService, this.languageConfigurationService, {
+                moduleId: 'vs/workbench/contrib/output/common/outputLinkComputer',
+                createData,
+                label: 'outputLinkComputer'
+            });
+        }
+        return this.worker;
+    }
+    async provideLinks(modelUri) {
+        const linkComputer = await this.getOrCreateWorker().withSyncedResources([modelUri]);
+        return linkComputer.computeLinks(( modelUri.toString()));
+    }
+    disposeWorker() {
+        if (this.worker) {
+            this.worker.dispose();
+            this.worker = undefined;
+        }
+    }
+};
+OutputLinkProvider.DISPOSE_WORKER_TIME = 3 * 60 * 1000;
+OutputLinkProvider = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageConfigurationService)),
+    ( __param(3, ILanguageFeaturesService))
+], OutputLinkProvider));
+export { OutputLinkProvider };

package/dist/vscode/vs/workbench/contrib/output/browser/outputServices.js

@@ -0,0 +1,166 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, OUTPUT_SCHEME, OUTPUT_VIEW_ID, Extensions, LOG_MIME, OUTPUT_MIME } from '../../../services/output/common/output.js';
+import { OutputLinkProvider } from './outputLinkProvider.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IViewsService } from '../../../common/views.js';
+import { IOutputChannelModelService } from '../common/outputChannelModelService.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const OUTPUT_ACTIVE_CHANNEL_KEY = 'output.activechannel';
+let OutputChannel = class OutputChannel extends Disposable {
+    constructor(outputChannelDescriptor, outputChannelModelService, languageService) {
+        super();
+        this.outputChannelDescriptor = outputChannelDescriptor;
+        this.scrollLock = false;
+        this.id = outputChannelDescriptor.id;
+        this.label = outputChannelDescriptor.label;
+        this.uri = ( URI.from({ scheme: OUTPUT_SCHEME, path: this.id }));
+        this.model = this._register(outputChannelModelService.createOutputChannelModel(this.id, this.uri, outputChannelDescriptor.languageId ? languageService.createById(outputChannelDescriptor.languageId) : languageService.createByMimeType(outputChannelDescriptor.log ? LOG_MIME : OUTPUT_MIME), outputChannelDescriptor.file));
+    }
+    append(output) {
+        this.model.append(output);
+    }
+    update(mode, till) {
+        this.model.update(mode, till, true);
+    }
+    clear() {
+        this.model.clear();
+    }
+    replace(value) {
+        this.model.replace(value);
+    }
+};
+OutputChannel = ( __decorate([
+    ( __param(1, IOutputChannelModelService)),
+    ( __param(2, ILanguageService))
+], OutputChannel));
+let OutputService = class OutputService extends Disposable {
+    constructor(storageService, instantiationService, textModelResolverService, logService, lifecycleService, viewsService, contextKeyService) {
+        super();
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.lifecycleService = lifecycleService;
+        this.viewsService = viewsService;
+        this.channels = ( new Map());
+        this._onActiveOutputChannel = this._register(( new Emitter()));
+        this.onActiveOutputChannel = this._onActiveOutputChannel.event;
+        this.activeChannelIdInStorage = this.storageService.get(OUTPUT_ACTIVE_CHANNEL_KEY, 1 , '');
+        this.activeOutputChannelContext = ACTIVE_OUTPUT_CHANNEL_CONTEXT.bindTo(contextKeyService);
+        this.activeOutputChannelContext.set(this.activeChannelIdInStorage);
+        this._register(this.onActiveOutputChannel(channel => this.activeOutputChannelContext.set(channel)));
+        this.activeLogOutputChannelContext = CONTEXT_ACTIVE_LOG_OUTPUT.bindTo(contextKeyService);
+        textModelResolverService.registerTextModelContentProvider(OUTPUT_SCHEME, this);
+        instantiationService.createInstance(OutputLinkProvider);
+        const registry = ( Registry.as(Extensions.OutputChannels));
+        for (const channelIdentifier of registry.getChannels()) {
+            this.onDidRegisterChannel(channelIdentifier.id);
+        }
+        this._register(registry.onDidRegisterChannel(this.onDidRegisterChannel, this));
+        if (!this.activeChannel) {
+            const channels = this.getChannelDescriptors();
+            this.setActiveChannel(channels && channels.length > 0 ? this.getChannel(channels[0].id) : undefined);
+        }
+        this._register(Event.filter(this.viewsService.onDidChangeViewVisibility, e => e.id === OUTPUT_VIEW_ID && e.visible)(() => {
+            if (this.activeChannel) {
+                this.viewsService.getActiveViewWithId(OUTPUT_VIEW_ID)?.showChannel(this.activeChannel, true);
+            }
+        }));
+        this._register(this.lifecycleService.onDidShutdown(() => this.dispose()));
+    }
+    provideTextContent(resource) {
+        const channel = this.getChannel(resource.path);
+        if (channel) {
+            return channel.model.loadModel();
+        }
+        return null;
+    }
+    async showChannel(id, preserveFocus) {
+        const channel = this.getChannel(id);
+        if (this.activeChannel?.id !== channel?.id) {
+            this.setActiveChannel(channel);
+            this._onActiveOutputChannel.fire(id);
+        }
+        const outputView = await this.viewsService.openView(OUTPUT_VIEW_ID, !preserveFocus);
+        if (outputView && channel) {
+            outputView.showChannel(channel, !!preserveFocus);
+        }
+    }
+    getChannel(id) {
+        return this.channels.get(id);
+    }
+    getChannelDescriptor(id) {
+        return ( Registry.as(Extensions.OutputChannels)).getChannel(id);
+    }
+    getChannelDescriptors() {
+        return ( Registry.as(Extensions.OutputChannels)).getChannels();
+    }
+    getActiveChannel() {
+        return this.activeChannel;
+    }
+    async onDidRegisterChannel(channelId) {
+        const channel = this.createChannel(channelId);
+        this.channels.set(channelId, channel);
+        if (!this.activeChannel || this.activeChannelIdInStorage === channelId) {
+            this.setActiveChannel(channel);
+            this._onActiveOutputChannel.fire(channelId);
+            const outputView = this.viewsService.getActiveViewWithId(OUTPUT_VIEW_ID);
+            outputView?.showChannel(channel, true);
+        }
+    }
+    createChannel(id) {
+        const channelDisposables = [];
+        const channel = this.instantiateChannel(id);
+        channel.model.onDispose(() => {
+            if (this.activeChannel === channel) {
+                const channels = this.getChannelDescriptors();
+                const channel = channels.length ? this.getChannel(channels[0].id) : undefined;
+                if (channel && this.viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
+                    this.showChannel(channel.id);
+                }
+                else {
+                    this.setActiveChannel(undefined);
+                }
+            }
+            ( Registry.as(Extensions.OutputChannels)).removeChannel(id);
+            dispose(channelDisposables);
+        }, channelDisposables);
+        return channel;
+    }
+    instantiateChannel(id) {
+        const channelData = ( Registry.as(Extensions.OutputChannels)).getChannel(id);
+        if (!channelData) {
+            this.logService.error(`Channel '${id}' is not registered yet`);
+            throw new Error(`Channel '${id}' is not registered yet`);
+        }
+        return this.instantiationService.createInstance(OutputChannel, channelData);
+    }
+    setActiveChannel(channel) {
+        this.activeChannel = channel;
+        this.activeLogOutputChannelContext.set(!!channel?.outputChannelDescriptor?.file && channel?.outputChannelDescriptor?.log);
+        if (this.activeChannel) {
+            this.storageService.store(OUTPUT_ACTIVE_CHANNEL_KEY, this.activeChannel.id, 1 , 0 );
+        }
+        else {
+            this.storageService.remove(OUTPUT_ACTIVE_CHANNEL_KEY, 1 );
+        }
+    }
+};
+OutputService = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, ILogService)),
+    ( __param(4, ILifecycleService)),
+    ( __param(5, IViewsService)),
+    ( __param(6, IContextKeyService))
+], OutputService));
+export { OutputService };