@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput.js

@@ -0,0 +1,250 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import './suggestEnabledInput.css.js';
+import { append, $ } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ContextMenuController } from 'monaco-editor/esm/vs/editor/contrib/contextmenu/browser/contextmenu.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { SuggestController } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggestController.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { selectionBackground, inputBackground, inputForeground, editorSelectionBackground, asCssVariable, inputPlaceholderForeground, asCssVariableWithDefault, inputBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { MenuPreventer } from '../menuPreventer.js';
+import { getSimpleEditorOptions } from '../simpleEditorOptions.js';
+import { SelectionClipboardContributionID } from '../selectionClipboard.js';
+import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { DEFAULT_FONT_FAMILY } from '../../../../browser/style.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ensureValidWordDefinition, getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+let SuggestEnabledInput = class SuggestEnabledInput extends Widget {
+    constructor(id, parent, suggestionProvider, ariaLabel, resourceHandle, options, defaultInstantiationService, modelService, contextKeyService, languageFeaturesService, configurationService) {
+        super();
+        this._onShouldFocusResults = ( (new Emitter()));
+        this.onShouldFocusResults = this._onShouldFocusResults.event;
+        this._onInputDidChange = ( (new Emitter()));
+        this.onInputDidChange = this._onInputDidChange.event;
+        this._onDidFocus = this._register(( (new Emitter())));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( (new Emitter())));
+        this.onDidBlur = this._onDidBlur.event;
+        this.stylingContainer = append(parent, $('.suggest-input-container'));
+        this.element = parent;
+        this.placeholderText = append(this.stylingContainer, $('.suggest-input-placeholder', undefined, options.placeholderText || ''));
+        const editorOptions = mixin(getSimpleEditorOptions(), getSuggestEnabledInputOptions(ariaLabel));
+        editorOptions.overflowWidgetsDomNode = options.overflowWidgetsDomNode;
+        editorOptions.accessibilitySupport = configurationService.getValue('editor.accessibilitySupport');
+        editorOptions.cursorBlinking = configurationService.getValue('editor.cursorBlinking');
+        const scopedContextKeyService = this.getScopedContextKeyService(contextKeyService);
+        const instantiationService = scopedContextKeyService
+            ? defaultInstantiationService.createChild(( (new ServiceCollection([IContextKeyService, scopedContextKeyService]))))
+            : defaultInstantiationService;
+        this.inputWidget = this._register(instantiationService.createInstance(CodeEditorWidget, this.stylingContainer, editorOptions, {
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                SuggestController.ID,
+                SnippetController2.ID,
+                ContextMenuController.ID,
+                MenuPreventer.ID,
+                SelectionClipboardContributionID,
+            ]),
+            isSimpleWidget: true,
+        }));
+        this._register(configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('editor.accessibilitySupport') ||
+                e.affectsConfiguration('editor.cursorBlinking')) {
+                const accessibilitySupport = configurationService.getValue('editor.accessibilitySupport');
+                const cursorBlinking = configurationService.getValue('editor.cursorBlinking');
+                this.inputWidget.updateOptions({
+                    accessibilitySupport,
+                    cursorBlinking
+                });
+            }
+        }));
+        this._register(this.inputWidget.onDidFocusEditorText(() => this._onDidFocus.fire()));
+        this._register(this.inputWidget.onDidBlurEditorText(() => this._onDidBlur.fire()));
+        const scopeHandle = ( URI.parse(resourceHandle));
+        this.inputModel = modelService.createModel('', null, scopeHandle, true);
+        this._register(this.inputModel);
+        this.inputWidget.setModel(this.inputModel);
+        this._register(this.inputWidget.onDidPaste(() => this.setValue(this.getValue())));
+        this._register((this.inputWidget.onDidFocusEditorText(() => {
+            if (options.focusContextKey) {
+                options.focusContextKey.set(true);
+            }
+            this.stylingContainer.classList.add('synthetic-focus');
+        })));
+        this._register((this.inputWidget.onDidBlurEditorText(() => {
+            if (options.focusContextKey) {
+                options.focusContextKey.set(false);
+            }
+            this.stylingContainer.classList.remove('synthetic-focus');
+        })));
+        const onKeyDownMonaco = Event.chain(this.inputWidget.onKeyDown);
+        this._register(onKeyDownMonaco.filter(e => e.keyCode === 3 ).on(e => { e.preventDefault();  }, this));
+        this._register(onKeyDownMonaco.filter(e => e.keyCode === 18  && (isMacintosh ? e.metaKey : e.ctrlKey)).on(() => this._onShouldFocusResults.fire(), this));
+        let preexistingContent = this.getValue();
+        const inputWidgetModel = this.inputWidget.getModel();
+        if (inputWidgetModel) {
+            this._register(inputWidgetModel.onDidChangeContent(() => {
+                const content = this.getValue();
+                this.placeholderText.style.visibility = content ? 'hidden' : 'visible';
+                if (preexistingContent.trim() === content.trim()) {
+                    return;
+                }
+                this._onInputDidChange.fire(undefined);
+                preexistingContent = content;
+            }));
+        }
+        const validatedSuggestProvider = {
+            provideResults: suggestionProvider.provideResults,
+            sortKey: suggestionProvider.sortKey || (a => a),
+            triggerCharacters: suggestionProvider.triggerCharacters || [],
+            wordDefinition: suggestionProvider.wordDefinition ? ensureValidWordDefinition(suggestionProvider.wordDefinition) : undefined,
+            alwaysShowSuggestions: !!suggestionProvider.alwaysShowSuggestions,
+        };
+        this.setValue(options.value || '');
+        this._register(languageFeaturesService.completionProvider.register({ scheme: scopeHandle.scheme, pattern: '**/' + scopeHandle.path, hasAccessToAllModels: true }, {
+            triggerCharacters: validatedSuggestProvider.triggerCharacters,
+            provideCompletionItems: (model, position, _context) => {
+                const query = model.getValue();
+                const zeroIndexedColumn = position.column - 1;
+                let alreadyTypedCount = 0, zeroIndexedWordStart = 0;
+                if (validatedSuggestProvider.wordDefinition) {
+                    const wordAtText = getWordAtText(position.column, validatedSuggestProvider.wordDefinition, query, 0);
+                    alreadyTypedCount = wordAtText?.word.length ?? 0;
+                    zeroIndexedWordStart = wordAtText ? wordAtText.startColumn - 1 : 0;
+                }
+                else {
+                    zeroIndexedWordStart = query.lastIndexOf(' ', zeroIndexedColumn - 1) + 1;
+                    alreadyTypedCount = zeroIndexedColumn - zeroIndexedWordStart;
+                }
+                if (!validatedSuggestProvider.alwaysShowSuggestions && alreadyTypedCount > 0 && validatedSuggestProvider.triggerCharacters?.indexOf(query[zeroIndexedWordStart]) === -1) {
+                    return { suggestions: [] };
+                }
+                return {
+                    suggestions: ( (suggestionProvider.provideResults(query).map((result) => {
+                        let label;
+                        let rest;
+                        if (typeof result === 'string') {
+                            label = result;
+                        }
+                        else {
+                            label = result.label;
+                            rest = result;
+                        }
+                        return {
+                            label,
+                            insertText: label,
+                            range: Range.fromPositions(position.delta(0, -alreadyTypedCount), position),
+                            sortText: validatedSuggestProvider.sortKey(label),
+                            kind: 17 ,
+                            ...rest
+                        };
+                    })))
+                };
+            }
+        }));
+        this.style(options.styleOverrides || {});
+    }
+    getScopedContextKeyService(_contextKeyService) {
+        return undefined;
+    }
+    updateAriaLabel(label) {
+        this.inputWidget.updateOptions({ ariaLabel: label });
+    }
+    setValue(val) {
+        val = val.replace(/\s/g, ' ');
+        const fullRange = this.inputModel.getFullModelRange();
+        this.inputWidget.executeEdits('suggestEnabledInput.setValue', [EditOperation.replace(fullRange, val)]);
+        this.inputWidget.setScrollTop(0);
+        this.inputWidget.setPosition(( (new Position(1, val.length + 1))));
+    }
+    getValue() {
+        return this.inputWidget.getValue();
+    }
+    style(styleOverrides) {
+        this.stylingContainer.style.backgroundColor = asCssVariable(styleOverrides.inputBackground ?? inputBackground);
+        this.stylingContainer.style.color = asCssVariable(styleOverrides.inputForeground ?? inputForeground);
+        this.placeholderText.style.color = asCssVariable(styleOverrides.inputPlaceholderForeground ?? inputPlaceholderForeground);
+        this.stylingContainer.style.borderWidth = '1px';
+        this.stylingContainer.style.borderStyle = 'solid';
+        this.stylingContainer.style.borderColor = asCssVariableWithDefault(styleOverrides.inputBorder ?? inputBorder, 'transparent');
+        const cursor = this.stylingContainer.getElementsByClassName('cursor')[0];
+        if (cursor) {
+            cursor.style.backgroundColor = asCssVariable(styleOverrides.inputForeground ?? inputForeground);
+        }
+    }
+    focus(selectAll) {
+        this.inputWidget.focus();
+        if (selectAll && this.inputWidget.getValue()) {
+            this.selectAll();
+        }
+    }
+    onHide() {
+        this.inputWidget.onHide();
+    }
+    layout(dimension) {
+        this.inputWidget.layout(dimension);
+        this.placeholderText.style.width = `${dimension.width - 2}px`;
+    }
+    selectAll() {
+        this.inputWidget.setSelection(( (new Range(1, 1, 1, this.getValue().length + 1))));
+    }
+};
+SuggestEnabledInput = ( (__decorate([
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IModelService))),
+    ( (__param(8, IContextKeyService))),
+    ( (__param(9, ILanguageFeaturesService))),
+    ( (__param(10, IConfigurationService)))
+], SuggestEnabledInput)));
+registerThemingParticipant((theme, collector) => {
+    const selectionBackgroundColor = theme.getColor(selectionBackground);
+    if (selectionBackgroundColor) {
+        const inputBackgroundColor = theme.getColor(inputBackground);
+        if (inputBackgroundColor) {
+            collector.addRule(`.suggest-input-container .monaco-editor .selected-text { background-color: ${( ( inputBackgroundColor.transparent(0.4)))}; }`);
+        }
+        const inputForegroundColor = theme.getColor(inputForeground);
+        if (inputForegroundColor) {
+            collector.addRule(`.suggest-input-container .monaco-editor .view-line span.inline-selected-text { color: ${inputForegroundColor}; }`);
+        }
+        const backgroundColor = theme.getColor(inputBackground);
+        if (backgroundColor) {
+            collector.addRule(`.suggest-input-container .monaco-editor-background { background-color: ${backgroundColor}; } `);
+        }
+        collector.addRule(`.suggest-input-container .monaco-editor .focused .selected-text { background-color: ${selectionBackgroundColor}; }`);
+    }
+    else {
+        collector.addRule(`.suggest-input-container .monaco-editor .focused .selected-text { background-color: ${theme.getColor(editorSelectionBackground)}; }`);
+    }
+});
+function getSuggestEnabledInputOptions(ariaLabel) {
+    return {
+        fontSize: 13,
+        lineHeight: 20,
+        wordWrap: 'off',
+        scrollbar: { vertical: 'hidden', },
+        roundedSelection: false,
+        guides: {
+            indentation: false
+        },
+        cursorWidth: 1,
+        fontFamily: DEFAULT_FONT_FAMILY,
+        ariaLabel: ariaLabel || '',
+        snippetSuggestions: 'none',
+        suggest: { filterGraceful: false, showIcons: false },
+        autoClosingBrackets: 'never'
+    };
+}
+export { SuggestEnabledInput };

