@codingame/monaco-vscode-quickaccess-service-override 1.85.0-next.2 → 1.85.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-quickaccess-service-override",
-  "version": "1.85.0-next.2",
+  "version": "1.85.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.85.0-next.2",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.1",
     "monaco-editor": "0.45.0"
   }
 }

package/quickaccess.js

@@ -13,6 +13,7 @@ import './vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLin
 import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess';
 import './vscode/src/vs/workbench/browser/actions/quickAccessActions.js';
 import './vscode/src/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js';
+import './vscode/src/vs/workbench/contrib/url/browser/url.contribution.js';
 import 'vscode/vscode/vs/workbench/browser/workbench.contribution';
 
 let isKeybindingConfigurationVisible = () => {

package/vscode/src/vs/workbench/contrib/url/browser/externalUriResolver.js

@@ -0,0 +1,27 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+
+let ExternalUriResolverContribution = class ExternalUriResolverContribution extends Disposable {
+    constructor(_openerService, _workbenchEnvironmentService) {
+        super();
+        if (_workbenchEnvironmentService.options && _workbenchEnvironmentService.options.resolveExternalUri) {
+            this._register(_openerService.registerExternalUriResolver({
+                resolveExternalUri: async (resource) => {
+                    return {
+                        resolved: await _workbenchEnvironmentService.options.resolveExternalUri(resource),
+                        dispose: () => {
+                        }
+                    };
+                }
+            }));
+        }
+    }
+};
+ExternalUriResolverContribution = ( __decorate([
+    ( __param(0, IOpenerService)),
+    ( __param(1, IBrowserWorkbenchEnvironmentService))
+], ExternalUriResolverContribution));
+
+export { ExternalUriResolverContribution };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomains.js

@@ -0,0 +1,200 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+
+const TRUSTED_DOMAINS_URI = ( URI.parse('trustedDomains:/Trusted Domains'));
+const TRUSTED_DOMAINS_STORAGE_KEY = 'http.linkProtectionTrustedDomains';
+const TRUSTED_DOMAINS_CONTENT_STORAGE_KEY = 'http.linkProtectionTrustedDomainsContent';
+const manageTrustedDomainSettingsCommand = {
+    id: 'workbench.action.manageTrustedDomain',
+    description: {
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/trustedDomains',
+            'trustedDomain.manageTrustedDomain',
+            'Manage Trusted Domains'
+        )),
+        args: []
+    },
+    handler: async (accessor) => {
+        const editorService = accessor.get(IEditorService);
+        editorService.openEditor({ resource: TRUSTED_DOMAINS_URI, languageId: 'jsonc', options: { pinned: true } });
+        return;
+    }
+};
+async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConfigure, resource, quickInputService, storageService, editorService, telemetryService) {
+    const parsedDomainToConfigure = ( URI.parse(domainToConfigure));
+    const toplevelDomainSegements = parsedDomainToConfigure.authority.split('.');
+    const domainEnd = toplevelDomainSegements.slice(toplevelDomainSegements.length - 2).join('.');
+    const topLevelDomain = '*.' + domainEnd;
+    const options = [];
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/trustedDomains',
+            'trustedDomain.trustDomain',
+            'Trust {0}',
+            domainToConfigure
+        )),
+        id: 'trust',
+        toTrust: domainToConfigure,
+        picked: true
+    });
+    const isIP = toplevelDomainSegements.length === 4 &&
+        toplevelDomainSegements.every(segment => Number.isInteger(+segment) || Number.isInteger(+segment.split(':')[0]));
+    if (isIP) {
+        if (parsedDomainToConfigure.authority.includes(':')) {
+            const base = parsedDomainToConfigure.authority.split(':')[0];
+            options.push({
+                type: 'item',
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/url/browser/trustedDomains',
+                    'trustedDomain.trustAllPorts',
+                    'Trust {0} on all ports',
+                    base
+                )),
+                toTrust: base + ':*',
+                id: 'trust'
+            });
+        }
+    }
+    else {
+        options.push({
+            type: 'item',
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/url/browser/trustedDomains',
+                'trustedDomain.trustSubDomain',
+                'Trust {0} and all its subdomains',
+                domainEnd
+            )),
+            toTrust: topLevelDomain,
+            id: 'trust'
+        });
+    }
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/trustedDomains',
+            'trustedDomain.trustAllDomains',
+            'Trust all domains (disables link protection)'
+        )),
+        toTrust: '*',
+        id: 'trust'
+    });
+    options.push({
+        type: 'item',
+        label: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/trustedDomains',
+            'trustedDomain.manageTrustedDomains',
+            'Manage Trusted Domains'
+        )),
+        id: 'manage'
+    });
+    const pickedResult = await quickInputService.pick(options, { activeItem: options[0] });
+    if (pickedResult && pickedResult.id) {
+        switch (pickedResult.id) {
+            case 'manage':
+                await editorService.openEditor({
+                    resource: TRUSTED_DOMAINS_URI.with({ fragment: ( resource.toString()) }),
+                    languageId: 'jsonc',
+                    options: { pinned: true }
+                });
+                return trustedDomains;
+            case 'trust': {
+                const itemToTrust = pickedResult.toTrust;
+                if (trustedDomains.indexOf(itemToTrust) === -1) {
+                    storageService.remove(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, -1 );
+                    storageService.store(TRUSTED_DOMAINS_STORAGE_KEY, JSON.stringify([...trustedDomains, itemToTrust]), -1 , 0 );
+                    return [...trustedDomains, itemToTrust];
+                }
+            }
+        }
+    }
+    return [];
+}
+function extractGitHubRemotesFromGitConfig(gitConfig) {
+    const domains = ( new Set());
+    let match;
+    const RemoteMatcher = /^\s*url\s*=\s*(?:git@|https:\/\/)github\.com(?::|\/)(\S*)\s*$/mg;
+    while (match = RemoteMatcher.exec(gitConfig)) {
+        const repo = match[1].replace(/\.git$/, '');
+        if (repo) {
+            domains.add(`https://github.com/${repo}/`);
+        }
+    }
+    return [...domains];
+}
+async function getRemotes(fileService, textFileService, contextService) {
+    const workspaceUris = ( contextService.getWorkspace().folders.map(folder => folder.uri));
+    const domains = await Promise.race([
+        ( new Promise(resolve => setTimeout(() => resolve([]), 2000))),
+        Promise.all(( workspaceUris.map(async (workspaceUri) => {
+            try {
+                const path = workspaceUri.path;
+                const uri = workspaceUri.with({ path: `${path !== '/' ? path : ''}/.git/config` });
+                const exists = await fileService.exists(uri);
+                if (!exists) {
+                    return [];
+                }
+                const gitConfig = (await (textFileService.read(uri, { acceptTextOnly: true }).catch(() => ({ value: '' })))).value;
+                return extractGitHubRemotesFromGitConfig(gitConfig);
+            }
+            catch {
+                return [];
+            }
+        })))
+    ]);
+    const set = domains.reduce((set, list) => list.reduce((set, item) => set.add(item), set), ( new Set()));
+    return [...set];
+}
+async function readTrustedDomains(accessor) {
+    const { defaultTrustedDomains, trustedDomains } = readStaticTrustedDomains(accessor);
+    const [workspaceDomains, userDomains] = await Promise.all([readWorkspaceTrustedDomains(accessor), readAuthenticationTrustedDomains(accessor)]);
+    return {
+        workspaceDomains,
+        userDomains,
+        defaultTrustedDomains,
+        trustedDomains,
+    };
+}
+async function readWorkspaceTrustedDomains(accessor) {
+    const fileService = accessor.get(IFileService);
+    const textFileService = accessor.get(ITextFileService);
+    const workspaceContextService = accessor.get(IWorkspaceContextService);
+    return getRemotes(fileService, textFileService, workspaceContextService);
+}
+async function readAuthenticationTrustedDomains(accessor) {
+    const authenticationService = accessor.get(IAuthenticationService);
+    return authenticationService.isAuthenticationProviderRegistered('github') && ((await authenticationService.getSessions('github')) ?? []).length > 0
+        ? [`https://github.com`]
+        : [];
+}
+function readStaticTrustedDomains(accessor) {
+    const storageService = accessor.get(IStorageService);
+    const productService = accessor.get(IProductService);
+    const environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
+    const defaultTrustedDomains = [
+        ...(productService.linkProtectionTrustedDomains ?? []),
+        ...(environmentService.options?.additionalTrustedDomains ?? [])
+    ];
+    let trustedDomains = [];
+    try {
+        const trustedDomainsSrc = storageService.get(TRUSTED_DOMAINS_STORAGE_KEY, -1 );
+        if (trustedDomainsSrc) {
+            trustedDomains = JSON.parse(trustedDomainsSrc);
+        }
+    }
+    catch (err) { }
+    return {
+        defaultTrustedDomains,
+        trustedDomains,
+    };
+}
+
+export { TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, TRUSTED_DOMAINS_STORAGE_KEY, configureOpenerTrustedDomainsHandler, extractGitHubRemotesFromGitConfig, manageTrustedDomainSettingsCommand, readAuthenticationTrustedDomains, readStaticTrustedDomains, readTrustedDomains, readWorkspaceTrustedDomains };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomainsFileSystemProvider.js

