@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/files/common/files.js

@@ -10,134 +10,111 @@ import { InputFocusedContextKey } from '../../../../platform/contextkey/common/c
 import { Event } from '../../../../base/common/event.js';
 import { localizeWithPath } from '../../../../nls.js';
 var TextFileContentProvider_1;
+const _moduleId = "vs/workbench/contrib/files/common/files";
 const VIEWLET_ID = 'workbench.view.explorer';
 const VIEW_ID = 'workbench.explorer.fileView';
-const ExplorerViewletVisibleContext = ( new RawContextKey(
+const ExplorerViewletVisibleContext = ( (new RawContextKey(
     'explorerViewletVisible',
     true,
-    { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerViewletVisible',
-        "True when the EXPLORER viewlet is visible."
-    )) }
-));
-const FoldersViewVisibleContext = ( new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localizeWithPath(
-    'vs/workbench/contrib/files/common/files',
-    'foldersViewVisible',
+    { type: 'boolean', description: ( localizeWithPath(_moduleId, 0, "True when the EXPLORER viewlet is visible.")) }
+)));
+const FoldersViewVisibleContext = ( (new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localizeWithPath(
+    _moduleId,
+    1,
     "True when the FOLDERS view (the file tree within the explorer view container) is visible."
-)) }));
-const ExplorerFolderContext = ( new RawContextKey(
+)) })));
+const ExplorerFolderContext = ( (new RawContextKey(
     'explorerResourceIsFolder',
     false,
-    { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerResourceIsFolder',
-        "True when the focused item in the EXPLORER is a folder."
-    )) }
-));
-const ExplorerResourceReadonlyContext = ( new RawContextKey(
+    { type: 'boolean', description: ( localizeWithPath(_moduleId, 2, "True when the focused item in the EXPLORER is a folder.")) }
+)));
+const ExplorerResourceReadonlyContext = ( (new RawContextKey(
     'explorerResourceReadonly',
     false,
-    { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerResourceReadonly',
-        "True when the focused item in the EXPLORER is read-only."
-    )) }
-));
-const ExplorerResourceNotReadonlyContext = ( ExplorerResourceReadonlyContext.toNegated());
-const ExplorerResourceAvailableEditorIdsContext = ( new RawContextKey('explorerResourceAvailableEditorIds', ''));
-const ExplorerRootContext = ( new RawContextKey(
+    { type: 'boolean', description: ( localizeWithPath(_moduleId, 3, "True when the focused item in the EXPLORER is read-only.")) }
+)));
+const ExplorerResourceNotReadonlyContext = ( (ExplorerResourceReadonlyContext.toNegated()));
+const ExplorerResourceAvailableEditorIdsContext = ( (new RawContextKey('explorerResourceAvailableEditorIds', '')));
+const ExplorerRootContext = ( (new RawContextKey(
     'explorerResourceIsRoot',
     false,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerResourceIsRoot',
+        _moduleId,
+        4,
         "True when the focused item in the EXPLORER is a root folder."
     )) }
-));
-const ExplorerResourceCut = ( new RawContextKey(
+)));
+const ExplorerResourceCut = ( (new RawContextKey(
     'explorerResourceCut',
     false,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerResourceCut',
+        _moduleId,
+        5,
         "True when an item in the EXPLORER has been cut for cut and paste."
     )) }
-));
-const ExplorerResourceMoveableToTrash = ( new RawContextKey(
+)));
+const ExplorerResourceMoveableToTrash = ( (new RawContextKey(
     'explorerResourceMoveableToTrash',
     false,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerResourceMoveableToTrash',
+        _moduleId,
+        6,
         "True when the focused item in the EXPLORER can be moved to trash."
     )) }
-));
-const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localizeWithPath(
-    'vs/workbench/contrib/files/common/files',
-    'filesExplorerFocus',
-    "True when the focus is inside the EXPLORER view."
-)) }));
-const OpenEditorsFocusedContext = ( new RawContextKey('openEditorsFocus', true, { type: 'boolean', description: ( localizeWithPath(
-    'vs/workbench/contrib/files/common/files',
-    'openEditorsFocus',
-    "True when the focus is inside the OPEN EDITORS view."
-)) }));
-const ExplorerFocusedContext = ( new RawContextKey(
+)));
+const FilesExplorerFocusedContext = ( (new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localizeWithPath(_moduleId, 7, "True when the focus is inside the EXPLORER view.")) })));
+const OpenEditorsFocusedContext = ( (new RawContextKey('openEditorsFocus', true, { type: 'boolean', description: ( localizeWithPath(_moduleId, 8, "True when the focus is inside the OPEN EDITORS view.")) })));
+const ExplorerFocusedContext = ( (new RawContextKey(
     'explorerViewletFocus',
     true,
-    { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerViewletFocus',
-        "True when the focus is inside the EXPLORER viewlet."
-    )) }
-));
-const ExplorerCompressedFocusContext = ( new RawContextKey(
+    { type: 'boolean', description: ( localizeWithPath(_moduleId, 9, "True when the focus is inside the EXPLORER viewlet.")) }
+)));
+const ExplorerCompressedFocusContext = ( (new RawContextKey(
     'explorerViewletCompressedFocus',
     true,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerViewletCompressedFocus',
+        _moduleId,
+        10,
         "True when the focused item in the EXPLORER view is a compact item."
     )) }
