@codingame/monaco-vscode-api 4.5.0 → 4.5.2

package/vscode/src/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js

@@ -23,9 +23,10 @@ import { IOpenerService } from '../../../../platform/opener/common/opener.servic
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.service.js';
+const _moduleId = "vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter";
 const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localizeWithPath(
-    'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-    'warningIcon',
+    _moduleId,
+    0,
     'Icon shown with a warning message in the extensions editor.'
 )));
 let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
@@ -47,35 +48,27 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
                         message: ( localizeWithPath(
-                            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                            'unicodeHighlighting.thisDocumentHasManyNonBasicAsciiUnicodeCharacters',
+                            _moduleId,
+                            1,
                             'This document contains many non-basic ASCII unicode characters'
                         )),
-                        command: ( new DisableHighlightingOfNonBasicAsciiCharactersAction()),
+                        command: ( (new DisableHighlightingOfNonBasicAsciiCharactersAction())),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localizeWithPath(
-                            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                            'unicodeHighlighting.thisDocumentHasManyAmbiguousUnicodeCharacters',
-                            'This document contains many ambiguous unicode characters'
-                        )),
-                        command: ( new DisableHighlightingOfAmbiguousCharactersAction()),
+                        message: ( localizeWithPath(_moduleId, 2, 'This document contains many ambiguous unicode characters')),
+                        command: ( (new DisableHighlightingOfAmbiguousCharactersAction())),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localizeWithPath(
-                            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                            'unicodeHighlighting.thisDocumentHasManyInvisibleUnicodeCharacters',
-                            'This document contains many invisible unicode characters'
-                        )),
-                        command: ( new DisableHighlightingOfInvisibleCharactersAction()),
+                        message: ( localizeWithPath(_moduleId, 3, 'This document contains many invisible unicode characters')),
+                        command: ( (new DisableHighlightingOfInvisibleCharactersAction())),
                     };
                 }
                 else {
-                    throw new Error('Unreachable');
+                    throw ( (new Error('Unreachable')));
                 }
                 this._bannerController.show({
                     id: 'unicodeHighlightBanner',
@@ -143,8 +136,8 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
             invisibleCharacters: options.invisibleCharacters,
             includeComments: options.includeComments,
             includeStrings: options.includeStrings,
-            allowedCodePoints: ( ( Object.keys(options.allowedCharacters)).map(c => c.codePointAt(0))),
-            allowedLocales: ( ( Object.keys(options.allowedLocales)).map(locale => {
+            allowedCodePoints: ( (( (Object.keys(options.allowedCharacters))).map(c => c.codePointAt(0)))),
+            allowedLocales: ( (( (Object.keys(options.allowedLocales))).map(locale => {
                 if (locale === '_os') {
                     const osLocale = new Intl.NumberFormat().resolvedOptions().locale;
                     return osLocale;
@@ -153,18 +146,18 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                     return language;
                 }
                 return locale;
-            })),
+            }))),
         };
         if (this._editorWorkerService.canComputeUnicodeHighlights(this._editor.getModel().uri)) {
-            this._highlighter = ( new DocumentUnicodeHighlighter(
+            this._highlighter = ( (new DocumentUnicodeHighlighter(
                 this._editor,
                 highlightOptions,
                 this._updateState,
                 this._editorWorkerService
-            ));
+            )));
         }
         else {
-            this._highlighter = ( new ViewportUnicodeHighlighter(this._editor, highlightOptions, this._updateState));
+            this._highlighter = ( (new ViewportUnicodeHighlighter(this._editor, highlightOptions, this._updateState)));
         }
     }
     getDecorationInfo(decoration) {
@@ -174,11 +167,11 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
         return null;
     }
 };