@@ -0,0 +1,136 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/json.js';
+import { FileType, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, readTrustedDomains, TRUSTED_DOMAINS_STORAGE_KEY } from './trustedDomains.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+const TRUSTED_DOMAINS_SCHEMA = 'trustedDomains';
+const TRUSTED_DOMAINS_STAT = {
+    type: FileType.File,
+    ctime: Date.now(),
+    mtime: Date.now(),
+    size: 0
+};
+const CONFIG_HELP_TEXT_PRE = `// Links matching one or more entries in the list below can be opened without link protection.
+// The following examples show what entries can look like:
+// - "https://microsoft.com": Matches this specific domain using https
+// - "https://microsoft.com:8080": Matches this specific domain on this port using https
+// - "https://microsoft.com:*": Matches this specific domain on any port using https
+// - "https://microsoft.com/foo": Matches https://microsoft.com/foo and https://microsoft.com/foo/bar,
+//   but not https://microsoft.com/foobar or https://microsoft.com/bar
+// - "https://*.microsoft.com": Match all domains ending in "microsoft.com" using https
+// - "microsoft.com": Match this specific domain using either http or https
+// - "*.microsoft.com": Match all domains ending in "microsoft.com" using either http or https
+// - "http://192.168.0.1: Matches this specific IP using http
+// - "http://192.168.0.*: Matches all IP's with this prefix using http
+// - "*": Match all domains using either http or https
+//
+`;
+const CONFIG_HELP_TEXT_AFTER = `//
+// You can use the "Manage Trusted Domains" command to open this file.
+// Save this file to apply the trusted domains rules.
+`;
+const CONFIG_PLACEHOLDER_TEXT = `[
+	// "https://microsoft.com"
+]`;
+function computeTrustedDomainContent(defaultTrustedDomains, trustedDomains, userTrustedDomains, workspaceTrustedDomains, configuring) {
+    let content = CONFIG_HELP_TEXT_PRE;
+    if (defaultTrustedDomains.length > 0) {
+        content += `// By default, VS Code trusts "localhost" as well as the following domains:\n`;
+        defaultTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    else {
+        content += `// By default, VS Code trusts "localhost".\n`;
+    }
+    if (userTrustedDomains.length) {
+        content += `//\n// Additionally, the following domains are trusted based on your logged-in Accounts:\n`;
+        userTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    if (workspaceTrustedDomains.length) {
+        content += `//\n// Further, the following domains are trusted based on your workspace configuration:\n`;
+        workspaceTrustedDomains.forEach(d => {
+            content += `// - "${d}"\n`;
+        });
+    }
+    content += CONFIG_HELP_TEXT_AFTER;
+    content += configuring ? `\n// Currently configuring trust for ${configuring}\n` : '';
+    if (trustedDomains.length === 0) {
+        content += CONFIG_PLACEHOLDER_TEXT;
+    }
+    else {
+        content += JSON.stringify(trustedDomains, null, 2);
+    }
+    return content;
+}
+let TrustedDomainsFileSystemProvider = class TrustedDomainsFileSystemProvider {
+    constructor(fileService, storageService, instantiationService) {
+        this.fileService = fileService;
+        this.storageService = storageService;
+        this.instantiationService = instantiationService;
+        this.capabilities = 2 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidChangeFile = Event.None;
+        this.fileService.registerProvider(TRUSTED_DOMAINS_SCHEMA, this);
+    }
+    stat(resource) {
+        return Promise.resolve(TRUSTED_DOMAINS_STAT);
+    }
+    async readFile(resource) {
+        let trustedDomainsContent = this.storageService.get(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, -1 );
+        const configuring = resource.fragment;
+        const { defaultTrustedDomains, trustedDomains, userDomains, workspaceDomains } = await this.instantiationService.invokeFunction(readTrustedDomains);
+        if (!trustedDomainsContent ||
+            trustedDomainsContent.indexOf(CONFIG_HELP_TEXT_PRE) === -1 ||
+            trustedDomainsContent.indexOf(CONFIG_HELP_TEXT_AFTER) === -1 ||
+            trustedDomainsContent.indexOf(configuring ?? '') === -1 ||
+            ( [...defaultTrustedDomains, ...trustedDomains, ...userDomains, ...workspaceDomains].some(d => !assertIsDefined(trustedDomainsContent).includes(d)))) {
+            trustedDomainsContent = computeTrustedDomainContent(defaultTrustedDomains, trustedDomains, userDomains, workspaceDomains, configuring);
+        }
+        const buffer = VSBuffer.fromString(trustedDomainsContent).buffer;
+        return buffer;
+    }
+    writeFile(resource, content, opts) {
+        try {
+            const trustedDomainsContent = ( VSBuffer.wrap(content).toString());
+            const trustedDomains = parse(trustedDomainsContent);
+            this.storageService.store(TRUSTED_DOMAINS_CONTENT_STORAGE_KEY, trustedDomainsContent, -1 , 0 );
+            this.storageService.store(TRUSTED_DOMAINS_STORAGE_KEY, JSON.stringify(trustedDomains) || '', -1 , 0 );
+        }
+        catch (err) { }
+        return Promise.resolve();
+    }
+    watch(resource, opts) {
+        return {
+            dispose() {
+                return;
+            }
+        };
+    }
+    mkdir(resource) {
+        return Promise.resolve(undefined);
+    }
+    readdir(resource) {
+        return Promise.resolve(undefined);
+    }
+    delete(resource, opts) {
+        return Promise.resolve(undefined);
+    }
+    rename(from, to, opts) {
+        return Promise.resolve(undefined);
+    }
+};
+TrustedDomainsFileSystemProvider = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IInstantiationService))
+], TrustedDomainsFileSystemProvider));
+
+export { TrustedDomainsFileSystemProvider };

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomainsValidator.js