-));
-const ExplorerCompressedFirstFocusContext = ( new RawContextKey(
+)));
+const ExplorerCompressedFirstFocusContext = ( (new RawContextKey(
     'explorerViewletCompressedFirstFocus',
     true,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerViewletCompressedFirstFocus',
+        _moduleId,
+        11,
         "True when the focus is inside a compact item's first part in the EXPLORER view."
     )) }
-));
-const ExplorerCompressedLastFocusContext = ( new RawContextKey(
+)));
+const ExplorerCompressedLastFocusContext = ( (new RawContextKey(
     'explorerViewletCompressedLastFocus',
     true,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'explorerViewletCompressedLastFocus',
+        _moduleId,
+        12,
         "True when the focus is inside a compact item's last part in the EXPLORER view."
     )) }
-));
-const ViewHasSomeCollapsibleRootItemContext = ( new RawContextKey(
+)));
+const ViewHasSomeCollapsibleRootItemContext = ( (new RawContextKey(
     'viewHasSomeCollapsibleItem',
     false,
     { type: 'boolean', description: ( localizeWithPath(
-        'vs/workbench/contrib/files/common/files',
-        'viewHasSomeCollapsibleItem',
+        _moduleId,
+        13,
         "True when a workspace in the EXPLORER view has some collapsible root child."
     )) }
-));
-const FilesExplorerFocusCondition = ( ContextKeyExpr.and(
+)));
+const FilesExplorerFocusCondition = ( (ContextKeyExpr.and(
     FoldersViewVisibleContext,
     FilesExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
-));
-const ExplorerFocusCondition = ( ContextKeyExpr.and(
+)));
+const ExplorerFocusCondition = ( (ContextKeyExpr.and(
     FoldersViewVisibleContext,
     ExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
-));
+)));
 const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
 const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
 const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
@@ -149,7 +126,7 @@ let TextFileContentProvider = TextFileContentProvider_1 = class TextFileContentP
         this.fileService = fileService;
         this.languageService = languageService;
         this.modelService = modelService;
