@codingame/monaco-vscode-api 1.83.1 → 1.83.3-next.0

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.js

@@ -1,4 +1,4 @@
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
@@ -10,10 +10,7 @@ registry.registerConfiguration({
     'properties': {
         'workbench.enableExperiments': {
             'type': 'boolean',
-            'description': ( localize(
-                'workbench.enableExperiments',
-                "Fetches experiments to run from a Microsoft online service."
-            )),
+            'description': localizeWithPath('vs/workbench/services/assignment/common/assignmentService', 'workbench.enableExperiments', "Fetches experiments to run from a Microsoft online service."),
             'default': true,
             'scope': 1 ,
             'restricted': true,

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -5,6 +5,7 @@ import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 function getAuthenticationProviderActivationEvent(id) { return `onAuthenticationRequest:${id}`; }
 function readAccountUsages(storageService, providerId, accountName) {
     const accountKey = `${providerId}-${accountName}-usages`;
@@ -76,10 +77,39 @@ CommandsRegistry.registerCommand('workbench.getCodeExchangeProxyEndpoints', func
     const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
     return environmentService.options?.codeExchangeProxyEndpoints;
 });
+const authenticationDefinitionSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: {
+            type: 'string',
+            description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.id', 'The id of the authentication provider.')
+        },
+        label: {
+            type: 'string',
+            description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.label', 'The human readable name of the authentication provider.'),
+        }
+    }
+};
+( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'authentication',
+    jsonSchema: {
+        description: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', { key: 'authenticationExtensionPoint', comment: [`'Contributes' means adds here`] }, 'Contributes authentication'),
+        type: 'array',
+        items: authenticationDefinitionSchema
+    },
+    activationEventsGenerator: (authenticationProviders, result) => {
+        for (const authenticationProvider of authenticationProviders) {
+            if (authenticationProvider.id) {
+                result.push(`onAuthenticationRequest:${authenticationProvider.id}`);
+            }
+        }
+    }
+}));
 MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
     command: {
         id: 'noAuthenticationProviders',
-        title: ( nls.localize('authentication.Placeholder', "No accounts requested yet...")),
+        title: nls.localizeWithPath('vs/workbench/services/authentication/browser/authenticationService', 'authentication.Placeholder', "No accounts requested yet..."),
         precondition: ContextKeyExpr.false()
     },
 });

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -103,10 +103,7 @@ let JSONEditingService = class JSONEditingService {
     toErrorMessage(error) {
         switch (error) {
             case 0 : {
-                return ( nls.localize(
-                    'errorInvalidFile',
-                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
-                ));
+                return nls.localizeWithPath('vs/workbench/services/configuration/common/jsonEditingService', 'errorInvalidFile', "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again.");
             }
         }
     }

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -4,7 +4,7 @@ import * as types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import { isWindows, isMacintosh, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { VariableKind, VariableError } from './configurationResolver.js';
 import { replaceAsync } from 'monaco-editor/esm/vs/base/common/strings.js';
 class AbstractVariableResolverService {
@@ -133,7 +133,7 @@ class AbstractVariableResolverService {
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw new VariableError(variableKind, (localize('canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
+            throw new VariableError(variableKind, (localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -143,7 +143,7 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -151,15 +151,15 @@ class AbstractVariableResolverService {
                 if (folder) {
                     return folder;
                 }
-                throw new VariableError(variableKind, localize('canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
+                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
             }
             if (folderUri) {
                 return folderUri;
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
-                throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
+                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
             }
-            throw new VariableError(variableKind, localize('canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
         };
         switch (variable) {
             case 'env':
@@ -172,19 +172,19 @@ class AbstractVariableResolverService {
                     }
                     return '';
                 }
-                throw new VariableError(VariableKind.Env, localize('missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
+                throw new VariableError(VariableKind.Env, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (types.isUndefinedOrNull(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
+                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
                     }
                     if (types.isObject(config)) {
-                        throw new VariableError(VariableKind.Config, localize('configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
+                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
                     }
                     return config;
                 }
-                throw new VariableError(VariableKind.Config, localize('missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
+                throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
             case 'command':
                 return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
             case 'input':
@@ -193,11 +193,11 @@ class AbstractVariableResolverService {
                 if (argument) {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
-                        throw new VariableError(VariableKind.ExtensionInstallFolder, localize('extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
+                        throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
                     }
                     return this.fsPath(ext.extensionLocation);
                 }
-                throw new VariableError(VariableKind.ExtensionInstallFolder, localize('missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
+                throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
             default: {
                 switch (variable) {
                     case 'workspaceRoot':
@@ -212,21 +212,21 @@ class AbstractVariableResolverService {
                         if (environment.userHome) {
                             return environment.userHome;
                         }
-                        throw new VariableError(VariableKind.UserHome, localize('canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
+                        throw new VariableError(VariableKind.UserHome, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
                     }
                     case 'lineNumber': {
                         const lineNumber = this._context.getLineNumber();
                         if (lineNumber) {
                             return lineNumber;
                         }
-                        throw new VariableError(VariableKind.LineNumber, localize('canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
+                        throw new VariableError(VariableKind.LineNumber, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
                     }
                     case 'selectedText': {
                         const selectedText = this._context.getSelectedText();
                         if (selectedText) {
                             return selectedText;
                         }
-                        throw new VariableError(VariableKind.SelectedText, localize('canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
+                        throw new VariableError(VariableKind.SelectedText, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
                     }
                     case 'file':
                         return getFilePath(VariableKind.File);
@@ -291,7 +291,7 @@ class AbstractVariableResolverService {
             if (typeof v === 'string') {
                 return v;
             }
-            throw new VariableError(variableKind, localize('noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
+            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
         }
         return match;
     }

package/vscode/src/vs/workbench/services/decorations/browser/decorationsService.js

@@ -8,7 +8,7 @@ import { createCSSRule, asCSSPropertyValue, removeCSSRulesContainingSelector, cr
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
@@ -147,7 +147,7 @@ class DecorationStyles {
         const strikethrough = ( data.some(d => d.strikethrough));
         if (onlyChildren) {
             badgeClassName = rule.bubbleBadgeClassName;
-            tooltip = ( localize('bubbleTitle', "Contains emphasized items"));
+            tooltip = localizeWithPath('vs/workbench/services/decorations/browser/decorationsService', 'bubbleTitle', "Contains emphasized items");
         }
         return {
             labelClassName,

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -2,7 +2,7 @@ import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
 import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
@@ -15,10 +15,7 @@ const editorAssociationsConfigurationNode = {
     properties: {
         'workbench.editorAssociations': {
             type: 'object',
-            markdownDescription: ( localize(
-                'editor.editorAssociations',
-                "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
-            )),
+            markdownDescription: localizeWithPath('vs/workbench/services/editor/common/editorResolverService', 'editor.editorAssociations', "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."),
             additionalProperties: {
                 type: 'string'
             }

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -67,8 +67,8 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
     constructor() {
         super({
             id: 'workbench.extensions.action.manageAuthorizedExtensionURIs',
-            title: { value: ( localize('manage', "Manage Authorized Extension URIs...")), original: 'Manage Authorized Extension URIs...' },
-            category: { value: ( localize('extensions', "Extensions")), original: 'Extensions' },
+            title: { value: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'manage', "Manage Authorized Extension URIs..."), original: 'Manage Authorized Extension URIs...' },
+            category: { value: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'extensions', "Extensions"), original: 'Extensions' },
             menu: {
                 id: MenuId.CommandPalette,
                 when: ( IsWebContext.toNegated())
@@ -81,7 +81,7 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
         const storage = ( new UserTrustedExtensionIdStorage(storageService));
         const items = ( storage.extensions.map(label => ({ label, picked: true })));
         if (items.length === 0) {
-            await quickInputService.pick([{ label: ( localize('no', 'There are currently no authorized extension URIs.')) }]);
+            await quickInputService.pick([{ label: localizeWithPath('vs/workbench/services/extensions/browser/extensionUrlHandler', 'no', 'There are currently no authorized extension URIs.') }]);
             return;
         }
         const result = await quickInputService.pick(items, { canPickMany: true });

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.js

@@ -40,7 +40,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         this._storageService = _storageService;
         this.remoteAuthority = null;
         this.extensions = null;
-        this._onDidExit = this._register(( (new Emitter())));
+        this._onDidExit = this._register(( new Emitter()));
         this.onExit = this._onDidExit.event;
         this._isTerminating = false;
         this._protocolPromise = null;
@@ -48,12 +48,12 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, 'webWorker');
     }
     async _getWebWorkerExtensionHostIframeSrc() {
-        const suffixSearchParams = ( (new URLSearchParams()));
+        const suffixSearchParams = ( new URLSearchParams());
         if (this._environmentService.debugExtensionHost && this._environmentService.debugRenderer) {
             suffixSearchParams.set('debugged', '1');
         }
         COI.addSearchParam(suffixSearchParams, true, true);
-        const suffix = `?${( ( suffixSearchParams.toString()))}`;
+        const suffix = `?${( suffixSearchParams.toString())}`;
         const iframeModulePath = 'vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html';
         if (platform.isWeb) {
             const webEndpointUrlTemplate = this._productService.webEndpointUrlTemplate;
@@ -71,16 +71,14 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                     .replace('{{uuid}}', `v--${hash}`)
                     .replace('{{commit}}', commit)
                     .replace('{{quality}}', quality));
-                const res = ( (new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`)));
+                const res = ( new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`));
                 res.searchParams.set('parentOrigin', window.origin);
                 res.searchParams.set('salt', stableOriginUUID);
-                return (
-                     (res.toString())
-                );
+                return ( res.toString());
             }
         }
-        const relativeExtensionHostIframeSrc = ( (FileAccess.asBrowserUri(iframeModulePath)));
-        return `${( ( relativeExtensionHostIframeSrc.toString(true)))}${suffix}`;
+        const relativeExtensionHostIframeSrc = ( FileAccess.asBrowserUri(iframeModulePath));
+        return `${( relativeExtensionHostIframeSrc.toString(true))}${suffix}`;
     }
     async start() {
         if (!this._protocolPromise) {
@@ -91,7 +89,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
     }
     async _startInsideIframe() {
         const webWorkerExtensionHostIframeSrc = await this._getWebWorkerExtensionHostIframeSrc();
-        const emitter = this._register(( (new Emitter())));
+        const emitter = this._register(( new Emitter()));
         const iframe = document.createElement('iframe');
         iframe.setAttribute('class', 'web-worker-ext-host-iframe');
         iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
@@ -100,7 +98,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         iframe.style.display = 'none';
         const vscodeWebWorkerExtHostId = generateUuid();
         iframe.setAttribute('src', `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`);
-        const barrier = ( (new Barrier()));
+        const barrier = ( new Barrier());
         let port;
         let barrierError = null;
         let barrierHasError = false;
@@ -130,7 +128,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             }
             if (event.data.error) {
                 const { name, message, stack } = event.data.error;
-                const err = ( (new Error()));
+                const err = ( new Error());
                 err.message = message;
                 err.name = name;
                 err.stack = stack;
@@ -139,7 +137,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
             const { data } = event.data;
             if (barrier.isOpen() || !(data instanceof MessagePort)) {
                 console.warn('UNEXPECTED message', event);
-                const err = ( (new Error('UNEXPECTED message')));
+                const err = ( new Error('UNEXPECTED message'));
                 return rejectBarrier(81 , err);
             }
             resolveBarrier(data);
@@ -150,8 +148,8 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         if (barrierHasError) {
             throw barrierError;
         }
-        const messagePorts = this._environmentService.options?.messagePorts ?? ( (new Map()));
-        iframe.contentWindow.postMessage({ type: 'vscode.init', data: messagePorts }, '*', [...( (messagePorts.values()))]);
+        const messagePorts = this._environmentService.options?.messagePorts ?? ( new Map());
+        iframe.contentWindow.postMessage({ type: 'vscode.init', data: messagePorts }, '*', [...( messagePorts.values())]);
         port.onmessage = (event) => {
             const { data } = event;
             if (!(data instanceof ArrayBuffer)) {
@@ -159,7 +157,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
                 this._onDidExit.fire([77, 'UNKNOWN data received']);
                 return;
             }
-            emitter.fire(VSBuffer.wrap(( (new Uint8Array(data, 0, data.byteLength)))));
+            emitter.fire(VSBuffer.wrap(( new Uint8Array(data, 0, data.byteLength))));
         };
         const protocol = {
             onMessage: emitter.event,
@@ -206,7 +204,7 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         const nlsBaseUrl = this._productService.extensionsGallery?.nlsBaseUrl;
         let nlsUrlWithDetails = undefined;
         if (nlsBaseUrl && this._productService.commit && !platform.Language.isDefaultVariant()) {
-            nlsUrlWithDetails = URI.joinPath(( (URI.parse(nlsBaseUrl))), this._productService.commit, this._productService.version, platform.Language.value());
+            nlsUrlWithDetails = URI.joinPath(( URI.parse(nlsBaseUrl)), this._productService.commit, this._productService.version, platform.Language.value());
         }
         return {
             commit: this._productService.commit,
@@ -258,16 +256,16 @@ let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
         };
     }
 };
-WebWorkerExtensionHost = ( (__decorate([
-    ( (__param(3, ITelemetryService))),
-    ( (__param(4, IWorkspaceContextService))),
-    ( (__param(5, ILabelService))),
-    ( (__param(6, ILogService))),
-    ( (__param(7, ILoggerService))),
-    ( (__param(8, IBrowserWorkbenchEnvironmentService))),
-    ( (__param(9, IUserDataProfilesService))),
-    ( (__param(10, IProductService))),
-    ( (__param(11, ILayoutService))),
-    ( (__param(12, IStorageService)))
-], WebWorkerExtensionHost)));
+WebWorkerExtensionHost = ( __decorate([
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ILogService)),
+    ( __param(7, ILoggerService)),
+    ( __param(8, IBrowserWorkbenchEnvironmentService)),
+    ( __param(9, IUserDataProfilesService)),
+    ( __param(10, IProductService)),
+    ( __param(11, ILayoutService)),
+    ( __param(12, IStorageService))
+], WebWorkerExtensionHost));
 export { WebWorkerExtensionHost };