@codingame/monaco-vscode-api 4.5.1 → 4.5.2

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -9,34 +9,27 @@ import { localizeWithPath } from '../../../../nls.js';
 import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
+const _moduleId = "vs/workbench/contrib/codeActions/browser/codeActionsContribution";
 const createCodeActionsAutoSave = (description) => {
     return {
         type: 'string',
         enum: ['always', 'explicit', 'never', true, false],
         enumDescriptions: [
             ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'alwaysSave',
+                _moduleId,
+                0,
                 'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
             )),
+            ( localizeWithPath(_moduleId, 1, 'Triggers Code Actions only when explicitly saved')),
+            ( localizeWithPath(_moduleId, 2, 'Never triggers Code Actions on save')),
             ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'explicitSave',
-                'Triggers Code Actions only when explicitly saved'
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'neverSave',
-                'Never triggers Code Actions on save'
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'explicitSaveBoolean',
+                _moduleId,
+                3,
                 'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
             )),
             ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'neverSaveBoolean',
+                _moduleId,
+                4,
                 'Never triggers Code Actions on save. This value will be deprecated in favor of "never".'
             ))
         ],
@@ -44,13 +37,13 @@ const createCodeActionsAutoSave = (description) => {
         description: description
     };
 };
-const codeActionsOnSaveDefaultProperties = ( Object.freeze({
+const codeActionsOnSaveDefaultProperties = ( (Object.freeze({
     'source.fixAll': createCodeActionsAutoSave(( localizeWithPath(
-        'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-        'codeActionsOnSave.fixAll',
+        _moduleId,
+        5,
         "Controls whether auto fix action should be run on file save."
     ))),
-}));
+})));
 const codeActionsOnSaveSchema = {
     oneOf: [
         {
@@ -66,8 +59,8 @@ const codeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localizeWithPath(
-        'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-        'editor.codeActionsOnSave',
+        _moduleId,
+        6,
         'Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. Example: `"source.organizeImports": "explicit" `'
     )),
     type: ['object', 'array'],
@@ -78,17 +71,17 @@ const codeActionsOnSaveSchema = {
     default: {},
     scope: 5 ,
 };
-const editorConfiguration = ( Object.freeze({
+const editorConfiguration = ( (Object.freeze({
     ...editorConfigurationBaseNode,
     properties: {
         'editor.codeActionsOnSave': codeActionsOnSaveSchema
     }
-}));
+})));
 let CodeActionsContribution = class CodeActionsContribution extends Disposable {
     constructor(codeActionsExtensionPoint, keybindingService) {
         super();
         this._contributedCodeActions = [];
-        this._onDidChangeContributions = this._register(( new Emitter()));
+        this._onDidChangeContributions = this._register(( (new Emitter())));
         codeActionsExtensionPoint.setHandler(extensionPoints => {
             this._contributedCodeActions = extensionPoints.flatMap(x => x.value).filter(x => Array.isArray(x.actions));
             this.updateConfigurationSchema(this._contributedCodeActions);
@@ -103,24 +96,24 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         const newProperties = { ...codeActionsOnSaveDefaultProperties };
         for (const [sourceAction, props] of this.getSourceActions(codeActionContributions)) {
             newProperties[sourceAction] = createCodeActionsAutoSave(( localizeWithPath(
-                'vs/workbench/contrib/codeActions/browser/codeActionsContribution',
-                'codeActionsOnSave.generic',
+                _moduleId,
+                7,
                 "Controls whether '{0}' actions should be run on file save.",
                 props.title
             )));
         }
         codeActionsOnSaveSchema.properties = newProperties;
-        ( Registry.as(Extensions.Configuration))
+        ( (Registry.as(Extensions.Configuration)))
             .notifyConfigurationSchemaUpdated(editorConfiguration);
     }
     getSourceActions(contributions) {
-        const defaultKinds = ( ( Object.keys(codeActionsOnSaveDefaultProperties)).map(value => ( new HierarchicalKind(value))));
-        const sourceActions = ( new Map());
+        const defaultKinds = ( (( (Object.keys(codeActionsOnSaveDefaultProperties))).map(value => ( (new HierarchicalKind(value))))));
+        const sourceActions = ( (new Map()));
         for (const contribution of contributions) {
             for (const action of contribution.actions) {
-                const kind = ( new HierarchicalKind(action.kind));
+                const kind = ( (new HierarchicalKind(action.kind)));
                 if (CodeActionKind.Source.contains(kind)
-                    && !( defaultKinds.some(defaultKind => defaultKind.contains(kind)))) {
+                    && !( (defaultKinds.some(defaultKind => defaultKind.contains(kind))))) {
                     sourceActions.set(kind.value, action);
                 }
             }
@@ -144,8 +137,8 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
                                 'kind': {
                                     anyOf: [
                                         {
-                                            enum: ( actions.map(action => action.kind)),
-                                            enumDescriptions: ( actions.map(action => action.description ?? action.title)),
+                                            enum: ( (actions.map(action => action.kind))),
+                                            enumDescriptions: ( (actions.map(action => action.description ?? action.title))),
                                         },
                                         { type: 'string' },
                                     ]
@@ -158,13 +151,13 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         };
         const getActions = (ofKind) => {
             const allActions = this._contributedCodeActions.flatMap(desc => desc.actions);
-            const out = ( new Map());
+            const out = ( (new Map()));
             for (const action of allActions) {
-                if (!( out.has(action.kind)) && ofKind.contains(( new HierarchicalKind(action.kind)))) {
+                if (!( (out.has(action.kind))) && ofKind.contains(( (new HierarchicalKind(action.kind))))) {
                     out.set(action.kind, action);
                 }
             }
-            return Array.from(( out.values()));
+            return Array.from(( (out.values())));
         };
         return [
             conditionalSchema(codeActionCommandId, getActions(HierarchicalKind.Empty)),
@@ -173,7 +166,7 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         ];
     }
 };
-CodeActionsContribution = ( __decorate([
-    ( __param(1, IKeybindingService))
-], CodeActionsContribution));
+CodeActionsContribution = ( (__decorate([
+    ( (__param(1, IKeybindingService)))
+], CodeActionsContribution)));
 export { CodeActionsContribution, editorConfiguration };

package/vscode/src/vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint.js

@@ -5,32 +5,25 @@ import { Disposable } from '../../../../base/common/lifecycle.js';
 import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import { MarkdownString } from '../../../../base/common/htmlContent.js';
+const _moduleId = "vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint";
 var CodeActionExtensionPointFields;
-( (function(CodeActionExtensionPointFields) {
+( ((function(CodeActionExtensionPointFields) {
     CodeActionExtensionPointFields["languages"] = "languages";
     CodeActionExtensionPointFields["actions"] = "actions";
     CodeActionExtensionPointFields["kind"] = "kind";
     CodeActionExtensionPointFields["title"] = "title";
     CodeActionExtensionPointFields["description"] = "description";
-})(CodeActionExtensionPointFields || (CodeActionExtensionPointFields = {})));
-const codeActionsExtensionPointSchema = ( Object.freeze({
+})(CodeActionExtensionPointFields || (CodeActionExtensionPointFields = {}))));
+const codeActionsExtensionPointSchema = ( (Object.freeze({
     type: 'array',
-    markdownDescription: ( localizeWithPath(
-        'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-        'contributes.codeActions',
-        "Configure which editor to use for a resource."
-    )),
+    markdownDescription: ( localizeWithPath(_moduleId, 0, "Configure which editor to use for a resource.")),
     items: {
         type: 'object',
         required: [CodeActionExtensionPointFields.languages, CodeActionExtensionPointFields.actions],
         properties: {
             [CodeActionExtensionPointFields.languages]: {
                 type: 'array',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                    'contributes.codeActions.languages',
-                    "Language modes that the code actions are enabled for."
-                )),
+                description: ( localizeWithPath(_moduleId, 1, "Language modes that the code actions are enabled for.")),
                 items: { type: 'string' }
             },
             [CodeActionExtensionPointFields.actions]: {
@@ -39,33 +32,21 @@ const codeActionsExtensionPointSchema = ( Object.freeze({
                 properties: {
                     [CodeActionExtensionPointFields.kind]: {
                         type: 'string',
-                        markdownDescription: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                            'contributes.codeActions.kind',
-                            "`CodeActionKind` of the contributed code action."
-                        )),
+                        markdownDescription: ( localizeWithPath(_moduleId, 2, "`CodeActionKind` of the contributed code action.")),
                     },
                     [CodeActionExtensionPointFields.title]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                            'contributes.codeActions.title',
-                            "Label for the code action used in the UI."
-                        )),
+                        description: ( localizeWithPath(_moduleId, 3, "Label for the code action used in the UI.")),
                     },
                     [CodeActionExtensionPointFields.description]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                            'contributes.codeActions.description',
-                            "Description of what the code action does."
-                        )),
+                        description: ( localizeWithPath(_moduleId, 4, "Description of what the code action does.")),
                     },
                 }
             }
         }
     }
-}));
+})));
 const codeActionsExtensionPointDescriptor = {
     extensionPoint: 'codeActions',
     deps: [languagesExtPoint],
@@ -84,38 +65,24 @@ class CodeActionsTableRenderer extends Disposable {
         if (!codeActions.length) {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
-        const flatActions = ( codeActions.map(contribution => ( contribution.actions.map(action => ({ ...action, languages: contribution.languages }))))).flat();
+        const flatActions = ( (codeActions.map(
+            contribution => ( (contribution.actions.map(action => ({ ...action, languages: contribution.languages }))))
+        ))).flat();
         const headers = [
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                'codeActions.title',
-                "Title"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                'codeActions.kind',
-                "Kind"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                'codeActions.description',
-                "Description"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-                'codeActions.languages',
-                "Languages"
-            ))
+            ( localizeWithPath(_moduleId, 5, "Title")),
+            ( localizeWithPath(_moduleId, 6, "Kind")),
+            ( localizeWithPath(_moduleId, 7, "Description")),
+            ( localizeWithPath(_moduleId, 8, "Languages"))
         ];
-        const rows = ( flatActions.sort((a, b) => a.title.localeCompare(b.title))
+        const rows = ( (flatActions.sort((a, b) => a.title.localeCompare(b.title))
             .map(action => {
             return [
                 action.title,
-                ( new MarkdownString()).appendMarkdown(`\`${action.kind}\``),
+                ( (new MarkdownString())).appendMarkdown(`\`${action.kind}\``),
                 action.description ?? '',
-                ( new MarkdownString()).appendMarkdown(`${( action.languages.map(lang => `\`${lang}\``)).join(' ')}`),
+                ( (new MarkdownString())).appendMarkdown(`${( (action.languages.map(lang => `\`${lang}\``))).join(' ')}`),
             ];
-        }));
+        })));
         return {
             data: {
                 headers,
@@ -125,16 +92,12 @@ class CodeActionsTableRenderer extends Disposable {
         };
     }
 }
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'codeActions',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/codeActions/common/codeActionsExtensionPoint',
-        'codeactions',
-        "Code Actions"
-    )),
+    label: ( localizeWithPath(_moduleId, 9, "Code Actions")),
     access: {
         canToggle: false,
     },
-    renderer: ( new SyncDescriptor(CodeActionsTableRenderer)),
+    renderer: ( (new SyncDescriptor(CodeActionsTableRenderer))),
 });
 export { codeActionsExtensionPointDescriptor };

package/vscode/src/vs/workbench/contrib/codeActions/common/documentationExtensionPoint.js

@@ -1,35 +1,24 @@
 import { localizeWithPath } from '../../../../nls.js';
 import { languagesExtPoint } from '../../../services/language/common/languageService.js';
+const _moduleId = "vs/workbench/contrib/codeActions/common/documentationExtensionPoint";
 var DocumentationExtensionPointFields;
-( (function(DocumentationExtensionPointFields) {
+( ((function(DocumentationExtensionPointFields) {
     DocumentationExtensionPointFields["when"] = "when";
     DocumentationExtensionPointFields["title"] = "title";
     DocumentationExtensionPointFields["command"] = "command";
 })(
     DocumentationExtensionPointFields || (DocumentationExtensionPointFields = {})
-));
-const documentationExtensionPointSchema = ( Object.freeze({
+)));
+const documentationExtensionPointSchema = ( (Object.freeze({
     type: 'object',
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-        'contributes.documentation',
-        "Contributed documentation."
-    )),
+    description: ( localizeWithPath(_moduleId, 0, "Contributed documentation.")),
     properties: {
         'refactoring': {
             type: 'array',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-                'contributes.documentation.refactorings',
-                "Contributed documentation for refactorings."
-            )),
+            description: ( localizeWithPath(_moduleId, 1, "Contributed documentation for refactorings.")),
             items: {
                 type: 'object',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-                    'contributes.documentation.refactoring',
-                    "Contributed documentation for refactoring."
-                )),
+                description: ( localizeWithPath(_moduleId, 2, "Contributed documentation for refactoring.")),
                 required: [
                     DocumentationExtensionPointFields.title,
                     DocumentationExtensionPointFields.when,
@@ -38,33 +27,21 @@ const documentationExtensionPointSchema = ( Object.freeze({
                 properties: {
                     [DocumentationExtensionPointFields.title]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-                            'contributes.documentation.refactoring.title',
-                            "Label for the documentation used in the UI."
-                        )),
+                        description: ( localizeWithPath(_moduleId, 3, "Label for the documentation used in the UI.")),
                     },
                     [DocumentationExtensionPointFields.when]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-                            'contributes.documentation.refactoring.when',
-                            "When clause."
-                        )),
+                        description: ( localizeWithPath(_moduleId, 4, "When clause.")),
                     },
                     [DocumentationExtensionPointFields.command]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/codeActions/common/documentationExtensionPoint',
-                            'contributes.documentation.refactoring.command',
-                            "Command executed."
-                        )),
+                        description: ( localizeWithPath(_moduleId, 5, "Command executed.")),
                     },
                 },
             }
         }
     }
-}));
+})));
 const documentationExtensionPointDescriptor = {
     extensionPoint: 'documentation',
     deps: [languagesExtPoint],

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -21,23 +21,20 @@ import { ActionBar } from '../../../../../base/browser/ui/actionbar/actionbar.js
 import { toAction } from '../../../../../base/common/actions.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 var EditorDictation_1;
-const EDITOR_DICTATION_IN_PROGRESS = ( new RawContextKey('editorDictation.inProgress', false));
-const VOICE_CATEGORY = ( localize2WithPath(
-    'vs/workbench/contrib/codeEditor/browser/dictation/editorDictation',
-    'voiceCategory',
-    "Voice"
-));
+const _moduleId = "vs/workbench/contrib/codeEditor/browser/dictation/editorDictation";
+const EDITOR_DICTATION_IN_PROGRESS = ( (new RawContextKey('editorDictation.inProgress', false)));
+const VOICE_CATEGORY = ( localize2WithPath(_moduleId, 0, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: 'workbench.action.editorDictation.start',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/codeEditor/browser/dictation/editorDictation',
-                'startDictation',
-                "Start Dictation in Editor"
-            )),
+            title: ( localize2WithPath(_moduleId, 1, "Start Dictation in Editor")),
             category: VOICE_CATEGORY,
-            precondition: ( ContextKeyExpr.and(HasSpeechProvider, ( EDITOR_DICTATION_IN_PROGRESS.toNegated()), ( EditorContextKeys.readOnly.toNegated()))),
+            precondition: ( (ContextKeyExpr.and(
+                HasSpeechProvider,
+                 (EDITOR_DICTATION_IN_PROGRESS.toNegated()),
+                 (EditorContextKeys.readOnly.toNegated())
+            ))),
             f1: true,
             keybinding: {
                 primary: 2048  | 512  | 52 ,
@@ -68,11 +65,7 @@ class EditorDictationStopAction extends EditorAction2 {
     constructor() {
         super({
             id: EditorDictationStopAction.ID,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/codeEditor/browser/dictation/editorDictation',
-                'stopDictation',
-                "Stop Dictation in Editor"
-            )),
+            title: ( localize2WithPath(_moduleId, 2, "Stop Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
@@ -93,20 +86,11 @@ class DictationWidget extends Disposable {
         this.suppressMouseDown = true;
         this.allowEditorOverflow = true;
         this.domNode = document.createElement('div');
-        const actionBar = this._register(( new ActionBar(this.domNode)));
+        const actionBar = this._register(( (new ActionBar(this.domNode))));
         const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel();
         actionBar.push(toAction({
             id: EditorDictationStopAction.ID,
-            label: stopActionKeybinding ? ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/dictation/editorDictation',
-                'stopDictationShort1',
-                "Stop Dictation ({0})",
-                stopActionKeybinding
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/dictation/editorDictation',
-                'stopDictationShort2',
-                "Stop Dictation"
-            )),
+            label: stopActionKeybinding ? ( localizeWithPath(_moduleId, 3, "Stop Dictation ({0})", stopActionKeybinding)) : ( localizeWithPath(_moduleId, 4, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), { icon: true, label: false, keybinding: stopActionKeybinding });
@@ -165,12 +149,12 @@ let EditorDictation = class EditorDictation extends Disposable {
         this.speechService = speechService;
         this.contextKeyService = contextKeyService;
         this.keybindingService = keybindingService;
-        this.widget = this._register(( new DictationWidget(this.editor, this.keybindingService)));
+        this.widget = this._register(( (new DictationWidget(this.editor, this.keybindingService))));
         this.editorDictationInProgress = EDITOR_DICTATION_IN_PROGRESS.bindTo(this.contextKeyService);
-        this.sessionDisposables = this._register(( new MutableDisposable()));
+        this.sessionDisposables = this._register(( (new MutableDisposable())));
     }
     async start() {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         this.sessionDisposables.value = disposables;
         this.widget.show();
         disposables.add(toDisposable(() => this.widget.hide()));
@@ -185,7 +169,7 @@ let EditorDictation = class EditorDictation extends Disposable {
             if (!previewStart) {
                 previewStart = assertIsDefined(this.editor.getPosition());
             }
-            const endPosition = ( new Position(previewStart.lineNumber, previewStart.column + text.length));
+            const endPosition = ( (new Position(previewStart.lineNumber, previewStart.column + text.length)));
             this.editor.executeEdits(EditorDictation_1.ID, [
                 EditOperation.replace(Range.fromPositions(previewStart, previewStart.with(undefined, previewStart.column + lastReplaceTextLength)), text)
             ], [
@@ -212,7 +196,7 @@ let EditorDictation = class EditorDictation extends Disposable {
             }
             this.editor.revealPositionInCenterIfOutsideViewport(endPosition);
         };
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         disposables.add(toDisposable(() => cts.dispose(true)));
         const session = await this.speechService.createSpeechToTextSession(cts.token, 'editor');
         disposables.add(session.onDidChange(e => {
@@ -247,11 +231,11 @@ let EditorDictation = class EditorDictation extends Disposable {
         this.sessionDisposables.clear();
     }
 };
-EditorDictation = EditorDictation_1 = ( __decorate([
-    ( __param(1, ISpeechService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IKeybindingService))
-], EditorDictation));
+EditorDictation = EditorDictation_1 = ( (__decorate([
+    ( (__param(1, ISpeechService))),
+    ( (__param(2, IContextKeyService))),
+    ( (__param(3, IKeybindingService)))
+], EditorDictation)));
 registerEditorContribution(EditorDictation.ID, EditorDictation, 4 );
 registerAction2(EditorDictationStartAction);
 registerAction2(EditorDictationStopAction);

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js

@@ -25,6 +25,7 @@ import { AccessibilityHelpAction } from '../../accessibility/browser/accessibleV
 import { getCommentCommandInfo } from '../../accessibility/browser/editorAccessibilityHelp.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import Severity$1 from '../../../../base/common/severity.js';
+const _moduleId = "vs/workbench/contrib/codeEditor/browser/diffEditorHelper";
 let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Disposable {
     static { this.ID = 'editor.contrib.diffEditorHelper'; }
     constructor(_diffEditor, _instantiationService, _configurationService, _notificationService) {
@@ -37,14 +38,10 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
         const isEmbeddedDiffEditor = this._diffEditor instanceof EmbeddedDiffEditorWidget;
         if (!isEmbeddedDiffEditor) {
             const computationResult = observableFromEvent(e => this._diffEditor.onDidUpdateDiff(e), () =>  this._diffEditor.getDiffComputationResult());
-            const onlyWhiteSpaceChange = ( computationResult.map(r => r && !r.identical && r.changes2.length === 0));
+            const onlyWhiteSpaceChange = ( (computationResult.map(r => r && !r.identical && r.changes2.length === 0)));
             this._register(autorunWithStore((reader, store) => {
                 if (onlyWhiteSpaceChange.read(reader)) {
-                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localizeWithPath(
-                        'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                        'hintWhitespace',
-                        "Show Whitespace Differences"
-                    )), null));
+                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localizeWithPath(_moduleId, 0, "Show Whitespace Differences")), null));
                     store.add(helperWidget.onClick(() => {
                         this._configurationService.updateValue('diffEditor.ignoreTrimWhitespace', false);
                     }));
@@ -55,16 +52,12 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                 const diffComputationResult = this._diffEditor.getDiffComputationResult();
                 if (diffComputationResult && diffComputationResult.quitEarly) {
                     this._notificationService.prompt(Severity$1.Warning, ( localizeWithPath(
-                        'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                        'hintTimeout',
+                        _moduleId,
+                        1,
                         "The diff algorithm was stopped early (after {0} ms.)",
                         this._diffEditor.maxComputationTime
                     )), [{
-                            label: ( localizeWithPath(
-                                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                                'removeTimeout',
-                                "Remove Limit"
-                            )),
+                            label: ( localizeWithPath(_moduleId, 2, "Remove Limit")),
                             run: () => {
                                 this._configurationService.updateValue('diffEditor.maxComputationTime', 0);
                             }
@@ -74,11 +67,11 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
         }
     }
 };
-DiffEditorHelperContribution = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, INotificationService))
-], DiffEditorHelperContribution));
+DiffEditorHelperContribution = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, INotificationService)))
+], DiffEditorHelperContribution)));
 function createScreenReaderHelp() {
     return AccessibilityHelpAction.addImplementation(105, 'diff-editor', async (accessor) => {
         const accessibleViewService = accessor.get(IAccessibleViewService);
@@ -99,34 +92,30 @@ function createScreenReaderHelp() {
         const switchSidesKb = keybindingService.lookupKeybinding('diffEditor.switchSide')?.getAriaLabel();
         if (switchSidesKb) {
             switchSides = ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                'msg3',
+                _moduleId,
+                3,
                 "Run the command Diff Editor: Switch Side ({0}) to toggle between the original and modified editors.",
                 switchSidesKb
             ));
         }
         else {
             switchSides = ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                'switchSidesNoKb',
+                _moduleId,
+                4,
                 "Run the command Diff Editor: Switch Side, which is currently not triggerable via keybinding, to toggle between the original and modified editors."
             ));
         }
         const diffEditorActiveAnnouncement = ( localizeWithPath(
-            'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-            'msg5',
+            _moduleId,
+            5,
             "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
         ));
         const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified'];
         const content = [
+            ( localizeWithPath(_moduleId, 6, "You are in a diff editor.")),
             ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                'msg1',
-                "You are in a diff editor."
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                'msg2',
+                _moduleId,
+                7,
                 "View the next ({0}) or previous ({1}) diff in diff review mode, which is optimized for screen readers.",
                 next,
                 previous
@@ -134,8 +123,8 @@ function createScreenReaderHelp() {
             switchSides,
             diffEditorActiveAnnouncement,
             ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/diffEditorHelper',
-                'msg4',
+                _moduleId,
+                8,
                 "To control which accessibility signals should be played, the following settings can be configured: {0}.",
                 keys.join(', ')
             )),
@@ -156,7 +145,7 @@ function createScreenReaderHelp() {
     }, ContextKeyEqualsExpr.create('isInDiffEditor', true));
 }
 registerDiffEditorContribution(DiffEditorHelperContribution.ID, DiffEditorHelperContribution);
-( Registry.as(Extensions.ConfigurationMigration))
+( (Registry.as(Extensions.ConfigurationMigration)))
     .registerConfigurationMigrations([{
         key: 'diffEditor.experimental.collapseUnchangedRegions',
         migrateFn: (value, accessor) => {