@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/browser/actions.js

@@ -0,0 +1,77 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IMenuService, SubmenuItemAction } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+class MenuActions extends Disposable {
+    get primaryActions() { return this._primaryActions; }
+    get secondaryActions() { return this._secondaryActions; }
+    constructor(menuId, options, menuService, contextKeyService) {
+        super();
+        this.options = options;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this._primaryActions = [];
+        this._secondaryActions = [];
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.disposables = this._register(( new DisposableStore()));
+        this.menu = this._register(menuService.createMenu(menuId, contextKeyService));
+        this._register(this.menu.onDidChange(() => this.updateActions()));
+        this.updateActions();
+    }
+    updateActions() {
+        this.disposables.clear();
+        this._primaryActions = [];
+        this._secondaryActions = [];
+        createAndFillInActionBarActions(this.menu, this.options, { primary: this._primaryActions, secondary: this._secondaryActions });
+        this.disposables.add(this.updateSubmenus([...this._primaryActions, ...this._secondaryActions], {}));
+        this._onDidChange.fire();
+    }
+    updateSubmenus(actions, submenus) {
+        const disposables = ( new DisposableStore());
+        for (const action of actions) {
+            if (action instanceof SubmenuItemAction && !submenus[action.item.submenu.id]) {
+                const menu = submenus[action.item.submenu.id] = disposables.add(this.menuService.createMenu(action.item.submenu, this.contextKeyService));
+                disposables.add(menu.onDidChange(() => this.updateActions()));
+                disposables.add(this.updateSubmenus(action.actions, submenus));
+            }
+        }
+        return disposables;
+    }
+}
+let CompositeMenuActions = class CompositeMenuActions extends Disposable {
+    constructor(menuId, contextMenuId, options, contextKeyService, menuService) {
+        super();
+        this.menuId = menuId;
+        this.contextMenuId = contextMenuId;
+        this.options = options;
+        this.contextKeyService = contextKeyService;
+        this.menuService = menuService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.menuActions = this._register(( new MenuActions(menuId, this.options, menuService, contextKeyService)));
+        this._register(this.menuActions.onDidChange(() => this._onDidChange.fire()));
+    }
+    getPrimaryActions() {
+        return this.menuActions.primaryActions;
+    }
+    getSecondaryActions() {
+        return this.menuActions.secondaryActions;
+    }
+    getContextMenuActions() {
+        const actions = [];
+        if (this.contextMenuId) {
+            const menu = this.menuService.createMenu(this.contextMenuId, this.contextKeyService);
+            createAndFillInActionBarActions(menu, this.options, { primary: [], secondary: actions });
+            menu.dispose();
+        }
+        return actions;
+    }
+};
+CompositeMenuActions = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IMenuService))
+], CompositeMenuActions));
+export { CompositeMenuActions };

package/dist/vscode/vs/workbench/browser/codeeditor.js

