@codingame/monaco-vscode-api 1.79.7-next.1 → 1.79.7-next.2

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget.js

@@ -0,0 +1,301 @@
+import './simpleFindWidget.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
+import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { FindReplaceState } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findState.js';
+import { SimpleButton, findPreviousMatchIcon, findNextMatchIcon, NLS_MATCHES_LOCATION, NLS_NO_RESULTS } from 'monaco-editor/esm/vs/editor/contrib/find/browser/findWidget.js';
+import { ContextScopedFindInput } from 'monaco-editor/esm/vs/platform/history/browser/contextScopedHistoryWidget.js';
+import { widgetClose } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { showHistoryKeybindingHint } from 'monaco-editor/esm/vs/platform/history/browser/historyWidgetKeybindingHint.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { defaultInputBoxStyles, defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+const NLS_FIND_INPUT_LABEL = ( nls.localize('label.find', "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( nls.localize('placeholder.find', "Find (\u21C5 for history)"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( nls.localize('label.previousMatchButton', "Previous Match"));
+const NLS_NEXT_MATCH_BTN_LABEL = ( nls.localize('label.nextMatchButton', "Next Match"));
+const NLS_CLOSE_BTN_LABEL = ( nls.localize('label.closeButton', "Close"));
+const SIMPLE_FIND_WIDGET_INITIAL_WIDTH = 310;
+const MATCHES_COUNT_WIDTH = 73;
+class SimpleFindWidget extends Widget {
+    constructor(options, contextViewService, contextKeyService, _keybindingService) {
+        super();
+        this._keybindingService = _keybindingService;
+        this._isVisible = false;
+        this._foundMatch = false;
+        this._width = 0;
+        this.state = ( new FindReplaceState());
+        this._matchesLimit = options.matchesLimit ?? Number.MAX_SAFE_INTEGER;
+        this._findInput = this._register(( new ContextScopedFindInput(null, contextViewService, {
+            label: NLS_FIND_INPUT_LABEL,
+            placeholder: NLS_FIND_INPUT_PLACEHOLDER,
+            validation: (value) => {
+                if (value.length === 0 || !this._findInput.getRegex()) {
+                    return null;
+                }
+                try {
+                    return null;
+                }
+                catch (e) {
+                    this._foundMatch = false;
+                    this.updateButtons(this._foundMatch);
+                    return { content: e.message };
+                }
+            },
+            showCommonFindToggles: options.showCommonFindToggles,
+            appendCaseSensitiveLabel: options.appendCaseSensitiveLabel && options.type === 'Terminal' ? this._getKeybinding("workbench.action.terminal.toggleFindCaseSensitive" ) : undefined,
+            appendRegexLabel: options.appendRegexLabel && options.type === 'Terminal' ? this._getKeybinding("workbench.action.terminal.toggleFindRegex" ) : undefined,
+            appendWholeWordsLabel: options.appendWholeWordsLabel && options.type === 'Terminal' ? this._getKeybinding("workbench.action.terminal.toggleFindWholeWord" ) : undefined,
+            showHistoryHint: () => showHistoryKeybindingHint(_keybindingService),
+            inputBoxStyles: defaultInputBoxStyles,
+            toggleStyles: defaultToggleStyles
+        }, contextKeyService)));
+        this._updateHistoryDelayer = ( new Delayer(500));
+        this._register(this._findInput.onInput(async (e) => {
+            if (!options.checkImeCompletionState || !this._findInput.isImeSessionInProgress) {
+                this._foundMatch = this._onInputChanged();
+                if (options.showResultCount) {
+                    await this.updateResultCount();
+                }
+                this.updateButtons(this._foundMatch);
+                this.focusFindBox();
+                this._delayedUpdateHistory();
+            }
+        }));
+        this._findInput.setRegex(!!this.state.isRegex);
+        this._findInput.setCaseSensitive(!!this.state.matchCase);
+        this._findInput.setWholeWords(!!this.state.wholeWord);
+        this._register(this._findInput.onDidOptionChange(() => {
+            this.state.change({
+                isRegex: this._findInput.getRegex(),
+                wholeWord: this._findInput.getWholeWords(),
+                matchCase: this._findInput.getCaseSensitive()
+            }, true);
+        }));
+        this._register(this.state.onFindReplaceStateChange(() => {
+            this._findInput.setRegex(this.state.isRegex);
+            this._findInput.setWholeWords(this.state.wholeWord);
+            this._findInput.setCaseSensitive(this.state.matchCase);
+            this.findFirst();
+        }));
+        this.prevBtn = this._register(( new SimpleButton({
+            label: NLS_PREVIOUS_MATCH_BTN_LABEL,
+            icon: findPreviousMatchIcon,
+            onTrigger: () => {
+                this.find(true);
+            }
+        })));
+        this.nextBtn = this._register(( new SimpleButton({
+            label: NLS_NEXT_MATCH_BTN_LABEL,
+            icon: findNextMatchIcon,
+            onTrigger: () => {
+                this.find(false);
+            }
+        })));
+        const closeBtn = this._register(( new SimpleButton({
+            label: NLS_CLOSE_BTN_LABEL,
+            icon: widgetClose,
+            onTrigger: () => {
+                this.hide();
+            }
+        })));
+        this._innerDomNode = document.createElement('div');
+        this._innerDomNode.classList.add('simple-find-part');
+        this._innerDomNode.appendChild(this._findInput.domNode);
+        this._innerDomNode.appendChild(this.prevBtn.domNode);
+        this._innerDomNode.appendChild(this.nextBtn.domNode);
+        this._innerDomNode.appendChild(closeBtn.domNode);
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('simple-find-part-wrapper');
+        this._domNode.appendChild(this._innerDomNode);
+        this.onkeyup(this._innerDomNode, e => {
+            if (e.equals(9 )) {
+                this.hide();
+                e.preventDefault();
+                return;
+            }
+        });
+        this._focusTracker = this._register(dom.trackFocus(this._innerDomNode));
+        this._register(this._focusTracker.onDidFocus(this._onFocusTrackerFocus.bind(this)));
+        this._register(this._focusTracker.onDidBlur(this._onFocusTrackerBlur.bind(this)));
+        this._findInputFocusTracker = this._register(dom.trackFocus(this._findInput.domNode));
+        this._register(this._findInputFocusTracker.onDidFocus(this._onFindInputFocusTrackerFocus.bind(this)));
+        this._register(this._findInputFocusTracker.onDidBlur(this._onFindInputFocusTrackerBlur.bind(this)));
+        this._register(dom.addDisposableListener(this._innerDomNode, 'click', (event) => {
+            event.stopPropagation();
+        }));
+        if (options?.showResultCount) {
+            this._domNode.classList.add('result-count');
+            this._matchesCount = document.createElement('div');
+            this._matchesCount.className = 'matchesCount';
+            this._findInput.domNode.insertAdjacentElement('afterend', this._matchesCount);
+            this._register(this._findInput.onDidChange(async () => {
+                await this.updateResultCount();
+            }));
+            this._register(this._findInput.onDidOptionChange(async () => {
+                this._foundMatch = this._onInputChanged();
+                await this.updateResultCount();
+                this.focusFindBox();
+                this._delayedUpdateHistory();
+            }));
+        }
+    }
+    get inputValue() {
+        return this._findInput.getValue();
+    }
+    get focusTracker() {
+        return this._focusTracker;
+    }
+    _getKeybinding(actionId) {
+        const kb = this._keybindingService?.lookupKeybinding(actionId);
+        if (!kb) {
+            return '';
+        }
+        return ` (${kb.getLabel()})`;
+    }
+    dispose() {
+        super.dispose();
+        if (this._domNode && this._domNode.parentElement) {
+            this._domNode.parentElement.removeChild(this._domNode);
+        }
+    }
+    isVisible() {
+        return this._isVisible;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    reveal(initialInput, animated = true) {
+        if (initialInput) {
+            this._findInput.setValue(initialInput);
+        }
+        if (this._isVisible) {
+            this._findInput.select();
+            return;
+        }
+        this._isVisible = true;
+        this.updateResultCount();
+        this.layout();
+        setTimeout(() => {
+            this._innerDomNode.classList.toggle('suppress-transition', !animated);
+            this._innerDomNode.classList.add('visible', 'visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'false');
+            this._findInput.select();
+            if (!animated) {
+                setTimeout(() => {
+                    this._innerDomNode.classList.remove('suppress-transition');
+                }, 0);
+            }
+        }, 0);
+    }
+    show(initialInput) {
+        if (initialInput && !this._isVisible) {
+            this._findInput.setValue(initialInput);
+        }
+        this._isVisible = true;
+        this.layout();
+        setTimeout(() => {
+            this._innerDomNode.classList.add('visible', 'visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'false');
+        }, 0);
+    }
+    hide(animated = true) {
+        if (this._isVisible) {
+            this._innerDomNode.classList.toggle('suppress-transition', !animated);
+            this._innerDomNode.classList.remove('visible-transition');
+            this._innerDomNode.setAttribute('aria-hidden', 'true');
+            setTimeout(() => {
+                this._isVisible = false;
+                this.updateButtons(this._foundMatch);
+                this._innerDomNode.classList.remove('visible', 'suppress-transition');
+            }, animated ? 200 : 0);
+        }
+    }
+    layout(width = this._width) {
+        this._width = width;
+        if (!this._isVisible) {
+            return;
+        }
+        if (this._matchesCount) {
+            let reducedFindWidget = false;
+            if (SIMPLE_FIND_WIDGET_INITIAL_WIDTH + MATCHES_COUNT_WIDTH + 28 >= width) {
+                reducedFindWidget = true;
+            }
+            this._innerDomNode.classList.toggle('reduced-find-widget', reducedFindWidget);
+        }
+    }
+    _delayedUpdateHistory() {
+        this._updateHistoryDelayer.trigger(this._updateHistory.bind(this));
+    }
+    _updateHistory() {
+        this._findInput.inputBox.addToHistory();
+    }
+    _getRegexValue() {
+        return this._findInput.getRegex();
+    }
+    _getWholeWordValue() {
+        return this._findInput.getWholeWords();
+    }
+    _getCaseSensitiveValue() {
+        return this._findInput.getCaseSensitive();
+    }
+    updateButtons(foundMatch) {
+        const hasInput = this.inputValue.length > 0;
+        this.prevBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+        this.nextBtn.setEnabled(this._isVisible && hasInput && foundMatch);
+    }
+    focusFindBox() {
+        this.nextBtn.focus();
+        this._findInput.inputBox.focus();
+    }
+    async updateResultCount() {
+        if (!this._matchesCount) {
+            this.updateButtons(this._foundMatch);
+            return;
+        }
+        const count = await this._getResultCount();
+        this._matchesCount.innerText = '';
+        const showRedOutline = (this.inputValue.length > 0 && count?.resultCount === 0);
+        this._matchesCount.classList.toggle('no-results', showRedOutline);
+        let label = '';
+        if (count?.resultCount) {
+            let matchesCount = String(count.resultCount);
+            if (count.resultCount >= this._matchesLimit) {
+                matchesCount += '+';
+            }
+            let matchesPosition = String(count.resultIndex + 1);
+            if (matchesPosition === '0') {
+                matchesPosition = '?';
+            }
+            label = strings.format(NLS_MATCHES_LOCATION, matchesPosition, matchesCount);
+        }
+        else {
+            label = NLS_NO_RESULTS;
+        }
+        alert(this._announceSearchResults(label, this.inputValue));
+        this._matchesCount.appendChild(document.createTextNode(label));
+        this._foundMatch = !!count && count.resultCount > 0;
+        this.updateButtons(this._foundMatch);
+    }
+    changeState(state) {
+        this.state.change(state, false);
+    }
+    _announceSearchResults(label, searchString) {
+        if (!searchString) {
+            return ( nls.localize('ariaSearchNoInput', "Enter search input"));
+        }
+        if (label === NLS_NO_RESULTS) {
+            return searchString === ''
+                ? ( nls.localize('ariaSearchNoResultEmpty', "{0} found", label))
+                : ( nls.localize('ariaSearchNoResult', "{0} found for '{1}'", label, searchString));
+        }
+        return ( nls.localize(
+            'ariaSearchNoResultWithLineNumNoCurrentMatch',
+            "{0} found for '{1}'",
+            label,
+            searchString
+        ));
+    }
+}
+export { SimpleFindWidget };

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsOutline.js

@@ -0,0 +1,362 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore, Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IOutlineService } from '../../../../services/outline/browser/outline.js';
+import { Extensions } from '../../../../common/contributions.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { DocumentSymbolGroupRenderer, DocumentSymbolRenderer, DocumentSymbolIdentityProvider, DocumentSymbolNavigationLabelProvider, DocumentSymbolAccessibilityProvider, DocumentSymbolFilter, DocumentSymbolVirtualDelegate, DocumentSymbolComparator } from './documentSymbolsTree.js';
+import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { TreeElement, OutlineModel, OutlineElement, IOutlineModelService, OutlineGroup } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { raceCancellation, timeout, Barrier, TimeoutTimer } from 'monaco-editor/esm/vs/base/common/async.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IMarkerDecorationsService } from 'monaco-editor/esm/vs/editor/common/services/markerDecorations.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+let DocumentSymbolBreadcrumbsSource = class DocumentSymbolBreadcrumbsSource {
+    constructor(_editor, _textResourceConfigurationService) {
+        this._editor = _editor;
+        this._textResourceConfigurationService = _textResourceConfigurationService;
+        this._breadcrumbs = [];
+    }
+    getBreadcrumbElements() {
+        return this._breadcrumbs;
+    }
+    clear() {
+        this._breadcrumbs = [];
+    }
+    update(model, position) {
+        const newElements = this._computeBreadcrumbs(model, position);
+        this._breadcrumbs = newElements;
+    }
+    _computeBreadcrumbs(model, position) {
+        let item = model.getItemEnclosingPosition(position);
+        if (!item) {
+            return [];
+        }
+        const chain = [];
+        while (item) {
+            chain.push(item);
+            const parent = item.parent;
+            if (parent instanceof OutlineModel) {
+                break;
+            }
+            if (parent instanceof OutlineGroup && parent.parent && parent.parent.children.size === 1) {
+                break;
+            }
+            item = parent;
+        }
+        const result = [];
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const element = chain[i];
+            if (this._isFiltered(element)) {
+                break;
+            }
+            result.push(element);
+        }
+        if (result.length === 0) {
+            return [];
+        }
+        return result;
+    }
+    _isFiltered(element) {
+        if (!(element instanceof OutlineElement)) {
+            return false;
+        }
+        const key = `breadcrumbs.${DocumentSymbolFilter.kindToConfigName[element.symbol.kind]}`;
+        let uri;
+        if (this._editor && this._editor.getModel()) {
+            const model = this._editor.getModel();
+            uri = model.uri;
+        }
+        return !this._textResourceConfigurationService.getValue(uri, key);
+    }
+};
+DocumentSymbolBreadcrumbsSource = ( __decorate([
+    ( __param(1, ITextResourceConfigurationService))
+], DocumentSymbolBreadcrumbsSource));
+let DocumentSymbolsOutline = class DocumentSymbolsOutline {
+    get activeElement() {
+        const posistion = this._editor.getPosition();
+        if (!posistion || !this._outlineModel) {
+            return undefined;
+        }
+        else {
+            return this._outlineModel.getItemEnclosingPosition(posistion);
+        }
+    }
+    constructor(_editor, target, firstLoadBarrier, _languageFeaturesService, _codeEditorService, _outlineModelService, _configurationService, _markerDecorationsService, textResourceConfigurationService, instantiationService) {
+        this._editor = _editor;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._codeEditorService = _codeEditorService;
+        this._outlineModelService = _outlineModelService;
+        this._configurationService = _configurationService;
+        this._markerDecorationsService = _markerDecorationsService;
+        this._disposables = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._outlineDisposables = ( new DisposableStore());
+        this.outlineKind = 'documentSymbols';
+        this._breadcrumbsDataSource = ( new DocumentSymbolBreadcrumbsSource(_editor, textResourceConfigurationService));
+        const delegate = ( new DocumentSymbolVirtualDelegate());
+        const renderers = [( new DocumentSymbolGroupRenderer()), instantiationService.createInstance(DocumentSymbolRenderer, true)];
+        const treeDataSource = {
+            getChildren: (parent) => {
+                if (parent instanceof OutlineElement || parent instanceof OutlineGroup) {
+                    return ( parent.children.values());
+                }
+                if (parent === this && this._outlineModel) {
+                    return ( this._outlineModel.children.values());
+                }
+                return [];
+            }
+        };
+        const comparator = ( new DocumentSymbolComparator());
+        const initialState = textResourceConfigurationService.getValue(_editor.getModel()?.uri, "outline.collapseItems" );
+        const options = {
+            collapseByDefault: target === 2  || ((target === 1  && initialState === "alwaysCollapse") ),
+            expandOnlyOnTwistieClick: true,
+            multipleSelectionSupport: false,
+            identityProvider: ( new DocumentSymbolIdentityProvider()),
+            keyboardNavigationLabelProvider: ( new DocumentSymbolNavigationLabelProvider()),
+            accessibilityProvider: ( new DocumentSymbolAccessibilityProvider(( localize('document', "Document Symbols")))),
+            filter: target === 1
+                ? instantiationService.createInstance(DocumentSymbolFilter, 'outline')
+                : target === 2
+                    ? instantiationService.createInstance(DocumentSymbolFilter, 'breadcrumbs')
+                    : undefined
+        };
+        this.config = {
+            breadcrumbsDataSource: this._breadcrumbsDataSource,
+            delegate,
+            renderers,
+            treeDataSource,
+            comparator,
+            options,
+            quickPickDataSource: { getQuickPickElements: () => { throw new Error('not implemented'); } }
+        };
+        this._disposables.add(_languageFeaturesService.documentSymbolProvider.onDidChange(_ => this._createOutline()));
+        this._disposables.add(this._editor.onDidChangeModel(_ => this._createOutline()));
+        this._disposables.add(this._editor.onDidChangeModelLanguage(_ => this._createOutline()));
+        const updateSoon = ( new TimeoutTimer());
+        this._disposables.add(updateSoon);
+        this._disposables.add(this._editor.onDidChangeModelContent(event => {
+            const model = this._editor.getModel();
+            if (model) {
+                const timeout = _outlineModelService.getDebounceValue(model);
+                updateSoon.cancelAndSet(() => this._createOutline(event), timeout);
+            }
+        }));
+        this._disposables.add(this._editor.onDidDispose(() => this._outlineDisposables.clear()));
+        this._createOutline().finally(() => firstLoadBarrier.open());
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._outlineDisposables.dispose();
+    }
+    get isEmpty() {
+        return !this._outlineModel || TreeElement.empty(this._outlineModel);
+    }
+    get uri() {
+        return this._outlineModel?.uri;
+    }
+    async reveal(entry, options, sideBySide) {
+        const model = OutlineModel.get(entry);
+        if (!model || !(entry instanceof OutlineElement)) {
+            return;
+        }
+        await this._codeEditorService.openCodeEditor({
+            resource: model.uri,
+            options: {
+                ...options,
+                selection: Range.collapseToStart(entry.symbol.selectionRange),
+                selectionRevealType: 3 ,
+            }
+        }, this._editor, sideBySide);
+    }
+    preview(entry) {
+        if (!(entry instanceof OutlineElement)) {
+            return Disposable.None;
+        }
+        const { symbol } = entry;
+        this._editor.revealRangeInCenterIfOutsideViewport(symbol.range, 0 );
+        const decorationsCollection = this._editor.createDecorationsCollection([{
+                range: symbol.range,
+                options: {
+                    description: 'document-symbols-outline-range-highlight',
+                    className: 'rangeHighlight',
+                    isWholeLine: true
+                }
+            }]);
+        return toDisposable(() => decorationsCollection.clear());
+    }
+    captureViewState() {
+        const viewState = this._editor.saveViewState();
+        return toDisposable(() => {
+            if (viewState) {
+                this._editor.restoreViewState(viewState);
+            }
+        });
+    }
+    async _createOutline(contentChangeEvent) {
+        this._outlineDisposables.clear();
+        if (!contentChangeEvent) {
+            this._setOutlineModel(undefined);
+        }
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const buffer = this._editor.getModel();
+        if (!( this._languageFeaturesService.documentSymbolProvider.has(buffer))) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        const versionIdThen = buffer.getVersionId();
+        const timeoutTimer = ( new TimeoutTimer());
+        this._outlineDisposables.add(timeoutTimer);
+        this._outlineDisposables.add(toDisposable(() => cts.dispose(true)));
+        try {
+            const model = await this._outlineModelService.getOrCreate(buffer, cts.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (TreeElement.empty(model) || !this._editor.hasModel()) {
+                this._setOutlineModel(model);
+                return;
+            }
+            if (contentChangeEvent && this._outlineModel && buffer.getLineCount() >= 25) {
+                const newSize = TreeElement.size(model);
+                const newLength = buffer.getValueLength();
+                const newRatio = newSize / newLength;
+                const oldSize = TreeElement.size(this._outlineModel);
+                const oldLength = newLength - contentChangeEvent.changes.reduce((prev, value) => prev + value.rangeLength, 0);
+                const oldRatio = oldSize / oldLength;
+                if (newRatio <= oldRatio * 0.5 || newRatio >= oldRatio * 1.5) {
+                    const value = await raceCancellation(timeout(2000).then(() => true), cts.token, false);
+                    if (!value) {
+                        return;
+                    }
+                }
+            }
+            this._applyMarkersToOutline(model);
+            this._outlineDisposables.add(this._markerDecorationsService.onDidChangeMarker(textModel => {
+                if (isEqual(model.uri, textModel.uri)) {
+                    this._applyMarkersToOutline(model);
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration("outline.problems.enabled" )) {
+                    if (this._configurationService.getValue("outline.problems.enabled" )) {
+                        this._applyMarkersToOutline(model);
+                    }
+                    else {
+                        model.updateMarker([]);
+                    }
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('outline')) {
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('breadcrumbs') && this._editor.hasModel()) {
+                    this._breadcrumbsDataSource.update(model, this._editor.getPosition());
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration("outline.icons" )) {
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('outline')) {
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._editor.onDidChangeCursorPosition(_ => {
+                timeoutTimer.cancelAndSet(() => {
+                    if (!buffer.isDisposed() && versionIdThen === buffer.getVersionId() && this._editor.hasModel()) {
+                        this._breadcrumbsDataSource.update(model, this._editor.getPosition());
+                        this._onDidChange.fire({ affectOnlyActiveElement: true });
+                    }
+                }, 150);
+            }));
+            this._setOutlineModel(model);
+        }
+        catch (err) {
+            this._setOutlineModel(undefined);
+            onUnexpectedError(err);
+        }
+    }
+    _applyMarkersToOutline(model) {
+        if (!model || !this._configurationService.getValue("outline.problems.enabled" )) {
+            return;
+        }
+        const markers = [];
+        for (const [range, marker] of this._markerDecorationsService.getLiveMarkers(model.uri)) {
+            if (marker.severity === MarkerSeverity.Error || marker.severity === MarkerSeverity.Warning) {
+                markers.push({ ...range, severity: marker.severity });
+            }
+        }
+        model.updateMarker(markers);
+    }
+    _setOutlineModel(model) {
+        const position = this._editor.getPosition();
+        if (!position || !model) {
+            this._outlineModel = undefined;
+            this._breadcrumbsDataSource.clear();
+        }
+        else {
+            if (!this._outlineModel?.merge(model)) {
+                this._outlineModel = model;
+            }
+            this._breadcrumbsDataSource.update(model, position);
+        }
+        this._onDidChange.fire({});
+    }
+};
+DocumentSymbolsOutline = ( __decorate([
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IOutlineModelService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IMarkerDecorationsService)),
+    ( __param(8, ITextResourceConfigurationService)),
+    ( __param(9, IInstantiationService))
+], DocumentSymbolsOutline));
+let DocumentSymbolsOutlineCreator = class DocumentSymbolsOutlineCreator {
+    constructor(outlineService) {
+        const reg = outlineService.registerOutlineCreator(this);
+        this.dispose = () => reg.dispose();
+    }
+    matches(candidate) {
+        const ctrl = candidate.getControl();
+        return isCodeEditor(ctrl) || isDiffEditor(ctrl);
+    }
+    async createOutline(pane, target, _token) {
+        const control = pane.getControl();
+        let editor;
+        if (isCodeEditor(control)) {
+            editor = control;
+        }
+        else if (isDiffEditor(control)) {
+            editor = control.getModifiedEditor();
+        }
+        if (!editor) {
+            return undefined;
+        }
+        const firstLoadBarrier = ( new Barrier());
+        const result = editor.invokeWithinContext(accessor => accessor.get(IInstantiationService).createInstance(DocumentSymbolsOutline, editor, target, firstLoadBarrier));
+        await firstLoadBarrier.wait();
+        return result;
+    }
+};
+DocumentSymbolsOutlineCreator = ( __decorate([
+    ( __param(0, IOutlineService))
+], DocumentSymbolsOutlineCreator));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DocumentSymbolsOutlineCreator, 4 );

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-list .monaco-list-row.focused.selected .outline-element .monaco-highlighted-label,.monaco-list .monaco-list-row.focused.selected .outline-element-decoration{color:inherit!important}.monaco-list .outline-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-list .outline-element .monaco-highlighted-label{color:var(--outline-element-color)}.monaco-breadcrumbs .outline-element .outline-element-decoration,.monaco-list .outline-element .outline-element-decoration{color:var(--outline-element-color);font-size:90%;font-weight:600;margin-left:auto;opacity:.75;padding:0 12px 0 5px;text-align:center}.monaco-breadcrumbs .outline-element .monaco-icon-label-container .monaco-icon-description-container,.monaco-breadcrumbs .outline-element .outline-element-decoration{display:none}.monaco-list .outline-element .outline-element-decoration.bubble{font-family:codicon;font-size:14px;opacity:.4;padding-right:8px}.monaco-list .outline-element .outline-element-icon{margin-right:4px}";
+n(css,{});
+export { css, css as default };