@codingame/monaco-vscode-extension-gallery-service-override 1.83.9

package/vscode/src/vs/workbench/contrib/extensions/browser/extensionEditor.js

@@ -0,0 +1,1868 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/extensionEditor.css.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { language, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Cache } from 'monaco-editor/esm/vs/base/common/cache.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { getErrorMessage, onUnexpectedError, isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { MutableDisposable, DisposableStore, toDisposable, Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { append, $, addDisposableListener, setParentFlowTo, join, reset } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtensionRecommendationsService } from 'vscode/vscode/vs/workbench/services/extensionRecommendations/common/extensionRecommendations';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { ExtensionContainers, VIEWLET_ID, IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { RemoteBadgeWidget, VerifiedPublisherWidget, InstallCountWidget, RatingsWidget, SponsorWidget, ExtensionStatusWidget, ExtensionWidget, ExtensionRecommendationWidget, onClick } from './extensionsWidgets.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { InstallDropdownAction, ReloadAction, ExtensionStatusLabelAction, ActionWithDropDownAction, UpdateAction, SkipUpdateAction, SetColorThemeAction, SetFileIconThemeAction, SetProductIconThemeAction, SetLanguageAction, ClearLanguageAction, EnableDropDownAction, DisableDropDownAction, RemoteInstallAction, LocalInstallAction, WebInstallAction, InstallingLabelAction, UninstallAction, MigrateDeprecatedExtensionAction, InstallAnotherVersionAction, SwitchToPreReleaseVersionAction, SwitchToReleasedVersionAction, ToggleSyncExtensionAction, ExtensionEditorManageExtensionAction, ExtensionDropDownAction, ExtensionActionWithDropdownActionViewItem, ExtensionStatusAction } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsActions';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { matchesScheme, IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { registerThemingParticipant, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { KeybindingLabel } from 'monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ExtensionsTree, ExtensionData, ExtensionsGridView, getExtensions } from './extensionsViewer.js';
+import { ShowCurrentReleaseNotesActionId } from '../../update/common/update.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { getDefaultValue } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED, IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { platform } from 'monaco-editor/esm/vs/base/common/process.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { renderMarkdownDocument, DEFAULT_MARKDOWN_STYLES } from '../../markdown/browser/markdownDocumentRenderer.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { TokenizationRegistry } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { generateTokensCSSForColorMap } from 'monaco-editor/esm/vs/editor/common/languages/supports/tokenization.js';
+import { editorBackground, textLinkForeground, textLinkActiveForeground, buttonHoverBackground, buttonForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { Delegate } from './extensionsList.js';
+import { renderMarkdown } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { errorIcon, warningIcon, infoIcon, preReleaseIcon } from 'vscode/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { valid } from 'vscode-semver';
+import { defaultKeybindingLabelStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+
+var ExtensionEditor_1;
+class NavBar extends Disposable {
+    get onChange() { return this._onChange.event; }
+    get currentId() { return this._currentId; }
+    constructor(container) {
+        super();
+        this._onChange = this._register(( new Emitter()));
+        this._currentId = null;
+        const element = append(container, $('.navbar'));
+        this.actions = [];
+        this.actionbar = this._register(( new ActionBar(element, { animated: false })));
+    }
+    push(id, label, tooltip) {
+        const action = ( new Action(id, label, undefined, true, () => this.update(id, true)));
+        action.tooltip = tooltip;
+        this.actions.push(action);
+        this.actionbar.push(action);
+        if (this.actions.length === 1) {
+            this.update(id);
+        }
+    }
+    clear() {
+        this.actions = dispose(this.actions);
+        this.actionbar.clear();
+    }
+    switch(id) {
+        const action = this.actions.find(action => action.id === id);
+        if (action) {
+            action.run();
+            return true;
+        }
+        return false;
+    }
+    update(id, focus) {
+        this._currentId = id;
+        this._onChange.fire({ id, focus: !!focus });
+        this.actions.forEach(a => a.checked = a.id === id);
+    }
+}
+const CONTEXT_SHOW_PRE_RELEASE_VERSION = ( new RawContextKey('showPreReleaseVersion', false));
+class ExtensionWithDifferentGalleryVersionWidget extends ExtensionWidget {
+    constructor() {
+        super(...arguments);
+        this._gallery = null;
+    }
+    get gallery() { return this._gallery; }
+    set gallery(gallery) {
+        if (this.extension && gallery && !areSameExtensions(this.extension.identifier, gallery.identifier)) {
+            return;
+        }
+        this._gallery = gallery;
+        this.update();
+    }
+}
+class VersionWidget extends ExtensionWithDifferentGalleryVersionWidget {
+    constructor(container) {
+        super();
+        this.element = append(container, $('code.version', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'extension version',
+            "Extension Version"
+        )) }));
+        this.render();
+    }
+    render() {
+        if (!this.extension || !valid(this.extension.version)) {
+            return;
+        }
+        this.element.textContent = `v${this.gallery?.version ?? this.extension.version}`;
+    }
+}
+class PreReleaseTextWidget extends ExtensionWithDifferentGalleryVersionWidget {
+    constructor(container) {
+        super();
+        this.element = append(container, $('span.pre-release'));
+        append(this.element, $('span' + ThemeIcon.asCSSSelector(preReleaseIcon)));
+        const textElement = append(this.element, $('span.pre-release-text'));
+        textElement.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'preRelease',
+            "Pre-Release"
+        ));
+        this.render();
+    }
+    render() {
+        this.element.style.display = this.isPreReleaseVersion() ? 'inherit' : 'none';
+    }
+    isPreReleaseVersion() {
+        if (!this.extension) {
+            return false;
+        }
+        if (this.gallery) {
+            return this.gallery.properties.isPreReleaseVersion;
+        }
+        return !!(this.extension.state === 1  ? this.extension.local?.isPreReleaseVersion : this.extension.gallery?.properties.isPreReleaseVersion);
+    }
+}
+let ExtensionEditor = class ExtensionEditor extends EditorPane {
+    static { ExtensionEditor_1 = this; }
+    static { this.ID = 'workbench.editor.extension'; }
+    constructor(telemetryService, instantiationService, paneCompositeService, extensionsWorkbenchService, extensionGalleryService, themeService, keybindingService, notificationService, openerService, extensionRecommendationsService, storageService, extensionService, webviewService, languageService, contextMenuService, contextKeyService) {
+        super(ExtensionEditor_1.ID, telemetryService, themeService, storageService);
+        this.instantiationService = instantiationService;
+        this.paneCompositeService = paneCompositeService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.extensionGalleryService = extensionGalleryService;
+        this.keybindingService = keybindingService;
+        this.notificationService = notificationService;
+        this.openerService = openerService;
+        this.extensionRecommendationsService = extensionRecommendationsService;
+        this.extensionService = extensionService;
+        this.webviewService = webviewService;
+        this.languageService = languageService;
+        this.contextMenuService = contextMenuService;
+        this.contextKeyService = contextKeyService;
+        this._scopedContextKeyService = this._register(( new MutableDisposable()));
+        this.initialScrollProgress = ( new Map());
+        this.currentIdentifier = '';
+        this.layoutParticipants = [];
+        this.contentDisposables = this._register(( new DisposableStore()));
+        this.transientDisposables = this._register(( new DisposableStore()));
+        this.activeElement = null;
+        this.extensionReadme = null;
+        this.extensionChangelog = null;
+        this.extensionManifest = null;
+    }
+    get scopedContextKeyService() {
+        return this._scopedContextKeyService.value;
+    }
+    createEditor(parent) {
+        const root = append(parent, $('.extension-editor'));
+        this._scopedContextKeyService.value = this.contextKeyService.createScoped(root);
+        this._scopedContextKeyService.value.createKey('inExtensionEditor', true);
+        this.showPreReleaseVersionContextKey = CONTEXT_SHOW_PRE_RELEASE_VERSION.bindTo(this._scopedContextKeyService.value);
+        root.tabIndex = 0;
+        root.style.outline = 'none';
+        root.setAttribute('role', 'document');
+        const header = append(root, $('.header'));
+        const iconContainer = append(header, $('.icon-container'));
+        const icon = append(iconContainer, $('img.icon', { draggable: false, alt: '' }));
+        const remoteBadge = this.instantiationService.createInstance(RemoteBadgeWidget, iconContainer, true);
+        const details = append(header, $('.details'));
+        const title = append(details, $('.title'));
+        const name = append(title, $('span.name.clickable', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'name',
+            "Extension name"
+        )), role: 'heading', tabIndex: 0 }));
+        const versionWidget = ( new VersionWidget(title));
+        const preReleaseWidget = ( new PreReleaseTextWidget(title));
+        const preview = append(title, $('span.preview', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'preview',
+            "Preview"
+        )) }));
+        preview.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'preview',
+            "Preview"
+        ));
+        const builtin = append(title, $('span.builtin'));
+        builtin.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'builtin',
+            "Built-in"
+        ));
+        const subtitle = append(details, $('.subtitle'));
+        const publisher = append(append(subtitle, $('.subtitle-entry')), $('.publisher.clickable', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'publisher',
+            "Publisher"
+        )), tabIndex: 0 }));
+        publisher.setAttribute('role', 'button');
+        const publisherDisplayName = append(publisher, $('.publisher-name'));
+        const verifiedPublisherWidget = this.instantiationService.createInstance(VerifiedPublisherWidget, append(publisher, $('.verified-publisher')), false);
+        const installCount = append(append(subtitle, $('.subtitle-entry')), $('span.install', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'install count',
+            "Install count"
+        )), tabIndex: 0 }));
+        const installCountWidget = this.instantiationService.createInstance(InstallCountWidget, installCount, false);
+        const rating = append(append(subtitle, $('.subtitle-entry')), $('span.rating.clickable', { title: ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'rating',
+            "Rating"
+        )), tabIndex: 0 }));
+        rating.setAttribute('role', 'link');
+        const ratingsWidget = this.instantiationService.createInstance(RatingsWidget, rating, false);
+        const sponsorWidget = this.instantiationService.createInstance(SponsorWidget, append(subtitle, $('.subtitle-entry')));
+        const widgets = [
+            remoteBadge,
+            versionWidget,
+            preReleaseWidget,
+            verifiedPublisherWidget,
+            installCountWidget,
+            ratingsWidget,
+            sponsorWidget,
+        ];
+        const description = append(details, $('.description'));
+        const installAction = this.instantiationService.createInstance(InstallDropdownAction);
+        const actions = [
+            this.instantiationService.createInstance(ReloadAction),
+            this.instantiationService.createInstance(ExtensionStatusLabelAction),
+            this.instantiationService.createInstance(ActionWithDropDownAction, 'extensions.updateActions', '', [[this.instantiationService.createInstance(UpdateAction, true)], [this.instantiationService.createInstance(SkipUpdateAction)]]),
+            this.instantiationService.createInstance(SetColorThemeAction),
+            this.instantiationService.createInstance(SetFileIconThemeAction),
+            this.instantiationService.createInstance(SetProductIconThemeAction),
+            this.instantiationService.createInstance(SetLanguageAction),
+            this.instantiationService.createInstance(ClearLanguageAction),
+            this.instantiationService.createInstance(EnableDropDownAction),
+            this.instantiationService.createInstance(DisableDropDownAction),
+            this.instantiationService.createInstance(RemoteInstallAction, false),
+            this.instantiationService.createInstance(LocalInstallAction),
+            this.instantiationService.createInstance(WebInstallAction),
+            installAction,
+            this.instantiationService.createInstance(InstallingLabelAction),
+            this.instantiationService.createInstance(ActionWithDropDownAction, 'extensions.uninstall', UninstallAction.UninstallLabel, [
+                [
+                    this.instantiationService.createInstance(MigrateDeprecatedExtensionAction, false),
+                    this.instantiationService.createInstance(UninstallAction),
+                    this.instantiationService.createInstance(InstallAnotherVersionAction),
+                ]
+            ]),
+            this.instantiationService.createInstance(SwitchToPreReleaseVersionAction, false),
+            this.instantiationService.createInstance(SwitchToReleasedVersionAction, false),
+            this.instantiationService.createInstance(ToggleSyncExtensionAction),
+            ( new ExtensionEditorManageExtensionAction(
+                this.scopedContextKeyService || this.contextKeyService,
+                this.instantiationService
+            )),
+        ];
+        const actionsAndStatusContainer = append(details, $('.actions-status-container'));
+        const extensionActionBar = this._register(( new ActionBar(actionsAndStatusContainer, {
+            animated: false,
+            actionViewItemProvider: (action) => {
+                if (action instanceof ExtensionDropDownAction) {
+                    return action.createActionViewItem();
+                }
+                if (action instanceof ActionWithDropDownAction) {
+                    return ( new ExtensionActionWithDropdownActionViewItem(
+                        action,
+                        { icon: true, label: true, menuActionsOrProvider: { getActions: () => action.menuActions }, menuActionClassNames: (action.class || '').split(' ') },
+                        this.contextMenuService
+                    ));
+                }
+                return undefined;
+            },
+            focusOnlyEnabledItems: true
+        })));
+        extensionActionBar.push(actions, { icon: true, label: true });
+        extensionActionBar.setFocusable(true);
+        this._register(Event.any(...( actions.map(a => Event.filter(a.onDidChange, e => e.enabled !== undefined))))(() => {
+            extensionActionBar.setFocusable(false);
+            extensionActionBar.setFocusable(true);
+        }));
+        const otherExtensionContainers = [];
+        const extensionStatusAction = this.instantiationService.createInstance(ExtensionStatusAction);
+        const extensionStatusWidget = this._register(this.instantiationService.createInstance(ExtensionStatusWidget, append(actionsAndStatusContainer, $('.status')), extensionStatusAction));
+        otherExtensionContainers.push(extensionStatusAction, new (class extends ExtensionWidget {
+            render() {
+                actionsAndStatusContainer.classList.toggle('list-layout', this.extension?.state === 1 );
+            }
+        })());
+        const recommendationWidget = this.instantiationService.createInstance(ExtensionRecommendationWidget, append(details, $('.recommendation')));
+        widgets.push(recommendationWidget);
+        this._register(Event.any(extensionStatusWidget.onDidRender, recommendationWidget.onDidRender)(() => {
+            if (this.dimension) {
+                this.layout(this.dimension);
+            }
+        }));
+        const extensionContainers = this.instantiationService.createInstance(ExtensionContainers, [...actions, ...widgets, ...otherExtensionContainers]);
+        for (const disposable of [...actions, ...widgets, ...otherExtensionContainers, extensionContainers]) {
+            this._register(disposable);
+        }
+        const onError = Event.chain(extensionActionBar.onDidRun, $ => ( $.map(({ error }) => error))
+            .filter(error => !!error));
+        this._register(onError(this.onError, this));
+        const body = append(root, $('.body'));
+        const navbar = ( new NavBar(body));
+        const content = append(body, $('.content'));
+        content.id = generateUuid();
+        this.template = {
+            builtin,
+            content,
+            description,
+            header,
+            icon,
+            iconContainer,
+            installCount,
+            name,
+            navbar,
+            preview,
+            publisher,
+            publisherDisplayName,
+            rating,
+            actionsAndStatusContainer,
+            extensionActionBar,
+            set extension(extension) {
+                extensionContainers.extension = extension;
+            },
+            set gallery(gallery) {
+                versionWidget.gallery = gallery;
+                preReleaseWidget.gallery = gallery;
+            },
+            set manifest(manifest) {
+                installAction.manifest = manifest;
+            }
+        };
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        this.updatePreReleaseVersionContext();
+        if (this.template) {
+            await this.render(input.extension, this.template, !!options?.preserveFocus);
+        }
+    }
+    setOptions(options) {
+        const currentOptions = this.options;
+        super.setOptions(options);
+        this.updatePreReleaseVersionContext();
+        if (this.input && this.template && currentOptions?.showPreReleaseVersion !== options?.showPreReleaseVersion) {
+            this.render(this.input.extension, this.template, !!options?.preserveFocus);
+        }
+    }
+    updatePreReleaseVersionContext() {
+        let showPreReleaseVersion = this.options?.showPreReleaseVersion;
+        if (isUndefined(showPreReleaseVersion)) {
+            showPreReleaseVersion = !!this.input.extension.gallery?.properties.isPreReleaseVersion;
+        }
+        this.showPreReleaseVersionContextKey?.set(showPreReleaseVersion);
+    }
+    async openTab(tab) {
+        if (!this.input || !this.template) {
+            return;
+        }
+        if (this.template.navbar.switch(tab)) {
+            return;
+        }
+        if (tab === "extensionPack" ) {
+            this.template.navbar.switch("readme" );
+        }
+    }
+    async getGalleryVersionToShow(extension, preRelease) {
+        if (isUndefined(preRelease)) {
+            return null;
+        }
+        if (preRelease === extension.gallery?.properties.isPreReleaseVersion) {
+            return null;
+        }
+        if (preRelease && !extension.hasPreReleaseVersion) {
+            return null;
+        }
+        if (!preRelease && !extension.hasReleaseVersion) {
+            return null;
+        }
+        return (await this.extensionGalleryService.getExtensions([{ ...extension.identifier, preRelease, hasPreRelease: extension.hasPreReleaseVersion }], CancellationToken.None))[0] || null;
+    }
+    async render(extension, template, preserveFocus) {
+        this.activeElement = null;
+        this.transientDisposables.clear();
+        const token = this.transientDisposables.add(( new CancellationTokenSource())).token;
+        const gallery = await this.getGalleryVersionToShow(extension, this.options?.showPreReleaseVersion);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.extensionReadme = ( new Cache(
+            () => gallery ? this.extensionGalleryService.getReadme(gallery, token) : extension.getReadme(token)
+        ));
+        this.extensionChangelog = ( new Cache(
+            () => gallery ? this.extensionGalleryService.getChangelog(gallery, token) : extension.getChangelog(token)
+        ));
+        this.extensionManifest = ( new Cache(
+            () => gallery ? this.extensionGalleryService.getManifest(gallery, token) : extension.getManifest(token)
+        ));
+        template.extension = extension;
+        template.gallery = gallery;
+        template.manifest = null;
+        this.transientDisposables.add(addDisposableListener(template.icon, 'error', () => template.icon.src = extension.iconUrlFallback, { once: true }));
+        template.icon.src = extension.iconUrl;
+        template.name.textContent = extension.displayName;
+        template.name.classList.toggle('clickable', !!extension.url);
+        template.name.classList.toggle('deprecated', !!extension.deprecationInfo);
+        template.preview.style.display = extension.preview ? 'inherit' : 'none';
+        template.builtin.style.display = extension.isBuiltin ? 'inherit' : 'none';
+        template.description.textContent = extension.description;
+        template.publisher.classList.toggle('clickable', !!extension.url);
+        template.publisherDisplayName.textContent = extension.publisherDisplayName;
+        template.installCount.parentElement?.classList.toggle('hide', !extension.url);
+        template.rating.parentElement?.classList.toggle('hide', !extension.url);
+        template.rating.classList.toggle('clickable', !!extension.url);
+        if (extension.url) {
+            this.transientDisposables.add(onClick(template.name, () => this.openerService.open(( URI.parse(extension.url)))));
+            this.transientDisposables.add(onClick(template.rating, () => this.openerService.open(( URI.parse(`${extension.url}&ssr=false#review-details`)))));
+            this.transientDisposables.add(onClick(template.publisher, () => {
+                this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true)
+                    .then(viewlet => viewlet?.getViewPaneContainer())
+                    .then(viewlet => viewlet.search(`publisher:"${extension.publisherDisplayName}"`));
+            }));
+        }
+        const manifest = await this.extensionManifest.get().promise;
+        if (token.isCancellationRequested) {
+            return;
+        }
+        if (manifest) {
+            template.manifest = manifest;
+        }
+        this.renderNavbar(extension, manifest, template, preserveFocus);
+        const extRecommendations = this.extensionRecommendationsService.getAllRecommendationsWithReason();
+        let recommendationsData = {};
+        if (extRecommendations[extension.identifier.id.toLowerCase()]) {
+            recommendationsData = { recommendationReason: extRecommendations[extension.identifier.id.toLowerCase()].reasonId };
+        }
+        this.telemetryService.publicLog('extensionGallery:openExtension', { ...extension.telemetryData, ...recommendationsData });
+    }
+    renderNavbar(extension, manifest, template, preserveFocus) {
+        template.content.innerText = '';
+        template.navbar.clear();
+        if (this.currentIdentifier !== extension.identifier.id) {
+            this.initialScrollProgress.clear();
+            this.currentIdentifier = extension.identifier.id;
+        }
+        if (extension.hasReadme()) {
+            template.navbar.push("readme" , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'details',
+                "Details"
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'detailstooltip',
+                "Extension details, rendered from the extension's 'README.md' file"
+            )));
+        }
+        if (manifest && manifest.contributes) {
+            template.navbar.push("contributions" , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'contributions',
+                "Feature Contributions"
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'contributionstooltip',
+                "Lists contributions to VS Code by this extension"
+            )));
+        }
+        if (extension.hasChangelog()) {
+            template.navbar.push("changelog" , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'changelog',
+                "Changelog"
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'changelogtooltip',
+                "Extension update history, rendered from the extension's 'CHANGELOG.md' file"
+            )));
+        }
+        if (extension.dependencies.length) {
+            template.navbar.push("dependencies" , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'dependencies',
+                "Dependencies"
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'dependenciestooltip',
+                "Lists extensions this extension depends on"
+            )));
+        }
+        if (manifest && manifest.extensionPack?.length && !this.shallRenderAsExtensionPack(manifest)) {
+            template.navbar.push("extensionPack" , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'extensionpack',
+                "Extension Pack"
+            )), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'extensionpacktooltip',
+                "Lists extensions those will be installed together with this extension"
+            )));
+        }
+        const addRuntimeStatusSection = () => template.navbar.push("runtimeStatus" , ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'runtimeStatus',
+            "Runtime Status"
+        )), ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'runtimeStatus description',
+            "Extension runtime status"
+        )));
+        if (this.extensionsWorkbenchService.getExtensionStatus(extension)) {
+            addRuntimeStatusSection();
+        }
+        else {
+            const disposable = this.extensionService.onDidChangeExtensionsStatus(e => {
+                if (( e.some(
+                    extensionIdentifier => areSameExtensions({ id: extensionIdentifier.value }, extension.identifier)
+                ))) {
+                    addRuntimeStatusSection();
+                    disposable.dispose();
+                }
+            }, this, this.transientDisposables);
+        }
+        if (template.navbar.currentId) {
+            this.onNavbarChange(extension, { id: template.navbar.currentId, focus: !preserveFocus }, template);
+        }
+        template.navbar.onChange(e => this.onNavbarChange(extension, e, template), this, this.transientDisposables);
+    }
+    clearInput() {
+        this.contentDisposables.clear();
+        this.transientDisposables.clear();
+        super.clearInput();
+    }
+    focus() {
+        this.activeElement?.focus();
+    }
+    showFind() {
+        this.activeWebview?.showFind();
+    }
+    runFindAction(previous) {
+        this.activeWebview?.runFindAction(previous);
+    }
+    get activeWebview() {
+        if (!this.activeElement || !this.activeElement.runFindAction) {
+            return undefined;
+        }
+        return this.activeElement;
+    }
+    onNavbarChange(extension, { id, focus }, template) {
+        this.contentDisposables.clear();
+        template.content.innerText = '';
+        this.activeElement = null;
+        if (id) {
+            const cts = ( new CancellationTokenSource());
+            this.contentDisposables.add(toDisposable(() => cts.dispose(true)));
+            this.open(id, extension, template, cts.token)
+                .then(activeElement => {
+                if (cts.token.isCancellationRequested) {
+                    return;
+                }
+                this.activeElement = activeElement;
+                if (focus) {
+                    this.focus();
+                }
+            });
+        }
+    }
+    open(id, extension, template, token) {
+        switch (id) {
+            case "readme" : return this.openDetails(extension, template, token);
+            case "contributions" : return this.openContributions(template, token);
+            case "changelog" : return this.openChangelog(template, token);
+            case "dependencies" : return this.openExtensionDependencies(extension, template, token);
+            case "extensionPack" : return this.openExtensionPack(extension, template, token);
+            case "runtimeStatus" : return this.openRuntimeStatus(extension, template, token);
+        }
+        return Promise.resolve(null);
+    }
+    async openMarkdown(cacheResult, noContentCopy, container, webviewIndex, title, token) {
+        try {
+            const body = await this.renderMarkdown(cacheResult, container, token);
+            if (token.isCancellationRequested) {
+                return Promise.resolve(null);
+            }
+            const webview = this.contentDisposables.add(this.webviewService.createWebviewOverlay({
+                title,
+                options: {
+                    enableFindWidget: true,
+                    tryRestoreScrollPosition: true,
+                    disableServiceWorker: true,
+                },
+                contentOptions: {},
+                extension: undefined,
+            }));
+            webview.initialScrollProgress = this.initialScrollProgress.get(webviewIndex) || 0;
+            webview.claim(this, this.scopedContextKeyService);
+            setParentFlowTo(webview.container, container);
+            webview.layoutWebviewOverElement(container);
+            webview.setHtml(body);
+            webview.claim(this, undefined);
+            this.contentDisposables.add(webview.onDidFocus(() => this.fireOnDidFocus()));
+            this.contentDisposables.add(webview.onDidScroll(() => this.initialScrollProgress.set(webviewIndex, webview.initialScrollProgress)));
+            const removeLayoutParticipant = arrays.insert(this.layoutParticipants, {
+                layout: () => {
+                    webview.layoutWebviewOverElement(container);
+                }
+            });
+            this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+            let isDisposed = false;
+            this.contentDisposables.add(toDisposable(() => { isDisposed = true; }));
+            this.contentDisposables.add(this.themeService.onDidColorThemeChange(async () => {
+                const body = await this.renderMarkdown(cacheResult, container);
+                if (!isDisposed) {
+                    webview.setHtml(body);
+                }
+            }));
+            this.contentDisposables.add(webview.onDidClickLink(link => {
+                if (!link) {
+                    return;
+                }
+                if (matchesScheme(link, Schemas.http) || matchesScheme(link, Schemas.https) || matchesScheme(link, Schemas.mailto)) {
+                    this.openerService.open(link);
+                }
+                if (matchesScheme(link, Schemas.command) && ( URI.parse(link)).path === ShowCurrentReleaseNotesActionId) {
+                    this.openerService.open(link, { allowCommands: true });
+                }
+            }));
+            return webview;
+        }
+        catch (e) {
+            const p = append(container, $('p.nocontent'));
+            p.textContent = noContentCopy;
+            return p;
+        }
+    }
+    async renderMarkdown(cacheResult, container, token) {
+        const contents = await this.loadContents(() => cacheResult, container);
+        if (token?.isCancellationRequested) {
+            return '';
+        }
+        const content = await renderMarkdownDocument(contents, this.extensionService, this.languageService, true, false, token);
+        if (token?.isCancellationRequested) {
+            return '';
+        }
+        return this.renderBody(content);
+    }
+    renderBody(body) {
+        const nonce = generateUuid();
+        const colorMap = TokenizationRegistry.getColorMap();
+        const css = colorMap ? generateTokensCSSForColorMap(colorMap) : '';
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src https: data:; media-src https:; script-src 'none'; style-src 'nonce-${nonce}';">
+				<style nonce="${nonce}">
+					${DEFAULT_MARKDOWN_STYLES}
+
+					/* prevent scroll-to-top button from blocking the body text */
+					body {
+						padding-bottom: 75px;
+					}
+
+					#scroll-to-top {
+						position: fixed;
+						width: 32px;
+						height: 32px;
+						right: 25px;
+						bottom: 25px;
+						background-color: var(--vscode-button-secondaryBackground);
+						border-color: var(--vscode-button-border);
+						border-radius: 50%;
+						cursor: pointer;
+						box-shadow: 1px 1px 1px rgba(0,0,0,.25);
+						outline: none;
+						display: flex;
+						justify-content: center;
+						align-items: center;
+					}
+
+					#scroll-to-top:hover {
+						background-color: var(--vscode-button-secondaryHoverBackground);
+						box-shadow: 2px 2px 2px rgba(0,0,0,.25);
+					}
+
+					body.vscode-high-contrast #scroll-to-top {
+						border-width: 2px;
+						border-style: solid;
+						box-shadow: none;
+					}
+
+					#scroll-to-top span.icon::before {
+						content: "";
+						display: block;
+						background: var(--vscode-button-secondaryForeground);
+						/* Chevron up icon */
+						webkit-mask-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxNiAxNiIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTYgMTY7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDojRkZGRkZGO30KCS5zdDF7ZmlsbDpub25lO30KPC9zdHlsZT4KPHRpdGxlPnVwY2hldnJvbjwvdGl0bGU+CjxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik04LDUuMWwtNy4zLDcuM0wwLDExLjZsOC04bDgsOGwtMC43LDAuN0w4LDUuMXoiLz4KPHJlY3QgY2xhc3M9InN0MSIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+Cjwvc3ZnPgo=');
+						-webkit-mask-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxNiAxNiIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTYgMTY7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDojRkZGRkZGO30KCS5zdDF7ZmlsbDpub25lO30KPC9zdHlsZT4KPHRpdGxlPnVwY2hldnJvbjwvdGl0bGU+CjxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik04LDUuMWwtNy4zLDcuM0wwLDExLjZsOC04bDgsOGwtMC43LDAuN0w4LDUuMXoiLz4KPHJlY3QgY2xhc3M9InN0MSIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+Cjwvc3ZnPgo=');
+						width: 16px;
+						height: 16px;
+					}
+					${css}
+				</style>
+			</head>
+			<body>
+				<a id="scroll-to-top" role="button" aria-label="scroll to top" href="#"><span class="icon"></span></a>
+				${body}
+			</body>
+		</html>`;
+    }
+    async openDetails(extension, template, token) {
+        const details = append(template.content, $('.details'));
+        const readmeContainer = append(details, $('.readme-container'));
+        const additionalDetailsContainer = append(details, $('.additional-details-container'));
+        const layout = () => details.classList.toggle('narrow', this.dimension && this.dimension.width < 500);
+        layout();
+        this.contentDisposables.add(toDisposable(arrays.insert(this.layoutParticipants, { layout })));
+        let activeElement = null;
+        const manifest = await this.extensionManifest.get().promise;
+        if (manifest && manifest.extensionPack?.length && this.shallRenderAsExtensionPack(manifest)) {
+            activeElement = await this.openExtensionPackReadme(manifest, readmeContainer, token);
+        }
+        else {
+            activeElement = await this.openMarkdown(this.extensionReadme.get(), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'noReadme',
+                "No README available."
+            )), readmeContainer, 0 , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'Readme title',
+                "Readme"
+            )), token);
+        }
+        this.renderAdditionalDetails(additionalDetailsContainer, extension);
+        return activeElement;
+    }
+    shallRenderAsExtensionPack(manifest) {
+        return !!(manifest.categories?.some(category => category.toLowerCase() === 'extension packs'));
+    }
+    async openExtensionPackReadme(manifest, container, token) {
+        if (token.isCancellationRequested) {
+            return Promise.resolve(null);
+        }
+        const extensionPackReadme = append(container, $('div', { class: 'extension-pack-readme' }));
+        extensionPackReadme.style.margin = '0 auto';
+        extensionPackReadme.style.maxWidth = '882px';
+        const extensionPack = append(extensionPackReadme, $('div', { class: 'extension-pack' }));
+        if (manifest.extensionPack.length <= 3) {
+            extensionPackReadme.classList.add('one-row');
+        }
+        else if (manifest.extensionPack.length <= 6) {
+            extensionPackReadme.classList.add('two-rows');
+        }
+        else if (manifest.extensionPack.length <= 9) {
+            extensionPackReadme.classList.add('three-rows');
+        }
+        else {
+            extensionPackReadme.classList.add('more-rows');
+        }
+        const extensionPackHeader = append(extensionPack, $('div.header'));
+        extensionPackHeader.textContent = ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'extension pack',
+            "Extension Pack ({0})",
+            manifest.extensionPack.length
+        ));
+        const extensionPackContent = append(extensionPack, $('div', { class: 'extension-pack-content' }));
+        extensionPackContent.setAttribute('tabindex', '0');
+        append(extensionPack, $('div.footer'));
+        const readmeContent = append(extensionPackReadme, $('div.readme-content'));
+        await Promise.all([
+            this.renderExtensionPack(manifest, extensionPackContent, token),
+            this.openMarkdown(this.extensionReadme.get(), ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'noReadme',
+                "No README available."
+            )), readmeContent, 0 , ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'Readme title',
+                "Readme"
+            )), token),
+        ]);
+        return { focus: () => extensionPackContent.focus() };
+    }
+    renderAdditionalDetails(container, extension) {
+        const content = $('div', { class: 'additional-details-content', tabindex: '0' });
+        const scrollableContent = ( new DomScrollableElement(content, {}));
+        const layout = () => scrollableContent.scanDomNode();
+        const removeLayoutParticipant = arrays.insert(this.layoutParticipants, { layout });
+        this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+        this.contentDisposables.add(scrollableContent);
+        this.renderCategories(content, extension);
+        this.renderExtensionResources(content, extension);
+        this.renderMoreInfo(content, extension);
+        append(container, scrollableContent.getDomNode());
+        scrollableContent.scanDomNode();
+    }
+    renderCategories(container, extension) {
+        if (extension.categories.length) {
+            const categoriesContainer = append(container, $('.categories-container.additional-details-element'));
+            append(categoriesContainer, $('.additional-details-title', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'categories',
+                "Categories"
+            ))));
+            const categoriesElement = append(categoriesContainer, $('.categories'));
+            for (const category of extension.categories) {
+                this.transientDisposables.add(onClick(append(categoriesElement, $('span.category', { tabindex: '0' }, category)), () => {
+                    this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true)
+                        .then(viewlet => viewlet?.getViewPaneContainer())
+                        .then(viewlet => viewlet.search(`@category:"${category}"`));
+                }));
+            }
+        }
+    }
+    renderExtensionResources(container, extension) {
+        const resources = [];
+        if (extension.url) {
+            resources.push([( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'Marketplace',
+                "Marketplace"
+            )), ( URI.parse(extension.url))]);
+        }
+        if (extension.repository) {
+            try {
+                resources.push([( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionEditor',
+                    'repository',
+                    "Repository"
+                )), ( URI.parse(extension.repository))]);
+            }
+            catch (error) {  }
+        }
+        if (extension.url && extension.licenseUrl) {
+            try {
+                resources.push([( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionEditor',
+                    'license',
+                    "License"
+                )), ( URI.parse(extension.licenseUrl))]);
+            }
+            catch (error) {  }
+        }
+        if (extension.publisherUrl) {
+            resources.push([extension.publisherDisplayName, extension.publisherUrl]);
+        }
+        if (resources.length || extension.publisherSponsorLink) {
+            const extensionResourcesContainer = append(container, $('.resources-container.additional-details-element'));
+            append(extensionResourcesContainer, $('.additional-details-title', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'resources',
+                "Extension Resources"
+            ))));
+            const resourcesElement = append(extensionResourcesContainer, $('.resources'));
+            for (const [label, uri] of resources) {
+                this.transientDisposables.add(onClick(append(resourcesElement, $('a.resource', { title: ( uri.toString()), tabindex: '0' }, label)), () => this.openerService.open(uri)));
+            }
+        }
+    }
+    renderMoreInfo(container, extension) {
+        const gallery = extension.gallery;
+        const moreInfoContainer = append(container, $('.more-info-container.additional-details-element'));
+        append(moreInfoContainer, $('.additional-details-title', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Marketplace Info',
+            "More Info"
+        ))));
+        const moreInfo = append(moreInfoContainer, $('.more-info'));
+        const toDateString = (date) => `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}, ${date.toLocaleTimeString(language, { hourCycle: 'h23' })}`;
+        if (gallery) {
+            append(moreInfo, $('.more-info-entry', undefined, $('div', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'published',
+                "Published"
+            ))), $('div', undefined, toDateString(( new Date(gallery.releaseDate))))), $('.more-info-entry', undefined, $('div', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'last released',
+                "Last released"
+            ))), $('div', undefined, toDateString(( new Date(gallery.lastUpdated))))));
+        }
+        if (extension.local && extension.local.installedTimestamp) {
+            append(moreInfo, $('.more-info-entry', undefined, $('div', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'last updated',
+                "Last updated"
+            ))), $('div', undefined, toDateString(( new Date(extension.local.installedTimestamp))))));
+        }
+        append(moreInfo, $('.more-info-entry', undefined, $('div', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'id',
+            "Identifier"
+        ))), $('code', undefined, extension.identifier.id)));
+    }
+    openChangelog(template, token) {
+        return this.openMarkdown(this.extensionChangelog.get(), ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'noChangelog',
+            "No Changelog available."
+        )), template.content, 1 , ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Changelog title',
+            "Changelog"
+        )), token);
+    }
+    openContributions(template, token) {
+        const content = $('div.subcontent.feature-contributions', { tabindex: '0' });
+        return this.loadContents(() => this.extensionManifest.get(), template.content)
+            .then(manifest => {
+            if (token.isCancellationRequested) {
+                return null;
+            }
+            if (!manifest) {
+                return content;
+            }
+            const scrollableContent = ( new DomScrollableElement(content, {}));
+            const layout = () => scrollableContent.scanDomNode();
+            const removeLayoutParticipant = arrays.insert(this.layoutParticipants, { layout });
+            this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+            const renders = [
+                this.renderSettings(content, manifest, layout),
+                this.renderCommands(content, manifest, layout),
+                this.renderCodeActions(content, manifest, layout),
+                this.renderLanguages(content, manifest, layout),
+                this.renderColorThemes(content, manifest, layout),
+                this.renderIconThemes(content, manifest, layout),
+                this.renderProductIconThemes(content, manifest, layout),
+                this.renderColors(content, manifest, layout),
+                this.renderJSONValidation(content, manifest, layout),
+                this.renderDebuggers(content, manifest, layout),
+                this.renderViewContainers(content, manifest, layout),
+                this.renderViews(content, manifest, layout),
+                this.renderLocalizations(content, manifest, layout),
+                this.renderCustomEditors(content, manifest, layout),
+                this.renderNotebooks(content, manifest, layout),
+                this.renderNotebookRenderers(content, manifest, layout),
+                this.renderAuthentication(content, manifest, layout),
+                this.renderActivationEvents(content, manifest, layout),
+            ];
+            scrollableContent.scanDomNode();
+            const isEmpty = !( renders.some(x => x));
+            if (isEmpty) {
+                append(content, $('p.nocontent')).textContent = ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionEditor',
+                    'noContributions',
+                    "No Contributions"
+                ));
+                append(template.content, content);
+            }
+            else {
+                append(template.content, scrollableContent.getDomNode());
+                this.contentDisposables.add(scrollableContent);
+            }
+            return content;
+        }, () => {
+            if (token.isCancellationRequested) {
+                return null;
+            }
+            append(content, $('p.nocontent')).textContent = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'noContributions',
+                "No Contributions"
+            ));
+            append(template.content, content);
+            return content;
+        });
+    }
+    openExtensionDependencies(extension, template, token) {
+        if (token.isCancellationRequested) {
+            return Promise.resolve(null);
+        }
+        if (arrays.isFalsyOrEmpty(extension.dependencies)) {
+            append(template.content, $('p.nocontent')).textContent = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'noDependencies',
+                "No Dependencies"
+            ));
+            return Promise.resolve(template.content);
+        }
+        const content = $('div', { class: 'subcontent' });
+        const scrollableContent = ( new DomScrollableElement(content, {}));
+        append(template.content, scrollableContent.getDomNode());
+        this.contentDisposables.add(scrollableContent);
+        const dependenciesTree = this.instantiationService.createInstance(ExtensionsTree, ( new ExtensionData(
+            extension,
+            null,
+            extension => extension.dependencies || [],
+            this.extensionsWorkbenchService
+        )), content, {
+            listBackground: editorBackground
+        });
+        const layout = () => {
+            scrollableContent.scanDomNode();
+            const scrollDimensions = scrollableContent.getScrollDimensions();
+            dependenciesTree.layout(scrollDimensions.height);
+        };
+        const removeLayoutParticipant = arrays.insert(this.layoutParticipants, { layout });
+        this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+        this.contentDisposables.add(dependenciesTree);
+        scrollableContent.scanDomNode();
+        return Promise.resolve({ focus() { dependenciesTree.domFocus(); } });
+    }
+    async openExtensionPack(extension, template, token) {
+        if (token.isCancellationRequested) {
+            return Promise.resolve(null);
+        }
+        const manifest = await this.loadContents(() => this.extensionManifest.get(), template.content);
+        if (token.isCancellationRequested) {
+            return null;
+        }
+        if (!manifest) {
+            return null;
+        }
+        return this.renderExtensionPack(manifest, template.content, token);
+    }
+    async openRuntimeStatus(extension, template, token) {
+        const content = $('div', { class: 'subcontent', tabindex: '0' });
+        const scrollableContent = ( new DomScrollableElement(content, {}));
+        const layout = () => scrollableContent.scanDomNode();
+        const removeLayoutParticipant = arrays.insert(this.layoutParticipants, { layout });
+        this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+        const updateContent = () => {
+            scrollableContent.scanDomNode();
+            reset(content, this.renderRuntimeStatus(extension, layout));
+        };
+        updateContent();
+        this.extensionService.onDidChangeExtensionsStatus(e => {
+            if (( e.some(
+                extensionIdentifier => areSameExtensions({ id: extensionIdentifier.value }, extension.identifier)
+            ))) {
+                updateContent();
+            }
+        }, this, this.contentDisposables);
+        this.contentDisposables.add(scrollableContent);
+        append(template.content, scrollableContent.getDomNode());
+        return content;
+    }
+    renderRuntimeStatus(extension, onDetailsToggle) {
+        const extensionStatus = this.extensionsWorkbenchService.getExtensionStatus(extension);
+        const element = $('.runtime-status');
+        if (extensionStatus?.activationTimes) {
+            const activationTime = extensionStatus.activationTimes.codeLoadingTime + extensionStatus.activationTimes.activateCallTime;
+            const activationElement = append(element, $('div.activation-details'));
+            const activationReasonElement = append(activationElement, $('div.activation-element-entry'));
+            append(activationReasonElement, $('span.activation-message-title', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'activation reason',
+                "Activation Event:"
+            ))));
+            append(activationReasonElement, $('code', undefined, extensionStatus.activationTimes.activationReason.startup ? ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'startup',
+                "Startup"
+            )) : extensionStatus.activationTimes.activationReason.activationEvent));
+            const activationTimeElement = append(activationElement, $('div.activation-element-entry'));
+            append(activationTimeElement, $('span.activation-message-title', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'activation time',
+                "Activation Time:"
+            ))));
+            append(activationTimeElement, $('code', undefined, `${activationTime}ms`));
+            if (ExtensionIdentifier.toKey(extensionStatus.activationTimes.activationReason.extensionId) !== ExtensionIdentifier.toKey(extension.identifier.id)) {
+                const activatedByElement = append(activationElement, $('div.activation-element-entry'));
+                append(activatedByElement, $('span.activation-message-title', undefined, ( localizeWithPath(
+                    'vs/workbench/contrib/extensions/browser/extensionEditor',
+                    'activatedBy',
+                    "Activated By:"
+                ))));
+                append(activatedByElement, $('span', undefined, extensionStatus.activationTimes.activationReason.extensionId.value));
+            }
+        }
+        else if (extension.local && (extension.local.manifest.main || extension.local.manifest.browser)) {
+            append(element, $('div.activation-message', undefined, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'not yet activated',
+                "Not yet activated."
+            ))));
+        }
+        if (extensionStatus?.runtimeErrors.length) {
+            append(element, $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'uncaught errors',
+                "Uncaught Errors ({0})",
+                extensionStatus.runtimeErrors.length
+            ))), $('div', undefined, ...( extensionStatus.runtimeErrors.map(
+                error => $('div.message-entry', undefined, $(`span${ThemeIcon.asCSSSelector(errorIcon)}`, undefined), $('span', undefined, getErrorMessage(error)))
+            )))));
+        }
+        if (extensionStatus?.messages.length) {
+            append(element, $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'messages',
+                "Messages ({0})",
+                extensionStatus?.messages.length
+            ))), $('div', undefined, ...( extensionStatus.messages.sort((a, b) => b.type - a.type)
+                .map(
+                message => $('div.message-entry', undefined, $(`span${ThemeIcon.asCSSSelector(message.type === Severity.Error ? errorIcon : message.type === Severity.Warning ? warningIcon : infoIcon)}`, undefined), $('span', undefined, message.message))
+            )))));
+        }
+        if (element.children.length === 0) {
+            append(element, $('div.no-status-message')).textContent = ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'noStatus',
+                "No status available."
+            ));
+        }
+        return element;
+    }
+    async renderExtensionPack(manifest, parent, token) {
+        if (token.isCancellationRequested) {
+            return null;
+        }
+        const content = $('div', { class: 'subcontent' });
+        const scrollableContent = ( new DomScrollableElement(content, { useShadows: false }));
+        append(parent, scrollableContent.getDomNode());
+        const extensionsGridView = this.instantiationService.createInstance(ExtensionsGridView, content, ( new Delegate()));
+        const extensions = await getExtensions(manifest.extensionPack, this.extensionsWorkbenchService);
+        extensionsGridView.setExtensions(extensions);
+        scrollableContent.scanDomNode();
+        this.contentDisposables.add(scrollableContent);
+        this.contentDisposables.add(extensionsGridView);
+        this.contentDisposables.add(toDisposable(arrays.insert(this.layoutParticipants, { layout: () => scrollableContent.scanDomNode() })));
+        return content;
+    }
+    renderSettings(container, manifest, onDetailsToggle) {
+        const configuration = manifest.contributes?.configuration;
+        let properties = {};
+        if (Array.isArray(configuration)) {
+            configuration.forEach(config => {
+                properties = { ...properties, ...config.properties };
+            });
+        }
+        else if (configuration) {
+            properties = configuration.properties;
+        }
+        let contrib = properties ? ( Object.keys(properties)) : [];
+        contrib = contrib.filter(key => {
+            const config = properties[key];
+            return !config.deprecationMessage && !config.markdownDeprecationMessage;
+        });
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'settings',
+            "Settings ({0})",
+            contrib.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'setting name',
+            "ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'description',
+            "Description"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'default',
+            "Default"
+        )))), ...( contrib.map(key => {
+            let description = properties[key].description || '';
+            if (properties[key].markdownDescription) {
+                const { element, dispose } = renderMarkdown({ value: properties[key].markdownDescription }, { actionHandler: { callback: (content) => this.openerService.open(content).catch(onUnexpectedError), disposables: this.contentDisposables } });
+                description = element;
+                this.contentDisposables.add(toDisposable(dispose));
+            }
+            return $('tr', undefined, $('td', undefined, $('code', undefined, key)), $('td', undefined, description), $('td', undefined, $('code', undefined, `${isUndefined(properties[key].default) ? getDefaultValue(properties[key].type) : properties[key].default}`)));
+        }))));
+        append(container, details);
+        return true;
+    }
+    renderDebuggers(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.debuggers || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'debuggers',
+            "Debuggers ({0})",
+            contrib.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'debugger name',
+            "Name"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'debugger type',
+            "Type"
+        )))), ...( contrib.map(
+            d => $('tr', undefined, $('td', undefined, d.label), $('td', undefined, d.type))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderViewContainers(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.viewsContainers || {};
+        const viewContainers = ( Object.keys(contrib)).reduce((result, location) => {
+            const viewContainersForLocation = contrib[location];
+            result.push(...( viewContainersForLocation.map(viewContainer => ({ ...viewContainer, location }))));
+            return result;
+        }, []);
+        if (!viewContainers.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'viewContainers',
+            "View Containers ({0})",
+            viewContainers.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'view container id',
+            "ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'view container title',
+            "Title"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'view container location',
+            "Where"
+        )))), ...( viewContainers.map(
+            viewContainer => $('tr', undefined, $('td', undefined, viewContainer.id), $('td', undefined, viewContainer.title), $('td', undefined, viewContainer.location))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderViews(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.views || {};
+        const views = ( Object.keys(contrib)).reduce((result, location) => {
+            const viewsForLocation = contrib[location];
+            result.push(...( viewsForLocation.map(view => ({ ...view, location }))));
+            return result;
+        }, []);
+        if (!views.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'views',
+            "Views ({0})",
+            views.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath('vs/workbench/contrib/extensions/browser/extensionEditor', 'view id', "ID"))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'view name',
+            "Name"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'view location',
+            "Where"
+        )))), ...( views.map(
+            view => $('tr', undefined, $('td', undefined, view.id), $('td', undefined, view.name), $('td', undefined, view.location))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderLocalizations(container, manifest, onDetailsToggle) {
+        const localizations = manifest.contributes?.localizations || [];
+        if (!localizations.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'localizations',
+            "Localizations ({0})",
+            localizations.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'localizations language id',
+            "Language ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'localizations language name',
+            "Language Name"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'localizations localized language name',
+            "Language Name (Localized)"
+        )))), ...( localizations.map(
+            localization => $('tr', undefined, $('td', undefined, localization.languageId), $('td', undefined, localization.languageName || ''), $('td', undefined, localization.localizedLanguageName || ''))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderCustomEditors(container, manifest, onDetailsToggle) {
+        const webviewEditors = manifest.contributes?.customEditors || [];
+        if (!webviewEditors.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'customEditors',
+            "Custom Editors ({0})",
+            webviewEditors.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'customEditors view type',
+            "View Type"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'customEditors priority',
+            "Priority"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'customEditors filenamePattern',
+            "Filename Pattern"
+        )))), ...( webviewEditors.map(
+            webviewEditor => $('tr', undefined, $('td', undefined, webviewEditor.viewType), $('td', undefined, webviewEditor.priority), $('td', undefined, arrays.coalesce(( webviewEditor.selector.map(x => x.filenamePattern))).join(', ')))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderCodeActions(container, manifest, onDetailsToggle) {
+        const codeActions = manifest.contributes?.codeActions || [];
+        if (!codeActions.length) {
+            return false;
+        }
+        const flatActions = arrays.flatten(( codeActions.map(contribution => ( contribution.actions.map(action => ({ ...action, languages: contribution.languages }))))));
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'codeActions',
+            "Code Actions ({0})",
+            flatActions.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'codeActions.title',
+            "Title"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'codeActions.kind',
+            "Kind"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'codeActions.description',
+            "Description"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'codeActions.languages',
+            "Languages"
+        )))), ...( flatActions.map(
+            action => $('tr', undefined, $('td', undefined, action.title), $('td', undefined, $('code', undefined, action.kind)), $('td', undefined, action.description ?? ''), $('td', undefined, ...( action.languages.map(language => $('code', undefined, language)))))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderAuthentication(container, manifest, onDetailsToggle) {
+        const authentication = manifest.contributes?.authentication || [];
+        if (!authentication.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'authentication',
+            "Authentication ({0})",
+            authentication.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'authentication.label',
+            "Label"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'authentication.id',
+            "ID"
+        )))), ...( authentication.map(
+            action => $('tr', undefined, $('td', undefined, action.label), $('td', undefined, action.id))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderColorThemes(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.themes || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'colorThemes',
+            "Color Themes ({0})",
+            contrib.length
+        ))), $('ul', undefined, ...( contrib.map(theme => $('li', undefined, theme.label)))));
+        append(container, details);
+        return true;
+    }
+    renderIconThemes(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.iconThemes || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'iconThemes',
+            "File Icon Themes ({0})",
+            contrib.length
+        ))), $('ul', undefined, ...( contrib.map(theme => $('li', undefined, theme.label)))));
+        append(container, details);
+        return true;
+    }
+    renderProductIconThemes(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.productIconThemes || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'productThemes',
+            "Product Icon Themes ({0})",
+            contrib.length
+        ))), $('ul', undefined, ...( contrib.map(theme => $('li', undefined, theme.label)))));
+        append(container, details);
+        return true;
+    }
+    renderColors(container, manifest, onDetailsToggle) {
+        const colors = manifest.contributes?.colors || [];
+        if (!colors.length) {
+            return false;
+        }
+        function colorPreview(colorReference) {
+            const result = [];
+            if (colorReference && colorReference[0] === '#') {
+                const color = ( Color.fromHex(colorReference));
+                if (color) {
+                    result.push($('span', { class: 'colorBox', style: 'background-color: ' + Color.Format.CSS.format(color) }, ''));
+                }
+            }
+            result.push($('code', undefined, colorReference));
+            return result;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'colors',
+            "Colors ({0})",
+            colors.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath('vs/workbench/contrib/extensions/browser/extensionEditor', 'colorId', "ID"))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'description',
+            "Description"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'defaultDark',
+            "Dark Default"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'defaultLight',
+            "Light Default"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'defaultHC',
+            "High Contrast Default"
+        )))), ...( colors.map(
+            color => $('tr', undefined, $('td', undefined, $('code', undefined, color.id)), $('td', undefined, color.description), $('td', undefined, ...colorPreview(color.defaults.dark)), $('td', undefined, ...colorPreview(color.defaults.light)), $('td', undefined, ...colorPreview(color.defaults.highContrast)))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderJSONValidation(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.jsonValidation || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'JSON Validation',
+            "JSON Validation ({0})",
+            contrib.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'fileMatch',
+            "File Match"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'schema',
+            "Schema"
+        )))), ...( contrib.map(
+            v => $('tr', undefined, $('td', undefined, $('code', undefined, Array.isArray(v.fileMatch) ? v.fileMatch.join(', ') : v.fileMatch)), $('td', undefined, v.url))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderCommands(container, manifest, onDetailsToggle) {
+        const rawCommands = manifest.contributes?.commands || [];
+        const commands = ( rawCommands.map(c => ({
+            id: c.command,
+            title: c.title,
+            keybindings: [],
+            menus: []
+        })));
+        const byId = arrays.index(commands, c => c.id);
+        const menus = manifest.contributes?.menus || {};
+        for (const context in menus) {
+            for (const menu of menus[context]) {
+                if (menu.command) {
+                    let command = byId[menu.command];
+                    if (command) {
+                        command.menus.push(context);
+                    }
+                    else {
+                        command = { id: menu.command, title: '', keybindings: [], menus: [context] };
+                        byId[command.id] = command;
+                        commands.push(command);
+                    }
+                }
+            }
+        }
+        const rawKeybindings = manifest.contributes?.keybindings ? (Array.isArray(manifest.contributes.keybindings) ? manifest.contributes.keybindings : [manifest.contributes.keybindings]) : [];
+        rawKeybindings.forEach(rawKeybinding => {
+            const keybinding = this.resolveKeybinding(rawKeybinding);
+            if (!keybinding) {
+                return;
+            }
+            let command = byId[rawKeybinding.command];
+            if (command) {
+                command.keybindings.push(keybinding);
+            }
+            else {
+                command = { id: rawKeybinding.command, title: '', keybindings: [keybinding], menus: [] };
+                byId[command.id] = command;
+                commands.push(command);
+            }
+        });
+        if (!commands.length) {
+            return false;
+        }
+        const renderKeybinding = (keybinding) => {
+            const element = $('');
+            const kbl = ( new KeybindingLabel(element, OS, defaultKeybindingLabelStyles));
+            kbl.set(keybinding);
+            return element;
+        };
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'commands',
+            "Commands ({0})",
+            commands.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'command name',
+            "ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'command title',
+            "Title"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'keyboard shortcuts',
+            "Keyboard Shortcuts"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'menuContexts',
+            "Menu Contexts"
+        )))), ...( commands.map(
+            c => $('tr', undefined, $('td', undefined, $('code', undefined, c.id)), $('td', undefined, typeof c.title === 'string' ? c.title : c.title.value), $('td', undefined, ...( c.keybindings.map(keybinding => renderKeybinding(keybinding)))), $('td', undefined, ...( c.menus.map(context => $('code', undefined, context)))))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderLanguages(container, manifest, onDetailsToggle) {
+        const contributes = manifest.contributes;
+        const rawLanguages = contributes?.languages || [];
+        const languages = ( rawLanguages.map(l => ({
+            id: l.id,
+            name: (l.aliases || [])[0] || l.id,
+            extensions: l.extensions || [],
+            hasGrammar: false,
+            hasSnippets: false
+        })));
+        const byId = arrays.index(languages, l => l.id);
+        const grammars = contributes?.grammars || [];
+        grammars.forEach(grammar => {
+            let language = byId[grammar.language];
+            if (language) {
+                language.hasGrammar = true;
+            }
+            else {
+                language = { id: grammar.language, name: grammar.language, extensions: [], hasGrammar: true, hasSnippets: false };
+                byId[language.id] = language;
+                languages.push(language);
+            }
+        });
+        const snippets = contributes?.snippets || [];
+        snippets.forEach(snippet => {
+            let language = byId[snippet.language];
+            if (language) {
+                language.hasSnippets = true;
+            }
+            else {
+                language = { id: snippet.language, name: snippet.language, extensions: [], hasGrammar: false, hasSnippets: true };
+                byId[language.id] = language;
+                languages.push(language);
+            }
+        });
+        if (!languages.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'languages',
+            "Languages ({0})",
+            languages.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'language id',
+            "ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'language name',
+            "Name"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'file extensions',
+            "File Extensions"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'grammar',
+            "Grammar"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'snippets',
+            "Snippets"
+        )))), ...( languages.map(
+            l => $('tr', undefined, $('td', undefined, l.id), $('td', undefined, l.name), $('td', undefined, ...join(( l.extensions.map(ext => $('code', undefined, ext))), ' ')), $('td', undefined, document.createTextNode(l.hasGrammar ? '✔︎' : '\u2014')), $('td', undefined, document.createTextNode(l.hasSnippets ? '✔︎' : '\u2014')))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderActivationEvents(container, manifest, onDetailsToggle) {
+        const activationEvents = manifest.activationEvents || [];
+        if (!activationEvents.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'activation events',
+            "Activation Events ({0})",
+            activationEvents.length
+        ))), $('ul', undefined, ...( activationEvents.map(
+            activationEvent => $('li', undefined, $('code', undefined, activationEvent))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderNotebooks(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.notebooks || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Notebooks',
+            "Notebooks ({0})",
+            contrib.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Notebook id',
+            "ID"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Notebook name',
+            "Name"
+        )))), ...( contrib.map(
+            d => $('tr', undefined, $('td', undefined, d.type), $('td', undefined, d.displayName))
+        ))));
+        append(container, details);
+        return true;
+    }
+    renderNotebookRenderers(container, manifest, onDetailsToggle) {
+        const contrib = manifest.contributes?.notebookRenderer || [];
+        if (!contrib.length) {
+            return false;
+        }
+        const details = $('details', { open: true, ontoggle: onDetailsToggle }, $('summary', { tabindex: '0' }, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'NotebookRenderers',
+            "Notebook Renderers ({0})",
+            contrib.length
+        ))), $('table', undefined, $('tr', undefined, $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Notebook renderer name',
+            "Name"
+        ))), $('th', undefined, ( localizeWithPath(
+            'vs/workbench/contrib/extensions/browser/extensionEditor',
+            'Notebook mimetypes',
+            "Mimetypes"
+        )))), ...( contrib.map(
+            d => $('tr', undefined, $('td', undefined, d.displayName), $('td', undefined, d.mimeTypes.join(',')))
+        ))));
+        append(container, details);
+        return true;
+    }
+    resolveKeybinding(rawKeyBinding) {
+        let key;
+        switch (platform) {
+            case 'win32':
+                key = rawKeyBinding.win;
+                break;
+            case 'linux':
+                key = rawKeyBinding.linux;
+                break;
+            case 'darwin':
+                key = rawKeyBinding.mac;
+                break;
+        }
+        return this.keybindingService.resolveUserBinding(key || rawKeyBinding.key)[0];
+    }
+    loadContents(loadingTask, container) {
+        container.classList.add('loading');
+        const result = this.contentDisposables.add(loadingTask());
+        const onDone = () => container.classList.remove('loading');
+        result.promise.then(onDone, onDone);
+        return result.promise;
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        this.layoutParticipants.forEach(p => p.layout());
+    }
+    onError(err) {
+        if (isCancellationError(err)) {
+            return;
+        }
+        this.notificationService.error(err);
+    }
+};
+ExtensionEditor = ExtensionEditor_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IPaneCompositePartService)),
+    ( __param(3, IExtensionsWorkbenchService)),
+    ( __param(4, IExtensionGalleryService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IExtensionRecommendationsService)),
+    ( __param(10, IStorageService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, IWebviewService)),
+    ( __param(13, ILanguageService)),
+    ( __param(14, IContextMenuService)),
+    ( __param(15, IContextKeyService))
+], ExtensionEditor));
+const contextKeyExpr = ( ContextKeyExpr.and(( ContextKeyExpr.equals('activeEditor', ExtensionEditor.ID)), ( EditorContextKeys.focus.toNegated())));
+registerAction2(class ShowExtensionEditorFindAction extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.action.extensioneditor.showfind',
+            title: ( localizeWithPath('vs/workbench/contrib/extensions/browser/extensionEditor', 'find', "Find")),
+            keybinding: {
+                when: contextKeyExpr,
+                weight: 100 ,
+                primary: 2048  | 36 ,
+            }
+        });
+    }
+    run(accessor) {
+        const extensionEditor = getExtensionEditor(accessor);
+        extensionEditor?.showFind();
+    }
+});
+registerAction2(class StartExtensionEditorFindNextAction extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.action.extensioneditor.findNext',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'find next',
+                "Find Next"
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(contextKeyExpr, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED)),
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        const extensionEditor = getExtensionEditor(accessor);
+        extensionEditor?.runFindAction(false);
+    }
+});
+registerAction2(class StartExtensionEditorFindPreviousAction extends Action2 {
+    constructor() {
+        super({
+            id: 'editor.action.extensioneditor.findPrevious',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/extensions/browser/extensionEditor',
+                'find previous',
+                "Find Previous"
+            )),
+            keybinding: {
+                when: ( ContextKeyExpr.and(contextKeyExpr, KEYBINDING_CONTEXT_WEBVIEW_FIND_WIDGET_FOCUSED)),
+                primary: 1024  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    run(accessor) {
+        const extensionEditor = getExtensionEditor(accessor);
+        extensionEditor?.runFindAction(true);
+    }
+});
+registerThemingParticipant((theme, collector) => {
+    const link = theme.getColor(textLinkForeground);
+    if (link) {
+        collector.addRule(`.monaco-workbench .extension-editor .content .details .additional-details-container .resources-container a.resource { color: ${link}; }`);
+        collector.addRule(`.monaco-workbench .extension-editor .content .feature-contributions a { color: ${link}; }`);
+    }
+    const activeLink = theme.getColor(textLinkActiveForeground);
+    if (activeLink) {
+        collector.addRule(`.monaco-workbench .extension-editor .content .details .additional-details-container .resources-container a.resource:hover,
+			.monaco-workbench .extension-editor .content .details .additional-details-container .resources-container a.resource:active { color: ${activeLink}; }`);
+        collector.addRule(`.monaco-workbench .extension-editor .content .feature-contributions a:hover,
+			.monaco-workbench .extension-editor .content .feature-contributions a:active { color: ${activeLink}; }`);
+    }
+    const buttonHoverBackgroundColor = theme.getColor(buttonHoverBackground);
+    if (buttonHoverBackgroundColor) {
+        collector.addRule(`.monaco-workbench .extension-editor .content > .details > .additional-details-container .categories-container > .categories > .category:hover { background-color: ${buttonHoverBackgroundColor}; border-color: ${buttonHoverBackgroundColor}; }`);
+        collector.addRule(`.monaco-workbench .extension-editor .content > .details > .additional-details-container .tags-container > .tags > .tag:hover { background-color: ${buttonHoverBackgroundColor}; border-color: ${buttonHoverBackgroundColor}; }`);
+    }
+    const buttonForegroundColor = theme.getColor(buttonForeground);
+    if (buttonForegroundColor) {
+        collector.addRule(`.monaco-workbench .extension-editor .content > .details > .additional-details-container .categories-container > .categories > .category:hover { color: ${buttonForegroundColor}; }`);
+        collector.addRule(`.monaco-workbench .extension-editor .content > .details > .additional-details-container .tags-container > .tags > .tag:hover { color: ${buttonForegroundColor}; }`);
+    }
+});
+function getExtensionEditor(accessor) {
+    const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+    if (activeEditorPane instanceof ExtensionEditor) {
+        return activeEditorPane;
+    }
+    return null;
+}
+
+export { ExtensionEditor };