@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -10,22 +10,17 @@ let MainThreadClipboard = class MainThreadClipboard {
         this._clipboardService = _clipboardService;
         this._logService = _logService;
     }
-    dispose() {
-    }
+    dispose() {}
     $readText() {
-        this._logService.trace('MainThreadClipboard#readText');
+        this._logService.trace("MainThreadClipboard#readText");
         const readText = this._clipboardService.readText();
         return readText;
     }
     $writeText(value) {
-        this._logService.trace('MainThreadClipboard#writeText with text.length : ', value.length);
+        this._logService.trace("MainThreadClipboard#writeText with text.length : ", value.length);
         return this._clipboardService.writeText(value);
     }
 };
-MainThreadClipboard = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadClipboard),
-    ( __param(1, IClipboardService)),
-    ( __param(2, ILogService))
-], MainThreadClipboard);
+MainThreadClipboard = __decorate([extHostNamedCustomer(MainContext.MainThreadClipboard), ( __param(1, IClipboardService)), ( __param(2, ILogService))], MainThreadClipboard);
 
 export { MainThreadClipboard };

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

@@ -16,8 +16,8 @@ class EditorWebviewZone {
         this.line = line;
         this.height = height;
         this.webview = webview;
-        this.domNode = createElement('div');
-        this.domNode.style.zIndex = '10';
+        this.domNode = createElement("div");
+        this.domNode.style.zIndex = "10";
         this.afterLineNumber = line;
         this.afterColumn = 1;
         this.heightInLines = height;
@@ -41,7 +41,7 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
     }
     async $createEditorInset(handle, id, uri, line, height, options, extensionId, extensionLocation) {
         let editor;
-        id = id.substr(0, id.indexOf(','));
+        id = id.substr(0, id.indexOf(","));
         for (const candidate of this._editorService.listCodeEditors()) {
             if (candidate.getId() === id && candidate.hasModel() && isEqual(candidate.getModel().uri, URI.revive(uri))) {
                 editor = candidate;
@@ -56,10 +56,13 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
         const webview = this._webviewService.createWebviewElement({
             title: undefined,
             options: {
-                enableFindWidget: false,
+                enableFindWidget: false
             },
             contentOptions: reviveWebviewContentOptions(options),
-            extension: { id: extensionId, location: URI.revive(extensionLocation) }
+            extension: {
+                id: extensionId,
+                location: URI.revive(extensionLocation)
+            }
         });
         const webviewZone = ( new EditorWebviewZone(editor, line, height, webview));
         const remove = () => {
@@ -71,7 +74,9 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
         disposables.add(editor.onDidDispose(remove));
         disposables.add(webviewZone);
         disposables.add(webview);
-        disposables.add(webview.onMessage(msg => this._proxy.$onDidReceiveMessage(handle, msg.message)));
+        disposables.add(
+            webview.onMessage(msg => this._proxy.$onDidReceiveMessage(handle, msg.message))
+        );
         this._insets.set(handle, webviewZone);
     }
     $disposeEditorInset(handle) {
@@ -95,15 +100,11 @@ let MainThreadEditorInsets = class MainThreadEditorInsets {
     getInset(handle) {
         const inset = this._insets.get(handle);
         if (!inset) {
-            throw ( new Error('Unknown inset'));
+            throw ( new Error("Unknown inset"));
         }
         return inset;
     }
 };
-MainThreadEditorInsets = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadEditorInsets),
-    ( __param(1, ICodeEditorService)),
-    ( __param(2, IWebviewService))
-], MainThreadEditorInsets);
+MainThreadEditorInsets = __decorate([extHostNamedCustomer(MainContext.MainThreadEditorInsets), ( __param(1, ICodeEditorService)), ( __param(2, IWebviewService))], MainThreadEditorInsets);
 
 export { MainThreadEditorInsets };

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

@@ -16,7 +16,10 @@ let MainThreadCommands = class MainThreadCommands {
         this._extensionService = _extensionService;
         this._commandRegistrations = ( new DisposableMap());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostCommands));
