@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/debug/browser/debugHover.js

@@ -1,354 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import * as lifecycle from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { editorHoverBackground, asCssVariable, editorHoverBorder, editorHoverForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { renderExpressionValue } from './baseDebugView.js';
-import { LinkDetector } from './linkDetector.js';
-import { VariablesRenderer } from './variablesView.js';
-import { IDebugService } from '../common/debug.js';
-import { Variable, Expression } from '../common/debugModel.js';
-import { getEvaluatableExpressionAtPosition } from '../common/debugUtils.js';
-var DebugHoverWidget_1;
-const $ = dom.$;
-async function doFindExpression(container, namesToFind) {
-    if (!container) {
-        return null;
-    }
-    const children = await container.getChildren();
-    const filtered = children.filter(v => namesToFind[0] === v.name);
-    if (filtered.length !== 1) {
-        return null;
-    }
-    if (namesToFind.length === 1) {
-        return filtered[0];
-    }
-    else {
-        return doFindExpression(filtered[0], namesToFind.slice(1));
-    }
-}
-async function findExpressionInStackFrame(stackFrame, namesToFind) {
-    const scopes = await stackFrame.getScopes();
-    const nonExpensive = scopes.filter(s => !s.expensive);
-    const expressions = coalesce(await Promise.all(( nonExpensive.map(scope => doFindExpression(scope, namesToFind)))));
-    return expressions.length > 0 && expressions.every(e => e.value === expressions[0].value) ? expressions[0] : undefined;
-}
-let DebugHoverWidget = class DebugHoverWidget {
-    static { DebugHoverWidget_1 = this; }
-    static { this.ID = 'debug.hoverWidget'; }
-    constructor(editor, debugService, instantiationService) {
-        this.editor = editor;
-        this.debugService = debugService;
-        this.instantiationService = instantiationService;
-        this.allowEditorOverflow = true;
-        this.highlightDecorations = this.editor.createDecorationsCollection();
-        this.isUpdatingTree = false;
-        this.toDispose = [];
-        this._isVisible = false;
-        this.showAtPosition = null;
-        this.positionPreference = [1 , 2 ];
-        this.debugHoverComputer = this.instantiationService.createInstance(DebugHoverComputer, this.editor);
-    }
-    create() {
-        this.domNode = $('.debug-hover-widget');
-        this.complexValueContainer = dom.append(this.domNode, $('.complex-value'));
-        this.complexValueTitle = dom.append(this.complexValueContainer, $('.title'));
-        this.treeContainer = dom.append(this.complexValueContainer, $('.debug-hover-tree'));
-        this.treeContainer.setAttribute('role', 'tree');
-        const tip = dom.append(this.complexValueContainer, $('.tip'));
-        tip.textContent = ( nls.localize(
-            { key: 'quickTip', comment: ['"switch to editor language hover" means to show the programming language hover widget instead of the debug hover'] },
-            'Hold {0} key to switch to editor language hover',
-            isMacintosh ? 'Option' : 'Alt'
-        ));
-        const dataSource = ( new DebugHoverDataSource());
-        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'DebugHover', this.treeContainer, ( new DebugHoverDelegate()), [this.instantiationService.createInstance(VariablesRenderer, linkeDetector)], dataSource, {
-            accessibilityProvider: ( new DebugHoverAccessibilityProvider()),
-            mouseSupport: false,
-            horizontalScrolling: true,
-            useShadows: false,
-            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
-            overrideStyles: {
-                listBackground: editorHoverBackground
-            }
-        });
-        this.valueContainer = $('.value');
-        this.valueContainer.tabIndex = 0;
-        this.valueContainer.setAttribute('role', 'tooltip');
-        this.scrollbar = ( new DomScrollableElement(this.valueContainer, { horizontal: 2  }));
-        this.domNode.appendChild(this.scrollbar.getDomNode());
-        this.toDispose.push(this.scrollbar);
-        this.editor.applyFontInfo(this.domNode);
-        this.domNode.style.backgroundColor = asCssVariable(editorHoverBackground);
-        this.domNode.style.border = `1px solid ${asCssVariable(editorHoverBorder)}`;
-        this.domNode.style.color = asCssVariable(editorHoverForeground);
-        this.toDispose.push(this.tree.onDidChangeContentHeight(() => {
-            if (!this.isUpdatingTree) {
-                this.layoutTreeAndContainer();
-            }
-        }));
-        this.toDispose.push(this.tree.onDidChangeContentWidth(() => {
-            if (!this.isUpdatingTree) {
-                this.layoutTreeAndContainer();
-            }
-        }));
-        this.registerListeners();
-        this.editor.addContentWidget(this);
-    }
-    registerListeners() {
-        this.toDispose.push(dom.addStandardDisposableListener(this.domNode, 'keydown', (e) => {
-            if (e.equals(9 )) {
-                this.hide();
-            }
-        }));
-        this.toDispose.push(this.editor.onDidChangeConfiguration((e) => {
-            if (e.hasChanged(49 )) {
-                this.editor.applyFontInfo(this.domNode);
-            }
-        }));
-        this.toDispose.push(this.debugService.getViewModel().onDidEvaluateLazyExpression(async (e) => {
-            if (e instanceof Variable && this.tree.hasNode(e)) {
-                await this.tree.updateChildren(e, false, true);
-                await this.tree.expand(e);
-            }
-        }));
-    }
-    isHovered() {
-        return !!this.domNode?.matches(':hover');
-    }
-    isVisible() {
-        return this._isVisible;
-    }
-    willBeVisible() {
-        return !!this.showCancellationSource;
-    }
-    getId() {
-        return DebugHoverWidget_1.ID;
-    }
-    getDomNode() {
-        return this.domNode;
-    }
-    async showAt(position, focus) {
-        this.showCancellationSource?.cancel();
-        const cancellationSource = this.showCancellationSource = ( new CancellationTokenSource());
-        const session = this.debugService.getViewModel().focusedSession;
-        if (!session || !this.editor.hasModel()) {
-            this.hide();
-            return 1 ;
-        }
-        const result = await this.debugHoverComputer.compute(position, cancellationSource.token);
-        if (cancellationSource.token.isCancellationRequested) {
-            this.hide();
-            return 2 ;
-        }
-        if (!result.range) {
-            this.hide();
-            return 1 ;
-        }
-        if (this.isVisible() && !result.rangeChanged) {
-            return 0 ;
-        }
-        const expression = await this.debugHoverComputer.evaluate(session);
-        if (cancellationSource.token.isCancellationRequested) {
-            this.hide();
-            return 2 ;
-        }
-        if (!expression || (expression instanceof Expression && !expression.available)) {
-            this.hide();
-            return 1 ;
-        }
-        this.highlightDecorations.set([{
-                range: result.range,
-                options: DebugHoverWidget_1._HOVER_HIGHLIGHT_DECORATION_OPTIONS
-            }]);
-        return this.doShow(result.range.getStartPosition(), expression, focus);
-    }
-    static { this._HOVER_HIGHLIGHT_DECORATION_OPTIONS = ModelDecorationOptions.register({
-        description: 'bdebug-hover-highlight',
-        className: 'hoverHighlight'
-    }); }
-    async doShow(position, expression, focus, forceValueHover = false) {
-        if (!this.domNode) {
-            this.create();
-        }
-        this.showAtPosition = position;
-        this._isVisible = true;
-        if (!expression.hasChildren || forceValueHover) {
-            this.complexValueContainer.hidden = true;
-            this.valueContainer.hidden = false;
-            renderExpressionValue(expression, this.valueContainer, {
-                showChanged: false,
-                colorize: true
-            });
-            this.valueContainer.title = '';
-            this.editor.layoutContentWidget(this);
-            this.scrollbar.scanDomNode();
-            if (focus) {
-                this.editor.render();
-                this.valueContainer.focus();
-            }
-            return undefined;
-        }
-        this.valueContainer.hidden = true;
-        this.expressionToRender = expression;
-        this.complexValueTitle.textContent = expression.value;
-        this.complexValueTitle.title = expression.value;
-        this.editor.layoutContentWidget(this);
-        this.tree.scrollTop = 0;
-        this.tree.scrollLeft = 0;
-        this.complexValueContainer.hidden = false;
-        if (focus) {
-            this.editor.render();
-            this.tree.domFocus();
-        }
-    }
-    layoutTreeAndContainer() {
-        this.layoutTree();
-        this.editor.layoutContentWidget(this);
-    }
-    layoutTree() {
-        const scrollBarHeight = 10;
-        const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight);
-        const realTreeWidth = this.tree.contentWidth;
-        const treeWidth = clamp(realTreeWidth, 400, 550);
-        this.tree.layout(treeHeight, treeWidth);
-        this.treeContainer.style.height = `${treeHeight}px`;
-        this.scrollbar.scanDomNode();
-    }
-    beforeRender() {
-        if (this.expressionToRender) {
-            const expression = this.expressionToRender;
-            this.expressionToRender = undefined;
-            this.isUpdatingTree = true;
-            this.tree.setInput(expression).finally(() => {
-                this.isUpdatingTree = false;
-            });
-        }
-        return null;
-    }
-    afterRender(positionPreference) {
-        if (positionPreference) {
-            this.positionPreference = [positionPreference];
-        }
-    }
-    hide() {
-        if (this.showCancellationSource) {
-            this.showCancellationSource.cancel();
-            this.showCancellationSource = undefined;
-        }
-        if (!this._isVisible) {
-            return;
-        }
-        if (dom.isAncestor(document.activeElement, this.domNode)) {
-            this.editor.focus();
-        }
-        this._isVisible = false;
-        this.highlightDecorations.clear();
-        this.editor.layoutContentWidget(this);
-        this.positionPreference = [1 , 2 ];
-    }
-    getPosition() {
-        return this._isVisible ? {
-            position: this.showAtPosition,
-            preference: this.positionPreference
-        } : null;
-    }
-    dispose() {
-        this.toDispose = lifecycle.dispose(this.toDispose);
-    }
-};
-DebugHoverWidget = DebugHoverWidget_1 = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IInstantiationService))
-], DebugHoverWidget));
-class DebugHoverAccessibilityProvider {
-    getWidgetAriaLabel() {
-        return ( nls.localize('treeAriaLabel', "Debug Hover"));
-    }
-    getAriaLabel(element) {
-        return ( nls.localize(
-            { key: 'variableAriaLabel', comment: ['Do not translate placeholders. Placeholders are name and value of a variable.'] },
-            "{0}, value {1}, variables, debug",
-            element.name,
-            element.value
-        ));
-    }
-}
-class DebugHoverDataSource {
-    hasChildren(element) {
-        return element.hasChildren;
-    }
-    getChildren(element) {
-        return element.getChildren();
-    }
-}
-class DebugHoverDelegate {
-    getHeight(element) {
-        return 18;
-    }
-    getTemplateId(element) {
-        return VariablesRenderer.ID;
-    }
-}
-let DebugHoverComputer = class DebugHoverComputer {
-    constructor(editor, debugService, languageFeaturesService, logService) {
-        this.editor = editor;
-        this.debugService = debugService;
-        this.languageFeaturesService = languageFeaturesService;
-        this.logService = logService;
-    }
-    async compute(position, token) {
-        const session = this.debugService.getViewModel().focusedSession;
-        if (!session || !this.editor.hasModel()) {
-            return { rangeChanged: false };
-        }
-        const model = this.editor.getModel();
-        const result = await getEvaluatableExpressionAtPosition(this.languageFeaturesService, model, position, token);
-        if (!result) {
-            return { rangeChanged: false };
-        }
-        const { range, matchingExpression } = result;
-        const rangeChanged = this._currentRange ?
-            !this._currentRange.equalsRange(range) :
-            true;
-        this._currentExpression = matchingExpression;
-        this._currentRange = Range.lift(range);
-        return { rangeChanged, range: this._currentRange };
-    }
-    async evaluate(session) {
-        if (!this._currentExpression) {
-            this.logService.error('No expression to evaluate');
-            return;
-        }
-        if (session.capabilities.supportsEvaluateForHovers) {
-            const expression = ( new Expression(this._currentExpression));
-            await expression.evaluate(session, this.debugService.getViewModel().focusedStackFrame, 'hover');
-            return expression;
-        }
-        else {
-            const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-            if (focusedStackFrame) {
-                return await findExpressionInStackFrame(focusedStackFrame, coalesce(( this._currentExpression.split('.').map(word => word.trim()))));
-            }
-        }
-        return undefined;
-    }
-};
-DebugHoverComputer = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, ILanguageFeaturesService)),
-    ( __param(3, ILogService))
-], DebugHoverComputer));
-export { DebugHoverWidget, findExpressionInStackFrame };

