@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/services/extensions/common/rpcProtocol.js

@@ -189,7 +189,7 @@ class RPCProtocol extends Disposable {
         for (let i = 0, len = identifiers.length; i < len; i++) {
             const identifier = identifiers[i];
             if (!this._locals[identifier.nid]) {
-                throw new Error(`Missing proxy instance ${identifier.sid}`);
+                throw ( new Error(`Missing proxy instance ${identifier.sid}`));
             }
         }
     }
@@ -347,11 +347,13 @@ class RPCProtocol extends Disposable {
     _doInvokeHandler(rpcId, methodName, args) {
         const actor = this._locals[rpcId];
         if (!actor) {
-            throw new Error('Unknown actor ' + getStringIdentifierForProxy(rpcId));
+            throw ( new Error('Unknown actor ' + getStringIdentifierForProxy(rpcId)));
         }
         const method = actor[methodName];
         if (typeof method !== 'function') {
-            throw new Error('Unknown method ' + methodName + ' on actor ' + getStringIdentifierForProxy(rpcId));
+            throw ( new Error(
+                'Unknown method ' + methodName + ' on actor ' + getStringIdentifierForProxy(rpcId)
+            ));
         }
         return method.apply(actor, args);
     }

package/vscode/src/vs/workbench/services/extensions/worker/polyfillNestedWorker.js

@@ -25,7 +25,7 @@ const _bootstrapFnSource = ( (function _bootstrapFn(workerUrl) {
         });
         port.start();
         globalThis.Worker = class {
-            constructor() { throw new TypeError('Nested workers from within nested worker are NOT supported.'); }
+            constructor() { throw ( new TypeError('Nested workers from within nested worker are NOT supported.')); }
         };
         importScripts(workerUrl);
     };

package/vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js

@@ -22,40 +22,37 @@ import { IMarkerService } from '../../../../platform/markers/common/markers.serv
 import { ITextResourceConfigurationService } from '../../../../editor/common/services/textResourceConfiguration.js';
 import '../../../../platform/instantiation/common/instantiation.js';
 var FilesConfigurationService_1;
-const AutoSaveAfterShortDelayContext = ( new RawContextKey('autoSaveAfterShortDelayContext', false, true));
+const _moduleId = "vs/workbench/services/filesConfiguration/common/filesConfigurationService";
+const AutoSaveAfterShortDelayContext = ( (new RawContextKey('autoSaveAfterShortDelayContext', false, true)));
 let FilesConfigurationService = class FilesConfigurationService extends Disposable {
     static { FilesConfigurationService_1 = this; }
     static { this.DEFAULT_AUTO_SAVE_MODE = isWeb ? AutoSaveConfiguration.AFTER_DELAY : AutoSaveConfiguration.OFF; }
     static { this.DEFAULT_AUTO_SAVE_DELAY = 1000; }
     static { this.READONLY_MESSAGES = {
         providerReadonly: { value: ( localizeWithPath(
-            'vs/workbench/services/filesConfiguration/common/filesConfigurationService',
-            'providerReadonly',
+            _moduleId,
+            0,
             "Editor is read-only because the file system of the file is read-only."
         )), isTrusted: true },
         sessionReadonly: { value: ( localizeWithPath(
-            'vs/workbench/services/filesConfiguration/common/filesConfigurationService',
-            { key: 'sessionReadonly', comment: ['Please do not translate the word "command", it is part of our internal syntax which must not change', '{Locked="](command:{0})"}'] },
+            _moduleId,
+            1,
             "Editor is read-only because the file was set read-only in this session. [Click here](command:{0}) to set writeable.",
             'workbench.action.files.setActiveEditorWriteableInSession'
         )), isTrusted: true },
         configuredReadonly: { value: ( localizeWithPath(
-            'vs/workbench/services/filesConfiguration/common/filesConfigurationService',
-            { key: 'configuredReadonly', comment: ['Please do not translate the word "command", it is part of our internal syntax which must not change', '{Locked="](command:{0})"}'] },
+            _moduleId,
+            2,
             "Editor is read-only because the file was set read-only via settings. [Click here](command:{0}) to configure.",
             `workbench.action.openSettings?${encodeURIComponent('["files.readonly"]')}`
         )), isTrusted: true },
         fileLocked: { value: ( localizeWithPath(
-            'vs/workbench/services/filesConfiguration/common/filesConfigurationService',
-            { key: 'fileLocked', comment: ['Please do not translate the word "command", it is part of our internal syntax which must not change', '{Locked="](command:{0})"}'] },
+            _moduleId,
+            3,
             "Editor is read-only because of file permissions. [Click here](command:{0}) to set writeable anyway.",
             'workbench.action.files.setActiveEditorWriteableInSession'
         )), isTrusted: true },
-        fileReadonly: { value: ( localizeWithPath(
-            'vs/workbench/services/filesConfiguration/common/filesConfigurationService',
-            'fileReadonly',
-            "Editor is read-only because the file is read-only."
-        )), isTrusted: true }
+        fileReadonly: { value: ( localizeWithPath(_moduleId, 4, "Editor is read-only because the file is read-only.")), isTrusted: true }
     }; }
     constructor(contextKeyService, configurationService, contextService, environmentService, uriIdentityService, fileService, markerService, textResourceConfigurationService) {
         super();
@@ -67,20 +64,20 @@ let FilesConfigurationService = class FilesConfigurationService extends Disposab
         this.fileService = fileService;
         this.markerService = markerService;
         this.textResourceConfigurationService = textResourceConfigurationService;
-        this._onDidChangeAutoSaveConfiguration = this._register(( new Emitter()));
+        this._onDidChangeAutoSaveConfiguration = this._register(( (new Emitter())));
         this.onDidChangeAutoSaveConfiguration = this._onDidChangeAutoSaveConfiguration.event;
-        this._onDidChangeAutoSaveDisabled = this._register(( new Emitter()));
+        this._onDidChangeAutoSaveDisabled = this._register(( (new Emitter())));
         this.onDidChangeAutoSaveDisabled = this._onDidChangeAutoSaveDisabled.event;
-        this._onDidChangeFilesAssociation = this._register(( new Emitter()));
+        this._onDidChangeFilesAssociation = this._register(( (new Emitter())));
         this.onDidChangeFilesAssociation = this._onDidChangeFilesAssociation.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( (new Emitter())));
         this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this.autoSaveConfigurationCache = ( new LRUCache(1000));
-        this.autoSaveDisabledOverrides = ( new ResourceMap());
+        this.autoSaveConfigurationCache = ( (new LRUCache(1000)));
+        this.autoSaveDisabledOverrides = ( (new ResourceMap()));
         this.autoSaveAfterShortDelayContext = AutoSaveAfterShortDelayContext.bindTo(this.contextKeyService);
-        this.readonlyIncludeMatcher = this._register(( new GlobalIdleValue(() => this.createReadonlyMatcher(FILES_READONLY_INCLUDE_CONFIG))));
-        this.readonlyExcludeMatcher = this._register(( new GlobalIdleValue(() => this.createReadonlyMatcher(FILES_READONLY_EXCLUDE_CONFIG))));
-        this.sessionReadonlyOverrides = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.readonlyIncludeMatcher = this._register(( (new GlobalIdleValue(() => this.createReadonlyMatcher(FILES_READONLY_INCLUDE_CONFIG)))));
+        this.readonlyExcludeMatcher = this._register(( (new GlobalIdleValue(() => this.createReadonlyMatcher(FILES_READONLY_EXCLUDE_CONFIG)))));
+        this.sessionReadonlyOverrides = ( (new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource))));
         const configuration = configurationService.getValue();
         this.currentGlobalAutoSaveConfiguration = this.computeAutoSaveConfiguration(undefined, configuration.files);
         this.currentFilesAssociationConfiguration = configuration?.files?.associations;
