@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditors.js

@@ -0,0 +1,215 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/customEditor.css.js';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { extname, isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { UndoCommand, RedoCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION } from 'vscode/vscode/vs/workbench/common/editor';
+import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
+import { CONTEXT_ACTIVE_CUSTOM_EDITOR_ID, CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE, CustomEditorInfoCollection } from '../common/customEditor.js';
+import { CustomEditorModelManager } from '../common/customEditorModelManager.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ContributedCustomEditors } from '../common/contributedCustomEditors.js';
+import { CustomEditorInput } from 'vscode/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
+
+let CustomEditorService = class CustomEditorService extends Disposable {
+    constructor(contextKeyService, fileService, storageService, editorService, editorGroupService, instantiationService, uriIdentityService, editorResolverService) {
+        super();
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.instantiationService = instantiationService;
+        this.uriIdentityService = uriIdentityService;
+        this.editorResolverService = editorResolverService;
+        this._untitledCounter = 0;
+        this._editorResolverDisposables = this._register(( new DisposableStore()));
+        this._editorCapabilities = ( new Map());
+        this._models = ( new CustomEditorModelManager());
+        this._onDidChangeEditorTypes = this._register(( new Emitter()));
+        this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
+        this._fileEditorFactory = ( Registry.as(EditorExtensions.EditorFactory)).getFileEditorFactory();
+        this._activeCustomEditorId = CONTEXT_ACTIVE_CUSTOM_EDITOR_ID.bindTo(contextKeyService);
+        this._focusedCustomEditorIsEditable = CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE.bindTo(contextKeyService);
+        this._contributedEditors = this._register(( new ContributedCustomEditors(storageService)));
+        this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
+        this._register(this._contributedEditors.onChange(() => {
+            this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
+            this.updateContexts();
+            this._onDidChangeEditorTypes.fire();
+        }));
+        this._register(this.editorService.onDidActiveEditorChange(() => this.updateContexts()));
+        this._register(fileService.onDidRunOperation(e => {
+            if (e.isOperation(2 )) {
+                this.handleMovedFileInOpenedFileEditors(e.resource, this.uriIdentityService.asCanonicalUri(e.target.resource));
+            }
+        }));
+        const PRIORITY = 105;
+        this._register(UndoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
+            return this.withActiveCustomEditor(editor => editor.undo());
+        }));
+        this._register(RedoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
+            return this.withActiveCustomEditor(editor => editor.redo());
+        }));
+        this.updateContexts();
+    }
+    getEditorTypes() {
+        return [...this._contributedEditors];
+    }
+    withActiveCustomEditor(f) {
+        const activeEditor = this.editorService.activeEditor;
+        if (activeEditor instanceof CustomEditorInput) {
+            const result = f(activeEditor);
+            if (result) {
+                return result;
+            }
+            return true;
+        }
+        return false;
+    }
+    registerContributionPoints() {
+        this._editorResolverDisposables.clear();
+        for (const contributedEditor of this._contributedEditors) {
+            for (const globPattern of contributedEditor.selector) {
+                if (!globPattern.filenamePattern) {
+                    continue;
+                }
+                this._editorResolverDisposables.add(this.editorResolverService.registerEditor(globPattern.filenamePattern, {
+                    id: contributedEditor.id,
+                    label: contributedEditor.displayName,
+                    detail: contributedEditor.providerDisplayName,
+                    priority: contributedEditor.priority,
+                }, {
+                    singlePerResource: () => !this.getCustomEditorCapabilities(contributedEditor.id)?.supportsMultipleEditorsPerDocument ?? true
+                }, {
+                    createEditorInput: ({ resource }, group) => {
+                        return { editor: CustomEditorInput.create(this.instantiationService, resource, contributedEditor.id, group.id) };
+                    },
+                    createUntitledEditorInput: ({ resource }, group) => {
+                        return { editor: CustomEditorInput.create(this.instantiationService, resource ?? ( URI.from(
+                            { scheme: Schemas.untitled, authority: `Untitled-${this._untitledCounter++}` }
+                        )), contributedEditor.id, group.id) };
+                    },
+                    createDiffEditorInput: (diffEditorInput, group) => {
+                        return { editor: this.createDiffEditorInput(diffEditorInput, contributedEditor.id, group) };
+                    },
+                }));
+            }
+        }
+    }
+    createDiffEditorInput(editor, editorID, group) {
+        const modifiedOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.modified.resource), editorID, group.id, { customClasses: 'modified' });
+        const originalOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.original.resource), editorID, group.id, { customClasses: 'original' });
+        return this.instantiationService.createInstance(DiffEditorInput, editor.label, editor.description, originalOverride, modifiedOverride, true);
+    }
+    get models() { return this._models; }
+    getCustomEditor(viewType) {
+        return this._contributedEditors.get(viewType);
+    }
+    getContributedCustomEditors(resource) {
+        return ( new CustomEditorInfoCollection(this._contributedEditors.getContributedEditors(resource)));
+    }
+    getUserConfiguredCustomEditors(resource) {
+        const resourceAssocations = this.editorResolverService.getAssociationsForResource(resource);
+        return ( new CustomEditorInfoCollection(coalesce(( resourceAssocations
+            .map(association => this._contributedEditors.get(association.viewType))))));
+    }
+    getAllCustomEditors(resource) {
+        return ( new CustomEditorInfoCollection([
+            ...this.getUserConfiguredCustomEditors(resource).allEditors,
+            ...this.getContributedCustomEditors(resource).allEditors,
+        ]));
+    }
+    registerCustomEditorCapabilities(viewType, options) {
+        if (( this._editorCapabilities.has(viewType))) {
+            throw new Error(`Capabilities for ${viewType} already set`);
+        }
+        this._editorCapabilities.set(viewType, options);
+        return toDisposable(() => {
+            this._editorCapabilities.delete(viewType);
+        });
+    }
+    getCustomEditorCapabilities(viewType) {
+        return this._editorCapabilities.get(viewType);
+    }
+    updateContexts() {
+        const activeEditorPane = this.editorService.activeEditorPane;
+        const resource = activeEditorPane?.input?.resource;
+        if (!resource) {
+            this._activeCustomEditorId.reset();
+            this._focusedCustomEditorIsEditable.reset();
+            return;
+        }
+        this._activeCustomEditorId.set(activeEditorPane?.input instanceof CustomEditorInput ? activeEditorPane.input.viewType : '');
+        this._focusedCustomEditorIsEditable.set(activeEditorPane?.input instanceof CustomEditorInput);
+    }
+    async handleMovedFileInOpenedFileEditors(oldResource, newResource) {
+        if (extname(oldResource).toLowerCase() === extname(newResource).toLowerCase()) {
+            return;
+        }
+        const possibleEditors = this.getAllCustomEditors(newResource);
+        if (!( possibleEditors.allEditors.some(editor => editor.priority !== RegisteredEditorPriority.option))) {
+            return;
+        }
+        const editorsToReplace = ( new Map());
+        for (const group of this.editorGroupService.groups) {
+            for (const editor of group.editors) {
+                if (this._fileEditorFactory.isFileEditor(editor)
+                    && !(editor instanceof CustomEditorInput)
+                    && isEqual(editor.resource, newResource)) {
+                    let entry = editorsToReplace.get(group.id);
+                    if (!entry) {
+                        entry = [];
+                        editorsToReplace.set(group.id, entry);
+                    }
+                    entry.push(editor);
+                }
+            }
+        }
+        if (!editorsToReplace.size) {
+            return;
+        }
+        for (const [group, entries] of editorsToReplace) {
+            this.editorService.replaceEditors(( entries.map(editor => {
+                let replacement;
+                if (possibleEditors.defaultEditor) {
+                    const viewType = possibleEditors.defaultEditor.id;
+                    replacement = CustomEditorInput.create(this.instantiationService, newResource, viewType, group);
+                }
+                else {
+                    replacement = { resource: newResource, options: { override: DEFAULT_EDITOR_ASSOCIATION.id } };
+                }
+                return {
+                    editor,
+                    replacement,
+                    options: {
+                        preserveFocus: true,
+                    }
+                };
+            })), group);
+        }
+    }
+};
+CustomEditorService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IEditorResolverService))
+], CustomEditorService));
+
+export { CustomEditorService };

