@codingame/monaco-vscode-api 2.0.3-improve-modularity.1 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/platform/actions/common/actions.js

@@ -22,6 +22,7 @@ class MenuId {
     static { this.DebugCallStackContext = ( new MenuId('DebugCallStackContext')); }
     static { this.DebugConsoleContext = ( new MenuId('DebugConsoleContext')); }
     static { this.DebugVariablesContext = ( new MenuId('DebugVariablesContext')); }
+    static { this.DebugHoverContext = ( new MenuId('DebugHoverContext')); }
     static { this.DebugWatchContext = ( new MenuId('DebugWatchContext')); }
     static { this.DebugToolBar = ( new MenuId('DebugToolBar')); }
     static { this.DebugToolBarStop = ( new MenuId('DebugToolBarStop')); }
@@ -40,6 +41,7 @@ class MenuId {
     static { this.EmptyEditorGroupContext = ( new MenuId('EmptyEditorGroupContext')); }
     static { this.EditorTabsBarContext = ( new MenuId('EditorTabsBarContext')); }
     static { this.EditorTabsBarShowTabsSubmenu = ( new MenuId('EditorTabsBarShowTabsSubmenu')); }
+    static { this.EditorTabsBarShowTabsZenModeSubmenu = ( new MenuId('EditorTabsBarShowTabsZenModeSubmenu')); }
     static { this.EditorActionsPositionSubmenu = ( new MenuId('EditorActionsPositionSubmenu')); }
     static { this.ExplorerContext = ( new MenuId('ExplorerContext')); }
     static { this.ExplorerContextShare = ( new MenuId('ExplorerContextShare')); }
@@ -75,13 +77,19 @@ class MenuId {
     static { this.OpenEditorsContextShare = ( new MenuId('OpenEditorsContextShare')); }
     static { this.ProblemsPanelContext = ( new MenuId('ProblemsPanelContext')); }
     static { this.SCMInputBox = ( new MenuId('SCMInputBox')); }
-    static { this.SCMHistoryItem = ( new MenuId('SCMHistoryItem')); }
+    static { this.SCMIncomingChanges = ( new MenuId('SCMIncomingChanges')); }
+    static { this.SCMOutgoingChanges = ( new MenuId('SCMOutgoingChanges')); }
+    static { this.SCMIncomingChangesAllChangesContext = ( new MenuId('SCMIncomingChangesAllChangesContext')); }
+    static { this.SCMIncomingChangesHistoryItemContext = ( new MenuId('SCMIncomingChangesHistoryItemContext')); }
+    static { this.SCMOutgoingChangesAllChangesContext = ( new MenuId('SCMOutgoingChangesAllChangesContext')); }
+    static { this.SCMOutgoingChangesHistoryItemContext = ( new MenuId('SCMOutgoingChangesHistoryItemContext')); }
     static { this.SCMChangeContext = ( new MenuId('SCMChangeContext')); }
     static { this.SCMResourceContext = ( new MenuId('SCMResourceContext')); }
     static { this.SCMResourceContextShare = ( new MenuId('SCMResourceContextShare')); }
     static { this.SCMResourceFolderContext = ( new MenuId('SCMResourceFolderContext')); }
     static { this.SCMResourceGroupContext = ( new MenuId('SCMResourceGroupContext')); }
     static { this.SCMSourceControl = ( new MenuId('SCMSourceControl')); }
+    static { this.SCMSourceControlInline = ( new MenuId('SCMSourceControlInline')); }
     static { this.SCMTitle = ( new MenuId('SCMTitle')); }
     static { this.SearchContext = ( new MenuId('SearchContext')); }
     static { this.SearchActionMenu = ( new MenuId('SearchActionContext')); }
@@ -347,6 +355,9 @@ function registerAction2(ctor) {
     const disposables = ( new DisposableStore());
     const action = ( new ctor());
     const { f1, menu, keybinding, ...command } = action.desc;
+    if (CommandsRegistry.getCommand(command.id)) {
+        throw new Error(`Cannot register two commands with the same id: ${command.id}`);
+    }
     disposables.add(CommandsRegistry.registerCommand({
         id: command.id,
         handler: (accessor, ...args) => action.run(accessor, ...args),

package/vscode/src/vs/platform/audioCues/browser/audioCueService.d.ts

@@ -10,14 +10,22 @@ interface IAudioCueService {
         cue: AudioCue;
         source: string;
     })[]): Promise<void>;
-    isEnabled(cue: AudioCue): boolean;
+    isCueEnabled(cue: AudioCue): boolean;
+    isAlertEnabled(cue: AudioCue): boolean;
     onEnabledChanged(cue: AudioCue): Event<void>;
+    onAlertEnabledChanged(cue: AudioCue): Event<void>;
     playSound(cue: Sound, allowManyInParallel?: boolean): Promise<void>;
     playAudioCueLoop(cue: AudioCue, milliseconds: number): IDisposable;
 }
 interface IAudioCueOptions {
     allowManyInParallel?: boolean;
     source?: string;
+    /**
+     * For actions like save or format, depending on the
+     * configured value, we will only
+     * play the sound if the user triggered the action.
+     */
+    userGesture?: boolean;
 }
 /**
  * Corresponds to the audio files in ./media.
@@ -56,6 +64,8 @@ declare class AudioCue {
     readonly sound: SoundSource;
     readonly name: string;
     readonly settingsKey: string;
+    readonly alertSettingsKey?: string | undefined;
+    readonly alertMessage?: string | undefined;
     private static _audioCues;
     private static register;
     static get allAudioCues(): AudioCue[];

package/vscode/src/vs/platform/audioCues/browser/audioCueService.js

@@ -21,14 +21,17 @@ let AudioCueService = class AudioCueService extends Disposable {
         this.sentTelemetry = ( new Set());
         this.playingSounds = ( new Set());
         this.obsoleteAudioCuesEnabled = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration('audioCues.enabled')), () =>  this.configurationService.getValue('audioCues.enabled'));
-        this.isEnabledCache = ( new Cache((cue) => {
-            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(cue.settingsKey)), () => this.configurationService.getValue(cue.settingsKey));
+        this.isCueEnabledCache = ( new Cache((event) => {
+            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.cue.settingsKey)), () => this.configurationService.getValue(event.cue.settingsKey));
             return derived(reader => {
                 const setting = settingObservable.read(reader);
                 if (setting === 'on' ||
                     (setting === 'auto' && this.screenReaderAttached.read(reader))) {
                     return true;
                 }
+                else if (setting === 'always' || setting === 'userGesture' && event.userGesture) {
+                    return true;
+                }
                 const obsoleteSetting = this.obsoleteAudioCuesEnabled.read(reader);
                 if (obsoleteSetting === 'on' ||
                     (obsoleteSetting === 'auto' && this.screenReaderAttached.read(reader))) {
@@ -36,10 +39,24 @@ let AudioCueService = class AudioCueService extends Disposable {
                 }
                 return false;
             });
-        }));
+        }, JSON.stringify));
+        this.isAlertEnabledCache = ( new Cache((event) => {
+            const settingObservable = observableFromEvent(Event.filter(this.configurationService.onDidChangeConfiguration, (e) => e.affectsConfiguration(event.cue.settingsKey)), () => event.cue.alertSettingsKey ? this.configurationService.getValue(event.cue.alertSettingsKey) : false);
+            return derived(reader => {
+                const setting = settingObservable.read(reader);
+                if (!this.screenReaderAttached.read(reader)) {
+                    return false;
+                }
+                return setting === true || setting === 'always' || setting === 'userGesture' && event.userGesture;
+            });
+        }, JSON.stringify));
     }
     async playAudioCue(cue, options = {}) {
-        if (this.isEnabled(cue)) {
+        const alertMessage = cue.alertMessage;
+        if (this.isAlertEnabled(cue, options.userGesture) && alertMessage) {
+            this.accessibilityService.status(alertMessage);
+        }
+        if (this.isCueEnabled(cue, options.userGesture)) {
             this.sendAudioCueTelemetry(cue, options.source);
             await this.playSound(cue.sound.getSound(), options.allowManyInParallel);
         }
@@ -48,7 +65,12 @@ let AudioCueService = class AudioCueService extends Disposable {
         for (const cue of cues) {
             this.sendAudioCueTelemetry('cue' in cue ? cue.cue : cue, 'source' in cue ? cue.source : undefined);
         }
-        const sounds = ( new Set(( ( cues.map(c => 'cue' in c ? c.cue : c)).filter(cue => this.isEnabled(cue)).map(cue => cue.sound.getSound()))));
+        const cueArray = ( cues.map(c => 'cue' in c ? c.cue : c));
+        const alerts = ( cueArray.filter(cue => this.isAlertEnabled(cue)).map(c => c.alertMessage));
+        if (alerts.length) {
+            this.accessibilityService.status(alerts.join(', '));
+        }
+        const sounds = ( new Set(( cueArray.filter(cue => this.isCueEnabled(cue)).map(cue => cue.sound.getSound()))));
         await Promise.all(( Array.from(sounds).map(sound => this.playSound(sound, true))));
     }
     sendAudioCueTelemetry(cue, source) {
@@ -114,11 +136,17 @@ let AudioCueService = class AudioCueService extends Disposable {
         playSound();
         return toDisposable(() => playing = false);
     }
-    isEnabled(cue) {
-        return this.isEnabledCache.get(cue).get();
+    isAlertEnabled(cue, userGesture) {
+        return this.isAlertEnabledCache.get({ cue, userGesture }).get() ?? false;
+    }
+    isCueEnabled(cue, userGesture) {
+        return this.isCueEnabledCache.get({ cue, userGesture }).get() ?? false;
     }
     onEnabledChanged(cue) {
-        return Event.fromObservableLight(this.isEnabledCache.get(cue));
+        return Event.fromObservableLight(this.isCueEnabledCache.get({ cue }));
+    }
+    onAlertEnabledChanged(cue) {
+        return Event.fromObservableLight(this.isAlertEnabledCache.get({ cue }));
     }
 };
 AudioCueService = ( __decorate([
@@ -142,8 +170,9 @@ function playAudio(url, volume) {
     }));
 }
 class Cache {
-    constructor(getValue) {
+    constructor(getValue, getKey) {
         this.getValue = getValue;
+        this.getKey = getKey;
         this.map = ( new Map());
     }
     get(arg) {
@@ -151,7 +180,8 @@ class Cache {
             return this.map.get(arg);
         }
         const value = this.getValue(arg);
-        this.map.set(arg, value);
+        const key = this.getKey(arg);
+        this.map.set(key, value);
         return value;
     }
 }
@@ -204,7 +234,13 @@ class AudioCue {
         const soundSource = ( new SoundSource(
             'randomOneOf' in options.sound ? options.sound.randomOneOf : [options.sound]
         ));
-        const audioCue = ( new AudioCue(soundSource, options.name, options.settingsKey));
+        const audioCue = ( new AudioCue(
+            soundSource,
+            options.name,
+            options.settingsKey,
+            options.alertSettingsKey,
+            options.alertMessage
+        ));
         AudioCue._audioCues.add(audioCue);
         return audioCue;
     }
@@ -219,6 +255,12 @@ class AudioCue {
         )),
         sound: Sound.error,
         settingsKey: 'audioCues.lineHasError',
+        alertSettingsKey: "accessibility.alert.error" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasError.alertMessage',
+            'Error'
+        ))
     }); }
     static { this.warning = AudioCue.register({
         name: ( localizeWithPath(
@@ -228,6 +270,12 @@ class AudioCue {
         )),
         sound: Sound.warning,
         settingsKey: 'audioCues.lineHasWarning',
+        alertSettingsKey: "accessibility.alert.warning" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasWarning.alertMessage',
+            'Warning'
+        ))
     }); }
     static { this.foldedArea = AudioCue.register({
         name: ( localizeWithPath(
@@ -237,6 +285,12 @@ class AudioCue {
         )),
         sound: Sound.foldedArea,
         settingsKey: 'audioCues.lineHasFoldedArea',
+        alertSettingsKey: "accessibility.alert.foldedArea" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasFoldedArea.alertMessage',
+            'Folded'
+        ))
     }); }
     static { this.break = AudioCue.register({
         name: ( localizeWithPath(
@@ -246,6 +300,12 @@ class AudioCue {
         )),
         sound: Sound.break,
         settingsKey: 'audioCues.lineHasBreakpoint',
+        alertSettingsKey: "accessibility.alert.breakpoint" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.lineHasBreakpoint.alertMessage',
+            'Breakpoint'
+        ))
     }); }
     static { this.inlineSuggestion = AudioCue.register({
         name: ( localizeWithPath(
@@ -264,6 +324,12 @@ class AudioCue {
         )),
         sound: Sound.quickFixes,
         settingsKey: 'audioCues.terminalQuickFix',
+        alertSettingsKey: "accessibility.alert.terminalQuickFix" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.terminalQuickFix.alertMessage',
+            'Quick Fix'
+        ))
     }); }
     static { this.onDebugBreak = AudioCue.register({
         name: ( localizeWithPath(
@@ -273,6 +339,12 @@ class AudioCue {
         )),
         sound: Sound.break,
         settingsKey: 'audioCues.onDebugBreak',
+        alertSettingsKey: "accessibility.alert.onDebugBreak" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.onDebugBreak.alertMessage',
+            'Breakpoint'
+        ))
     }); }
     static { this.noInlayHints = AudioCue.register({
         name: ( localizeWithPath(
@@ -281,7 +353,13 @@ class AudioCue {
             'No Inlay Hints on Line'
         )),
         sound: Sound.error,
-        settingsKey: 'audioCues.noInlayHints'
+        settingsKey: 'audioCues.noInlayHints',
+        alertSettingsKey: "accessibility.alert.noInlayHints" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.noInlayHints.alertMessage',
+            'No Inlay Hints'
+        ))
     }); }
     static { this.taskCompleted = AudioCue.register({
         name: ( localizeWithPath(
@@ -290,7 +368,13 @@ class AudioCue {
             'Task Completed'
         )),
         sound: Sound.taskCompleted,
-        settingsKey: 'audioCues.taskCompleted'
+        settingsKey: 'audioCues.taskCompleted',
+        alertSettingsKey: "accessibility.alert.taskCompleted" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.taskCompleted.alertMessage',
+            'Task Completed'
+        ))
     }); }
     static { this.taskFailed = AudioCue.register({
         name: ( localizeWithPath(
@@ -299,7 +383,13 @@ class AudioCue {
             'Task Failed'
         )),
         sound: Sound.taskFailed,
-        settingsKey: 'audioCues.taskFailed'
+        settingsKey: 'audioCues.taskFailed',
+        alertSettingsKey: "accessibility.alert.taskFailed" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.taskFailed.alertMessage',
+            'Task Failed'
+        ))
     }); }
     static { this.terminalCommandFailed = AudioCue.register({
         name: ( localizeWithPath(
@@ -308,7 +398,13 @@ class AudioCue {
             'Terminal Command Failed'
         )),
         sound: Sound.error,
-        settingsKey: 'audioCues.terminalCommandFailed'
+        settingsKey: 'audioCues.terminalCommandFailed',
+        alertSettingsKey: "accessibility.alert.terminalCommandFailed" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.terminalCommandFailed.alertMessage',
+            'Command Failed'
+        ))
     }); }
     static { this.terminalBell = AudioCue.register({
         name: ( localizeWithPath(
@@ -317,7 +413,13 @@ class AudioCue {
             'Terminal Bell'
         )),
         sound: Sound.terminalBell,
-        settingsKey: 'audioCues.terminalBell'
+        settingsKey: 'audioCues.terminalBell',
+        alertSettingsKey: "accessibility.alert.terminalBell" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.terminalBell.alertMessage',
+            'Terminal Bell'
+        ))
     }); }
     static { this.notebookCellCompleted = AudioCue.register({
         name: ( localizeWithPath(
@@ -326,7 +428,13 @@ class AudioCue {
             'Notebook Cell Completed'
         )),
         sound: Sound.taskCompleted,
-        settingsKey: 'audioCues.notebookCellCompleted'
+        settingsKey: 'audioCues.notebookCellCompleted',
+        alertSettingsKey: "accessibility.alert.notebookCellCompleted" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.notebookCellCompleted.alertMessage',
+            'Notebook Cell Completed'
+        ))
     }); }
     static { this.notebookCellFailed = AudioCue.register({
         name: ( localizeWithPath(
@@ -335,7 +443,13 @@ class AudioCue {
             'Notebook Cell Failed'
         )),
         sound: Sound.taskFailed,
-        settingsKey: 'audioCues.notebookCellFailed'
+        settingsKey: 'audioCues.notebookCellFailed',
+        alertSettingsKey: "accessibility.alert.notebookCellFailed" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.notebookCellFailed.alertMessage',
+            'Notebook Cell Failed'
+        ))
     }); }
     static { this.diffLineInserted = AudioCue.register({
         name: ( localizeWithPath(
@@ -344,7 +458,7 @@ class AudioCue {
             'Diff Line Inserted'
         )),
         sound: Sound.diffLineInserted,
-        settingsKey: 'audioCues.diffLineInserted'
+        settingsKey: 'audioCues.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AudioCue.register({
         name: ( localizeWithPath(
@@ -353,7 +467,7 @@ class AudioCue {
             'Diff Line Deleted'
         )),
         sound: Sound.diffLineDeleted,
-        settingsKey: 'audioCues.diffLineDeleted'
+        settingsKey: 'audioCues.diffLineDeleted',
     }); }
     static { this.diffLineModified = AudioCue.register({
         name: ( localizeWithPath(
@@ -362,7 +476,7 @@ class AudioCue {
             'Diff Line Modified'
         )),
         sound: Sound.diffLineModified,
-        settingsKey: 'audioCues.diffLineModified'
+        settingsKey: 'audioCues.diffLineModified',
     }); }
     static { this.chatRequestSent = AudioCue.register({
         name: ( localizeWithPath(
@@ -371,7 +485,13 @@ class AudioCue {
             'Chat Request Sent'
         )),
         sound: Sound.chatRequestSent,
-        settingsKey: 'audioCues.chatRequestSent'
+        settingsKey: 'audioCues.chatRequestSent',
+        alertSettingsKey: "accessibility.alert.chatRequestSent" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.chatRequestSent.alertMessage',
+            'Chat Request Sent'
+        ))
     }); }
     static { this.chatResponseReceived = AudioCue.register({
         name: ( localizeWithPath(
@@ -387,7 +507,7 @@ class AudioCue {
                 Sound.chatResponseReceived3,
                 Sound.chatResponseReceived4
             ]
-        }
+        },
     }); }
     static { this.chatResponsePending = AudioCue.register({
         name: ( localizeWithPath(
@@ -396,7 +516,13 @@ class AudioCue {
             'Chat Response Pending'
         )),
         sound: Sound.chatResponsePending,
-        settingsKey: 'audioCues.chatResponsePending'
+        settingsKey: 'audioCues.chatResponsePending',
+        alertSettingsKey: "accessibility.alert.chatResponsePending" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.chatResponsePending.alertMessage',
+            'Chat Response Pending'
+        ))
     }); }
     static { this.clear = AudioCue.register({
         name: ( localizeWithPath(
@@ -405,12 +531,24 @@ class AudioCue {
             'Clear'
         )),
         sound: Sound.clear,
-        settingsKey: 'audioCues.clear'
+        settingsKey: 'audioCues.clear',
+        alertSettingsKey: "accessibility.alert.clear" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.clear.alertMessage',
+            'Clear'
+        ))
     }); }
     static { this.save = AudioCue.register({
         name: ( localizeWithPath('vs/platform/audioCues/browser/audioCueService', 'audioCues.save', 'Save')),
         sound: Sound.save,
-        settingsKey: 'audioCues.save'
+        settingsKey: 'audioCues.save',
+        alertSettingsKey: "accessibility.alert.save" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.save.alertMessage',
+            'Save'
+        ))
     }); }
     static { this.format = AudioCue.register({
         name: ( localizeWithPath(
@@ -419,12 +557,20 @@ class AudioCue {
             'Format'
         )),
         sound: Sound.format,
-        settingsKey: 'audioCues.format'
+        settingsKey: 'audioCues.format',
+        alertSettingsKey: "accessibility.alert.format" ,
+        alertMessage: ( localizeWithPath(
+            'vs/platform/audioCues/browser/audioCueService',
+            'audioCues.format.alertMessage',
+            'Format'
+        ))
     }); }
-    constructor(sound, name, settingsKey) {
+    constructor(sound, name, settingsKey, alertSettingsKey, alertMessage) {
         this.sound = sound;
         this.name = name;
         this.settingsKey = settingsKey;
+        this.alertSettingsKey = alertSettingsKey;
+        this.alertMessage = alertMessage;
     }
 }
 export { AudioCue, AudioCueService, IAudioCueService, Sound, SoundSource };

package/vscode/src/vs/platform/clipboard/browser/clipboardService.js

@@ -1,12 +1,16 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
-import { addDisposableListener, getActiveDocument, $ } from '../../../base/browser/dom.js';
+import { onDidRegisterWindow, addDisposableListener, getActiveDocument, $ } from '../../../base/browser/dom.js';
+import { mainWindow } from '../../../base/browser/window.js';
 import { DeferredPromise } from '../../../base/common/async.js';
 import { Event } from '../../../base/common/event.js';
+import { hash } from '../../../base/common/hash.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { ILayoutService } from '../../layout/browser/layoutService.js';
 import { ILogService } from '../../log/common/log.js';
+var BrowserClipboardService_1;
 let BrowserClipboardService = class BrowserClipboardService extends Disposable {
+    static { BrowserClipboardService_1 = this; }
     constructor(layoutService, logService) {
         super();
         this.layoutService = layoutService;
@@ -14,9 +18,13 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
         this.mapTextToType = ( new Map());
         this.findText = '';
         this.resources = [];
+        this.resourcesStateHash = undefined;
         if (isSafari || isWebkitWebView) {
             this.installWebKitWriteTextWorkaround();
         }
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
+            disposables.add(addDisposableListener(window.document, 'copy', () => this.clearResources()));
+        }, { window: mainWindow, disposables: this._store }));
     }
     installWebKitWriteTextWorkaround() {
         const handler = () => {
@@ -39,6 +47,7 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
         }, { container: this.layoutService.mainContainer, disposables: this._store }));
     }
     async writeText(text, type) {
+        this.writeResources([]);
         if (type) {
             this.mapTextToType.set(type, text);
             return;
@@ -52,6 +61,9 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
         catch (error) {
             console.error(error);
         }
+        this.fallbackWriteText(text);
+    }
+    fallbackWriteText(text) {
         const activeDocument = getActiveDocument();
         const activeElement = activeDocument.activeElement;
         const textArea = activeDocument.body.appendChild($('textarea', { 'aria-hidden': true }));
@@ -66,7 +78,6 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
             activeElement.focus();
         }
         activeDocument.body.removeChild(textArea);
-        return;
     }
     async readText(type) {
         if (type) {
@@ -77,8 +88,8 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
         }
         catch (error) {
             console.error(error);
-            return '';
         }
+        return '';
     }
     async readFindText() {
         return this.findText;
@@ -86,17 +97,39 @@ let BrowserClipboardService = class BrowserClipboardService extends Disposable {
     async writeFindText(text) {
         this.findText = text;
     }
+    static { this.MAX_RESOURCE_STATE_SOURCE_LENGTH = 1000; }
     async writeResources(resources) {
-        this.resources = resources;
+        if (resources.length === 0) {
+            this.clearResources();
+        }
+        else {
+            this.resources = resources;
+            this.resourcesStateHash = await this.computeResourcesStateHash();
+        }
     }
     async readResources() {
+        const resourcesStateHash = await this.computeResourcesStateHash();
+        if (this.resourcesStateHash !== resourcesStateHash) {
+            this.clearResources();
+        }
         return this.resources;
     }
+    async computeResourcesStateHash() {
+        if (this.resources.length === 0) {
+            return undefined;
+        }
+        const clipboardText = await this.readText();
+        return hash(clipboardText.substring(0, BrowserClipboardService_1.MAX_RESOURCE_STATE_SOURCE_LENGTH));
+    }
     async hasResources() {
         return this.resources.length > 0;
     }
+    clearResources() {
+        this.resources = [];
+        this.resourcesStateHash = undefined;
+    }
 };
-BrowserClipboardService = ( __decorate([
+BrowserClipboardService = BrowserClipboardService_1 = ( __decorate([
     ( __param(0, ILayoutService)),
     ( __param(1, ILogService))
 ], BrowserClipboardService));

package/vscode/src/vs/platform/configuration/common/configuration.d.ts

@@ -29,7 +29,6 @@ interface IConfigurationChangeEvent {
     readonly affectedKeys: ReadonlySet<string>;
     readonly change: IConfigurationChange;
     affectsConfiguration(configuration: string, overrides?: IConfigurationOverrides): boolean;
-    readonly sourceConfig: any;
 }
 interface IConfigurationValue<T> {
     readonly defaultValue?: T;

package/vscode/src/vs/platform/environment/common/environmentService.js

@@ -1,2 +1,2 @@
-const EXTENSION_IDENTIFIER_WITH_LOG_REGEX = /^([^.]+\..+):(.+)$/;
+const EXTENSION_IDENTIFIER_WITH_LOG_REGEX = /^([^.]+\..+)[:=](.+)$/;
 export { EXTENSION_IDENTIFIER_WITH_LOG_REGEX };

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.d.ts

@@ -65,6 +65,7 @@ interface IGalleryExtension {
     properties: IGalleryExtensionProperties;
     telemetryData?: any;
     queryContext?: IStringDictionary<any>;
+    supportLink?: string;
 }
 interface IGalleryMetadata {
     id: string;
@@ -80,6 +81,7 @@ type Metadata = Partial<IGalleryMetadata & {
     isSystem: boolean;
     updated: boolean;
     preRelease: boolean;
+    hasPreReleaseVersion: boolean;
     installedTimestamp: number;
     pinned: boolean;
 }>;
@@ -90,6 +92,7 @@ interface ILocalExtension extends IExtension {
     publisherDisplayName: string | null;
     installedTimestamp?: number;
     isPreReleaseVersion: boolean;
+    hasPreReleaseVersion: boolean;
     preRelease: boolean;
     updated: boolean;
     pinned: boolean;
@@ -156,14 +159,15 @@ type InstallOptions = {
     pinned?: boolean;
     donotIncludePackAndDependencies?: boolean;
     installGivenVersion?: boolean;
+    preRelease?: boolean;
     installPreReleaseVersion?: boolean;
     donotVerifySignature?: boolean;
     operation?: InstallOperation;
+    profileLocation?: URI;
     /**
      * Context passed through to InstallExtensionResult
      */
     context?: IStringDictionary<any>;
-    profileLocation?: URI;
 };
 type InstallVSIXOptions = InstallOptions & {
     installOnlyNewlyAddedFromExtensionPack?: boolean;