@@ -89,12 +86,12 @@ let FilesConfigurationService = class FilesConfigurationService extends Disposab
         this.registerListeners();
     }
     createReadonlyMatcher(config) {
-        const matcher = this._register(( new ResourceGlobMatcher(
+        const matcher = this._register(( (new ResourceGlobMatcher(
             resource => this.configurationService.getValue(config, { resource }),
             event => event.affectsConfiguration(config),
             this.contextService,
             this.configurationService
-        )));
+        ))));
         this._register(matcher.onExpressionChange(() => this._onDidChangeReadonly.fire()));
         return matcher;
     }
@@ -238,13 +235,13 @@ let FilesConfigurationService = class FilesConfigurationService extends Disposab
     hasShortAutoSaveDelay(resourceOrEditor) {
         const resource = this.toResource(resourceOrEditor);
         if (this.getAutoSaveConfiguration(resource).isShortAutoSaveDelay) {
-            return !resource || !( this.autoSaveDisabledOverrides.has(resource));
+            return !resource || !( (this.autoSaveDisabledOverrides.has(resource)));
         }
         return false;
     }
     getAutoSaveMode(resourceOrEditor, saveReason) {
         const resource = this.toResource(resourceOrEditor);
-        if (resource && ( this.autoSaveDisabledOverrides.has(resource))) {
+        if (resource && ( (this.autoSaveDisabledOverrides.has(resource)))) {
             return { mode: 0 , reason: 4  };
         }
         const autoSaveConfiguration = this.getAutoSaveConfiguration(resource);
@@ -281,7 +278,7 @@ let FilesConfigurationService = class FilesConfigurationService extends Disposab
     async toggleAutoSave() {
         const currentSetting = this.configurationService.getValue('files.autoSave');
         let newAutoSaveValue;
-        if (( [AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE].some(setting => setting === currentSetting))) {
+        if (( ([AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE].some(setting => setting === currentSetting)))) {
             newAutoSaveValue = AutoSaveConfiguration.OFF;
         }
         else {
@@ -323,14 +320,14 @@ let FilesConfigurationService = class FilesConfigurationService extends Disposab
         return this.configurationService.getValue('files.saveConflictResolution', { resource, overrideIdentifier: language }) !== 'overwriteFileOnDisk';
     }
 };
-FilesConfigurationService = FilesConfigurationService_1 = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IMarkerService)),
-    ( __param(7, ITextResourceConfigurationService))
-], FilesConfigurationService));
+FilesConfigurationService = FilesConfigurationService_1 = ( (__decorate([
+    ( (__param(0, IContextKeyService))),
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IEnvironmentService))),
+    ( (__param(4, IUriIdentityService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, IMarkerService))),
+    ( (__param(7, ITextResourceConfigurationService)))
+], FilesConfigurationService)));
 export { AutoSaveAfterShortDelayContext, FilesConfigurationService };