package/dist/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { dirname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { ICustomEditorService } from '../common/customEditor.js';
+import { IWebviewService } from '../../webview/browser/webview.js';
+import { LazilyResolvedWebviewEditorInput, IWebviewWorkbenchService } from '../../webviewPanel/browser/webviewWorkbenchService.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IUntitledTextEditorService } from '../../../services/untitled/common/untitledTextEditorService.js';
+let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEditorInput {
+    static create(instantiationService, resource, viewType, group, options) {
+        return instantiationService.invokeFunction(accessor => {
+            const untitledString = accessor.get(IUntitledTextEditorService).getValue(resource);
+            const untitledDocumentData = untitledString ? VSBuffer.fromString(untitledString) : undefined;
+            const webview = accessor.get(IWebviewService).createWebviewOverlay({
+                providedViewType: viewType,
+                title: undefined,
+                options: { customClasses: options?.customClasses },
+                contentOptions: {},
+                extension: undefined,
+            });
+            const input = instantiationService.createInstance(CustomEditorInput, { resource, viewType }, webview, { untitledDocumentData: untitledDocumentData, oldResource: options?.oldResource });
+            if (typeof group !== 'undefined') {
+                input.updateGroup(group);
+            }
+            return input;
+        });
+    }
+    get resource() { return this._editorResource; }
+    constructor(init, webview, options, webviewWorkbenchService, instantiationService, labelService, customEditorService, fileDialogService, undoRedoService, fileService, filesConfigurationService) {
+        super({ providedId: init.viewType, viewType: init.viewType, name: '' }, webview, webviewWorkbenchService);
+        this.instantiationService = instantiationService;
+        this.labelService = labelService;
+        this.customEditorService = customEditorService;
+        this.fileDialogService = fileDialogService;
+        this.undoRedoService = undoRedoService;
+        this.fileService = fileService;
+        this.filesConfigurationService = filesConfigurationService;
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._editorResource = init.resource;
+        this.oldResource = options.oldResource;
+        this._defaultDirtyState = options.startsDirty;
+        this._backupId = options.backupId;
+        this._untitledDocumentData = options.untitledDocumentData;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.labelService.onDidChangeFormatters(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onLabelEvent(e.scheme)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onLabelEvent(e.scheme)));
+    }
+    onLabelEvent(scheme) {
+        if (scheme === this.resource.scheme) {
+            this.updateLabel();
+        }
+    }
+    updateLabel() {
+        this._shortDescription = undefined;
+        this._mediumDescription = undefined;
+        this._longDescription = undefined;
+        this._shortTitle = undefined;
+        this._mediumTitle = undefined;
+        this._longTitle = undefined;
+        this._onDidChangeLabel.fire();
+    }
+    get typeId() {
+        return CustomEditorInput.typeId;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = 0 ;
+        capabilities |= 128 ;
+        if (!this.customEditorService.getCustomEditorCapabilities(this.viewType)?.supportsMultipleEditorsPerDocument) {
+            capabilities |= 8 ;
+        }
+        if (this._modelRef) {
+            if (this._modelRef.object.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
+                capabilities |= 2 ;
+            }
+        }
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= 4 ;
+        }
+        return capabilities;
+    }
+    getName() {
+        return basename(this.labelService.getUriLabel(this.resource));
+    }
+    getDescription(verbosity = 1 ) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortDescription;
+            case 2 :
+                return this.longDescription;
+            case 1 :
+            default:
+                return this.mediumDescription;
+        }
+    }
+    get shortDescription() {
+        if (typeof this._shortDescription !== 'string') {
+            this._shortDescription = this.labelService.getUriBasenameLabel(dirname(this.resource));
+        }
+        return this._shortDescription;
+    }
+    get mediumDescription() {
+        if (typeof this._mediumDescription !== 'string') {
+            this._mediumDescription = this.labelService.getUriLabel(dirname(this.resource), { relative: true });
+        }
+        return this._mediumDescription;
+    }
+    get longDescription() {
+        if (typeof this._longDescription !== 'string') {
+            this._longDescription = this.labelService.getUriLabel(dirname(this.resource));
+        }
+        return this._longDescription;
+    }
+    get shortTitle() {
+        if (typeof this._shortTitle !== 'string') {
+            this._shortTitle = this.getName();
+        }
+        return this._shortTitle;
+    }
+    get mediumTitle() {
+        if (typeof this._mediumTitle !== 'string') {
+            this._mediumTitle = this.labelService.getUriLabel(this.resource, { relative: true });
+        }
+        return this._mediumTitle;
+    }
+    get longTitle() {
+        if (typeof this._longTitle !== 'string') {
+            this._longTitle = this.labelService.getUriLabel(this.resource);
+        }
+        return this._longTitle;
+    }
+    getTitle(verbosity) {
+        switch (verbosity) {
+            case 0 :
+                return this.shortTitle;
+            case 2 :
+                return this.longTitle;
+            default:
+            case 1 :
+                return this.mediumTitle;
+        }
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return this === other || (other instanceof CustomEditorInput
+            && this.viewType === other.viewType
+            && isEqual(this.resource, other.resource));
+    }
+    copy() {
+        return CustomEditorInput.create(this.instantiationService, this.resource, this.viewType, this.group, this.webview.options);
+    }
+    isDirty() {
+        if (!this._modelRef) {
+            return !!this._defaultDirtyState;
+        }
+        return this._modelRef.object.isDirty();
+    }
+    async save(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this._modelRef.object.saveCustomEditor(options);
+        if (!target) {
+            return undefined;
+        }
+        if (!isEqual(target, this.resource)) {
+            return { resource: target };
+        }
+        return this;
+    }
+    async saveAs(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const dialogPath = this._editorResource;
+        const target = await this.fileDialogService.pickFileToSave(dialogPath, options?.availableFileSystems);
+        if (!target) {
+            return undefined;
+        }
+        if (!(await this._modelRef.object.saveCustomEditorAs(this._editorResource, target, options))) {
+            return undefined;
+        }
+        return (await this.rename(groupId, target))?.editor;
+    }
+    async revert(group, options) {
+        if (this._modelRef) {
+            return this._modelRef.object.revert(options);
+        }
+        this._defaultDirtyState = false;
+        this._onDidChangeDirty.fire();
+    }
+    async resolve() {
+        await super.resolve();
+        if (this.isDisposed()) {
+            return null;
+        }
+        if (!this._modelRef) {
+            const oldCapabilities = this.capabilities;
+            this._modelRef = this._register(assertIsDefined(await this.customEditorService.models.tryRetain(this.resource, this.viewType)));
+            this._register(this._modelRef.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+            this._register(this._modelRef.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+            if (this._untitledDocumentData) {
+                this._defaultDirtyState = true;
+            }
+            if (this.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+            if (this.capabilities !== oldCapabilities) {
+                this._onDidChangeCapabilities.fire();
+            }
+        }
+        return null;
+    }
+    async rename(group, newResource) {
+        return { editor: { resource: newResource } };
+    }
+    undo() {
+        assertIsDefined(this._modelRef);
+        return this.undoRedoService.undo(this.resource);
+    }
+    redo() {
+        assertIsDefined(this._modelRef);
+        return this.undoRedoService.redo(this.resource);
+    }
+    onMove(handler) {
+        this._moveHandler = handler;
+    }
+    transfer(other) {
+        if (!super.transfer(other)) {
+            return;
+        }
+        other._moveHandler = this._moveHandler;
+        this._moveHandler = undefined;
+        return other;
+    }
+    get backupId() {
+        if (this._modelRef) {
+            return this._modelRef.object.backupId;
+        }
+        return this._backupId;
+    }
+    get untitledDocumentData() {
+        return this._untitledDocumentData;
+    }
+    toUntyped() {
+        return {
+            resource: this.resource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+};
+CustomEditorInput.typeId = 'workbench.editors.webviewEditor';
+CustomEditorInput = ( __decorate([
+    ( __param(3, IWebviewWorkbenchService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, ICustomEditorService)),
+    ( __param(7, IFileDialogService)),
+    ( __param(8, IUndoRedoService)),
+    ( __param(9, IFileService)),
+    ( __param(10, IFilesConfigurationService))
+], CustomEditorInput));
+export { CustomEditorInput };

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

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ICustomEditorService = ( createDecorator('customEditorService'));
+export { ICustomEditorService };

package/dist/vscode/vs/workbench/contrib/debug/browser/debugActionViewItems.js

@@ -59,6 +59,7 @@ let StartDebugActionViewItem = class StartDebugActionViewItem extends BaseAction
         const keybindingLabel = keybinding ? ` (${keybinding})` : '';
         this.start.title = this.action.label + keybindingLabel;
         this.start.setAttribute('role', 'button');
+        this.start.ariaLabel = this.start.title;
         this.toDispose.push(dom.addDisposableListener(this.start, dom.EventType.CLICK, () => {
             this.start.blur();
             if (this.debugService.state !== 1 ) {

package/dist/vscode/vs/workbench/contrib/debug/browser/debugCommands.js

@@ -407,7 +407,8 @@ KeybindingsRegistry.registerCommandAndKeybindingRule({
 KeybindingsRegistry.registerCommandAndKeybindingRule({
     id: STEP_OVER_ID,
     weight: 200 ,
-    primary: isWeb ? ((512  | 68) ) : 68 ,
+    primary: 68 ,
+    secondary: isWeb ? [((512  | 68) )] : undefined,
     when: ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')),
     handler: async (accessor, _, context) => {
         const contextKeyService = accessor.get(IContextKeyService);

package/dist/vscode/vs/workbench/contrib/debug/browser/debugConfigurationManager.js

@@ -3,7 +3,7 @@ import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { sequence } from 'monaco-editor/esm/vs/base/common/async.js';
 import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
@@ -163,22 +163,6 @@ let ConfigurationManager = class ConfigurationManager {
                 type,
                 pick: async () => {
                     await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    const disposables = ( new DisposableStore());
-                    const input = disposables.add(this.quickInputService.createQuickPick());
-                    input.busy = true;
-                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
-                    input.show();
-                    const chosenPromise = ( new Promise(resolve => {
-                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
-                        disposables.add(input.onDidTriggerItemButton(async (context) => {
-                            resolve(undefined);
-                            const { launch, config } = context.item;
-                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
-                            await launch.writeConfiguration(config);
-                            await this.selectConfiguration(launch, config.name);
-                            this.removeRecentDynamicConfigurations(config.name, config.type);
-                        }));
-                    }));
                     const token = ( new CancellationTokenSource());
                     const picks = [];
                     const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
@@ -196,10 +180,26 @@ let ConfigurationManager = class ConfigurationManager {
                             })))));
                         }
                     });
+                    const disposables = ( new DisposableStore());
+                    const input = disposables.add(this.quickInputService.createQuickPick());
+                    input.busy = true;
+                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
+                    const chosenPromise = ( new Promise(resolve => {
+                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
+                        disposables.add(input.onDidTriggerItemButton(async (context) => {
+                            resolve(undefined);
+                            const { launch, config } = context.item;
+                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
+                            await launch.writeConfiguration(config);
+                            await this.selectConfiguration(launch, config.name);
+                            this.removeRecentDynamicConfigurations(config.name, config.type);
+                        }));
+                    }));
                     const nestedPicks = await Promise.all(picks);
                     const items = flatten(nestedPicks);
                     input.items = items;
                     input.busy = false;
+                    input.show();
                     const chosen = await chosenPromise;
                     disposables.dispose();
                     if (!chosen) {
@@ -225,7 +225,7 @@ let ConfigurationManager = class ConfigurationManager {
     }
     removeRecentDynamicConfigurations(name, type) {
         const remaining = this.getRecentDynamicConfigurations().filter(c => c.name !== name || c.type !== type);
-        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 0 );
+        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 1 );
         if (this.selectedConfiguration.name === name && this.selectedType === type && this.selectedDynamic) {
             this.selectConfiguration(undefined, undefined);
         }
@@ -349,7 +349,7 @@ let ConfigurationManager = class ConfigurationManager {
             if (name && dynamicConfig.type) {
                 recentDynamicProviders.unshift({ name, type: dynamicConfig.type });
                 recentDynamicProviders = distinct(recentDynamicProviders, t => `${t.name} : ${t.type}`);
-                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 0 );
+                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 1 );
             }
         }
         else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
@@ -562,7 +562,7 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         if (!launchExistInFile) {
             const content = await this.getInitialConfigurationContent(undefined, type, useInitialConfigs, token);
             if (content) {
-                await this.configurationService.updateValue('launch', Json.parse(content), 5 );
+                await this.configurationService.updateValue('launch', json.parse(content), 5 );
             }
             else {
                 return { editor: null, created: false };