@codingame/monaco-vscode-base-service-override 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/services/label/common/labelService.js

@@ -29,63 +29,63 @@ import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { Memento } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/memento';
 
 const resourceLabelFormattersExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'resourceLabelFormatters',
+    extensionPoint: "resourceLabelFormatters",
     jsonSchema: {
-        description: ( localize(14142, 'Contributes resource label formatting rules.')),
-        type: 'array',
+        description: ( localize(14531, "Contributes resource label formatting rules.")),
+        type: "array",
         items: {
-            type: 'object',
-            required: ['scheme', 'formatting'],
+            type: "object",
+            required: ["scheme", "formatting"],
             properties: {
                 scheme: {
-                    type: 'string',
+                    type: "string",
                     description: ( localize(
-                        14143,
-                        'URI scheme on which to match the formatter on. For example "file". Simple glob patterns are supported.'
-                    )),
+                        14532,
+                        "URI scheme on which to match the formatter on. For example \"file\". Simple glob patterns are supported."
+                    ))
                 },
                 authority: {
-                    type: 'string',
+                    type: "string",
                     description: ( localize(
-                        14144,
-                        'URI authority on which to match the formatter on. Simple glob patterns are supported.'
-                    )),
+                        14533,
+                        "URI authority on which to match the formatter on. Simple glob patterns are supported."
+                    ))
                 },
                 formatting: {
-                    description: ( localize(14145, "Rules for formatting uri resource labels.")),
-                    type: 'object',
+                    description: ( localize(14534, "Rules for formatting uri resource labels.")),
+                    type: "object",
                     properties: {
                         label: {
-                            type: 'string',
+                            type: "string",
                             description: ( localize(
-                                14146,
+                                14535,
                                 "Label rules to display. For example: myLabel:/${path}. ${path}, ${scheme}, ${authority} and ${authoritySuffix} are supported as variables."
                             ))
                         },
                         separator: {
-                            type: 'string',
+                            type: "string",
                             description: ( localize(
-                                14147,
-                                "Separator to be used in the uri label display. '/' or '\' as an example."
+                                14536,
+                                "Separator to be used in the uri label display. '/' or '' as an example."
                             ))
                         },
                         stripPathStartingSeparator: {
-                            type: 'boolean',
+                            type: "boolean",
                             description: ( localize(
-                                14148,
+                                14537,
                                 "Controls whether `${path}` substitutions should have starting separator characters stripped."
                             ))
                         },
                         tildify: {
-                            type: 'boolean',
+                            type: "boolean",
                             description: ( localize(
-                                14149,
+                                14538,
                                 "Controls if the start of the uri label should be tildified when possible."
                             ))
                         },
                         workspaceSuffix: {
-                            type: 'string',
-                            description: ( localize(14150, "Suffix appended to the workspace label."))
+                            type: "string",
+                            description: ( localize(14539, "Suffix appended to the workspace label."))
                         }
                     }
                 }
