@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,842 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/workspaceTrustEditor.css.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { workspaceTrustToString, IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
-import { Extensions } from '../../../common/contributions.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
-import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { WorkspaceTrustEditor, shieldIcon } from './workspaceTrustEditor.js';
-import { WorkspaceTrustEditorInput } from '../../../services/workspaces/browser/workspaceTrustEditorInput.js';
-import { WORKSPACE_TRUST_ENABLED, WORKSPACE_TRUST_STARTUP_PROMPT, WORKSPACE_TRUST_BANNER, WORKSPACE_TRUST_UNTRUSTED_FILES, WORKSPACE_TRUST_EMPTY_WINDOW } from '../../../services/workspaces/common/workspaceTrust.js';
-import { EditorExtensions } from '../../../common/editor.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { isSingleFolderWorkspaceIdentifier, toWorkspaceIdentifier, isEmptyWorkspaceIdentifier, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { resolve, dirname as dirname$1 } from 'monaco-editor/esm/vs/base/common/path.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { IBannerService } from '../../../services/banner/browser/bannerService.js';
-import { isVirtualWorkspace } from '../../../../platform/workspace/common/virtualWorkspace.js';
-import { LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID } from '../../extensions/common/extensions.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { WORKSPACE_TRUST_SETTING_TAG } from '../../preferences/common/preferences.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { WorkspaceTrustContext, MANAGE_TRUST_COMMAND_ID } from '../common/workspace.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
-import { securityConfigurationNodeBase } from '../../../common/configuration.js';
-import { basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-const BANNER_RESTRICTED_MODE = 'workbench.banner.restrictedMode';
-const STARTUP_PROMPT_SHOWN_KEY = 'workspace.trust.startupPrompt.shown';
-const BANNER_RESTRICTED_MODE_DISMISSED_KEY = 'workbench.banner.restrictedMode.dismissed';
-let WorkspaceTrustContextKeys = class WorkspaceTrustContextKeys extends Disposable {
-    constructor(contextKeyService, workspaceTrustEnablementService, workspaceTrustManagementService) {
-        super();
-        this._ctxWorkspaceTrustEnabled = WorkspaceTrustContext.IsEnabled.bindTo(contextKeyService);
-        this._ctxWorkspaceTrustEnabled.set(workspaceTrustEnablementService.isWorkspaceTrustEnabled());
-        this._ctxWorkspaceTrustState = WorkspaceTrustContext.IsTrusted.bindTo(contextKeyService);
-        this._ctxWorkspaceTrustState.set(workspaceTrustManagementService.isWorkspaceTrusted());
-        this._register(workspaceTrustManagementService.onDidChangeTrust(trusted => this._ctxWorkspaceTrustState.set(trusted)));
-    }
-};
-WorkspaceTrustContextKeys = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IWorkspaceTrustEnablementService)),
-    ( __param(2, IWorkspaceTrustManagementService))
-], WorkspaceTrustContextKeys));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkspaceTrustContextKeys, 3 );
-let WorkspaceTrustRequestHandler = class WorkspaceTrustRequestHandler extends Disposable {
-    constructor(dialogService, commandService, workspaceContextService, workspaceTrustManagementService, workspaceTrustRequestService) {
-        super();
-        this.dialogService = dialogService;
-        this.commandService = commandService;
-        this.workspaceContextService = workspaceContextService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.workspaceTrustRequestService = workspaceTrustRequestService;
-        this.registerListeners();
-    }
-    get useWorkspaceLanguage() {
-        return !isSingleFolderWorkspaceIdentifier(toWorkspaceIdentifier(this.workspaceContextService.getWorkspace()));
-    }
-    async registerListeners() {
-        await this.workspaceTrustManagementService.workspaceResolved;
-        this._register(this.workspaceTrustRequestService.onDidInitiateOpenFilesTrustRequest(async () => {
-            const markdownDetails = [
-                this.workspaceContextService.getWorkbenchState() !== 1  ?
-                    ( localize(
-                        'openLooseFileWorkspaceDetails',
-                        "You are trying to open untrusted files in a workspace which is trusted."
-                    )) :
-                    ( localize(
-                        'openLooseFileWindowDetails',
-                        "You are trying to open untrusted files in a window which is trusted."
-                    )),
-                ( localize(
-                    'openLooseFileLearnMore',
-                    "If you don't want to open untrusted files, we recommend to open them in Restricted Mode in a new window as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
-                ))
-            ];
-            await this.dialogService.prompt({
-                type: Severity.Info,
-                message: this.workspaceContextService.getWorkbenchState() !== 1  ?
-                    ( localize(
-                        'openLooseFileWorkspaceMesssage',
-                        "Do you want to allow untrusted files in this workspace?"
-                    )) :
-                    ( localize(
-                        'openLooseFileWindowMesssage',
-                        "Do you want to allow untrusted files in this window?"
-                    )),
-                buttons: [
-                    {
-                        label: ( localize({ key: 'open', comment: ['&& denotes a mnemonic'] }, "&&Open")),
-                        run: ({ checkboxChecked }) => this.workspaceTrustRequestService.completeOpenFilesTrustRequest(1 , !!checkboxChecked)
-                    },
-                    {
-                        label: ( localize(
-                            { key: 'newWindow', comment: ['&& denotes a mnemonic'] },
-                            "Open in &&Restricted Mode"
-                        )),
-                        run: ({ checkboxChecked }) => this.workspaceTrustRequestService.completeOpenFilesTrustRequest(2 , !!checkboxChecked)
-                    }
-                ],
-                cancelButton: {
-                    run: () => this.workspaceTrustRequestService.completeOpenFilesTrustRequest(3 )
-                },
-                checkbox: {
-                    label: ( localize(
-                        'openLooseFileWorkspaceCheckbox',
-                        "Remember my decision for all workspaces"
-                    )),
-                    checked: false
-                },
-                custom: {
-                    icon: Codicon.shield,
-                    markdownDetails: ( markdownDetails.map(md => { return { markdown: ( new MarkdownString(md)) }; }))
-                }
-            });
-        }));
-        this._register(this.workspaceTrustRequestService.onDidInitiateWorkspaceTrustRequest(async (requestOptions) => {
-            const message = this.useWorkspaceLanguage ?
-                ( localize(
-                    'workspaceTrust',
-                    "Do you trust the authors of the files in this workspace?"
-                )) :
-                ( localize('folderTrust', "Do you trust the authors of the files in this folder?"));
-            const defaultDetails = ( localize(
-                'immediateTrustRequestMessage',
-                "A feature you are trying to use may be a security risk if you do not trust the source of the files or folders you currently have open."
-            ));
-            const details = requestOptions?.message ?? defaultDetails;
-            const buttons = requestOptions?.buttons ?? [
-                { label: this.useWorkspaceLanguage ? ( localize(
-                    { key: 'grantWorkspaceTrustButton', comment: ['&& denotes a mnemonic'] },
-                    "&&Trust Workspace & Continue"
-                )) : ( localize(
-                    { key: 'grantFolderTrustButton', comment: ['&& denotes a mnemonic'] },
-                    "&&Trust Folder & Continue"
-                )), type: 'ContinueWithTrust' },
-                { label: ( localize(
-                    { key: 'manageWorkspaceTrustButton', comment: ['&& denotes a mnemonic'] },
-                    "&&Manage"
-                )), type: 'Manage' }
-            ];
-            if (!( buttons.some(b => b.type === 'Cancel'))) {
-                buttons.push({ label: ( localize('cancelWorkspaceTrustButton', "Cancel")), type: 'Cancel' });
-            }
-            const { result } = await this.dialogService.prompt({
-                type: Severity.Info,
-                message,
-                custom: {
-                    icon: Codicon.shield,
-                    markdownDetails: [
-                        { markdown: ( new MarkdownString(details)) },
-                        { markdown: ( new MarkdownString(( localize(
-                            'immediateTrustRequestLearnMore',
-                            "If you don't trust the authors of these files, we do not recommend continuing as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
-                        )))) }
-                    ]
-                },
-                buttons: ( buttons.filter(b => b.type !== 'Cancel').map(button => {
-                    return {
-                        label: button.label,
-                        run: () => button.type
-                    };
-                })),
-                cancelButton: (() => {
-                    const cancelButton = buttons.find(b => b.type === 'Cancel');
-                    if (!cancelButton) {
-                        return undefined;
-                    }
-                    return {
-                        label: cancelButton.label,
-                        run: () => cancelButton.type
-                    };
-                })()
-            });
-            switch (result) {
-                case 'ContinueWithTrust':
-                    await this.workspaceTrustRequestService.completeWorkspaceTrustRequest(true);
-                    break;
-                case 'ContinueWithoutTrust':
-                    await this.workspaceTrustRequestService.completeWorkspaceTrustRequest(undefined);
-                    break;
-                case 'Manage':
-                    this.workspaceTrustRequestService.cancelWorkspaceTrustRequest();
-                    await this.commandService.executeCommand(MANAGE_TRUST_COMMAND_ID);
-                    break;
-                case 'Cancel':
-                    this.workspaceTrustRequestService.cancelWorkspaceTrustRequest();
-                    break;
-            }
-        }));
-    }
-};
-WorkspaceTrustRequestHandler = ( __decorate([
-    ( __param(0, IDialogService)),
-    ( __param(1, ICommandService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IWorkspaceTrustManagementService)),
-    ( __param(4, IWorkspaceTrustRequestService))
-], WorkspaceTrustRequestHandler));
-let WorkspaceTrustUXHandler = class WorkspaceTrustUXHandler extends Disposable {
-    constructor(dialogService, workspaceContextService, workspaceTrustEnablementService, workspaceTrustManagementService, configurationService, statusbarService, storageService, workspaceTrustRequestService, bannerService, labelService, hostService, productService, remoteAgentService, environmentService, fileService) {
-        super();
-        this.dialogService = dialogService;
-        this.workspaceContextService = workspaceContextService;
-        this.workspaceTrustEnablementService = workspaceTrustEnablementService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.configurationService = configurationService;
-        this.statusbarService = statusbarService;
-        this.storageService = storageService;
-        this.workspaceTrustRequestService = workspaceTrustRequestService;
-        this.bannerService = bannerService;
-        this.labelService = labelService;
-        this.hostService = hostService;
-        this.productService = productService;
-        this.remoteAgentService = remoteAgentService;
-        this.environmentService = environmentService;
-        this.fileService = fileService;
-        this.entryId = `status.workspaceTrust.${this.workspaceContextService.getWorkspace().id}`;
-        this.statusbarEntryAccessor = this._register(( new MutableDisposable()));
-        (async () => {
-            await this.workspaceTrustManagementService.workspaceTrustInitialized;
-            if (this.workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
-                this.registerListeners();
-                this.createStatusbarEntry();
-                if (this.hostService.hasFocus) {
-                    this.showModalOnStart();
-                }
-                else {
-                    const focusDisposable = this.hostService.onDidChangeFocus(focused => {
-                        if (focused) {
-                            focusDisposable.dispose();
-                            this.showModalOnStart();
-                        }
-                    });
-                }
-            }
-        })();
-    }
-    registerListeners() {
-        this._register(this.workspaceContextService.onWillChangeWorkspaceFolders(e => {
-            if (e.fromCache) {
-                return;
-            }
-            if (!this.workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
-                return;
-            }
-            const addWorkspaceFolder = async (e) => {
-                const trusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
-                if (trusted && (e.changes.added.length || e.changes.changed.length)) {
-                    const addedFoldersTrustInfo = await Promise.all(( e.changes.added.map(folder => this.workspaceTrustManagementService.getUriTrustInfo(folder.uri))));
-                    if (!( addedFoldersTrustInfo.map(info => info.trusted)).every(trusted => trusted)) {
-                        const { confirmed } = await this.dialogService.confirm({
-                            type: Severity.Info,
-                            message: ( localize(
-                                'addWorkspaceFolderMessage',
-                                "Do you trust the authors of the files in this folder?"
-                            )),
-                            detail: ( localize(
-                                'addWorkspaceFolderDetail',
-                                "You are adding files that are not currently trusted to a trusted workspace. Do you trust the authors of these new files?"
-                            )),
-                            cancelButton: ( localize('no', 'No')),
-                            custom: { icon: Codicon.shield }
-                        });
-                        await this.workspaceTrustManagementService.setUrisTrust(( addedFoldersTrustInfo.map(i => i.uri)), confirmed);
-                    }
-                }
-            };
-            return e.join(addWorkspaceFolder(e));
-        }));
-        this._register(this.workspaceTrustManagementService.onDidChangeTrust(trusted => {
-            this.updateWorkbenchIndicators(trusted);
-        }));
-        this._register(this.workspaceTrustRequestService.onDidInitiateWorkspaceTrustRequestOnStartup(async () => {
-            let titleString;
-            let learnMoreString;
-            let trustOption;
-            let dontTrustOption;
-            const isAiGeneratedWorkspace = await this.isAiGeneratedWorkspace();
-            if (isAiGeneratedWorkspace && this.productService.aiGeneratedWorkspaceTrust) {
-                titleString = this.productService.aiGeneratedWorkspaceTrust.title;
-                learnMoreString = this.productService.aiGeneratedWorkspaceTrust.startupTrustRequestLearnMore;
-                trustOption = this.productService.aiGeneratedWorkspaceTrust.trustOption;
-                dontTrustOption = this.productService.aiGeneratedWorkspaceTrust.dontTrustOption;
-            }
-            else {
-                console.warn('AI generated workspace trust dialog contents not available.');
-            }
-            const title = titleString ?? (this.useWorkspaceLanguage ?
-                ( localize(
-                    'workspaceTrust',
-                    "Do you trust the authors of the files in this workspace?"
-                )) :
-                ( localize('folderTrust', "Do you trust the authors of the files in this folder?")));
-            let checkboxText;
-            const workspaceIdentifier = toWorkspaceIdentifier(this.workspaceContextService.getWorkspace());
-            const isSingleFolderWorkspace = isSingleFolderWorkspaceIdentifier(workspaceIdentifier);
-            const isEmptyWindow = isEmptyWorkspaceIdentifier(workspaceIdentifier);
-            if (!isAiGeneratedWorkspace && this.workspaceTrustManagementService.canSetParentFolderTrust()) {
-                const name = basename(dirname(workspaceIdentifier.uri));
-                checkboxText = ( localize(
-                    'checkboxString',
-                    "Trust the authors of all files in the parent folder '{0}'",
-                    name
-                ));
-            }
-            this.doShowModal(title, { label: trustOption ?? ( localize(
-                { key: 'trustOption', comment: ['&& denotes a mnemonic'] },
-                "&&Yes, I trust the authors"
-            )), sublabel: isSingleFolderWorkspace ? ( localize('trustFolderOptionDescription', "Trust folder and enable all features")) : ( localize(
-                'trustWorkspaceOptionDescription',
-                "Trust workspace and enable all features"
-            )) }, { label: dontTrustOption ?? ( localize(
-                { key: 'dontTrustOption', comment: ['&& denotes a mnemonic'] },
-                "&&No, I don't trust the authors"
-            )), sublabel: isSingleFolderWorkspace ? ( localize('dontTrustFolderOptionDescription', "Browse folder in restricted mode")) : ( localize(
-                'dontTrustWorkspaceOptionDescription',
-                "Browse workspace in restricted mode"
-            )) }, [
-                !isSingleFolderWorkspace ?
-                    ( localize(
-                        'workspaceStartupTrustDetails',
-                        "{0} provides features that may automatically execute files in this workspace.",
-                        this.productService.nameShort
-                    )) :
-                    ( localize(
-                        'folderStartupTrustDetails',
-                        "{0} provides features that may automatically execute files in this folder.",
-                        this.productService.nameShort
-                    )),
-                learnMoreString ?? ( localize(
-                    'startupTrustRequestLearnMore',
-                    "If you don't trust the authors of these files, we recommend to continue in restricted mode as the files may be malicious. See [our docs](https://aka.ms/vscode-workspace-trust) to learn more."
-                )),
-                !isEmptyWindow ?
-                    `\`${this.labelService.getWorkspaceLabel(workspaceIdentifier, { verbose: 2  })}\`` : '',
-            ], checkboxText);
-        }));
-    }
-    updateWorkbenchIndicators(trusted) {
-        const bannerItem = this.getBannerItem(!trusted);
-        this.updateStatusbarEntry(trusted);
-        if (bannerItem) {
-            if (!trusted) {
-                this.bannerService.show(bannerItem);
-            }
-            else {
-                this.bannerService.hide(BANNER_RESTRICTED_MODE);
-            }
-        }
-    }
-    async doShowModal(question, trustedOption, untrustedOption, markdownStrings, trustParentString) {
-        await this.dialogService.prompt({
-            type: Severity.Info,
-            message: question,
-            checkbox: trustParentString ? {
-                label: trustParentString
-            } : undefined,
-            buttons: [
-                {
-                    label: trustedOption.label,
-                    run: async ({ checkboxChecked }) => {
-                        if (checkboxChecked) {
-                            await this.workspaceTrustManagementService.setParentFolderTrust(true);
-                        }
-                        else {
-                            await this.workspaceTrustRequestService.completeWorkspaceTrustRequest(true);
-                        }
-                    }
-                },
-                {
-                    label: untrustedOption.label,
-                    run: () => {
-                        this.updateWorkbenchIndicators(false);
-                        this.workspaceTrustRequestService.cancelWorkspaceTrustRequest();
-                    }
-                }
-            ],
-            custom: {
-                buttonDetails: [
-                    trustedOption.sublabel,
-                    untrustedOption.sublabel
-                ],
-                disableCloseAction: true,
-                icon: Codicon.shield,
-                markdownDetails: ( markdownStrings.map(md => { return { markdown: ( new MarkdownString(md)) }; }))
-            }
-        });
-        this.storageService.store(STARTUP_PROMPT_SHOWN_KEY, true, 1 , 1 );
-    }
-    async showModalOnStart() {
-        if (this.workspaceTrustManagementService.isWorkspaceTrusted()) {
-            this.updateWorkbenchIndicators(true);
-            return;
-        }
-        if (!(this.workspaceTrustManagementService.canSetWorkspaceTrust())) {
-            return;
-        }
-        if (isVirtualWorkspace(this.workspaceContextService.getWorkspace())) {
-            this.updateWorkbenchIndicators(false);
-            return;
-        }
-        if (this.workspaceContextService.getWorkbenchState() === 1 ) {
-            this.updateWorkbenchIndicators(false);
-            return;
-        }
-        if (this.startupPromptSetting === 'never') {
-            this.updateWorkbenchIndicators(false);
-            return;
-        }
-        if (this.startupPromptSetting === 'once' && this.storageService.getBoolean(STARTUP_PROMPT_SHOWN_KEY, 1 , false)) {
-            this.updateWorkbenchIndicators(false);
-            return;
-        }
-        this.workspaceTrustRequestService.requestWorkspaceTrustOnStartup();
-    }
-    get startupPromptSetting() {
-        return this.configurationService.getValue(WORKSPACE_TRUST_STARTUP_PROMPT);
-    }
-    get useWorkspaceLanguage() {
-        return !isSingleFolderWorkspaceIdentifier(toWorkspaceIdentifier(this.workspaceContextService.getWorkspace()));
-    }
-    async isAiGeneratedWorkspace() {
-        const aiGeneratedWorkspaces = URI.joinPath(this.environmentService.workspaceStorageHome, 'aiGeneratedWorkspaces.json');
-        return await this.fileService.exists(aiGeneratedWorkspaces).then(async (result) => {
-            if (result) {
-                try {
-                    const content = await this.fileService.readFile(aiGeneratedWorkspaces);
-                    const workspaces = JSON.parse(( content.value.toString()));
-                    if (workspaces.indexOf(( this.workspaceContextService.getWorkspace().folders[0].uri.toString())) > -1) {
-                        return true;
-                    }
-                }
-                catch (e) {
-                }
-            }
-            return false;
-        });
-    }
-    getBannerItem(restrictedMode) {
-        const dismissedRestricted = this.storageService.getBoolean(BANNER_RESTRICTED_MODE_DISMISSED_KEY, 1 , false);
-        if (this.bannerSetting === 'never') {
-            return undefined;
-        }
-        if (this.bannerSetting === 'untilDismissed' && dismissedRestricted) {
-            return undefined;
-        }
-        const actions = [
-            {
-                label: ( localize('restrictedModeBannerManage', "Manage")),
-                href: 'command:' + MANAGE_TRUST_COMMAND_ID
-            },
-            {
-                label: ( localize('restrictedModeBannerLearnMore', "Learn More")),
-                href: 'https://aka.ms/vscode-workspace-trust'
-            }
-        ];
-        return {
-            id: BANNER_RESTRICTED_MODE,
-            icon: shieldIcon,
-            ariaLabel: this.getBannerItemAriaLabels(),
-            message: this.getBannerItemMessages(),
-            actions,
-            onClose: () => {
-                if (restrictedMode) {
-                    this.storageService.store(BANNER_RESTRICTED_MODE_DISMISSED_KEY, true, 1 , 1 );
-                }
-            }
-        };
-    }
-    getBannerItemAriaLabels() {
-        switch (this.workspaceContextService.getWorkbenchState()) {
-            case 1 :
-                return ( localize(
-                    'restrictedModeBannerAriaLabelWindow',
-                    "Restricted Mode is intended for safe code browsing. Trust this window to enable all features. Use navigation keys to access banner actions."
-                ));
-            case 2 :
-                return ( localize(
-                    'restrictedModeBannerAriaLabelFolder',
-                    "Restricted Mode is intended for safe code browsing. Trust this folder to enable all features. Use navigation keys to access banner actions."
-                ));
-            case 3 :
-                return ( localize(
-                    'restrictedModeBannerAriaLabelWorkspace',
-                    "Restricted Mode is intended for safe code browsing. Trust this workspace to enable all features. Use navigation keys to access banner actions."
-                ));
-        }
-    }
-    getBannerItemMessages() {
-        switch (this.workspaceContextService.getWorkbenchState()) {
-            case 1 :
-                return ( localize(
-                    'restrictedModeBannerMessageWindow',
-                    "Restricted Mode is intended for safe code browsing. Trust this window to enable all features."
-                ));
-            case 2 :
-                return ( localize(
-                    'restrictedModeBannerMessageFolder',
-                    "Restricted Mode is intended for safe code browsing. Trust this folder to enable all features."
-                ));
-            case 3 :
-                return ( localize(
-                    'restrictedModeBannerMessageWorkspace',
-                    "Restricted Mode is intended for safe code browsing. Trust this workspace to enable all features."
-                ));
-        }
-    }
-    get bannerSetting() {
-        const result = this.configurationService.getValue(WORKSPACE_TRUST_BANNER);
-        if (result !== 'always' && isWeb && !this.remoteAgentService.getConnection()?.remoteAuthority) {
-            return 'never';
-        }
-        return result;
-    }
-    createStatusbarEntry() {
-        const entry = this.getStatusbarEntry(this.workspaceTrustManagementService.isWorkspaceTrusted());
-        this.statusbarEntryAccessor.value = this.statusbarService.addEntry(entry, this.entryId, 0 , 0.99 * Number.MAX_VALUE );
-        this.statusbarService.updateEntryVisibility(this.entryId, false);
-    }
-    getStatusbarEntry(trusted) {
-        const text = workspaceTrustToString(trusted);
-        let ariaLabel = '';
-        let toolTip;
-        switch (this.workspaceContextService.getWorkbenchState()) {
-            case 1 : {
-                ariaLabel = trusted ? ( localize('status.ariaTrustedWindow', "This window is trusted.")) :
-                    ( localize(
-                        'status.ariaUntrustedWindow',
-                        "Restricted Mode: Some features are disabled because this window is not trusted."
-                    ));
-                toolTip = trusted ? ariaLabel : {
-                    value: ( localize(
-                        { key: 'status.tooltipUntrustedWindow2', comment: ['[abc]({n}) are links.  Only translate `features are disabled` and `window is not trusted`. Do not change brackets and parentheses or {n}'] },
-                        "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [window is not trusted]({1}).",
-                        `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
-                        `command:${MANAGE_TRUST_COMMAND_ID}`
-                    )),
-                    isTrusted: true,
-                    supportThemeIcons: true
-                };
-                break;
-            }
-            case 2 : {
-                ariaLabel = trusted ? ( localize('status.ariaTrustedFolder', "This folder is trusted.")) :
-                    ( localize(
-                        'status.ariaUntrustedFolder',
-                        "Restricted Mode: Some features are disabled because this folder is not trusted."
-                    ));
-                toolTip = trusted ? ariaLabel : {
-                    value: ( localize(
-                        { key: 'status.tooltipUntrustedFolder2', comment: ['[abc]({n}) are links.  Only translate `features are disabled` and `folder is not trusted`. Do not change brackets and parentheses or {n}'] },
-                        "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [folder is not trusted]({1}).",
-                        `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
-                        `command:${MANAGE_TRUST_COMMAND_ID}`
-                    )),
-                    isTrusted: true,
-                    supportThemeIcons: true
-                };
-                break;
-            }
-            case 3 : {
-                ariaLabel = trusted ? ( localize('status.ariaTrustedWorkspace', "This workspace is trusted.")) :
-                    ( localize(
-                        'status.ariaUntrustedWorkspace',
-                        "Restricted Mode: Some features are disabled because this workspace is not trusted."
-                    ));
-                toolTip = trusted ? ariaLabel : {
-                    value: ( localize(
-                        { key: 'status.tooltipUntrustedWorkspace2', comment: ['[abc]({n}) are links. Only translate `features are disabled` and `workspace is not trusted`. Do not change brackets and parentheses or {n}'] },
-                        "Running in Restricted Mode\n\nSome [features are disabled]({0}) because this [workspace is not trusted]({1}).",
-                        `command:${LIST_WORKSPACE_UNSUPPORTED_EXTENSIONS_COMMAND_ID}`,
-                        `command:${MANAGE_TRUST_COMMAND_ID}`
-                    )),
-                    isTrusted: true,
-                    supportThemeIcons: true
-                };
-                break;
-            }
-        }
-        return {
-            name: ( localize('status.WorkspaceTrust', "Workspace Trust")),
-            text: trusted ? `$(shield)` : `$(shield) ${text}`,
-            ariaLabel: ariaLabel,
-            tooltip: toolTip,
-            command: MANAGE_TRUST_COMMAND_ID,
-            kind: 'prominent'
-        };
-    }
-    updateStatusbarEntry(trusted) {
-        this.statusbarEntryAccessor.value?.update(this.getStatusbarEntry(trusted));
-        this.statusbarService.updateEntryVisibility(this.entryId, !trusted);
-    }
-};
-WorkspaceTrustUXHandler = ( __decorate([
-    ( __param(0, IDialogService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IWorkspaceTrustEnablementService)),
-    ( __param(3, IWorkspaceTrustManagementService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IStatusbarService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IWorkspaceTrustRequestService)),
-    ( __param(8, IBannerService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IHostService)),
-    ( __param(11, IProductService)),
-    ( __param(12, IRemoteAgentService)),
-    ( __param(13, IEnvironmentService)),
-    ( __param(14, IFileService))
-], WorkspaceTrustUXHandler));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkspaceTrustRequestHandler, 2 );
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkspaceTrustUXHandler, 3 );
-( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(WorkspaceTrustEditor, WorkspaceTrustEditor.ID, ( localize('workspaceTrustEditor', "Workspace Trust Editor"))), [
-    ( new SyncDescriptor(WorkspaceTrustEditorInput))
-]);
-const CONFIGURE_TRUST_COMMAND_ID = 'workbench.trust.configure';
-const WORKSPACES_CATEGORY = { value: ( localize('workspacesCategory', "Workspaces")), original: 'Workspaces' };
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: CONFIGURE_TRUST_COMMAND_ID,
-            title: { original: 'Configure Workspace Trust Settings', value: ( localize('configureWorkspaceTrustSettings', "Configure Workspace Trust Settings")) },
-            precondition: ( ContextKeyExpr.and(WorkspaceTrustContext.IsEnabled, ( ContextKeyExpr.equals(`config.${WORKSPACE_TRUST_ENABLED}`, true)))),
-            category: WORKSPACES_CATEGORY,
-            f1: true
-        });
-    }
-    run(accessor) {
-        accessor.get(IPreferencesService).openUserSettings({ jsonEditor: false, query: `@tag:${WORKSPACE_TRUST_SETTING_TAG}` });
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: MANAGE_TRUST_COMMAND_ID,
-            title: { original: 'Manage Workspace Trust', value: ( localize('manageWorkspaceTrust', "Manage Workspace Trust")) },
-            precondition: ( ContextKeyExpr.and(WorkspaceTrustContext.IsEnabled, ( ContextKeyExpr.equals(`config.${WORKSPACE_TRUST_ENABLED}`, true)))),
-            category: WORKSPACES_CATEGORY,
-            f1: true,
-        });
-    }
-    run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const input = instantiationService.createInstance(WorkspaceTrustEditorInput);
-        editorService.openEditor(input, { pinned: true });
-        return;
-    }
-});
-( Registry.as(Extensions$1.Configuration))
-    .registerConfiguration({
-    ...securityConfigurationNodeBase,
-    properties: {
-        [WORKSPACE_TRUST_ENABLED]: {
-            type: 'boolean',
-            default: true,
-            description: ( localize(
-                'workspace.trust.description',
-                "Controls whether or not Workspace Trust is enabled within VS Code."
-            )),
-            tags: [WORKSPACE_TRUST_SETTING_TAG],
-            scope: 1 ,
-        },
-        [WORKSPACE_TRUST_STARTUP_PROMPT]: {
-            type: 'string',
-            default: 'once',
-            description: ( localize(
-                'workspace.trust.startupPrompt.description',
-                "Controls when the startup prompt to trust a workspace is shown."
-            )),
-            tags: [WORKSPACE_TRUST_SETTING_TAG],
-            scope: 1 ,
-            enum: ['always', 'once', 'never'],
-            enumDescriptions: [
-                ( localize(
-                    'workspace.trust.startupPrompt.always',
-                    "Ask for trust every time an untrusted workspace is opened."
-                )),
-                ( localize(
-                    'workspace.trust.startupPrompt.once',
-                    "Ask for trust the first time an untrusted workspace is opened."
-                )),
-                ( localize(
-                    'workspace.trust.startupPrompt.never',
-                    "Do not ask for trust when an untrusted workspace is opened."
-                )),
-            ]
-        },
-        [WORKSPACE_TRUST_BANNER]: {
-            type: 'string',
-            default: 'untilDismissed',
-            description: ( localize(
-                'workspace.trust.banner.description',
-                "Controls when the restricted mode banner is shown."
-            )),
-            tags: [WORKSPACE_TRUST_SETTING_TAG],
-            scope: 1 ,
-            enum: ['always', 'untilDismissed', 'never'],
-            enumDescriptions: [
-                ( localize(
-                    'workspace.trust.banner.always',
-                    "Show the banner every time an untrusted workspace is open."
-                )),
-                ( localize(
-                    'workspace.trust.banner.untilDismissed',
-                    "Show the banner when an untrusted workspace is opened until dismissed."
-                )),
-                ( localize(
-                    'workspace.trust.banner.never',
-                    "Do not show the banner when an untrusted workspace is open."
-                )),
-            ]
-        },
-        [WORKSPACE_TRUST_UNTRUSTED_FILES]: {
-            type: 'string',
-            default: 'prompt',
-            markdownDescription: ( localize(
-                'workspace.trust.untrustedFiles.description',
-                "Controls how to handle opening untrusted files in a trusted workspace. This setting also applies to opening files in an empty window which is trusted via `#{0}#`.",
-                WORKSPACE_TRUST_EMPTY_WINDOW
-            )),
-            tags: [WORKSPACE_TRUST_SETTING_TAG],
-            scope: 1 ,
-            enum: ['prompt', 'open', 'newWindow'],
-            enumDescriptions: [
-                ( localize(
-                    'workspace.trust.untrustedFiles.prompt',
-                    "Ask how to handle untrusted files for each workspace. Once untrusted files are introduced to a trusted workspace, you will not be prompted again."
-                )),
-                ( localize(
-                    'workspace.trust.untrustedFiles.open',
-                    "Always allow untrusted files to be introduced to a trusted workspace without prompting."
-                )),
-                ( localize(
-                    'workspace.trust.untrustedFiles.newWindow',
-                    "Always open untrusted files in a separate window in restricted mode without prompting."
-                )),
-            ]
-        },
-        [WORKSPACE_TRUST_EMPTY_WINDOW]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localize(
-                'workspace.trust.emptyWindow.description',
-                "Controls whether or not the empty window is trusted by default within VS Code. When used with `#{0}#`, you can enable the full functionality of VS Code without prompting in an empty window.",
-                WORKSPACE_TRUST_UNTRUSTED_FILES
-            )),
-            tags: [WORKSPACE_TRUST_SETTING_TAG],
-            scope: 1
-        }
-    }
-});
-let WorkspaceTrustTelemetryContribution = class WorkspaceTrustTelemetryContribution extends Disposable {
-    constructor(environmentService, telemetryService, workspaceContextService, workspaceTrustEnablementService, workspaceTrustManagementService) {
-        super();
-        this.environmentService = environmentService;
-        this.telemetryService = telemetryService;
-        this.workspaceContextService = workspaceContextService;
-        this.workspaceTrustEnablementService = workspaceTrustEnablementService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.workspaceTrustManagementService.workspaceTrustInitialized
-            .then(() => {
-            this.logInitialWorkspaceTrustInfo();
-            this.logWorkspaceTrust(this.workspaceTrustManagementService.isWorkspaceTrusted());
-            this._register(this.workspaceTrustManagementService.onDidChangeTrust(isTrusted => this.logWorkspaceTrust(isTrusted)));
-        });
-    }
-    logInitialWorkspaceTrustInfo() {
-        if (!this.workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
-            const disabledByCliFlag = this.environmentService.disableWorkspaceTrust;
-            this.telemetryService.publicLog2('workspaceTrustDisabled', {
-                reason: disabledByCliFlag ? 'cli' : 'setting'
-            });
-            return;
-        }
-        this.telemetryService.publicLog2('workspaceTrustFolderCounts', {
-            trustedFoldersCount: this.workspaceTrustManagementService.getTrustedUris().length,
-        });
-    }
-    async logWorkspaceTrust(isTrusted) {
-        if (!this.workspaceTrustEnablementService.isWorkspaceTrustEnabled()) {
-            return;
-        }
-        this.telemetryService.publicLog2('workspaceTrustStateChanged', {
-            workspaceId: this.workspaceContextService.getWorkspace().id,
-            isTrusted: isTrusted
-        });
-        if (isTrusted) {
-            const getDepth = (folder) => {
-                let resolvedPath = resolve(folder);
-                let depth = 0;
-                while (dirname$1(resolvedPath) !== resolvedPath && depth < 100) {
-                    resolvedPath = dirname$1(resolvedPath);
-                    depth++;
-                }
-                return depth;
-            };
-            for (const folder of this.workspaceContextService.getWorkspace().folders) {
-                const { trusted, uri } = await this.workspaceTrustManagementService.getUriTrustInfo(folder.uri);
-                if (!trusted) {
-                    continue;
-                }
-                const workspaceFolderDepth = getDepth(folder.uri.fsPath);
-                const trustedFolderDepth = getDepth(uri.fsPath);
-                const delta = workspaceFolderDepth - trustedFolderDepth;
-                this.telemetryService.publicLog2('workspaceFolderDepthBelowTrustedFolder', { workspaceFolderDepth, trustedFolderDepth, delta });
-            }
-        }
-    }
-};
-WorkspaceTrustTelemetryContribution = ( __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IWorkspaceTrustEnablementService)),
-    ( __param(4, IWorkspaceTrustManagementService))
-], WorkspaceTrustTelemetryContribution));
-( Registry.as(Extensions.Workbench))
-    .registerWorkbenchContribution(WorkspaceTrustTelemetryContribution, 3 );
-export { WorkspaceTrustContextKeys, WorkspaceTrustRequestHandler, WorkspaceTrustUXHandler };