@@ -0,0 +1,185 @@
+import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { isCodeEditor, isCompositeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { $, clearNode, append } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { asCssVariableWithDefault, buttonBackground, asCssVariable, editorBackground, buttonForeground, editorForeground, contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IEditorService } from '../services/editor/common/editorService.js';
+import { ModelDecorationOptions } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { EmbeddedCodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/embeddedCodeEditorWidget.js';
+let RangeHighlightDecorations = class RangeHighlightDecorations extends Disposable {
+    constructor(editorService) {
+        super();
+        this.editorService = editorService;
+        this._onHighlightRemoved = this._register(( new Emitter()));
+        this.onHighlightRemoved = this._onHighlightRemoved.event;
+        this.rangeHighlightDecorationId = null;
+        this.editor = null;
+        this.editorDisposables = this._register(( new DisposableStore()));
+    }
+    removeHighlightRange() {
+        if (this.editor && this.rangeHighlightDecorationId) {
+            const decorationId = this.rangeHighlightDecorationId;
+            this.editor.changeDecorations((accessor) => {
+                accessor.removeDecoration(decorationId);
+            });
+            this._onHighlightRemoved.fire();
+        }
+        this.rangeHighlightDecorationId = null;
+    }
+    highlightRange(range, editor) {
+        editor = editor ?? this.getEditor(range);
+        if (isCodeEditor(editor)) {
+            this.doHighlightRange(editor, range);
+        }
+        else if (isCompositeEditor(editor) && isCodeEditor(editor.activeCodeEditor)) {
+            this.doHighlightRange(editor.activeCodeEditor, range);
+        }
+    }
+    doHighlightRange(editor, selectionRange) {
+        this.removeHighlightRange();
+        editor.changeDecorations((changeAccessor) => {
+            this.rangeHighlightDecorationId = changeAccessor.addDecoration(selectionRange.range, this.createRangeHighlightDecoration(selectionRange.isWholeLine));
+        });
+        this.setEditor(editor);
+    }
+    getEditor(resourceRange) {
+        const resource = this.editorService.activeEditor?.resource;
+        if (resource && isEqual(resource, resourceRange.resource) && isCodeEditor(this.editorService.activeTextEditorControl)) {
+            return this.editorService.activeTextEditorControl;
+        }
+        return undefined;
+    }
+    setEditor(editor) {
+        if (this.editor !== editor) {
+            this.editorDisposables.clear();
+            this.editor = editor;
+            this.editorDisposables.add(this.editor.onDidChangeCursorPosition((e) => {
+                if (e.reason === 0
+                    || e.reason === 3
+                    || e.reason === 5
+                    || e.reason === 6 ) {
+                    this.removeHighlightRange();
+                }
+            }));
+            this.editorDisposables.add(this.editor.onDidChangeModel(() => { this.removeHighlightRange(); }));
+            this.editorDisposables.add(this.editor.onDidDispose(() => {
+                this.removeHighlightRange();
+                this.editor = null;
+            }));
+        }
+    }
+    createRangeHighlightDecoration(isWholeLine = true) {
+        return (isWholeLine ? RangeHighlightDecorations._WHOLE_LINE_RANGE_HIGHLIGHT : RangeHighlightDecorations._RANGE_HIGHLIGHT);
+    }
+    dispose() {
+        super.dispose();
+        if (this.editor?.getModel()) {
+            this.removeHighlightRange();
+            this.editor = null;
+        }
+    }
+};
+RangeHighlightDecorations._WHOLE_LINE_RANGE_HIGHLIGHT = ModelDecorationOptions.register({
+    description: 'codeeditor-range-highlight-whole',
+    stickiness: 1 ,
+    className: 'rangeHighlight',
+    isWholeLine: true
+});
+RangeHighlightDecorations._RANGE_HIGHLIGHT = ModelDecorationOptions.register({
+    description: 'codeeditor-range-highlight',
+    stickiness: 1 ,
+    className: 'rangeHighlight'
+});
+RangeHighlightDecorations = ( __decorate([
+    ( __param(0, IEditorService))
+], RangeHighlightDecorations));
+let FloatingClickWidget = class FloatingClickWidget extends Widget {
+    constructor(editor, label, keyBindingAction, keybindingService) {
+        super();
+        this.editor = editor;
+        this.label = label;
+        this._onClick = this._register(( new Emitter()));
+        this.onClick = this._onClick.event;
+        this._domNode = $('.floating-click-widget');
+        this._domNode.style.padding = '6px 11px';
+        this._domNode.style.borderRadius = '2px';
+        this._domNode.style.cursor = 'pointer';
+        if (keyBindingAction) {
+            const keybinding = keybindingService.lookupKeybinding(keyBindingAction);
+            if (keybinding) {
+                this.label += ` (${keybinding.getLabel()})`;
+            }
+        }
+    }
+    getId() {
+        return 'editor.overlayWidget.floatingClickWidget';
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return {
+            preference: 1
+        };
+    }
+    render() {
+        clearNode(this._domNode);
+        this._domNode.style.backgroundColor = asCssVariableWithDefault(buttonBackground, asCssVariable(editorBackground));
+        this._domNode.style.color = asCssVariableWithDefault(buttonForeground, asCssVariable(editorForeground));
+        this._domNode.style.border = `1px solid ${asCssVariable(contrastBorder)}`;
+        append(this._domNode, $('')).textContent = this.label;
+        this.onclick(this._domNode, e => this._onClick.fire());
+        this.editor.addOverlayWidget(this);
+    }
+    dispose() {
+        this.editor.removeOverlayWidget(this);
+        super.dispose();
+    }
+};
+FloatingClickWidget = ( __decorate([
+    ( __param(3, IKeybindingService))
+], FloatingClickWidget));
+let FloatingClickMenu = class FloatingClickMenu extends Disposable {
+    constructor(editor, instantiationService, menuService, contextKeyService) {
+        super();
+        if (!(editor instanceof EmbeddedCodeEditorWidget)) {
+            const menu = menuService.createMenu(MenuId.EditorContent, contextKeyService);
+            const menuDisposables = ( new DisposableStore());
+            const renderMenuAsFloatingClickBtn = () => {
+                menuDisposables.clear();
+                if (!editor.hasModel() || editor.getOption(59 )) {
+                    return;
+                }
+                const actions = [];
+                createAndFillInActionBarActions(menu, { renderShortTitle: true, shouldForwardArgs: true }, actions);
+                if (actions.length === 0) {
+                    return;
+                }
+                const [first] = actions;
+                const widget = instantiationService.createInstance(FloatingClickWidget, editor, first.label, first.id);
+                menuDisposables.add(widget);
+                menuDisposables.add(widget.onClick(() => first.run(editor.getModel().uri)));
+                widget.render();
+            };
+            this._store.add(menu);
+            this._store.add(menuDisposables);
+            this._store.add(menu.onDidChange(renderMenuAsFloatingClickBtn));
+            renderMenuAsFloatingClickBtn();
+        }
+    }
+};
+FloatingClickMenu.ID = 'editor.contrib.floatingClickMenu';
+FloatingClickMenu = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IMenuService)),
+    ( __param(3, IContextKeyService))
+], FloatingClickMenu));
+export { FloatingClickMenu, FloatingClickWidget, RangeHighlightDecorations };