package/vscode/src/vs/workbench/services/language/common/languageService.js

@@ -16,44 +16,29 @@ import { Extensions } from '../../extensionManagement/common/extensionFeatures.j
 import { Registry } from '../../../../platform/registry/common/platform.js';
 import { index } from '../../../../base/common/arrays.js';
 import { MarkdownString } from '../../../../base/common/htmlContent.js';
+const _moduleId = "vs/workbench/services/language/common/languageService";
 const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languages',
     jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'vscode.extension.contributes.languages',
-            'Contributes language declarations.'
-        )),
+        description: ( localizeWithPath(_moduleId, 0, 'Contributes language declarations.')),
         type: 'array',
         items: {
             type: 'object',
             defaultSnippets: [{ body: { id: '${1:languageId}', aliases: ['${2:label}'], extensions: ['${3:extension}'], configuration: './language-configuration.json' } }],
             properties: {
                 id: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.id',
-                        'ID of the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 1, 'ID of the language.')),
                     type: 'string'
                 },
                 aliases: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.aliases',
-                        'Name aliases for the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 2, 'Name aliases for the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 extensions: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.extensions',
-                        'File extensions associated to the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 3, 'File extensions associated to the language.')),
                     default: ['.foo'],
                     type: 'array',
                     items: {
@@ -61,33 +46,21 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     }
                 },
                 filenames: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.filenames',
-                        'File names associated to the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 4, 'File names associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 filenamePatterns: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.filenamePatterns',
-                        'File name glob patterns associated to the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 5, 'File name glob patterns associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 mimetypes: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.mimetypes',
-                        'Mime types associated to the language.'
-                    )),
+                    description: ( localizeWithPath(_moduleId, 6, 'Mime types associated to the language.')),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -95,16 +68,16 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 firstLine: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.firstLine',
+                        _moduleId,
+                        7,
                         'A regular expression matching the first line of a file of the language.'
                     )),
                     type: 'string'
                 },
                 configuration: {
                     description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.configuration',
+                        _moduleId,
+                        8,
                         'A relative path to a file containing configuration options for the language.'
                     )),
                     type: 'string',
