@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.1

package/vscode/src/vs/workbench/services/search/common/queryBuilder.d.ts

@@ -32,4 +32,4 @@ interface ITextQueryBuilderOptions extends ICommonQueryBuilderOptions {
     };
 }
 
-export { ITextQueryBuilderOptions };
+export type { ITextQueryBuilderOptions };

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

@@ -49,4 +49,4 @@ interface ITextSearchContext {
 }
 type ITextSearchResult = ITextSearchMatch | ITextSearchContext;
 
-export { IFileMatch, INotebookPatternInfo, IPatternInfo, IRawFileMatch2, ISearchRange, ITextSearchContext, ITextSearchMatch, ITextSearchPreviewOptions, ITextSearchResult, ITextSearchResultPreview };
+export type { IFileMatch, INotebookPatternInfo, IPatternInfo, IRawFileMatch2, ISearchRange, ITextSearchContext, ITextSearchMatch, ITextSearchPreviewOptions, ITextSearchResult, ITextSearchResultPreview };

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

@@ -3,7 +3,7 @@ import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
 import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ResourceSet, ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
@@ -15,7 +15,7 @@ import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/c
 import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
 import { IEditorService } from '../../editor/common/editorService.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
-import { deserializeSearchError, pathIncludedInQuery, isFileMatch, isProgressMessage, SearchErrorCode, FileMatch } from './search.js';
+import { deserializeSearchError, pathIncludedInQuery, SearchErrorCode, FileMatch, isFileMatch, isProgressMessage } from './search.js';
 import { editorMatchesToTextSearchResults, addContextToEditorMatches } from './searchHelpers.js';
 let SearchService = class SearchService extends Disposable {
     constructor(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService) {
@@ -56,31 +56,46 @@ let SearchService = class SearchService extends Disposable {
             list.delete(scheme);
         });
     }
-    async textSearch(query, token, onProgress, notebookURIs) {
-        const localResults = this.getLocalResults(query);
+    async textSearch(query, token, onProgress) {
+        const results = this.textSearchSplitSyncAsync(query, token, onProgress);
+        const openEditorResults = results.syncResults;
+        const otherResults = await results.asyncResults;
+        return {
+            limitHit: otherResults.limitHit || openEditorResults.limitHit,
+            results: [...otherResults.results, ...openEditorResults.results],
+            messages: [...otherResults.messages, ...openEditorResults.messages]
+        };
+    }
+    textSearchSplitSyncAsync(query, token, onProgress, notebookFilesToIgnore, asyncNotebookFilesToIgnore) {
+        const openEditorResults = this.getOpenEditorResults(query);
         if (onProgress) {
-            arrays.coalesce([...( localResults.results.values())]).forEach(onProgress);
+            arrays.coalesce([...( openEditorResults.results.values())]).filter(e => !(notebookFilesToIgnore && ( notebookFilesToIgnore.has(e.resource)))).forEach(onProgress);
         }
-        const onProviderProgress = (progress) => {
-            if (isFileMatch(progress)) {
-                if (!( localResults.results.has(progress.resource)) && !(notebookURIs && ( notebookURIs.has(progress.resource))) && onProgress) {
+        const syncResults = {
+            results: arrays.coalesce([...( openEditorResults.results.values())]),
+            limitHit: openEditorResults.limitHit ?? false,
+            messages: []
+        };
+        const getAsyncResults = async () => {
+            const resolvedAsyncNotebookFilesToIgnore = (await asyncNotebookFilesToIgnore) ?? ( new ResourceSet());
+            const onProviderProgress = (progress) => {
+                if (isFileMatch(progress)) {
+                    if (!( openEditorResults.results.has(progress.resource)) && !( resolvedAsyncNotebookFilesToIgnore.has(progress.resource)) && onProgress) {
+                        onProgress(progress);
+                    }
+                }
+                else if (onProgress) {
                     onProgress(progress);
                 }
-            }
-            else if (onProgress) {
-                onProgress(progress);
-            }
-            if (isProgressMessage(progress)) {
-                this.logService.debug('SearchService#search', progress.message);
-            }
+                if (isProgressMessage(progress)) {
+                    this.logService.debug('SearchService#search', progress.message);
+                }
+            };
+            return await this.doSearch(query, token, onProviderProgress);
         };
-        const otherResults = await this.doSearch(query, token, onProviderProgress);
         return {
-            ...otherResults,
-            ...{
-                limitHit: otherResults.limitHit || localResults.limitHit
-            },
-            results: [...otherResults.results, ...arrays.coalesce([...( localResults.results.values())])]
+            syncResults,
+            asyncResults: getAsyncResults()
         };
     }
     fileSearch(query, token) {
@@ -275,8 +290,8 @@ let SearchService = class SearchService extends Disposable {
             });
         }
     }
-    getLocalResults(query) {
-        const localResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+    getOpenEditorResults(query) {
+        const openEditorResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
         let limitHit = false;
         if (query.type === 2 ) {
             const canonicalToOriginalResources = ( new ResourceMap());
@@ -320,17 +335,17 @@ let SearchService = class SearchService extends Disposable {
                         matches = matches.slice(0, askMax - 1);
                     }
                     const fileMatch = ( new FileMatch(originalResource));
-                    localResults.set(originalResource, fileMatch);
+                    openEditorResults.set(originalResource, fileMatch);
                     const textSearchResults = editorMatchesToTextSearchResults(matches, model, query.previewOptions);
                     fileMatch.results = addContextToEditorMatches(textSearchResults, model, query);
                 }
                 else {
-                    localResults.set(originalResource, null);
+                    openEditorResults.set(originalResource, null);
                 }
             });
         }
         return {
-            results: localResults,
+            results: openEditorResults,
             limitHit
         };
     }