package/dist/vscode/vs/workbench/browser/composite.js

@@ -0,0 +1,102 @@
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Component } from '../common/component.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+class Composite extends Component {
+    get onDidFocus() {
+        if (!this._onDidFocus) {
+            this._onDidFocus = this.registerFocusTrackEvents().onDidFocus;
+        }
+        return this._onDidFocus.event;
+    }
+    fireOnDidFocus() {
+        this._onDidFocus?.fire();
+    }
+    get onDidBlur() {
+        if (!this._onDidBlur) {
+            this._onDidBlur = this.registerFocusTrackEvents().onDidBlur;
+        }
+        return this._onDidBlur.event;
+    }
+    hasFocus() {
+        return this._hasFocus;
+    }
+    registerFocusTrackEvents() {
+        const container = assertIsDefined(this.getContainer());
+        const focusTracker = this._register(trackFocus(container));
+        const onDidFocus = this._onDidFocus = this._register(( new Emitter()));
+        this._register(focusTracker.onDidFocus(() => {
+            this._hasFocus = true;
+            onDidFocus.fire();
+        }));
+        const onDidBlur = this._onDidBlur = this._register(( new Emitter()));
+        this._register(focusTracker.onDidBlur(() => {
+            this._hasFocus = false;
+            onDidBlur.fire();
+        }));
+        return { onDidFocus, onDidBlur };
+    }
+    get telemetryService() { return this._telemetryService; }
+    constructor(id, telemetryService, themeService, storageService) {
+        super(id, themeService, storageService);
+        this._onTitleAreaUpdate = this._register(( new Emitter()));
+        this.onTitleAreaUpdate = this._onTitleAreaUpdate.event;
+        this._hasFocus = false;
+        this._telemetryService = telemetryService;
+        this.visible = false;
+    }
+    getTitle() {
+        return undefined;
+    }
+    create(parent) {
+        this.parent = parent;
+    }
+    getContainer() {
+        return this.parent;
+    }
+    setVisible(visible) {
+        if (this.visible !== !!visible) {
+            this.visible = visible;
+        }
+    }
+    focus() {
+    }
+    updateStyles() {
+        super.updateStyles();
+    }
+    getMenuIds() {
+        return [];
+    }
+    getActions() {
+        return [];
+    }
+    getSecondaryActions() {
+        return [];
+    }
+    getContextMenuActions() {
+        return [];
+    }
+    getActionViewItem(action) {
+        return undefined;
+    }
+    getActionsContext() {
+        return null;
+    }
+    getActionRunner() {
+        if (!this.actionRunner) {
+            this.actionRunner = this._register(( new ActionRunner()));
+        }
+        return this.actionRunner;
+    }
+    updateTitleArea() {
+        this._onTitleAreaUpdate.fire();
+    }
+    isVisible() {
+        return this.visible;
+    }
+    getControl() {
+        return undefined;
+    }
+}
+export { Composite };

