@codingame/monaco-vscode-api 1.83.8 → 1.83.9

package/vscode/src/vs/workbench/contrib/comments/browser/commentsController.js

@@ -1,1194 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { findFirstIdxMonotonousOrArrLen } from 'monaco-editor/esm/vs/base/common/arraysFind.js';
-import { createCancelablePromise, Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import './media/review.css.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { EditorType } from 'monaco-editor/esm/vs/editor/common/editorCommon.js';
-import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import * as languages from 'monaco-editor/esm/vs/editor/common/languages.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { CommentGlyphWidget } from './commentGlyphWidget.js';
-import { ICommentService } from './commentService.js';
-import { ReviewZoneWidget, parseMouseDownInfoFromEvent, isMouseUpEventDragFromMouseDown } from './commentThreadZoneWidget.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { EmbeddedCodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
-import { IViewsService } from '../../../common/views.js';
-import { COMMENTS_VIEW_ID } from './commentsTreeViewer.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { COMMENTS_SECTION } from '../common/commentsConfiguration.js';
-import { COMMENTEDITOR_DECORATION_KEY } from './commentReply.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { CommentThreadRangeDecorator } from './commentThreadRangeDecorator.js';
-import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
-import { CommentContextKeys } from '../common/commentContextKeys.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-const ID = 'editor.contrib.review';
-class CommentingRangeDecoration {
-    get id() {
-        return this._decorationId;
-    }
-    set id(id) {
-        this._decorationId = id;
-    }
-    get range() {
-        return {
-            startLineNumber: this._startLineNumber, startColumn: 1,
-            endLineNumber: this._endLineNumber, endColumn: 1
-        };
-    }
-    constructor(_editor, _ownerId, _extensionId, _label, _range, options, commentingRangesInfo, isHover = false) {
-        this._editor = _editor;
-        this._ownerId = _ownerId;
-        this._extensionId = _extensionId;
-        this._label = _label;
-        this._range = _range;
-        this.options = options;
-        this.commentingRangesInfo = commentingRangesInfo;
-        this.isHover = isHover;
-        this._startLineNumber = _range.startLineNumber;
-        this._endLineNumber = _range.endLineNumber;
-    }
-    getCommentAction() {
-        return {
-            extensionId: this._extensionId,
-            label: this._label,
-            ownerId: this._ownerId,
-            commentingRangesInfo: this.commentingRangesInfo
-        };
-    }
-    getOriginalRange() {
-        return this._range;
-    }
-    getActiveRange() {
-        return this.id ? this._editor.getModel().getDecorationRange(this.id) : undefined;
-    }
-}
-class CommentingRangeDecorator {
-    static { this.description = 'commenting-range-decorator'; }
-    constructor() {
-        this.commentingRangeDecorations = [];
-        this.decorationIds = [];
-        this._lastHover = -1;
-        this._onDidChangeDecorationsCount = ( new Emitter());
-        this.onDidChangeDecorationsCount = this._onDidChangeDecorationsCount.event;
-        const decorationOptions = {
-            description: CommentingRangeDecorator.description,
-            isWholeLine: true,
-            linesDecorationsClassName: 'comment-range-glyph comment-diff-added'
-        };
-        this.decorationOptions = ModelDecorationOptions.createDynamic(decorationOptions);
-        const hoverDecorationOptions = {
-            description: CommentingRangeDecorator.description,
-            isWholeLine: true,
-            linesDecorationsClassName: `comment-range-glyph line-hover`
-        };
-        this.hoverDecorationOptions = ModelDecorationOptions.createDynamic(hoverDecorationOptions);
-        const multilineDecorationOptions = {
-            description: CommentingRangeDecorator.description,
-            isWholeLine: true,
-            linesDecorationsClassName: `comment-range-glyph multiline-add`
-        };
-        this.multilineDecorationOptions = ModelDecorationOptions.createDynamic(multilineDecorationOptions);
-    }
-    updateHover(hoverLine) {
-        if (this._editor && this._infos && (hoverLine !== this._lastHover)) {
-            this._doUpdate(this._editor, this._infos, hoverLine);
-        }
-        this._lastHover = hoverLine ?? -1;
-    }
-    updateSelection(cursorLine, range = ( new Range(0, 0, 0, 0))) {
-        this._lastSelection = range.isEmpty() ? undefined : range;
-        this._lastSelectionCursor = range.isEmpty() ? undefined : cursorLine;
-        if (this._editor && this._infos) {
-            this._doUpdate(this._editor, this._infos, cursorLine, range);
-        }
-    }
-    update(editor, commentInfos, cursorLine, range) {
-        if (editor) {
-            this._editor = editor;
-            this._infos = commentInfos;
-            this._doUpdate(editor, commentInfos, cursorLine, range);
-        }
-    }
-    _lineHasThread(editor, lineRange) {
-        return editor.getDecorationsInRange(lineRange)?.find(decoration => decoration.options.description === CommentGlyphWidget.description);
-    }
-    _doUpdate(editor, commentInfos, emphasisLine = -1, selectionRange = this._lastSelection) {
-        const model = editor.getModel();
-        if (!model) {
-            return;
-        }
-        emphasisLine = this._lastSelectionCursor ?? emphasisLine;
-        const commentingRangeDecorations = [];
-        for (const info of commentInfos) {
-            info.commentingRanges.ranges.forEach(range => {
-                const rangeObject = ( new Range(
-                    range.startLineNumber,
-                    range.startColumn,
-                    range.endLineNumber,
-                    range.endColumn
-                ));
-                let intersectingSelectionRange = selectionRange ? rangeObject.intersectRanges(selectionRange) : undefined;
-                if ((selectionRange && (emphasisLine >= 0) && intersectingSelectionRange)
-                    && !((intersectingSelectionRange.startLineNumber === intersectingSelectionRange.endLineNumber)
-                        && (emphasisLine === intersectingSelectionRange.startLineNumber))) {
-                    let intersectingEmphasisRange;
-                    if (emphasisLine <= intersectingSelectionRange.startLineNumber) {
-                        intersectingEmphasisRange = intersectingSelectionRange.collapseToStart();
-                        intersectingSelectionRange = ( new Range(
-                            intersectingSelectionRange.startLineNumber + 1,
-                            1,
-                            intersectingSelectionRange.endLineNumber,
-                            1
-                        ));
-                    }
-                    else {
-                        intersectingEmphasisRange = ( new Range(
-                            intersectingSelectionRange.endLineNumber,
-                            1,
-                            intersectingSelectionRange.endLineNumber,
-                            1
-                        ));
-                        intersectingSelectionRange = ( new Range(
-                            intersectingSelectionRange.startLineNumber,
-                            1,
-                            intersectingSelectionRange.endLineNumber - 1,
-                            1
-                        ));
-                    }
-                    commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                        editor,
-                        info.owner,
-                        info.extensionId,
-                        info.label,
-                        intersectingSelectionRange,
-                        this.multilineDecorationOptions,
-                        info.commentingRanges,
-                        true
-                    )));
-                    if (!this._lineHasThread(editor, intersectingEmphasisRange)) {
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            intersectingEmphasisRange,
-                            this.hoverDecorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                    const beforeRangeEndLine = Math.min(intersectingEmphasisRange.startLineNumber, intersectingSelectionRange.startLineNumber) - 1;
-                    const hasBeforeRange = rangeObject.startLineNumber <= beforeRangeEndLine;
-                    const afterRangeStartLine = Math.max(intersectingEmphasisRange.endLineNumber, intersectingSelectionRange.endLineNumber) + 1;
-                    const hasAfterRange = rangeObject.endLineNumber >= afterRangeStartLine;
-                    if (hasBeforeRange) {
-                        const beforeRange = ( new Range(range.startLineNumber, 1, beforeRangeEndLine, 1));
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            beforeRange,
-                            this.decorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                    if (hasAfterRange) {
-                        const afterRange = ( new Range(afterRangeStartLine, 1, range.endLineNumber, 1));
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            afterRange,
-                            this.decorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                }
-                else if ((rangeObject.startLineNumber <= emphasisLine) && (emphasisLine <= rangeObject.endLineNumber)) {
-                    if (rangeObject.startLineNumber < emphasisLine) {
-                        const beforeRange = ( new Range(range.startLineNumber, 1, emphasisLine - 1, 1));
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            beforeRange,
-                            this.decorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                    const emphasisRange = ( new Range(emphasisLine, 1, emphasisLine, 1));
-                    if (!this._lineHasThread(editor, emphasisRange)) {
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            emphasisRange,
-                            this.hoverDecorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                    if (emphasisLine < rangeObject.endLineNumber) {
-                        const afterRange = ( new Range(emphasisLine + 1, 1, range.endLineNumber, 1));
-                        commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                            editor,
-                            info.owner,
-                            info.extensionId,
-                            info.label,
-                            afterRange,
-                            this.decorationOptions,
-                            info.commentingRanges,
-                            true
-                        )));
-                    }
-                }
-                else {
-                    commentingRangeDecorations.push(( new CommentingRangeDecoration(
-                        editor,
-                        info.owner,
-                        info.extensionId,
-                        info.label,
-                        range,
-                        this.decorationOptions,
-                        info.commentingRanges
-                    )));
-                }
-            });
-        }
-        editor.changeDecorations((accessor) => {
-            this.decorationIds = accessor.deltaDecorations(this.decorationIds, commentingRangeDecorations);
-            commentingRangeDecorations.forEach((decoration, index) => decoration.id = this.decorationIds[index]);
-        });
-        const rangesDifference = this.commentingRangeDecorations.length - commentingRangeDecorations.length;
-        this.commentingRangeDecorations = commentingRangeDecorations;
-        if (rangesDifference) {
-            this._onDidChangeDecorationsCount.fire(this.commentingRangeDecorations.length);
-        }
-    }
-    areRangesIntersectingOrTouchingByLine(a, b) {
-        if (a.endLineNumber < (b.startLineNumber - 1)) {
-            return false;
-        }
-        if ((b.endLineNumber + 1) < a.startLineNumber) {
-            return false;
-        }
-        return true;
-    }
-    getMatchedCommentAction(commentRange) {
-        if (commentRange === undefined) {
-            const foundInfos = this._infos?.filter(info => info.commentingRanges.fileComments);
-            if (foundInfos) {
-                return ( foundInfos.map(foundInfo => {
-                    return {
-                        ownerId: foundInfo.owner,
-                        extensionId: foundInfo.extensionId,
-                        label: foundInfo.label,
-                        commentingRangesInfo: foundInfo.commentingRanges
-                    };
-                }));
-            }
-            return [];
-        }
-        const foundHoverActions = ( new Map());
-        for (const decoration of this.commentingRangeDecorations) {
-            const range = decoration.getActiveRange();
-            if (range && this.areRangesIntersectingOrTouchingByLine(range, commentRange)) {
-                const action = decoration.getCommentAction();
-                const alreadyFoundInfo = foundHoverActions.get(action.ownerId);
-                if (alreadyFoundInfo?.action.commentingRangesInfo === action.commentingRangesInfo) {
-                    const newRange = ( new Range(
-                        range.startLineNumber < alreadyFoundInfo.range.startLineNumber ? range.startLineNumber : alreadyFoundInfo.range.startLineNumber,
-                        range.startColumn < alreadyFoundInfo.range.startColumn ? range.startColumn : alreadyFoundInfo.range.startColumn,
-                        range.endLineNumber > alreadyFoundInfo.range.endLineNumber ? range.endLineNumber : alreadyFoundInfo.range.endLineNumber,
-                        range.endColumn > alreadyFoundInfo.range.endColumn ? range.endColumn : alreadyFoundInfo.range.endColumn
-                    ));
-                    foundHoverActions.set(action.ownerId, { range: newRange, action });
-                }
-                else {
-                    foundHoverActions.set(action.ownerId, { range, action });
-                }
-            }
-        }
-        return ( Array.from(( foundHoverActions.values())).filter(action => {
-            return (action.range.startLineNumber <= commentRange.startLineNumber) && (commentRange.endLineNumber <= action.range.endLineNumber);
-        }).map(actions => actions.action));
-    }
-    getNearestCommentingRange(findPosition, reverse) {
-        let findPositionContainedWithin;
-        let decorations;
-        if (reverse) {
-            decorations = [];
-            for (let i = this.commentingRangeDecorations.length - 1; i >= 0; i--) {
-                decorations.push(this.commentingRangeDecorations[i]);
-            }
-        }
-        else {
-            decorations = this.commentingRangeDecorations;
-        }
-        for (const decoration of decorations) {
-            const range = decoration.getActiveRange();
-            if (!range) {
-                continue;
-            }
-            if (findPositionContainedWithin && this.areRangesIntersectingOrTouchingByLine(range, findPositionContainedWithin)) {
-                findPositionContainedWithin = Range.plusRange(findPositionContainedWithin, range);
-                continue;
-            }
-            if (range.startLineNumber <= findPosition.lineNumber && findPosition.lineNumber <= range.endLineNumber) {
-                findPositionContainedWithin = ( new Range(
-                    range.startLineNumber,
-                    range.startColumn,
-                    range.endLineNumber,
-                    range.endColumn
-                ));
-                continue;
-            }
-            if (!reverse && range.endLineNumber < findPosition.lineNumber) {
-                continue;
-            }
-            if (reverse && range.startLineNumber > findPosition.lineNumber) {
-                continue;
-            }
-            return range;
-        }
-        return (decorations.length > 0 ? (decorations[0].getActiveRange() ?? undefined) : undefined);
-    }
-    dispose() {
-        this.commentingRangeDecorations = [];
-    }
-}
-let CommentController = class CommentController {
-    constructor(editor, commentService, instantiationService, codeEditorService, contextMenuService, quickInputService, viewsService, configurationService, contextKeyService, editorService, keybindingService, accessibilityService) {
-        this.commentService = commentService;
-        this.instantiationService = instantiationService;
-        this.codeEditorService = codeEditorService;
-        this.contextMenuService = contextMenuService;
-        this.quickInputService = quickInputService;
-        this.viewsService = viewsService;
-        this.configurationService = configurationService;
-        this.editorService = editorService;
-        this.keybindingService = keybindingService;
-        this.accessibilityService = accessibilityService;
-        this.globalToDispose = ( new DisposableStore());
-        this.localToDispose = ( new DisposableStore());
-        this.mouseDownInfo = null;
-        this._commentingRangeSpaceReserved = false;
-        this._emptyThreadsToAddQueue = [];
-        this._editorDisposables = [];
-        this._hasRespondedToEditorChange = false;
-        this._commentInfos = [];
-        this._commentWidgets = [];
-        this._pendingNewCommentCache = {};
-        this._pendingEditsCache = {};
-        this._computePromise = null;
-        this._activeCursorHasCommentingRange = CommentContextKeys.activeCursorHasCommentingRange.bindTo(contextKeyService);
-        this._activeEditorHasCommentingRange = CommentContextKeys.activeEditorHasCommentingRange.bindTo(contextKeyService);
-        if (editor instanceof EmbeddedCodeEditorWidget) {
-            return;
-        }
-        this.editor = editor;
-        this._commentingRangeDecorator = ( new CommentingRangeDecorator());
-        this.globalToDispose.add(this._commentingRangeDecorator.onDidChangeDecorationsCount(count => {
-            if (count === 0) {
-                this.clearEditorListeners();
-            }
-            else if (this._editorDisposables.length === 0) {
-                this.registerEditorListeners();
-            }
-        }));
-        this.globalToDispose.add(this._commentThreadRangeDecorator = ( new CommentThreadRangeDecorator(this.commentService)));
-        this.globalToDispose.add(this.commentService.onDidDeleteDataProvider(ownerId => {
-            if (ownerId) {
-                delete this._pendingNewCommentCache[ownerId];
-                delete this._pendingEditsCache[ownerId];
-            }
-            else {
-                this._pendingNewCommentCache = {};
-                this._pendingEditsCache = {};
-            }
-            this.beginCompute();
-        }));
-        this.globalToDispose.add(this.commentService.onDidSetDataProvider(_ => this.beginComputeAndHandleEditorChange()));
-        this.globalToDispose.add(this.commentService.onDidUpdateCommentingRanges(_ => this.beginComputeAndHandleEditorChange()));
-        this.globalToDispose.add(this.commentService.onDidSetResourceCommentInfos(e => {
-            const editorURI = this.editor && this.editor.hasModel() && this.editor.getModel().uri;
-            if (editorURI && ( editorURI.toString()) === ( e.resource.toString())) {
-                this.setComments(e.commentInfos.filter(commentInfo => commentInfo !== null));
-            }
-        }));
-        this.globalToDispose.add(this.commentService.onDidChangeCommentingEnabled(e => {
-            if (e) {
-                this.registerEditorListeners();
-                this.beginCompute();
-            }
-            else {
-                this.tryUpdateReservedSpace();
-                this.clearEditorListeners();
-                this._commentingRangeDecorator.update(this.editor, []);
-                this._commentThreadRangeDecorator.update(this.editor, []);
-                dispose(this._commentWidgets);
-                this._commentWidgets = [];
-            }
-        }));
-        this.globalToDispose.add(this.editor.onDidChangeModel(_ => this.onModelChanged()));
-        this.globalToDispose.add(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('diffEditor.renderSideBySide')) {
-                this.beginCompute();
-            }
-        }));
-        this.onModelChanged();
-        this.codeEditorService.registerDecorationType('comment-controller', COMMENTEDITOR_DECORATION_KEY, {});
-        this.commentService.registerContinueOnCommentProvider({
-            provideContinueOnComments: () => {
-                const pendingComments = [];
-                if (this._commentWidgets) {
-                    for (const zone of this._commentWidgets) {
-                        const zonePendingComments = zone.getPendingComments();
-                        const pendingNewComment = zonePendingComments.newComment;
-                        if (!pendingNewComment || !zone.commentThread.range) {
-                            continue;
-                        }
-                        let lastCommentBody;
-                        if (zone.commentThread.comments && zone.commentThread.comments.length) {
-                            const lastComment = zone.commentThread.comments[zone.commentThread.comments.length - 1];
-                            if (typeof lastComment.body === 'string') {
-                                lastCommentBody = lastComment.body;
-                            }
-                            else {
-                                lastCommentBody = lastComment.body.value;
-                            }
-                        }
-                        if (pendingNewComment !== lastCommentBody) {
-                            pendingComments.push({
-                                owner: zone.owner,
-                                uri: zone.editor.getModel().uri,
-                                range: zone.commentThread.range,
-                                body: pendingNewComment
-                            });
-                        }
-                    }
-                }
-                return pendingComments;
-            }
-        });
-    }
-    registerEditorListeners() {
-        this._editorDisposables = [];
-        if (!this.editor) {
-            return;
-        }
-        this._editorDisposables.push(this.editor.onMouseMove(e => this.onEditorMouseMove(e)));
-        this._editorDisposables.push(this.editor.onDidChangeCursorPosition(e => this.onEditorChangeCursorPosition(e.position)));
-        this._editorDisposables.push(this.editor.onDidFocusEditorWidget(() => this.onEditorChangeCursorPosition(this.editor?.getPosition() ?? null)));
-        this._editorDisposables.push(this.editor.onDidChangeCursorSelection(e => this.onEditorChangeCursorSelection(e)));
-        this._editorDisposables.push(this.editor.onDidBlurEditorWidget(() => this.onEditorChangeCursorSelection()));
-    }
-    clearEditorListeners() {
-        dispose(this._editorDisposables);
-        this._editorDisposables = [];
-    }
-    onEditorMouseMove(e) {
-        const position = e.target.position?.lineNumber;
-        if (e.event.leftButton.valueOf() && position && this.mouseDownInfo) {
-            this._commentingRangeDecorator.updateSelection(position, ( new Range(this.mouseDownInfo.lineNumber, 1, position, 1)));
-        }
-        else {
-            this._commentingRangeDecorator.updateHover(position);
-        }
-    }
-    onEditorChangeCursorSelection(e) {
-        const position = this.editor?.getPosition()?.lineNumber;
-        if (position) {
-            this._commentingRangeDecorator.updateSelection(position, e?.selection);
-        }
-    }
-    onEditorChangeCursorPosition(e) {
-        const decorations = e ? this.editor?.getDecorationsInRange(Range.fromPositions(e, { column: -1, lineNumber: e.lineNumber })) : undefined;
-        let hasCommentingRange = false;
-        if (decorations) {
-            for (const decoration of decorations) {
-                if (decoration.options.description === CommentGlyphWidget.description) {
-                    hasCommentingRange = false;
-                    break;
-                }
-                else if (decoration.options.description === CommentingRangeDecorator.description) {
-                    hasCommentingRange = true;
-                }
-            }
-        }
-        this._activeCursorHasCommentingRange.set(hasCommentingRange);
-    }
-    isEditorInlineOriginal(testEditor) {
-        if (this.configurationService.getValue('diffEditor.renderSideBySide')) {
-            return false;
-        }
-        const foundEditor = this.editorService.visibleTextEditorControls.find(editor => {
-            if (editor.getEditorType() === EditorType.IDiffEditor) {
-                const diffEditor = editor;
-                return diffEditor.getOriginalEditor() === testEditor;
-            }
-            return false;
-        });
-        return !!foundEditor;
-    }
-    beginCompute() {
-        this._computePromise = createCancelablePromise(token => {
-            const editorURI = this.editor && this.editor.hasModel() && this.editor.getModel().uri;
-            if (editorURI) {
-                return this.commentService.getDocumentComments(editorURI);
-            }
-            return Promise.resolve([]);
-        });
-        return this._computePromise.then(commentInfos => {
-            this.setComments(coalesce(commentInfos));
-            this._computePromise = null;
-        }, error => console.log(error));
-    }
-    beginComputeCommentingRanges() {
-        if (this._computeCommentingRangeScheduler) {
-            if (this._computeCommentingRangePromise) {
-                this._computeCommentingRangePromise.cancel();
-                this._computeCommentingRangePromise = null;
-            }
-            this._computeCommentingRangeScheduler.trigger(() => {
-                const editorURI = this.editor && this.editor.hasModel() && this.editor.getModel().uri;
-                if (editorURI) {
-                    return this.commentService.getDocumentComments(editorURI);
-                }
-                return Promise.resolve([]);
-            }).then(commentInfos => {
-                if (this.commentService.isCommentingEnabled) {
-                    const meaningfulCommentInfos = coalesce(commentInfos);
-                    this._commentingRangeDecorator.update(this.editor, meaningfulCommentInfos, this.editor?.getPosition()?.lineNumber, this.editor?.getSelection() ?? undefined);
-                }
-            }, (err) => {
-                onUnexpectedError(err);
-                return null;
-            });
-        }
-    }
-    static get(editor) {
-        return editor.getContribution(ID);
-    }
-    revealCommentThread(threadId, commentUniqueId, fetchOnceIfNotExist, focus) {
-        const commentThreadWidget = this._commentWidgets.filter(widget => widget.commentThread.threadId === threadId);
-        if (commentThreadWidget.length === 1) {
-            commentThreadWidget[0].reveal(commentUniqueId, focus);
-        }
-        else if (fetchOnceIfNotExist) {
-            if (this._computePromise) {
-                this._computePromise.then(_ => {
-                    this.revealCommentThread(threadId, commentUniqueId, false, focus);
-                });
-            }
-            else {
-                this.beginCompute().then(_ => {
-                    this.revealCommentThread(threadId, commentUniqueId, false, focus);
-                });
-            }
-        }
-    }
-    collapseAll() {
-        for (const widget of this._commentWidgets) {
-            widget.collapse();
-        }
-    }
-    expandAll() {
-        for (const widget of this._commentWidgets) {
-            widget.expand();
-        }
-    }
-    expandUnresolved() {
-        for (const widget of this._commentWidgets) {
-            if (widget.commentThread.state === languages.CommentThreadState.Unresolved) {
-                widget.expand();
-            }
-        }
-    }
-    nextCommentThread() {
-        this._findNearestCommentThread();
-    }
-    _findNearestCommentThread(reverse) {
-        if (!this._commentWidgets.length || !this.editor?.hasModel()) {
-            return;
-        }
-        const after = this.editor.getSelection().getEndPosition();
-        const sortedWidgets = this._commentWidgets.sort((a, b) => {
-            if (reverse) {
-                const temp = a;
-                a = b;
-                b = temp;
-            }
-            if (a.commentThread.range === undefined) {
-                return -1;
-            }
-            if (b.commentThread.range === undefined) {
-                return 1;
-            }
-            if (a.commentThread.range.startLineNumber < b.commentThread.range.startLineNumber) {
-                return -1;
-            }
-            if (a.commentThread.range.startLineNumber > b.commentThread.range.startLineNumber) {
-                return 1;
-            }
-            if (a.commentThread.range.startColumn < b.commentThread.range.startColumn) {
-                return -1;
-            }
-            if (a.commentThread.range.startColumn > b.commentThread.range.startColumn) {
-                return 1;
-            }
-            return 0;
-        });
-        const idx = findFirstIdxMonotonousOrArrLen(sortedWidgets, widget => {
-            const lineValueOne = reverse ? after.lineNumber : (widget.commentThread.range?.startLineNumber ?? 0);
-            const lineValueTwo = reverse ? (widget.commentThread.range?.startLineNumber ?? 0) : after.lineNumber;
-            const columnValueOne = reverse ? after.column : (widget.commentThread.range?.startColumn ?? 0);
-            const columnValueTwo = reverse ? (widget.commentThread.range?.startColumn ?? 0) : after.column;
-            if (lineValueOne > lineValueTwo) {
-                return true;
-            }
-            if (lineValueOne < lineValueTwo) {
-                return false;
-            }
-            if (columnValueOne > columnValueTwo) {
-                return true;
-            }
-            return false;
-        });
-        let nextWidget;
-        if (idx === this._commentWidgets.length) {
-            nextWidget = this._commentWidgets[0];
-        }
-        else {
-            nextWidget = sortedWidgets[idx];
-        }
-        this.editor.setSelection(nextWidget.commentThread.range ?? ( new Range(1, 1, 1, 1)));
-        nextWidget.reveal(undefined, true);
-    }
-    previousCommentThread() {
-        this._findNearestCommentThread(true);
-    }
-    _findNearestCommentingRange(reverse) {
-        if (!this.editor?.hasModel()) {
-            return;
-        }
-        const after = this.editor.getSelection().getEndPosition();
-        const range = this._commentingRangeDecorator.getNearestCommentingRange(after, reverse);
-        if (range) {
-            const position = reverse ? range.getEndPosition() : range.getStartPosition();
-            this.editor.setPosition(position);
-            this.editor.revealLineInCenterIfOutsideViewport(position.lineNumber);
-        }
-        if (this.accessibilityService.isScreenReaderOptimized()) {
-            const commentRangeStart = range?.getStartPosition().lineNumber;
-            const commentRangeEnd = range?.getEndPosition().lineNumber;
-            if (commentRangeStart && commentRangeEnd) {
-                const oneLine = commentRangeStart === commentRangeEnd;
-                oneLine ? status(( nls.localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentsController',
-                    'commentRange',
-                    "Line {0}",
-                    commentRangeStart
-                ))) : status(( nls.localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentsController',
-                    'commentRangeStart',
-                    "Lines {0} to {1}",
-                    commentRangeStart,
-                    commentRangeEnd
-                )));
-            }
-        }
-    }
-    nextCommentingRange() {
-        this._findNearestCommentingRange();
-    }
-    previousCommentingRange() {
-        this._findNearestCommentingRange(true);
-    }
-    dispose() {
-        this.globalToDispose.dispose();
-        this.localToDispose.dispose();
-        dispose(this._editorDisposables);
-        dispose(this._commentWidgets);
-        this.editor = null;
-    }
-    onModelChanged() {
-        this.localToDispose.clear();
-        this.removeCommentWidgetsAndStoreCache();
-        if (!this.editor) {
-            return;
-        }
-        this._hasRespondedToEditorChange = false;
-        this.localToDispose.add(this.editor.onMouseDown(e => this.onEditorMouseDown(e)));
-        this.localToDispose.add(this.editor.onMouseUp(e => this.onEditorMouseUp(e)));
-        if (this._editorDisposables.length) {
-            this.clearEditorListeners();
-            this.registerEditorListeners();
-        }
-        this._computeCommentingRangeScheduler = ( new Delayer(200));
-        this.localToDispose.add({
-            dispose: () => {
-                this._computeCommentingRangeScheduler?.cancel();
-                this._computeCommentingRangeScheduler = null;
-            }
-        });
-        this.localToDispose.add(this.editor.onDidChangeModelContent(async () => {
-            this.beginComputeCommentingRanges();
-        }));
-        this.localToDispose.add(this.commentService.onDidUpdateCommentThreads(async (e) => {
-            const editorURI = this.editor && this.editor.hasModel() && this.editor.getModel().uri;
-            if (!editorURI || !this.commentService.isCommentingEnabled) {
-                return;
-            }
-            if (this._computePromise) {
-                await this._computePromise;
-            }
-            const commentInfo = this._commentInfos.filter(info => info.owner === e.owner);
-            if (!commentInfo || !commentInfo.length) {
-                return;
-            }
-            const added = e.added.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
-            const removed = e.removed.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
-            const changed = e.changed.filter(thread => thread.resource && thread.resource === ( editorURI.toString()));
-            const pending = e.pending.filter(pending => ( pending.uri.toString()) === ( editorURI.toString()));
-            removed.forEach(thread => {
-                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId && zoneWidget.commentThread.threadId !== '');
-                if (matchedZones.length) {
-                    const matchedZone = matchedZones[0];
-                    const index = this._commentWidgets.indexOf(matchedZone);
-                    this._commentWidgets.splice(index, 1);
-                    matchedZone.dispose();
-                }
-                const infosThreads = this._commentInfos.filter(info => info.owner === e.owner)[0].threads;
-                for (let i = 0; i < infosThreads.length; i++) {
-                    if (infosThreads[i] === thread) {
-                        infosThreads.splice(i, 1);
-                        i--;
-                    }
-                }
-            });
-            changed.forEach(thread => {
-                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId);
-                if (matchedZones.length) {
-                    const matchedZone = matchedZones[0];
-                    matchedZone.update(thread);
-                    this.openCommentsView(thread);
-                }
-            });
-            added.forEach(thread => {
-                const matchedZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.threadId === thread.threadId);
-                if (matchedZones.length) {
-                    return;
-                }
-                const matchedNewCommentThreadZones = this._commentWidgets.filter(zoneWidget => zoneWidget.owner === e.owner && zoneWidget.commentThread.commentThreadHandle === -1 && Range.equalsRange(zoneWidget.commentThread.range, thread.range));
-                if (matchedNewCommentThreadZones.length) {
-                    matchedNewCommentThreadZones[0].update(thread);
-                    return;
-                }
-                const continueOnCommentText = (thread.range ? this.commentService.removeContinueOnComment({ owner: e.owner, uri: editorURI, range: thread.range })?.body : undefined);
-                const pendingCommentText = (this._pendingNewCommentCache[e.owner] && this._pendingNewCommentCache[e.owner][thread.threadId])
-                    ?? continueOnCommentText;
-                const pendingEdits = this._pendingEditsCache[e.owner] && this._pendingEditsCache[e.owner][thread.threadId];
-                this.displayCommentThread(e.owner, thread, pendingCommentText, pendingEdits);
-                this._commentInfos.filter(info => info.owner === e.owner)[0].threads.push(thread);
-                this.tryUpdateReservedSpace();
-            });
-            pending.forEach(thread => {
-                this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
-            });
-            this._commentThreadRangeDecorator.update(this.editor, commentInfo);
-        }));
-        this.beginComputeAndHandleEditorChange();
-    }
-    beginComputeAndHandleEditorChange() {
-        this.beginCompute().then(() => {
-            if (!this._hasRespondedToEditorChange) {
-                if (( this._commentInfos.some(
-                    commentInfo => commentInfo.commentingRanges.ranges.length > 0 || commentInfo.commentingRanges.fileComments
-                ))) {
-                    this._hasRespondedToEditorChange = true;
-                    const verbose = this.configurationService.getValue("accessibility.verbosity.comments" );
-                    if (verbose) {
-                        const keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp" )?.getAriaLabel();
-                        if (keybinding) {
-                            status(( nls.localizeWithPath(
-                                'vs/workbench/contrib/comments/browser/commentsController',
-                                'hasCommentRangesKb',
-                                "Editor has commenting ranges, run the command Open Accessibility Help ({0}), for more information.",
-                                keybinding
-                            )));
-                        }
-                        else {
-                            status(( nls.localizeWithPath(
-                                'vs/workbench/contrib/comments/browser/commentsController',
-                                'hasCommentRangesNoKb',
-                                "Editor has commenting ranges, run the command Open Accessibility Help, which is currently not triggerable via keybinding, for more information."
-                            )));
-                        }
-                    }
-                    else {
-                        status(( nls.localizeWithPath(
-                            'vs/workbench/contrib/comments/browser/commentsController',
-                            'hasCommentRanges',
-                            "Editor has commenting ranges."
-                        )));
-                    }
-                }
-            }
-        });
-    }
-    async openCommentsView(thread) {
-        if (thread.comments && (thread.comments.length > 0)) {
-            const openViewState = this.configurationService.getValue(COMMENTS_SECTION).openView;
-            if (openViewState === 'file') {
-                return this.viewsService.openView(COMMENTS_VIEW_ID);
-            }
-            else if (openViewState === 'firstFile' || (openViewState === 'firstFileUnresolved' && thread.state === languages.CommentThreadState.Unresolved)) {
-                const hasShownView = this.viewsService.getViewWithId(COMMENTS_VIEW_ID)?.hasRendered;
-                if (!hasShownView) {
-                    return this.viewsService.openView(COMMENTS_VIEW_ID);
-                }
-            }
-        }
-        return undefined;
-    }
-    displayCommentThread(owner, thread, pendingComment, pendingEdits) {
-        if (!this.editor?.getModel()) {
-            return;
-        }
-        if (this.isEditorInlineOriginal(this.editor)) {
-            return;
-        }
-        const zoneWidget = this.instantiationService.createInstance(ReviewZoneWidget, this.editor, owner, thread, pendingComment, pendingEdits);
-        zoneWidget.display(thread.range);
-        this._commentWidgets.push(zoneWidget);
-        this.openCommentsView(thread);
-    }
-    onEditorMouseDown(e) {
-        this.mouseDownInfo = parseMouseDownInfoFromEvent(e);
-    }
-    onEditorMouseUp(e) {
-        const matchedLineNumber = isMouseUpEventDragFromMouseDown(this.mouseDownInfo, e);
-        this.mouseDownInfo = null;
-        if (!this.editor || matchedLineNumber === null || !e.target.element) {
-            return;
-        }
-        const mouseUpIsOnDecorator = (e.target.element.className.indexOf('comment-range-glyph') >= 0);
-        const lineNumber = e.target.position.lineNumber;
-        let range;
-        let selection;
-        if ((matchedLineNumber !== lineNumber)) {
-            if (matchedLineNumber > lineNumber) {
-                selection = ( new Range(
-                    matchedLineNumber,
-                    this.editor.getModel().getLineLength(matchedLineNumber) + 1,
-                    lineNumber,
-                    1
-                ));
-            }
-            else {
-                selection = ( new Range(
-                    matchedLineNumber,
-                    1,
-                    lineNumber,
-                    this.editor.getModel().getLineLength(lineNumber) + 1
-                ));
-            }
-        }
-        else if (mouseUpIsOnDecorator) {
-            selection = this.editor.getSelection();
-        }
-        if (selection && (selection.startLineNumber <= lineNumber) && (lineNumber <= selection.endLineNumber)) {
-            range = selection;
-            this.editor.setSelection(( new Range(selection.endLineNumber, 1, selection.endLineNumber, 1)));
-        }
-        else if (mouseUpIsOnDecorator) {
-            range = ( new Range(lineNumber, 1, lineNumber, 1));
-        }
-        if (range) {
-            this.addOrToggleCommentAtLine(range, e);
-        }
-    }
-    async addOrToggleCommentAtLine(commentRange, e) {
-        if (!this._addInProgress) {
-            this._addInProgress = true;
-            const existingCommentsAtLine = this._commentWidgets.filter(widget => widget.getGlyphPosition() === (commentRange ? commentRange.endLineNumber : 0));
-            if (existingCommentsAtLine.length) {
-                const allExpanded = existingCommentsAtLine.every(widget => widget.expanded);
-                existingCommentsAtLine.forEach(allExpanded ? widget => widget.collapse() : widget => widget.expand());
-                this.processNextThreadToAdd();
-                return;
-            }
-            else {
-                this.addCommentAtLine(commentRange, e);
-            }
-        }
-        else {
-            this._emptyThreadsToAddQueue.push([commentRange, e]);
-        }
-    }
-    processNextThreadToAdd() {
-        this._addInProgress = false;
-        const info = this._emptyThreadsToAddQueue.shift();
-        if (info) {
-            this.addOrToggleCommentAtLine(info[0], info[1]);
-        }
-    }
-    addCommentAtLine(range, e) {
-        const newCommentInfos = this._commentingRangeDecorator.getMatchedCommentAction(range);
-        if (!newCommentInfos.length || !this.editor?.hasModel()) {
-            this._addInProgress = false;
-            if (!newCommentInfos.length) {
-                throw new Error('There are no commenting ranges at the current position.');
-            }
-            return Promise.resolve();
-        }
-        if (newCommentInfos.length > 1) {
-            if (e && range) {
-                this.contextMenuService.showContextMenu({
-                    getAnchor: () => e.event,
-                    getActions: () => this.getContextMenuActions(newCommentInfos, range),
-                    getActionsContext: () => newCommentInfos.length ? newCommentInfos[0] : undefined,
-                    onHide: () => { this._addInProgress = false; }
-                });
-                return Promise.resolve();
-            }
-            else {
-                const picks = this.getCommentProvidersQuickPicks(newCommentInfos);
-                return this.quickInputService.pick(picks, { placeHolder: ( nls.localizeWithPath(
-                    'vs/workbench/contrib/comments/browser/commentsController',
-                    'pickCommentService',
-                    "Select Comment Provider"
-                )), matchOnDescription: true }).then(pick => {
-                    if (!pick) {
-                        return;
-                    }
-                    const commentInfos = newCommentInfos.filter(info => info.ownerId === pick.id);
-                    if (commentInfos.length) {
-                        const { ownerId } = commentInfos[0];
-                        this.addCommentAtLine2(range, ownerId);
-                    }
-                }).then(() => {
-                    this._addInProgress = false;
-                });
-            }
-        }
-        else {
-            const { ownerId } = newCommentInfos[0];
-            this.addCommentAtLine2(range, ownerId);
-        }
-        return Promise.resolve();
-    }
-    getCommentProvidersQuickPicks(commentInfos) {
-        const picks = ( commentInfos.map((commentInfo) => {
-            const { ownerId, extensionId, label } = commentInfo;
-            return {
-                label: label || extensionId,
-                id: ownerId
-            };
-        }));
-        return picks;
-    }
-    getContextMenuActions(commentInfos, commentRange) {
-        const actions = [];
-        commentInfos.forEach(commentInfo => {
-            const { ownerId, extensionId, label } = commentInfo;
-            actions.push(( new Action('addCommentThread', `${label || extensionId}`, undefined, true, () => {
-                this.addCommentAtLine2(commentRange, ownerId);
-                return Promise.resolve();
-            })));
-        });
-        return actions;
-    }
-    addCommentAtLine2(range, ownerId) {
-        if (!this.editor) {
-            return;
-        }
-        this.commentService.createCommentThreadTemplate(ownerId, this.editor.getModel().uri, range);
-        this.processNextThreadToAdd();
-        return;
-    }
-    getExistingCommentEditorOptions(editor) {
-        const lineDecorationsWidth = editor.getOption(65 );
-        let extraEditorClassName = [];
-        const configuredExtraClassName = editor.getRawOptions().extraEditorClassName;
-        if (configuredExtraClassName) {
-            extraEditorClassName = configuredExtraClassName.split(' ');
-        }
-        return { lineDecorationsWidth, extraEditorClassName };
-    }
-    getWithoutCommentsEditorOptions(editor, extraEditorClassName, startingLineDecorationsWidth) {
-        let lineDecorationsWidth = startingLineDecorationsWidth;
-        const inlineCommentPos = extraEditorClassName.findIndex(name => name === 'inline-comment');
-        if (inlineCommentPos >= 0) {
-            extraEditorClassName.splice(inlineCommentPos, 1);
-        }
-        const options = editor.getOptions();
-        if (options.get(43 ) && options.get(109 ) !== 'never') {
-            lineDecorationsWidth += 11;
-        }
-        lineDecorationsWidth -= 24;
-        return { extraEditorClassName, lineDecorationsWidth };
-    }
-    getWithCommentsEditorOptions(editor, extraEditorClassName, startingLineDecorationsWidth) {
-        let lineDecorationsWidth = startingLineDecorationsWidth;
-        const options = editor.getOptions();
-        if (options.get(43 ) && options.get(109 ) !== 'never') {
-            lineDecorationsWidth -= 11;
-        }
-        lineDecorationsWidth += 24;
-        extraEditorClassName.push('inline-comment');
-        return { lineDecorationsWidth, extraEditorClassName };
-    }
-    updateEditorLayoutOptions(editor, extraEditorClassName, lineDecorationsWidth) {
-        editor.updateOptions({
-            extraEditorClassName: extraEditorClassName.join(' '),
-            lineDecorationsWidth: lineDecorationsWidth
-        });
-    }
-    tryUpdateReservedSpace() {
-        if (!this.editor) {
-            return;
-        }
-        const hasCommentsOrRanges = ( this._commentInfos.some(info => {
-            const hasRanges = Boolean(info.commentingRanges && (Array.isArray(info.commentingRanges) ? info.commentingRanges : info.commentingRanges.ranges).length);
-            return hasRanges || (info.threads.length > 0);
-        }));
-        if (hasCommentsOrRanges && !this._commentingRangeSpaceReserved && this.commentService.isCommentingEnabled) {
-            this._commentingRangeSpaceReserved = true;
-            const { lineDecorationsWidth, extraEditorClassName } = this.getExistingCommentEditorOptions(this.editor);
-            const newOptions = this.getWithCommentsEditorOptions(this.editor, extraEditorClassName, lineDecorationsWidth);
-            this.updateEditorLayoutOptions(this.editor, newOptions.extraEditorClassName, newOptions.lineDecorationsWidth);
-        }
-        else if ((!hasCommentsOrRanges || !this.commentService.isCommentingEnabled) && this._commentingRangeSpaceReserved) {
-            this._commentingRangeSpaceReserved = false;
-            const { lineDecorationsWidth, extraEditorClassName } = this.getExistingCommentEditorOptions(this.editor);
-            const newOptions = this.getWithoutCommentsEditorOptions(this.editor, extraEditorClassName, lineDecorationsWidth);
-            this.updateEditorLayoutOptions(this.editor, newOptions.extraEditorClassName, newOptions.lineDecorationsWidth);
-        }
-    }
-    setComments(commentInfos) {
-        if (!this.editor || !this.commentService.isCommentingEnabled) {
-            return;
-        }
-        this._commentInfos = commentInfos;
-        this.tryUpdateReservedSpace();
-        this.removeCommentWidgetsAndStoreCache();
-        let hasCommentingRanges = false;
-        this._commentInfos.forEach(info => {
-            if (!hasCommentingRanges && (info.commentingRanges.ranges.length > 0 || info.commentingRanges.fileComments)) {
-                hasCommentingRanges = true;
-            }
-            const providerCacheStore = this._pendingNewCommentCache[info.owner];
-            const providerEditsCacheStore = this._pendingEditsCache[info.owner];
-            info.threads = info.threads.filter(thread => !thread.isDisposed);
-            info.threads.forEach(thread => {
-                let pendingComment = undefined;
-                if (providerCacheStore) {
-                    pendingComment = providerCacheStore[thread.threadId];
-                }
-                let pendingEdits = undefined;
-                if (providerEditsCacheStore) {
-                    pendingEdits = providerEditsCacheStore[thread.threadId];
-                }
-                if (pendingComment || pendingEdits) {
-                    thread.collapsibleState = languages.CommentThreadCollapsibleState.Expanded;
-                }
-                this.displayCommentThread(info.owner, thread, pendingComment, pendingEdits);
-            });
-            info.pendingCommentThreads?.forEach(thread => {
-                this.commentService.createCommentThreadTemplate(thread.owner, thread.uri, Range.lift(thread.range));
-            });
-        });
-        this._commentingRangeDecorator.update(this.editor, this._commentInfos);
-        this._commentThreadRangeDecorator.update(this.editor, this._commentInfos);
-        if (hasCommentingRanges) {
-            this._activeEditorHasCommentingRange.set(true);
-        }
-        else {
-            this._activeEditorHasCommentingRange.set(false);
-        }
-    }
-    closeWidget() {
-        this._commentWidgets?.forEach(widget => widget.hide());
-        if (this.editor) {
-            this.editor.focus();
-            this.editor.revealRangeInCenter(this.editor.getSelection());
-        }
-    }
-    removeCommentWidgetsAndStoreCache() {
-        if (this._commentWidgets) {
-            this._commentWidgets.forEach(zone => {
-                const pendingComments = zone.getPendingComments();
-                const pendingNewComment = pendingComments.newComment;
-                const providerNewCommentCacheStore = this._pendingNewCommentCache[zone.owner];
-                let lastCommentBody;
-                if (zone.commentThread.comments && zone.commentThread.comments.length) {
-                    const lastComment = zone.commentThread.comments[zone.commentThread.comments.length - 1];
-                    if (typeof lastComment.body === 'string') {
-                        lastCommentBody = lastComment.body;
-                    }
-                    else {
-                        lastCommentBody = lastComment.body.value;
-                    }
-                }
-                if (pendingNewComment && (pendingNewComment !== lastCommentBody)) {
-                    if (!providerNewCommentCacheStore) {
-                        this._pendingNewCommentCache[zone.owner] = {};
-                    }
-                    this._pendingNewCommentCache[zone.owner][zone.commentThread.threadId] = pendingNewComment;
-                }
-                else {
-                    if (providerNewCommentCacheStore) {
-                        delete providerNewCommentCacheStore[zone.commentThread.threadId];
-                    }
-                }
-                const pendingEdits = pendingComments.edits;
-                const providerEditsCacheStore = this._pendingEditsCache[zone.owner];
-                if (( Object.keys(pendingEdits)).length > 0) {
-                    if (!providerEditsCacheStore) {
-                        this._pendingEditsCache[zone.owner] = {};
-                    }
-                    this._pendingEditsCache[zone.owner][zone.commentThread.threadId] = pendingEdits;
-                }
-                else if (providerEditsCacheStore) {
-                    delete providerEditsCacheStore[zone.commentThread.threadId];
-                }
-                zone.dispose();
-            });
-        }
-        this._commentWidgets = [];
-    }
-};
-CommentController = ( __decorate([
-    ( __param(1, ICommentService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IQuickInputService)),
-    ( __param(6, IViewsService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IEditorService)),
-    ( __param(10, IKeybindingService)),
-    ( __param(11, IAccessibilityService))
-], CommentController));
-export { CommentController, ID };