package/vscode/src/vs/workbench/contrib/customEditor/browser/media/customEditor.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".webview.modified{box-shadow:-6px 0 5px -5px var(--vscode-scrollbar-shadow)}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/customEditor/common/contributedCustomEditors.js

@@ -0,0 +1,78 @@
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { CustomEditorInfo } from './customEditor.js';
+import { customEditorsExtensionPoint } from './extensionPoint.js';
+import { RegisteredEditorPriority } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+
+class ContributedCustomEditors extends Disposable {
+    static { this.CUSTOM_EDITORS_STORAGE_ID = 'customEditors'; }
+    static { this.CUSTOM_EDITORS_ENTRY_ID = 'editors'; }
+    constructor(storageService) {
+        super();
+        this._editors = ( new Map());
+        this._onChange = this._register(( new Emitter()));
+        this.onChange = this._onChange.event;
+        this._memento = ( new Memento(ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID, storageService));
+        const mementoObject = this._memento.getMemento(0 , 1 );
+        for (const info of (mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] || [])) {
+            this.add(( new CustomEditorInfo(info)));
+        }
+        customEditorsExtensionPoint.setHandler(extensions => {
+            this.update(extensions);
+        });
+    }
+    update(extensions) {
+        this._editors.clear();
+        for (const extension of extensions) {
+            for (const webviewEditorContribution of extension.value) {
+                this.add(( new CustomEditorInfo({
+                    id: webviewEditorContribution.viewType,
+                    displayName: webviewEditorContribution.displayName,
+                    providerDisplayName: extension.description.isBuiltin ? ( localizeWithPath(
+                        'vs/workbench/contrib/customEditor/common/contributedCustomEditors',
+                        'builtinProviderDisplayName',
+                        "Built-in"
+                    )) : extension.description.displayName || extension.description.identifier.value,
+                    selector: webviewEditorContribution.selector || [],
+                    priority: getPriorityFromContribution(webviewEditorContribution, extension.description),
+                })));
+            }
+        }
+        const mementoObject = this._memento.getMemento(0 , 1 );
+        mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._editors.values()));
+        this._memento.saveMemento();
+        this._onChange.fire();
+    }
+    [Symbol.iterator]() {
+        return ( this._editors.values());
+    }
+    get(viewType) {
+        return this._editors.get(viewType);
+    }
+    getContributedEditors(resource) {
+        return Array.from(( this._editors.values()))
+            .filter(customEditor => customEditor.matches(resource));
+    }
+    add(info) {
+        if (( this._editors.has(info.id))) {
+            console.error(`Custom editor with id '${info.id}' already registered`);
+            return;
+        }
+        this._editors.set(info.id, info);
+    }
+}
+function getPriorityFromContribution(contribution, extension) {
+    switch (contribution.priority) {
+        case RegisteredEditorPriority.default:
+        case RegisteredEditorPriority.option:
+            return contribution.priority;
+        case RegisteredEditorPriority.builtin:
+            return extension.isBuiltin ? RegisteredEditorPriority.builtin : RegisteredEditorPriority.default;
+        default:
+            return RegisteredEditorPriority.default;
+    }
+}
+
+export { ContributedCustomEditors };