@@ -0,0 +1,205 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { WindowIdleValue } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { matchesScheme, Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { readAuthenticationTrustedDomains, readWorkspaceTrustedDomains, readStaticTrustedDomains, configureOpenerTrustedDomainsHandler } from './trustedDomains.js';
+import { testUrlMatchesGlob } from 'vscode/vscode/vs/workbench/contrib/url/common/urlGlob';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+let OpenerValidatorContributions = class OpenerValidatorContributions {
+    constructor(_openerService, _storageService, _dialogService, _productService, _quickInputService, _editorService, _clipboardService, _telemetryService, _instantiationService, _authenticationService, _workspaceContextService, _configurationService, _workspaceTrustService) {
+        this._openerService = _openerService;
+        this._storageService = _storageService;
+        this._dialogService = _dialogService;
+        this._productService = _productService;
+        this._quickInputService = _quickInputService;
+        this._editorService = _editorService;
+        this._clipboardService = _clipboardService;
+        this._telemetryService = _telemetryService;
+        this._instantiationService = _instantiationService;
+        this._authenticationService = _authenticationService;
+        this._workspaceContextService = _workspaceContextService;
+        this._configurationService = _configurationService;
+        this._workspaceTrustService = _workspaceTrustService;
+        this._openerService.registerValidator({ shouldOpen: (uri, options) => this.validateLink(uri, options) });
+        this._readAuthenticationTrustedDomainsResult = ( new WindowIdleValue(
+            mainWindow,
+            () => this._instantiationService.invokeFunction(readAuthenticationTrustedDomains)
+        ));
+        this._authenticationService.onDidRegisterAuthenticationProvider(() => {
+            this._readAuthenticationTrustedDomainsResult?.dispose();
+            this._readAuthenticationTrustedDomainsResult = ( new WindowIdleValue(
+                mainWindow,
+                () => this._instantiationService.invokeFunction(readAuthenticationTrustedDomains)
+            ));
+        });
+        this._readWorkspaceTrustedDomainsResult = ( new WindowIdleValue(
+            mainWindow,
+            () => this._instantiationService.invokeFunction(readWorkspaceTrustedDomains)
+        ));
+        this._workspaceContextService.onDidChangeWorkspaceFolders(() => {
+            this._readWorkspaceTrustedDomainsResult?.dispose();
+            this._readWorkspaceTrustedDomainsResult = ( new WindowIdleValue(
+                mainWindow,
+                () => this._instantiationService.invokeFunction(readWorkspaceTrustedDomains)
+            ));
+        });
+    }
+    async validateLink(resource, openOptions) {
+        if (!matchesScheme(resource, Schemas.http) && !matchesScheme(resource, Schemas.https)) {
+            return true;
+        }
+        if (openOptions?.fromWorkspace && this._workspaceTrustService.isWorkspaceTrusted() && !this._configurationService.getValue('workbench.trustedDomains.promptInTrustedWorkspace')) {
+            return true;
+        }
+        const originalResource = resource;
+        let resourceUri;
+        if (typeof resource === 'string') {
+            resourceUri = ( URI.parse(resource));
+        }
+        else {
+            resourceUri = resource;
+        }
+        const { scheme, authority, path, query, fragment } = resourceUri;
+        const domainToOpen = `${scheme}://${authority}`;
+        const [workspaceDomains, userDomains] = await Promise.all([this._readWorkspaceTrustedDomainsResult.value, this._readAuthenticationTrustedDomainsResult.value]);
+        const { defaultTrustedDomains, trustedDomains, } = this._instantiationService.invokeFunction(readStaticTrustedDomains);
+        const allTrustedDomains = [...defaultTrustedDomains, ...trustedDomains, ...userDomains, ...workspaceDomains];
+        if (isURLDomainTrusted(resourceUri, allTrustedDomains)) {
+            return true;
+        }
+        else {
+            let formattedLink = `${scheme}://${authority}${path}`;
+            const linkTail = `${query ? '?' + query : ''}${fragment ? '#' + fragment : ''}`;
+            const remainingLength = Math.max(0, 60 - formattedLink.length);
+            const linkTailLengthToKeep = Math.min(Math.max(5, remainingLength), linkTail.length);
+            if (linkTailLengthToKeep === linkTail.length) {
+                formattedLink += linkTail;
+            }
+            else {
+                formattedLink += linkTail.charAt(0) + '...' + linkTail.substring(linkTail.length - linkTailLengthToKeep + 1);
+            }
+            const { result } = await this._dialogService.prompt({
+                type: Severity.Info,
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                    'openExternalLinkAt',
+                    'Do you want {0} to open the external website?',
+                    this._productService.nameShort
+                )),
+                detail: typeof originalResource === 'string' ? originalResource : formattedLink,
+                buttons: [
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'open', comment: ['&& denotes a mnemonic'] },
+                            '&&Open'
+                        )),
+                        run: () => true
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'copy', comment: ['&& denotes a mnemonic'] },
+                            '&&Copy'
+                        )),
+                        run: () => {
+                            this._clipboardService.writeText(typeof originalResource === 'string' ? originalResource : ( resourceUri.toString(true)));
+                            return false;
+                        }
+                    },
+                    {
+                        label: ( localizeWithPath(
+                            'vs/workbench/contrib/url/browser/trustedDomainsValidator',
+                            { key: 'configureTrustedDomains', comment: ['&& denotes a mnemonic'] },
+                            'Configure &&Trusted Domains'
+                        )),
+                        run: async () => {
+                            const pickedDomains = await configureOpenerTrustedDomainsHandler(trustedDomains, domainToOpen, resourceUri, this._quickInputService, this._storageService, this._editorService);
+                            if (pickedDomains.indexOf('*') !== -1) {
+                                return true;
+                            }
+                            if (isURLDomainTrusted(resourceUri, pickedDomains)) {
+                                return true;
+                            }
+                            return false;
+                        }
+                    }
+                ],
+                cancelButton: {
+                    run: () => false
+                }
+            });
+            return result;
+        }
+    }
+};
+OpenerValidatorContributions = ( __decorate([
+    ( __param(0, IOpenerService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, IProductService)),
+    ( __param(4, IQuickInputService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IClipboardService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, IInstantiationService)),
+    ( __param(9, IAuthenticationService)),
+    ( __param(10, IWorkspaceContextService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, IWorkspaceTrustManagementService))
+], OpenerValidatorContributions));
+const rLocalhost = /^localhost(:\d+)?$/i;
+const r127 = /^127.0.0.1(:\d+)?$/;
+function isLocalhostAuthority(authority) {
+    return rLocalhost.test(authority) || r127.test(authority);
+}
+function normalizeURL(url) {
+    const caseInsensitiveAuthorities = ['github.com'];
+    try {
+        const parsed = typeof url === 'string' ? ( URI.parse(url, true)) : url;
+        if (caseInsensitiveAuthorities.includes(parsed.authority)) {
+            return ( parsed.with({ path: parsed.path.toLowerCase() }).toString(true));
+        }
+        else {
+            return ( parsed.toString(true));
+        }
+    }
+    catch {
+        return ( url.toString());
+    }
+}
+function isURLDomainTrusted(url, trustedDomains) {
+    url = ( URI.parse(normalizeURL(url)));
+    trustedDomains = ( trustedDomains.map(normalizeURL));
+    if (isLocalhostAuthority(url.authority)) {
+        return true;
+    }
+    for (let i = 0; i < trustedDomains.length; i++) {
+        if (trustedDomains[i] === '*') {
+            return true;
+        }
+        if (testUrlMatchesGlob(url, trustedDomains[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { OpenerValidatorContributions, isURLDomainTrusted };

package/vscode/src/vs/workbench/contrib/url/browser/url.contribution.js

@@ -0,0 +1,70 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { ExternalUriResolverContribution } from './externalUriResolver.js';
+import { manageTrustedDomainSettingsCommand } from './trustedDomains.js';
+import { TrustedDomainsFileSystemProvider } from './trustedDomainsFileSystemProvider.js';
+import { OpenerValidatorContributions } from './trustedDomainsValidator.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { workbenchConfigurationNodeBase } from 'vscode/vscode/vs/workbench/common/configuration';
+
+class OpenUrlAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.url.openUrl',
+            title: { value: ( localizeWithPath('vs/workbench/contrib/url/browser/url.contribution', 'openUrl', "Open URL")), original: 'Open URL' },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const urlService = accessor.get(IURLService);
+        return quickInputService.input({ prompt: ( localizeWithPath(
+            'vs/workbench/contrib/url/browser/url.contribution',
+            'urlToOpen',
+            "URL to open"
+        )) }).then(input => {
+            if (input) {
+                const uri = ( URI.parse(input));
+                urlService.open(uri, { originalUrl: input });
+            }
+        });
+    }
+}
+registerAction2(OpenUrlAction);
+CommandsRegistry.registerCommand(manageTrustedDomainSettingsCommand);
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: manageTrustedDomainSettingsCommand.id,
+        title: {
+            value: manageTrustedDomainSettingsCommand.description.description,
+            original: 'Manage Trusted Domains'
+        }
+    }
+});
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(OpenerValidatorContributions, 3 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(TrustedDomainsFileSystemProvider, 2 );
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExternalUriResolverContribution, 2 );
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        'workbench.trustedDomains.promptInTrustedWorkspace': {
+            scope: 1 ,
+            type: 'boolean',
+            default: false,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/url/browser/url.contribution',
+                'workbench.trustedDomains.promptInTrustedWorkspace',
+                "When enabled, trusted domain prompts will appear when opening links in trusted workspaces."
+            ))
+        }
+    }
+});