-        this.fileWatcherDisposable = this._register(( new MutableDisposable()));
+        this.fileWatcherDisposable = this._register(( (new MutableDisposable())));
     }
     static async open(resource, scheme, label, editorService, options) {
         await editorService.openEditor({
@@ -173,7 +150,7 @@ let TextFileContentProvider = TextFileContentProvider_1 = class TextFileContentP
         const savedFileResource = TextFileContentProvider_1.textFileToResource(resource);
         const codeEditorModel = await this.resolveEditorModel(resource);
         if (!this.fileWatcherDisposable.value) {
-            const disposables = ( new DisposableStore());
+            const disposables = ( (new DisposableStore()));
             this.fileWatcherDisposable.value = disposables;
             disposables.add(this.fileService.onDidFilesChange(changes => {
                 if (changes.contains(savedFileResource, 0 )) {
@@ -207,12 +184,12 @@ let TextFileContentProvider = TextFileContentProvider_1 = class TextFileContentP
         return codeEditorModel;
     }
 };
-TextFileContentProvider = TextFileContentProvider_1 = ( __decorate([
-    ( __param(0, ITextFileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILanguageService)),
-    ( __param(3, IModelService))
-], TextFileContentProvider));
+TextFileContentProvider = TextFileContentProvider_1 = ( (__decorate([
+    ( (__param(0, ITextFileService))),
+    ( (__param(1, IFileService))),
+    ( (__param(2, ILanguageService))),
+    ( (__param(3, IModelService)))
+], TextFileContentProvider)));
 class OpenEditor {
     static { this.COUNTER = 0; }
     constructor(_editor, _group) {

package/vscode/src/vs/workbench/contrib/folding/browser/folding.contribution.js

@@ -9,6 +9,7 @@ import { editorConfigurationBaseNode } from '../../../../editor/common/config/ed
 import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 var DefaultFoldingRangeProvider_1;
+const _moduleId = "vs/workbench/contrib/folding/browser/folding.contribution";
 let DefaultFoldingRangeProvider = class DefaultFoldingRangeProvider extends Disposable {
     static { DefaultFoldingRangeProvider_1 = this; }
     static { this.configName = 'editor.defaultFoldingRangeProvider'; }
@@ -29,12 +30,8 @@ let DefaultFoldingRangeProvider = class DefaultFoldingRangeProvider extends Disp
         DefaultFoldingRangeProvider_1.extensionItemLabels.length = 0;
         DefaultFoldingRangeProvider_1.extensionDescriptions.length = 0;
         DefaultFoldingRangeProvider_1.extensionIds.push(null);
-        DefaultFoldingRangeProvider_1.extensionItemLabels.push(( localizeWithPath('vs/workbench/contrib/folding/browser/folding.contribution', 'null', 'All')));
-        DefaultFoldingRangeProvider_1.extensionDescriptions.push(( localizeWithPath(
-            'vs/workbench/contrib/folding/browser/folding.contribution',
-            'nullFormatterDescription',
-            "All active folding range providers"
-        )));
+        DefaultFoldingRangeProvider_1.extensionItemLabels.push(( localizeWithPath(_moduleId, 0, 'All')));
+        DefaultFoldingRangeProvider_1.extensionDescriptions.push(( localizeWithPath(_moduleId, 1, "All active folding range providers")));
         const languageExtensions = [];
         const otherExtensions = [];
         for (const extension of this._extensionService.extensions) {
@@ -67,17 +64,17 @@ let DefaultFoldingRangeProvider = class DefaultFoldingRangeProvider extends Disp
         return undefined;
     }
 };
-DefaultFoldingRangeProvider = DefaultFoldingRangeProvider_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IConfigurationService))
-], DefaultFoldingRangeProvider));
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+DefaultFoldingRangeProvider = DefaultFoldingRangeProvider_1 = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IConfigurationService)))
+], DefaultFoldingRangeProvider)));
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         [DefaultFoldingRangeProvider.configName]: {
             description: ( localizeWithPath(
-                'vs/workbench/contrib/folding/browser/folding.contribution',
-                'formatter.default',
+                _moduleId,
+                2,
                 "Defines a default folding range provider that takes precedence over all other folding range providers. Must be the identifier of an extension contributing a folding range provider."
             )),
             type: ['string', 'null'],
@@ -88,4 +85,4 @@ DefaultFoldingRangeProvider = DefaultFoldingRangeProvider_1 = ( __decorate([
         }
     }
 });
-( Registry.as(Extensions$1.Workbench)).registerWorkbenchContribution(DefaultFoldingRangeProvider, 3 );
+( (Registry.as(Extensions$1.Workbench))).registerWorkbenchContribution(DefaultFoldingRangeProvider, 3 );

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsMultiple.js

@@ -31,6 +31,7 @@ import { CommandsRegistry } from '../../../../platform/commands/common/commands.
 import { generateUuid } from '../../../../base/common/uuid.js';
 import Severity$1 from '../../../../base/common/severity.js';
 var DefaultFormatter_1;
+const _moduleId = "vs/workbench/contrib/format/browser/formatActionsMultiple";
 let DefaultFormatter = class DefaultFormatter extends Disposable {
     static { DefaultFormatter_1 = this; }
     static { this.configName = 'editor.defaultFormatter'; }
@@ -49,7 +50,7 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         this._languageFeaturesService = _languageFeaturesService;
         this._languageStatusService = _languageStatusService;
         this._editorService = _editorService;
-        this._languageStatusStore = this._store.add(( new DisposableStore()));
+        this._languageStatusStore = this._store.add(( (new DisposableStore())));
         this._store.add(this._extensionService.onDidChangeExtensions(this._updateConfigValues, this));
         this._store.add(FormattingConflicts.setFormatterSelector((formatter, document, mode, kind) => this._selectFormatter(formatter, document, mode, kind)));
         this._store.add(_editorService.onDidActiveEditorChange(this._updateStatus, this));
@@ -78,16 +79,8 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         DefaultFormatter_1.extensionItemLabels.length = 0;
         DefaultFormatter_1.extensionDescriptions.length = 0;
         DefaultFormatter_1.extensionIds.push(null);
-        DefaultFormatter_1.extensionItemLabels.push(( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'null',
-            'None'
-        )));
-        DefaultFormatter_1.extensionDescriptions.push(( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'nullFormatterDescription',
-            "None"
-        )));
+        DefaultFormatter_1.extensionItemLabels.push(( localizeWithPath(_moduleId, 0, 'None')));
+        DefaultFormatter_1.extensionDescriptions.push(( localizeWithPath(_moduleId, 1, "None")));
         for (const extension of extensions) {
             if (extension.main || extension.browser) {
                 DefaultFormatter_1.extensionIds.push(extension.identifier.value);
@@ -114,15 +107,15 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
                 const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
                 const detail = kind === 1
                     ? ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    'miss.1',
+                    _moduleId,
+                    2,
                     "Extension '{0}' is configured as formatter but it cannot format '{1}'-files",
                     extension.displayName || extension.name,
                     langName
                 ))
                     : ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    'miss.2',
