@codingame/monaco-vscode-extensions-service-override 11.1.2 → 12.0.1

package/vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.d.ts

@@ -0,0 +1,21 @@
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { ICodeEditorService } from "vscode/vscode/vs/editor/browser/services/codeEditorService";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { IWebviewContentOptions, MainThreadEditorInsetsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IWebviewService } from "vscode/vscode/vs/workbench/contrib/webview/browser/webview.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+export declare class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
+    private readonly _editorService;
+    private readonly _webviewService;
+    private readonly _proxy;
+    private readonly _disposables;
+    private readonly _insets;
+    constructor(context: IExtHostContext, _editorService: ICodeEditorService, _webviewService: IWebviewService);
+    dispose(): void;
+    $createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: IWebviewContentOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void>;
+    $disposeEditorInset(handle: number): void;
+    $setHtml(handle: number, value: string): void;
+    $setOptions(handle: number, options: IWebviewContentOptions): void;
+    $postMessage(handle: number, value: any): Promise<boolean>;
+    private getInset;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadCodeInsets.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { getWindow } from 'vscode/vscode/vs/base/browser/dom';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { isEqual } from 'vscode/vscode/vs/base/common/resources';

package/vscode/src/vs/workbench/api/browser/mainThreadCommands.d.ts

@@ -0,0 +1,20 @@
+import { ICommandService } from "vscode/vscode/vs/platform/commands/common/commands.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { SerializableObjectWithBuffers } from "vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { MainThreadCommandsShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadCommands implements MainThreadCommandsShape {
+    private readonly _commandService;
+    private readonly _extensionService;
+    private readonly _commandRegistrations;
+    private readonly _generateCommandsDocumentationRegistration;
+    private readonly _proxy;
+    constructor(extHostContext: IExtHostContext, _commandService: ICommandService, _extensionService: IExtensionService);
+    dispose(): void;
+    private _generateCommandsDocumentation;
+    $registerCommand(id: string): void;
+    $unregisterCommand(id: string): void;
+    $fireCommandActivationEvent(id: string): void;
+    $executeCommand<T>(id: string, args: any[] | SerializableObjectWithBuffers<any[]>, retry: boolean): Promise<T | undefined>;
+    $getCommands(): Promise<string[]>;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadCommands.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
 import { revive } from 'vscode/vscode/vs/base/common/marshalling';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';

package/vscode/src/vs/workbench/api/browser/mainThreadComments.d.ts

@@ -0,0 +1,169 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI, UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IRange } from "vscode/vscode/vs/editor/common/core/range";
+import * as languages from "vscode/vscode/vs/editor/common/languages";
+import { ExtensionIdentifier } from "vscode/vscode/vs/platform/extensions/common/extensions";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { ICommentController } from "@codingame/monaco-vscode-comments-service-override/vscode/vs/workbench/contrib/comments/browser/commentService";
+import { ICommentService } from "vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service";
+import { CommentProviderFeatures, ExtHostCommentsShape, MainThreadCommentsShape, CommentThreadChanges } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IViewDescriptorService } from "vscode/vscode/vs/workbench/common/views.service";
+import { ICellRange } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { IViewsService } from "vscode/vscode/vs/workbench/services/views/common/viewsService.service";
+import { MarshalledCommentThread } from "../../common/comments.js";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+export declare class MainThreadCommentThread<T> implements languages.CommentThread<T> {
+    commentThreadHandle: number;
+    controllerHandle: number;
+    extensionId: string;
+    threadId: string;
+    resource: string;
+    private _range;
+    private _canReply;
+    private _isTemplate;
+    editorId?: string | undefined;
+    private _input?;
+    get input(): languages.CommentInput | undefined;
+    set input(value: languages.CommentInput | undefined);
+    private readonly _onDidChangeInput;
+    get onDidChangeInput(): Event<languages.CommentInput | undefined>;
+    private _label;
+    get label(): string | undefined;
+    set label(label: string | undefined);
+    private _contextValue;
+    get contextValue(): string | undefined;
+    set contextValue(context: string | undefined);
+    private readonly _onDidChangeLabel;
+    readonly onDidChangeLabel: Event<string | undefined>;
+    private _comments;
+    get comments(): ReadonlyArray<languages.Comment> | undefined;
+    set comments(newComments: ReadonlyArray<languages.Comment> | undefined);
+    private readonly _onDidChangeComments;
+    get onDidChangeComments(): Event<readonly languages.Comment[] | undefined>;
+    set range(range: T | undefined);
+    get range(): T | undefined;
+    private readonly _onDidChangeCanReply;
+    get onDidChangeCanReply(): Event<boolean>;
+    set canReply(state: boolean);
+    get canReply(): boolean;
+    private _collapsibleState;
+    get collapsibleState(): languages.CommentThreadCollapsibleState | undefined;
+    set collapsibleState(newState: languages.CommentThreadCollapsibleState | undefined);
+    private _initialCollapsibleState;
+    get initialCollapsibleState(): languages.CommentThreadCollapsibleState | undefined;
+    private set initialCollapsibleState(value);
+    private readonly _onDidChangeCollapsibleState;
+    onDidChangeCollapsibleState: Event<languages.CommentThreadCollapsibleState | undefined>;
+    private readonly _onDidChangeInitialCollapsibleState;
+    onDidChangeInitialCollapsibleState: Event<languages.CommentThreadCollapsibleState | undefined>;
+    private _isDisposed;
+    get isDisposed(): boolean;
+    isDocumentCommentThread(): this is languages.CommentThread<IRange>;
+    private _state;
+    get state(): languages.CommentThreadState | undefined;
+    set state(newState: languages.CommentThreadState | undefined);
+    private _applicability;
+    get applicability(): languages.CommentThreadApplicability | undefined;
+    set applicability(value: languages.CommentThreadApplicability | undefined);
+    private readonly _onDidChangeApplicability;
+    readonly onDidChangeApplicability: Event<languages.CommentThreadApplicability | undefined>;
+    get isTemplate(): boolean;
+    private readonly _onDidChangeState;
+    onDidChangeState: Event<languages.CommentThreadState | undefined>;
+    constructor(commentThreadHandle: number, controllerHandle: number, extensionId: string, threadId: string, resource: string, _range: T | undefined, comments: languages.Comment[] | undefined, _canReply: boolean, _isTemplate: boolean, editorId?: string | undefined);
+    batchUpdate(changes: CommentThreadChanges<T>): void;
+    hasComments(): boolean;
+    dispose(): void;
+    toJSON(): MarshalledCommentThread;
+}
+export declare class MainThreadCommentController implements ICommentController {
+    private readonly _proxy;
+    private readonly _commentService;
+    private readonly _handle;
+    private readonly _uniqueId;
+    private readonly _id;
+    private readonly _label;
+    private _features;
+    get handle(): number;
+    get id(): string;
+    get contextValue(): string;
+    get proxy(): ExtHostCommentsShape;
+    get label(): string;
+    private _reactions;
+    get reactions(): languages.CommentReaction[] | undefined;
+    set reactions(reactions: languages.CommentReaction[] | undefined);
+    get options(): languages.CommentOptions | undefined;
+    private readonly _threads;
+    activeEditingCommentThread?: MainThreadCommentThread<IRange | ICellRange>;
+    get features(): CommentProviderFeatures;
+    get owner(): string;
+    constructor(_proxy: ExtHostCommentsShape, _commentService: ICommentService, _handle: number, _uniqueId: string, _id: string, _label: string, _features: CommentProviderFeatures);
+    get activeComment(): {
+        thread: languages.CommentThread<IRange>;
+        comment?: languages.Comment | undefined;
+    } | undefined;
+    private _activeComment;
+    setActiveCommentAndThread(commentInfo: {
+        thread: languages.CommentThread;
+        comment?: languages.Comment;
+    } | undefined): Promise<void>;
+    updateFeatures(features: CommentProviderFeatures): void;
+    createCommentThread(extensionId: string, commentThreadHandle: number, threadId: string, resource: UriComponents, range: IRange | ICellRange | undefined, comments: languages.Comment[], isTemplate: boolean, editorId?: string): languages.CommentThread<IRange | ICellRange>;
+    updateCommentThread(commentThreadHandle: number, threadId: string, resource: UriComponents, changes: CommentThreadChanges): void;
+    deleteCommentThread(commentThreadHandle: number): void;
+    deleteCommentThreadMain(commentThreadId: string): void;
+    updateInput(input: string): void;
+    updateCommentingRanges(resourceHints?: languages.CommentingRangeResourceHint): void;
+    private getKnownThread;
+    getDocumentComments(resource: URI, token: CancellationToken): Promise<{
+        uniqueOwner: string;
+        label: string;
+        threads: languages.CommentThread<IRange>[];
+        commentingRanges: {
+            resource: URI;
+            ranges: IRange[];
+            fileComments: boolean;
+        };
+    }>;
+    getNotebookComments(resource: URI, token: CancellationToken): Promise<{
+        uniqueOwner: string;
+        label: string;
+        threads: languages.CommentThread<ICellRange>[];
+    }>;
+    toggleReaction(uri: URI, thread: languages.CommentThread, comment: languages.Comment, reaction: languages.CommentReaction, token: CancellationToken): Promise<void>;
+    getAllComments(): MainThreadCommentThread<IRange | ICellRange>[];
+    createCommentThreadTemplate(resource: UriComponents, range: IRange | undefined, editorId?: string): Promise<void>;
+    updateCommentThreadTemplate(threadHandle: number, range: IRange): Promise<void>;
+    toJSON(): any;
+}
+export declare class MainThreadComments extends Disposable implements MainThreadCommentsShape {
+    private readonly _commentService;
+    private readonly _viewsService;
+    private readonly _viewDescriptorService;
+    private readonly _uriIdentityService;
+    private readonly _editorService;
+    private readonly _proxy;
+    private _handlers;
+    private _commentControllers;
+    private _activeEditingCommentThread?;
+    private readonly _activeEditingCommentThreadDisposables;
+    private _openViewListener;
+    constructor(extHostContext: IExtHostContext, _commentService: ICommentService, _viewsService: IViewsService, _viewDescriptorService: IViewDescriptorService, _uriIdentityService: IUriIdentityService, _editorService: IEditorService);
+    $registerCommentController(handle: number, id: string, label: string, extensionId: string): void;
+    $unregisterCommentController(handle: number): void;
+    $updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void;
+    $createCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, range: IRange | ICellRange | undefined, comments: languages.Comment[], extensionId: ExtensionIdentifier, isTemplate: boolean, editorId?: string): languages.CommentThread<IRange | ICellRange> | undefined;
+    $updateCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, changes: CommentThreadChanges): void;
+    $deleteCommentThread(handle: number, commentThreadHandle: number): void;
+    $updateCommentingRanges(handle: number, resourceHints?: languages.CommentingRangeResourceHint): void;
+    $revealCommentThread(handle: number, commentThreadHandle: number, commentUniqueIdInThread: number, options: languages.CommentThreadRevealOptions): Promise<void>;
+    $hideCommentThread(handle: number, commentThreadHandle: number): Promise<void>;
+    private registerView;
+    private setComments;
+    private registerViewOpenedListener;
+    private registerViewListeners;
+    private getHandler;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadComments.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore, DisposableMap, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -7,19 +8,20 @@ import { CommentThreadCollapsibleState } from 'vscode/vscode/vs/editor/common/la
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService.service';
-import { CommentsPanel } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsView';
+import { CommentsPanel } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsView';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/views';
+import { COMMENTS_VIEW_ID, COMMENTS_VIEW_TITLE, COMMENTS_VIEW_STORAGE_ID } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsTreeViewer';
+import { Extensions, ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views.service';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { ViewPaneContainer } from '@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { registerIcon } from 'vscode/vscode/vs/platform/theme/common/iconRegistry';
 import { localize } from 'vscode/vscode/vs/nls';
+import { MarshalledId } from 'vscode/vscode/vs/base/common/marshallingIds';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
-import { revealCommentThread } from '@codingame/monaco-vscode-comments-extensions-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
+import { revealCommentThread } from '@codingame/monaco-vscode-eb7d5efd-2e60-59f8-9ba4-9a8ae8cb2957-common/vscode/vs/workbench/contrib/comments/browser/commentsController';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 
@@ -119,18 +121,19 @@ class MainThreadCommentThread {
         this._canReply = _canReply;
         this._isTemplate = _isTemplate;
         this.editorId = editorId;
-        this._onDidChangeInput = ( (new Emitter()));
-        this._onDidChangeLabel = ( (new Emitter()));
+        this._onDidChangeInput = ( new Emitter());
+        this._onDidChangeLabel = ( new Emitter());
         this.onDidChangeLabel = this._onDidChangeLabel.event;
-        this._onDidChangeComments = ( (new Emitter()));
-        this._onDidChangeCanReply = ( (new Emitter()));
-        this._onDidChangeCollapsibleState = ( (new Emitter()));
+        this._onDidChangeComments = ( new Emitter());
+        this._onDidChangeCanReply = ( new Emitter());
+        this._collapsibleState = CommentThreadCollapsibleState.Collapsed;
+        this._onDidChangeCollapsibleState = ( new Emitter());
         this.onDidChangeCollapsibleState = this._onDidChangeCollapsibleState.event;
-        this._onDidChangeInitialCollapsibleState = ( (new Emitter()));
+        this._onDidChangeInitialCollapsibleState = ( new Emitter());
         this.onDidChangeInitialCollapsibleState = this._onDidChangeInitialCollapsibleState.event;
-        this._onDidChangeApplicability = ( (new Emitter()));
+        this._onDidChangeApplicability = ( new Emitter());
         this.onDidChangeApplicability = this._onDidChangeApplicability.event;
-        this._onDidChangeState = ( (new Emitter()));
+        this._onDidChangeState = ( new Emitter());
         this.onDidChangeState = this._onDidChangeState.event;
         this._isDisposed = false;
         if (_isTemplate) {
@@ -183,7 +186,7 @@ class MainThreadCommentThread {
     }
     toJSON() {
         return {
-            $mid: 7 ,
+            $mid: MarshalledId.CommentThread,
             commentControlHandle: this.controllerHandle,
             commentThreadHandle: this.commentThreadHandle,
         };
@@ -192,7 +195,7 @@ class MainThreadCommentThread {
 class CommentThreadWithDisposable {
     constructor(thread) {
         this.thread = thread;
-        this.disposableStore = ( (new DisposableStore()));
+        this.disposableStore = ( new DisposableStore());
     }
     dispose() {
         this.disposableStore.dispose();
@@ -237,7 +240,7 @@ class MainThreadCommentController {
         this._id = _id;
         this._label = _label;
         this._features = _features;
-        this._threads = ( (new DisposableMap()));
+        this._threads = ( new DisposableMap());
     }
     get activeComment() {
         return this._activeComment;
@@ -250,19 +253,8 @@ class MainThreadCommentController {
         this._features = features;
     }
     createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, comments, isTemplate, editorId) {
-        const thread = ( (new MainThreadCommentThread(
-            commentThreadHandle,
-            this.handle,
-            extensionId,
-            threadId,
-             (URI.revive(resource).toString()),
-            range,
-            comments,
-            true,
-            isTemplate,
-            editorId
-        )));
-        const threadWithDisposable = ( (new CommentThreadWithDisposable(thread)));
+        const thread = ( new MainThreadCommentThread(commentThreadHandle, this.handle, extensionId, threadId, ( URI.revive(resource).toString()), range, comments, true, isTemplate, editorId));
+        const threadWithDisposable = ( new CommentThreadWithDisposable(thread));
         this._threads.set(commentThreadHandle, threadWithDisposable);
         threadWithDisposable.disposableStore.add(thread.onDidChangeCollapsibleState(() => {
             this.proxy.$updateCommentThread(this.handle, thread.commentThreadHandle, { collapseState: thread.collapsibleState });
@@ -327,7 +319,7 @@ class MainThreadCommentController {
         }
     }
     deleteCommentThreadMain(commentThreadId) {
-        for (const { thread } of ( (this._threads.values()))) {
+        for (const { thread } of ( this._threads.values())) {
             if (thread.threadId === commentThreadId) {
                 this._proxy.$deleteCommentThread(this._handle, thread.commentThreadHandle);
             }
@@ -347,7 +339,7 @@ class MainThreadCommentController {
     getKnownThread(commentThreadHandle) {
         const thread = this._threads.get(commentThreadHandle);
         if (!thread) {
-            throw ( (new Error('unknown thread')));
+            throw ( new Error('unknown thread'));
         }
         return thread.thread;
     }
@@ -365,9 +357,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( (this._threads.keys()))]) {
+        for (const thread of [...( this._threads.keys())]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.thread.resource === ( (resource.toString()))) {
+            if (commentThread.thread.resource === ( resource.toString())) {
                 if (commentThread.thread.isDocumentCommentThread()) {
                     ret.push(commentThread.thread);
                 }
@@ -394,9 +386,9 @@ class MainThreadCommentController {
             };
         }
         const ret = [];
-        for (const thread of [...( (this._threads.keys()))]) {
+        for (const thread of [...( this._threads.keys())]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.thread.resource === ( (resource.toString()))) {
+            if (commentThread.thread.resource === ( resource.toString())) {
                 if (!commentThread.thread.isDocumentCommentThread()) {
                     ret.push(commentThread.thread);
                 }
@@ -413,7 +405,7 @@ class MainThreadCommentController {
     }
     getAllComments() {
         const ret = [];
-        for (const thread of [...( (this._threads.keys()))]) {
+        for (const thread of [...( this._threads.keys())]) {
             ret.push(this._threads.get(thread).thread);
         }
         return ret;
@@ -426,12 +418,12 @@ class MainThreadCommentController {
     }
     toJSON() {
         return {
-            $mid: 6 ,
+            $mid: MarshalledId.CommentController,
             handle: this.handle
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(4553, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2255, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
         super();
@@ -440,11 +432,11 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         this._viewDescriptorService = _viewDescriptorService;
         this._uriIdentityService = _uriIdentityService;
         this._editorService = _editorService;
-        this._handlers = ( (new Map()));
-        this._commentControllers = ( (new Map()));
-        this._activeEditingCommentThreadDisposables = this._register(( (new DisposableStore())));
+        this._handlers = ( new Map());
+        this._commentControllers = ( new Map());
+        this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
         this._openViewListener = null;
-        this._proxy = ( (extHostContext.getProxy(ExtHostContext.ExtHostComments)));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
         this._commentService.unregisterCommentController();
         this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
             const handle = thread.controllerHandle;
@@ -460,7 +452,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     $registerCommentController(handle, id, label, extensionId) {
         const providerId = `${id}-${extensionId}`;
         this._handlers.set(handle, providerId);
-        const provider = ( (new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {})));
+        const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
         this._commentService.registerCommentController(providerId, provider);
         this._commentControllers.set(handle, provider);
         const commentsPanelAlreadyConstructed = !!this._viewDescriptorService.getViewDescriptorById(COMMENTS_VIEW_ID);
@@ -541,23 +533,23 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     }
     registerView(commentsViewAlreadyRegistered) {
         if (!commentsViewAlreadyRegistered) {
-            const VIEW_CONTAINER = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
+            const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
                 title: COMMENTS_VIEW_TITLE,
-                ctorDescriptor: ( (new SyncDescriptor(
+                ctorDescriptor: ( new SyncDescriptor(
                     ViewPaneContainer,
                     [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-                ))),
+                )),
                 storageId: COMMENTS_VIEW_STORAGE_ID,
                 hideIfEmpty: true,
                 icon: commentsViewIcon,
                 order: 10,
-            }, 1 );
-            ( (Registry.as(Extensions.ViewsRegistry))).registerViews([{
+            }, ViewContainerLocation.Panel);
+            ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
                     id: COMMENTS_VIEW_ID,
                     name: COMMENTS_VIEW_TITLE,
                     canToggleVisibility: false,
-                    ctorDescriptor: ( (new SyncDescriptor(CommentsPanel))),
+                    ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
                     canMoveView: true,
                     containerIcon: commentsViewIcon,
                     focusCommand: {
@@ -567,7 +559,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
     }
     setComments() {
-        [...( (this._commentControllers.keys()))].forEach(handle => {
+        [...( this._commentControllers.keys())].forEach(handle => {
             const threads = this._commentControllers.get(handle).getAllComments();
             if (threads.length) {
                 const providerId = this.getHandler(handle);
@@ -607,19 +599,19 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }));
     }
     getHandler(handle) {
-        if (!( (this._handlers.has(handle)))) {
-            throw ( (new Error('Unknown handler')));
+        if (!( this._handlers.has(handle))) {
+            throw ( new Error('Unknown handler'));
         }
         return this._handlers.get(handle);
     }
 };
 MainThreadComments = __decorate([
     extHostNamedCustomer(MainContext.MainThreadComments),
-    ( (__param(1, ICommentService))),
-    ( (__param(2, IViewsService))),
-    ( (__param(3, IViewDescriptorService))),
-    ( (__param(4, IUriIdentityService))),
-    ( (__param(5, IEditorService)))
+    ( __param(1, ICommentService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, IUriIdentityService)),
+    ( __param(5, IEditorService))
 ], MainThreadComments);
 
 export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };

package/vscode/src/vs/workbench/api/browser/mainThreadConfiguration.d.ts

@@ -0,0 +1,20 @@
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { MainThreadConfigurationShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { ConfigurationTarget, IConfigurationOverrides } from "vscode/vscode/vs/platform/configuration/common/configuration";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+export declare class MainThreadConfiguration implements MainThreadConfigurationShape {
+    private readonly _workspaceContextService;
+    private readonly configurationService;
+    private readonly _environmentService;
+    private readonly _configurationListener;
+    constructor(extHostContext: IExtHostContext, _workspaceContextService: IWorkspaceContextService, configurationService: IConfigurationService, _environmentService: IEnvironmentService);
+    private _getConfigurationData;
+    dispose(): void;
+    $updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: any, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+    $removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
+    private writeConfiguration;
+    private _updateValue;
+    private deriveConfigurationTarget;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadConfiguration.js

@@ -1,10 +1,13 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { getScopes, Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { getScopes, Extensions, ConfigurationScope } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { WorkbenchState } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { ExtHostContext, MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ConfigurationTarget } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
 
@@ -41,13 +44,13 @@ let MainThreadConfiguration = class MainThreadConfiguration {
         target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
         const configurationValue = this.configurationService.inspect(key, overrides);
         switch (target) {
-            case 8 :
+            case ConfigurationTarget.MEMORY:
                 return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
-            case 6 :
+            case ConfigurationTarget.WORKSPACE_FOLDER:
                 return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
-            case 5 :
+            case ConfigurationTarget.WORKSPACE:
                 return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
-            case 4 :
+            case ConfigurationTarget.USER_REMOTE:
                 return this._updateValue(key, value, target, configurationValue?.userRemote?.override, overrides, scopeToLanguage);
             default:
                 return this._updateValue(key, value, target, configurationValue?.userLocal?.override, overrides, scopeToLanguage);
@@ -61,13 +64,13 @@ let MainThreadConfiguration = class MainThreadConfiguration {
         return this.configurationService.updateValue(key, value, overrides, configurationTarget, { donotNotifyError: true });
     }
     deriveConfigurationTarget(key, overrides) {
-        if (overrides.resource && this._workspaceContextService.getWorkbenchState() === 3 ) {
+        if (overrides.resource && this._workspaceContextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
             const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-            if (configurationProperties[key] && ((configurationProperties[key].scope === 4  || configurationProperties[key].scope === 5) )) {
-                return 6 ;
+            if (configurationProperties[key] && (configurationProperties[key].scope === ConfigurationScope.RESOURCE || configurationProperties[key].scope === ConfigurationScope.LANGUAGE_OVERRIDABLE)) {
+                return ConfigurationTarget.WORKSPACE_FOLDER;
             }
         }
-        return 5 ;
+        return ConfigurationTarget.WORKSPACE;
     }
 };
 MainThreadConfiguration = __decorate([

package/vscode/src/vs/workbench/api/browser/mainThreadConsole.d.ts

@@ -0,0 +1,13 @@
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { MainThreadConsoleShape } from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { IEnvironmentService } from "vscode/vscode/vs/platform/environment/common/environment.service";
+import { IRemoteConsoleLog } from "../../../base/common/console.js";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+export declare class MainThreadConsole implements MainThreadConsoleShape {
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _isExtensionDevTestFromCli;
+    constructor(_extHostContext: IExtHostContext, _environmentService: IEnvironmentService, _logService: ILogService);
+    dispose(): void;
+    $logExtensionHostMessage(entry: IRemoteConsoleLog): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadConsole.js

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.d.ts

@@ -0,0 +1,38 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { UriComponents } from "vscode/vscode/vs/base/common/uri";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "vscode/vscode/vs/platform/storage/common/storage.service";
+import { MainThreadWebviewPanels } from "./mainThreadWebviewPanels.js";
+import { MainThreadWebviews } from "./mainThreadWebviews.js";
+import * as extHostProtocol from "vscode/vscode/vs/workbench/api/common/extHost.protocol";
+import { ICustomEditorService } from "vscode/vscode/vs/workbench/contrib/customEditor/common/customEditor.service";
+import { IWebviewWorkbenchService } from "vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service";
+import { IEditorGroupsService } from "vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IWorkingCopyFileService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+export declare class MainThreadCustomEditors extends Disposable implements extHostProtocol.MainThreadCustomEditorsShape {
+    private readonly mainThreadWebview;
+    private readonly mainThreadWebviewPanels;
+    private readonly _customEditorService;
+    private readonly _editorGroupService;
+    private readonly _editorService;
+    private readonly _instantiationService;
+    private readonly _webviewWorkbenchService;
+    private readonly _proxyCustomEditors;
+    private readonly _editorProviders;
+    private readonly _editorRenameBackups;
+    private readonly _webviewOriginStore;
+    constructor(context: IExtHostContext, mainThreadWebview: MainThreadWebviews, mainThreadWebviewPanels: MainThreadWebviewPanels, extensionService: IExtensionService, storageService: IStorageService, workingCopyService: IWorkingCopyService, workingCopyFileService: IWorkingCopyFileService, _customEditorService: ICustomEditorService, _editorGroupService: IEditorGroupsService, _editorService: IEditorService, _instantiationService: IInstantiationService, _webviewWorkbenchService: IWebviewWorkbenchService);
+    $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, capabilities: extHostProtocol.CustomTextEditorCapabilities, serializeBuffersForPostMessage: boolean): void;
+    $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, supportsMultipleEditorsPerDocument: boolean, serializeBuffersForPostMessage: boolean): void;
+    private registerEditorProvider;
+    $unregisterEditorProvider(viewType: string): void;
+    private getOrCreateCustomEditorModel;
+    $onDidEdit(resourceComponents: UriComponents, viewType: string, editId: number, label: string | undefined): Promise<void>;
+    $onContentChange(resourceComponents: UriComponents, viewType: string): Promise<void>;
+    private getCustomEditorModel;
+    private onWillRunWorkingCopyFileOperation;
+}