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

package/vscode/src/vs/workbench/contrib/preferences/browser/keyboardLayoutPicker.js

@@ -0,0 +1,195 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { parseKeyboardLayoutDescription, areKeyboardLayoutsEqual, getKeyboardLayoutId } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
+import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout.service';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { KEYBOARD_LAYOUT_OPEN_PICKER } from 'vscode/vscode/vs/workbench/contrib/preferences/common/preferences';
+import { isMacintosh, isWindows } from 'vscode/vscode/vs/base/common/platform';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+
+let KeyboardLayoutPickerContribution = class KeyboardLayoutPickerContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.keyboardLayoutPicker'; }
+    constructor(keyboardLayoutService, statusbarService) {
+        super();
+        this.keyboardLayoutService = keyboardLayoutService;
+        this.statusbarService = statusbarService;
+        this.pickerElement = this._register(( new MutableDisposable()));
+        const name = ( localizeWithPath(
+            'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+            'status.workbench.keyboardLayout',
+            "Keyboard Layout"
+        ));
+        const layout = this.keyboardLayoutService.getCurrentKeyboardLayout();
+        if (layout) {
+            const layoutInfo = parseKeyboardLayoutDescription(layout);
+            const text = ( localizeWithPath(
+                'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                'keyboardLayout',
+                "Layout: {0}",
+                layoutInfo.label
+            ));
+            this.pickerElement.value = this.statusbarService.addEntry({
+                name,
+                text,
+                ariaLabel: text,
+                command: KEYBOARD_LAYOUT_OPEN_PICKER
+            }, 'status.workbench.keyboardLayout', 1 );
+        }
+        this._register(this.keyboardLayoutService.onDidChangeKeyboardLayout(() => {
+            const layout = this.keyboardLayoutService.getCurrentKeyboardLayout();
+            const layoutInfo = parseKeyboardLayoutDescription(layout);
+            if (this.pickerElement.value) {
+                const text = ( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                    'keyboardLayout',
+                    "Layout: {0}",
+                    layoutInfo.label
+                ));
+                this.pickerElement.value.update({
+                    name,
+                    text,
+                    ariaLabel: text,
+                    command: KEYBOARD_LAYOUT_OPEN_PICKER
+                });
+            }
+            else {
+                const text = ( localizeWithPath(
+                    'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                    'keyboardLayout',
+                    "Layout: {0}",
+                    layoutInfo.label
+                ));
+                this.pickerElement.value = this.statusbarService.addEntry({
+                    name,
+                    text,
+                    ariaLabel: text,
+                    command: KEYBOARD_LAYOUT_OPEN_PICKER
+                }, 'status.workbench.keyboardLayout', 1 );
+            }
+        }));
+    }
+};
+KeyboardLayoutPickerContribution = ( __decorate([
+    ( __param(0, IKeyboardLayoutService)),
+    ( __param(1, IStatusbarService))
+], KeyboardLayoutPickerContribution));
+registerWorkbenchContribution2(KeyboardLayoutPickerContribution.ID, KeyboardLayoutPickerContribution, 1 );
+const DEFAULT_CONTENT = [
+    `// ${( localizeWithPath(
+        'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+        'displayLanguage',
+        'Defines the keyboard layout used in VS Code in the browser environment.'
+    ))}`,
+    `// ${( localizeWithPath(
+        'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+        'doc',
+        'Open VS Code and run "Developer: Inspect Key Mappings (JSON)" from Command Palette.'
+    ))}`,
+    ``,
+    `// Once you have the keyboard layout info, please paste it below.`,
+    '\n'
+].join('\n');
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: KEYBOARD_LAYOUT_OPEN_PICKER,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                'keyboard.chooseLayout',
+                "Change Keyboard Layout"
+            )),
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const keyboardLayoutService = accessor.get(IKeyboardLayoutService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const configurationService = accessor.get(IConfigurationService);
+        const environmentService = accessor.get(IEnvironmentService);
+        const editorService = accessor.get(IEditorService);
+        const fileService = accessor.get(IFileService);
+        const layouts = keyboardLayoutService.getAllKeyboardLayouts();
+        const currentLayout = keyboardLayoutService.getCurrentKeyboardLayout();
+        const layoutConfig = configurationService.getValue('keyboard.layout');
+        const isAutoDetect = layoutConfig === 'autodetect';
+        const picks = ( layouts.map(layout => {
+            const picked = !isAutoDetect && areKeyboardLayoutsEqual(currentLayout, layout);
+            const layoutInfo = parseKeyboardLayoutDescription(layout);
+            return {
+                layout: layout,
+                label: [layoutInfo.label, (layout && layout.isUserKeyboardLayout) ? '(User configured layout)' : ''].join(' '),
+                id: layout.text || layout.lang || layout.layout,
+                description: layoutInfo.description + (picked ? ' (Current layout)' : ''),
+                picked: !isAutoDetect && areKeyboardLayoutsEqual(currentLayout, layout)
+            };
+        })).sort((a, b) => {
+            return a.label < b.label ? -1 : (a.label > b.label ? 1 : 0);
+        });
+        if (picks.length > 0) {
+            const platform = isMacintosh ? 'Mac' : isWindows ? 'Win' : 'Linux';
+            picks.unshift({ type: 'separator', label: ( localizeWithPath(
+                'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                'layoutPicks',
+                "Keyboard Layouts ({0})",
+                platform
+            )) });
+        }
+        const configureKeyboardLayout = { label: ( localizeWithPath(
+            'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+            'configureKeyboardLayout',
+            "Configure Keyboard Layout"
+        )) };
+        picks.unshift(configureKeyboardLayout);
+        const autoDetectMode = {
+            label: ( localizeWithPath(
+                'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+                'autoDetect',
+                "Auto Detect"
+            )),
+            description: isAutoDetect ? `Current: ${parseKeyboardLayoutDescription(currentLayout).label}` : undefined,
+            picked: isAutoDetect ? true : undefined
+        };
+        picks.unshift(autoDetectMode);
+        const pick = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/preferences/browser/keyboardLayoutPicker',
+            'pickKeyboardLayout',
+            "Select Keyboard Layout"
+        )), matchOnDescription: true });
+        if (!pick) {
+            return;
+        }
+        if (pick === autoDetectMode) {
+            configurationService.updateValue('keyboard.layout', 'autodetect');
+            return;
+        }
+        if (pick === configureKeyboardLayout) {
+            const file = environmentService.keyboardLayoutResource;
+            await fileService.stat(file).then(undefined, () => {
+                return fileService.createFile(file, VSBuffer.fromString(DEFAULT_CONTENT));
+            }).then((stat) => {
+                if (!stat) {
+                    return undefined;
+                }
+                return editorService.openEditor({
+                    resource: stat.resource,
+                    languageId: 'jsonc',
+                    options: { pinned: true }
+                });
+            }, (error) => {
+                throw new Error(localizeWithPath('vs/workbench/contrib/preferences/browser/keyboardLayoutPicker', 'fail.createSettings', "Unable to create '{0}' ({1}).", file.toString(), error));
+            });
+            return Promise.resolve();
+        }
+        configurationService.updateValue('keyboard.layout', getKeyboardLayoutId(pick.layout));
+    }
+});
+
+export { KeyboardLayoutPickerContribution };

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