+                    _moduleId,
+                    3,
                     "Extension '{0}' is configured as formatter but it can only format '{1}'-files as a whole, not selections or parts of it.",
                     extension.displayName || extension.name,
                     langName
@@ -136,14 +129,14 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const message = !defaultFormatterId
             ? ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'config.needed',
+            _moduleId,
+            4,
             "There are multiple formatters for '{0}' files. One of them should be configured as default formatter.",
             DefaultFormatter_1._maybeQuotes(langName)
         ))
             : ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'config.bad',
+            _moduleId,
+            5,
             "Extension '{0}' is configured as formatter but not available. Select a different default formatter to continue.",
             defaultFormatterId
         ));
@@ -156,43 +149,31 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         }
         if (mode !== 2 ) {
             const { confirmed } = await this._dialogService.confirm({
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    'miss',
-                    "Configure Default Formatter"
-                )),
+                message: ( localizeWithPath(_moduleId, 6, "Configure Default Formatter")),
                 detail: formatterOrMessage,
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    { key: 'do.config', comment: ['&& denotes a mnemonic'] },
-                    "&&Configure..."
-                ))
+                primaryButton: ( localizeWithPath(_moduleId, 7, "&&Configure..."))
             });
             if (confirmed) {
                 return this._pickAndPersistDefaultFormatter(formatter, document);
             }
         }
         else {
-            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'do.config.notification',
-                "Configure..."
-            )), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
+            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localizeWithPath(_moduleId, 8, "Configure...")), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
         }
         return undefined;
     }
     async _pickAndPersistDefaultFormatter(formatter, document) {
-        const picks = ( formatter.map((formatter, index) => {
+        const picks = ( (formatter.map((formatter, index) => {
             return {
                 index,
                 label: formatter.displayName || (formatter.extensionId ? formatter.extensionId.value : '?'),
                 description: formatter.extensionId && formatter.extensionId.value
             };
-        }));
+        })));
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const pick = await this._quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'select',
+            _moduleId,
+            9,
             "Select a default formatter for '{0}' files",
             DefaultFormatter_1._maybeQuotes(langName)
         )) });
@@ -216,7 +197,7 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         if (formatter.length === 0) {
             return;
         }
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         this._languageStatusStore.add(toDisposable(() => cts.dispose(true)));
         this._analyzeFormatter(1 , formatter, document).then(result => {
             if (cts.token.isCancellationRequested) {
@@ -225,26 +206,14 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
             if (typeof result !== 'string') {
                 return;
             }
-            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'do.config.command',
-                "Configure..."
-            )) };
+            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localizeWithPath(_moduleId, 10, "Configure...")) };
             this._languageStatusStore.add(CommandsRegistry.registerCommand(command.id, () => this._pickAndPersistDefaultFormatter(formatter, document)));
             this._languageStatusStore.add(this._languageStatusService.addStatus({
                 id: 'formatter.conflict',
-                name: ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    'summary',
-                    "Formatter Conflicts"
-                )),
+                name: ( localizeWithPath(_moduleId, 11, "Formatter Conflicts")),
                 selector: { language: document.getLanguageId(), pattern: document.uri.fsPath },
                 severity: Severity$1.Error,
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                    'formatter',
-                    "Formatting"
-                )),
+                label: ( localizeWithPath(_moduleId, 12, "Formatting")),
                 detail: result,
                 busy: false,
                 source: '',
@@ -254,26 +223,26 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         });
     }
 };