-UnicodeHighlighter = ( __decorate([
-    ( __param(1, IEditorWorkerService)),
-    ( __param(2, IWorkspaceTrustManagementService)),
-    ( __param(3, IInstantiationService))
-], UnicodeHighlighter));
+UnicodeHighlighter = ( (__decorate([
+    ( (__param(1, IEditorWorkerService))),
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, IInstantiationService)))
+], UnicodeHighlighter)));
 function resolveOptions(trusted, options) {
     return {
         nonBasicASCII: options.nonBasicASCII === inUntrustedWorkspace ? !trusted : options.nonBasicASCII,
@@ -199,7 +192,7 @@ let DocumentUnicodeHighlighter = class DocumentUnicodeHighlighter extends Dispos
         this._editorWorkerService = _editorWorkerService;
         this._model = this._editor.getModel();
         this._decorations = this._editor.createDecorationsCollection();
-        this._updateSoon = this._register(( new RunOnceScheduler(() => this._update(), 250)));
+        this._updateSoon = this._register(( (new RunOnceScheduler(() => this._update(), 250))));
         this._register(this._editor.onDidChangeModelContent(() => {
             this._updateSoon.schedule();
         }));
@@ -241,7 +234,7 @@ let DocumentUnicodeHighlighter = class DocumentUnicodeHighlighter extends Dispos
         });
     }
     getDecorationInfo(decoration) {
-        if (!( this._decorations.has(decoration))) {
+        if (!( (this._decorations.has(decoration)))) {
             return null;
         }
         const model = this._editor.getModel();
@@ -256,9 +249,9 @@ let DocumentUnicodeHighlighter = class DocumentUnicodeHighlighter extends Dispos
         };
     }
 };
-DocumentUnicodeHighlighter = ( __decorate([
-    ( __param(3, IEditorWorkerService))
-], DocumentUnicodeHighlighter));
+DocumentUnicodeHighlighter = ( (__decorate([
+    ( (__param(3, IEditorWorkerService)))
+], DocumentUnicodeHighlighter)));
 class ViewportUnicodeHighlighter extends Disposable {
     constructor(_editor, _options, _updateState) {
         super();
@@ -267,7 +260,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         this._updateState = _updateState;
         this._model = this._editor.getModel();
         this._decorations = this._editor.createDecorationsCollection();
-        this._updateSoon = this._register(( new RunOnceScheduler(() => this._update(), 250)));
+        this._updateSoon = this._register(( (new RunOnceScheduler(() => this._update(), 250))));
         this._register(this._editor.onDidLayoutChange(() => {
             this._updateSoon.schedule();
         }));
@@ -322,7 +315,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         this._decorations.set(decorations);
     }
     getDecorationInfo(decoration) {
-        if (!( this._decorations.has(decoration))) {
+        if (!( (this._decorations.has(decoration)))) {
             return null;
         }
         const model = this._editor.getModel();
@@ -337,11 +330,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localizeWithPath(
-    'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-    'unicodeHighlight.configureUnicodeHighlightOptions',
-    'Configure Unicode Highlight Options'
-));
+const configureUnicodeHighlightOptionsStr = ( localizeWithPath(_moduleId, 4, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -359,7 +348,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
             return [];
         }
         const result = [];
-        const existedReason = ( new Set());
+        const existedReason = ( (new Set()));
         let index = 300;
         for (const d of lineDecorations) {
             const highlightInfo = unicodeHighlighter.getDecorationInfo(d);
@@ -374,8 +363,8 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case 0 : {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localizeWithPath(
-                            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                            'unicodeHighlight.characterIsAmbiguousASCII',
+                            _moduleId,
+                            5,
                             'The character {0} could be confused with the ASCII character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -383,8 +372,8 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localizeWithPath(
-                            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                            'unicodeHighlight.characterIsAmbiguous',
+                            _moduleId,
+                            6,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -393,23 +382,18 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case 1 :
-                    reason = ( localizeWithPath(
-                        'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                        'unicodeHighlight.characterIsInvisible',
-                        'The character {0} is invisible.',
-                        codePointStr
-                    ));
+                    reason = ( localizeWithPath(_moduleId, 7, 'The character {0} is invisible.', codePointStr));
                     break;
                 case 2 :
                     reason = ( localizeWithPath(
-                        'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                        'unicodeHighlight.characterIsNonBasicAscii',
+                        _moduleId,
+                        8,
                         'The character {0} is not a basic ASCII character.',
                         codePointStr
                     ));
                     break;
             }
-            if (( existedReason.has(reason))) {
+            if (( (existedReason.has(reason)))) {
                 continue;
             }
             existedReason.add(reason);
@@ -419,17 +403,13 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'unicodeHighlight.adjustSettings',
-                'Adjust settings'
-            ));
+            const adjustSettings = ( localizeWithPath(_moduleId, 9, 'Adjust settings'));
             const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
-            const markdown = ( new MarkdownString('', true))
+            const markdown = ( (new MarkdownString('', true)))
                 .appendMarkdown(reason)
                 .appendText(' ')
                 .appendLink(uri, adjustSettings, configureUnicodeHighlightOptionsStr);
-            result.push(( new MarkdownHover(this, d.range, [markdown], false, index++)));
+            result.push(( (new MarkdownHover(this, d.range, [markdown], false, index++))));
         }
         return result;
     }
@@ -437,12 +417,12 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
         return renderMarkdownHovers(context, hoverParts, this._editor, this._languageService, this._openerService);
     }
 };
