@codingame/monaco-vscode-api 1.81.8-next.2 → 1.82.0-next.0

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorModel.js

@@ -9,7 +9,7 @@ import { createTextBufferFactoryFromStream } from 'monaco-editor/esm/vs/editor/c
 import { IWorkingCopyService } from '../../workingCopy/common/workingCopyService.js';
 import { NO_TYPE_ID } from '../../workingCopy/common/workingCopy.js';
 import { ITextFileService } from '../../textfile/common/textfiles.js';
-import { withNullAsUndefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 import { ensureValidWordDefinition } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
 import { IEditorService } from '../../editor/common/editorService.js';
@@ -18,9 +18,11 @@ import { UTF8 } from '../../textfile/common/encoding.js';
 import { bufferToReadable, VSBuffer, bufferToStream } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { ILanguageDetectionService } from '../../languageDetection/common/languageDetectionWorkerService.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+var UntitledTextEditorModel_1;
 let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEditorModel {
+    static { UntitledTextEditorModel_1 = this; }
     static { this.FIRST_LINE_NAME_MAX_LENGTH = 40; }
-    static { this.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH = UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH * 10; }
+    static { this.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH = UntitledTextEditorModel_1.FIRST_LINE_NAME_MAX_LENGTH * 10; }
     static { this.ACTIVE_EDITOR_LANGUAGE_ID = '${activeEditorLanguage}'; }
     get name() {
         if (this.configuredLabelFormat === 'content' && !this.hasAssociatedFilePath && this.cachedModelFirstLineWords) {
@@ -89,7 +91,7 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
         }
     }
     setLanguageId(languageId, source) {
-        const actualLanguage = languageId === UntitledTextEditorModel.ACTIVE_EDITOR_LANGUAGE_ID
+        const actualLanguage = languageId === UntitledTextEditorModel_1.ACTIVE_EDITOR_LANGUAGE_ID
             ? this.editorService.activeTextEditorLanguageId
             : languageId;
         this.preferredLanguageId = actualLanguage;
@@ -141,7 +143,7 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
     async backup(token) {
         let content = undefined;
         if (this.isResolved()) {
-            content = await this.textFileService.getEncodedReadable(this.resource, withNullAsUndefined(this.createSnapshot()), { encoding: UTF8 });
+            content = await this.textFileService.getEncodedReadable(this.resource, this.createSnapshot() ?? undefined, { encoding: UTF8 });
         }
         else if (typeof this.initialValue === 'string') {
             content = bufferToReadable(VSBuffer.fromString(this.initialValue));
@@ -194,7 +196,7 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
             this.setDirty(true);
         }
         if (( e.changes.some(
-            change => (change.range.startLineNumber === 1 || change.range.endLineNumber === 1) && change.range.startColumn <= UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH
+            change => (change.range.startLineNumber === 1 || change.range.endLineNumber === 1) && change.range.startColumn <= UntitledTextEditorModel_1.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH
         ))) {
             this.updateNameFromFirstLine(textEditorModel);
         }
@@ -211,11 +213,12 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
             startLineNumber: 1,
             endLineNumber: 1,
             startColumn: 1,
-            endColumn: UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH + 1
+            endColumn: UntitledTextEditorModel_1.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH + 1
         })
-            .trim().replace(/\s+/g, ' ');
+            .trim().replace(/\s+/g, ' ')
+            .replace(/\u202E/g, '');
         firstLineText = firstLineText.substr(0, getCharContainingOffset(
-        firstLineText, UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH)[0]);
+        firstLineText, UntitledTextEditorModel_1.FIRST_LINE_NAME_MAX_LENGTH)[0]);
         if (firstLineText && ensureValidWordDefinition().exec(firstLineText)) {
             modelFirstWordsCandidate = firstLineText;
         }
@@ -228,7 +231,7 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
         return false;
     }
 };
