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

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess.js

@@ -0,0 +1,217 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IQuickInputService, ItemActivation } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { AbstractGotoSymbolQuickAccessProvider } from 'monaco-editor/esm/vs/editor/contrib/quickAccess/browser/gotoSymbolQuickAccess.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable, toDisposable, DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { prepareQuery } from 'monaco-editor/esm/vs/base/common/fuzzyScorer.js';
+import { fuzzyScore, createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IOutlineService } from '../../../../services/outline/browser/outline.js';
+import { isCompositeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { IOutlineModelService } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+let GotoSymbolQuickAccessProvider = class GotoSymbolQuickAccessProvider extends AbstractGotoSymbolQuickAccessProvider {
+    constructor(editorService, editorGroupService, configurationService, languageFeaturesService, outlineService, outlineModelService) {
+        super(languageFeaturesService, outlineModelService, {
+            openSideBySideDirection: () => this.configuration.openSideBySideDirection
+        });
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.configurationService = configurationService;
+        this.outlineService = outlineService;
+        this.onDidActiveTextEditorControlChange = this.editorService.onDidActiveEditorChange;
+    }
+    get configuration() {
+        const editorConfig = this.configurationService.getValue().workbench?.editor;
+        return {
+            openEditorPinned: !editorConfig?.enablePreviewFromQuickOpen || !editorConfig?.enablePreview,
+            openSideBySideDirection: editorConfig?.openSideBySideDirection
+        };
+    }
+    get activeTextEditorControl() {
+        if (isCompositeEditor(this.editorService.activeEditorPane?.getControl())) {
+            return undefined;
+        }
+        return this.editorService.activeTextEditorControl;
+    }
+    gotoLocation(context, options) {
+        if ((options.keyMods.alt || (this.configuration.openEditorPinned && options.keyMods.ctrlCmd) || options.forceSideBySide) && this.editorService.activeEditor) {
+            context.restoreViewState?.();
+            const editorOptions = {
+                selection: options.range,
+                pinned: options.keyMods.ctrlCmd || this.configuration.openEditorPinned,
+                preserveFocus: options.preserveFocus
+            };
+            this.editorGroupService.sideGroup.openEditor(this.editorService.activeEditor, editorOptions);
+        }
+        else {
+            super.gotoLocation(context, options);
+        }
+    }
+    async getSymbolPicks(model, filter, options, disposables, token) {
+        const result = await Promise.race([
+            this.waitForLanguageSymbolRegistry(model, disposables),
+            timeout(GotoSymbolQuickAccessProvider.SYMBOL_PICKS_TIMEOUT)
+        ]);
+        if (!result || token.isCancellationRequested) {
+            return [];
+        }
+        return this.doGetSymbolPicks(this.getDocumentSymbols(model, token), prepareQuery(filter), options, token);
+    }
+    provideWithoutTextEditor(picker) {
+        if (this.canPickWithOutlineService()) {
+            return this.doGetOutlinePicks(picker);
+        }
+        return super.provideWithoutTextEditor(picker);
+    }
+    canPickWithOutlineService() {
+        return this.editorService.activeEditorPane ? this.outlineService.canCreateOutline(this.editorService.activeEditorPane) : false;
+    }
+    doGetOutlinePicks(picker) {
+        const pane = this.editorService.activeEditorPane;
+        if (!pane) {
+            return Disposable.None;
+        }
+        const cts = ( new CancellationTokenSource());
+        const disposables = ( new DisposableStore());
+        disposables.add(toDisposable(() => cts.dispose(true)));
+        picker.busy = true;
+        this.outlineService.createOutline(pane, 4 , cts.token).then(outline => {
+            if (!outline) {
+                return;
+            }
+            if (cts.token.isCancellationRequested) {
+                outline.dispose();
+                return;
+            }
+            disposables.add(outline);
+            const viewState = outline.captureViewState();
+            disposables.add(toDisposable(() => {
+                if (picker.selectedItems.length === 0) {
+                    viewState.dispose();
+                }
+            }));
+            const entries = outline.config.quickPickDataSource.getQuickPickElements();
+            const items = ( entries.map((entry, idx) => {
+                return {
+                    kind: 0 ,
+                    index: idx,
+                    score: 0,
+                    label: entry.label,
+                    description: entry.description,
+                    ariaLabel: entry.ariaLabel,
+                    iconClasses: entry.iconClasses
+                };
+            }));
+            disposables.add(picker.onDidAccept(() => {
+                picker.hide();
+                const [entry] = picker.selectedItems;
+                if (entry && entries[entry.index]) {
+                    outline.reveal(entries[entry.index].element, {}, false);
+                }
+            }));
+            const updatePickerItems = () => {
+                const filteredItems = items.filter(item => {
+                    if (picker.value === '@') {
+                        item.score = 0;
+                        item.highlights = undefined;
+                        return true;
+                    }
+                    const score = fuzzyScore(picker.value, picker.value.toLowerCase(), 1 , item.label, item.label.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
+                    if (!score) {
+                        return false;
+                    }
+                    item.score = score[1];
+                    item.highlights = { label: createMatches(score) };
+                    return true;
+                });
+                if (filteredItems.length === 0) {
+                    const label = ( localize('empty', 'No matching entries'));
+                    picker.items = [{ label, index: -1, kind: 14  }];
+                    picker.ariaLabel = label;
+                }
+                else {
+                    picker.items = filteredItems;
+                }
+            };
+            updatePickerItems();
+            disposables.add(picker.onDidChangeValue(updatePickerItems));
+            const previewDisposable = ( new MutableDisposable());
+            disposables.add(previewDisposable);
+            disposables.add(picker.onDidChangeActive(() => {
+                const [entry] = picker.activeItems;
+                if (entry && entries[entry.index]) {
+                    previewDisposable.value = outline.preview(entries[entry.index].element);
+                }
+                else {
+                    previewDisposable.clear();
+                }
+            }));
+        }).catch(err => {
+            onUnexpectedError(err);
+            picker.hide();
+        }).finally(() => {
+            picker.busy = false;
+        });
+        return disposables;
+    }
+};
+GotoSymbolQuickAccessProvider.SYMBOL_PICKS_TIMEOUT = 8000;
+GotoSymbolQuickAccessProvider = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, IOutlineService)),
+    ( __param(5, IOutlineModelService))
+], GotoSymbolQuickAccessProvider));
+class GotoSymbolAction extends Action2 {
+    constructor() {
+        super({
+            id: GotoSymbolAction.ID,
+            title: {
+                value: ( localize('gotoSymbol', "Go to Symbol in Editor...")),
+                mnemonicTitle: ( localize(
+                    { key: 'miGotoSymbolInEditor', comment: ['&& denotes a mnemonic'] },
+                    "Go to &&Symbol in Editor..."
+                )),
+                original: 'Go to Symbol in Editor...'
+            },
+            f1: true,
+            keybinding: {
+                when: undefined,
+                weight: 200 ,
+                primary: 2048  | 1024  | 45
+            },
+            menu: [{
+                    id: MenuId.MenubarGoMenu,
+                    group: '4_symbol_nav',
+                    order: 1
+                }]
+        });
+    }
+    run(accessor) {
+        accessor.get(IQuickInputService).quickAccess.show(GotoSymbolQuickAccessProvider.PREFIX, { itemActivation: ItemActivation.NONE });
+    }
+}
+GotoSymbolAction.ID = 'workbench.action.gotoSymbol';
+registerAction2(GotoSymbolAction);
+( Registry.as(Extensions.Quickaccess)).registerQuickAccessProvider({
+    ctor: GotoSymbolQuickAccessProvider,
+    prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX,
+    contextKey: 'inFileSymbolsPicker',
+    placeholder: ( localize('gotoSymbolQuickAccessPlaceholder', "Type the name of a symbol to go to.")),
+    helpEntries: [
+        { description: ( localize('gotoSymbolQuickAccess', "Go to Symbol in Editor")), prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX, commandId: GotoSymbolAction.ID },
+        { description: ( localize('gotoSymbolByCategoryQuickAccess', "Go to Symbol in Editor by Category")), prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX_BY_CATEGORY }
+    ]
+});
+export { GotoSymbolQuickAccessProvider };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".suggest-input-container{border-radius:2px;padding:2px 6px}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor-background,.suggest-input-container .mtk1{color:inherit}.suggest-input-container .suggest-input-placeholder{margin-top:1px;overflow:hidden;pointer-events:none;position:absolute;text-overflow:ellipsis;white-space:nowrap;z-index:1}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor .lines-content{background:none}";
+n(css,{});
+export { css, css as default };

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/codeEditor/browser/workbenchReferenceSearch.js

@@ -0,0 +1,24 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { ReferencesController } from 'monaco-editor/esm/vs/editor/contrib/gotoSymbol/browser/peek/referencesController.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+let WorkbenchReferencesController = class WorkbenchReferencesController extends ReferencesController {
+    constructor(editor, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService) {
+        super(false, editor, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService);
+    }
+};
+WorkbenchReferencesController = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IConfigurationService))
+], WorkbenchReferencesController));
+registerEditorContribution(ReferencesController.ID, WorkbenchReferencesController, 4 );
+export { WorkbenchReferencesController };