-UnicodeHighlighterHoverParticipant = ( __decorate([
-    ( __param(1, ILanguageService)),
-    ( __param(2, IOpenerService))
-], UnicodeHighlighterHoverParticipant));
+UnicodeHighlighterHoverParticipant = ( (__decorate([
+    ( (__param(1, ILanguageService))),
+    ( (__param(2, IOpenerService)))
+], UnicodeHighlighterHoverParticipant)));
 function codePointToHex(codePoint) {
-    return `U+${( codePoint.toString(16)).padStart(4, '0')}`;
+    return `U+${( (codePoint.toString(16))).padStart(4, '0')}`;
 }
 function formatCodePointMarkdown(codePoint) {
     let value = `\`${codePointToHex(codePoint)}\``;
@@ -462,9 +442,9 @@ function computeReason(char, options) {
 }
 class Decorations {
     constructor() {
-        this.map = ( new Map());
+        this.map = ( (new Map()));
     }
-    static { this.instance = ( new Decorations()); }
+    static { this.instance = ( (new Decorations())); }
     getDecorationFromOptions(options) {
         return this.getDecoration(!options.includeComments, !options.includeStrings);
     }
@@ -492,19 +472,11 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.disableHighlightingInComments',
-                'Disable highlighting of characters in comments'
-            )),
+            label: ( localizeWithPath(_moduleId, 10, 'Disable highlighting of characters in comments')),
             alias: 'Disable highlighting of characters in comments',
             precondition: undefined
         });
-        this.shortLabel = ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.disableHighlightingInComments.shortLabel',
-            'Disable Highlight In Comments'
-        ));
+        this.shortLabel = ( localizeWithPath(_moduleId, 11, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -521,19 +493,11 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.disableHighlightingInStrings',
-                'Disable highlighting of characters in strings'
-            )),
+            label: ( localizeWithPath(_moduleId, 12, 'Disable highlighting of characters in strings')),
             alias: 'Disable highlighting of characters in strings',
             precondition: undefined
         });
-        this.shortLabel = ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.disableHighlightingInStrings.shortLabel',
-            'Disable Highlight In Strings'
-        ));
+        this.shortLabel = ( localizeWithPath(_moduleId, 13, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -550,19 +514,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters',
-                'Disable highlighting of ambiguous characters'
-            )),
+            label: ( localizeWithPath(_moduleId, 14, 'Disable highlighting of ambiguous characters')),
             alias: 'Disable highlighting of ambiguous characters',
             precondition: undefined
         });
-        this.shortLabel = ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.disableHighlightingOfAmbiguousCharacters.shortLabel',
-            'Disable Ambiguous Highlight'
-        ));
+        this.shortLabel = ( localizeWithPath(_moduleId, 15, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -579,19 +535,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.disableHighlightingOfInvisibleCharacters',
-                'Disable highlighting of invisible characters'
-            )),
+            label: ( localizeWithPath(_moduleId, 16, 'Disable highlighting of invisible characters')),
             alias: 'Disable highlighting of invisible characters',
             precondition: undefined
         });
-        this.shortLabel = ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.disableHighlightingOfInvisibleCharacters.shortLabel',
-            'Disable Invisible Highlight'
-        ));
+        this.shortLabel = ( localizeWithPath(_moduleId, 17, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -608,19 +556,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters',
-                'Disable highlighting of non basic ASCII characters'
-            )),
+            label: ( localizeWithPath(_moduleId, 18, 'Disable highlighting of non basic ASCII characters')),
             alias: 'Disable highlighting of non basic ASCII characters',
             precondition: undefined
         });