package/dist/vscode/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarActions.js

@@ -0,0 +1,146 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { AuxiliaryBarVisibleContext } from '../../../common/contextkeys.js';
+import { ViewContainerLocationToString } from '../../../common/views.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+var _a;
+const auxiliaryBarRightIcon = ( registerIcon(
+    'auxiliarybar-right-layout-icon',
+    Codicon.layoutSidebarRight,
+    ( localize(
+        'toggleAuxiliaryIconRight',
+        'Icon to toggle the auxiliary bar off in its right position.'
+    ))
+));
+const auxiliaryBarRightOffIcon = ( registerIcon(
+    'auxiliarybar-right-off-layout-icon',
+    Codicon.layoutSidebarRightOff,
+    ( localize(
+        'toggleAuxiliaryIconRightOn',
+        'Icon to toggle the auxiliary bar on in its right position.'
+    ))
+));
+const auxiliaryBarLeftIcon = ( registerIcon('auxiliarybar-left-layout-icon', Codicon.layoutSidebarLeft, ( localize(
+    'toggleAuxiliaryIconLeft',
+    'Icon to toggle the auxiliary bar in its left position.'
+))));
+const auxiliaryBarLeftOffIcon = ( registerIcon(
+    'auxiliarybar-left-off-layout-icon',
+    Codicon.layoutSidebarLeftOff,
+    ( localize(
+        'toggleAuxiliaryIconLeftOn',
+        'Icon to toggle the auxiliary bar on in its left position.'
+    ))
+));
+class ToggleAuxiliaryBarAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleAuxiliaryBarAction.ID,
+            title: { value: ToggleAuxiliaryBarAction.LABEL, original: 'Toggle Secondary Side Bar Visibility' },
+            toggled: {
+                condition: AuxiliaryBarVisibleContext,
+                title: ( localize('secondary sidebar', "Secondary Side Bar")),
+                mnemonicTitle: ( localize(
+                    { key: 'secondary sidebar mnemonic', comment: ['&& denotes a mnemonic'] },
+                    "Secondary Si&&de Bar"
+                )),
+            },
+            category: Categories.View,
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 512  | 32
+            },
+            menu: [
+                {
+                    id: MenuId.LayoutControlMenuSubmenu,
+                    group: '0_workbench_layout',
+                    order: 1
+                },
+                {
+                    id: MenuId.MenubarAppearanceMenu,
+                    group: '2_workbench_layout',
+                    order: 2
+                }
+            ]
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        layoutService.setPartHidden(layoutService.isVisible("workbench.parts.auxiliarybar" ), "workbench.parts.auxiliarybar" );
+    }
+}
+ToggleAuxiliaryBarAction.ID = 'workbench.action.toggleAuxiliaryBar';
+ToggleAuxiliaryBarAction.LABEL = ( localize('toggleAuxiliaryBar', "Toggle Secondary Side Bar Visibility"));
+registerAction2(ToggleAuxiliaryBarAction);
+registerAction2((_a = class FocusAuxiliaryBarAction extends Action2 {
+        constructor() {
+            super({
+                id: FocusAuxiliaryBarAction.ID,
+                title: { value: FocusAuxiliaryBarAction.LABEL, original: 'Focus into Secondary Side Bar' },
+                category: Categories.View,
+                f1: true,
+            });
+        }
+        async run(accessor) {
+            const paneCompositeService = accessor.get(IPaneCompositePartService);
+            const layoutService = accessor.get(IWorkbenchLayoutService);
+            if (!layoutService.isVisible("workbench.parts.auxiliarybar" )) {
+                layoutService.setPartHidden(false, "workbench.parts.auxiliarybar" );
+            }
+            const composite = paneCompositeService.getActivePaneComposite(2 );
+            composite?.focus();
+        }
+    },
+    _a.ID = 'workbench.action.focusAuxiliaryBar',
+    _a.LABEL = ( localize('focusAuxiliaryBar', "Focus into Secondary Side Bar")),
+    _a));
+MenuRegistry.appendMenuItems([
+    {
+        id: MenuId.LayoutControlMenu,
+        item: {
+            group: '0_workbench_toggles',
+            command: {
+                id: ToggleAuxiliaryBarAction.ID,
+                title: ( localize('toggleSecondarySideBar', "Toggle Secondary Side Bar")),
+                toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarLeftIcon },
+                icon: auxiliaryBarLeftOffIcon,
+            },
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'toggles')), ( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'both')))), ( ContextKeyExpr.equals('config.workbench.sideBar.location', 'right')))),
+            order: 0
+        }
+    }, {
+        id: MenuId.LayoutControlMenu,
+        item: {
+            group: '0_workbench_toggles',
+            command: {
+                id: ToggleAuxiliaryBarAction.ID,
+                title: ( localize('toggleSecondarySideBar', "Toggle Secondary Side Bar")),
+                toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarRightIcon },
+                icon: auxiliaryBarRightOffIcon,
+            },
+            when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'toggles')), ( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'both')))), ( ContextKeyExpr.equals('config.workbench.sideBar.location', 'left')))),
+            order: 2
+        }
+    }, {
+        id: MenuId.ViewTitleContext,
+        item: {
+            group: '3_workbench_layout_move',
+            command: {
+                id: ToggleAuxiliaryBarAction.ID,
+                title: { value: ( localize('hideAuxiliaryBar', "Hide Secondary Side Bar")), original: 'Hide Secondary Side Bar' },
+            },
+            when: ( ContextKeyExpr.and(AuxiliaryBarVisibleContext, ( ContextKeyExpr.equals(
+                'viewLocation',
+                ViewContainerLocationToString(2 )
+            )))),
+            order: 2
+        }
+    }
+]);
+export { ToggleAuxiliaryBarAction };

