@codingame/monaco-vscode-api 1.83.5 → 1.83.6

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -0,0 +1,404 @@
+import { Throttler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { DBClosedError } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
+import { BroadcastDataChannel } from '../../../base/browser/broadcast.js';
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileNotExists',
+    "File does not exist"
+)), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileIsDirectory',
+    "File is Directory"
+)), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileNotDirectory',
+    "File is not a directory"
+)), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'dirIsNotEmpty',
+    "Directory is not empty"
+)), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'fileExceedsStorageQuota',
+    "File exceeds available storage quota"
+)), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localizeWithPath(
+    'vs/platform/files/browser/indexedDBFileSystemProvider',
+    'internal',
+    "Internal error occurred in IndexedDB File System Provider. ({0})",
+    message
+)), FileSystemProviderErrorCode.Unknown);
+class IndexedDBFileSystemNode {
+    constructor(entry) {
+        this.entry = entry;
+        this.type = entry.type;
+    }
+    read(path) {
+        return this.doRead(path.split('/').filter(p => p.length));
+    }
+    doRead(pathParts) {
+        if (pathParts.length === 0) {
+            return this.entry;
+        }
+        if (this.entry.type !== FileType.Directory) {
+            throw ERR_UNKNOWN_INTERNAL('Internal error reading from IndexedDBFSNode -- expected directory at ' + this.entry.path);
+        }
+        const next = this.entry.children.get(pathParts[0]);
+        if (!next) {
+            return undefined;
+        }
+        return next.doRead(pathParts.slice(1));
+    }
+    delete(path) {
+        const toDelete = path.split('/').filter(p => p.length);
+        if (toDelete.length === 0) {
+            if (this.entry.type !== FileType.Directory) {
+                throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode. Expected root entry to be directory`);
+            }
+            this.entry.children.clear();
+        }
+        else {
+            return this.doDelete(toDelete, path);
+        }
+    }
+    doDelete(pathParts, originalPath) {
+        if (pathParts.length === 0) {
+            throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode -- got no deletion path parts (encountered while deleting ${originalPath})`);
+        }
+        else if (this.entry.type !== FileType.Directory) {
+            throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected directory at ' + this.entry.path);
+        }
+        else if (pathParts.length === 1) {
+            this.entry.children.delete(pathParts[0]);
+        }
+        else {
+            const next = this.entry.children.get(pathParts[0]);
+            if (!next) {
+                throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected entry at ' + this.entry.path + '/' + next);
+            }
+            next.doDelete(pathParts.slice(1), originalPath);
+        }
+    }
+    add(path, entry) {
+        this.doAdd(path.split('/').filter(p => p.length), entry, path);
+    }
+    doAdd(pathParts, entry, originalPath) {
+        if (pathParts.length === 0) {
+            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- adding empty path (encountered while adding ${originalPath})`);
+        }
+        else if (this.entry.type !== FileType.Directory) {
+            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- parent is not a directory (encountered while adding ${originalPath})`);
+        }
+        else if (pathParts.length === 1) {
+            const next = pathParts[0];
+            const existing = this.entry.children.get(next);
+            if (entry.type === 'dir') {
+                if (existing?.entry.type === FileType.File) {
+                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+                }
+                this.entry.children.set(next, existing ?? ( new IndexedDBFileSystemNode({
+                    type: FileType.Directory,
+                    path: this.entry.path + '/' + next,
+                    children: ( new Map()),
+                })));
+            }
+            else {
+                if (existing?.entry.type === FileType.Directory) {
+                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting directory with file: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+                }
+                this.entry.children.set(next, ( new IndexedDBFileSystemNode({
+                    type: FileType.File,
+                    path: this.entry.path + '/' + next,
+                    size: entry.size,
+                })));
+            }
+        }
+        else if (pathParts.length > 1) {
+            const next = pathParts[0];
+            let childNode = this.entry.children.get(next);
+            if (!childNode) {
+                childNode = ( new IndexedDBFileSystemNode({
+                    children: ( new Map()),
+                    path: this.entry.path + '/' + next,
+                    type: FileType.Directory
+                }));
+                this.entry.children.set(next, childNode);
+            }
+            else if (childNode.type === FileType.File) {
+                throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file entry with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
+            }
+            childNode.doAdd(pathParts.slice(1), entry, originalPath);
+        }
+    }
+    print(indentation = '') {
+        console.log(indentation + this.entry.path);
+        if (this.entry.type === FileType.Directory) {
+            this.entry.children.forEach(child => child.print(indentation + ' '));
+        }
+    }
+}
+class IndexedDBFileSystemProvider extends Disposable {
+    constructor(scheme, indexedDB, store, watchCrossWindowChanges) {
+        super();
+        this.scheme = scheme;
+        this.indexedDB = indexedDB;
+        this.store = store;
+        this.capabilities = 2
+            | 1024 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.extUri = ( new ExtUri(() => false)) ;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._onReportError = this._register(( new Emitter()));
+        this.onReportError = this._onReportError.event;
+        this.mtimes = ( new Map());
+        this.fileWriteBatch = [];
+        this.writeManyThrottler = ( new Throttler());
+        if (watchCrossWindowChanges) {
+            this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`)));
+            this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
+                this._onDidChangeFile.fire(( changes.map(c => ({ type: c.type, resource: URI.revive(c.resource) }))));
+            }));
+        }
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    async mkdir(resource) {
+        try {
+            const resourceStat = await this.stat(resource);
+            if (resourceStat.type === FileType.File) {
+                throw ERR_FILE_NOT_DIR;
+            }
+        }
+        catch (error) {  }
+        (await this.getFiletree()).add(resource.path, { type: 'dir' });
+    }
+    async stat(resource) {
+        const entry = (await this.getFiletree()).read(resource.path);
+        if (entry?.type === FileType.File) {
+            return {
+                type: FileType.File,
+                ctime: 0,
+                mtime: this.mtimes.get(( resource.toString())) || 0,
+                size: entry.size ?? (await this.readFile(resource)).byteLength
+            };
+        }
+        if (entry?.type === FileType.Directory) {
+            return {
+                type: FileType.Directory,
+                ctime: 0,
+                mtime: 0,
+                size: 0
+            };
+        }
+        throw ERR_FILE_NOT_FOUND;
+    }
+    async readdir(resource) {
+        try {
+            const entry = (await this.getFiletree()).read(resource.path);
+            if (!entry) {
+                return [];
+            }
+            if (entry.type !== FileType.Directory) {
+                throw ERR_FILE_NOT_DIR;
+            }
+            else {
+                return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
+            }
+        }
+        catch (error) {
+            this.reportError('readDir', error);
+            throw error;
+        }
+    }
+    async readFile(resource) {
+        try {
+            const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.get(resource.path));
+            if (result === undefined) {
+                throw ERR_FILE_NOT_FOUND;
+            }
+            const buffer = result instanceof Uint8Array ? result : isString(result) ? VSBuffer.fromString(result).buffer : undefined;
+            if (buffer === undefined) {
+                throw ERR_UNKNOWN_INTERNAL(`IndexedDB entry at "${resource.path}" in unexpected format`);
+            }
+            const fileTree = await this.getFiletree();
+            fileTree.add(resource.path, { type: 'file', size: buffer.byteLength });
+            return buffer;
+        }
+        catch (error) {
+            this.reportError('readFile', error);
+            throw error;
+        }
+    }
+    async writeFile(resource, content, opts) {
+        try {
+            const existing = await this.stat(resource).catch(() => undefined);
+            if (existing?.type === FileType.Directory) {
+                throw ERR_FILE_IS_DIR;
+            }
+            await this.bulkWrite([[resource, content]]);
+        }
+        catch (error) {
+            this.reportError('writeFile', error);
+            throw error;
+        }
+    }
+    async rename(from, to, opts) {
+        const fileTree = await this.getFiletree();
+        const fromEntry = fileTree.read(from.path);
+        if (!fromEntry) {
+            throw ERR_FILE_NOT_FOUND;
+        }
+        const toEntry = fileTree.read(to.path);
+        if (toEntry) {
+            if (!opts.overwrite) {
+                throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+            }
+            if (toEntry.type !== fromEntry.type) {
+                throw createFileSystemProviderError('Cannot rename files with different types', FileSystemProviderErrorCode.Unknown);
+            }
+            await this.delete(to, { recursive: true, useTrash: false, atomic: false });
+        }
+        const toTargetResource = (path) => this.extUri.joinPath(to, this.extUri.relativePath(from, from.with({ path })) || '');
+        const sourceEntries = await this.tree(from);
+        const sourceFiles = [];
+        for (const sourceEntry of sourceEntries) {
+            if (sourceEntry[1] === FileType.File) {
+                sourceFiles.push(sourceEntry);
+            }
+            else if (sourceEntry[1] === FileType.Directory) {
+                fileTree.add(toTargetResource(sourceEntry[0]).path, { type: 'dir' });
+            }
+        }
+        if (sourceFiles.length) {
+            const targetFiles = [];
+            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
+            for (let index = 0; index < sourceFiles.length; index++) {
+                const content = sourceFilesContents[index] instanceof Uint8Array ? sourceFilesContents[index] : isString(sourceFilesContents[index]) ? VSBuffer.fromString(sourceFilesContents[index]).buffer : undefined;
+                if (content) {
+                    targetFiles.push([toTargetResource(sourceFiles[index][0]), content]);
+                }
+            }
+            await this.bulkWrite(targetFiles);
+        }
+        await this.delete(from, { recursive: true, useTrash: false, atomic: false });
+    }
+    async delete(resource, opts) {
+        let stat;
+        try {
+            stat = await this.stat(resource);
+        }
+        catch (e) {
+            if (e.code === FileSystemProviderErrorCode.FileNotFound) {
+                return;
+            }
+            throw e;
+        }
+        let toDelete;
+        if (opts.recursive) {
+            const tree = await this.tree(resource);
+            toDelete = ( tree.map(([path]) => path));
+        }
+        else {
+            if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
+                throw ERR_DIR_NOT_EMPTY;
+            }
+            toDelete = [resource.path];
+        }
+        await this.deleteKeys(toDelete);
+        (await this.getFiletree()).delete(resource.path);
+        toDelete.forEach(key => this.mtimes.delete(key));
+        this.triggerChanges(( toDelete.map(
+            path => ({ resource: resource.with({ path }), type: 2  })
+        )));
+    }
+    async tree(resource) {
+        const stat = await this.stat(resource);
+        const allEntries = [[resource.path, stat.type]];
+        if (stat.type === FileType.Directory) {
+            const dirEntries = await this.readdir(resource);
+            for (const [key, type] of dirEntries) {
+                const childResource = this.extUri.joinPath(resource, key);
+                allEntries.push([childResource.path, type]);
+                if (type === FileType.Directory) {
+                    const childEntries = await this.tree(childResource);
+                    allEntries.push(...childEntries);
+                }
+            }
+        }
+        return allEntries;
+    }
+    triggerChanges(changes) {
+        if (changes.length) {
+            this._onDidChangeFile.fire(changes);
+            this.changesBroadcastChannel?.postData(changes);
+        }
+    }
+    getFiletree() {
+        if (!this.cachedFiletree) {
+            this.cachedFiletree = (async () => {
+                const rootNode = ( new IndexedDBFileSystemNode({
+                    children: ( new Map()),
+                    path: '',
+                    type: FileType.Directory
+                }));
+                const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.getAllKeys());
+                const keys = ( result.map(key => ( key.toString())));
+                keys.forEach(key => rootNode.add(key, { type: 'file' }));
+                return rootNode;
+            })();
+        }
+        return this.cachedFiletree;
+    }
+    async bulkWrite(files) {
+        files.forEach(([resource, content]) => this.fileWriteBatch.push({ content, resource }));
+        await this.writeManyThrottler.queue(() => this.writeMany());
+        const fileTree = await this.getFiletree();
+        for (const [resource, content] of files) {
+            fileTree.add(resource.path, { type: 'file', size: content.byteLength });
+            this.mtimes.set(( resource.toString()), Date.now());
+        }
+        this.triggerChanges(( files.map(([resource]) => ({ resource, type: 0  }))));
+    }
+    async writeMany() {
+        if (this.fileWriteBatch.length) {
+            const fileBatch = this.fileWriteBatch.splice(0, this.fileWriteBatch.length);
+            try {
+                await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( fileBatch.map(entry => {
+                    return objectStore.put(entry.content, entry.resource.path);
+                })));
+            }
+            catch (ex) {
+                if (ex instanceof DOMException && ex.name === 'QuotaExceededError') {
+                    throw ERR_FILE_EXCEEDS_STORAGE_QUOTA;
+                }
+                throw ex;
+            }
+        }
+    }
+    async deleteKeys(keys) {
+        if (keys.length) {
+            await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( keys.map(key => objectStore.delete(key))));
+        }
+    }
+    async reset() {
+        await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => objectStore.clear());
+    }
+    reportError(operation, error) {
+        this._onReportError.fire({ scheme: this.scheme, operation, code: error instanceof FileSystemProviderError || error instanceof DBClosedError ? error.code : 'unknown' });
+    }
+}
+export { IndexedDBFileSystemProvider };

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

@@ -98,7 +98,12 @@ let FileService = class FileService extends Disposable {
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
             const error = ( new ErrorNoTelemetry());
-            error.message = localizeWithPath('vs/platform/files/common/fileService', '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;
@@ -400,7 +405,13 @@ let FileService = class FileService extends Disposable {
         }
     }
     restoreReadError(error, resource, options) {
-        const message = localizeWithPath('vs/platform/files/common/fileService', '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));
         }

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

@@ -44,18 +44,38 @@ class ByteSize {
             size = 0;
         }
         if (size < ByteSize.KB) {
-            return localizeWithPath('vs/platform/files/common/files', 'sizeB', "{0}B", size.toFixed(0));
+            return ( localizeWithPath('vs/platform/files/common/files', 'sizeB', "{0}B", size.toFixed(0)));
         }
         if (size < ByteSize.MB) {
-            return localizeWithPath('vs/platform/files/common/files', '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 localizeWithPath('vs/platform/files/common/files', '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 localizeWithPath('vs/platform/files/common/files', 'sizeGB', "{0}GB", (size / ByteSize.GB).toFixed(2));
+            return ( localizeWithPath(
+                'vs/platform/files/common/files',
+                'sizeGB',
+                "{0}GB",
+                (size / ByteSize.GB).toFixed(2)
+            ));
         }
-        return localizeWithPath('vs/platform/files/common/files', '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/keyboardLayout/common/keyboardConfig.js

@@ -13,21 +13,33 @@ const keyboardConfiguration = {
     'id': 'keyboard',
     'order': 15,
     'type': 'object',
-    'title': nls.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', '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.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', '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.localizeWithPath('vs/platform/keyboardLayout/common/keyboardConfig', '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

@@ -132,20 +132,36 @@ let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
         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") });
+                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") });
+                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") });
+                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") });
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'morecCommands',
+                    "other commands"
+                )) });
                 addOtherSeparator = false;
             }
             commandPicks.push(this.toCommandPick(commandPick, runOptions));
@@ -162,7 +178,11 @@ let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
                 }
                 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") });
+                    commandPicks.unshift({ type: 'separator', label: ( localizeWithPath(
+                        'vs/platform/quickinput/browser/commandsQuickAccess',
+                        'suggested',
+                        "similar commands"
+                    )) });
                 }
                 return commandPicks;
             })()
@@ -174,7 +194,13 @@ let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
         }
         const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
         const ariaLabel = keybinding ?
-            localizeWithPath('vs/platform/quickinput/browser/commandsQuickAccess', 'commandPickAriaLabelWithKeybinding', "{0}, {1}", commandPick.label, keybinding.getAriaLabel()) :
+            ( localizeWithPath(
+                'vs/platform/quickinput/browser/commandsQuickAccess',
+                'commandPickAriaLabelWithKeybinding',
+                "{0}, {1}",
+                commandPick.label,
+                keybinding.getAriaLabel()
+            )) :
             commandPick.label;
         return {
             ...commandPick,
@@ -194,7 +220,12 @@ let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
                 }
                 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));
+                        this.dialogService.error(( localizeWithPath(
+                            'vs/platform/quickinput/browser/commandsQuickAccess',
+                            'canNotRun',
+                            "Command '{0}' resulted in an error",
+                            commandPick.label
+                        )), toErrorMessage(error));
                     }
                 }
             }

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

@@ -46,7 +46,13 @@ let HelpQuickAccessProvider = class HelpQuickAccessProvider {
                 prefix,
                 label,
                 keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
-                ariaLabel: localizeWithPath('vs/platform/quickinput/browser/helpQuickAccess', 'helpPickAriaLabel', "{0}, {1}", label, helpEntry.description),
+                ariaLabel: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/helpQuickAccess',
+                    'helpPickAriaLabel',
+                    "{0}, {1}",
+                    label,
+                    helpEntry.description
+                )),
                 description: helpEntry.description
             };
         }));

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

@@ -29,7 +29,7 @@ class AbstractRequestService extends Disposable {
         super();
         this.counter = 0;
         this.logger = loggerService.createLogger('network', {
-            name: localizeWithPath('vs/platform/request/common/request', 'request', "Network Requests"),
+            name: ( localizeWithPath('vs/platform/request/common/request', 'request', "Network Requests")),
             when: ( CONTEXT_LOG_LEVEL.isEqualTo(LogLevelToString(LogLevel.Trace))).serialize()
         });
     }