package/vscode/src/vs/workbench/contrib/customEditor/common/customEditor.js

@@ -0,0 +1,56 @@
+import { distinct } from 'vscode/vscode/vs/base/common/arrays';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { RawContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { globMatchesResource, RegisteredEditorPriority, priorityToRank } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+
+const CONTEXT_ACTIVE_CUSTOM_EDITOR_ID = ( new RawContextKey('activeCustomEditorId', '', {
+    type: 'string',
+    description: ( localizeWithPath(
+        'vs/workbench/contrib/customEditor/common/customEditor',
+        'context.customEditor',
+        "The viewType of the currently active custom editor."
+    )),
+}));
+const CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE = ( new RawContextKey('focusedCustomEditorIsEditable', false));
+class CustomEditorInfo {
+    constructor(descriptor) {
+        this.id = descriptor.id;
+        this.displayName = descriptor.displayName;
+        this.providerDisplayName = descriptor.providerDisplayName;
+        this.priority = descriptor.priority;
+        this.selector = descriptor.selector;
+    }
+    matches(resource) {
+        return ( this.selector.some(
+            selector => selector.filenamePattern && globMatchesResource(selector.filenamePattern, resource)
+        ));
+    }
+}
+class CustomEditorInfoCollection {
+    constructor(editors) {
+        this.allEditors = distinct(editors, editor => editor.id);
+    }
+    get length() { return this.allEditors.length; }
+    get defaultEditor() {
+        return this.allEditors.find(editor => {
+            switch (editor.priority) {
+                case RegisteredEditorPriority.default:
+                case RegisteredEditorPriority.builtin:
+                    return this.allEditors.every(otherEditor => otherEditor === editor || isLowerPriority(otherEditor, editor));
+                default:
+                    return false;
+            }
+        });
+    }
+    get bestAvailableEditor() {
+        const editors = Array.from(this.allEditors).sort((a, b) => {
+            return priorityToRank(a.priority) - priorityToRank(b.priority);
+        });
+        return editors[0];
+    }
+}
+function isLowerPriority(otherEditor, editor) {
+    return priorityToRank(otherEditor.priority) < priorityToRank(editor.priority);
+}
+
+export { CONTEXT_ACTIVE_CUSTOM_EDITOR_ID, CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE, CustomEditorInfo, CustomEditorInfoCollection };

package/vscode/src/vs/workbench/contrib/customEditor/common/customEditorModelManager.js

@@ -0,0 +1,63 @@
+import { createSingleCallFunction } from 'vscode/vscode/vs/base/common/functional';
+
+class CustomEditorModelManager {
+    constructor() {
+        this._references = ( new Map());
+    }
+    async getAllModels(resource) {
+        const keyStart = `${( resource.toString())}@@@`;
+        const models = [];
+        for (const [key, entry] of this._references) {
+            if (key.startsWith(keyStart) && entry.model) {
+                models.push(await entry.model);
+            }
+        }
+        return models;
+    }
+    async get(resource, viewType) {
+        const key = this.key(resource, viewType);
+        const entry = this._references.get(key);
+        return entry?.model;
+    }
+    tryRetain(resource, viewType) {
+        const key = this.key(resource, viewType);
+        const entry = this._references.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        entry.counter++;
+        return entry.model.then(model => {
+            return {
+                object: model,
+                dispose: createSingleCallFunction(() => {
+                    if (--entry.counter <= 0) {
+                        entry.model.then(x => x.dispose());
+                        this._references.delete(key);
+                    }
+                }),
+            };
+        });
+    }
+    add(resource, viewType, model) {
+        const key = this.key(resource, viewType);
+        const existing = this._references.get(key);
+        if (existing) {
+            throw new Error('Model already exists');
+        }
+        this._references.set(key, { viewType, model, counter: 0 });
+        return this.tryRetain(resource, viewType);
+    }
+    disposeAllModelsForView(viewType) {
+        for (const [key, value] of this._references) {
+            if (value.viewType === viewType) {
+                value.model.then(x => x.dispose());
+                this._references.delete(key);
+            }
+        }
+    }
+    key(resource, viewType) {
+        return `${( resource.toString())}@@@${viewType}`;
+    }
+}
+
+export { CustomEditorModelManager };

package/vscode/src/vs/workbench/contrib/customEditor/common/extensionPoint.js

@@ -0,0 +1,183 @@
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { languagesExtPoint } from 'vscode/vscode/vs/workbench/services/language/common/languageService';
+
+const Fields = ( Object.freeze({
+    viewType: 'viewType',
+    displayName: 'displayName',
+    selector: 'selector',
+    priority: 'priority',
+}));
+const CustomEditorsContribution = {
+    description: ( localizeWithPath(
+        'vs/workbench/contrib/customEditor/common/extensionPoint',
+        'contributes.customEditors',
+        'Contributed custom editors.'
+    )),
+    type: 'array',
+    defaultSnippets: [{
+            body: [{
+                    [Fields.viewType]: '$1',
+                    [Fields.displayName]: '$2',
+                    [Fields.selector]: [{
+                            filenamePattern: '$3'
+                        }],
+                }]
+        }],
+    items: {
+        type: 'object',
+        required: [
+            Fields.viewType,
+            Fields.displayName,
+            Fields.selector,
+        ],
+        properties: {
+            [Fields.viewType]: {
+                type: 'string',
+                markdownDescription: ( localizeWithPath(
+                    'vs/workbench/contrib/customEditor/common/extensionPoint',
+                    'contributes.viewType',
+                    'Identifier for the custom editor. This must be unique across all custom editors, so we recommend including your extension id as part of `viewType`. The `viewType` is used when registering custom editors with `vscode.registerCustomEditorProvider` and in the `onCustomEditor:${id}` [activation event](https://code.visualstudio.com/api/references/activation-events).'
+                )),
+            },
+            [Fields.displayName]: {
+                type: 'string',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/customEditor/common/extensionPoint',
+                    'contributes.displayName',
+                    'Human readable name of the custom editor. This is displayed to users when selecting which editor to use.'
+                )),
+            },
+            [Fields.selector]: {
+                type: 'array',
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/customEditor/common/extensionPoint',
+                    'contributes.selector',
+                    'Set of globs that the custom editor is enabled for.'
+                )),
+                items: {
+                    type: 'object',
+                    defaultSnippets: [{
+                            body: {
+                                filenamePattern: '$1',
+                            }
+                        }],
+                    properties: {
+                        filenamePattern: {
+                            type: 'string',
+                            description: ( localizeWithPath(
+                                'vs/workbench/contrib/customEditor/common/extensionPoint',
+                                'contributes.selector.filenamePattern',
+                                'Glob that the custom editor is enabled for.'
+                            )),
+                        },
+                    }
+                }
+            },
+            [Fields.priority]: {
+                type: 'string',
+                markdownDeprecationMessage: ( localizeWithPath(
+                    'vs/workbench/contrib/customEditor/common/extensionPoint',
+                    'contributes.priority',
+                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
+                )),
+                enum: [
+                    "default" ,
+                    "option" ,
+                ],
+                markdownEnumDescriptions: [
+                    ( localizeWithPath(
+                        'vs/workbench/contrib/customEditor/common/extensionPoint',
+                        'contributes.priority.default',
+                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
+                    )),
+                    ( localizeWithPath(
+                        'vs/workbench/contrib/customEditor/common/extensionPoint',
+                        'contributes.priority.option',
+                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
+                    )),
+                ],
+                default: 'default'
+            }
+        }
+    }
+};
+const customEditorsExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'customEditors',
+    deps: [languagesExtPoint],
+    jsonSchema: CustomEditorsContribution,
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            const viewType = contrib[Fields.viewType];
+            if (viewType) {
+                result.push(`onCustomEditor:${viewType}`);
+            }
+        }
+    },
+});
+class CustomEditorsDataRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 'table';
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.customEditors;
+    }
+    render(manifest) {
+        const customEditors = manifest.contributes?.customEditors || [];
+        if (!customEditors.length) {
+            return { data: { headers: [], rows: [] }, dispose: () => { } };
+        }
+        const headers = [
+            ( localizeWithPath(
+                'vs/workbench/contrib/customEditor/common/extensionPoint',
+                'customEditors view type',
+                "View Type"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/contrib/customEditor/common/extensionPoint',
+                'customEditors priority',
+                "Priority"
+            )),
+            ( localizeWithPath(
+                'vs/workbench/contrib/customEditor/common/extensionPoint',
+                'customEditors filenamePattern',
+                "Filename Pattern"
+            )),
+        ];
+        const rows = ( customEditors
+            .map(customEditor => {
+            return [
+                customEditor.viewType,
+                customEditor.priority ?? '',
+                coalesce(( customEditor.selector.map(x => x.filenamePattern))).join(', ')
+            ];
+        }));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => { }
+        };
+    }
+}
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'customEditors',
+    label: ( localizeWithPath(
+        'vs/workbench/contrib/customEditor/common/extensionPoint',
+        'customEditors',
+        "Custom Editors"
+    )),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(CustomEditorsDataRenderer)),
+});
+
+export { customEditorsExtensionPoint };

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/externalUriOpener.contribution.js

@@ -0,0 +1,8 @@
+import { Extensions } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { externalUriOpenersConfigurationNode } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
+import 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+
+( Registry.as(Extensions.Configuration))
+    .registerConfiguration(externalUriOpenersConfigurationNode);