-        this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand('_generateCommandsDocumentation', () => this._generateCommandsDocumentation());
+        this._generateCommandsDocumentationRegistration = CommandsRegistry.registerCommand(
+            "_generateCommandsDocumentation",
+            () => this._generateCommandsDocumentation()
+        );
     }
     dispose() {
         this._commandRegistrations.dispose();
@@ -32,9 +35,9 @@ let MainThreadCommands = class MainThreadCommands {
         }
         const all = [];
         for (const id in result) {
-            all.push('`' + id + '` - ' + _generateMarkdown(result[id]));
+            all.push("`" + id + "` - " + _generateMarkdown(result[id]));
         }
-        console.log(all.join('\n'));
+        console.log(all.join("\n"));
     }
     $registerCommand(id) {
         this._commandRegistrations.set(id, CommandsRegistry.registerCommand(id, (accessor, ...args) => {
@@ -61,7 +64,7 @@ let MainThreadCommands = class MainThreadCommands {
         }
         if (retry && args.length > 0 && !CommandsRegistry.getCommand(id)) {
             await this._extensionService.activateByEvent(`onCommand:${id}`);
-            throw ( new Error('$executeCommand:retry'));
+            throw ( new Error("$executeCommand:retry"));
         }
         return this._commandService.executeCommand(id, ...args);
     }
@@ -69,31 +72,25 @@ let MainThreadCommands = class MainThreadCommands {
         return Promise.resolve([...( CommandsRegistry.getCommands().keys())]);
     }
 };
-MainThreadCommands = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadCommands),
-    ( __param(1, ICommandService)),
-    ( __param(2, IExtensionService))
-], MainThreadCommands);
+MainThreadCommands = __decorate([extHostNamedCustomer(MainContext.MainThreadCommands), ( __param(1, ICommandService)), ( __param(2, IExtensionService))], MainThreadCommands);
 function _generateMarkdown(description) {
-    if (typeof description === 'string') {
+    if (typeof description === "string") {
         return description;
-    }
-    else {
-        const descriptionString = isString(description.description)
-            ? description.description
-            : description.description.original;
+    } else {
+        const descriptionString = isString(description.description) ?
+        description.description : description.description.original;
         const parts = [descriptionString];
-        parts.push('\n\n');
+        parts.push("\n\n");
         if (description.args) {
             for (const arg of description.args) {
-                parts.push(`* _${arg.name}_ - ${arg.description || ''}\n`);
+                parts.push(`* _${arg.name}_ - ${arg.description || ""}\n`);
             }
         }
         if (description.returns) {
             parts.push(`* _(returns)_ - ${description.returns}`);
         }
-        parts.push('\n\n');
-        return parts.join('');
+        parts.push("\n\n");
+        return parts.join("");
     }
 }
 

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

@@ -33,7 +33,9 @@ class MainThreadCommentThread {
         this._input = value;
         this._onDidChangeInput.fire(value);
     }
-    get onDidChangeInput() { return this._onDidChangeInput.event; }
+    get onDidChangeInput() {
+        return this._onDidChangeInput.event;
+    }
     get label() {
         return this._label;
     }
@@ -54,14 +56,18 @@ class MainThreadCommentThread {
         this._comments = newComments;
         this._onDidChangeComments.fire(this._comments);
     }
-    get onDidChangeComments() { return this._onDidChangeComments.event; }
+    get onDidChangeComments() {
+        return this._onDidChangeComments.event;
+    }
     set range(range) {
         this._range = range;
     }
     get range() {
         return this._range;
     }
-    get onDidChangeCanReply() { return this._onDidChangeCanReply.event; }
+    get onDidChangeCanReply() {
+        return this._onDidChangeCanReply.event;
+    }
     set canReply(state) {
         this._canReply = state;
         this._onDidChangeCanReply.fire(!!this._canReply);
@@ -111,7 +117,18 @@ class MainThreadCommentThread {
     get isTemplate() {
         return this._isTemplate;
     }
-    constructor(commentThreadHandle, controllerHandle, extensionId, threadId, resource, _range, comments, _canReply, _isTemplate, editorId) {
+    constructor(
+        commentThreadHandle,
+        controllerHandle,
+        extensionId,
+        threadId,
+        resource,
+        _range,
+        comments,
+        _canReply,
+        _isTemplate,
+        editorId
+    ) {
         this.commentThreadHandle = commentThreadHandle;
         this.controllerHandle = controllerHandle;
         this.extensionId = extensionId;
@@ -138,38 +155,37 @@ class MainThreadCommentThread {
         this._isDisposed = false;
         if (_isTemplate) {
             this.comments = [];
-        }
-        else if (comments) {
+        } else if (comments) {
             this._comments = comments;
         }
     }
     batchUpdate(changes) {
-        const modified = (value) => Object.prototype.hasOwnProperty.call(changes, value);
-        if (modified('range')) {
+        const modified = value => Object.prototype.hasOwnProperty.call(changes, value);
+        if (modified("range")) {
             this._range = changes.range;
         }
-        if (modified('label')) {
+        if (modified("label")) {
             this._label = changes.label;
         }
-        if (modified('contextValue')) {
+        if (modified("contextValue")) {
             this._contextValue = changes.contextValue === null ? undefined : changes.contextValue;
         }
-        if (modified('comments')) {
+        if (modified("comments")) {
             this.comments = changes.comments;
         }
-        if (modified('collapseState')) {
+        if (modified("collapseState")) {
             this.collapsibleState = changes.collapseState;
         }
-        if (modified('canReply')) {
+        if (modified("canReply")) {
             this.canReply = changes.canReply;
         }
-        if (modified('state')) {
+        if (modified("state")) {
             this.state = changes.state;
         }
-        if (modified('applicability')) {
+        if (modified("applicability")) {
             this.applicability = changes.applicability;
         }
-        if (modified('isTemplate')) {
+        if (modified("isTemplate")) {
             this._isTemplate = changes.isTemplate;
         }
     }
@@ -188,7 +204,7 @@ class MainThreadCommentThread {
         return {
             $mid: MarshalledId.CommentThread,
             commentControlHandle: this.controllerHandle,
-            commentThreadHandle: this.commentThreadHandle,
+            commentThreadHandle: this.commentThreadHandle
         };
     }
 }
@@ -248,17 +264,31 @@ class MainThreadCommentController extends Disposable {
     }
     async setActiveCommentAndThread(commentInfo) {
         this._activeComment = commentInfo;
-        return this._proxy.$setActiveComment(this._handle, commentInfo ? { commentThreadHandle: commentInfo.thread.commentThreadHandle, uniqueIdInThread: commentInfo.comment?.uniqueIdInThread } : undefined);
+        return this._proxy.$setActiveComment(this._handle, commentInfo ? {
+            commentThreadHandle: commentInfo.thread.commentThreadHandle,
+            uniqueIdInThread: commentInfo.comment?.uniqueIdInThread
+        } : undefined);
     }
     updateFeatures(features) {
         this._features = features;
     }
-    createCommentThread(extensionId, commentThreadHandle, threadId, resource, range, comments, isTemplate, editorId) {
+    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));
         this._threads.set(commentThreadHandle, threadWithDisposable);
         threadWithDisposable.disposableStore.add(thread.onDidChangeCollapsibleState(() => {
-            this.proxy.$updateCommentThread(this.handle, thread.commentThreadHandle, { collapseState: thread.collapsibleState });
+            this.proxy.$updateCommentThread(this.handle, thread.commentThreadHandle, {
+                collapseState: thread.collapsibleState
+            });
         }));
         if (thread.isDocumentCommentThread()) {
             this._commentService.updateComments(this._uniqueId, {
@@ -267,8 +297,7 @@ class MainThreadCommentController extends Disposable {
                 changed: [],
                 pending: []
             });
-        }
-        else {
+        } else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [thread],
                 removed: [],
@@ -288,8 +317,7 @@ class MainThreadCommentController extends Disposable {
                 changed: [thread],
                 pending: []
             });
-        }
-        else {
+        } else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [],
                 removed: [],
@@ -309,8 +337,7 @@ class MainThreadCommentController extends Disposable {
                 changed: [],
                 pending: []
             });
-        }
-        else {
+        } else {
             this._commentService.updateNotebookComments(this._uniqueId, {
                 added: [],
                 removed: [thread],
@@ -320,7 +347,9 @@ class MainThreadCommentController extends Disposable {
         }
     }
     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);
             }
@@ -340,7 +369,7 @@ class MainThreadCommentController extends Disposable {
     getKnownThread(commentThreadHandle) {
         const thread = this._threads.get(commentThreadHandle);
         if (!thread) {
-            throw ( new Error('unknown thread'));
+            throw ( new Error("unknown thread"));
         }
         return thread.thread;
     }
@@ -424,9 +453,16 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2500, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2503, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
-    constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
+    constructor(
+        extHostContext,
+        _commentService,
+        _viewsService,
+        _viewDescriptorService,
+        _uriIdentityService,
+        _editorService
+    ) {
         super();
         this._commentService = _commentService;
         this._viewsService = _viewsService;
@@ -441,16 +477,18 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         this._onChangeContainerLocationListener = this._register(( new MutableDisposable()));
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
         this._commentService.unregisterCommentController();
-        this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
-            const handle = thread.controllerHandle;
-            const controller = this._commentControllers.get(handle);
-            if (!controller) {
-                return;
-            }
-            this._activeEditingCommentThreadDisposables.clear();
-            this._activeEditingCommentThread = thread;
-            controller.activeEditingCommentThread = this._activeEditingCommentThread;
-        }));
+        this._register(
+            this._commentService.onDidChangeActiveEditingCommentThread(async thread => {
+                const handle = thread.controllerHandle;
+                const controller = this._commentControllers.get(handle);
+                if (!controller) {
+                    return;
+                }
+                this._activeEditingCommentThreadDisposables.clear();
+                this._activeEditingCommentThread = thread;
+                controller.activeEditingCommentThread = this._activeEditingCommentThread;
+            })
+        );
     }
     $registerCommentController(handle, id, label, extensionId) {
         const providerId = `${id}-${extensionId}`;
@@ -471,10 +509,9 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         this._handlers.delete(handle);
         this._commentControllers.get(handle)?.dispose();
         this._commentControllers.delete(handle);
-        if (typeof providerId !== 'string') {
+        if (typeof providerId !== "string") {
             return;
-        }
-        else {
+        } else {
             this._commentService.unregisterCommentController(providerId);
         }
     }
@@ -485,12 +522,31 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         }
         provider.updateFeatures(features);
     }
-    $createCommentThread(handle, commentThreadHandle, threadId, resource, range, comments, extensionId, isTemplate, editorId) {
+    $createCommentThread(
+        handle,
+        commentThreadHandle,
+        threadId,
+        resource,
+        range,
+        comments,
+        extensionId,
+        isTemplate,
+        editorId
+    ) {
         const provider = this._commentControllers.get(handle);
         if (!provider) {
             return undefined;
         }
-        return provider.createCommentThread(extensionId.value, commentThreadHandle, threadId, resource, range, comments, isTemplate, editorId);
+        return provider.createCommentThread(
+            extensionId.value,
+            commentThreadHandle,
+            threadId,
+            resource,
+            range,
+            comments,
+            isTemplate,
+            editorId
+        );
     }
     $updateCommentThread(handle, commentThreadHandle, threadId, resource, changes) {
         const provider = this._commentControllers.get(handle);
@@ -523,7 +579,16 @@ let MainThreadComments = class MainThreadComments extends Disposable {
             return Promise.resolve();
         }
         const comment = thread.comments?.find(comment => comment.uniqueIdInThread === commentUniqueIdInThread);
-        revealCommentThread(this._commentService, this._editorService, this._uriIdentityService, thread, comment, options.focusReply, undefined, options.preserveFocus);
+        revealCommentThread(
+            this._commentService,
+            this._editorService,
+            this._uriIdentityService,
+            thread,
+            comment,
+            options.focusReply,
+            undefined,
+            options.preserveFocus
+        );
     }
     async $hideCommentThread(handle, commentThreadHandle) {
         const provider = this._commentControllers.get(handle);
@@ -542,26 +607,25 @@ let MainThreadComments = class MainThreadComments extends Disposable {
             const VIEW_CONTAINER = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
                 id: COMMENTS_VIEW_ID,
                 title: COMMENTS_VIEW_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(
-                    ViewPaneContainer,
-                    [COMMENTS_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-                )),
+                ctorDescriptor: ( new SyncDescriptor(ViewPaneContainer, [COMMENTS_VIEW_ID, {
+                    mergeViewWithContainerWhenSingleView: true
+                }])),
                 storageId: COMMENTS_VIEW_STORAGE_ID,
                 hideIfEmpty: true,
                 icon: commentsViewIcon,
-                order: 10,
+                order: 10
             }, ViewContainerLocation.Panel);
             ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
-                    id: COMMENTS_VIEW_ID,
-                    name: COMMENTS_VIEW_TITLE,
-                    canToggleVisibility: false,
-                    ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
-                    canMoveView: true,
-                    containerIcon: commentsViewIcon,
-                    focusCommand: {
-                        id: 'workbench.action.focusCommentsPanel'
-                    }
-                }], VIEW_CONTAINER);
+                id: COMMENTS_VIEW_ID,
+                name: COMMENTS_VIEW_TITLE,
+                canToggleVisibility: false,
+                ctorDescriptor: ( new SyncDescriptor(CommentsPanel)),
+                canMoveView: true,
+                containerIcon: commentsViewIcon,
+                focusCommand: {
+                    id: "workbench.action.focusCommentsPanel"
+                }
+            }], VIEW_CONTAINER);
         }
         this.registerViewListeners(commentsPanelAlreadyConstructed);
     }