package/dist/vscode/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js

@@ -0,0 +1,68 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProductService } from '../../../../platform/product/common/productService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { BrowserDialogHandler } from './dialogHandler.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+let DialogHandlerContribution = class DialogHandlerContribution extends Disposable {
+    constructor(dialogService, logService, layoutService, keybindingService, instantiationService, productService, clipboardService) {
+        super();
+        this.dialogService = dialogService;
+        this.impl = ( new BrowserDialogHandler(
+            logService,
+            layoutService,
+            keybindingService,
+            instantiationService,
+            productService,
+            clipboardService
+        ));
+        this.model = this.dialogService.model;
+        this._register(this.model.onWillShowDialog(() => {
+            if (!this.currentDialog) {
+                this.processDialogs();
+            }
+        }));
+        this.processDialogs();
+    }
+    async processDialogs() {
+        while (this.model.dialogs.length) {
+            this.currentDialog = this.model.dialogs[0];
+            let result = undefined;
+            if (this.currentDialog.args.confirmArgs) {
+                const args = this.currentDialog.args.confirmArgs;
+                result = await this.impl.confirm(args.confirmation);
+            }
+            else if (this.currentDialog.args.inputArgs) {
+                const args = this.currentDialog.args.inputArgs;
+                result = await this.impl.input(args.input);
+            }
+            else if (this.currentDialog.args.promptArgs) {
+                const args = this.currentDialog.args.promptArgs;
+                result = await this.impl.prompt(args.prompt);
+            }
+            else {
+                await this.impl.about();
+            }
+            this.currentDialog.close(result);
+            this.currentDialog = undefined;
+        }
+    }
+};
+DialogHandlerContribution = ( __decorate([
+    ( __param(0, IDialogService)),
+    ( __param(1, ILogService)),
+    ( __param(2, ILayoutService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IProductService)),
+    ( __param(6, IClipboardService))
+], DialogHandlerContribution));
+const workbenchRegistry = ( Registry.as(Extensions.Workbench));
+workbenchRegistry.registerWorkbenchContribution(DialogHandlerContribution, 1 );
+export { DialogHandlerContribution };