package/vscode/src/vs/workbench/contrib/debug/browser/debugMemory.js

@@ -1,204 +0,0 @@
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { toDisposable, DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
-import { assertNever } from 'monaco-editor/esm/vs/base/common/assert.js';
-import { FileType, FilePermission, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { DEBUG_MEMORY_SCHEME } from '../common/debug.js';
-const rangeRe = /range=([0-9]+):([0-9]+)/;
-class DebugMemoryFileSystemProvider {
-    constructor(debugService) {
-        this.debugService = debugService;
-        this.memoryFdCounter = 0;
-        this.fdMemory = ( new Map());
-        this.changeEmitter = ( new Emitter());
-        this.onDidChangeCapabilities = Event.None;
-        this.onDidChangeFile = this.changeEmitter.event;
-        this.capabilities = 0
-            | 1024
-            | 4 ;
-        debugService.onDidEndSession(session => {
-            for (const [fd, memory] of this.fdMemory) {
-                if (memory.session === session) {
-                    this.close(fd);
-                }
-            }
-        });
-    }
-    watch(resource, opts) {
-        if (opts.recursive) {
-            return toDisposable(() => { });
-        }
-        const { session, memoryReference, offset } = this.parseUri(resource);
-        const disposable = ( new DisposableStore());
-        disposable.add(session.onDidChangeState(() => {
-            if (session.state === 3  || session.state === 0 ) {
-                this.changeEmitter.fire([{ type: 2 , resource }]);
-            }
-        }));
-        disposable.add(session.onDidInvalidateMemory(e => {
-            if (e.body.memoryReference !== memoryReference) {
-                return;
-            }
-            if (offset && (e.body.offset >= offset.toOffset || e.body.offset + e.body.count < offset.fromOffset)) {
-                return;
-            }
-            this.changeEmitter.fire([{ resource, type: 0  }]);
-        }));
-        return disposable;
-    }
-    stat(file) {
-        const { readOnly } = this.parseUri(file);
-        return Promise.resolve({
-            type: FileType.File,
-            mtime: 0,
-            ctime: 0,
-            size: 0,
-            permissions: readOnly ? FilePermission.Readonly : undefined,
-        });
-    }
-    mkdir() {
-        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
-    }
-    readdir() {
-        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
-    }
-    delete() {
-        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
-    }
-    rename() {
-        throw createFileSystemProviderError(`Not allowed`, FileSystemProviderErrorCode.NoPermissions);
-    }
-    open(resource, _opts) {
-        const { session, memoryReference, offset } = this.parseUri(resource);
-        const fd = this.memoryFdCounter++;
-        let region = session.getMemory(memoryReference);
-        if (offset) {
-            region = ( new MemoryRegionView(region, offset));
-        }
-        this.fdMemory.set(fd, { session, region });
-        return Promise.resolve(fd);
-    }
-    close(fd) {
-        this.fdMemory.get(fd)?.region.dispose();
-        this.fdMemory.delete(fd);
-        return Promise.resolve();
-    }
-    async writeFile(resource, content) {
-        const { offset } = this.parseUri(resource);
-        if (!offset) {
-            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
-        }
-        const fd = await this.open(resource, { create: false });
-        try {
-            await this.write(fd, offset.fromOffset, content, 0, content.length);
-        }
-        finally {
-            this.close(fd);
-        }
-    }
-    async readFile(resource) {
-        const { offset } = this.parseUri(resource);
-        if (!offset) {
-            throw createFileSystemProviderError(`Range must be present to read a file`, FileSystemProviderErrorCode.FileNotFound);
-        }
-        const data = ( new Uint8Array(offset.toOffset - offset.fromOffset));
-        const fd = await this.open(resource, { create: false });
-        try {
-            await this.read(fd, offset.fromOffset, data, 0, data.length);
-            return data;
-        }
-        finally {
-            this.close(fd);
-        }
-    }
-    async read(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        const ranges = await memory.region.read(pos, length);
-        let readSoFar = 0;
-        for (const range of ranges) {
-            switch (range.type) {
-                case 1 :
-                    return readSoFar;
-                case 2 :
-                    if (readSoFar > 0) {
-                        return readSoFar;
-                    }
-                    else {
-                        throw createFileSystemProviderError(range.error, FileSystemProviderErrorCode.Unknown);
-                    }
-                case 0 : {
-                    const start = Math.max(0, pos - range.offset);
-                    const toWrite = range.data.slice(start, Math.min(range.data.byteLength, start + (length - readSoFar)));
-                    data.set(toWrite.buffer, offset + readSoFar);
-                    readSoFar += toWrite.byteLength;
-                    break;
-                }
-                default:
-                    assertNever(range);
-            }
-        }
-        return readSoFar;
-    }
-    write(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        return memory.region.write(pos, VSBuffer.wrap(data).slice(offset, offset + length));
-    }
-    parseUri(uri) {
-        if (uri.scheme !== DEBUG_MEMORY_SCHEME) {
-            throw createFileSystemProviderError(`Cannot open file with scheme ${uri.scheme}`, FileSystemProviderErrorCode.FileNotFound);
-        }
-        const session = this.debugService.getModel().getSession(uri.authority);
-        if (!session) {
-            throw createFileSystemProviderError(`Debug session not found`, FileSystemProviderErrorCode.FileNotFound);
-        }
-        let offset;
-        const rangeMatch = rangeRe.exec(uri.query);
-        if (rangeMatch) {
-            offset = { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) };
-        }
-        const [, memoryReference] = uri.path.split('/');
-        return {
-            session,
-            offset,
-            readOnly: !session.capabilities.supportsWriteMemoryRequest,
-            sessionId: uri.authority,
-            memoryReference: decodeURIComponent(memoryReference),
-        };
-    }
-}
-class MemoryRegionView extends Disposable {
-    constructor(parent, range) {
-        super();
-        this.parent = parent;
-        this.range = range;
-        this.invalidateEmitter = ( new Emitter());
-        this.onDidInvalidate = this.invalidateEmitter.event;
-        this.width = this.range.toOffset - this.range.fromOffset;
-        this.writable = parent.writable;
-        this._register(parent);
-        this._register(parent.onDidInvalidate(e => {
-            const fromOffset = clamp(e.fromOffset - range.fromOffset, 0, this.width);
-            const toOffset = clamp(e.toOffset - range.fromOffset, 0, this.width);
-            if (toOffset > fromOffset) {
-                this.invalidateEmitter.fire({ fromOffset, toOffset });
-            }
-        }));
-    }
-    read(fromOffset, toOffset) {
-        if (fromOffset < 0) {
-            throw new RangeError(`Invalid fromOffset: ${fromOffset}`);
-        }
-        return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
-    }
-    write(offset, data) {
-        return this.parent.write(this.range.fromOffset + offset, data);
-    }
-}
-export { DebugMemoryFileSystemProvider };

package/vscode/src/vs/workbench/contrib/debug/browser/debugProgress.js

@@ -1,80 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { VIEWLET_ID, IDebugService } from '../common/debug.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IViewsService } from '../../../common/views.js';
-import { NotificationPriority } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-let DebugProgressContribution = class DebugProgressContribution {
-    constructor(debugService, progressService, viewsService) {
-        this.toDispose = [];
-        let progressListener;
-        const listenOnProgress = (session) => {
-            if (progressListener) {
-                progressListener.dispose();
-                progressListener = undefined;
-            }
-            if (session) {
-                progressListener = session.onDidProgressStart(async (progressStartEvent) => {
-                    const promise = ( new Promise(r => {
-                        const listener = Event.any(Event.filter(session.onDidProgressEnd, e => e.body.progressId === progressStartEvent.body.progressId), session.onDidEndAdapter)(() => {
-                            listener.dispose();
-                            r();
-                        });
-                    }));
-                    if (viewsService.isViewContainerVisible(VIEWLET_ID)) {
-                        progressService.withProgress({ location: VIEWLET_ID }, () => promise);
-                    }
-                    const source = debugService.getAdapterManager().getDebuggerLabel(session.configuration.type);
-                    progressService.withProgress({
-                        location: 15 ,
-                        title: progressStartEvent.body.title,
-                        cancellable: progressStartEvent.body.cancellable,
-                        priority: NotificationPriority.SILENT,
-                        source,
-                        delay: 500
-                    }, progressStep => {
-                        let total = 0;
-                        const reportProgress = (progress) => {
-                            let increment = undefined;
-                            if (typeof progress.percentage === 'number') {
-                                increment = progress.percentage - total;
-                                total += increment;
-                            }
-                            progressStep.report({
-                                message: progress.message,
-                                increment,
-                                total: typeof increment === 'number' ? 100 : undefined,
-                            });
-                        };
-                        if (progressStartEvent.body.message) {
-                            reportProgress(progressStartEvent.body);
-                        }
-                        const progressUpdateListener = session.onDidProgressUpdate(e => {
-                            if (e.body.progressId === progressStartEvent.body.progressId) {
-                                reportProgress(e.body);
-                            }
-                        });
-                        return promise.then(() => progressUpdateListener.dispose());
-                    }, () => session.cancel(progressStartEvent.body.progressId));
-                });
-            }
-        };
-        this.toDispose.push(debugService.getViewModel().onDidFocusSession(listenOnProgress));
-        listenOnProgress(debugService.getViewModel().focusedSession);
-        this.toDispose.push(debugService.onWillNewSession(session => {
-            if (!progressListener) {
-                listenOnProgress(session);
-            }
-        }));
-    }
-    dispose() {
-        dispose(this.toDispose);
-    }
-};
-DebugProgressContribution = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IProgressService)),
-    ( __param(2, IViewsService))
-], DebugProgressContribution));
-export { DebugProgressContribution };