@@ -0,0 +1,38 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { workbenchConfigurationNodeBase } from 'vscode/vscode/vs/workbench/common/configuration';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { SashSettingsController } from './sash.js';
+import { isIOS } from 'vscode/vscode/vs/base/common/platform';
+
+( Registry.as(Extensions.Workbench))
+    .registerWorkbenchContribution(SashSettingsController, 3 );
+( Registry.as(Extensions$1.Configuration))
+    .registerConfiguration({
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        'workbench.sash.size': {
+            type: 'number',
+            default: isIOS ? 20 : 4,
+            minimum: 1,
+            maximum: 20,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/sash/browser/sash.contribution',
+                'sashSize',
+                "Controls the feedback area size in pixels of the dragging area in between views/editors. Set it to a larger value if you feel it's hard to resize views using the mouse."
+            ))
+        },
+        'workbench.sash.hoverDelay': {
+            type: 'number',
+            default: 300,
+            minimum: 0,
+            maximum: 2000,
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/sash/browser/sash.contribution',
+                'sashHoverDelay',
+                "Controls the hover feedback delay in milliseconds of the dragging area in between views/editors."
+            ))
+        },
+    }
+});

package/vscode/src/vs/workbench/contrib/sash/browser/sash.js

@@ -0,0 +1,41 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { clamp } from 'vscode/vscode/vs/base/common/numbers';
+import { setGlobalSashSize, setGlobalHoverDelay } from 'vscode/vscode/vs/base/browser/ui/sash/sash';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
+
+let SashSettingsController = class SashSettingsController {
+    constructor(configurationService, layoutService) {
+        this.configurationService = configurationService;
+        this.layoutService = layoutService;
+        this.disposables = ( new DisposableStore());
+        const onDidChangeSize = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('workbench.sash.size'));
+        onDidChangeSize(this.onDidChangeSize, this, this.disposables);
+        this.onDidChangeSize();
+        const onDidChangeHoverDelay = Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('workbench.sash.hoverDelay'));
+        onDidChangeHoverDelay(this.onDidChangeHoverDelay, this, this.disposables);
+        this.onDidChangeHoverDelay();
+    }
+    onDidChangeSize() {
+        const configuredSize = this.configurationService.getValue('workbench.sash.size');
+        const size = clamp(configuredSize, 4, 20);
+        const hoverSize = clamp(configuredSize, 1, 8);
+        this.layoutService.mainContainer.style.setProperty('--vscode-sash-size', size + 'px');
+        this.layoutService.mainContainer.style.setProperty('--vscode-sash-hover-size', hoverSize + 'px');
+        setGlobalSashSize(size);
+    }
+    onDidChangeHoverDelay() {
+        setGlobalHoverDelay(this.configurationService.getValue('workbench.sash.hoverDelay'));
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+SashSettingsController = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILayoutService))
+], SashSettingsController));
+
+export { SashSettingsController };

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

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .type-hierarchy .message,.monaco-workbench .type-hierarchy .results{display:none}.monaco-workbench .type-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .type-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .type-hierarchy .editor,.monaco-workbench .type-hierarchy .tree{height:100%}.monaco-editor .type-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-editor .type-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-workbench .type-hierarchy .tree .typehierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .type-hierarchy .tree .typehierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .type-hierarchy .type-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .type-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .type-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .type-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,283 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { registerEditorContribution, EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { PeekContext } from 'vscode/vscode/vs/editor/contrib/peekView/browser/peekView';
+import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { TypeHierarchyTreePeekWidget } from './typeHierarchyPeek.js';
+import { TypeHierarchyProviderRegistry, TypeHierarchyModel } from 'vscode/vscode/vs/workbench/contrib/typeHierarchy/common/typeHierarchy';
+
+var TypeHierarchyController_1;
+const _ctxHasTypeHierarchyProvider = ( new RawContextKey('editorHasTypeHierarchyProvider', false, ( localizeWithPath(
+    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+    'editorHasTypeHierarchyProvider',
+    'Whether a type hierarchy provider is available'
+))));
+const _ctxTypeHierarchyVisible = ( new RawContextKey('typeHierarchyVisible', false, ( localizeWithPath(
+    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+    'typeHierarchyVisible',
+    'Whether type hierarchy peek is currently showing'
+))));
+const _ctxTypeHierarchyDirection = ( new RawContextKey(
+    'typeHierarchyDirection',
+    undefined,
+    { type: 'string', description: ( localizeWithPath(
+        'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+        'typeHierarchyDirection',
+        'whether type hierarchy shows super types or subtypes'
+    )) }
+));
+function sanitizedDirection(candidate) {
+    return candidate === "subtypes"  || candidate === "supertypes"
+        ? candidate
+        : "subtypes" ;
+}
+let TypeHierarchyController = class TypeHierarchyController {
+    static { TypeHierarchyController_1 = this; }
+    static { this.Id = 'typeHierarchy'; }
+    static get(editor) {
+        return editor.getContribution(TypeHierarchyController_1.Id);
+    }
+    static { this._storageDirectionKey = 'typeHierarchy/defaultDirection'; }
+    constructor(_editor, _contextKeyService, _storageService, _editorService, _instantiationService) {
+        this._editor = _editor;
+        this._contextKeyService = _contextKeyService;
+        this._storageService = _storageService;
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._disposables = ( new DisposableStore());
+        this._sessionDisposables = ( new DisposableStore());
+        this._ctxHasProvider = _ctxHasTypeHierarchyProvider.bindTo(this._contextKeyService);
+        this._ctxIsVisible = _ctxTypeHierarchyVisible.bindTo(this._contextKeyService);
+        this._ctxDirection = _ctxTypeHierarchyDirection.bindTo(this._contextKeyService);
+        this._disposables.add(Event.any(_editor.onDidChangeModel, _editor.onDidChangeModelLanguage, TypeHierarchyProviderRegistry.onDidChange)(() => {
+            this._ctxHasProvider.set(_editor.hasModel() && ( TypeHierarchyProviderRegistry.has(_editor.getModel())));
+        }));
+        this._disposables.add(this._sessionDisposables);
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    async startTypeHierarchyFromEditor() {
+        this._sessionDisposables.clear();
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const document = this._editor.getModel();
+        const position = this._editor.getPosition();
+        if (!( TypeHierarchyProviderRegistry.has(document))) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        const model = TypeHierarchyModel.create(document, position, cts.token);
+        const direction = sanitizedDirection(this._storageService.get(TypeHierarchyController_1._storageDirectionKey, 0 , "subtypes" ));
+        this._showTypeHierarchyWidget(position, direction, model, cts);
+    }
+    _showTypeHierarchyWidget(position, direction, model, cts) {
+        this._ctxIsVisible.set(true);
+        this._ctxDirection.set(direction);
+        Event.any(this._editor.onDidChangeModel, this._editor.onDidChangeModelLanguage)(this.endTypeHierarchy, this, this._sessionDisposables);
+        this._widget = this._instantiationService.createInstance(TypeHierarchyTreePeekWidget, this._editor, position, direction);
+        this._widget.showLoading();
+        this._sessionDisposables.add(this._widget.onDidClose(() => {
+            this.endTypeHierarchy();
+            this._storageService.store(TypeHierarchyController_1._storageDirectionKey, this._widget.direction, 0 , 0 );
+        }));
+        this._sessionDisposables.add({ dispose() { cts.dispose(true); } });
+        this._sessionDisposables.add(this._widget);
+        model.then(model => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (model) {
+                this._sessionDisposables.add(model);
+                this._widget.showModel(model);
+            }
+            else {
+                this._widget.showMessage(( localizeWithPath(
+                    'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                    'no.item',
+                    "No results"
+                )));
+            }
+        }).catch(err => {
+            if (isCancellationError(err)) {
+                this.endTypeHierarchy();
+                return;
+            }
+            this._widget.showMessage(( localizeWithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'error',
+                "Failed to show type hierarchy"
+            )));
+        });
+    }
+    async startTypeHierarchyFromTypeHierarchy() {
+        if (!this._widget) {
+            return;
+        }
+        const model = this._widget.getModel();
+        const typeItem = this._widget.getFocused();
+        if (!typeItem || !model) {
+            return;
+        }
+        const newEditor = await this._editorService.openCodeEditor({ resource: typeItem.item.uri }, this._editor);
+        if (!newEditor) {
+            return;
+        }
+        const newModel = model.fork(typeItem.item);
+        this._sessionDisposables.clear();
+        TypeHierarchyController_1.get(newEditor)?._showTypeHierarchyWidget(Range.lift(newModel.root.selectionRange).getStartPosition(), this._widget.direction, Promise.resolve(newModel), ( new CancellationTokenSource()));
+    }
+    showSupertypes() {
+        this._widget?.updateDirection("supertypes" );
+        this._ctxDirection.set("supertypes" );
+    }
+    showSubtypes() {
+        this._widget?.updateDirection("subtypes" );
+        this._ctxDirection.set("subtypes" );
+    }
+    endTypeHierarchy() {
+        this._sessionDisposables.clear();
+        this._ctxIsVisible.set(false);
+        this._editor.focus();
+    }
+};
+TypeHierarchyController = TypeHierarchyController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, ICodeEditorService)),
+    ( __param(4, IInstantiationService))
+], TypeHierarchyController));
+registerEditorContribution(TypeHierarchyController.Id, TypeHierarchyController, 0 );
+registerAction2(class PeekTypeHierarchyAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showTypeHierarchy',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title',
+                'Peek Type Hierarchy'
+            )),
+            menu: {
+                id: MenuId.EditorContextPeek,
+                group: 'navigation',
+                order: 1000,
+                when: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            },
+            precondition: ( ContextKeyExpr.and(_ctxHasTypeHierarchyProvider, PeekContext.notInPeekEditor)),
+            f1: true
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromEditor();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showSupertypes',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.supertypes',
+                'Show Supertypes'
+            )),
+            icon: Codicon.typeHierarchySuper,
+            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxTypeHierarchyDirection.isEqualTo("subtypes" )),
+                order: 1,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.showSupertypes();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.showSubtypes',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.subtypes',
+                'Show Subtypes'
+            )),
+            icon: Codicon.typeHierarchySub,
+            precondition: ( ContextKeyExpr.and(_ctxTypeHierarchyVisible, ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )))),
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 512  + 38 ,
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                when: ( _ctxTypeHierarchyDirection.isEqualTo("supertypes" )),
+                order: 1,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.showSubtypes();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.refocusTypeHierarchy',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'title.refocusTypeHierarchy',
+                'Refocus Type Hierarchy'
+            )),
+            precondition: _ctxTypeHierarchyVisible,
+            keybinding: {
+                weight: 200 ,
+                primary: 1024  + 3
+            }
+        });
+    }
+    async runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.startTypeHierarchyFromTypeHierarchy();
+    }
+});
+registerAction2(class extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'editor.closeTypeHierarchy',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/typeHierarchy/browser/typeHierarchy.contribution',
+                'close',
+                'Close'
+            )),
+            icon: Codicon.close,
+            precondition: _ctxTypeHierarchyVisible,
+            keybinding: {
+                weight: 200  + 10,
+                primary: 9 ,
+                when: ContextKeyExpr.not('config.editor.stablePeek')
+            },
+            menu: {
+                id: TypeHierarchyTreePeekWidget.TitleMenu,
+                order: 1000
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor) {
+        return TypeHierarchyController.get(editor)?.endTypeHierarchy();
+    }
+});