-DefaultFormatter = DefaultFormatter_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IWorkbenchExtensionEnablementService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, IQuickInputService)),
-    ( __param(6, ILanguageService)),
-    ( __param(7, ILanguageFeaturesService)),
-    ( __param(8, ILanguageStatusService)),
-    ( __param(9, IEditorService))
-], DefaultFormatter));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DefaultFormatter, 3 );
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+DefaultFormatter = DefaultFormatter_1 = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IWorkbenchExtensionEnablementService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, IDialogService))),
+    ( (__param(5, IQuickInputService))),
+    ( (__param(6, ILanguageService))),
+    ( (__param(7, ILanguageFeaturesService))),
+    ( (__param(8, ILanguageStatusService))),
+    ( (__param(9, IEditorService)))
+], DefaultFormatter)));
+( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(DefaultFormatter, 3 );
+( (Registry.as(Extensions$1.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         [DefaultFormatter.configName]: {
             description: ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'formatter.default',
+                _moduleId,
+                13,
                 "Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter."
             )),
             type: ['string', 'null'],
@@ -290,7 +259,7 @@ function logFormatterTelemetry(telemetryService, mode, options, pick) {
     }
     telemetryService.publicLog2('formatterpick', {
         mode,
-        extensions: ( options.map(extKey)),
+        extensions: ( (options.map(extKey))),
         pick: pick ? extKey(pick) : 'none'
     });
 }
@@ -301,35 +270,23 @@ async function showFormatterPick(accessor, model, formatters) {
     const overrides = { resource: model.uri, overrideIdentifier: model.getLanguageId() };
     const defaultFormatter = configService.getValue(DefaultFormatter.configName, overrides);
     let defaultFormatterPick;
-    const picks = ( formatters.map((provider, index) => {
+    const picks = ( (formatters.map((provider, index) => {
         const isDefault = ExtensionIdentifier.equals(provider.extensionId, defaultFormatter);
         const pick = {
             index,
             label: provider.displayName || '',
-            description: isDefault ? ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'def',
-                "(default)"
-            )) : undefined,
+            description: isDefault ? ( localizeWithPath(_moduleId, 14, "(default)")) : undefined,
         };
         if (isDefault) {
             defaultFormatterPick = pick;
         }
         return pick;
-    }));
+    })));
     const configurePick = {
-        label: ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'config',
-            "Configure Default Formatter..."
-        ))
+        label: ( localizeWithPath(_moduleId, 15, "Configure Default Formatter..."))
     };
     const pick = await quickPickService.pick([...picks, { type: 'separator' }, configurePick], {
-        placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'format.placeHolder',
-            "Select a formatter"
-        )),
+        placeHolder: ( localizeWithPath(_moduleId, 16, "Select a formatter")),
         activeItem: defaultFormatterPick
     });
     if (!pick) {
@@ -338,8 +295,8 @@ async function showFormatterPick(accessor, model, formatters) {
     else if (pick === configurePick) {
         const langName = languageService.getLanguageName(model.getLanguageId()) || model.getLanguageId();
         const pick = await quickPickService.pick(picks, { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/format/browser/formatActionsMultiple',
-            'select',
+            _moduleId,
+            9,
             "Select a default formatter for '{0}' files",
             DefaultFormatter._maybeQuotes(langName)
         )) });
@@ -356,16 +313,12 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatDocument.multiple',
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'formatDocument.label.multiple',
-                "Format Document With..."
-            )),
+            label: ( localizeWithPath(_moduleId, 17, "Format Document With...")),
             alias: 'Format Document...',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 EditorContextKeys.hasMultipleDocumentFormattingProvider
-            )),
+            ))),
             contextMenuOpts: {
                 group: '1_modification',
                 order: 1.3
@@ -392,15 +345,14 @@ registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatSelection.multiple',
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/format/browser/formatActionsMultiple',
-                'formatSelection.label.multiple',
-                "Format Selection With..."
-            )),
+            label: ( localizeWithPath(_moduleId, 18, "Format Selection With...")),
             alias: 'Format Code...',
-            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.and(EditorContextKeys.writable)), EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider)),
+            precondition: ( (ContextKeyExpr.and(
+                 (ContextKeyExpr.and(EditorContextKeys.writable)),
+                EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider
+            ))),
             contextMenuOpts: {
-                when: ( ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection)),
+                when: ( (ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection))),
                 group: '1_modification',
                 order: 1.31
             }
@@ -416,12 +368,12 @@ registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
         const model = editor.getModel();
         let range = editor.getSelection();
         if (range.isEmpty()) {
-            range = ( new Range(
+            range = ( (new Range(
                 range.startLineNumber,
                 1,
                 range.startLineNumber,
                 model.getLineMaxColumn(range.startLineNumber)
-            ));
+            )));
         }
         const provider = languageFeaturesService.documentRangeFormattingEditProvider.ordered(model);
         const pick = await instaService.invokeFunction(showFormatterPick, model, provider);