@@ -113,25 +86,17 @@ const languagesExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 icon: {
                     type: 'object',
                     description: ( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'vscode.extension.contributes.languages.icon',
+                        _moduleId,
+                        9,
                         'A icon to use as file icon, if no icon theme provides one for the language.'
                     )),
                     properties: {
                         light: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/services/language/common/languageService',
-                                'vscode.extension.contributes.languages.icon.light',
-                                'Icon path when a light theme is used'
-                            )),
+                            description: ( localizeWithPath(_moduleId, 10, 'Icon path when a light theme is used')),
                             type: 'string'
                         },
                         dark: {
-                            description: ( localizeWithPath(
-                                'vs/workbench/services/language/common/languageService',
-                                'vscode.extension.contributes.languages.icon.dark',
-                                'Icon path when a dark theme is used'
-                            )),
+                            description: ( localizeWithPath(_moduleId, 11, 'Icon path when a dark theme is used')),
                             type: 'string'
                         }
                     }
@@ -158,13 +123,18 @@ class LanguageTableRenderer extends Disposable {
     render(manifest) {
         const contributes = manifest.contributes;
         const rawLanguages = contributes?.languages || [];
-        const languages = ( rawLanguages.map(l => ({
-            id: l.id,
-            name: (l.aliases || [])[0] || l.id,
-            extensions: l.extensions || [],
-            hasGrammar: false,
-            hasSnippets: false
-        })));
+        const languages = [];
+        for (const l of rawLanguages) {
+            if (isValidLanguageExtensionPoint(l)) {
+                languages.push({
+                    id: l.id,
+                    name: (l.aliases || [])[0] || l.id,
+                    extensions: l.extensions || [],
+                    hasGrammar: false,
+                    hasSnippets: false
+                });
+            }
+        }
         const byId = index(languages, l => l.id);
         const grammars = contributes?.grammars || [];
         grammars.forEach(grammar => {
@@ -194,41 +164,21 @@ class LanguageTableRenderer extends Disposable {
             return { data: { headers: [], rows: [] }, dispose: () => { } };
         }
         const headers = [
-            ( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'language id',
-                "ID"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'language name',
-                "Name"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'file extensions',
-                "File Extensions"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'grammar',
-                "Grammar"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'snippets',
-                "Snippets"
-            ))
+            ( localizeWithPath(_moduleId, 12, "ID")),
+            ( localizeWithPath(_moduleId, 13, "Name")),
+            ( localizeWithPath(_moduleId, 14, "File Extensions")),
+            ( localizeWithPath(_moduleId, 15, "Grammar")),
+            ( localizeWithPath(_moduleId, 16, "Snippets"))
         ];
-        const rows = ( languages.sort((a, b) => a.id.localeCompare(b.id))
+        const rows = ( (languages.sort((a, b) => a.id.localeCompare(b.id))
             .map(l => {
             return [
                 l.id, l.name,
-                ( new MarkdownString()).appendMarkdown(`${( l.extensions.map(e => `\`${e}\``)).join(' ')}`),
+                ( (new MarkdownString())).appendMarkdown(`${( (l.extensions.map(e => `\`${e}\``))).join(' ')}`),
                 l.hasGrammar ? '✔︎' : '\u2014',
                 l.hasSnippets ? '✔︎' : '\u2014'
             ];
-        }));
+        })));
         return {
             data: {
                 headers,
@@ -238,17 +188,13 @@ class LanguageTableRenderer extends Disposable {
         };
     }
 }
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'languages',
-    label: ( localizeWithPath(
-        'vs/workbench/services/language/common/languageService',
-        'languages',
-        "Programming Languages"
-    )),
+    label: ( localizeWithPath(_moduleId, 17, "Programming Languages")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(LanguageTableRenderer)),
+    renderer: ( (new SyncDescriptor(LanguageTableRenderer))),
 });
 let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageService {
     constructor(extensionService, configurationService, environmentService, logService) {
@@ -262,8 +208,8 @@ let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageSe
                 const extension = extensions[i];
                 if (!Array.isArray(extension.value)) {
                     extension.collector.error(( localizeWithPath(
-                        'vs/workbench/services/language/common/languageService',
-                        'invalid',
+                        _moduleId,
+                        18,
                         "Invalid `contributes.{0}`. Expected an array.",
                         languagesExtPoint.name
                     )));
@@ -271,7 +217,7 @@ let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageSe
                 }
                 for (let j = 0, lenJ = extension.value.length; j < lenJ; j++) {
                     const ext = extension.value[j];
-                    if (isValidLanguageExtensionPoint(ext, extension.description, extension.collector)) {
+                    if (isValidLanguageExtensionPoint(ext, extension.collector)) {
                         let configuration = undefined;
                         if (ext.configuration) {
                             configuration = joinPath(extension.description.extensionLocation, ext.configuration);
@@ -313,7 +259,7 @@ let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageSe
         const configuration = this._configurationService.getValue();
         clearConfiguredLanguageAssociations();
         if (configuration.files?.associations) {
-            ( Object.keys(configuration.files.associations)).forEach(pattern => {
+            ( (Object.keys(configuration.files.associations))).forEach(pattern => {
                 const langId = configuration.files.associations[pattern];
                 if (typeof langId !== 'string') {
                     this.logService.warn(`Ignoring configured 'files.associations' for '${pattern}' because its type is not a string but '${typeof langId}'`);
@@ -326,12 +272,12 @@ let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageSe
         this._onDidChange.fire();
     }
 };
-WorkbenchLanguageService = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IEnvironmentService)),
-    ( __param(3, ILogService))
-], WorkbenchLanguageService));
+WorkbenchLanguageService = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IEnvironmentService))),
+    ( (__param(3, ILogService)))
+], WorkbenchLanguageService)));
 function isUndefinedOrStringArray(value) {
     if (typeof value === 'undefined') {
         return true;
@@ -341,74 +287,69 @@ function isUndefinedOrStringArray(value) {
     }
     return value.every(item => typeof item === 'string');
 }
-function isValidLanguageExtensionPoint(value, extension, collector) {
+function isValidLanguageExtensionPoint(value, collector) {
     if (!value) {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'invalid.empty',
-            "Empty value for `contributes.{0}`",
-            languagesExtPoint.name
-        )));
+        collector?.error(( localizeWithPath(_moduleId, 19, "Empty value for `contributes.{0}`", languagesExtPoint.name)));
         return false;
     }
     if (typeof value.id !== 'string') {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'require.id',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            20,
             "property `{0}` is mandatory and must be of type `string`",
             'id'
         )));
         return false;
     }
     if (!isUndefinedOrStringArray(value.extensions)) {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.extensions',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            21,
             "property `{0}` can be omitted and must be of type `string[]`",
             'extensions'
         )));
         return false;
     }
     if (!isUndefinedOrStringArray(value.filenames)) {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.filenames',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            22,
             "property `{0}` can be omitted and must be of type `string[]`",
             'filenames'
         )));
         return false;
     }
     if (typeof value.firstLine !== 'undefined' && typeof value.firstLine !== 'string') {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.firstLine',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            23,
             "property `{0}` can be omitted and must be of type `string`",
             'firstLine'
         )));
         return false;
     }
     if (typeof value.configuration !== 'undefined' && typeof value.configuration !== 'string') {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.configuration',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            24,
             "property `{0}` can be omitted and must be of type `string`",
             'configuration'
         )));
         return false;
     }
     if (!isUndefinedOrStringArray(value.aliases)) {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.aliases',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            25,
             "property `{0}` can be omitted and must be of type `string[]`",
             'aliases'
         )));
         return false;
     }
     if (!isUndefinedOrStringArray(value.mimetypes)) {
-        collector.error(( localizeWithPath(
-            'vs/workbench/services/language/common/languageService',
-            'opt.mimetypes',
+        collector?.error(( localizeWithPath(
+            _moduleId,
+            26,
             "property `{0}` can be omitted and must be of type `string[]`",
             'mimetypes'
         )));
@@ -416,9 +357,9 @@ function isValidLanguageExtensionPoint(value, extension, collector) {
     }
     if (typeof value.icon !== 'undefined') {
         if (typeof value.icon !== 'object' || typeof value.icon.light !== 'string' || typeof value.icon.dark !== 'string') {
-            collector.error(( localizeWithPath(
-                'vs/workbench/services/language/common/languageService',
-                'opt.icon',
+            collector?.error(( localizeWithPath(
+                _moduleId,
+                27,
                 "property `{0}` can be omitted and must be of type `object` with properties `{1}` and `{2}` of type `string`",
                 'icon',
                 'light',

package/vscode/src/vs/workbench/services/layout/browser/layoutService.js

@@ -1,4 +1,4 @@
-import { isMacintosh, isNative, isWeb } from '../../../../base/common/platform.js';
+import { isWeb, isMacintosh, isNative } from '../../../../base/common/platform.js';
 import { isAuxiliaryWindow } from '../../../../base/browser/window.js';
 import { hasNativeTitlebar, getMenuBarVisibility } from '../../../../platform/window/common/window.js';
 import { isFullscreen, isWCOEnabled } from '../../../../base/browser/browser.js';
@@ -54,9 +54,11 @@ function panelOpensMaximizedFromString(str) {
 function shouldShowCustomTitleBar(configurationService, window, menuBarToggled) {
     const inFullscreen = isFullscreen(window);
     const nativeTitleBarEnabled = hasNativeTitlebar(configurationService);
-    const showCustomTitleBar = configurationService.getValue("window.customTitleBarVisibility" );
-    if (showCustomTitleBar === "never"  && nativeTitleBarEnabled || showCustomTitleBar === "windowed"  && inFullscreen) {
-        return false;
+    if (!isWeb) {
+        const showCustomTitleBar = configurationService.getValue("window.customTitleBarVisibility" );
+        if (showCustomTitleBar === "never"  && nativeTitleBarEnabled || showCustomTitleBar === "windowed"  && inFullscreen) {
+            return false;
+        }
     }
     if (!isTitleBarEmpty(configurationService)) {
         return true;

package/vscode/src/vs/workbench/services/lifecycle/common/lifecycleService.js

@@ -57,7 +57,7 @@ let AbstractLifecycleService = class AbstractLifecycleService extends Disposable
     }
     set phase(value) {
         if (value < this.phase) {
-            throw new Error('Lifecycle cannot go backwards');
+            throw ( new Error('Lifecycle cannot go backwards'));
         }
         if (this._phase === value) {
             return;

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorInput.js

@@ -7,11 +7,8 @@ import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js'
 import { EditorInput } from '../../../common/editor/editorInput.js';
 import { KeybindingsEditorModel } from './keybindingsEditorModel.js';
 var KeybindingsEditorInput_1;
-const KeybindingsEditorIcon = registerIcon('keybindings-editor-label-icon', Codicon.keyboard, ( localizeWithPath(
-    'vs/workbench/services/preferences/browser/keybindingsEditorInput',
-    'keybindingsEditorLabelIcon',
-    'Icon of the keybindings editor label.'
-)));
+const _moduleId = "vs/workbench/services/preferences/browser/keybindingsEditorInput";
+const KeybindingsEditorIcon = registerIcon('keybindings-editor-label-icon', Codicon.keyboard, ( localizeWithPath(_moduleId, 0, 'Icon of the keybindings editor label.')));
 let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
     static { KeybindingsEditorInput_1 = this; }
     static { this.ID = 'workbench.input.keybindings'; }
@@ -25,11 +22,7 @@ let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
         return KeybindingsEditorInput_1.ID;
     }
     getName() {
-        return ( localizeWithPath(
-            'vs/workbench/services/preferences/browser/keybindingsEditorInput',
-            'keybindingsInputName',
-            "Keyboard Shortcuts"
-        ));
+        return ( localizeWithPath(_moduleId, 1, "Keyboard Shortcuts"));
     }
     getIcon() {
         return KeybindingsEditorIcon;
@@ -45,7 +38,7 @@ let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
         super.dispose();
     }
 };
-KeybindingsEditorInput = KeybindingsEditorInput_1 = ( __decorate([
-    ( __param(0, IInstantiationService))
-], KeybindingsEditorInput));
+KeybindingsEditorInput = KeybindingsEditorInput_1 = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], KeybindingsEditorInput)));
 export { KeybindingsEditorInput };