-UntitledTextEditorModel = ( __decorate([
+UntitledTextEditorModel = UntitledTextEditorModel_1 = ( __decorate([
     ( __param(5, ILanguageService)),
     ( __param(6, IModelService)),
     ( __param(7, IWorkingCopyBackupService)),

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorService.d.ts

@@ -91,4 +91,4 @@ interface IUntitledTextEditorModelManager {
     isUntitledWithAssociatedResource(resource: URI): boolean;
 }
 
-export { IExistingUntitledTextEditorOptions, INewUntitledTextEditorOptions, INewUntitledTextEditorWithAssociatedResourceOptions, IUntitledTextEditorModelManager };
+export type { IExistingUntitledTextEditorOptions, INewUntitledTextEditorOptions, INewUntitledTextEditorWithAssociatedResourceOptions, IUntitledTextEditorModelManager };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -7,8 +7,10 @@ import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+var UntitledTextEditorService_1;
 const IUntitledTextEditorService = ( (createDecorator('untitledTextEditorService')));
 let UntitledTextEditorService = class UntitledTextEditorService extends Disposable {
+    static { UntitledTextEditorService_1 = this; }
     static { this.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/; }
     constructor(instantiationService, configurationService) {
         super();
@@ -104,10 +106,10 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
         }
     }
     isUntitledWithAssociatedResource(resource) {
-        return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
+        return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService_1.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
     }
 };
-UntitledTextEditorService = ( (__decorate([
+UntitledTextEditorService = UntitledTextEditorService_1 = ( (__decorate([
     ( (__param(0, IInstantiationService))),
     ( (__param(1, IConfigurationService)))
 ], UntitledTextEditorService)));

package/vscode/src/vs/workbench/services/update/browser/updateService.d.ts

@@ -10,4 +10,4 @@ interface IUpdateProvider {
     checkForUpdate(): Promise<IUpdate | null>;
 }
 
-export { IUpdate, IUpdateProvider };
+export type { IUpdate, IUpdateProvider };

package/vscode/src/vs/workbench/services/url/browser/urlService.d.ts

@@ -25,4 +25,4 @@ interface IURLCallbackProvider {
     create(options?: Partial<UriComponents>): URI;
 }
 
-export { IURLCallbackProvider };
+export type { IURLCallbackProvider };

package/vscode/src/vs/workbench/services/userData/browser/userDataInit.d.ts

@@ -12,4 +12,4 @@ interface IUserDataInitializationService extends IUserDataInitializer {
     _serviceBrand: any;
 }
 
-export { IUserDataInitializationService, IUserDataInitializer };
+export { IUserDataInitializationService, type IUserDataInitializer };

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

@@ -16,4 +16,4 @@ interface IUserDataProfileService {
     getShortName(profile: IUserDataProfile): string;
 }
 
-export { DidChangeUserDataProfileEvent, IUserDataProfileService };
+export { type DidChangeUserDataProfileEvent, IUserDataProfileService };

package/vscode/src/vs/workbench/services/views/browser/viewDescriptorService.js

@@ -4,7 +4,7 @@ import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'monaco-editor
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Disposable, DisposableMap, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ViewPaneContainer, ViewPaneContainerAction, ViewsSubMenu } from '../../../browser/parts/views/viewPaneContainer.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
@@ -14,8 +14,10 @@ import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiati
 import { getViewsStateStorageId, ViewContainerModel } from '../common/viewContainerModel.js';
 import { registerAction2, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+var ViewDescriptorService_1;
 function getViewContainerStorageId(viewContainerId) { return `${viewContainerId}.state`; }
 let ViewDescriptorService = class ViewDescriptorService extends Disposable {
+    static { ViewDescriptorService_1 = this; }
     static { this.VIEWS_CUSTOMIZATIONS = 'views.customizations'; }
     static { this.COMMON_CONTAINER_ID_PREFIX = 'workbench.views.service'; }
     get viewContainers() { return this.viewContainersRegistry.all; }
@@ -58,11 +60,11 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
             this.onDidDeregisterViewContainer(viewContainer);
             this._onDidChangeViewContainers.fire({ removed: [{ container: viewContainer, location: this.getViewContainerLocation(viewContainer) }], added: [] });
         }));
-        this._register(this.storageService.onDidChangeValue((e) => { this.onDidStorageChange(e); }));
+        this._register(this.storageService.onDidChangeValue(0 , ViewDescriptorService_1.VIEWS_CUSTOMIZATIONS, this._register(( new DisposableStore())))(() => this.onDidStorageChange()));
         this.extensionService.whenInstalledExtensionsRegistered().then(() => this.whenExtensionsRegistered());
     }
     migrateToViewsCustomizationsStorage() {
-        if (this.storageService.get(ViewDescriptorService.VIEWS_CUSTOMIZATIONS, 0 )) {
+        if (this.storageService.get(ViewDescriptorService_1.VIEWS_CUSTOMIZATIONS, 0 )) {
             return;
         }
         const viewContainerLocationsValue = this.storageService.get('views.cachedViewContainerLocations', 0 );
@@ -77,7 +79,7 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
             viewLocations: viewDescriptorLocations.reduce((result, [id, { containerId }]) => { result[id] = containerId; return result; }, {}),
             viewContainerBadgeEnablementStates: {}
         };
-        this.storageService.store(ViewDescriptorService.VIEWS_CUSTOMIZATIONS, JSON.stringify(viewsCustomizations), 0 , 0 );
+        this.storageService.store(ViewDescriptorService_1.VIEWS_CUSTOMIZATIONS, JSON.stringify(viewsCustomizations), 0 , 0 );
         this.storageService.remove('views.cachedViewContainerLocations', 0 );
         this.storageService.remove('views.cachedViewPositions', 0 );
     }
@@ -136,7 +138,7 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
         });
     }
     isGeneratedContainerId(id) {
-        return id.startsWith(ViewDescriptorService.COMMON_CONTAINER_ID_PREFIX);
+        return id.startsWith(ViewDescriptorService_1.COMMON_CONTAINER_ID_PREFIX);
     }
     onDidDeregisterViews(views, viewContainer) {
         const regroupedViews = this.regroupViews(viewContainer.id, views);
@@ -256,7 +258,7 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
     }
     reportMovedViews(views, from, to) {
         const containerToString = (container) => {
-            if (container.id.startsWith(ViewDescriptorService.COMMON_CONTAINER_ID_PREFIX)) {
+            if (container.id.startsWith(ViewDescriptorService_1.COMMON_CONTAINER_ID_PREFIX)) {
                 return 'custom';
             }
             if (!container.extensionId) {
@@ -336,9 +338,8 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
         this.getOrCreateDefaultViewContainerLocationContextKey(container).set(true);
         return container;
     }
-    onDidStorageChange(e) {
-        if (e.key === ViewDescriptorService.VIEWS_CUSTOMIZATIONS && e.scope === 0
-            && JSON.stringify(this.viewCustomizations) !== this.getStoredViewCustomizationsValue() ) {
+    onDidStorageChange() {
+        if (JSON.stringify(this.viewCustomizations) !== this.getStoredViewCustomizationsValue() ) {
             this.onDidViewCustomizationsStorageChange();
         }
     }
@@ -400,7 +401,7 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
         this.viewDescriptorsCustomLocations = newViewDescriptorCustomizations;
     }
     generateContainerId(location) {
-        return `${ViewDescriptorService.COMMON_CONTAINER_ID_PREFIX}.${ViewContainerLocationToString(location)}.${generateUuid()}`;
+        return `${ViewDescriptorService_1.COMMON_CONTAINER_ID_PREFIX}.${ViewContainerLocationToString(location)}.${generateUuid()}`;
     }
     saveViewCustomizations() {
         const viewCustomizations = { viewContainerLocations: {}, viewLocations: {}, viewContainerBadgeEnablementStates: {} };
@@ -445,10 +446,10 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
         }
     }
     getStoredViewCustomizationsValue() {
-        return this.storageService.get(ViewDescriptorService.VIEWS_CUSTOMIZATIONS, 0 , '{}');
+        return this.storageService.get(ViewDescriptorService_1.VIEWS_CUSTOMIZATIONS, 0 , '{}');
     }
     setStoredViewCustomizationsValue(value) {
-        this.storageService.store(ViewDescriptorService.VIEWS_CUSTOMIZATIONS, value, 0 , 0 );
+        this.storageService.store(ViewDescriptorService_1.VIEWS_CUSTOMIZATIONS, value, 0 , 0 );
     }
     getViewsByContainer(viewContainer) {
         const result = this.viewsRegistry.getViews(viewContainer).filter(viewDescriptor => {
@@ -678,7 +679,7 @@ let ViewDescriptorService = class ViewDescriptorService extends Disposable {
         return contextKey;
     }
 };
-ViewDescriptorService = ( __decorate([
+ViewDescriptorService = ViewDescriptorService_1 = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, IContextKeyService)),
     ( __param(2, IStorageService)),

package/vscode/src/vs/workbench/services/views/common/viewContainerModel.js

@@ -3,7 +3,7 @@ import { defaultViewIcon, Extensions } from '../../../common/views.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.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 { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
@@ -49,7 +49,7 @@ let ViewDescriptorsState = class ViewDescriptorsState extends Disposable {
         this.logger = loggerService.createLogger(getViewsLogFile(workbenchEnvironmentService), { id: VIEWS_LOG_ID, name: VIEWS_LOG_NAME, hidden: true });
         this.globalViewsStateStorageId = getViewsStateStorageId(viewContainerStorageId);
         this.workspaceViewsStateStorageId = viewContainerStorageId;
-        this._register(this.storageService.onDidChangeValue(e => this.onDidStorageChange(e)));
+        this._register(this.storageService.onDidChangeValue(0 , this.globalViewsStateStorageId, this._register(( (new DisposableStore()))))(() => this.onDidStorageChange()));
         this.state = this.initialize();
     }
     set(id, state) {
@@ -94,9 +94,8 @@ let ViewDescriptorsState = class ViewDescriptorsState extends Disposable {
         }
         this.setStoredGlobalState(storedGlobalState);
     }
-    onDidStorageChange(e) {
-        if (e.key === this.globalViewsStateStorageId && e.scope === 0
-            && this.globalViewsStatesValue !== this.getStoredGlobalViewsStatesValue() ) {
+    onDidStorageChange() {
+        if (this.globalViewsStatesValue !== this.getStoredGlobalViewsStatesValue() ) {
             this._globalViewsStatesValue = undefined;
             const storedViewsVisibilityStates = this.getStoredGlobalState();
             const storedWorkspaceViewsStates = this.getStoredWorkspaceState();

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopy.d.ts

@@ -96,4 +96,4 @@ interface IResolvedFileWorkingCopy<M extends IFileWorkingCopyModel> extends IFil
     readonly model: M;
 }
 
-export { IFileWorkingCopy, IFileWorkingCopyModel, IFileWorkingCopyModelConfiguration, IResolvedFileWorkingCopy };
+export type { IFileWorkingCopy, IFileWorkingCopyModel, IFileWorkingCopyModelConfiguration, IResolvedFileWorkingCopy };

package/vscode/src/vs/workbench/services/workingCopy/common/resourceWorkingCopy.d.ts

@@ -25,4 +25,4 @@ interface IResourceWorkingCopy extends IWorkingCopy, IDisposable {
     isDisposed(): boolean;
 }
 
-export { IResourceWorkingCopy };
+export type { IResourceWorkingCopy };

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopy.d.ts

@@ -174,4 +174,4 @@ interface IStoredFileWorkingCopySaveEvent extends IWorkingCopySaveEvent {
     readonly stat: IFileStatWithMetadata;
 }
 
-export { IResolvedStoredFileWorkingCopy, IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelContentChangedEvent, IStoredFileWorkingCopyResolveOptions, IStoredFileWorkingCopySaveEvent, StoredFileWorkingCopyState };
+export { type IResolvedStoredFileWorkingCopy, type IStoredFileWorkingCopy, type IStoredFileWorkingCopyModel, type IStoredFileWorkingCopyModelContentChangedEvent, type IStoredFileWorkingCopyResolveOptions, type IStoredFileWorkingCopySaveEvent, StoredFileWorkingCopyState };

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

@@ -46,6 +46,7 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
     }
     dispose() {
         this.saveParticipants.splice(0, this.saveParticipants.length);
+        super.dispose();
     }
 };
 StoredFileWorkingCopySaveParticipant = ( __decorate([

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

@@ -167,4 +167,4 @@ interface IWorkingCopy extends IWorkingCopyIdentifier {
     revert(options?: IRevertOptions): Promise<void>;
 }
 
-export { IWorkingCopy, IWorkingCopyBackup, IWorkingCopyBackupMeta, IWorkingCopyIdentifier, IWorkingCopySaveEvent, WorkingCopyCapabilities };
+export { type IWorkingCopy, type IWorkingCopyBackup, type IWorkingCopyBackupMeta, type IWorkingCopyIdentifier, type IWorkingCopySaveEvent, WorkingCopyCapabilities };

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

@@ -1,16 +1,20 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { deepClone, equals } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { isReadableStream, peekStream } from 'monaco-editor/esm/vs/base/common/stream.js';
 import { VSBuffer, prefixedBufferStream, prefixedBufferReadable, bufferToStream, streamToBuffer, readableToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { NO_TYPE_ID } from './workingCopy.js';
+var WorkingCopyBackupServiceImpl_1;
 class WorkingCopyBackupsModel {
     static async create(backupRoot, fileService) {
         const model = ( (new WorkingCopyBackupsModel(backupRoot, fileService)));
@@ -81,7 +85,8 @@ class WorkingCopyBackupsModel {
         this.cache.clear();
     }
 }
-(class WorkingCopyBackupServiceImpl extends Disposable {
+let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Disposable {
+    static { WorkingCopyBackupServiceImpl_1 = this; }
     static { this.PREAMBLE_END_MARKER = '\n'; }
     static { this.PREAMBLE_END_MARKER_CHARCODE = '\n'.charCodeAt(0); }
     static { this.PREAMBLE_META_SEPARATOR = ' '; }
@@ -134,7 +139,7 @@ class WorkingCopyBackupsModel {
                 return;
             }
             let preamble = this.createPreamble(identifier, meta);
-            if (preamble.length >= WorkingCopyBackupServiceImpl.PREAMBLE_MAX_LENGTH) {
+            if (preamble.length >= WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH) {
                 preamble = this.createPreamble(identifier);
             }
             const preambleBuffer = VSBuffer.fromString(preamble);
@@ -153,7 +158,7 @@ class WorkingCopyBackupsModel {
         });
     }
     createPreamble(identifier, meta) {
-        return `${( ( identifier.resource.toString()))}${WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER}`;
+        return `${( ( identifier.resource.toString()))}${WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR}${JSON.stringify({ ...meta, typeId: identifier.typeId })}${WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER}`;
     }
     async discardBackups(filter) {
         const model = await this.ready;
@@ -213,11 +218,11 @@ class WorkingCopyBackupsModel {
             if (!( (model.has(backupResource)))) {
                 return;
             }
-            const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl.PREAMBLE_MAX_LENGTH);
+            const backupPreamble = await this.readToMatchingString(backupResource, WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER, WorkingCopyBackupServiceImpl_1.PREAMBLE_MAX_LENGTH);
             if (!backupPreamble) {
                 return;
             }
-            const metaStartIndex = backupPreamble.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR);
+            const metaStartIndex = backupPreamble.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
             let resourcePreamble;
             let metaPreamble;
             if (metaStartIndex > 0) {
@@ -256,14 +261,14 @@ class WorkingCopyBackupsModel {
             const backupStream = await this.fileService.readFileStream(backupResource);
             const peekedBackupStream = await peekStream(backupStream.value, 1);
             const firstBackupChunk = VSBuffer.concat(peekedBackupStream.buffer);
-            const preambleEndIndex = firstBackupChunk.buffer.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_END_MARKER_CHARCODE);
+            const preambleEndIndex = firstBackupChunk.buffer.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_END_MARKER_CHARCODE);
             if (preambleEndIndex === -1) {
                 this.logService.trace(`Backup: Could not find meta end marker in ${backupResource}. The file is probably corrupt (filesize: ${backupStream.size}).`);
                 return undefined;
             }
             const preambelRaw = ( (firstBackupChunk.slice(0, preambleEndIndex).toString()));
             let meta;
-            const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl.PREAMBLE_META_SEPARATOR);
+            const metaStartIndex = preambelRaw.indexOf(WorkingCopyBackupServiceImpl_1.PREAMBLE_META_SEPARATOR);
             if (metaStartIndex !== -1) {
                 meta = this.parsePreambleMeta(preambelRaw.substr(metaStartIndex + 1)).meta;
             }
@@ -305,7 +310,11 @@ class WorkingCopyBackupsModel {
     joinBackups() {
         return this.ioOperationQueues.whenDrained();
     }
-});
+};
+WorkingCopyBackupServiceImpl = WorkingCopyBackupServiceImpl_1 = ( (__decorate([
+    ( (__param(1, IFileService))),
+    ( (__param(2, ILogService)))
+], WorkingCopyBackupServiceImpl)));
 class InMemoryWorkingCopyBackupService {
     constructor() {
         this.backups = ( (new ResourceMap()));

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

@@ -30,6 +30,7 @@ let WorkingCopyFileOperationParticipant = class WorkingCopyFileOperationParticip
     }
     dispose() {
         this.participants.clear();
+        super.dispose();
     }
 };
 WorkingCopyFileOperationParticipant = ( __decorate([

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyFileService.d.ts

@@ -189,4 +189,4 @@ interface IWorkingCopyFileService {
     getDirty(resource: URI): readonly IWorkingCopy[];
 }
 
-export { ICopyOperation, ICreateFileOperation, ICreateOperation, IDeleteOperation, IFileOperationUndoRedoInfo, IMoveOperation, IStoredFileWorkingCopySaveParticipant, IWorkingCopyFileOperationParticipant, IWorkingCopyFileService, SourceTargetPair, WorkingCopyFileEvent };
+export { type ICopyOperation, type ICreateFileOperation, type ICreateOperation, type IDeleteOperation, type IFileOperationUndoRedoInfo, type IMoveOperation, type IStoredFileWorkingCopySaveParticipant, type IWorkingCopyFileOperationParticipant, IWorkingCopyFileService, type SourceTargetPair, type WorkingCopyFileEvent };

package/vscode/src/vs/workbench/services/workspaces/browser/workspacesService.js

@@ -4,7 +4,7 @@ import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { isTemporaryWorkspace, WORKSPACE_EXTENSION, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.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 { getWorkspaceIdentifier } from './workspaces.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
@@ -12,7 +12,9 @@ import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+var BrowserWorkspacesService_1;
 let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable {
+    static { BrowserWorkspacesService_1 = this; }
     static { this.RECENTLY_OPENED_KEY = 'recently.opened'; }
     constructor(storageService, contextService, logService, fileService, environmentService, uriIdentityService) {
         super();
@@ -28,14 +30,9 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         this.registerListeners();
     }
     registerListeners() {
-        this._register(this.storageService.onDidChangeValue(e => this.onDidChangeStorage(e)));
+        this._register(this.storageService.onDidChangeValue(-1 , BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, this._register(( new DisposableStore())))(() => this._onRecentlyOpenedChange.fire()));
         this._register(this.contextService.onDidChangeWorkspaceFolders(e => this.onDidChangeWorkspaceFolders(e)));
     }
-    onDidChangeStorage(e) {
-        if (e.key === BrowserWorkspacesService.RECENTLY_OPENED_KEY && e.scope === -1 ) {
-            this._onRecentlyOpenedChange.fire();
-        }
-    }
     onDidChangeWorkspaceFolders(e) {
         if (!isTemporaryWorkspace(this.contextService.getWorkspace())) {
             return;
@@ -57,7 +54,7 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         }
     }
     async getRecentlyOpened() {
-        const recentlyOpenedRaw = this.storageService.get(BrowserWorkspacesService.RECENTLY_OPENED_KEY, -1 );
+        const recentlyOpenedRaw = this.storageService.get(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, -1 );
         if (recentlyOpenedRaw) {
             const recentlyOpened = restoreRecentlyOpened(JSON.parse(recentlyOpenedRaw), this.logService);
             recentlyOpened.workspaces = recentlyOpened.workspaces.filter(recent => {
@@ -105,10 +102,10 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         });
     }
     async saveRecentlyOpened(data) {
-        return this.storageService.store(BrowserWorkspacesService.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), -1 , 0 );
+        return this.storageService.store(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, JSON.stringify(toStoreData(data)), -1 , 0 );
     }
     async clearRecentlyOpened() {
-        this.storageService.remove(BrowserWorkspacesService.RECENTLY_OPENED_KEY, -1 );
+        this.storageService.remove(BrowserWorkspacesService_1.RECENTLY_OPENED_KEY, -1 );
     }
     async enterWorkspace(workspaceUri) {
         return { workspace: await this.getWorkspaceIdentifier(workspaceUri) };
@@ -143,7 +140,7 @@ let BrowserWorkspacesService = class BrowserWorkspacesService extends Disposable
         return [];
     }
 };
-BrowserWorkspacesService = ( __decorate([
+BrowserWorkspacesService = BrowserWorkspacesService_1 = ( __decorate([
     ( __param(0, IStorageService)),
     ( __param(1, IWorkspaceContextService)),
     ( __param(2, ILogService)),

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

@@ -1,29 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { ISemanticSimilarityService } from '../../services/semanticSimilarity/common/semanticSimilarityService.js';
-let MainThreadSemanticSimilarity = class MainThreadSemanticSimilarity extends Disposable {
-    constructor(context, _semanticSimilarityService) {
-        super();
-        this._semanticSimilarityService = _semanticSimilarityService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostSemanticSimilarity));
-    }
-    $registerSemanticSimilarityProvider(handle) {
-        const provider = {
-            provideSimilarityScore: (string1, comparisons, token) => {
-                return this._proxy.$provideSimilarityScore(handle, string1, comparisons, token);
-            },
-        };
-        this._registrations.set(handle, this._semanticSimilarityService.registerSemanticSimilarityProvider(provider));
-    }
-    $unregisterSemanticSimilarityProvider(handle) {
-        this._registrations.deleteAndDispose(handle);
-    }
-};
-MainThreadSemanticSimilarity = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadSemanticSimilarity),
-    ( __param(1, ISemanticSimilarityService))
-], MainThreadSemanticSimilarity);
-export { MainThreadSemanticSimilarity };

package/vscode/src/vs/workbench/api/common/extHostSemanticSimilarity.js

@@ -1,31 +0,0 @@
-import { MainContext } from './extHost.protocol.js';
-import { Disposable } from './extHostTypes.js';
-class ExtHostSemanticSimilarity {
-    constructor(mainContext) {
-        this._semanticSimilarityProviders = ( new Map());
-        this._nextHandle = 0;
-        this._proxy = ( mainContext.getProxy(MainContext.MainThreadSemanticSimilarity));
-    }
-    async $provideSimilarityScore(handle, string1, comparisons, token) {
-        if (this._semanticSimilarityProviders.size === 0) {
-            throw new Error('No semantic similarity providers registered');
-        }
-        const provider = this._semanticSimilarityProviders.get(handle);
-        if (!provider) {
-            throw new Error('Semantic similarity provider not found');
-        }
-        const result = await provider.provideSimilarityScore(string1, comparisons, token);
-        return result;
-    }
-    registerSemanticSimilarityProvider(extension, provider) {
-        const handle = this._nextHandle;
-        this._nextHandle++;
-        this._semanticSimilarityProviders.set(handle, provider);
-        this._proxy.$registerSemanticSimilarityProvider(handle);
-        return ( new Disposable(() => {
-            this._proxy.$unregisterSemanticSimilarityProvider(handle);
-            this._semanticSimilarityProviders.delete(handle);
-        }));
-    }
-}
-export { ExtHostSemanticSimilarity };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatActions.js

@@ -1,3 +0,0 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-const CHAT_CATEGORY = { value: ( localize('chat.category', "Chat")), original: 'Chat' };
-export { CHAT_CATEGORY };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/quickQuestionActions/quickQuestionAction.js

@@ -1,47 +0,0 @@
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { CHAT_CATEGORY } from '../chatActions.js';
-import { CONTEXT_PROVIDER_EXISTS } from '../../../common/chatContextKeys.js';
-const ASK_QUICK_QUESTION_ACTION_ID = 'chat.action.askQuickQuestion';
-class AskQuickQuestionAction extends Action2 {
-    static { this.modeRegistry = ( new Map()); }
-    static registerMode(mode, modeAction) {
-        AskQuickQuestionAction.modeRegistry.set(mode, ( new Lazy(() => ( new modeAction()))));
-    }
-    constructor() {
-        super({
-            id: ASK_QUICK_QUESTION_ACTION_ID,
-            title: { value: ( localize('chat', "Chat")), original: 'Chat' },
-            precondition: CONTEXT_PROVIDER_EXISTS,
-            icon: Codicon.commentDiscussion,
-            f1: false,
-            category: CHAT_CATEGORY,
-            keybinding: {
-                weight: 200 ,
-                primary: 2048  | 1024  | 39 ,
-                linux: {
-                    primary: 2048  | 1024  | 512  | 39
-                }
-            },
-            menu: {
-                id: MenuId.LayoutControlMenu,
-                group: '0_workbench_toggles',
-                when: ( ContextKeyExpr.notEquals('config.chat.experimental.defaultMode', 'chatView')),
-                order: 0
-            }
-        });
-    }
-    run(accessor, query) {
-        const configurationService = accessor.get(IConfigurationService);
-        const mode = configurationService.getValue('chat.experimental.quickQuestion.mode');
-        const modeAction = AskQuickQuestionAction.modeRegistry.get(mode);
-        if (modeAction) {
-            modeAction.value.run(accessor, query);
-        }
-    }
-}
-export { ASK_QUICK_QUESTION_ACTION_ID, AskQuickQuestionAction };

package/vscode/src/vs/workbench/contrib/chat/common/chatContextKeys.js

@@ -1,4 +0,0 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-const CONTEXT_PROVIDER_EXISTS = ( new RawContextKey('hasChatProvider', false, { type: 'boolean', description: ( localize('hasChatProvider', "True when some chat provider has been registered.")) }));
-export { CONTEXT_PROVIDER_EXISTS };