@codingame/monaco-vscode-extensions-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/workbench/api/browser/mainThreadLanguages.js

@@ -73,7 +73,7 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
         };
     }
     async $computeFullSyntaxHighlighting(source, languageId) {
-        const colorMap = ( (TokenizationRegistry.getColorMap() ?? []).map(c => c ? Color.Format.CSS.formatHexA(c) : ""));
+        const colorMap = (TokenizationRegistry.getColorMap() ?? []).map(c => c ? Color.Format.CSS.formatHexA(c) : "");
         const resolvedLanguageId = this._languageService.isRegisteredLanguageId(languageId) ? languageId : this._languageService.getLanguageIdByLanguageName(languageId);
         const grammar = resolvedLanguageId ? await this._textMateService.createTokenizer(resolvedLanguageId) : null;
         if (!grammar) {

package/vscode/src/vs/workbench/api/browser/mainThreadMessageService.js

@@ -47,7 +47,7 @@ let MainThreadMessageService = class MainThreadMessageService {
     }
     _showMessage(severity, message, commands, options) {
         return (new Promise(resolve => {
-            const primaryActions = ( commands.map(command => toAction({
+            const primaryActions = commands.map(command => toAction({
                 id: `_extension_message_handle_${command.handle}`,
                 label: command.title,
                 enabled: true,
@@ -55,7 +55,7 @@ let MainThreadMessageService = class MainThreadMessageService {
                     resolve(command.handle);
                     return Promise.resolve();
                 }
-            })));
+            }));
             let source;
             let sourceIsUrgent = false;
             if (options.source) {
@@ -66,13 +66,13 @@ let MainThreadMessageService = class MainThreadMessageService {
                 sourceIsUrgent = MainThreadMessageService_1.URGENT_NOTIFICATION_SOURCES.includes(source.id);
             }
             if (!source) {
-                source = ( localize(3027, "Extension"));
+                source = ( localize(4998, "Extension"));
             }
             const secondaryActions = [];
             if (options.source) {
                 secondaryActions.push(toAction({
                     id: options.source.identifier.value,
-                    label: ( localize(3028, "Manage Extension")),
+                    label: ( localize(4999, "Manage Extension")),
                     run: () => {
                         return this._commandService.executeCommand("_extensions.manage", options.source.identifier.value);
                     }
@@ -111,12 +111,12 @@ let MainThreadMessageService = class MainThreadMessageService {
         if (!cancelButton) {
             if (buttons.length > 0) {
                 cancelButton = {
-                    label: ( localize(3029, "Cancel")),
+                    label: ( localize(5000, "Cancel")),
                     run: () => undefined
                 };
             } else {
                 cancelButton = {
-                    label: ( localize(3030, "&&OK")),
+                    label: ( localize(5001, "&&OK")),
                     run: () => undefined
                 };
             }

package/vscode/src/vs/workbench/api/browser/mainThreadOutputService.js

@@ -94,11 +94,11 @@ let MainThreadOutputService = class MainThreadOutputService extends Disposable {
     }
     _showChannelQuietly(channel) {
         const statusProperties = {
-            name: ( localize(3032, "Show Output")),
+            name: ( localize(5003, "Show Output")),
             text: "$(output)",
-            ariaLabel: ( localize(3033, "Show {0} Output Channel", channel.label)),
+            ariaLabel: ( localize(5004, "Show {0} Output Channel", channel.label)),
             command: `workbench.action.output.show.${channel.id}`,
-            tooltip: ( localize(3034, "Show {0} Output Channel", channel.label)),
+            tooltip: ( localize(5005, "Show {0} Output Channel", channel.label)),
             kind: "prominent"
         };
         if (!this._outputStatusItem.value) {

package/vscode/src/vs/workbench/api/browser/mainThreadProgress.js

@@ -38,7 +38,7 @@ let MainThreadProgress = class MainThreadProgress {
                 location: ProgressLocation.Notification,
                 secondaryActions: [toAction({
                     id: extensionId,
-                    label: ( localize(3035, "Manage Extension")),
+                    label: ( localize(5006, "Manage Extension")),
                     run: () => this._commandService.executeCommand("_extensions.manage", extensionId)
                 })]
             };

package/vscode/src/vs/workbench/api/browser/mainThreadQuickDiff.js

@@ -62,12 +62,12 @@ let MainThreadQuickDiff = class MainThreadQuickDiff {
             this.proxy.$acceptSourceControlDiffInformation(handle, undefined);
             return;
         }
-        const changes = ( primaryResult.changes2.map(change => [
+        const changes = primaryResult.changes2.map(change => [
             change.original.startLineNumber,
             change.original.endLineNumberExclusive,
             change.modified.startLineNumber,
             change.modified.endLineNumberExclusive
-        ]));
+        ]);
         const diffInformation = {
             documentVersion: model.changesVersionId,
             original: primaryResult.original,

package/vscode/src/vs/workbench/api/browser/mainThreadQuickOpen.js

@@ -56,7 +56,7 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
         if (options.canPickMany) {
             return this._quickInputService.pick(contents, options, token).then(items => {
                 if (items) {
-                    return ( items.map(item => item.handle));
+                    return items.map(item => item.handle);
                 }
                 return undefined;
             });
@@ -124,10 +124,10 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
             if (params.type === "quickPick") {
                 const quickPick = input;
                 store.add(quickPick.onDidChangeActive(items => {
-                    this._proxy.$onDidChangeActive(sessionId, ( items.map(item => item.handle)));
+                    this._proxy.$onDidChangeActive(sessionId, items.map(item => item.handle));
                 }));
                 store.add(quickPick.onDidChangeSelection(items => {
-                    this._proxy.$onDidChangeSelection(sessionId, ( items.map(item => item.handle)));
+                    this._proxy.$onDidChangeSelection(sessionId, items.map(item => item.handle));
                 }));
                 store.add(quickPick.onDidTriggerItemButton(e => {
                     const transferButton = e.button;

package/vscode/src/vs/workbench/api/browser/mainThreadSCM.js

@@ -296,9 +296,9 @@ class MainThreadSCMHistoryProvider {
         });
     }
     $onDidChangeHistoryItemRefs(historyItemRefs) {
-        const added = ( historyItemRefs.added.map(ref => toISCMHistoryItemRef(ref)));
-        const modified = ( historyItemRefs.modified.map(ref => toISCMHistoryItemRef(ref)));
-        const removed = ( historyItemRefs.removed.map(ref => toISCMHistoryItemRef(ref)));
+        const added = historyItemRefs.added.map(ref => toISCMHistoryItemRef(ref));
+        const modified = historyItemRefs.modified.map(ref => toISCMHistoryItemRef(ref));
+        const removed = historyItemRefs.removed.map(ref => toISCMHistoryItemRef(ref));
         this._historyItemRefChanges.set({
             added,
             modified,
@@ -482,7 +482,7 @@ class MainThreadSCMProvider {
         }
     }
     $registerGroups(_groups) {
-        const groups = ( _groups.map(([handle, id, label, features, multiDiffEditorEnableViewChanges]) => {
+        const groups = _groups.map(([handle, id, label, features, multiDiffEditorEnableViewChanges]) => {
             const group = ( new MainThreadSCMResourceGroup(
                 this.handle,
                 handle,
@@ -495,7 +495,7 @@ class MainThreadSCMProvider {
             ));
             this._groupsByHandle[handle] = group;
             return group;
-        }));
+        });
         this.groups.splice(this.groups.length, 0, ...groups);
         this._onDidChangeResourceGroups.fire();
     }
@@ -522,7 +522,7 @@ class MainThreadSCMProvider {
             }
             groupSlices.reverse();
             for (const [start, deleteCount, rawResources] of groupSlices) {
-                const resources = ( rawResources.map(rawResource => {
+                const resources = rawResources.map(rawResource => {
                     const [
                         handle,
                         sourceUri,
@@ -558,7 +558,7 @@ class MainThreadSCMProvider {
                         URI.revive(multiDiffEditorOriginalUri),
                         URI.revive(multiDiffEditorModifiedUri)
                     ));
-                }));
+                });
                 group.splice(start, deleteCount, resources);
             }
         }

package/vscode/src/vs/workbench/api/browser/mainThreadSaveParticipant.js

@@ -17,7 +17,7 @@ class ExtHostSaveParticipant {
             return undefined;
         }
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(3036, "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
+            setTimeout(() => reject(( new Error(( localize(5007, "Aborted onWillSaveTextDocument-event after 1750ms"))))), 1750);
             this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( new Error("listener failed")));

package/vscode/src/vs/workbench/api/browser/mainThreadSecretState.js

@@ -72,13 +72,13 @@ let MainThreadSecretState = class MainThreadSecretState extends Disposable {
             throw ( new Error("Secret storage service does not support keys() method"));
         }
         const allKeys = await ( this.secretStorageService.keys());
-        const keys = ( ( allKeys.map(key => this.parseKey(key))).filter(
+        const keys = allKeys.map(key => this.parseKey(key)).filter(
             parsedKey => parsedKey !== undefined && parsedKey.extensionId === extensionId
         ).map((
             {
                 key
             }
-        ) => key));
+        ) => key);
         this.logService.trace(`[mainThreadSecretState] Got ${keys.length}key(s) for: `, extensionId);
         return keys;
     }

package/vscode/src/vs/workbench/api/browser/mainThreadTask.js

@@ -157,7 +157,7 @@ var ProcessExecutionDTO;
     ProcessExecutionDTO.is = is;
     function from(value) {
         const process = isString(value.name) ? value.name : value.name.value;
-        const args = value.args ? ( value.args.map(value => isString(value) ? value : value.value)) : [];
+        const args = value.args ? value.args.map(value => isString(value) ? value : value.value) : [];
         const result = {
             process: process,
             args: args
@@ -397,7 +397,7 @@ var TaskDTO;
         }
         command.presentation = TaskPresentationOptionsDTO.to(task.presentationOptions);
         const source = TaskSourceDTO.to(task.source, workspace);
-        const label = ( localize(3037, "{0}: {1}", source.label, task.name));
+        const label = ( localize(5008, "{0}: {1}", source.label, task.name));
         const definition = TaskDefinitionDTO.to(task.definition, executeOnly);
         const id = (CustomExecutionDTO.is(task.execution) && task._id) ? task._id : `${task.source.extensionId}.${definition._key}`;
         const result = ( new ContributedTask(

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.d.ts

@@ -11,7 +11,7 @@ import { IEnvironmentVariableService } from "@codingame/monaco-vscode-api/vscode
 import { ITerminalProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
 import { ITerminalProfileResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
 import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
-import { ISerializableEnvironmentDescriptionMap, ISerializableEnvironmentVariableCollection } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/terminal/common/environmentVariable";
+import { ISerializableEnvironmentDescriptionMap, ISerializableEnvironmentVariableCollection } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/environmentVariable";
 import { ITerminalLinkProviderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/links/browser/links.service";
 import { ITerminalQuickFixService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/quickFix/browser/quickFix.service";
 import { ITerminalCompletionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/suggest/browser/terminalCompletionService.service";

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalService.js

@@ -111,9 +111,9 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
         }
         if (this._environmentVariableService.collections.size > 0) {
             const collectionAsArray = [...this._environmentVariableService.collections.entries()];
-            const serializedCollections = ( collectionAsArray.map(e => {
+            const serializedCollections = collectionAsArray.map(e => {
                 return [e[0], serializeEnvironmentVariableCollection(e[1].map)];
-            }));
+            });
             this._proxy.$initEnvironmentVariableCollections(serializedCollections);
         }
         remoteAgentService.getEnvironment().then(async env => {
@@ -351,7 +351,7 @@ let MainThreadTerminalService = class MainThreadTerminalService extends Disposab
                 if (matchResult) {
                     const result = await this._proxy.$provideTerminalQuickFixes(id, matchResult, token);
                     if (result && Array.isArray(result)) {
-                        return ( result.map(r => parseQuickFix(id, extensionId, r)));
+                        return result.map(r => parseQuickFix(id, extensionId, r));
                     } else if (result) {
                         return parseQuickFix(id, extensionId, result);
                     }
@@ -521,13 +521,13 @@ class ExtensionTerminalLinkProvider {
     async provideLinks(instance, line) {
         const proxy = this._proxy;
         const extHostLinks = await proxy.$provideLinks(instance.instanceId, line);
-        return ( extHostLinks.map(dto => ({
+        return extHostLinks.map(dto => ({
             id: dto.id,
             startIndex: dto.startIndex,
             length: dto.length,
             label: dto.label,
             activate: () => proxy.$activateLink(instance.instanceId, dto.id)
-        })));
+        }));
     }
 }
 function getOutputMatchForLines(lines, outputMatcher) {

package/vscode/src/vs/workbench/api/browser/mainThreadTerminalShellIntegration.js

@@ -34,7 +34,7 @@ let MainThreadTerminalShellIntegration = class MainThreadTerminalShellIntegratio
             }
         }
         const onDidAddCommandDetection = this._store.add(this._terminalService.createOnInstanceEvent(instance => {
-            return ( Event.map(instance.capabilities.onDidAddCommandDetectionCapability, () => instance));
+            return Event.map(instance.capabilities.onDidAddCommandDetectionCapability, () => instance);
         })).event;
         this._store.add(onDidAddCommandDetection(e => this._enableShellIntegration(e)));
         const cwdChangeEvent = this._store.add(

package/vscode/src/vs/workbench/api/browser/mainThreadTesting.js

@@ -105,7 +105,10 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         this.testProfiles.removeProfile(controllerId, profileId);
     }
     $addTestsToRun(controllerId, runId, tests) {
-        this.withLiveRun(runId, r => r.addTestChainToRun(controllerId, ( tests.map(t => ITestItem.deserialize(this.uriIdentityService, t)))));
+        this.withLiveRun(runId, r => r.addTestChainToRun(
+            controllerId,
+            tests.map(t => ITestItem.deserialize(this.uriIdentityService, t))
+        ));
     }
     $appendCoverage(runId, taskId, coverage) {
         this.withLiveRun(runId, run => {
@@ -118,7 +121,7 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
                 let value = task.coverage.read(undefined);
                 if (!value) {
                     value = ( new TestCoverage(run, taskId, this.uriIdentityService, {
-                        getCoverageDetails: (id, testId, token) => this.proxy.$getCoverageDetails(id, testId, token).then(r => ( r.map(CoverageDetails.deserialize)))
+                        getCoverageDetails: (id, testId, token) => this.proxy.$getCoverageDetails(id, testId, token).then(r => r.map(CoverageDetails.deserialize))
                     }));
                     value.append(deserialized, tx);
                     task.coverage.set(value, tx);
@@ -172,10 +175,10 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
             runTests: (reqs, token) => this.proxy.$runControllerTests(reqs, token),
             startContinuousRun: (reqs, token) => this.proxy.$startContinuousRun(reqs, token),
             expandTest: (testId, levels) => this.proxy.$expandTest(testId, isFinite(levels) ? levels : -1),
-            getRelatedCode: (testId, token) => this.proxy.$getCodeRelatedToTest(testId, token).then(locations => ( locations.map(l => ({
+            getRelatedCode: (testId, token) => this.proxy.$getCodeRelatedToTest(testId, token).then(locations => locations.map(l => ({
                 uri: URI.revive(l.uri),
                 range: Range.lift(l.range)
-            }))))
+            })))
         };
         disposable.add(toDisposable(() => this.testProfiles.removeProfile(controllerId)));
         disposable.add(this.testService.registerTestController(controllerId, controller));
@@ -205,14 +208,17 @@ let MainThreadTesting = class MainThreadTesting extends Disposable {
         this.testProviderRegistrations.delete(controllerId);
     }
     $subscribeToDiffs() {
-        this.proxy.$acceptDiff(( this.testService.collection.getReviverDiff().map(TestsDiffOp.serialize)));
+        this.proxy.$acceptDiff(this.testService.collection.getReviverDiff().map(TestsDiffOp.serialize));
         this.diffListener.value = this.testService.onDidProcessDiff(this.proxy.$acceptDiff, this.proxy);
     }
     $unsubscribeFromDiffs() {
         this.diffListener.clear();
     }
     $publishDiff(controllerId, diff) {
-        this.testService.publishDiff(controllerId, ( diff.map(d => TestsDiffOp.deserialize(this.uriIdentityService, d))));
+        this.testService.publishDiff(
+            controllerId,
+            diff.map(d => TestsDiffOp.deserialize(this.uriIdentityService, d))
+        );
     }
     async $runTests(req, token) {
         const result = await this.testService.runResolvedTests(req, token);

package/vscode/src/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -197,23 +197,23 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
         disposables.add(
             treeView.onDidCollapseItem(item => this._proxy.$setExpanded(treeViewId, item.handle, false))
         );
-        disposables.add(
-            treeView.onDidChangeSelectionAndFocus(items => this._proxy.$setSelectionAndFocus(treeViewId, ( items.selection.map((
+        disposables.add(treeView.onDidChangeSelectionAndFocus(
+            items => this._proxy.$setSelectionAndFocus(treeViewId, items.selection.map((
                 {
                     handle
                 }
-            ) => handle)), items.focus.handle))
-        );
+            ) => handle), items.focus.handle)
+        ));
         disposables.add(
             treeView.onDidChangeVisibility(isVisible => this._proxy.$setVisible(treeViewId, isVisible))
         );
         disposables.add(treeView.onDidChangeCheckboxState(items => {
-            this._proxy.$changeCheckboxState(treeViewId, ( items.map(item => {
+            this._proxy.$changeCheckboxState(treeViewId, items.map(item => {
                 return {
                     treeItemHandle: item.handle,
                     newState: item.checkbox?.isChecked ?? false
                 };
-            })));
+            }));
         }));
     }
     getTreeView(treeViewId) {
@@ -280,7 +280,9 @@ class TreeViewDragAndDropController {
         }
         const additionalDataTransfer = ( new VSDataTransfer());
         additionalDataTransferDTO.items.forEach(([type, item]) => {
-            const value = type === Mimes.uriList && item.uriListData ? UriList.create(( item.uriListData.map(part => typeof part === "string" ? part : URI.revive(part)))) : item.asString;
+            const value = type === Mimes.uriList && item.uriListData ? UriList.create(
+                item.uriListData.map(part => typeof part === "string" ? part : URI.revive(part))
+            ) : item.asString;
             additionalDataTransfer.replace(type, createStringDataTransferItem(value));
         });
         return additionalDataTransfer;
@@ -305,7 +307,10 @@ class TreeViewDataProvider {
         if (!treeItems) {
             this.itemsMap.clear();
         }
-        return this._proxy.$getChildren(this.treeViewId, treeItems ? ( treeItems.map(item => item.handle)) : undefined).then(children => {
+        return this._proxy.$getChildren(
+            this.treeViewId,
+            treeItems ? treeItems.map(item => item.handle) : undefined
+        ).then(children => {
             const convertedChildren = this.convertTransferChildren(treeItems ?? [], children);
             return this.postGetChildren(convertedChildren);
         }, err => {

package/vscode/src/vs/workbench/api/browser/mainThreadTunnelService.js

@@ -83,13 +83,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         if (this.portsAttributesProviders.size === 0) {
             return [];
         }
-        const appropriateHandles = ( Array.from(this.portsAttributesProviders.entries()).filter(entry => {
+        const appropriateHandles = Array.from(this.portsAttributesProviders.entries()).filter(entry => {
             const selector = entry[1];
             const portRange = (typeof selector.portRange === "number") ? [selector.portRange, selector.portRange + 1] : selector.portRange;
             const portInRange = portRange ? ( ports.some(port => portRange[0] <= port && port < portRange[1])) : true;
             const commandMatches = !selector.commandPattern || (commandLine && (commandLine.match(selector.commandPattern)));
             return portInRange && commandMatches;
-        }).map(entry => entry[0]));
+        }).map(entry => entry[0]);
         if (appropriateHandles.length === 0) {
             return [];
         }
@@ -116,13 +116,13 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
     }
     async elevationPrompt(tunnelOptions, tunnel, source) {
         return this.notificationService.prompt(Severity.Info, ( localize(
-            3038,
+            5009,
             "The extension {0} has forwarded port {1}. You'll need to run as superuser to use port {2} locally.",
             source,
             tunnelOptions.remoteAddress.port,
             tunnelOptions.localAddressPort
         )), [{
-            label: ( localize(3039, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
+            label: ( localize(5010, "Use Port {0} as Sudo...", tunnel.tunnelRemotePort)),
             run: async () => {
                 this.elevateionRetry = true;
                 await this.remoteExplorerService.close({
@@ -147,7 +147,7 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
         return this.remoteExplorerService.close(remote, TunnelCloseReason.Other);
     }
     async $getTunnels() {
-        return ( (await this.tunnelService.tunnels).map(tunnel => {
+        return (await this.tunnelService.tunnels).map(tunnel => {
             return {
                 remoteAddress: {
                     port: tunnel.tunnelRemotePort,
@@ -157,7 +157,7 @@ let MainThreadTunnelService = class MainThreadTunnelService extends Disposable {
                 privacy: tunnel.privacy,
                 protocol: tunnel.protocol
             };
-        }));
+        });
     }
     async $onFoundNewCandidates(candidates) {
         this.remoteExplorerService.onFoundNewCandidates(candidates);

package/vscode/src/vs/workbench/api/browser/mainThreadUriOpeners.js

@@ -63,7 +63,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                     }, token);
                 } catch (e) {
                     if (!isCancellationError(e)) {
-                        const openDefaultAction = ( new Action("default", ( localize(3040, "Open using default opener")), undefined, undefined, async () => {
+                        const openDefaultAction = ( new Action("default", ( localize(5011, "Open using default opener")), undefined, undefined, async () => {
                             await this.openerService.open(uri, {
                                 allowTunneling: false,
                                 allowContributedOpeners: defaultExternalUriOpenerId
@@ -72,7 +72,7 @@ let MainThreadUriOpeners = class MainThreadUriOpeners extends Disposable {
                         openDefaultAction.tooltip = ( uri.toString());
                         this.notificationService.notify({
                             severity: Severity.Error,
-                            message: ( localize(3041, "Could not open uri with '{0}': {1}", id, (e.toString()))),
+                            message: ( localize(5012, "Could not open uri with '{0}': {1}", id, (e.toString()))),
                             actions: {
                                 primary: [openDefaultAction]
                             }

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -118,7 +118,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
                 <meta http-equiv="Content-type" content="text/html;charset=UTF-8">
                 <meta http-equiv="Content-Security-Policy" content="default-src 'none';">
             </head>
-            <body>${( localize(3042, "An error occurred while loading view: {0}", escape(viewType)))}</body>
+            <body>${( localize(5013, "An error occurred while loading view: {0}", escape(viewType)))}</body>
         </html>`;
     }
 };
@@ -135,7 +135,7 @@ function reviveWebviewContentOptions(webviewOptions) {
         allowForms: webviewOptions.enableForms,
         forwardUntrustedKeypressEvents: true,
         enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? webviewOptions.localResourceRoots.map(r => URI.revive(r)) : undefined,
         portMapping: webviewOptions.portMapping
     };
 }

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -96,10 +96,10 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
         }
     }
     $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
-        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({
+        const workspaceFoldersToAdd = foldersToAdd.map(f => ({
             uri: URI.revive(f.uri),
             name: f.name
-        })));
+        }));
         this._notificationService.status(
             this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount),
             {
@@ -114,10 +114,10 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
         const wantsToDelete = removeCount > 0;
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
-                message = ( localize(3043, "Extension '{0}' added 1 folder to the workspace", extensionName));
+                message = ( localize(5014, "Extension '{0}' added 1 folder to the workspace", extensionName));
             } else {
                 message = ( localize(
-                    3044,
+                    5015,
                     "Extension '{0}' added {1} folders to the workspace",
                     extensionName,
                     addCount
@@ -126,10 +126,10 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
         }
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
-                message = ( localize(3045, "Extension '{0}' removed 1 folder from the workspace", extensionName));
+                message = ( localize(5016, "Extension '{0}' removed 1 folder from the workspace", extensionName));
             } else {
                 message = ( localize(
-                    3046,
+                    5017,
                     "Extension '{0}' removed {1} folders from the workspace",
                     extensionName,
                     removeCount
@@ -137,7 +137,7 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
             }
         }
         else {
-            message = ( localize(3047, "Extension '{0}' changed folders of the workspace", extensionName));
+            message = ( localize(5018, "Extension '{0}' changed folders of the workspace", extensionName));
         }
         return message;
     }
@@ -162,7 +162,7 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
         const workspace = this._contextService.getWorkspace();
         const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, revive(options));
         return this._searchService.fileSearch(query, token).then(result => {
-            return ( result.results.map(m => m.resource));
+            return result.results.map(m => m.resource);
         }, err => {
             if (!isCancellationError(err)) {
                 return Promise.reject(err);
@@ -173,7 +173,7 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
     $startTextSearch(pattern, _folder, options, requestId, token) {
         const folder = URI.revive(_folder);
         const workspace = this._contextService.getWorkspace();
-        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
+        const folders = folder ? [folder] : workspace.folders.map(folder => folder.uri);
         const query = this._queryBuilder.text(pattern, folders, revive(options));
         query._reason = "startTextSearch";
         const onProgress = p => {
@@ -212,9 +212,11 @@ let MainThreadWorkspace = class MainThreadWorkspace extends Disposable {
         if (!result.success) {
             return [];
         }
-        return coalesce(( result.editors.map(editor => EditorResourceAccessor.getCanonicalUri(editor, {
-            supportSideBySide: SideBySideEditor.PRIMARY
-        }))));
+        return coalesce(
+            result.editors.map(editor => EditorResourceAccessor.getCanonicalUri(editor, {
+                supportSideBySide: SideBySideEditor.PRIMARY
+            }))
+        );
     }
     $saveAll(includeUntitled) {
         return this._editorService.saveAll({

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -60,7 +60,7 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         }));
         this._register(extensionService.onWillStop(e => {
             e.veto(true, ( localize(
-                11284,
+                13409,
                 "An extension provided text editor for '{0}' is still open that would close otherwise.",
                 this.name
             )));