-        this.shortLabel = ( localizeWithPath(
-            'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-            'unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters.shortLabel',
-            'Disable Non ASCII Highlight'
-        ));
+        this.shortLabel = ( localizeWithPath(_moduleId, 19, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -637,11 +577,7 @@ class ShowExcludeOptions extends EditorAction {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'action.unicodeHighlight.showExcludeOptions',
-                "Show Exclude Options"
-            )),
+            label: ( localizeWithPath(_moduleId, 20, "Show Exclude Options")),
             alias: 'Show Exclude Options',
             precondition: undefined
         });
@@ -654,15 +590,15 @@ class ShowExcludeOptions extends EditorAction {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return ( localizeWithPath(
-                    'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                    'unicodeHighlight.excludeInvisibleCharFromBeingHighlighted',
+                    _moduleId,
+                    21,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 ));
             }
             return ( localizeWithPath(
-                'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                'unicodeHighlight.excludeCharFromBeingHighlighted',
+                _moduleId,
+                22,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             ));
@@ -672,8 +608,8 @@ class ShowExcludeOptions extends EditorAction {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localizeWithPath(
-                        'vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter',
-                        "unicodeHighlight.allowCommonCharactersInLanguage",
+                        _moduleId,
+                        23,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),
@@ -688,23 +624,23 @@ class ShowExcludeOptions extends EditorAction {
             run: () => excludeCharFromBeingHighlighted(configurationService, [codePoint])
         });
         if (inComment) {
-            const action = ( new DisableHighlightingInCommentsAction());
+            const action = ( (new DisableHighlightingInCommentsAction()));
             options.push({ label: action.label, run: async () => action.runAction(configurationService) });
         }
         else if (inString) {
-            const action = ( new DisableHighlightingInStringsAction());
+            const action = ( (new DisableHighlightingInStringsAction()));
             options.push({ label: action.label, run: async () => action.runAction(configurationService) });
         }
         if (reason.kind === 0 ) {
-            const action = ( new DisableHighlightingOfAmbiguousCharactersAction());
+            const action = ( (new DisableHighlightingOfAmbiguousCharactersAction()));
             options.push({ label: action.label, run: async () => action.runAction(configurationService) });
         }
         else if (reason.kind === 1 ) {
-            const action = ( new DisableHighlightingOfInvisibleCharactersAction());
+            const action = ( (new DisableHighlightingOfInvisibleCharactersAction()));
             options.push({ label: action.label, run: async () => action.runAction(configurationService) });
         }
         else if (reason.kind === 2 ) {
-            const action = ( new DisableHighlightingOfNonBasicAsciiCharactersAction());
+            const action = ( (new DisableHighlightingOfNonBasicAsciiCharactersAction()));
             options.push({ label: action.label, run: async () => action.runAction(configurationService) });
         }
         else {
@@ -745,7 +681,7 @@ async function excludeLocaleFromBeingHighlighted(configurationService, locales)
     await configurationService.updateValue(unicodeHighlightConfigKeys.allowedLocales, value, 2 );
 }
 function expectNever(value) {
-    throw new Error(`Unexpected value: ${value}`);
+    throw ( (new Error(`Unexpected value: ${value}`)));
 }
 registerEditorAction(DisableHighlightingOfAmbiguousCharactersAction);
 registerEditorAction(DisableHighlightingOfInvisibleCharactersAction);

package/vscode/src/vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js

