@codingame/monaco-vscode-api 1.82.2 → 1.82.3

package/vscode/src/vs/workbench/contrib/workspace/browser/workspaceTrustEditor.js

@@ -0,0 +1,1047 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { $, addDisposableListener, EventType, EventHelper, addStandardDisposableListener, clearNode, append, isAncestor } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ButtonBar } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { isVirtualResource, isVirtualWorkspace } from '../../../../platform/workspace/common/virtualWorkspace.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 { asCssVariable, buttonBackground, buttonSecondaryBackground, editorErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { toWorkspaceIdentifier, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { debugIconStartForeground } from '../../debug/browser/debugColors.js';
+import { LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID, IExtensionsWorkbenchService } from '../../extensions/common/extensions.js';
+import { IWorkbenchConfigurationService } from '../../../services/configuration/common/configuration.js';
+import { IExtensionManifestPropertiesService } from '../../../services/extensions/common/extensionManifestPropertiesService.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { getExtensionDependencies } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { IWorkbenchExtensionEnablementService } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { posix, win32 } from 'monaco-editor/esm/vs/base/common/path.js';
+import { hasDriveLetter, toSlashes } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { defaultButtonStyles, defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var TrustedUriActionsColumnRenderer_1, TrustedUriPathColumnRenderer_1, TrustedUriHostColumnRenderer_1, WorkspaceTrustEditor_1;
+const shieldIcon = registerIcon('workspace-trust-banner', Codicon.shield, ( (localize('shieldIcon', 'Icon for workspace trust ion the banner.'))));
+const checkListIcon = registerIcon('workspace-trust-editor-check', Codicon.check, ( (localize('checkListIcon', 'Icon for the checkmark in the workspace trust editor.'))));
+const xListIcon = registerIcon('workspace-trust-editor-cross', Codicon.x, ( (localize('xListIcon', 'Icon for the cross in the workspace trust editor.'))));
+const folderPickerIcon = registerIcon('workspace-trust-editor-folder-picker', Codicon.folder, ( (localize(
+    'folderPickerIcon',
+    'Icon for the pick folder icon in the workspace trust editor.'
+))));
+const editIcon = registerIcon('workspace-trust-editor-edit-folder', Codicon.edit, ( (localize('editIcon', 'Icon for the edit folder icon in the workspace trust editor.'))));
+const removeIcon = registerIcon('workspace-trust-editor-remove-folder', Codicon.close, ( (localize(
+    'removeIcon',
+    'Icon for the remove folder icon in the workspace trust editor.'
+))));
+let WorkspaceTrustedUrisTable = class WorkspaceTrustedUrisTable extends Disposable {
+    constructor(container, instantiationService, workspaceService, workspaceTrustManagementService, uriService, labelService, fileDialogService) {
+        super();
+        this.container = container;
+        this.instantiationService = instantiationService;
+        this.workspaceService = workspaceService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.uriService = uriService;
+        this.labelService = labelService;
+        this.fileDialogService = fileDialogService;
+        this._onDidAcceptEdit = this._register(( (new Emitter())));
+        this.onDidAcceptEdit = this._onDidAcceptEdit.event;
+        this._onDidRejectEdit = this._register(( (new Emitter())));
+        this.onDidRejectEdit = this._onDidRejectEdit.event;
+        this._onEdit = this._register(( (new Emitter())));
+        this.onEdit = this._onEdit.event;
+        this._onDelete = this._register(( (new Emitter())));
+        this.onDelete = this._onDelete.event;
+        this.descriptionElement = container.appendChild($('.workspace-trusted-folders-description'));
+        const tableElement = container.appendChild($('.trusted-uris-table'));
+        const addButtonBarElement = container.appendChild($('.trusted-uris-button-bar'));
+        this.table = this.instantiationService.createInstance(WorkbenchTable, 'WorkspaceTrust', tableElement, ( (new TrustedUriTableVirtualDelegate())), [
+            {
+                label: ( (localize('hostColumnLabel', "Host"))),
+                tooltip: '',
+                weight: 1,
+                templateId: TrustedUriHostColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: ( (localize('pathColumnLabel', "Path"))),
+                tooltip: '',
+                weight: 8,
+                templateId: TrustedUriPathColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+            {
+                label: '',
+                tooltip: '',
+                weight: 1,
+                minimumWidth: 75,
+                maximumWidth: 75,
+                templateId: TrustedUriActionsColumnRenderer.TEMPLATE_ID,
+                project(row) { return row; }
+            },
+        ], [
+            this.instantiationService.createInstance(TrustedUriHostColumnRenderer),
+            this.instantiationService.createInstance(TrustedUriPathColumnRenderer, this),
+            this.instantiationService.createInstance(TrustedUriActionsColumnRenderer, this, this.currentWorkspaceUri),
+        ], {
+            horizontalScrolling: false,
+            alwaysConsumeMouseWheel: false,
+            openOnSingleClick: false,
+            multipleSelectionSupport: false,
+            accessibilityProvider: {
+                getAriaLabel: (item) => {
+                    const hostLabel = getHostLabel(this.labelService, item);
+                    if (hostLabel === undefined || hostLabel.length === 0) {
+                        return (
+                             (localize(
+                                'trustedFolderAriaLabel',
+                                "{0}, trusted",
+                                this.labelService.getUriLabel(item.uri)
+                            ))
+                        );
+                    }
+                    return (
+                         (localize(
+                            'trustedFolderWithHostAriaLabel',
+                            "{0} on {1}, trusted",
+                            this.labelService.getUriLabel(item.uri),
+                            hostLabel
+                        ))
+                    );
+                },
+                getWidgetAriaLabel: () => ( (localize('trustedFoldersAndWorkspaces', "Trusted Folders & Workspaces")))
+            }
+        });
+        this._register(this.table.onDidOpen(item => {
+            if (item && item.element && !item.browserEvent?.defaultPrevented) {
+                this.edit(item.element, true);
+            }
+        }));
+        const buttonBar = this._register(( (new ButtonBar(addButtonBarElement))));
+        const addButton = this._register(buttonBar.addButton({ title: ( (localize('addButton', "Add Folder"))), ...defaultButtonStyles }));
+        addButton.label = ( (localize('addButton', "Add Folder")));
+        this._register(addButton.onDidClick(async () => {
+            const uri = await this.fileDialogService.showOpenDialog({
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                defaultUri: this.currentWorkspaceUri,
+                openLabel: ( (localize('trustUri', "Trust Folder"))),
+                title: ( (localize('selectTrustedUri', "Select Folder To Trust")))
+            });
+            if (uri) {
+                this.workspaceTrustManagementService.setUrisTrust(uri, true);
+            }
+        }));
+        this._register(this.workspaceTrustManagementService.onDidChangeTrustedFolders(() => {
+            this.updateTable();
+        }));
+    }
+    getIndexOfTrustedUriEntry(item) {
+        const index = this.trustedUriEntries.indexOf(item);
+        if (index === -1) {
+            for (let i = 0; i < this.trustedUriEntries.length; i++) {
+                if (this.trustedUriEntries[i].uri === item.uri) {
+                    return i;
+                }
+            }
+        }
+        return index;
+    }
+    selectTrustedUriEntry(item, focus = true) {
+        const index = this.getIndexOfTrustedUriEntry(item);
+        if (index !== -1) {
+            if (focus) {
+                this.table.domFocus();
+                this.table.setFocus([index]);
+            }
+            this.table.setSelection([index]);
+        }
+    }
+    get currentWorkspaceUri() {
+        return this.workspaceService.getWorkspace().folders[0]?.uri || URI.file('/');
+    }
+    get trustedUriEntries() {
+        const currentWorkspace = this.workspaceService.getWorkspace();
+        const currentWorkspaceUris = ( (currentWorkspace.folders.map(folder => folder.uri)));
+        if (currentWorkspace.configuration) {
+            currentWorkspaceUris.push(currentWorkspace.configuration);
+        }
+        const entries = ( (this.workspaceTrustManagementService.getTrustedUris().map(uri => {
+            let relatedToCurrentWorkspace = false;
+            for (const workspaceUri of currentWorkspaceUris) {
+                relatedToCurrentWorkspace = relatedToCurrentWorkspace || this.uriService.extUri.isEqualOrParent(workspaceUri, uri);
+            }
+            return {
+                uri,
+                parentOfWorkspaceItem: relatedToCurrentWorkspace
+            };
+        })));
+        const sortedEntries = entries.sort((a, b) => {
+            if (a.uri.scheme !== b.uri.scheme) {
+                if (a.uri.scheme === Schemas.file) {
+                    return -1;
+                }
+                if (b.uri.scheme === Schemas.file) {
+                    return 1;
+                }
+            }
+            const aIsWorkspace = a.uri.path.endsWith('.code-workspace');
+            const bIsWorkspace = b.uri.path.endsWith('.code-workspace');
+            if (aIsWorkspace !== bIsWorkspace) {
+                if (aIsWorkspace) {
+                    return 1;
+                }
+                if (bIsWorkspace) {
+                    return -1;
+                }
+            }
+            return a.uri.fsPath.localeCompare(b.uri.fsPath);
+        });
+        return sortedEntries;
+    }
+    layout() {
+        this.table.layout((this.trustedUriEntries.length * TrustedUriTableVirtualDelegate.ROW_HEIGHT) + TrustedUriTableVirtualDelegate.HEADER_ROW_HEIGHT, undefined);
+    }
+    updateTable() {
+        const entries = this.trustedUriEntries;
+        this.container.classList.toggle('empty', entries.length === 0);
+        this.descriptionElement.innerText = entries.length ?
+            ( (localize(
+            'trustedFoldersDescription',
+            "You trust the following folders, their subfolders, and workspace files."
+        ))) :
+            ( (localize(
+            'noTrustedFoldersDescriptions',
+            "You haven't trusted any folders or workspace files yet."
+        )));
+        this.table.splice(0, Number.POSITIVE_INFINITY, this.trustedUriEntries);
+        this.layout();
+    }
+    validateUri(path, item) {
+        if (!item) {
+            return null;
+        }
+        if (item.uri.scheme === 'vscode-vfs') {
+            const segments = path.split(posix.sep).filter(s => s.length);
+            if (segments.length === 0 && path.startsWith(posix.sep)) {
+                return {
+                    type: 2 ,
+                    content: ( (localize(
+                        { key: 'trustAll', comment: ['The {0} will be a host name where repositories are hosted.'] },
+                        "You will trust all repositories on {0}.",
+                        getHostLabel(this.labelService, item)
+                    )))
+                };
+            }
+            if (segments.length === 1) {
+                return {
+                    type: 2 ,
+                    content: ( (localize(
+                        { key: 'trustOrg', comment: ['The {0} will be an organization or user name.', 'The {1} will be a host name where repositories are hosted.'] },
+                        "You will trust all repositories and forks under '{0}' on {1}.",
+                        segments[0],
+                        getHostLabel(this.labelService, item)
+                    )))
+                };
+            }
+            if (segments.length > 2) {
+                return {
+                    type: 3 ,
+                    content: ( (localize(
+                        'invalidTrust',
+                        "You cannot trust individual folders within a repository.",
+                        path
+                    )))
+                };
+            }
+        }
+        return null;
+    }
+    acceptEdit(item, uri) {
+        const trustedFolders = this.workspaceTrustManagementService.getTrustedUris();
+        const index = trustedFolders.findIndex(u => this.uriService.extUri.isEqual(u, item.uri));
+        if (index >= trustedFolders.length || index === -1) {
+            trustedFolders.push(uri);
+        }
+        else {
+            trustedFolders[index] = uri;
+        }
+        this.workspaceTrustManagementService.setTrustedUris(trustedFolders);
+        this._onDidAcceptEdit.fire(item);
+    }
+    rejectEdit(item) {
+        this._onDidRejectEdit.fire(item);
+    }
+    async delete(item) {
+        await this.workspaceTrustManagementService.setUrisTrust([item.uri], false);
+        this._onDelete.fire(item);
+    }
+    async edit(item, usePickerIfPossible) {
+        const canUseOpenDialog = item.uri.scheme === Schemas.file ||
+            (item.uri.scheme === this.currentWorkspaceUri.scheme &&
+                this.uriService.extUri.isEqualAuthority(this.currentWorkspaceUri.authority, item.uri.authority) &&
+                !isVirtualResource(item.uri));
+        if (canUseOpenDialog && usePickerIfPossible) {
+            const uri = await this.fileDialogService.showOpenDialog({
+                canSelectFiles: false,
+                canSelectFolders: true,
+                canSelectMany: false,
+                defaultUri: item.uri,
+                openLabel: ( (localize('trustUri', "Trust Folder"))),
+                title: ( (localize('selectTrustedUri', "Select Folder To Trust")))
+            });
+            if (uri) {
+                this.acceptEdit(item, uri[0]);
+            }
+            else {
+                this.rejectEdit(item);
+            }
+        }
+        else {
+            this.selectTrustedUriEntry(item);
+            this._onEdit.fire(item);
+        }
+    }
+};
+WorkspaceTrustedUrisTable = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IWorkspaceTrustManagementService))),
+    ( (__param(4, IUriIdentityService))),
+    ( (__param(5, ILabelService))),
+    ( (__param(6, IFileDialogService)))
+], WorkspaceTrustedUrisTable)));
+class TrustedUriTableVirtualDelegate {
+    constructor() {
+        this.headerRowHeight = TrustedUriTableVirtualDelegate.HEADER_ROW_HEIGHT;
+    }
+    static { this.HEADER_ROW_HEIGHT = 30; }
+    static { this.ROW_HEIGHT = 24; }
+    getHeight(item) {
+        return TrustedUriTableVirtualDelegate.ROW_HEIGHT;
+    }
+}
+let TrustedUriActionsColumnRenderer = class TrustedUriActionsColumnRenderer {
+    static { TrustedUriActionsColumnRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'actions'; }
+    constructor(table, currentWorkspaceUri, uriService) {
+        this.table = table;
+        this.currentWorkspaceUri = currentWorkspaceUri;
+        this.uriService = uriService;
+        this.templateId = TrustedUriActionsColumnRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const element = container.appendChild($('.actions'));
+        const actionBar = ( (new ActionBar(element, { animated: false })));
+        return { actionBar };
+    }
+    renderElement(item, index, templateData, height) {
+        templateData.actionBar.clear();
+        const canUseOpenDialog = item.uri.scheme === Schemas.file ||
+            (item.uri.scheme === this.currentWorkspaceUri.scheme &&
+                this.uriService.extUri.isEqualAuthority(this.currentWorkspaceUri.authority, item.uri.authority) &&
+                !isVirtualResource(item.uri));
+        const actions = [];
+        if (canUseOpenDialog) {
+            actions.push(this.createPickerAction(item));
+        }
+        actions.push(this.createEditAction(item));
+        actions.push(this.createDeleteAction(item));
+        templateData.actionBar.push(actions, { icon: true });
+    }
+    createEditAction(item) {
+        return {
+            class: ThemeIcon.asClassName(editIcon),
+            enabled: true,
+            id: 'editTrustedUri',
+            tooltip: ( (localize('editTrustedUri', "Edit Path"))),
+            run: () => {
+                this.table.edit(item, false);
+            }
+        };
+    }
+    createPickerAction(item) {
+        return {
+            class: ThemeIcon.asClassName(folderPickerIcon),
+            enabled: true,
+            id: 'pickerTrustedUri',
+            tooltip: ( (localize('pickerTrustedUri', "Open File Picker"))),
+            run: () => {
+                this.table.edit(item, true);
+            }
+        };
+    }
+    createDeleteAction(item) {
+        return {
+            class: ThemeIcon.asClassName(removeIcon),
+            enabled: true,
+            id: 'deleteTrustedUri',
+            tooltip: ( (localize('deleteTrustedUri', "Delete Path"))),
+            run: async () => {
+                await this.table.delete(item);
+            }
+        };
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+    }
+};
+TrustedUriActionsColumnRenderer = TrustedUriActionsColumnRenderer_1 = ( (__decorate([
+    ( (__param(2, IUriIdentityService)))
+], TrustedUriActionsColumnRenderer)));
+let TrustedUriPathColumnRenderer = class TrustedUriPathColumnRenderer {
+    static { TrustedUriPathColumnRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'path'; }
+    constructor(table, contextViewService) {
+        this.table = table;
+        this.contextViewService = contextViewService;
+        this.templateId = TrustedUriPathColumnRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const element = container.appendChild($('.path'));
+        const pathLabel = element.appendChild($('div.path-label'));
+        const pathInput = ( (new InputBox(element, this.contextViewService, {
+            validationOptions: {
+                validation: value => this.table.validateUri(value, this.currentItem)
+            },
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        const disposables = ( (new DisposableStore()));
+        const renderDisposables = disposables.add(( (new DisposableStore())));
+        return {
+            element,
+            pathLabel,
+            pathInput,
+            disposables,
+            renderDisposables
+        };
+    }
+    renderElement(item, index, templateData, height) {
+        templateData.renderDisposables.clear();
+        this.currentItem = item;
+        templateData.renderDisposables.add(this.table.onEdit(async (e) => {
+            if (item === e) {
+                templateData.element.classList.add('input-mode');
+                templateData.pathInput.focus();
+                templateData.pathInput.select();
+                templateData.element.parentElement.style.paddingLeft = '0px';
+            }
+        }));
+        templateData.renderDisposables.add(addDisposableListener(templateData.pathInput.element, EventType.DBLCLICK, e => {
+            EventHelper.stop(e);
+        }));
+        const hideInputBox = () => {
+            templateData.element.classList.remove('input-mode');
+            templateData.element.parentElement.style.paddingLeft = '5px';
+        };
+        const accept = () => {
+            hideInputBox();
+            const pathToUse = templateData.pathInput.value;
+            const uri = hasDriveLetter(pathToUse) ? item.uri.with({ path: posix.sep + toSlashes(pathToUse) }) : item.uri.with({ path: pathToUse });
+            templateData.pathLabel.innerText = this.formatPath(uri);
+            if (uri) {
+                this.table.acceptEdit(item, uri);
+            }
+        };
+        const reject = () => {
+            hideInputBox();
+            templateData.pathInput.value = stringValue;
+            this.table.rejectEdit(item);
+        };
+        templateData.renderDisposables.add(addStandardDisposableListener(templateData.pathInput.inputElement, EventType.KEY_DOWN, e => {
+            let handled = false;
+            if (e.equals(3 )) {
+                accept();
+                handled = true;
+            }
+            else if (e.equals(9 )) {
+                reject();
+                handled = true;
+            }
+            if (handled) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        }));
+        templateData.renderDisposables.add((addDisposableListener(templateData.pathInput.inputElement, EventType.BLUR, () => {
+            reject();
+        })));
+        const stringValue = this.formatPath(item.uri);
+        templateData.pathInput.value = stringValue;
+        templateData.pathLabel.innerText = stringValue;
+        templateData.element.classList.toggle('current-workspace-parent', item.parentOfWorkspaceItem);
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+        templateData.renderDisposables.dispose();
+    }
+    formatPath(uri) {
+        if (uri.scheme === Schemas.file) {
+            return normalizeDriveLetter(uri.fsPath);
+        }
+        if (uri.path.startsWith(posix.sep)) {
+            const pathWithoutLeadingSeparator = uri.path.substring(1);
+            const isWindowsPath = hasDriveLetter(pathWithoutLeadingSeparator, true);
+            if (isWindowsPath) {
+                return normalizeDriveLetter(win32.normalize(pathWithoutLeadingSeparator), true);
+            }
+        }
+        return uri.path;
+    }
+};
+TrustedUriPathColumnRenderer = TrustedUriPathColumnRenderer_1 = ( (__decorate([
+    ( (__param(1, IContextViewService)))
+], TrustedUriPathColumnRenderer)));
+function getHostLabel(labelService, item) {
+    return item.uri.authority ? labelService.getHostLabel(item.uri.scheme, item.uri.authority) : ( (localize('localAuthority', "Local")));
+}
+let TrustedUriHostColumnRenderer = class TrustedUriHostColumnRenderer {
+    static { TrustedUriHostColumnRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'host'; }
+    constructor(labelService) {
+        this.labelService = labelService;
+        this.templateId = TrustedUriHostColumnRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const disposables = ( (new DisposableStore()));
+        const renderDisposables = disposables.add(( (new DisposableStore())));
+        const element = container.appendChild($('.host'));
+        const hostContainer = element.appendChild($('div.host-label'));
+        const buttonBarContainer = element.appendChild($('div.button-bar'));
+        return {
+            element,
+            hostContainer,
+            buttonBarContainer,
+            disposables,
+            renderDisposables
+        };
+    }
+    renderElement(item, index, templateData, height) {
+        templateData.renderDisposables.clear();
+        templateData.renderDisposables.add({ dispose: () => { clearNode(templateData.buttonBarContainer); } });
+        templateData.hostContainer.innerText = getHostLabel(this.labelService, item);
+        templateData.element.classList.toggle('current-workspace-parent', item.parentOfWorkspaceItem);
+        templateData.hostContainer.style.display = '';
+        templateData.buttonBarContainer.style.display = 'none';
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+TrustedUriHostColumnRenderer = TrustedUriHostColumnRenderer_1 = ( (__decorate([
+    ( (__param(0, ILabelService)))
+], TrustedUriHostColumnRenderer)));
+let WorkspaceTrustEditor = class WorkspaceTrustEditor extends EditorPane {
+    static { WorkspaceTrustEditor_1 = this; }
+    static { this.ID = 'workbench.editor.workspaceTrust'; }
+    constructor(telemetryService, themeService, storageService, workspaceService, extensionWorkbenchService, extensionManifestPropertiesService, instantiationService, workspaceTrustManagementService, configurationService, extensionEnablementService, productService, keybindingService) {
+        super(WorkspaceTrustEditor_1.ID, telemetryService, themeService, storageService);
+        this.workspaceService = workspaceService;
+        this.extensionWorkbenchService = extensionWorkbenchService;
+        this.extensionManifestPropertiesService = extensionManifestPropertiesService;
+        this.instantiationService = instantiationService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.configurationService = configurationService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.productService = productService;
+        this.keybindingService = keybindingService;
+        this.rendering = false;
+        this.rerenderDisposables = this._register(( (new DisposableStore())));
+        this.layoutParticipants = [];
+    }
+    createEditor(parent) {
+        this.rootElement = append(parent, $('.workspace-trust-editor', { tabindex: '0' }));
+        this.createHeaderElement(this.rootElement);
+        const scrollableContent = $('.workspace-trust-editor-body');
+        this.bodyScrollBar = this._register(( (new DomScrollableElement(scrollableContent, {
+            horizontal: 2 ,
+            vertical: 1 ,
+        }))));
+        append(this.rootElement, this.bodyScrollBar.getDomNode());
+        this.createAffectedFeaturesElement(scrollableContent);
+        this.createConfigurationElement(scrollableContent);
+        this.rootElement.style.setProperty('--workspace-trust-selected-color', asCssVariable(buttonBackground));
+        this.rootElement.style.setProperty('--workspace-trust-unselected-color', asCssVariable(buttonSecondaryBackground));
+        this.rootElement.style.setProperty('--workspace-trust-check-color', asCssVariable(debugIconStartForeground));
+        this.rootElement.style.setProperty('--workspace-trust-x-color', asCssVariable(editorErrorForeground));
+        this._register(addDisposableListener(this.rootElement, EventType.KEY_DOWN, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            if (event.equals(16 ) || event.equals(18 )) {
+                const navOrder = [this.headerContainer, this.trustedContainer, this.untrustedContainer, this.configurationContainer];
+                const currentIndex = navOrder.findIndex(element => {
+                    return isAncestor(document.activeElement, element);
+                });
+                let newIndex = currentIndex;
+                if (event.equals(18 )) {
+                    newIndex++;
+                }
+                else if (event.equals(16 )) {
+                    newIndex = Math.max(0, newIndex);
+                    newIndex--;
+                }
+                newIndex += navOrder.length;
+                newIndex %= navOrder.length;
+                navOrder[newIndex].focus();
+            }
+            else if (event.equals(9 )) {
+                this.rootElement.focus();
+            }
+            else if (event.equals(2048  | 3 )) {
+                if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
+                    this.workspaceTrustManagementService.setWorkspaceTrust(!this.workspaceTrustManagementService.isWorkspaceTrusted());
+                }
+            }
+            else if (event.equals(2048  | 1024  | 3 )) {
+                if (this.workspaceTrustManagementService.canSetParentFolderTrust()) {
+                    this.workspaceTrustManagementService.setParentFolderTrust(true);
+                }
+            }
+        }));
+    }
+    focus() {
+        this.rootElement.focus();
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        await this.workspaceTrustManagementService.workspaceTrustInitialized;
+        this.registerListeners();
+        await this.render();
+    }
+    registerListeners() {
+        this._register(this.extensionWorkbenchService.onChange(() => this.render()));
+        this._register(this.configurationService.onDidChangeRestrictedSettings(() => this.render()));
+        this._register(this.workspaceTrustManagementService.onDidChangeTrust(() => this.render()));
+        this._register(this.workspaceTrustManagementService.onDidChangeTrustedFolders(() => this.render()));
+    }
+    getHeaderContainerClass(trusted) {
+        if (trusted) {
+            return 'workspace-trust-header workspace-trust-trusted';
+        }
+        return 'workspace-trust-header workspace-trust-untrusted';
+    }
+    getHeaderTitleText(trusted) {
+        if (trusted) {
+            if (this.workspaceTrustManagementService.isWorkspaceTrustForced()) {
+                return (
+                     (localize('trustedUnsettableWindow', "This window is trusted"))
+                );
+            }
+            switch (this.workspaceService.getWorkbenchState()) {
+                case 1 :
+                    return (
+                         (localize('trustedHeaderWindow', "You trust this window"))
+                    );
+                case 2 :
+                    return (
+                         (localize('trustedHeaderFolder', "You trust this folder"))
+                    );
+                case 3 :
+                    return (
+                         (localize('trustedHeaderWorkspace', "You trust this workspace"))
+                    );
+            }
+        }
+        return (
+             (localize('untrustedHeader', "You are in Restricted Mode"))
+        );
+    }
+    getHeaderTitleIconClassNames(trusted) {
+        return ThemeIcon.asClassNameArray(shieldIcon);
+    }
+    getFeaturesHeaderText(trusted) {
+        let title = '';
+        let subTitle = '';
+        switch (this.workspaceService.getWorkbenchState()) {
+            case 1 : {
+                title = trusted ? ( (localize('trustedWindow', "In a Trusted Window"))) : ( (localize('untrustedWorkspace', "In Restricted Mode")));
+                subTitle = trusted ? ( (localize(
+                    'trustedWindowSubtitle',
+                    "You trust the authors of the files in the current window. All features are enabled:"
+                ))) :
+                    ( (localize(
+                    'untrustedWindowSubtitle',
+                    "You do not trust the authors of the files in the current window. The following features are disabled:"
+                )));
+                break;
+            }
+            case 2 : {
+                title = trusted ? ( (localize('trustedFolder', "In a Trusted Folder"))) : ( (localize('untrustedWorkspace', "In Restricted Mode")));
+                subTitle = trusted ? ( (localize(
+                    'trustedFolderSubtitle',
+                    "You trust the authors of the files in the current folder. All features are enabled:"
+                ))) :
+                    ( (localize(
+                    'untrustedFolderSubtitle',
+                    "You do not trust the authors of the files in the current folder. The following features are disabled:"
+                )));
+                break;
+            }
+            case 3 : {
+                title = trusted ? ( (localize('trustedWorkspace', "In a Trusted Workspace"))) : ( (localize('untrustedWorkspace', "In Restricted Mode")));
+                subTitle = trusted ? ( (localize(
+                    'trustedWorkspaceSubtitle',
+                    "You trust the authors of the files in the current workspace. All features are enabled:"
+                ))) :
+                    ( (localize(
+                    'untrustedWorkspaceSubtitle',
+                    "You do not trust the authors of the files in the current workspace. The following features are disabled:"
+                )));
+                break;
+            }
+        }
+        return [title, subTitle];
+    }
+    async render() {
+        if (this.rendering) {
+            return;
+        }
+        this.rendering = true;
+        this.rerenderDisposables.clear();
+        const isWorkspaceTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
+        this.rootElement.classList.toggle('trusted', isWorkspaceTrusted);
+        this.rootElement.classList.toggle('untrusted', !isWorkspaceTrusted);
+        this.headerTitleText.innerText = this.getHeaderTitleText(isWorkspaceTrusted);
+        this.headerTitleIcon.className = 'workspace-trust-title-icon';
+        this.headerTitleIcon.classList.add(...this.getHeaderTitleIconClassNames(isWorkspaceTrusted));
+        this.headerDescription.innerText = '';
+        const headerDescriptionText = append(this.headerDescription, $('div'));
+        headerDescriptionText.innerText = isWorkspaceTrusted ?
+            ( (localize(
+            'trustedDescription',
+            "All features are enabled because trust has been granted to the workspace."
+        ))) :
+            ( (localize(
+            'untrustedDescription',
+            "{0} is in a restricted mode intended for safe code browsing.",
+            this.productService.nameShort
+        )));
+        const headerDescriptionActions = append(this.headerDescription, $('div'));
+        const headerDescriptionActionsText = ( (localize(
+            { key: 'workspaceTrustEditorHeaderActions', comment: ['Please ensure the markdown link syntax is not broken up with whitespace [text block](link block)'] },
+            "[Configure your settings]({0}) or [learn more](https://aka.ms/vscode-workspace-trust).",
+            `command:workbench.trust.configure`
+        )));
+        for (const node of parseLinkedText(headerDescriptionActionsText).nodes) {
+            if (typeof node === 'string') {
+                append(headerDescriptionActions, document.createTextNode(node));
+            }
+            else {
+                this.rerenderDisposables.add(this.instantiationService.createInstance(Link, headerDescriptionActions, { ...node, tabIndex: -1 }, {}));
+            }
+        }
+        this.headerContainer.className = this.getHeaderContainerClass(isWorkspaceTrusted);
+        this.rootElement.setAttribute('aria-label', `${( ( localize('root element label', "Manage Workspace Trust")))}:  ${this.headerContainer.innerText}`);
+        const restrictedSettings = this.configurationService.restrictedSettings;
+        const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+        const settingsRequiringTrustedWorkspaceCount = restrictedSettings.default.filter(key => {
+            const property = configurationRegistry.getConfigurationProperties()[key];
+            if (property.scope === 1  || property.scope === 2 ) {
+                return false;
+            }
+            if (property.deprecationMessage || property.markdownDeprecationMessage) {
+                if (restrictedSettings.workspace?.includes(key)) {
+                    return true;
+                }
+                if (restrictedSettings.workspaceFolder) {
+                    for (const workspaceFolderSettings of ( (restrictedSettings.workspaceFolder.values()))) {
+                        if (workspaceFolderSettings.includes(key)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return true;
+        }).length;
+        this.renderAffectedFeatures(settingsRequiringTrustedWorkspaceCount, this.getExtensionCount());
+        this.workspaceTrustedUrisTable.updateTable();
+        this.bodyScrollBar.getDomNode().style.height = `calc(100% - ${this.headerContainer.clientHeight}px)`;
+        this.bodyScrollBar.scanDomNode();
+        this.rendering = false;
+    }
+    getExtensionCount() {
+        const set = ( (new Set()));
+        const inVirtualWorkspace = isVirtualWorkspace(this.workspaceService.getWorkspace());
+        const localExtensions = ( (this.extensionWorkbenchService.local.filter(ext => ext.local).map(ext => ext.local)));
+        for (const extension of localExtensions) {
+            const enablementState = this.extensionEnablementService.getEnablementState(extension);
+            if (enablementState !== 8  && enablementState !== 9  &&
+                enablementState !== 0  && enablementState !== 5 ) {
+                continue;
+            }
+            if (inVirtualWorkspace && this.extensionManifestPropertiesService.getExtensionVirtualWorkspaceSupportType(extension.manifest) === false) {
+                continue;
+            }
+            if (this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(extension.manifest) !== true) {
+                set.add(extension.identifier.id);
+                continue;
+            }
+            const dependencies = getExtensionDependencies(localExtensions, extension);
+            if (( (dependencies.some(
+                ext => this.extensionManifestPropertiesService.getExtensionUntrustedWorkspaceSupportType(ext.manifest) === false
+            )))) {
+                set.add(extension.identifier.id);
+            }
+        }
+        return set.size;
+    }
+    createHeaderElement(parent) {
+        this.headerContainer = append(parent, $('.workspace-trust-header', { tabIndex: '0' }));
+        this.headerTitleContainer = append(this.headerContainer, $('.workspace-trust-title'));
+        this.headerTitleIcon = append(this.headerTitleContainer, $('.workspace-trust-title-icon'));
+        this.headerTitleText = append(this.headerTitleContainer, $('.workspace-trust-title-text'));
+        this.headerDescription = append(this.headerContainer, $('.workspace-trust-description'));
+    }
+    createConfigurationElement(parent) {
+        this.configurationContainer = append(parent, $('.workspace-trust-settings', { tabIndex: '0' }));
+        const configurationTitle = append(this.configurationContainer, $('.workspace-trusted-folders-title'));
+        configurationTitle.innerText = ( (localize('trustedFoldersAndWorkspaces', "Trusted Folders & Workspaces")));
+        this.workspaceTrustedUrisTable = this._register(this.instantiationService.createInstance(WorkspaceTrustedUrisTable, this.configurationContainer));
+    }
+    createAffectedFeaturesElement(parent) {
+        this.affectedFeaturesContainer = append(parent, $('.workspace-trust-features'));
+        this.trustedContainer = append(this.affectedFeaturesContainer, $('.workspace-trust-limitations.trusted', { tabIndex: '0' }));
+        this.untrustedContainer = append(this.affectedFeaturesContainer, $('.workspace-trust-limitations.untrusted', { tabIndex: '0' }));
+    }
+    async renderAffectedFeatures(numSettings, numExtensions) {
+        clearNode(this.trustedContainer);
+        clearNode(this.untrustedContainer);
+        const [trustedTitle, trustedSubTitle] = this.getFeaturesHeaderText(true);
+        this.renderLimitationsHeaderElement(this.trustedContainer, trustedTitle, trustedSubTitle);
+        const trustedContainerItems = this.workspaceService.getWorkbenchState() === 1  ?
+            [
+                ( (localize('trustedTasks', "Tasks are allowed to run"))),
+                ( (localize('trustedDebugging', "Debugging is enabled"))),
+                ( (localize('trustedExtensions', "All enabled extensions are activated")))
+            ] :
+            [
+                ( (localize('trustedTasks', "Tasks are allowed to run"))),
+                ( (localize('trustedDebugging', "Debugging is enabled"))),
+                ( (localize('trustedSettings', "All workspace settings are applied"))),
+                ( (localize('trustedExtensions', "All enabled extensions are activated")))
+            ];
+        this.renderLimitationsListElement(this.trustedContainer, trustedContainerItems, ThemeIcon.asClassNameArray(checkListIcon));
+        const [untrustedTitle, untrustedSubTitle] = this.getFeaturesHeaderText(false);
+        this.renderLimitationsHeaderElement(this.untrustedContainer, untrustedTitle, untrustedSubTitle);
+        const untrustedContainerItems = this.workspaceService.getWorkbenchState() === 1  ?
+            [
+                ( (localize('untrustedTasks', "Tasks are not allowed to run"))),
+                ( (localize('untrustedDebugging', "Debugging is disabled"))),
+                fixBadLocalizedLinks(( (localize(
+                    { key: 'untrustedExtensions', comment: ['Please ensure the markdown link syntax is not broken up with whitespace [text block](link block)'] },
+                    "[{0} extensions]({1}) are disabled or have limited functionality",
+                    numExtensions,
+                    `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`
+                ))))
+            ] :
+            [
+                ( (localize('untrustedTasks', "Tasks are not allowed to run"))),
+                ( (localize('untrustedDebugging', "Debugging is disabled"))),
+                fixBadLocalizedLinks(numSettings ? ( (localize(
+                    { key: 'untrustedSettings', comment: ['Please ensure the markdown link syntax is not broken up with whitespace [text block](link block)'] },
+                    "[{0} workspace settings]({1}) are not applied",
+                    numSettings,
+                    'command:settings.filterUntrusted'
+                ))) : ( (localize(
+                    'no untrustedSettings',
+                    "Workspace settings requiring trust are not applied"
+                )))),
+                fixBadLocalizedLinks(( (localize(
+                    { key: 'untrustedExtensions', comment: ['Please ensure the markdown link syntax is not broken up with whitespace [text block](link block)'] },
+                    "[{0} extensions]({1}) are disabled or have limited functionality",
+                    numExtensions,
+                    `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`
+                ))))
+            ];
+        this.renderLimitationsListElement(this.untrustedContainer, untrustedContainerItems, ThemeIcon.asClassNameArray(xListIcon));
+        if (this.workspaceTrustManagementService.isWorkspaceTrusted()) {
+            if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
+                this.addDontTrustButtonToElement(this.untrustedContainer);
+            }
+            else {
+                this.addTrustedTextToElement(this.untrustedContainer);
+            }
+        }
+        else {
+            if (this.workspaceTrustManagementService.canSetWorkspaceTrust()) {
+                this.addTrustButtonToElement(this.trustedContainer);
+            }
+        }
+    }
+    createButtonRow(parent, buttonInfo, enabled) {
+        const buttonRow = append(parent, $('.workspace-trust-buttons-row'));
+        const buttonContainer = append(buttonRow, $('.workspace-trust-buttons'));
+        const buttonBar = this.rerenderDisposables.add(( (new ButtonBar(buttonContainer))));
+        for (const { action, keybinding } of buttonInfo) {
+            const button = buttonBar.addButtonWithDescription(defaultButtonStyles);
+            button.label = action.label;
+            button.enabled = enabled !== undefined ? enabled : action.enabled;
+            button.description = keybinding.getLabel();
+            button.element.ariaLabel = action.label + ', ' + ( (localize('keyboardShortcut', "Keyboard Shortcut: {0}", keybinding.getAriaLabel())));
+            this.rerenderDisposables.add(button.onDidClick(e => {
+                if (e) {
+                    EventHelper.stop(e, true);
+                }
+                action.run();
+            }));
+        }
+    }
+    addTrustButtonToElement(parent) {
+        const trustAction = ( (new Action(
+            'workspace.trust.button.action.grant',
+             (localize('trustButton', "Trust")),
+            undefined,
+            true,
+            async () => {
+                await this.workspaceTrustManagementService.setWorkspaceTrust(true);
+            }
+        )));
+        const trustActions = [{ action: trustAction, keybinding: this.keybindingService.resolveUserBinding(isMacintosh ? 'Cmd+Enter' : 'Ctrl+Enter')[0] }];
+        if (this.workspaceTrustManagementService.canSetParentFolderTrust()) {
+            const workspaceIdentifier = toWorkspaceIdentifier(this.workspaceService.getWorkspace());
+            const name = basename(dirname(workspaceIdentifier.uri));
+            const trustMessageElement = append(parent, $('.trust-message-box'));
+            trustMessageElement.innerText = ( (localize(
+                'trustMessage',
+                "Trust the authors of all files in the current folder or its parent '{0}'.",
+                name
+            )));
+            const trustParentAction = ( (new Action(
+                'workspace.trust.button.action.grantParent',
+                 (localize('trustParentButton', "Trust Parent")),
+                undefined,
+                true,
+                async () => {
+                    await this.workspaceTrustManagementService.setParentFolderTrust(true);
+                }
+            )));
+            trustActions.push({ action: trustParentAction, keybinding: this.keybindingService.resolveUserBinding(isMacintosh ? 'Cmd+Shift+Enter' : 'Ctrl+Shift+Enter')[0] });
+        }
+        this.createButtonRow(parent, trustActions);
+    }
+    addDontTrustButtonToElement(parent) {
+        this.createButtonRow(parent, [{
+                action: ( (new Action(
+                    'workspace.trust.button.action.deny',
+                     (localize('dontTrustButton', "Don't Trust")),
+                    undefined,
+                    true,
+                    async () => {
+                        await this.workspaceTrustManagementService.setWorkspaceTrust(false);
+                    }
+                ))),
+                keybinding: this.keybindingService.resolveUserBinding(isMacintosh ? 'Cmd+Enter' : 'Ctrl+Enter')[0]
+            }]);
+    }
+    addTrustedTextToElement(parent) {
+        if (this.workspaceService.getWorkbenchState() === 1 ) {
+            return;
+        }
+        const textElement = append(parent, $('.workspace-trust-untrusted-description'));
+        if (!this.workspaceTrustManagementService.isWorkspaceTrustForced()) {
+            textElement.innerText = this.workspaceService.getWorkbenchState() === 3  ? ( (localize(
+                'untrustedWorkspaceReason',
+                "This workspace is trusted via the bolded entries in the trusted folders below."
+            ))) : ( (localize(
+                'untrustedFolderReason',
+                "This folder is trusted via the bolded entries in the the trusted folders below."
+            )));
+        }
+        else {
+            textElement.innerText = ( (localize(
+                'trustedForcedReason',
+                "This window is trusted by nature of the workspace that is opened."
+            )));
+        }
+    }
+    renderLimitationsHeaderElement(parent, headerText, subtitleText) {
+        const limitationsHeaderContainer = append(parent, $('.workspace-trust-limitations-header'));
+        const titleElement = append(limitationsHeaderContainer, $('.workspace-trust-limitations-title'));
+        const textElement = append(titleElement, $('.workspace-trust-limitations-title-text'));
+        const subtitleElement = append(limitationsHeaderContainer, $('.workspace-trust-limitations-subtitle'));
+        textElement.innerText = headerText;
+        subtitleElement.innerText = subtitleText;
+    }
+    renderLimitationsListElement(parent, limitations, iconClassNames) {
+        const listContainer = append(parent, $('.workspace-trust-limitations-list-container'));
+        const limitationsList = append(listContainer, $('ul'));
+        for (const limitation of limitations) {
+            const limitationListItem = append(limitationsList, $('li'));
+            const icon = append(limitationListItem, $('.list-item-icon'));
+            const text = append(limitationListItem, $('.list-item-text'));
+            icon.classList.add(...iconClassNames);
+            const linkedText = parseLinkedText(limitation);
+            for (const node of linkedText.nodes) {
+                if (typeof node === 'string') {
+                    append(text, document.createTextNode(node));
+                }
+                else {
+                    this.rerenderDisposables.add(this.instantiationService.createInstance(Link, text, { ...node, tabIndex: -1 }, {}));
+                }
+            }
+        }
+    }
+    layout(dimension) {
+        if (!this.isVisible()) {
+            return;
+        }
+        this.workspaceTrustedUrisTable.layout();
+        this.layoutParticipants.forEach(participant => {
+            participant.layout();
+        });
+        this.bodyScrollBar.scanDomNode();
+    }
+};
+WorkspaceTrustEditor.__decorator = ( (__decorate([
+    debounce(100)
+], WorkspaceTrustEditor.prototype, "render", null)));
+WorkspaceTrustEditor = WorkspaceTrustEditor_1 = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IStorageService))),
+    ( (__param(3, IWorkspaceContextService))),
+    ( (__param(4, IExtensionsWorkbenchService))),
+    ( (__param(5, IExtensionManifestPropertiesService))),
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IWorkspaceTrustManagementService))),
+    ( (__param(8, IWorkbenchConfigurationService))),
+    ( (__param(9, IWorkbenchExtensionEnablementService))),
+    ( (__param(10, IProductService))),
+    ( (__param(11, IKeybindingService)))
+], WorkspaceTrustEditor)));
+function fixBadLocalizedLinks(badString) {
+    const regex = /(.*)\[(.+)\]\s*\((.+)\)(.*)/;
+    return badString.replace(regex, '$1[$2]($3)$4');
+}
+export { WorkspaceTrustEditor, shieldIcon };