@@ -97,7 +97,7 @@ const posixPathSeparatorRegexp = /\//g;
 const winPathSeparatorRegexp = /[\\\/]/g;
 const labelMatchingRegexp = /\$\{(scheme|authoritySuffix|authority|path|(query)\.(.+?))\}/g;
 function hasDriveLetterIgnorePlatform(path) {
-    return !!(path && path[2] === ':');
+    return !!(path && path[2] === ":");
 }
 let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
     constructor(labelService) {
@@ -105,14 +105,16 @@ let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
         resourceLabelFormattersExtPoint.setHandler((extensions, delta) => {
             for (const added of delta.added) {
                 for (const untrustedFormatter of added.value) {
-                    const formatter = { ...untrustedFormatter };
-                    if (typeof formatter.formatting.label !== 'string') {
-                        formatter.formatting.label = '${authority}${path}';
+                    const formatter = {
+                        ...untrustedFormatter
+                    };
+                    if (typeof formatter.formatting.label !== "string") {
+                        formatter.formatting.label = "${authority}${path}";
                     }
                     if (typeof formatter.formatting.separator !== `string`) {
                         formatter.formatting.separator = sep;
                     }
-                    if (!isProposedApiEnabled(added.description, 'contribLabelFormatterWorkspaceTooltip') && formatter.formatting.workspaceTooltip) {
+                    if (!isProposedApiEnabled(added.description, "contribLabelFormatterWorkspaceTooltip") && formatter.formatting.workspaceTooltip) {
                         formatter.formatting.workspaceTooltip = undefined;
                     }
                     this.formattersDisposables.set(formatter, labelService.registerFormatter(formatter));
@@ -126,23 +128,32 @@ let ResourceLabelFormattersHandler = class ResourceLabelFormattersHandler {
         });
     }
 };
-ResourceLabelFormattersHandler = ( __decorate([
-    ( __param(0, ILabelService))
-], ResourceLabelFormattersHandler));
+ResourceLabelFormattersHandler = ( __decorate([( __param(0, ILabelService))], ResourceLabelFormattersHandler));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ResourceLabelFormattersHandler, LifecyclePhase.Restored);
 const FORMATTER_CACHE_SIZE = 50;
 let LabelService = class LabelService extends Disposable {
-    constructor(environmentService, contextService, pathService, remoteAgentService, storageService, lifecycleService) {
+    constructor(
+        environmentService,
+        contextService,
+        pathService,
+        remoteAgentService,
+        storageService,
+        lifecycleService
+    ) {
         super();
         this.environmentService = environmentService;
         this.contextService = contextService;
         this.pathService = pathService;
         this.remoteAgentService = remoteAgentService;
-        this._onDidChangeFormatters = this._register(( new Emitter({ leakWarningThreshold: 400 })));
+        this._onDidChangeFormatters = this._register(( new Emitter({
+            leakWarningThreshold: 400
+        })));
         this.onDidChangeFormatters = this._onDidChangeFormatters.event;
         this.os = OS;
-        this.userHome = pathService.defaultUriScheme === Schemas.file ? this.pathService.userHome({ preferLocal: true }) : undefined;
-        const memento = this.storedFormattersMemento = ( new Memento('cachedResourceLabelFormatters2', storageService));
+        this.userHome = pathService.defaultUriScheme === Schemas.file ? this.pathService.userHome({
+            preferLocal: true
+        }) : undefined;
+        const memento = this.storedFormattersMemento = ( new Memento("cachedResourceLabelFormatters2", storageService));
         this.storedFormatters = memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
         this.formatters = this.storedFormatters?.formatters?.slice() || [];
         this.resolveRemoteEnvironment();
@@ -163,10 +174,9 @@ let LabelService = class LabelService extends Disposable {
                 if (!formatter.authority) {
                     continue;
                 }
-                if (match(formatter.authority, resource.authority, { ignoreCase: true }) &&
-                    (!bestResult?.authority ||
-                        formatter.authority.length > bestResult.authority.length ||
-                        ((formatter.authority.length === bestResult.authority.length) && formatter.priority))) {
+                if (match(formatter.authority, resource.authority, {
+                    ignoreCase: true
+                }) && (!bestResult?.authority || formatter.authority.length > bestResult.authority.length || ((formatter.authority.length === bestResult.authority.length) && formatter.priority))) {
                     bestResult = formatter;
                 }
             }
@@ -176,7 +186,10 @@ let LabelService = class LabelService extends Disposable {
     getUriLabel(resource, options = {}) {
         let formatting = this.findFormatting(resource);
         if (formatting && options.separator) {
-            formatting = { ...formatting, separator: options.separator };
+            formatting = {
+                ...formatting,
+                separator: options.separator
+            };
         }
         let label = this.doGetUriLabel(resource, formatting, options);
         if (!formatting && options.separator) {
@@ -191,7 +204,9 @@ let LabelService = class LabelService extends Disposable {
         if (!formatting) {
             return getPathLabel(resource, {
                 os: this.os,
-                tildify: this.userHome ? { userHome: this.userHome } : undefined,
+                tildify: this.userHome ? {
+                    userHome: this.userHome
+                } : undefined,
                 relative: options.relative ? {
                     noPrefix: options.noPrefix,
                     getWorkspace: () => this.contextService.getWorkspace(),
@@ -205,7 +220,9 @@ let LabelService = class LabelService extends Disposable {
                 const workspace = this.contextService.getWorkspace();
                 const firstFolder = workspace.folders.at(0);
                 if (firstFolder && resource.scheme !== firstFolder.uri.scheme && resource.path.startsWith(posix.sep)) {
-                    folder = this.contextService.getWorkspaceFolder(firstFolder.uri.with({ path: resource.path }));
+                    folder = this.contextService.getWorkspaceFolder(firstFolder.uri.with({
+                        path: resource.path
+                    }));
                 }
             }
             if (folder) {
@@ -217,8 +234,7 @@ let LabelService = class LabelService extends Disposable {
                 }
                 if (!relativeLabel[overlap] || relativeLabel[overlap] === formatting.separator) {
                     relativeLabel = relativeLabel.substring(1 + overlap);
-                }
-                else if (overlap === folderLabel.length && folder.uri.path === posix.sep) {
+                } else if (overlap === folderLabel.length && folder.uri.path === posix.sep) {
                     relativeLabel = relativeLabel.substring(overlap);
                 }
                 const hasMultipleRoots = this.contextService.getWorkspace().folders.length > 1;
@@ -237,22 +253,23 @@ let LabelService = class LabelService extends Disposable {
         let pathLib;
         if (formatting?.separator === win32.sep) {
             pathLib = win32;
-        }
-        else if (formatting?.separator === posix.sep) {
+        } else if (formatting?.separator === posix.sep) {
             pathLib = posix;
-        }
-        else {
+        } else {
             pathLib = (this.os === OperatingSystem.Windows) ? win32 : posix;
         }
         return pathLib.basename(label);
     }
     getWorkspaceLabel(workspace, options) {
         if (isWorkspace(workspace)) {
+            if (workspace.isAgentSessionsWorkspace) {
+                return localize(14540, "Agent Sessions");
+            }
             const identifier = toWorkspaceIdentifier(workspace);
             if (isSingleFolderWorkspaceIdentifier(identifier) || isWorkspaceIdentifier(identifier)) {
                 return this.getWorkspaceLabel(identifier, options);
             }
-            return '';
+            return "";
         }
         if (URI.isUri(workspace)) {
             return this.doGetSingleFolderWorkspaceLabel(workspace, options);
@@ -263,14 +280,14 @@ let LabelService = class LabelService extends Disposable {
         if (isWorkspaceIdentifier(workspace)) {
             return this.doGetWorkspaceLabel(workspace.configPath, options);
         }
-        return '';
+        return "";
     }
     doGetWorkspaceLabel(workspaceUri, options) {
         if (isUntitledWorkspace(workspaceUri, this.environmentService)) {
-            return localize(14151, "Untitled (Workspace)");
+            return localize(14541, "Untitled (Workspace)");
         }
         if (isTemporaryWorkspace(workspaceUri)) {
-            return localize(14152, "Workspace");
+            return localize(14542, "Workspace");
         }
         let filename = basename(workspaceUri);
         if (filename.endsWith(WORKSPACE_EXTENSION)) {
@@ -278,20 +295,20 @@ let LabelService = class LabelService extends Disposable {
         }
         let label;
         switch (options?.verbose) {
-            case Verbosity.SHORT:
-                label = filename;
-                break;
-            case Verbosity.LONG:
-                label = ( localize(
-                    14153,
-                    "{0} (Workspace)",
-                    this.getUriLabel(joinPath(dirname(workspaceUri), filename))
-                ));
-                break;
-            case Verbosity.MEDIUM:
-            default:
-                label = ( localize(14154, "{0} (Workspace)", filename));
-                break;
+        case Verbosity.SHORT:
+            label = filename;
+            break;
+        case Verbosity.LONG:
+            label = ( localize(
+                14543,
+                "{0} (Workspace)",
+                this.getUriLabel(joinPath(dirname(workspaceUri), filename))
+            ));
+            break;
+        case Verbosity.MEDIUM:
+        default:
+            label = ( localize(14544, "{0} (Workspace)", filename));
+            break;
         }
         if (options?.verbose === Verbosity.SHORT) {
             return label;
@@ -301,14 +318,14 @@ let LabelService = class LabelService extends Disposable {
     doGetSingleFolderWorkspaceLabel(folderUri, options) {
         let label;
         switch (options?.verbose) {
-            case Verbosity.LONG:
-                label = this.getUriLabel(folderUri);
-                break;
-            case Verbosity.SHORT:
-            case Verbosity.MEDIUM:
-            default:
-                label = basename(folderUri) || posix.sep;
-                break;
+        case Verbosity.LONG:
+            label = this.getUriLabel(folderUri);
+            break;
+        case Verbosity.SHORT:
+        case Verbosity.MEDIUM:
+        default:
+            label = basename(folderUri) || posix.sep;
+            break;
         }
         if (options?.verbose === Verbosity.SHORT) {
             return label;
@@ -316,15 +333,24 @@ let LabelService = class LabelService extends Disposable {
         return this.appendWorkspaceSuffix(label, folderUri);
     }
     getSeparator(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        const formatter = this.findFormatting(( URI.from({
+            scheme,
+            authority
+        })));
         return formatter?.separator || posix.sep;
     }
     getHostLabel(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
-        return formatter?.workspaceSuffix || authority || '';
+        const formatter = this.findFormatting(( URI.from({
+            scheme,
+            authority
+        })));
+        return formatter?.workspaceSuffix || authority || "";
     }
     getHostTooltip(scheme, authority) {
-        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        const formatter = this.findFormatting(( URI.from({
+            scheme,
+            authority
+        })));
         return formatter?.workspaceTooltip;
     }
     registerCachedFormatter(formatter) {
@@ -335,8 +361,7 @@ let LabelService = class LabelService extends Disposable {
         }
         if (replace === -1) {
             list.unshift(formatter);
-        }
-        else {
+        } else {
             for (let i = replace; i > 0; i--) {
                 list[i] = list[i - 1];
             }
@@ -347,38 +372,45 @@ let LabelService = class LabelService extends Disposable {
     }
     registerFormatter(formatter) {
         this.formatters.push(formatter);
-        this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+        this._onDidChangeFormatters.fire({
+            scheme: formatter.scheme
+        });
         return {
             dispose: () => {
                 this.formatters = this.formatters.filter(f => f !== formatter);
-                this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+                this._onDidChangeFormatters.fire({
+                    scheme: formatter.scheme
+                });
             }
         };
     }
     formatUri(resource, formatting, forceNoTildify) {
         let label = formatting.label.replace(labelMatchingRegexp, (match, token, qsToken, qsValue) => {
             switch (token) {
-                case 'scheme': return resource.scheme;
-                case 'authority': return resource.authority;
-                case 'authoritySuffix': {
-                    const i = resource.authority.indexOf('+');
+            case "scheme":
+                return resource.scheme;
+            case "authority":
+                return resource.authority;
+            case "authoritySuffix":
+                {
+                    const i = resource.authority.indexOf("+");
                     return i === -1 ? resource.authority : resource.authority.slice(i + 1);
                 }
-                case 'path':
-                    return formatting.stripPathStartingSeparator
-                        ? resource.path.slice(resource.path[0] === formatting.separator ? 1 : 0)
-                        : resource.path;
-                default: {
-                    if (qsToken === 'query') {
-                        const { query } = resource;
-                        if (query && query[0] === '{' && query[query.length - 1] === '}') {
+            case "path":
+                return formatting.stripPathStartingSeparator ? resource.path.slice(resource.path[0] === formatting.separator ? 1 : 0) : resource.path;
+            default:
+                {
+                    if (qsToken === "query") {
+                        const {
+                            query
+                        } = resource;
+                        if (query && query[0] === "{" && query[query.length - 1] === "}") {
                             try {
-                                return JSON.parse(query)[qsValue] || '';
-                            }
-                            catch { }
+                                return JSON.parse(query)[qsValue] || "";
+                            } catch {}
                         }
                     }
-                    return '';
+                    return "";
                 }
             }
         });
@@ -396,21 +428,17 @@ let LabelService = class LabelService extends Disposable {
         return this.adjustPathSeparators(label, formatting.separator);
     }
     adjustPathSeparators(label, separator) {
-        return label.replace(this.os === OperatingSystem.Windows ? winPathSeparatorRegexp : posixPathSeparatorRegexp, separator);
+        return label.replace(
+            this.os === OperatingSystem.Windows ? winPathSeparatorRegexp : posixPathSeparatorRegexp,
+            separator
+        );
     }
     appendWorkspaceSuffix(label, uri) {
         const formatting = this.findFormatting(uri);
-        const suffix = formatting && (typeof formatting.workspaceSuffix === 'string') ? formatting.workspaceSuffix : undefined;
+        const suffix = formatting && (typeof formatting.workspaceSuffix === "string") ? formatting.workspaceSuffix : undefined;
         return suffix ? `${label} [${suffix}]` : label;
     }
 };
-LabelService = ( __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IPathService)),
-    ( __param(3, IRemoteAgentService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, ILifecycleService))
-], LabelService));
+LabelService = ( __decorate([( __param(0, IWorkbenchEnvironmentService)), ( __param(1, IWorkspaceContextService)), ( __param(2, IPathService)), ( __param(3, IRemoteAgentService)), ( __param(4, IStorageService)), ( __param(5, ILifecycleService))], LabelService));
 
 export { LabelService };

package/vscode/src/vs/workbench/services/path/browser/pathService.js

@@ -17,7 +17,7 @@ function guessLocalUserHome(environmentService, contextService) {
     return ( URI.from({
         scheme: AbstractPathService.findDefaultUriScheme(environmentService, contextService),
         authority: environmentService.remoteAuthority,
-        path: '/'
+        path: "/"
     }));
 }
 

package/vscode/src/vs/workbench/services/path/common/pathService.js

@@ -29,7 +29,7 @@ let AbstractPathService = AbstractPathService_1 = class AbstractPathService {
         })();
     }
     hasValidBasename(resource, arg2, basename) {
-        if (typeof arg2 === 'string' || typeof arg2 === 'undefined') {
+        if (typeof arg2 === "string" || typeof arg2 === "undefined") {
             return this.resolveOS.then(os => this.doHasValidBasename(resource, os, arg2));
         }
         return this.doHasValidBasename(resource, arg2, basename);
@@ -69,41 +69,34 @@ let AbstractPathService = AbstractPathService_1 = class AbstractPathService {
     }
     get path() {
         return this.resolveOS.then(os => {
-            return os === OperatingSystem.Windows ?
-                win32 :
-                posix;
+            return os === OperatingSystem.Windows ? win32 : posix;
         });
     }
     async fileURI(_path) {
-        let authority = '';
+        let authority = "";
         const os = await this.resolveOS;
         if (os === OperatingSystem.Windows) {
-            _path = _path.replace(/\\/g, '/');
+            _path = _path.replace(/\\/g, "/");
         }
-        if (_path[0] === '/' && _path[1] === '/') {
-            const idx = _path.indexOf('/', 2);
+        if (_path[0] === "/" && _path[1] === "/") {
+            const idx = _path.indexOf("/", 2);
             if (idx === -1) {
                 authority = _path.substring(2);
-                _path = '/';
-            }
-            else {
+                _path = "/";
+            } else {
                 authority = _path.substring(2, idx);
-                _path = _path.substring(idx) || '/';
+                _path = _path.substring(idx) || "/";
             }
         }
         return ( URI.from({
             scheme: Schemas.file,
             authority,
             path: _path,
-            query: '',
-            fragment: ''
+            query: "",
+            fragment: ""
         }));
     }
 };
-AbstractPathService = AbstractPathService_1 = ( __decorate([
-    ( __param(1, IRemoteAgentService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IWorkspaceContextService))
-], AbstractPathService));
+AbstractPathService = AbstractPathService_1 = ( __decorate([( __param(1, IRemoteAgentService)), ( __param(2, IWorkbenchEnvironmentService)), ( __param(3, IWorkspaceContextService))], AbstractPathService));
 
 export { AbstractPathService };

package/vscode/src/vs/workbench/services/request/browser/requestService.js

@@ -14,7 +14,10 @@ import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/
 
 let BrowserRequestService = class BrowserRequestService extends AbstractRequestService {
     constructor(remoteAgentService, configurationService, loggerService) {
-        const logger = loggerService.createLogger(`network`, { name: ( localize(14260, "Network")), group: windowLogGroup });
+        const logger = loggerService.createLogger(`network`, {
+            name: ( localize(14651, "Network")),
+            group: windowLogGroup
+        });
         const logService = ( new LogService(logger));
         super(logService);
         this.remoteAgentService = remoteAgentService;
@@ -25,7 +28,7 @@ let BrowserRequestService = class BrowserRequestService extends AbstractRequestS
     async request(options, token) {
         try {
             if (!options.proxyAuthorization) {
-                options.proxyAuthorization = this.configurationService.inspect('http.proxyAuthorization').userLocalValue;
+                options.proxyAuthorization = this.configurationService.inspect("http.proxyAuthorization").userLocalValue;
             }
             const context = await this.logAndRequest(options, () => request(options, token, () => mainWindow.navigator.onLine));
             const connection = this.remoteAgentService.getConnection();
@@ -33,8 +36,7 @@ let BrowserRequestService = class BrowserRequestService extends AbstractRequestS
                 return this._makeRemoteRequest(connection, options, token);
             }
             return context;
-        }
-        catch (error) {
+        } catch (error) {
             const connection = this.remoteAgentService.getConnection();
             if (connection) {
                 return this._makeRemoteRequest(connection, options, token);
@@ -55,20 +57,20 @@ let BrowserRequestService = class BrowserRequestService extends AbstractRequestS
         return [];
     }
     _makeRemoteRequest(connection, options, token) {
-        return connection.withChannel('request', channel => ( new RequestChannelClient(channel)).request(options, token));
+        return connection.withChannel("request", channel => ( new RequestChannelClient(channel)).request(options, token));
     }
 };
-BrowserRequestService = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ILoggerService))
-], BrowserRequestService));
-CommandsRegistry.registerCommand('_workbench.fetchJSON', async function (accessor, url, method) {
-    const result = await fetch(url, { method, headers: { Accept: 'application/json' } });
+BrowserRequestService = ( __decorate([( __param(0, IRemoteAgentService)), ( __param(1, IConfigurationService)), ( __param(2, ILoggerService))], BrowserRequestService));
+CommandsRegistry.registerCommand("_workbench.fetchJSON", async function(accessor, url, method) {
+    const result = await fetch(url, {
+        method,
+        headers: {
+            Accept: "application/json"
+        }
+    });
     if (result.ok) {
         return result.json();
-    }
-    else {
+    } else {
         throw ( new Error(result.statusText));
     }
 });

package/vscode/src/vs/workbench/services/url/browser/urlService.js

@@ -21,10 +21,12 @@ class BrowserURLOpener {
         if (!matchesScheme(resource, this.productService.urlProtocol)) {
             return false;
         }
-        if (typeof resource === 'string') {
+        if (typeof resource === "string") {
             resource = ( URI.parse(resource));
         }
-        return this.urlService.open(resource, { trusted: true });
+        return this.urlService.open(resource, {
+            trusted: true
+        });
     }
 }
 let BrowserURLService = class BrowserURLService extends AbstractURLService {
@@ -32,7 +34,9 @@ let BrowserURLService = class BrowserURLService extends AbstractURLService {
         super();
         this.provider = environmentService.options?.urlCallbackProvider;
         if (this.provider) {
-            this._register(this.provider.onCallback(uri => this.open(uri, { trusted: true })));
+            this._register(this.provider.onCallback(uri => this.open(uri, {
+                trusted: true
+            })));
         }
         this._register(openerService.registerOpener(( new BrowserURLOpener(this, productService))));
     }
@@ -40,13 +44,9 @@ let BrowserURLService = class BrowserURLService extends AbstractURLService {
         if (this.provider) {
             return this.provider.create(options);
         }
-        return ( URI.parse('unsupported://'));
+        return ( URI.parse("unsupported://"));
     }
 };
-BrowserURLService = ( __decorate([
-    ( __param(0, IBrowserWorkbenchEnvironmentService)),
-    ( __param(1, IOpenerService)),
-    ( __param(2, IProductService))
-], BrowserURLService));
+BrowserURLService = ( __decorate([( __param(0, IBrowserWorkbenchEnvironmentService)), ( __param(1, IOpenerService)), ( __param(2, IProductService))], BrowserURLService));
 
 export { BrowserURLService };

package/vscode/src/vs/workbench/services/userActivity/common/userActivityRegistry.js

@@ -3,7 +3,7 @@
 class UserActivityRegistry {
     constructor() {
         this.todo = [];
-        this.add = (ctor) => {
+        this.add = ctor => {
             this.todo.push(ctor);
         };
     }

package/vscode/src/vs/workbench/services/userActivity/common/userActivityService.js

@@ -19,7 +19,9 @@ let UserActivityService = class UserActivityService extends Disposable {
         this.active = 0;
         this.isActive = true;
         this.onDidChangeIsActive = this.changeEmitter.event;
-        this._register(runWhenGlobalIdle(() => userActivityRegistry.take(this, instantiationService)));
+        this._register(
+            runWhenGlobalIdle(() => userActivityRegistry.take(this, instantiationService))
+        );
     }
     markActive(opts) {
         if (opts?.extendOnly && !this.isActive) {
@@ -42,8 +44,6 @@ let UserActivityService = class UserActivityService extends Disposable {
         });
     }
 };
-UserActivityService = ( __decorate([
-    ( __param(0, IInstantiationService))
-], UserActivityService));
+UserActivityService = ( __decorate([( __param(0, IInstantiationService))], UserActivityService));
 
 export { UserActivityService };