@@ -5,6 +5,7 @@ import { registerEditorContribution } from '../../../browser/editorExtensions.js
 import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+const _moduleId = "vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators";
 const ignoreUnusualLineTerminators = 'ignoreUnusualLineTerminators';
 function writeIgnoreState(codeEditorService, model, state) {
     codeEditorService.setModelProperty(model.uri, ignoreUnusualLineTerminators, state);
@@ -67,32 +68,16 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: ( localizeWithPath(
-                    'vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators',
-                    'unusualLineTerminators.title',
-                    "Unusual Line Terminators"
-                )),
-                message: ( localizeWithPath(
-                    'vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators',
-                    'unusualLineTerminators.message',
-                    "Detected unusual line terminators"
-                )),
+                title: ( localizeWithPath(_moduleId, 0, "Unusual Line Terminators")),
+                message: ( localizeWithPath(_moduleId, 1, "Detected unusual line terminators")),
                 detail: ( localizeWithPath(
-                    'vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators',
-                    'unusualLineTerminators.detail',
+                    _moduleId,
+                    2,
                     "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.",
                     basename(model.uri)
                 )),
-                primaryButton: ( localizeWithPath(
-                    'vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators',
-                    { key: 'unusualLineTerminators.fix', comment: ['&& denotes a mnemonic'] },
-                    "&&Remove Unusual Line Terminators"
-                )),
-                cancelButton: ( localizeWithPath(
-                    'vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators',
-                    'unusualLineTerminators.ignore',
-                    "Ignore"
-                ))
+                primaryButton: ( localizeWithPath(_moduleId, 3, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localizeWithPath(_moduleId, 4, "Ignore"))
             });
         }
         finally {
@@ -105,9 +90,9 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         model.removeUnusualLineTerminators(this._editor.getSelections());
     }
 };
-UnusualLineTerminatorsDetector = ( __decorate([
-    ( __param(1, IDialogService)),
-    ( __param(2, ICodeEditorService))
-], UnusualLineTerminatorsDetector));
+UnusualLineTerminatorsDetector = ( (__decorate([
+    ( (__param(1, IDialogService))),
+    ( (__param(2, ICodeEditorService)))
+], UnusualLineTerminatorsDetector)));
 registerEditorContribution(UnusualLineTerminatorsDetector.ID, UnusualLineTerminatorsDetector, 1 );
 export { UnusualLineTerminatorsDetector };

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.js

@@ -15,49 +15,46 @@ import '../../../../platform/theme/common/colors/miscColors.js';
 import '../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId, registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+const _moduleId = "vs/editor/contrib/wordHighlighter/browser/highlightDecorations";
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlight',
+    _moduleId,
+    0,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlightStrong',
+    _moduleId,
+    1,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', { light: wordHighlightBackground, dark: wordHighlightBackground, hcDark: wordHighlightBackground, hcLight: wordHighlightBackground }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlightText',
+    _moduleId,
+    2,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlightBorder',
+    _moduleId,
+    3,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlightStrongBorder',
+    _moduleId,
+    4,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', { light: wordHighlightBorder, dark: wordHighlightBorder, hcDark: wordHighlightBorder, hcLight: wordHighlightBorder }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'wordHighlightTextBorder',
-    "Border color of a textual occurrence for a symbol."
-)));
+registerColor('editor.wordHighlightTextBorder', { light: wordHighlightBorder, dark: wordHighlightBorder, hcDark: wordHighlightBorder, hcLight: wordHighlightBorder }, ( localizeWithPath(_moduleId, 5, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', { dark: '#A0A0A0CC', light: '#A0A0A0CC', hcDark: '#A0A0A0CC', hcLight: '#A0A0A0CC' }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'overviewRulerWordHighlightForeground',
+    _moduleId,
+    6,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', { dark: '#C0A0C0CC', light: '#C0A0C0CC', hcDark: '#C0A0C0CC', hcLight: '#C0A0C0CC' }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'overviewRulerWordHighlightStrongForeground',
+    _moduleId,
+    7,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', { dark: overviewRulerSelectionHighlightForeground, light: overviewRulerSelectionHighlightForeground, hcDark: overviewRulerSelectionHighlightForeground, hcLight: overviewRulerSelectionHighlightForeground }, ( localizeWithPath(
-    'vs/editor/contrib/wordHighlighter/browser/highlightDecorations',
-    'overviewRulerWordHighlightTextForeground',
+    _moduleId,
+    8,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({
@@ -134,7 +131,7 @@ function getSelectionHighlightDecorationOptions(hasSemanticHighlights) {
 registerThemingParticipant((theme, collector) => {
     const selectionHighlight = theme.getColor(editorSelectionHighlight);
     if (selectionHighlight) {
-        collector.addRule(`.monaco-editor .selectionHighlight { background-color: ${( selectionHighlight.transparent(0.5))}; }`);
+        collector.addRule(`.monaco-editor .selectionHighlight { background-color: ${( (selectionHighlight.transparent(0.5)))}; }`);
     }
 });
 export { getHighlightDecorationOptions, getSelectionHighlightDecorationOptions };