package/vscode/src/vs/workbench/services/statusbar/browser/statusbar.d.ts

@@ -113,6 +113,7 @@ interface IStatusbarStyleOverride {
     readonly background?: ColorIdentifier;
     readonly border?: ColorIdentifier;
 }
+type StatusbarEntryKind = 'standard' | 'warning' | 'error' | 'prominent' | 'remote' | 'offline';
 /**
  * A declarative way of describing a status bar entry
  */
@@ -142,11 +143,15 @@ interface IStatusbarEntry {
      */
     readonly tooltip?: string | IMarkdownString | HTMLElement;
     /**
-     * An optional color to use for the entry
+     * An optional color to use for the entry.
+     *
+     * @deprecated Use `kind` instead to support themable hover styles.
      */
     readonly color?: string | ThemeColor;
     /**
-     * An optional background color to use for the entry
+     * An optional background color to use for the entry.
+     *
+     * @deprecated Use `kind` instead to support themable hover styles.
      */
     readonly backgroundColor?: string | ThemeColor;
     /**
@@ -165,6 +170,10 @@ interface IStatusbarEntry {
      * specified, `syncing` will be used.
      */
     readonly showProgress?: boolean | 'syncing' | 'loading';
+    /**
+     * The kind of status bar entry. This applies different colors to the entry.
+     */
+    readonly kind?: StatusbarEntryKind;
 }
 interface IStatusbarEntryAccessor extends IDisposable {
     /**
@@ -173,4 +182,4 @@ interface IStatusbarEntryAccessor extends IDisposable {
     update(properties: IStatusbarEntry): void;
 }
 
-export { IStatusbarEntry, IStatusbarEntryAccessor, IStatusbarEntryLocation, IStatusbarEntryPriority, IStatusbarService, IStatusbarStyleOverride, ShowTooltipCommand, StatusbarAlignment };
+export { type IStatusbarEntry, type IStatusbarEntryAccessor, type IStatusbarEntryLocation, type IStatusbarEntryPriority, IStatusbarService, type IStatusbarStyleOverride, ShowTooltipCommand, StatusbarAlignment, type StatusbarEntryKind };

package/vscode/src/vs/workbench/services/statusbar/browser/statusbar.js

@@ -12,4 +12,5 @@ const ShowTooltipCommand = {
     id: 'statusBar.entry.showTooltip',
     title: ''
 };
-export { IStatusbarService, ShowTooltipCommand, isStatusbarEntryLocation, isStatusbarEntryPriority };
+const StatusbarEntryKinds = ['standard', 'warning', 'error', 'prominent', 'remote', 'offline'];
+export { IStatusbarService, ShowTooltipCommand, StatusbarEntryKinds, isStatusbarEntryLocation, isStatusbarEntryPriority };

package/vscode/src/vs/workbench/services/storage/browser/storageService.js

@@ -11,7 +11,9 @@ import { Storage, isStorageItemsChangeEvent, InMemoryStorageDatabase } from 'mon
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { AbstractStorageService, isProfileUsingDefaultStorage, IS_NEW_KEY } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { isUserDataProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+var BrowserStorageService_1;
 let BrowserStorageService = class BrowserStorageService extends AbstractStorageService {
+    static { BrowserStorageService_1 = this; }
     static { this.BROWSER_DEFAULT_FLUSH_INTERVAL = 5 * 1000; }
     get hasPendingUpdate() {
         return Boolean(this.applicationStorageDatabase?.hasPendingUpdate ||
@@ -19,7 +21,7 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
             this.workspaceStorageDatabase?.hasPendingUpdate);
     }
     constructor(workspace, userDataProfileService, logService) {
-        super({ flushInterval: BrowserStorageService.BROWSER_DEFAULT_FLUSH_INTERVAL });
+        super({ flushInterval: BrowserStorageService_1.BROWSER_DEFAULT_FLUSH_INTERVAL });
         this.workspace = workspace;
         this.userDataProfileService = userDataProfileService;
         this.logService = logService;
@@ -150,7 +152,7 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
         return this.workspace.id === scope.id;
     }
 };
-BrowserStorageService = ( __decorate([
+BrowserStorageService = BrowserStorageService_1 = ( __decorate([
     ( __param(2, ILogService))
 ], BrowserStorageService));
 class InMemoryIndexedDBStorageDatabase extends InMemoryStorageDatabase {

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionItem.d.ts

@@ -25,4 +25,4 @@ declare class SimpleCompletionItem {
     constructor(completion: ISimpleCompletion);
 }
 
-export { ISimpleCompletion, SimpleCompletionItem };
+export { type ISimpleCompletion, SimpleCompletionItem };

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionModel.d.ts

@@ -27,4 +27,4 @@ declare class SimpleCompletionModel {
     private _createCachedState;
 }
 
-export { ISimpleCompletionStats, LineContext, SimpleCompletionModel };
+export { type ISimpleCompletionStats, LineContext, SimpleCompletionModel };

package/vscode/src/vs/workbench/services/suggest/browser/simpleSuggestWidget.d.ts

@@ -7,4 +7,4 @@ interface ISimpleSelectedSuggestion {
     model: SimpleCompletionModel;
 }
 
-export { ISimpleSelectedSuggestion };
+export type { ISimpleSelectedSuggestion };

package/vscode/src/vs/workbench/services/textMate/browser/backgroundTokenization/textMateWorkerTokenizerController.js

@@ -49,7 +49,7 @@ class TextMateWorkerTokenizerController extends Disposable {
             maxTokenizationLineLength: this._maxTokenizationLineLength.get(),
             controllerId: this.controllerId,
         });
-        this._register(autorun('update maxTokenizationLineLength', reader => {
+        this._register(autorun(reader => {
             const maxTokenizationLineLength = this._maxTokenizationLineLength.read(reader);
             this._worker.acceptMaxTokenizationLineLength(this.controllerId, maxTokenizationLineLength);
         }));

package/vscode/src/vs/workbench/services/textMate/browser/backgroundTokenization/threadedBackgroundTokenizerFactory.js

@@ -13,7 +13,9 @@ import { IExtensionResourceLoaderService } from '../../../../../platform/extensi
 import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { TextMateWorkerTokenizerController } from './textMateWorkerTokenizerController.js';
+var ThreadedBackgroundTokenizerFactory_1;
 let ThreadedBackgroundTokenizerFactory = class ThreadedBackgroundTokenizerFactory {
+    static { ThreadedBackgroundTokenizerFactory_1 = this; }
     static { this._reportedMismatchingTokens = false; }
     constructor(_reportTokenizationTime, _shouldTokenizeAsync, _extensionResourceLoaderService, _modelService, _languageConfigurationService, _configurationService, _languageService, _environmentService, _notificationService, _telemetryService) {
         this._reportTokenizationTime = _reportTokenizationTime;
@@ -46,7 +48,7 @@ let ThreadedBackgroundTokenizerFactory = class ThreadedBackgroundTokenizerFactor
             if (store.isDisposed || !workerProxy) {
                 return undefined;
             }
-            const controllerContainer = { controller: undefined };
+            const controllerContainer = { controller: undefined, worker: this._worker };
             store.add(keepAliveWhenAttached(textModel, () => {
                 const controller = ( new TextMateWorkerTokenizerController(
                     textModel,
@@ -71,16 +73,16 @@ let ThreadedBackgroundTokenizerFactory = class ThreadedBackgroundTokenizerFactor
                 store.dispose();
             },
             requestTokens: async (startLineNumber, endLineNumberExclusive) => {
-                const controller = (await controllerContainer)?.controller;
-                if (controller) {
-                    controller.requestTokens(startLineNumber, endLineNumberExclusive);
+                const container = await controllerContainer;
+                if (container?.controller && container.worker === this._worker) {
+                    container.controller.requestTokens(startLineNumber, endLineNumberExclusive);
                 }
             },
             reportMismatchingTokens: (lineNumber) => {
-                if (ThreadedBackgroundTokenizerFactory._reportedMismatchingTokens) {
+                if (ThreadedBackgroundTokenizerFactory_1._reportedMismatchingTokens) {
                     return;
                 }
-                ThreadedBackgroundTokenizerFactory._reportedMismatchingTokens = true;
+                ThreadedBackgroundTokenizerFactory_1._reportedMismatchingTokens = true;
                 this._notificationService.error({
                     message: 'Async Tokenization Token Mismatch in line ' + lineNumber,
                     name: 'Async Tokenization Token Mismatch',
@@ -168,7 +170,7 @@ let ThreadedBackgroundTokenizerFactory = class ThreadedBackgroundTokenizerFactor
         this._workerProxyPromise = null;
     }
 };
-ThreadedBackgroundTokenizerFactory = ( __decorate([
+ThreadedBackgroundTokenizerFactory = ThreadedBackgroundTokenizerFactory_1 = ( __decorate([
     ( __param(2, IExtensionResourceLoaderService)),
     ( __param(3, IModelService)),
     ( __param(4, ILanguageConfigurationService)),

package/vscode/src/vs/workbench/services/textMate/browser/textMateTokenizationFeatureImpl.js

@@ -29,7 +29,9 @@ import { grammarsExtPoint } from '../common/TMGrammars.js';
 import { IWorkbenchThemeService } from '../../themes/common/workbenchThemeService.js';
 import * as vscodeTextmate from 'vscode-textmate';
 import * as vscodeOniguruma from 'vscode-oniguruma';
+var TextMateTokenizationFeature_1;
 let TextMateTokenizationFeature = class TextMateTokenizationFeature extends Disposable {
+    static { TextMateTokenizationFeature_1 = this; }
     static { this.reportTokenizationTimeCounter = { sync: 0, async: 0 }; }
     constructor(_languageService, _themeService, _extensionResourceLoaderService, _notificationService, _logService, _configurationService, _progressService, _environmentService, _instantiationService, _telemetryService) {
         super();
@@ -318,15 +320,15 @@ let TextMateTokenizationFeature = class TextMateTokenizationFeature extends Disp
     }
     _reportTokenizationTime(timeMs, languageId, sourceExtensionId, lineLength, fromWorker, isRandomSample) {
         const key = fromWorker ? 'async' : 'sync';
-        if (TextMateTokenizationFeature.reportTokenizationTimeCounter[key] > 50) {
+        if (TextMateTokenizationFeature_1.reportTokenizationTimeCounter[key] > 50) {
             return;
         }
-        if (TextMateTokenizationFeature.reportTokenizationTimeCounter[key] === 0) {
+        if (TextMateTokenizationFeature_1.reportTokenizationTimeCounter[key] === 0) {
             setTimeout(() => {
-                TextMateTokenizationFeature.reportTokenizationTimeCounter[key] = 0;
+                TextMateTokenizationFeature_1.reportTokenizationTimeCounter[key] = 0;
             }, 1000 * 60 * 60);
         }
-        TextMateTokenizationFeature.reportTokenizationTimeCounter[key]++;
+        TextMateTokenizationFeature_1.reportTokenizationTimeCounter[key]++;
         this._telemetryService.publicLog2('editor.tokenizedLine', {
             timeMs,
             languageId,
@@ -338,7 +340,7 @@ let TextMateTokenizationFeature = class TextMateTokenizationFeature extends Disp
         });
     }
 };
-TextMateTokenizationFeature = ( __decorate([
+TextMateTokenizationFeature = TextMateTokenizationFeature_1 = ( __decorate([
     ( __param(0, ILanguageService)),
     ( __param(1, IWorkbenchThemeService)),
     ( __param(2, IExtensionResourceLoaderService)),

package/vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js

@@ -24,7 +24,7 @@ let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFi
         this.registerListeners();
     }
     registerListeners() {
-        this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles'));
+        this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles')));
     }
     onBeforeShutdown() {
         if (( this.files.models.some(model => model.hasState(2 )))) {

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -36,10 +36,11 @@ import { IDecorationsService } from '../../decorations/common/decorations.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { listErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var AbstractTextFileService_1;
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
+    static { AbstractTextFileService_1 = this; }
     static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize('textFileCreate.source', "File Created"))); }
     static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize('textFileOverwrite.source', "File Replaced"))); }
     constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
@@ -67,7 +68,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         this.provideDecorations();
     }
     provideDecorations() {
-        this.decorationsService.registerDecorationsProvider(new (class extends Disposable {
+        const provider = this._register(new (class extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
@@ -117,6 +118,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                 return undefined;
             }
         })(this.files));
+        this._register(this.decorationsService.registerDecorationsProvider(provider));
     }
     get encoding() {
         if (!this._encoding) {
@@ -207,7 +209,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             acceptTextOnly: options?.acceptTextOnly ?? false,
             guessEncoding: options?.autoGuessEncoding || this.textResourceConfigurationService.getValue(resource, 'files.autoGuessEncoding'),
             overwriteEncoding: async (detectedEncoding) => {
-                const { encoding } = await this.encoding.getPreferredReadEncoding(resource, options, withNullAsUndefined(detectedEncoding));
+                const { encoding } = await this.encoding.getPreferredReadEncoding(resource, options, detectedEncoding ?? undefined);
                 return encoding;
             }
         });
@@ -326,7 +328,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         let sourceTextModel = undefined;
         if (sourceModel instanceof BaseTextEditorModel) {
             if (sourceModel.isResolved()) {
-                sourceTextModel = withNullAsUndefined(sourceModel.textEditorModel);
+                sourceTextModel = sourceModel.textEditorModel ?? undefined;
             }
         }
         else {
@@ -354,7 +356,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         if (!options?.source) {
             options = {
                 ...options,
-                source: targetExists ? AbstractTextFileService.TEXTFILE_SAVE_REPLACE_SOURCE : AbstractTextFileService.TEXTFILE_SAVE_CREATE_SOURCE
+                source: targetExists ? AbstractTextFileService_1.TEXTFILE_SAVE_REPLACE_SOURCE : AbstractTextFileService_1.TEXTFILE_SAVE_CREATE_SOURCE
             };
         }
         return targetModel.save(options);
@@ -459,7 +461,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         return false;
     }
 };
-AbstractTextFileService = ( __decorate([
+AbstractTextFileService = AbstractTextFileService_1 = ( __decorate([
     ( __param(0, IFileService)),
     ( __param(1, IUntitledTextEditorService)),
     ( __param(2, ILifecycleService)),

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

@@ -1,5 +1,6 @@
 import { newWriteableStream, listenStream } from 'monaco-editor/esm/vs/base/common/stream.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 const UTF8 = 'utf8';
 const UTF8_with_bom = 'utf8bom';
 const UTF16be = 'utf16be';
@@ -56,6 +57,7 @@ function toDecodeStream(source, options) {
         const bufferedChunks = [];
         let bytesBuffered = 0;
         let decoder = undefined;
+        const cts = ( new CancellationTokenSource());
         const createDecoder = async () => {
             try {
                 const detected = await detectEncodingFromBuffer({
@@ -77,12 +79,12 @@ function toDecodeStream(source, options) {
                 });
             }
             catch (error) {
-                sourceListener?.dispose();
+                cts.cancel();
                 target.destroy();
                 reject(error);
             }
         };
-        const sourceListener = listenStream(source, {
+        listenStream(source, {
             onData: async (chunk) => {
                 if (decoder) {
                     target.write(decoder.write(chunk.buffer));
@@ -104,7 +106,7 @@ function toDecodeStream(source, options) {
                 }
                 target.end(decoder?.end());
             }
-        });
+        }, cts.token);
     }));
 }
 async function toEncodeReadable(readable, encoding, options) {

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

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.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 { ITextFileService } from './textfiles.js';
 import { SaveSourceRegistry } from '../../../common/editor.js';
 import { BaseTextEditorModel } from '../../../common/editor/textEditorModel.js';
@@ -26,7 +26,9 @@ import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
 import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { IExtensionService } from '../../extensions/common/extensions.js';
+var TextFileEditorModel_1;
 let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel {
+    static { TextFileEditorModel_1 = this; }
     static { this.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource('textFileEncoding.source', ( (localize('textFileCreate.source', "File Encoding Changed")))); }
     static { this.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD = 500; }
     constructor(resource, preferredEncoding,
@@ -147,7 +149,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
                 orphaned: this.inOrphanMode
             };
         }
-        const content = await this.textFileService.getEncodedReadable(this.resource, withNullAsUndefined(this.createSnapshot()), { encoding: UTF8 });
+        const content = await this.textFileService.getEncodedReadable(this.resource, this.createSnapshot() ?? undefined, { encoding: UTF8 });
         return { meta, content };
     }
     async revert(options) {
@@ -180,7 +182,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             this.trace('resolve() - exit - without resolving because model is disposed');
             return;
         }
-        if (!options?.contents && (this.dirty || this.saveSequentializer.hasPending())) {
+        if (!options?.contents && (this.dirty || this.saveSequentializer.isRunning())) {
             this.trace('resolve() - exit - without resolving because model is dirty or being saved');
             return;
         }
@@ -476,30 +478,30 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             this.trace(`doSave(${versionId}) - exit - refusing to save() recursively from save participant`);
             return;
         }
-        if (this.saveSequentializer.hasPending(versionId)) {
-            this.trace(`doSave(${versionId}) - exit - found a pending save for versionId ${versionId}`);
-            return this.saveSequentializer.pending;
+        if (this.saveSequentializer.isRunning(versionId)) {
+            this.trace(`doSave(${versionId}) - exit - found a running save for versionId ${versionId}`);
+            return this.saveSequentializer.running;
         }
         if (!options.force && !this.dirty) {
             this.trace(`doSave(${versionId}) - exit - because not dirty and/or versionId is different (this.isDirty: ${this.dirty}, this.versionId: ${this.versionId})`);
             return;
         }
-        if (this.saveSequentializer.hasPending()) {
+        if (this.saveSequentializer.isRunning()) {
             this.trace(`doSave(${versionId}) - exit - because busy saving`);
-            this.saveSequentializer.cancelPending();
-            return this.saveSequentializer.setNext(() => this.doSave(options));
+            this.saveSequentializer.cancelRunning();
+            return this.saveSequentializer.queue(() => this.doSave(options));
         }
         if (this.isResolved()) {
             this.textEditorModel.pushStackElement();
         }
         const saveCancellation = ( (new CancellationTokenSource()));
-        return this.saveSequentializer.setPending(versionId, (async () => {
+        return this.saveSequentializer.run(versionId, (async () => {
             if (this.isResolved() && !options.skipSaveParticipants) {
                 try {
                     if (options.reason === 2  && typeof this.lastModelContentChangeFromUndoRedo === 'number') {
                         const timeFromUndoRedoToSave = Date.now() - this.lastModelContentChangeFromUndoRedo;
-                        if (timeFromUndoRedoToSave < TextFileEditorModel.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD) {
-                            await timeout(TextFileEditorModel.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD - timeFromUndoRedoToSave);
+                        if (timeFromUndoRedoToSave < TextFileEditorModel_1.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD) {
+                            await timeout(TextFileEditorModel_1.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD - timeFromUndoRedoToSave);
                         }
                     }
                     if (!saveCancellation.token.isCancellationRequested) {
@@ -533,7 +535,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             this.trace(`doSave(${versionId}) - before write()`);
             const lastResolvedFileStat = assertIsDefined(this.lastResolvedFileStat);
             const resolvedTextFileEditorModel = this;
-            return this.saveSequentializer.setPending(versionId, (async () => {
+            return this.saveSequentializer.run(versionId, (async () => {
                 try {
                     const stat = await this.textFileService.write(lastResolvedFileStat.resource, resolvedTextFileEditorModel.createSnapshot(), {
                         mtime: lastResolvedFileStat.mtime,
@@ -603,13 +605,13 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             case 4 :
                 return this.inOrphanMode;
             case 2 :
-                return this.saveSequentializer.hasPending();
+                return this.saveSequentializer.isRunning();
             case 0 :
                 return !this.dirty;
         }
     }
     async joinState(state) {
-        return this.saveSequentializer.pending;
+        return this.saveSequentializer.running;
     }
     getLanguageId() {
         if (this.textEditorModel) {
@@ -650,7 +652,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
                 this.setDirty(true);
             }
             if (!this.inConflictMode) {
-                await this.save({ source: TextFileEditorModel.TEXTFILE_SAVE_ENCODING_SOURCE });
+                await this.save({ source: TextFileEditorModel_1.TEXTFILE_SAVE_ENCODING_SOURCE });
             }
         }
         else {
@@ -700,7 +702,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         super.dispose();
     }
 };
-TextFileEditorModel = ( (__decorate([
+TextFileEditorModel = TextFileEditorModel_1 = ( (__decorate([
     ( (__param(3, ILanguageService))),
     ( (__param(4, IModelService))),
     ( (__param(5, IFileService))),

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

@@ -40,11 +40,14 @@ let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
             }
             model.textEditorModel?.pushStackElement();
         }, () => {
-            cts.dispose(true);
+            cts.cancel();
+        }).finally(() => {
+            cts.dispose();
         });
     }
     dispose() {
         this.saveParticipants.splice(0, this.saveParticipants.length);
+        super.dispose();
     }
 };
 TextFileSaveParticipant = ( __decorate([

package/vscode/src/vs/workbench/services/textfile/common/textfiles.d.ts

@@ -397,4 +397,4 @@ interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
     createSnapshot(): ITextSnapshot;
 }
 
-export { EncodingMode, IEncodingSupport, ILanguageSupport, IReadTextFileEncodingOptions, IReadTextFileOptions, IResolvedTextFileEditorModel, IResourceEncoding, IResourceEncodings, ISaveErrorHandler, ITextFileContent, ITextFileEditorModel, ITextFileEditorModelManager, ITextFileEditorModelResolveOrCreateOptions, ITextFileEditorModelSaveEvent, ITextFileResolveEvent, ITextFileResolveOptions, ITextFileSaveAsOptions, ITextFileSaveEvent, ITextFileSaveOptions, ITextFileSaveParticipant, ITextFileService, ITextFileStreamContent, IWriteTextFileOptions, TextFileEditorModelState, TextFileResolveReason };
+export { EncodingMode, type IEncodingSupport, type ILanguageSupport, type IReadTextFileEncodingOptions, type IReadTextFileOptions, type IResolvedTextFileEditorModel, type IResourceEncoding, type IResourceEncodings, type ISaveErrorHandler, type ITextFileContent, type ITextFileEditorModel, type ITextFileEditorModelManager, type ITextFileEditorModelResolveOrCreateOptions, type ITextFileEditorModelSaveEvent, type ITextFileResolveEvent, type ITextFileResolveOptions, type ITextFileSaveAsOptions, type ITextFileSaveEvent, type ITextFileSaveOptions, type ITextFileSaveParticipant, ITextFileService, type ITextFileStreamContent, type IWriteTextFileOptions, TextFileEditorModelState, TextFileResolveReason };

package/vscode/src/vs/workbench/services/themes/common/workbenchThemeService.d.ts

@@ -17,4 +17,4 @@ interface IThemeExtensionPoint {
     _watch: boolean;
 }
 
-export { IColorCustomizations, IThemeExtensionPoint, IThemeScopedColorCustomizations, VS_DARK_THEME, VS_HC_LIGHT_THEME, VS_HC_THEME, VS_LIGHT_THEME };
+export { type IColorCustomizations, type IThemeExtensionPoint, type IThemeScopedColorCustomizations, VS_DARK_THEME, VS_HC_LIGHT_THEME, VS_HC_THEME, VS_LIGHT_THEME };

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

@@ -9,10 +9,12 @@ import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resou
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { IPathService } from '../../path/common/pathService.js';
 import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
+var UntitledTextEditorInput_1;
 let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractTextResourceEditorInput {
+    static { UntitledTextEditorInput_1 = this; }
     static { this.ID = 'workbench.editors.untitledEditorInput'; }
     get typeId() {
-        return UntitledTextEditorInput.ID;
+        return UntitledTextEditorInput_1.ID;
     }
     get editorId() {
         return DEFAULT_EDITOR_ASSOCIATION.id;
@@ -99,7 +101,7 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
         if (this === otherInput) {
             return true;
         }
-        if (otherInput instanceof UntitledTextEditorInput) {
+        if (otherInput instanceof UntitledTextEditorInput_1) {
             return isEqual(otherInput.resource, this.resource);
         }
         if (isUntitledResourceEditorInput(otherInput)) {
@@ -112,7 +114,7 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
         super.dispose();
     }
 };
-UntitledTextEditorInput = ( __decorate([
+UntitledTextEditorInput = UntitledTextEditorInput_1 = ( __decorate([
     ( __param(1, ITextFileService)),
     ( __param(2, ILabelService)),
     ( __param(3, IEditorService)),

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

@@ -34,4 +34,4 @@ interface IUntitledTextEditorModel extends ITextEditorModel, ILanguageSupport, I
     resolve(): Promise<void>;
 }
 
-export { IUntitledTextEditorModel };
+export type { IUntitledTextEditorModel };