@@ -610,18 +674,11 @@ let MainThreadComments = class MainThreadComments extends Disposable {
     }
     getHandler(handle) {
         if (!( this._handlers.has(handle))) {
-            throw ( new Error('Unknown handler'));
+            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))
-], MainThreadComments);
+MainThreadComments = __decorate([extHostNamedCustomer(MainContext.MainThreadComments), ( __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.js

@@ -12,7 +12,12 @@ import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/pl
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 
 let MainThreadConfiguration = class MainThreadConfiguration {
-    constructor(extHostContext, _workspaceContextService, configurationService, _environmentService) {
+    constructor(
+        extHostContext,
+        _workspaceContextService,
+        configurationService,
+        _environmentService
+    ) {
         this._workspaceContextService = _workspaceContextService;
         this.configurationService = configurationService;
         this._environmentService = _environmentService;
@@ -23,7 +28,10 @@ let MainThreadConfiguration = class MainThreadConfiguration {
         });
     }
     _getConfigurationData() {
-        const configurationData = { ...(this.configurationService.getConfigurationData()), configurationScopes: [] };
+        const configurationData = {
+            ...(this.configurationService.getConfigurationData()),
+            configurationScopes: []
+        };
         if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
             configurationData.configurationScopes = getScopes();
         }
@@ -33,35 +41,86 @@ let MainThreadConfiguration = class MainThreadConfiguration {
         this._configurationListener.dispose();
     }
     $updateConfigurationOption(target, key, value, overrides, scopeToLanguage) {
-        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        overrides = {
+            resource: overrides?.resource ? URI.revive(overrides.resource) : undefined,
+            overrideIdentifier: overrides?.overrideIdentifier
+        };
         return this.writeConfiguration(target, key, value, overrides, scopeToLanguage);
     }
     $removeConfigurationOption(target, key, overrides, scopeToLanguage) {
-        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        overrides = {
+            resource: overrides?.resource ? URI.revive(overrides.resource) : undefined,
+            overrideIdentifier: overrides?.overrideIdentifier
+        };
         return this.writeConfiguration(target, key, undefined, overrides, scopeToLanguage);
     }
     writeConfiguration(target, key, value, overrides, scopeToLanguage) {
         target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
         const configurationValue = this.configurationService.inspect(key, overrides);
         switch (target) {
-            case ConfigurationTarget.MEMORY:
-                return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
-            case ConfigurationTarget.WORKSPACE_FOLDER:
-                return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
-            case ConfigurationTarget.WORKSPACE:
-                return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
-            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);
+        case ConfigurationTarget.MEMORY:
+            return this._updateValue(
+                key,
+                value,
+                target,
+                configurationValue?.memory?.override,
+                overrides,
+                scopeToLanguage
+            );
+        case ConfigurationTarget.WORKSPACE_FOLDER:
+            return this._updateValue(
+                key,
+                value,
+                target,
+                configurationValue?.workspaceFolder?.override,
+                overrides,
+                scopeToLanguage
+            );
+        case ConfigurationTarget.WORKSPACE:
+            return this._updateValue(
+                key,
+                value,
+                target,
+                configurationValue?.workspace?.override,
+                overrides,
+                scopeToLanguage
+            );
+        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
+            );
         }
     }
-    _updateValue(key, value, configurationTarget, overriddenValue, overrides, scopeToLanguage) {
-        overrides = scopeToLanguage === true ? overrides
-            : scopeToLanguage === false ? { resource: overrides.resource }
-                : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
-                    : { resource: overrides.resource };
-        return this.configurationService.updateValue(key, value, overrides, configurationTarget, { donotNotifyError: true });
+    _updateValue(
+        key,
+        value,
+        configurationTarget,
+        overriddenValue,
+        overrides,
+        scopeToLanguage
+    ) {
+        overrides = scopeToLanguage === true ? overrides : scopeToLanguage === false ? {
+            resource: overrides.resource
+        } : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides : {
+            resource: overrides.resource
+        };
+        return this.configurationService.updateValue(key, value, overrides, configurationTarget, {
+            donotNotifyError: true
+        });
     }
     deriveConfigurationTarget(key, overrides) {
         if (overrides.resource && this._workspaceContextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
@@ -73,11 +132,6 @@ let MainThreadConfiguration = class MainThreadConfiguration {
         return ConfigurationTarget.WORKSPACE;
     }
 };
-MainThreadConfiguration = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadConfiguration),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEnvironmentService))
-], MainThreadConfiguration);
+MainThreadConfiguration = __decorate([extHostNamedCustomer(MainContext.MainThreadConfiguration), ( __param(1, IWorkspaceContextService)), ( __param(2, IConfigurationService)), ( __param(3, IEnvironmentService))], MainThreadConfiguration);
 
 export { MainThreadConfiguration };