@codingame/monaco-vscode-api 1.83.2 → 1.83.3

package/vscode/src/vs/platform/files/common/fileService.js

@@ -12,7 +12,7 @@ import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
 import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from 'monaco-editor/esm/vs/base/common/stream.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, FilePermission, etag, FileOperationEvent, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
@@ -92,17 +92,13 @@ let FileService = class FileService extends Disposable {
     }
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
-            throw new FileOperationError(localize('invalidPath', "Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 );
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'invalidPath', "Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 );
         }
         await this.activateProvider(resource.scheme);
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
             const error = ( new ErrorNoTelemetry());
-            error.message = ( localize(
-                'noProviderFound',
-                "ENOPRO: No file system provider found for resource '{0}'",
-                ( resource.toString())
-            ));
+            error.message = localizeWithPath('vs/platform/files/common/fileService', 'noProviderFound', "ENOPRO: No file system provider found for resource '{0}'", ( resource.toString()));
             throw error;
         }
         return provider;
@@ -127,7 +123,7 @@ let FileService = class FileService extends Disposable {
         }
         catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
-                throw new FileOperationError(localize('fileNotFoundError', "Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+                throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileNotFoundError', "Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 );
             }
             throw ensureFileSystemProviderError(error);
         }
@@ -234,7 +230,7 @@ let FileService = class FileService extends Disposable {
     }
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
-            throw new FileOperationError(localize('fileExists', "Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 , options);
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileExists', "Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 , options);
         }
     }
     async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), options) {
@@ -288,25 +284,25 @@ let FileService = class FileService extends Disposable {
             this._onDidRunOperation.fire(( new FileOperationEvent(resource, 4 )));
         }
         catch (error) {
-            throw new FileOperationError(localize('err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), writeFileOptions);
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), writeFileOptions);
         }
         return this.resolve(resource, { resolveMetadata: true });
     }
     async validateWriteFile(provider, resource, options) {
         const unlock = !!options?.unlock;
         if (unlock && !((provider.capabilities & 8192) )) {
-            throw new Error(localize('writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
+            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
         }
         const atomic = !!options?.atomic;
         if (atomic) {
             if (!((provider.capabilities & 32768) )) {
-                throw new Error(localize('writeFailedAtomicUnsupported1', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnsupported1', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
             }
             if (!((provider.capabilities & 2) )) {
-                throw new Error(localize('writeFailedAtomicUnsupported2', "Unable to atomically write file '{0}' because provider does not support unbuffered writes.", this.resourceForError(resource)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnsupported2', "Unable to atomically write file '{0}' because provider does not support unbuffered writes.", this.resourceForError(resource)));
             }
             if (unlock) {
-                throw new Error(localize('writeFailedAtomicUnlock', "Unable to unlock file '{0}' because atomic write is enabled.", this.resourceForError(resource)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnlock', "Unable to unlock file '{0}' because atomic write is enabled.", this.resourceForError(resource)));
             }
         }
         let stat = undefined;
@@ -317,13 +313,13 @@ let FileService = class FileService extends Disposable {
             return undefined;
         }
         if ((stat.type & FileType.Directory) !== 0) {
-            throw new FileOperationError(localize('fileIsDirectoryWriteError', "Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileIsDirectoryWriteError', "Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
         }
         this.throwIfFileIsReadonly(resource, stat);
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(localize('fileModifiedError', "File Modified Since"), 3 , options);
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileModifiedError', "File Modified Since"), 3 , options);
         }
         return stat;
     }
@@ -404,12 +400,7 @@ let FileService = class FileService extends Disposable {
         }
     }
     restoreReadError(error, resource, options) {
-        const message = ( localize(
-            'err.read',
-            "Unable to read file '{0}' ({1})",
-            this.resourceForError(resource),
-            ( ensureFileSystemProviderError(error).toString())
-        ));
+        const message = localizeWithPath('vs/platform/files/common/fileService', 'err.read', "Unable to read file '{0}' ({1})", this.resourceForError(resource), ( ensureFileSystemProviderError(error).toString()));
         if (error instanceof NotModifiedSinceFileOperationError) {
             return ( new NotModifiedSinceFileOperationError(message, error.stat, options));
         }
@@ -464,17 +455,17 @@ let FileService = class FileService extends Disposable {
     async validateReadFile(resource, options) {
         const stat = await this.resolve(resource, { resolveMetadata: true });
         if (stat.isDirectory) {
-            throw new FileOperationError(localize('fileIsDirectoryReadError', "Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileIsDirectoryReadError', "Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
         }
         if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw new NotModifiedSinceFileOperationError(localize('fileNotModifiedError', "File not modified since"), stat, options);
+            throw new NotModifiedSinceFileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileNotModifiedError', "File not modified since"), stat, options);
         }
         this.validateReadFileLimits(resource, stat.size, options);
         return stat;
     }
     validateReadFileLimits(resource, size, options) {
         if (typeof options?.limits?.size === 'number' && size > options.limits.size) {
-            throw new TooLargeFileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), 7 , size, options);
+            throw new TooLargeFileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), 7 , size, options);
         }
     }
     async canMove(source, target, overwrite) {
@@ -592,21 +583,21 @@ let FileService = class FileService extends Disposable {
                 isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw new Error(localize('unableToMoveCopyError1', "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system", this.resourceForError(source), this.resourceForError(target)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError1', "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system", this.resourceForError(source), this.resourceForError(target)));
             }
             if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
-                throw new Error(localize('unableToMoveCopyError2', "Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError2', "Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
             }
         }
         const exists = await this.exists(target);
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
-                throw new FileOperationError(localize('unableToMoveCopyError3', "Unable to move/copy '{0}' because target '{1}' already exists at destination.", this.resourceForError(source), this.resourceForError(target)), 4 );
+                throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError3', "Unable to move/copy '{0}' because target '{1}' already exists at destination.", this.resourceForError(source), this.resourceForError(target)), 4 );
             }
             if (sourceProvider === targetProvider) {
                 const { providerExtUri } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
-                    throw new Error(localize('unableToMoveCopyError4', "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
+                    throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError4', "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
                 }
             }
         }
@@ -636,7 +627,7 @@ let FileService = class FileService extends Disposable {
             try {
                 const stat = await provider.stat(directory);
                 if ((stat.type & FileType.Directory) === 0) {
-                    throw new Error(localize('mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
+                    throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
                 }
                 break;
             }
@@ -673,14 +664,14 @@ let FileService = class FileService extends Disposable {
         const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
         const useTrash = !!options?.useTrash;
         if (useTrash && !((provider.capabilities & 4096) )) {
-            throw new Error(localize('deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
+            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
         }
         const atomic = options?.atomic;
         if (atomic && !((provider.capabilities & 65536) )) {
-            throw new Error(localize('deleteFailedAtomicUnsupported', "Unable to delete file '{0}' atomically because provider does not support it.", this.resourceForError(resource)));
+            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedAtomicUnsupported', "Unable to delete file '{0}' atomically because provider does not support it.", this.resourceForError(resource)));
         }
         if (useTrash && atomic) {
-            throw new Error(localize('deleteFailedTrashAndAtomicUnsupported', "Unable to atomically delete file '{0}' because using trash is enabled.", this.resourceForError(resource)));
+            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedTrashAndAtomicUnsupported', "Unable to atomically delete file '{0}' because using trash is enabled.", this.resourceForError(resource)));
         }
         let stat = undefined;
         try {
@@ -692,13 +683,13 @@ let FileService = class FileService extends Disposable {
             this.throwIfFileIsReadonly(resource, stat);
         }
         else {
-            throw new FileOperationError(localize('deleteFailedNotFound', "Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedNotFound', "Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 );
         }
         const recursive = !!options?.recursive;
         if (!recursive) {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
-                throw new Error(localize('deleteFailedNonEmptyFolder', "Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
+                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedNonEmptyFolder', "Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
             }
         }
         return provider;
@@ -933,13 +924,13 @@ let FileService = class FileService extends Disposable {
     }
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & 2048 ) {
-            throw new FileOperationError(localize('err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
         }
         return provider;
     }
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
-            throw new FileOperationError(localize('err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
+            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
         }
     }
     resourceForError(resource) {

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

@@ -1,5 +1,5 @@
 import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 var FileType;
 ( (function(FileType) {
     FileType[FileType["Unknown"] = 0] = "Unknown";
@@ -44,18 +44,18 @@ class ByteSize {
             size = 0;
         }
         if (size < ByteSize.KB) {
-            return ( localize('sizeB', "{0}B", size.toFixed(0)));
+            return localizeWithPath('vs/platform/files/common/files', 'sizeB', "{0}B", size.toFixed(0));
         }
         if (size < ByteSize.MB) {
-            return ( localize('sizeKB', "{0}KB", (size / ByteSize.KB).toFixed(2)));
+            return localizeWithPath('vs/platform/files/common/files', 'sizeKB', "{0}KB", (size / ByteSize.KB).toFixed(2));
         }
         if (size < ByteSize.GB) {
-            return ( localize('sizeMB', "{0}MB", (size / ByteSize.MB).toFixed(2)));
+            return localizeWithPath('vs/platform/files/common/files', 'sizeMB', "{0}MB", (size / ByteSize.MB).toFixed(2));
         }
         if (size < ByteSize.TB) {
-            return ( localize('sizeGB', "{0}GB", (size / ByteSize.GB).toFixed(2)));
+            return localizeWithPath('vs/platform/files/common/files', 'sizeGB', "{0}GB", (size / ByteSize.GB).toFixed(2));
         }
-        return ( localize('sizeTB', "{0}TB", (size / ByteSize.TB).toFixed(2)));
+        return localizeWithPath('vs/platform/files/common/files', 'sizeTB', "{0}TB", (size / ByteSize.TB).toFixed(2));
     }
 }
 export { ByteSize, FileChangeType, FilePermission, FileSystemProviderCapabilities, FileType };

package/vscode/src/vs/platform/files/common/io.js

@@ -1,6 +1,6 @@
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 async function readFileIntoStream(provider, resource, target, transformer, options, token) {
     let error = undefined;
@@ -68,7 +68,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(localizeWithPath('vs/platform/files/common/io', 'fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

package/vscode/src/vs/platform/keyboardLayout/common/keyboardConfig.js

@@ -13,27 +13,21 @@ const keyboardConfiguration = {
     'id': 'keyboard',
     'order': 15,
     'type': 'object',
-    'title': ( nls.localize('keyboardConfigurationTitle', "Keyboard")),
+    'title': nls.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', 'keyboardConfigurationTitle', "Keyboard"),
     'properties': {
         'keyboard.dispatch': {
             scope: 1 ,
             type: 'string',
             enum: ['code', 'keyCode'],
             default: 'code',
-            markdownDescription: ( nls.localize(
-                'dispatch',
-                "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."
-            )),
+            markdownDescription: nls.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', 'dispatch', "Controls the dispatching logic for key presses to use either `code` (recommended) or `keyCode`."),
             included: OS === 2  || OS === 3
         },
         'keyboard.mapAltGrToCtrlAlt': {
             scope: 1 ,
             type: 'boolean',
             default: false,
-            markdownDescription: ( nls.localize(
-                'mapAltGrToCtrlAlt',
-                "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."
-            )),
+            markdownDescription: nls.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', 'mapAltGrToCtrlAlt', "Controls if the AltGraph+ modifier should be treated as Ctrl+Alt+."),
             included: OS === 1
         }
     }

package/vscode/src/vs/platform/quickinput/browser/commandsQuickAccess.js

@@ -0,0 +1,300 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
+import { normalizeTfIdfScores, TfIdfCalculator } from '../../../base/common/tfIdf.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { PickerQuickAccessProvider } from './pickerQuickAccess.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IDialogService } from '../../dialogs/common/dialogs.js';
+var AbstractCommandsQuickAccessProvider_1, CommandsHistory_1;
+let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
+    static { AbstractCommandsQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '>'; }
+    static { this.TFIDF_THRESHOLD = 0.5; }
+    static { this.TFIDF_MAX_RESULTS = 5; }
+    static { this.WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString); }
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(AbstractCommandsQuickAccessProvider_1.PREFIX, options);
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.dialogService = dialogService;
+        this.commandsHistory = this._register(this.instantiationService.createInstance(CommandsHistory));
+        this.options = options;
+    }
+    async _getPicks(filter, _disposables, token, runOptions) {
+        const allCommandPicks = await this.getCommandPicks(token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const runTfidf = createSingleCallFunction(() => {
+            const tfidf = ( new TfIdfCalculator());
+            tfidf.updateDocuments(( allCommandPicks.map(commandPick => ({
+                key: commandPick.commandId,
+                textChunks: [commandPick.label + (commandPick.commandAlias ? ` ${commandPick.commandAlias}` : '')]
+            }))));
+            const result = tfidf.calculateScores(filter, token);
+            return normalizeTfIdfScores(result)
+                .filter(score => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD)
+                .slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
+        });
+        const filteredCommandPicks = [];
+        for (const commandPick of allCommandPicks) {
+            const labelHighlights = AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.label) ?? undefined;
+            const aliasHighlights = commandPick.commandAlias ? AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.commandAlias) ?? undefined : undefined;
+            if (labelHighlights || aliasHighlights) {
+                commandPick.highlights = {
+                    label: labelHighlights,
+                    detail: this.options.showAlias ? aliasHighlights : undefined
+                };
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter === commandPick.commandId) {
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter.length >= 3) {
+                const tfidf = runTfidf();
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const tfidfScore = tfidf.find(score => score.key === commandPick.commandId);
+                if (tfidfScore) {
+                    commandPick.tfIdfScore = tfidfScore.score;
+                    filteredCommandPicks.push(commandPick);
+                }
+            }
+        }
+        const mapLabelToCommand = ( new Map());
+        for (const commandPick of filteredCommandPicks) {
+            const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
+            if (existingCommandForLabel) {
+                commandPick.description = commandPick.commandId;
+                existingCommandForLabel.description = existingCommandForLabel.commandId;
+            }
+            else {
+                mapLabelToCommand.set(commandPick.label, commandPick);
+            }
+        }
+        filteredCommandPicks.sort((commandPickA, commandPickB) => {
+            if (commandPickA.tfIdfScore && commandPickB.tfIdfScore) {
+                if (commandPickA.tfIdfScore === commandPickB.tfIdfScore) {
+                    return commandPickA.label.localeCompare(commandPickB.label);
+                }
+                return commandPickB.tfIdfScore - commandPickA.tfIdfScore;
+            }
+            else if (commandPickA.tfIdfScore) {
+                return 1;
+            }
+            else if (commandPickB.tfIdfScore) {
+                return -1;
+            }
+            const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
+            const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
+            if (commandACounter && commandBCounter) {
+                return commandACounter > commandBCounter ? -1 : 1;
+            }
+            if (commandACounter) {
+                return -1;
+            }
+            if (commandBCounter) {
+                return 1;
+            }
+            if (this.options.suggestedCommandIds) {
+                const commandASuggestion = ( this.options.suggestedCommandIds.has(commandPickA.commandId));
+                const commandBSuggestion = ( this.options.suggestedCommandIds.has(commandPickB.commandId));
+                if (commandASuggestion && commandBSuggestion) {
+                    return 0;
+                }
+                if (commandASuggestion) {
+                    return -1;
+                }
+                if (commandBSuggestion) {
+                    return 1;
+                }
+            }
+            return commandPickA.label.localeCompare(commandPickB.label);
+        });
+        const commandPicks = [];
+        let addOtherSeparator = false;
+        let addSuggestedSeparator = true;
+        let addCommonlyUsedSeparator = !!this.options.suggestedCommandIds;
+        for (let i = 0; i < filteredCommandPicks.length; i++) {
+            const commandPick = filteredCommandPicks[i];
+            if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'recentlyUsed', "recently used") });
+                addOtherSeparator = true;
+            }
+            if (addSuggestedSeparator && commandPick.tfIdfScore !== undefined) {
+                commandPicks.push({ type: 'separator', label: localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'suggested', "similar commands") });
+                addSuggestedSeparator = false;
+            }
+            if (addCommonlyUsedSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'commonlyUsed', "commonly used") });
+                addOtherSeparator = true;
+                addCommonlyUsedSeparator = false;
+            }
+            if (addOtherSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && !this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'morecCommands', "other commands") });
+                addOtherSeparator = false;
+            }
+            commandPicks.push(this.toCommandPick(commandPick, runOptions));
+        }
+        if (!this.hasAdditionalCommandPicks(filter, token)) {
+            return commandPicks;
+        }
+        return {
+            picks: commandPicks,
+            additionalPicks: (async () => {
+                const additionalCommandPicks = await this.getAdditionalCommandPicks(allCommandPicks, filteredCommandPicks, filter, token);
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const commandPicks = ( additionalCommandPicks.map(commandPick => this.toCommandPick(commandPick, runOptions)));
+                if (addSuggestedSeparator && commandPicks[0]?.type !== 'separator') {
+                    commandPicks.unshift({ type: 'separator', label: localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'suggested', "similar commands") });
+                }
+                return commandPicks;
+            })()
+        };
+    }
+    toCommandPick(commandPick, runOptions) {
+        if (commandPick.type === 'separator') {
+            return commandPick;
+        }
+        const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
+        const ariaLabel = keybinding ?
+            localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'commandPickAriaLabelWithKeybinding', "{0}, {1}", commandPick.label, keybinding.getAriaLabel()) :
+            commandPick.label;
+        return {
+            ...commandPick,
+            ariaLabel,
+            detail: this.options.showAlias && commandPick.commandAlias !== commandPick.label ? commandPick.commandAlias : undefined,
+            keybinding,
+            accept: async () => {
+                this.commandsHistory.push(commandPick.commandId);
+                this.telemetryService.publicLog2('workbenchActionExecuted', {
+                    id: commandPick.commandId,
+                    from: runOptions?.from ?? 'quick open'
+                });
+                try {
+                    commandPick.args?.length
+                        ? await this.commandService.executeCommand(commandPick.commandId, ...commandPick.args)
+                        : await this.commandService.executeCommand(commandPick.commandId);
+                }
+                catch (error) {
+                    if (!isCancellationError(error)) {
+                        this.dialogService.error(localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'canNotRun', "Command '{0}' resulted in an error", commandPick.label), toErrorMessage(error));
+                    }
+                }
+            }
+        };
+    }
+};
+AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IDialogService))
+], AbstractCommandsQuickAccessProvider));
+let CommandsHistory = class CommandsHistory extends Disposable {
+    static { CommandsHistory_1 = this; }
+    static { this.DEFAULT_COMMANDS_HISTORY_LENGTH = 50; }
+    static { this.PREF_KEY_CACHE = 'commandPalette.mru.cache'; }
+    static { this.PREF_KEY_COUNTER = 'commandPalette.mru.counter'; }
+    static { this.counter = 1; }
+    constructor(storageService, configurationService) {
+        super();
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.configuredCommandsHistoryLength = 0;
+        this.updateConfiguration();
+        this.load();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
+    }
+    updateConfiguration(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.history')) {
+            return;
+        }
+        this.configuredCommandsHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(this.configurationService);
+        if (CommandsHistory_1.cache && CommandsHistory_1.cache.limit !== this.configuredCommandsHistoryLength) {
+            CommandsHistory_1.cache.limit = this.configuredCommandsHistoryLength;
+            CommandsHistory_1.saveState(this.storageService);
+        }
+    }
+    load() {
+        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
+        let serializedCache;
+        if (raw) {
+            try {
+                serializedCache = JSON.parse(raw);
+            }
+            catch (error) {
+            }
+        }
+        const cache = CommandsHistory_1.cache = ( new LRUCache(this.configuredCommandsHistoryLength, 1));
+        if (serializedCache) {
+            let entries;
+            if (serializedCache.usesLRU) {
+                entries = serializedCache.entries;
+            }
+            else {
+                entries = serializedCache.entries.sort((a, b) => a.value - b.value);
+            }
+            entries.forEach(entry => cache.set(entry.key, entry.value));
+        }
+        CommandsHistory_1.counter = this.storageService.getNumber(CommandsHistory_1.PREF_KEY_COUNTER, 0 , CommandsHistory_1.counter);
+    }
+    push(commandId) {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        CommandsHistory_1.cache.set(commandId, CommandsHistory_1.counter++);
+        CommandsHistory_1.saveState(this.storageService);
+    }
+    peek(commandId) {
+        return CommandsHistory_1.cache?.peek(commandId);
+    }
+    static saveState(storageService) {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        const serializedCache = { usesLRU: true, entries: [] };
+        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
+        storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
+        storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
+    }
+    static getConfiguredCommandHistoryLength(configurationService) {
+        const config = configurationService.getValue();
+        const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
+        if (typeof configuredCommandHistoryLength === 'number') {
+            return configuredCommandHistoryLength;
+        }
+        return CommandsHistory_1.DEFAULT_COMMANDS_HISTORY_LENGTH;
+    }
+    static clearHistory(configurationService, storageService) {
+        const commandHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(configurationService);
+        CommandsHistory_1.cache = ( new LRUCache(commandHistoryLength));
+        CommandsHistory_1.counter = 1;
+        CommandsHistory_1.saveState(storageService);
+    }
+};
+CommandsHistory = CommandsHistory_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IConfigurationService))
+], CommandsHistory));
+export { AbstractCommandsQuickAccessProvider, CommandsHistory };