@codingame/monaco-vscode-api 1.82.6 → 1.83.1

package/vscode/src/vs/workbench/services/extensions/common/remoteExtensionHost.js

@@ -18,7 +18,6 @@ import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspac
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { parseExtensionDevOptions } from './extensionDevOptions.js';
 import { isMessageOfType, UIKind, createMessageOfType } from './extensionHostProtocol.js';
-import { ExtensionHostExtensions } from './extensions.js';
 let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
     constructor(runningLocation, _initDataProvider, remoteSocketFactoryService, _contextService, _environmentService, _telemetryService, _logService, _loggerService, _labelService, remoteAuthorityResolverService, _extensionHostDebugService, _productService, _signService) {
         super();
@@ -36,7 +35,7 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
         this._productService = _productService;
         this._signService = _signService;
         this.startup = 1 ;
-        this.extensions = ( new ExtensionHostExtensions());
+        this.extensions = null;
         this._onExit = this._register(( new Emitter()));
         this.onExit = this._onExit.event;
         this.remoteAuthority = this._initDataProvider.remoteAuthority;
@@ -46,7 +45,7 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
         const devOpts = parseExtensionDevOptions(this._environmentService);
         this._isExtensionDevHost = devOpts.isExtensionDevHost;
     }
-    async start() {
+    start() {
         const options = {
             commit: this._productService.commit,
             quality: this._productService.quality,
@@ -61,7 +60,6 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
             logService: this._logService,
             ipcLogger: null
         };
-        const initDataPromise = this._initDataProvider.getInitData();
         return this.remoteAuthorityResolverService.resolveAuthority(this._initDataProvider.remoteAuthority).then((resolverResult) => {
             const startParams = {
                 language: platform.language,
@@ -101,7 +99,7 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
                     }, 60 * 1000);
                     const disposable = protocol.onMessage(msg => {
                         if (isMessageOfType(msg, 1 )) {
-                            this._createExtHostInitData(initDataPromise, isExtensionDevelopmentDebug).then(data => {
+                            this._createExtHostInitData(isExtensionDevelopmentDebug).then(data => {
                                 protocol.send(VSBuffer.fromString(JSON.stringify(data)));
                             });
                             return;
@@ -132,10 +130,10 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
         }
         this._onExit.fire([0, reconnectionToken]);
     }
-    async _createExtHostInitData(initDataPromise, isExtensionDevelopmentDebug) {
-        const remoteInitData = await initDataPromise;
+    async _createExtHostInitData(isExtensionDevelopmentDebug) {
+        const remoteInitData = await this._initDataProvider.getInitData();
+        this.extensions = remoteInitData.extensions;
         const workspace = this._contextService.getWorkspace();
-        const deltaExtensions = this.extensions.set(remoteInitData.allExtensions, remoteInitData.myExtensions);
         return {
             commit: this._productService.commit,
             version: this._productService.version,
@@ -171,9 +169,7 @@ let RemoteExtensionHost = class RemoteExtensionHost extends Disposable {
                 includeStack: false,
                 logNative: Boolean(this._environmentService.debugExtensionHost.debugId)
             },
-            allExtensions: deltaExtensions.toAdd,
-            activationEvents: deltaExtensions.addActivationEvents,
-            myExtensions: deltaExtensions.myToAdd,
+            extensions: this.extensions.toSnapshot(),
             telemetryInfo: {
                 sessionId: this._telemetryService.sessionId,
                 machineId: this._telemetryService.machineId,

package/vscode/src/vs/workbench/services/extensions/common/rpcProtocol.js

@@ -3,7 +3,7 @@ import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { transformIncomingURIs } from '../../../../base/common/uriIpc.js';
 import { CanceledLazyPromise, LazyPromise } from './lazyPromise.js';
 import { getStringIdentifierForProxy, SerializableObjectWithBuffers, ProxyIdentifier } from './proxyIdentifier.js';
@@ -103,6 +103,7 @@ class RPCProtocol extends Disposable {
         this._isDisposed = true;
         ( Object.keys(this._pendingRPCReplies)).forEach((msgId) => {
             const pending = this._pendingRPCReplies[msgId];
+            delete this._pendingRPCReplies[msgId];
             pending.resolveErr(errors.canceled());
         });
     }
@@ -368,14 +369,15 @@ class RPCProtocol extends Disposable {
         const req = ++this._lastMessageId;
         const callId = String(req);
         const result = ( new LazyPromise());
+        const disposable = ( new DisposableStore());
         if (cancellationToken) {
-            cancellationToken.onCancellationRequested(() => {
+            disposable.add(cancellationToken.onCancellationRequested(() => {
                 const msg = MessageIO.serializeCancel(req);
                 this._logger?.logOutgoing(msg.byteLength, req, 0 , `cancel`);
                 this._protocol.send(MessageIO.serializeCancel(req));
-            });
+            }));
         }
-        this._pendingRPCReplies[callId] = result;
+        this._pendingRPCReplies[callId] = ( new PendingRPCReply(result, disposable));
         this._onWillSendRequest(req);
         const msg = MessageIO.serializeRequest(req, rpcId, methodName, serializedRequestArguments, !!cancellationToken);
         this._logger?.logOutgoing(msg.byteLength, req, 0 , `request: ${getStringIdentifierForProxy(rpcId)}.${methodName}(`, args);
@@ -383,6 +385,20 @@ class RPCProtocol extends Disposable {
         return result;
     }
 }
+class PendingRPCReply {
+    constructor(_promise, _disposable) {
+        this._promise = _promise;
+        this._disposable = _disposable;
+    }
+    resolveOk(value) {
+        this._promise.resolveOk(value);
+        this._disposable.dispose();
+    }
+    resolveErr(err) {
+        this._promise.resolveErr(err);
+        this._disposable.dispose();
+    }
+}
 class MessageBuffer {
     static alloc(type, req, messageSize) {
         const result = ( new MessageBuffer(VSBuffer.alloc(messageSize + 1  + 4 ), 0));

package/vscode/src/vs/workbench/services/keybinding/browser/keybindingService.js

@@ -224,7 +224,28 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
         });
         this.updateKeybindingsJsonSchema();
         this._register(extensionService.onDidRegisterExtensions(() => this.updateKeybindingsJsonSchema()));
-        this._register(dom.addDisposableListener(window, dom.EventType.KEY_DOWN, (e) => {
+        this._register(this._registerKeyListeners(window));
+        this._register(dom.onDidCreateWindow(({ window, disposableStore }) => {
+            disposableStore.add(this._registerKeyListeners(window));
+        }));
+        this._register(browser.onDidChangeFullscreen(() => {
+            const keyboard = navigator.keyboard;
+            if (BrowserFeatures.keyboard === 2 ) {
+                return;
+            }
+            if (browser.isFullscreen()) {
+                keyboard?.lock(['Escape']);
+            }
+            else {
+                keyboard?.unlock();
+            }
+            this._cachedResolver = null;
+            this._onDidUpdateKeybindings.fire();
+        }));
+    }
+    _registerKeyListeners(window) {
+        const disposables = ( new DisposableStore());
+        disposables.add(dom.addDisposableListener(window, dom.EventType.KEY_DOWN, (e) => {
             this.isComposingGlobalContextKey.set(e.isComposing);
             const keyEvent = ( new StandardKeyboardEvent(e));
             this._log(`/ Received  keydown event - ${printKeyboardEvent(e)}`);
@@ -235,7 +256,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             }
             this.isComposingGlobalContextKey.set(false);
         }));
-        this._register(dom.addDisposableListener(window, dom.EventType.KEY_UP, (e) => {
+        disposables.add(dom.addDisposableListener(window, dom.EventType.KEY_UP, (e) => {
             this.isComposingGlobalContextKey.set(e.isComposing);
             const keyEvent = ( new StandardKeyboardEvent(e));
             const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
@@ -244,20 +265,7 @@ let WorkbenchKeybindingService = WorkbenchKeybindingService_1 = class WorkbenchK
             }
             this.isComposingGlobalContextKey.set(false);
         }));
-        this._register(browser.onDidChangeFullscreen(() => {
-            const keyboard = navigator.keyboard;
-            if (BrowserFeatures.keyboard === 2 ) {
-                return;
-            }
-            if (browser.isFullscreen()) {
-                keyboard?.lock(['Escape']);
-            }
-            else {
-                keyboard?.unlock();
-            }
-            this._cachedResolver = null;
-            this._onDidUpdateKeybindings.fire();
-        }));
+        return disposables;
     }
     registerSchemaContribution(contribution) {
         this._contributions.push(contribution);

package/vscode/src/vs/workbench/services/output/common/output.js

@@ -6,7 +6,6 @@ const OUTPUT_MIME = 'text/x-code-output';
 const OUTPUT_SCHEME = 'output';
 const OUTPUT_MODE_ID = 'Log';
 const LOG_MIME = 'text/x-code-log-output';
-const LOG_SCHEME = 'log';
 const LOG_MODE_ID = 'log';
 const OUTPUT_VIEW_ID = 'workbench.panel.output';
 const CONTEXT_IN_OUTPUT = ( new RawContextKey('inOutput', false));
@@ -51,4 +50,4 @@ class OutputChannelRegistry {
 }
 Registry.add(Extensions.OutputChannels, ( new OutputChannelRegistry()));
 const ACTIVE_OUTPUT_CHANNEL_CONTEXT = ( new RawContextKey('activeOutputChannel', ''));
-export { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, CONTEXT_IN_OUTPUT, CONTEXT_OUTPUT_SCROLL_LOCK, Extensions, IOutputService, LOG_MIME, LOG_MODE_ID, LOG_SCHEME, OUTPUT_MIME, OUTPUT_MODE_ID, OUTPUT_SCHEME, OUTPUT_VIEW_ID, OutputChannelUpdateMode };
+export { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, CONTEXT_IN_OUTPUT, CONTEXT_OUTPUT_SCROLL_LOCK, Extensions, IOutputService, LOG_MIME, LOG_MODE_ID, OUTPUT_MIME, OUTPUT_MODE_ID, OUTPUT_SCHEME, OUTPUT_VIEW_ID, OutputChannelUpdateMode };

package/vscode/src/vs/workbench/services/preferences/common/preferences.d.ts

@@ -4,8 +4,8 @@ import { Event } from '../../../../base/common/event.js';
 import { IJSONSchemaMap, IJSONSchema } from '../../../../base/common/jsonSchema.js';
 import { URI } from '../../../../base/common/uri.js';
 import { IRange } from '../../../../editor/common/core/range.js';
-import { ITextModel } from '../../../../editor/common/model.js';
 import { IExtensionInfo, ConfigurationScope, EditPresentationTypes } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { ITextModel } from '../../../../editor/common/model.js';
 import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
 import { IEditorOptions } from '../../../../platform/editor/common/editor.js';
 import { IEditorPane } from '../../../common/editor.js';
@@ -60,13 +60,13 @@ interface ISetting {
     editPresentation?: EditPresentationTypes;
     nonLanguageSpecificDefaultValueSource?: string | IExtensionInfo;
     isLanguageTagSetting?: boolean;
-    categoryOrder?: number;
     categoryLabel?: string;
     displayExtensionId?: string;
     stableExtensionId?: string;
     prereleaseExtensionId?: string;
     title?: string;
     extensionGroupTitle?: string;
+    internalOrder?: number;
 }
 interface ISearchResult {
     filterMatches: ISettingMatch[];
@@ -90,13 +90,13 @@ interface IFilterResult {
 /**
  * The ways a setting could match a query,
  * sorted in increasing order of relevance.
- * For now, ignore description and value matches.
  */
 declare enum SettingMatchType {
     None = 0,
-    RemoteMatch = 1,
-    WholeWordMatch = 2,
-    KeyMatch = 4
+    LanguageTagSettingMatch = 1,
+    RemoteMatch = 2,
+    DescriptionOrValueMatch = 4,
+    KeyMatch = 8
 }
 interface ISettingMatch {
     setting: ISetting;

package/vscode/src/vs/workbench/services/preferences/common/preferences.js

@@ -23,9 +23,10 @@ var SettingValueType;
 var SettingMatchType;
 ( (function(SettingMatchType) {
     SettingMatchType[SettingMatchType["None"] = 0] = "None";
-    SettingMatchType[SettingMatchType["RemoteMatch"] = 1] = "RemoteMatch";
-    SettingMatchType[SettingMatchType["WholeWordMatch"] = 2] = "WholeWordMatch";
-    SettingMatchType[SettingMatchType["KeyMatch"] = 4] = "KeyMatch";
+    SettingMatchType[SettingMatchType["LanguageTagSettingMatch"] = 1] = "LanguageTagSettingMatch";
+    SettingMatchType[SettingMatchType["RemoteMatch"] = 2] = "RemoteMatch";
+    SettingMatchType[SettingMatchType["DescriptionOrValueMatch"] = 4] = "DescriptionOrValueMatch";
+    SettingMatchType[SettingMatchType["KeyMatch"] = 8] = "KeyMatch";
 })(SettingMatchType || (SettingMatchType = {})));
 function validateSettingsEditorOptions(options) {
     return {

package/vscode/src/vs/workbench/services/preferences/common/preferencesModels.d.ts

@@ -13,7 +13,6 @@ declare abstract class AbstractSettingsModel extends EditorModel {
      * Remove duplicates between result groups, preferring results in earlier groups
      */
     private removeDuplicateResults;
-    private compareTwoNullableNumbers;
     filterSettings(filter: string, groupFilter: IGroupFilter, settingMatcher: ISettingMatcher): ISettingMatch[];
     getPreference(key: string): ISetting | undefined;
     protected collectMetadata(groups: ISearchResultGroup[]): IStringDictionary<IFilterMetadata>;

package/vscode/src/vs/workbench/services/search/common/fileSearchManager.js

@@ -236,7 +236,7 @@ class FileSearchManager {
         }
     }
     doSearch(engine, batchSize, onResultBatch, token) {
-        token.onCancellationRequested(() => {
+        const listener = token.onCancellationRequested(() => {
             engine.cancel();
         });
         const _onResult = (match) => {
@@ -253,11 +253,13 @@ class FileSearchManager {
             if (batch.length) {
                 onResultBatch(batch);
             }
+            listener.dispose();
             return result;
         }, error => {
             if (batch.length) {
                 onResultBatch(batch);
             }
+            listener.dispose();
             return Promise.reject(error);
         });
     }

package/vscode/src/vs/workbench/services/search/common/search.js

@@ -9,6 +9,7 @@ import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js'
 import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
 const VIEWLET_ID = 'workbench.view.search';
 const VIEW_ID = 'workbench.view.search';
+const SEARCH_RESULT_LANGUAGE_ID = 'search-result';
 const SEARCH_EXCLUDE_CONFIG = 'search.exclude';
 const SEARCH_ELIDED_PREFIX = '⟪ ';
 const SEARCH_ELIDED_SUFFIX = ' characters skipped ⟫';
@@ -272,4 +273,4 @@ function listToMap(list) {
     }
     return map;
 }
-export { FileMatch, ISearchService, OneLineRange, QueryGlobTester, SEARCH_EXCLUDE_CONFIG, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, VIEWLET_ID, VIEW_ID, deserializeSearchError, getExcludes, hasSiblingFn, hasSiblingPromiseFn, isFileMatch, isProgressMessage, pathIncludedInQuery, resolvePatternsForProvider, resultIsMatch };
+export { FileMatch, ISearchService, OneLineRange, QueryGlobTester, SEARCH_EXCLUDE_CONFIG, SEARCH_RESULT_LANGUAGE_ID, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, VIEWLET_ID, VIEW_ID, deserializeSearchError, getExcludes, hasSiblingFn, hasSiblingPromiseFn, isFileMatch, isProgressMessage, pathIncludedInQuery, resolvePatternsForProvider, resultIsMatch };

package/vscode/src/vs/workbench/services/search/common/textSearchManager.js

@@ -19,8 +19,7 @@ class TextSearchManager {
     }
     search(onProgress, token) {
         const folderQueries = this.query.folderQueries || [];
-        const tokenSource = ( new CancellationTokenSource());
-        token.onCancellationRequested(() => tokenSource.cancel());
+        const tokenSource = ( new CancellationTokenSource(token));
         return ( new Promise((resolve, reject) => {
             this.collector = ( new TextSearchResultsCollector(onProgress));
             let isCanceled = false;

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModel.js

@@ -17,7 +17,7 @@ import { IWorkingCopyService } from '../../workingCopy/common/workingCopyService
 import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
 import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { UTF8, UTF8_with_bom, UTF16be, UTF16le } from './encoding.js';
 import { createTextBufferFactoryFromStream } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
 import { ILanguageDetectionService } from '../../languageDetection/common/languageDetectionWorkerService.js';
@@ -106,7 +106,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         if (fileEventImpactsModel && this.inOrphanMode !== newInOrphanModeGuess) {
             let newInOrphanModeValidated = false;
             if (newInOrphanModeGuess) {
-                await timeout(100);
+                await timeout(100, CancellationToken.None);
                 if (this.isDisposed()) {
                     newInOrphanModeValidated = true;
                 }

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfileService.js

@@ -1,14 +1,12 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
 import { defaultUserDataProfileIcon } from './userDataProfile.js';
-let UserDataProfileService = class UserDataProfileService extends Disposable {
+class UserDataProfileService extends Disposable {
     get currentProfile() { return this._currentProfile; }
-    constructor(currentProfile, userDataProfilesService) {
+    constructor(currentProfile) {
         super();
         this._onDidChangeCurrentProfile = this._register(( new Emitter()));
         this.onDidChangeCurrentProfile = this._onDidChangeCurrentProfile.event;
@@ -36,8 +34,5 @@ let UserDataProfileService = class UserDataProfileService extends Disposable {
         }
         return `$(${defaultUserDataProfileIcon.id})`;
     }
-};
-UserDataProfileService = ( __decorate([
-    ( __param(1, IUserDataProfilesService))
-], UserDataProfileService));
+}
 export { UserDataProfileService };

package/vscode/src/vs/workbench/services/workingCopy/common/resourceWorkingCopy.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
@@ -13,7 +14,6 @@ let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
         this.orphaned = false;
         this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
-        this.disposed = false;
         this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
     }
     isOrphaned() {
@@ -39,7 +39,7 @@ let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
         if (fileEventImpactsUs && this.orphaned !== newInOrphanModeGuess) {
             let newInOrphanModeValidated = false;
             if (newInOrphanModeGuess) {
-                await timeout(100);
+                await timeout(100, CancellationToken.None);
                 if (this.isDisposed()) {
                     newInOrphanModeValidated = true;
                 }
@@ -60,10 +60,9 @@ let ResourceWorkingCopy = class ResourceWorkingCopy extends Disposable {
         }
     }
     isDisposed() {
-        return this.disposed;
+        return this._store.isDisposed;
     }
     dispose() {
-        this.disposed = true;
         this.orphaned = false;
         this._onWillDispose.fire();
         super.dispose();

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant.js

@@ -40,6 +40,7 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
                 }
             }
             workingCopy.model?.pushStackElement();
+            cts.dispose();
         }, () => {
             cts.dispose(true);
         });

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.js

@@ -315,8 +315,9 @@ WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( (__decorate([
     ( (__param(1, IFileService))),
     ( (__param(2, ILogService)))
 ], WorkingCopyBackupServiceImpl)));
-class InMemoryWorkingCopyBackupService {
+class InMemoryWorkingCopyBackupService extends Disposable {
     constructor() {
+        super();
         this.backups = ( (new ResourceMap()));
     }
     async hasBackups() {

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.js

@@ -1,7 +1,7 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableMap, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 const IWorkingCopyService = ( createDecorator('workingCopyService'));
 class WorkingCopyService extends Disposable {
@@ -19,6 +19,7 @@ class WorkingCopyService extends Disposable {
         this.onDidSave = this._onDidSave.event;
         this._workingCopies = ( new Set());
         this.mapResourceToWorkingCopies = ( new ResourceMap());
+        this.mapWorkingCopyToListeners = this._register(( new DisposableMap()));
     }
     get workingCopies() { return Array.from(( this._workingCopies.values())); }
     registerWorkingCopy(workingCopy) {
@@ -36,13 +37,13 @@ class WorkingCopyService extends Disposable {
         disposables.add(workingCopy.onDidChangeContent(() => this._onDidChangeContent.fire(workingCopy)));
         disposables.add(workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(workingCopy)));
         disposables.add(workingCopy.onDidSave(e => this._onDidSave.fire({ workingCopy, ...e })));
+        this.mapWorkingCopyToListeners.set(workingCopy, disposables);
         this._onDidRegister.fire(workingCopy);
         if (workingCopy.isDirty()) {
             this._onDidChangeDirty.fire(workingCopy);
         }
         return toDisposable(() => {
             this.unregisterWorkingCopy(workingCopy);
-            dispose(disposables);
             this._onDidUnregister.fire(workingCopy);
         });
     }
@@ -55,6 +56,7 @@ class WorkingCopyService extends Disposable {
         if (workingCopy.isDirty()) {
             this._onDidChangeDirty.fire(workingCopy);
         }
+        this.mapWorkingCopyToListeners.deleteAndDispose(workingCopy);
     }
     has(resourceOrIdentifier) {
         if (URI.isUri(resourceOrIdentifier)) {

package/vscode/src/vs/editor/browser/widget/diffEditorWidget2/diffEditorWidget2.contribution.js

@@ -1,180 +0,0 @@
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { findFocusedDiffEditor } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditor.contribution.js';
-import { DiffEditorWidget2 } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget2/diffEditorWidget2.js';
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ContextKeyExpr, ContextKeyEqualsExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-class ToggleCollapseUnchangedRegions extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleCollapseUnchangedRegions',
-            title: { value: ( localize('toggleCollapseUnchangedRegions', "Toggle Collapse Unchanged Regions")), original: 'Toggle Collapse Unchanged Regions' },
-            icon: Codicon.map,
-            precondition: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
-            toggled: ( ContextKeyExpr.has('config.diffEditor.hideUnchangedRegions.enabled')),
-            menu: {
-                id: MenuId.EditorTitle,
-                order: 22,
-                group: 'navigation',
-                when: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
-            },
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.hideUnchangedRegions.enabled');
-        configurationService.updateValue('diffEditor.hideUnchangedRegions.enabled', newValue);
-    }
-}
-registerAction2(ToggleCollapseUnchangedRegions);
-class ToggleShowMovedCodeBlocks extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleShowMovedCodeBlocks',
-            title: { value: ( localize('toggleShowMovedCodeBlocks', "Toggle Show Moved Code Blocks")), original: 'Toggle Show Moved Code Blocks' },
-            precondition: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.experimental.showMoves');
-        configurationService.updateValue('diffEditor.experimental.showMoves', newValue);
-    }
-}
-registerAction2(ToggleShowMovedCodeBlocks);
-class ToggleUseInlineViewWhenSpaceIsLimited extends Action2 {
-    constructor() {
-        super({
-            id: 'diffEditor.toggleUseInlineViewWhenSpaceIsLimited',
-            title: { value: ( localize(
-                'toggleUseInlineViewWhenSpaceIsLimited',
-                "Toggle Use Inline View When Space Is Limited"
-            )), original: 'Toggle Use Inline View When Space Is Limited' },
-            precondition: ContextKeyEqualsExpr.create('diffEditorVersion', 2),
-        });
-    }
-    run(accessor, ...args) {
-        const configurationService = accessor.get(IConfigurationService);
-        const newValue = !configurationService.getValue('diffEditor.useInlineViewWhenSpaceIsLimited');
-        configurationService.updateValue('diffEditor.useInlineViewWhenSpaceIsLimited', newValue);
-    }
-}
-registerAction2(ToggleUseInlineViewWhenSpaceIsLimited);
-MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
-    command: {
-        id: ( new ToggleUseInlineViewWhenSpaceIsLimited()).desc.id,
-        title: ( localize('useInlineViewWhenSpaceIsLimited', "Use Inline View When Space Is Limited")),
-        toggled: ( ContextKeyExpr.has('config.diffEditor.useInlineViewWhenSpaceIsLimited')),
-    },
-    order: 11,
-    group: '1_diff',
-    when: ( ContextKeyExpr.and(
-        EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached,
-        ContextKeyEqualsExpr.create('diffEditorVersion', 2)
-    ))
-});
-MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
-    command: {
-        id: ( new ToggleShowMovedCodeBlocks()).desc.id,
-        title: ( localize('showMoves', "Show Moved Code Blocks")),
-        icon: Codicon.move,
-        toggled: ContextKeyEqualsExpr.create('config.diffEditor.experimental.showMoves', true),
-    },
-    order: 10,
-    group: '1_diff',
-    when: ContextKeyEqualsExpr.create('diffEditorVersion', 2)
-});
-const diffEditorCategory = {
-    value: ( localize('diffEditor', 'Diff Editor')),
-    original: 'Diff Editor',
-};
-class SwitchSide extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.switchSide',
-            title: { value: ( localize('switchSide', "Switch Side")), original: 'Switch Side' },
-            icon: Codicon.arrowSwap,
-            precondition: ( ContextKeyExpr.and(ContextKeyEqualsExpr.create('diffEditorVersion', 2), ( ContextKeyExpr.has('isInDiffEditor')))),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, arg) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget2) {
-            if (arg && arg.dryRun) {
-                return { destinationSelection: diffEditor.mapToOtherSide().destinationSelection };
-            }
-            else {
-                diffEditor.switchSide();
-            }
-        }
-        return undefined;
-    }
-}
-registerAction2(SwitchSide);
-class ExitCompareMove extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.exitCompareMove',
-            title: { value: ( localize('exitCompareMove', "Exit Compare Move")), original: 'Exit Compare Move' },
-            icon: Codicon.close,
-            precondition: EditorContextKeys.comparingMovedCode,
-            f1: false,
-            category: diffEditorCategory,
-            keybinding: {
-                weight: 10000,
-                primary: 9 ,
-            }
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget2) {
-            diffEditor.exitCompareMove();
-        }
-    }
-}
-registerAction2(ExitCompareMove);
-class CollapseAllUnchangedRegions extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.collapseAllUnchangedRegions',
-            title: { value: ( localize('collapseAllUnchangedRegions', "Collapse All Unchanged Regions")), original: 'Collapse All Unchanged Regions' },
-            icon: Codicon.fold,
-            precondition: ( ContextKeyExpr.and(ContextKeyEqualsExpr.create('diffEditorVersion', 2), ( ContextKeyExpr.has('isInDiffEditor')))),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget2) {
-            diffEditor.collapseAllUnchangedRegions();
-        }
-    }
-}
-registerAction2(CollapseAllUnchangedRegions);
-class ShowAllUnchangedRegions extends EditorAction2 {
-    constructor() {
-        super({
-            id: 'diffEditor.showAllUnchangedRegions',
-            title: { value: ( localize('showAllUnchangedRegions', "Show All Unchanged Regions")), original: 'Show All Unchanged Regions' },
-            icon: Codicon.unfold,
-            precondition: ( ContextKeyExpr.and(ContextKeyEqualsExpr.create('diffEditorVersion', 2), ( ContextKeyExpr.has('isInDiffEditor')))),
-            f1: true,
-            category: diffEditorCategory,
-        });
-    }
-    runEditorCommand(accessor, editor, ...args) {
-        const diffEditor = findFocusedDiffEditor(accessor);
-        if (diffEditor instanceof DiffEditorWidget2) {
-            diffEditor.showAllUnchangedRegions();
-        }
-    }
-}
-registerAction2(ShowAllUnchangedRegions);
-export { CollapseAllUnchangedRegions, ExitCompareMove, ShowAllUnchangedRegions, SwitchSide, ToggleCollapseUnchangedRegions, ToggleShowMovedCodeBlocks, ToggleUseInlineViewWhenSpaceIsLimited };