@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/base/browser/ui/tree/abstractTree.js

@@ -0,0 +1,1949 @@
+import { append, $, clearNode, createStyleSheet, isActiveElement, hasParentWithClass, h, getWindow } from '../../dom.js';
+import { DomEmitter } from '../../event.js';
+import { StandardKeyboardEvent } from '../../keyboardEvent.js';
+import { ActionBar } from '../actionbar/actionbar.js';
+import { FindInput } from '../findinput/findInput.js';
+import { unthemedInboxStyles } from '../inputbox/inputBox.js';
+import { ElementsDragAndDropData } from '../list/listView.js';
+import { isInputElement, List, MouseController, isButton, isMonacoEditor, isStickyScrollElement, isMonacoCustomToggle, isActionItem } from '../list/listWidget.js';
+import { Toggle, unthemedToggleStyles } from '../toggle/toggle.js';
+import { isFilterResult, getVisibleState } from './indexTreeModel.js';
+import { TreeMouseEventTarget, TreeError } from './tree.js';
+import { Action } from '../../../common/actions.js';
+import { firstOrDefault, equals, distinct, range } from '../../../common/arrays.js';
+import { Delayer, disposableTimeout, timeout } from '../../../common/async.js';
+import { Codicon } from '../../../common/codicons.js';
+import { ThemeIcon } from '../../../common/themables.js';
+import { SetMap } from '../../../common/map.js';
+import { Event, EventBufferer, Emitter, Relay } from '../../../common/event.js';
+import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
+import { Disposable, DisposableStore, toDisposable, dispose } from '../../../common/lifecycle.js';
+import { clamp } from '../../../common/numbers.js';
+import { isNumber } from '../../../common/types.js';
+import './media/tree.css.js';
+import { localizeWithPath } from '../../../../nls.js';
+class TreeElementsDragAndDropData extends ElementsDragAndDropData {
+    set context(context) {
+        this.data.context = context;
+    }
+    get context() {
+        return this.data.context;
+    }
+    constructor(data) {
+        super(( data.elements.map(node => node.element)));
+        this.data = data;
+    }
+}
+function asTreeDragAndDropData(data) {
+    if (data instanceof ElementsDragAndDropData) {
+        return ( new TreeElementsDragAndDropData(data));
+    }
+    return data;
+}
+class TreeNodeListDragAndDrop {
+    constructor(modelProvider, dnd) {
+        this.modelProvider = modelProvider;
+        this.dnd = dnd;
+        this.autoExpandDisposable = Disposable.None;
+        this.disposables = ( new DisposableStore());
+    }
+    getDragURI(node) {
+        return this.dnd.getDragURI(node.element);
+    }
+    getDragLabel(nodes, originalEvent) {
+        if (this.dnd.getDragLabel) {
+            return this.dnd.getDragLabel(( nodes.map(node => node.element)), originalEvent);
+        }
+        return undefined;
+    }
+    onDragStart(data, originalEvent) {
+        this.dnd.onDragStart?.(asTreeDragAndDropData(data), originalEvent);
+    }
+    onDragOver(data, targetNode, targetIndex, originalEvent, raw = true) {
+        const result = this.dnd.onDragOver(asTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, originalEvent);
+        const didChangeAutoExpandNode = this.autoExpandNode !== targetNode;
+        if (didChangeAutoExpandNode) {
+            this.autoExpandDisposable.dispose();
+            this.autoExpandNode = targetNode;
+        }
+        if (typeof targetNode === 'undefined') {
+            return result;
+        }
+        if (didChangeAutoExpandNode && typeof result !== 'boolean' && result.autoExpand) {
+            this.autoExpandDisposable = disposableTimeout(() => {
+                const model = this.modelProvider();
+                const ref = model.getNodeLocation(targetNode);
+                if (model.isCollapsed(ref)) {
+                    model.setCollapsed(ref, false);
+                }
+                this.autoExpandNode = undefined;
+            }, 500, this.disposables);
+        }
+        if (typeof result === 'boolean' || !result.accept || typeof result.bubble === 'undefined' || result.feedback) {
+            if (!raw) {
+                const accept = typeof result === 'boolean' ? result : result.accept;
+                const effect = typeof result === 'boolean' ? undefined : result.effect;
+                return { accept, effect, feedback: [targetIndex] };
+            }
+            return result;
+        }
+        if (result.bubble === 1 ) {
+            const model = this.modelProvider();
+            const ref = model.getNodeLocation(targetNode);
+            const parentRef = model.getParentNodeLocation(ref);
+            const parentNode = model.getNode(parentRef);
+            const parentIndex = parentRef && model.getListIndex(parentRef);
+            return this.onDragOver(data, parentNode, parentIndex, originalEvent, false);
+        }
+        const model = this.modelProvider();
+        const ref = model.getNodeLocation(targetNode);
+        const start = model.getListIndex(ref);
+        const length = model.getListRenderCount(ref);
+        return { ...result, feedback: range(start, start + length) };
+    }
+    drop(data, targetNode, targetIndex, originalEvent) {
+        this.autoExpandDisposable.dispose();
+        this.autoExpandNode = undefined;
+        this.dnd.drop(asTreeDragAndDropData(data), targetNode && targetNode.element, targetIndex, originalEvent);
+    }
+    onDragEnd(originalEvent) {
+        this.dnd.onDragEnd?.(originalEvent);
+    }
+    dispose() {
+        this.disposables.dispose();
+        this.dnd.dispose();
+    }
+}
+function asListOptions(modelProvider, options) {
+    return options && {
+        ...options,
+        identityProvider: options.identityProvider && {
+            getId(el) {
+                return options.identityProvider.getId(el.element);
+            }
+        },
+        dnd: options.dnd && ( new TreeNodeListDragAndDrop(modelProvider, options.dnd)),
+        multipleSelectionController: options.multipleSelectionController && {
+            isSelectionSingleChangeEvent(e) {
+                return options.multipleSelectionController.isSelectionSingleChangeEvent({ ...e, element: e.element });
+            },
+            isSelectionRangeChangeEvent(e) {
+                return options.multipleSelectionController.isSelectionRangeChangeEvent({ ...e, element: e.element });
+            }
+        },
+        accessibilityProvider: options.accessibilityProvider && {
+            ...options.accessibilityProvider,
+            getSetSize(node) {
+                const model = modelProvider();
+                const ref = model.getNodeLocation(node);
+                const parentRef = model.getParentNodeLocation(ref);
+                const parentNode = model.getNode(parentRef);
+                return parentNode.visibleChildrenCount;
+            },
+            getPosInSet(node) {
+                return node.visibleChildIndex + 1;
+            },
+            isChecked: options.accessibilityProvider && options.accessibilityProvider.isChecked ? (node) => {
+                return options.accessibilityProvider.isChecked(node.element);
+            } : undefined,
+            getRole: options.accessibilityProvider && options.accessibilityProvider.getRole ? (node) => {
+                return options.accessibilityProvider.getRole(node.element);
+            } : () => 'treeitem',
+            getAriaLabel(e) {
+                return options.accessibilityProvider.getAriaLabel(e.element);
+            },
+            getWidgetAriaLabel() {
+                return options.accessibilityProvider.getWidgetAriaLabel();
+            },
+            getWidgetRole: options.accessibilityProvider && options.accessibilityProvider.getWidgetRole ? () => options.accessibilityProvider.getWidgetRole() : () => 'tree',
+            getAriaLevel: options.accessibilityProvider && options.accessibilityProvider.getAriaLevel ? (node) => options.accessibilityProvider.getAriaLevel(node.element) : (node) => {
+                return node.depth;
+            },
+            getActiveDescendantId: options.accessibilityProvider.getActiveDescendantId && (node => {
+                return options.accessibilityProvider.getActiveDescendantId(node.element);
+            })
+        },
+        keyboardNavigationLabelProvider: options.keyboardNavigationLabelProvider && {
+            ...options.keyboardNavigationLabelProvider,
+            getKeyboardNavigationLabel(node) {
+                return options.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(node.element);
+            }
+        }
+    };
+}
+class ComposedTreeDelegate {
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    getHeight(element) {
+        return this.delegate.getHeight(element.element);
+    }
+    getTemplateId(element) {
+        return this.delegate.getTemplateId(element.element);
+    }
+    hasDynamicHeight(element) {
+        return !!this.delegate.hasDynamicHeight && this.delegate.hasDynamicHeight(element.element);
+    }
+    setDynamicHeight(element, height) {
+        this.delegate.setDynamicHeight?.(element.element, height);
+    }
+}
+class AbstractTreeViewState {
+    static lift(state) {
+        return state instanceof AbstractTreeViewState ? state : ( new AbstractTreeViewState(state));
+    }
+    static empty(scrollTop = 0) {
+        return ( new AbstractTreeViewState({
+            focus: [],
+            selection: [],
+            expanded: Object.create(null),
+            scrollTop,
+        }));
+    }
+    constructor(state) {
+        this.focus = ( new Set(state.focus));
+        this.selection = ( new Set(state.selection));
+        if (state.expanded instanceof Array) {
+            this.expanded = Object.create(null);
+            for (const id of state.expanded) {
+                this.expanded[id] = 1;
+            }
+        }
+        else {
+            this.expanded = state.expanded;
+        }
+        this.expanded = state.expanded;
+        this.scrollTop = state.scrollTop;
+    }
+    toJSON() {
+        return {
+            focus: Array.from(this.focus),
+            selection: Array.from(this.selection),
+            expanded: this.expanded,
+            scrollTop: this.scrollTop,
+        };
+    }
+}
+var RenderIndentGuides;
+( (function(RenderIndentGuides) {
+    RenderIndentGuides["None"] = "none";
+    RenderIndentGuides["OnHover"] = "onHover";
+    RenderIndentGuides["Always"] = "always";
+})(RenderIndentGuides || (RenderIndentGuides = {})));
+class EventCollection {
+    get elements() {
+        return this._elements;
+    }
+    constructor(onDidChange, _elements = []) {
+        this._elements = _elements;
+        this.disposables = ( new DisposableStore());
+        this.onDidChange = Event.forEach(onDidChange, elements => this._elements = elements, this.disposables);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+}
+class TreeRenderer {
+    static { this.DefaultIndent = 8; }
+    constructor(renderer, modelProvider, onDidChangeCollapseState, activeNodes, renderedIndentGuides, options = {}) {
+        this.renderer = renderer;
+        this.modelProvider = modelProvider;
+        this.activeNodes = activeNodes;
+        this.renderedIndentGuides = renderedIndentGuides;
+        this.renderedElements = ( new Map());
+        this.renderedNodes = ( new Map());
+        this.indent = TreeRenderer.DefaultIndent;
+        this.hideTwistiesOfChildlessElements = false;
+        this.shouldRenderIndentGuides = false;
+        this.activeIndentNodes = ( new Set());
+        this.indentGuidesDisposable = Disposable.None;
+        this.disposables = ( new DisposableStore());
+        this.templateId = renderer.templateId;
+        this.updateOptions(options);
+        ( Event.map(onDidChangeCollapseState, e => e.node))(this.onDidChangeNodeTwistieState, this, this.disposables);
+        renderer.onDidChangeTwistieState?.(this.onDidChangeTwistieState, this, this.disposables);
+    }
+    updateOptions(options = {}) {
+        if (typeof options.indent !== 'undefined') {
+            const indent = clamp(options.indent, 0, 40);
+            if (indent !== this.indent) {
+                this.indent = indent;
+                for (const [node, templateData] of this.renderedNodes) {
+                    this.renderTreeElement(node, templateData);
+                }
+            }
+        }
+        if (typeof options.renderIndentGuides !== 'undefined') {
+            const shouldRenderIndentGuides = options.renderIndentGuides !== RenderIndentGuides.None;
+            if (shouldRenderIndentGuides !== this.shouldRenderIndentGuides) {
+                this.shouldRenderIndentGuides = shouldRenderIndentGuides;
+                for (const [node, templateData] of this.renderedNodes) {
+                    this._renderIndentGuides(node, templateData);
+                }
+                this.indentGuidesDisposable.dispose();
+                if (shouldRenderIndentGuides) {
+                    const disposables = ( new DisposableStore());
+                    this.activeNodes.onDidChange(this._onDidChangeActiveNodes, this, disposables);
+                    this.indentGuidesDisposable = disposables;
+                    this._onDidChangeActiveNodes(this.activeNodes.elements);
+                }
+            }
+        }
+        if (typeof options.hideTwistiesOfChildlessElements !== 'undefined') {
+            this.hideTwistiesOfChildlessElements = options.hideTwistiesOfChildlessElements;
+        }
+    }
+    renderTemplate(container) {
+        const el = append(container, $('.monaco-tl-row'));
+        const indent = append(el, $('.monaco-tl-indent'));
+        const twistie = append(el, $('.monaco-tl-twistie'));
+        const contents = append(el, $('.monaco-tl-contents'));
+        const templateData = this.renderer.renderTemplate(contents);
+        return { container, indent, twistie, indentGuidesDisposable: Disposable.None, templateData };
+    }
+    renderElement(node, index, templateData, height) {
+        this.renderedNodes.set(node, templateData);
+        this.renderedElements.set(node.element, node);
+        this.renderTreeElement(node, templateData);
+        this.renderer.renderElement(node, index, templateData.templateData, height);
+    }
+    disposeElement(node, index, templateData, height) {
+        templateData.indentGuidesDisposable.dispose();
+        this.renderer.disposeElement?.(node, index, templateData.templateData, height);
+        if (typeof height === 'number') {
+            this.renderedNodes.delete(node);
+            this.renderedElements.delete(node.element);
+        }
+    }
+    disposeTemplate(templateData) {
+        this.renderer.disposeTemplate(templateData.templateData);
+    }
+    onDidChangeTwistieState(element) {
+        const node = this.renderedElements.get(element);
+        if (!node) {
+            return;
+        }
+        this.onDidChangeNodeTwistieState(node);
+    }
+    onDidChangeNodeTwistieState(node) {
+        const templateData = this.renderedNodes.get(node);
+        if (!templateData) {
+            return;
+        }
+        this._onDidChangeActiveNodes(this.activeNodes.elements);
+        this.renderTreeElement(node, templateData);
+    }
+    renderTreeElement(node, templateData) {
+        const indent = TreeRenderer.DefaultIndent + (node.depth - 1) * this.indent;
+        templateData.twistie.style.paddingLeft = `${indent}px`;
+        templateData.indent.style.width = `${indent + this.indent - 16}px`;
+        if (node.collapsible) {
+            templateData.container.setAttribute('aria-expanded', String(!node.collapsed));
+        }
+        else {
+            templateData.container.removeAttribute('aria-expanded');
+        }
+        templateData.twistie.classList.remove(...ThemeIcon.asClassNameArray(Codicon.treeItemExpanded));
+        let twistieRendered = false;
+        if (this.renderer.renderTwistie) {
+            twistieRendered = this.renderer.renderTwistie(node.element, templateData.twistie);
+        }
+        if (node.collapsible && (!this.hideTwistiesOfChildlessElements || node.visibleChildrenCount > 0)) {
+            if (!twistieRendered) {
+                templateData.twistie.classList.add(...ThemeIcon.asClassNameArray(Codicon.treeItemExpanded));
+            }
+            templateData.twistie.classList.add('collapsible');
+            templateData.twistie.classList.toggle('collapsed', node.collapsed);
+        }
+        else {
+            templateData.twistie.classList.remove('collapsible', 'collapsed');
+        }
+        this._renderIndentGuides(node, templateData);
+    }
+    _renderIndentGuides(node, templateData) {
+        clearNode(templateData.indent);
+        templateData.indentGuidesDisposable.dispose();
+        if (!this.shouldRenderIndentGuides) {
+            return;
+        }
+        const disposableStore = ( new DisposableStore());
+        const model = this.modelProvider();
+        while (true) {
+            const ref = model.getNodeLocation(node);
+            const parentRef = model.getParentNodeLocation(ref);
+            if (!parentRef) {
+                break;
+            }
+            const parent = model.getNode(parentRef);
+            const guide = $('.indent-guide', { style: `width: ${this.indent}px` });
+            if (( this.activeIndentNodes.has(parent))) {
+                guide.classList.add('active');
+            }
+            if (templateData.indent.childElementCount === 0) {
+                templateData.indent.appendChild(guide);
+            }
+            else {
+                templateData.indent.insertBefore(guide, templateData.indent.firstElementChild);
+            }
+            this.renderedIndentGuides.add(parent, guide);
+            disposableStore.add(toDisposable(() => this.renderedIndentGuides.delete(parent, guide)));
+            node = parent;
+        }
+        templateData.indentGuidesDisposable = disposableStore;
+    }
+    _onDidChangeActiveNodes(nodes) {
+        if (!this.shouldRenderIndentGuides) {
+            return;
+        }
+        const set = ( new Set());
+        const model = this.modelProvider();
+        nodes.forEach(node => {
+            const ref = model.getNodeLocation(node);
+            try {
+                const parentRef = model.getParentNodeLocation(ref);
+                if (node.collapsible && node.children.length > 0 && !node.collapsed) {
+                    set.add(node);
+                }
+                else if (parentRef) {
+                    set.add(model.getNode(parentRef));
+                }
+            }
+            catch {
+            }
+        });
+        this.activeIndentNodes.forEach(node => {
+            if (!( set.has(node))) {
+                this.renderedIndentGuides.forEach(node, line => line.classList.remove('active'));
+            }
+        });
+        set.forEach(node => {
+            if (!( this.activeIndentNodes.has(node))) {
+                this.renderedIndentGuides.forEach(node, line => line.classList.add('active'));
+            }
+        });
+        this.activeIndentNodes = set;
+    }
+    dispose() {
+        this.renderedNodes.clear();
+        this.renderedElements.clear();
+        this.indentGuidesDisposable.dispose();
+        dispose(this.disposables);
+    }
+}
+class FindFilter {
+    get totalCount() { return this._totalCount; }
+    get matchCount() { return this._matchCount; }
+    set pattern(pattern) {
+        this._pattern = pattern;
+        this._lowercasePattern = pattern.toLowerCase();
+    }
+    constructor(tree, keyboardNavigationLabelProvider, _filter) {
+        this.tree = tree;
+        this.keyboardNavigationLabelProvider = keyboardNavigationLabelProvider;
+        this._filter = _filter;
+        this._totalCount = 0;
+        this._matchCount = 0;
+        this._pattern = '';
+        this._lowercasePattern = '';
+        this.disposables = ( new DisposableStore());
+        tree.onWillRefilter(this.reset, this, this.disposables);
+    }
+    filter(element, parentVisibility) {
+        let visibility = 1 ;
+        if (this._filter) {
+            const result = this._filter.filter(element, parentVisibility);
+            if (typeof result === 'boolean') {
+                visibility = result ? 1  : 0 ;
+            }
+            else if (isFilterResult(result)) {
+                visibility = getVisibleState(result.visibility);
+            }
+            else {
+                visibility = result;
+            }
+            if (visibility === 0 ) {
+                return false;
+            }
+        }
+        this._totalCount++;
+        if (!this._pattern) {
+            this._matchCount++;
+            return { data: FuzzyScore.Default, visibility };
+        }
+        const label = this.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(element);
+        const labels = Array.isArray(label) ? label : [label];
+        for (const l of labels) {
+            const labelStr = l && ( l.toString());
+            if (typeof labelStr === 'undefined') {
+                return { data: FuzzyScore.Default, visibility };
+            }
+            let score;
+            if (this.tree.findMatchType === TreeFindMatchType.Contiguous) {
+                const index = labelStr.toLowerCase().indexOf(this._lowercasePattern);
+                if (index > -1) {
+                    score = [Number.MAX_SAFE_INTEGER, 0];
+                    for (let i = this._lowercasePattern.length; i > 0; i--) {
+                        score.push(index + i - 1);
+                    }
+                }
+            }
+            else {
+                score = fuzzyScore(this._pattern, this._lowercasePattern, 0, labelStr, labelStr.toLowerCase(), 0, { firstMatchCanBeWeak: true, boostFullMatch: true });
+            }
+            if (score) {
+                this._matchCount++;
+                return labels.length === 1 ?
+                    { data: score, visibility } :
+                    { data: { label: labelStr, score: score }, visibility };
+            }
+        }
+        if (this.tree.findMode === TreeFindMode.Filter) {
+            if (typeof this.tree.options.defaultFindVisibility === 'number') {
+                return this.tree.options.defaultFindVisibility;
+            }
+            else if (this.tree.options.defaultFindVisibility) {
+                return this.tree.options.defaultFindVisibility(element);
+            }
+            else {
+                return 2 ;
+            }
+        }
+        else {
+            return { data: FuzzyScore.Default, visibility };
+        }
+    }
+    reset() {
+        this._totalCount = 0;
+        this._matchCount = 0;
+    }
+    dispose() {
+        dispose(this.disposables);
+    }
+}
+class ModeToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.listFilter,
+            title: ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'filter', "Filter")),
+            isChecked: opts.isChecked ?? false,
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+class FuzzyToggle extends Toggle {
+    constructor(opts) {
+        super({
+            icon: Codicon.searchFuzzy,
+            title: ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'fuzzySearch', "Fuzzy Match")),
+            isChecked: opts.isChecked ?? false,
+            inputActiveOptionBorder: opts.inputActiveOptionBorder,
+            inputActiveOptionForeground: opts.inputActiveOptionForeground,
+            inputActiveOptionBackground: opts.inputActiveOptionBackground
+        });
+    }
+}
+const unthemedFindWidgetStyles = {
+    inputBoxStyles: unthemedInboxStyles,
+    toggleStyles: unthemedToggleStyles,
+    listFilterWidgetBackground: undefined,
+    listFilterWidgetNoMatchesOutline: undefined,
+    listFilterWidgetOutline: undefined,
+    listFilterWidgetShadow: undefined
+};
+var TreeFindMode;
+( (function(TreeFindMode) {
+    TreeFindMode[TreeFindMode["Highlight"] = 0] = "Highlight";
+    TreeFindMode[TreeFindMode["Filter"] = 1] = "Filter";
+})(TreeFindMode || (TreeFindMode = {})));
+var TreeFindMatchType;
+( (function(TreeFindMatchType) {
+    TreeFindMatchType[TreeFindMatchType["Fuzzy"] = 0] = "Fuzzy";
+    TreeFindMatchType[TreeFindMatchType["Contiguous"] = 1] = "Contiguous";
+})(TreeFindMatchType || (TreeFindMatchType = {})));
+class FindWidget extends Disposable {
+    set mode(mode) {
+        this.modeToggle.checked = mode === TreeFindMode.Filter;
+        this.findInput.inputBox.setPlaceHolder(mode === TreeFindMode.Filter ? ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'type to filter', "Type to filter")) : ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'type to search', "Type to search")));
+    }
+    set matchType(matchType) {
+        this.matchTypeToggle.checked = matchType === TreeFindMatchType.Fuzzy;
+    }
+    get value() {
+        return this.findInput.inputBox.value;
+    }
+    set value(value) {
+        this.findInput.inputBox.value = value;
+    }
+    constructor(container, tree, contextViewProvider, mode, matchType, options) {
+        super();
+        this.tree = tree;
+        this.elements = h('.monaco-tree-type-filter', [
+            h('.monaco-tree-type-filter-grab.codicon.codicon-debug-gripper@grab', { tabIndex: 0 }),
+            h('.monaco-tree-type-filter-input@findInput'),
+            h('.monaco-tree-type-filter-actionbar@actionbar'),
+        ]);
+        this.width = 0;
+        this.right = 0;
+        this.top = 0;
+        this._onDidDisable = ( new Emitter());
+        this.onDidDisable = this._onDidDisable.event;
+        container.appendChild(this.elements.root);
+        this._register(toDisposable(() => container.removeChild(this.elements.root)));
+        const styles = options?.styles ?? unthemedFindWidgetStyles;
+        if (styles.listFilterWidgetBackground) {
+            this.elements.root.style.backgroundColor = styles.listFilterWidgetBackground;
+        }
+        if (styles.listFilterWidgetShadow) {
+            this.elements.root.style.boxShadow = `0 0 8px 2px ${styles.listFilterWidgetShadow}`;
+        }
+        this.modeToggle = this._register(( new ModeToggle({ ...styles.toggleStyles, isChecked: mode === TreeFindMode.Filter })));
+        this.matchTypeToggle = this._register(( new FuzzyToggle(
+            { ...styles.toggleStyles, isChecked: matchType === TreeFindMatchType.Fuzzy }
+        )));
+        this.onDidChangeMode = ( Event.map(
+            this.modeToggle.onChange,
+            () => this.modeToggle.checked ? TreeFindMode.Filter : TreeFindMode.Highlight,
+            this._store
+        ));
+        this.onDidChangeMatchType = ( Event.map(
+            this.matchTypeToggle.onChange,
+            () => this.matchTypeToggle.checked ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous,
+            this._store
+        ));
+        this.findInput = this._register(( new FindInput(this.elements.findInput, contextViewProvider, {
+            label: ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'type to search', "Type to search")),
+            additionalToggles: [this.modeToggle, this.matchTypeToggle],
+            showCommonFindToggles: false,
+            inputBoxStyles: styles.inputBoxStyles,
+            toggleStyles: styles.toggleStyles,
+            history: options?.history
+        })));
+        this.actionbar = this._register(( new ActionBar(this.elements.actionbar)));
+        this.mode = mode;
+        const emitter = this._register(( new DomEmitter(this.findInput.inputBox.inputElement, 'keydown')));
+        const onKeyDown = Event.chain(emitter.event, $ => ( $.map(e => ( new StandardKeyboardEvent(e)))));
+        this._register(onKeyDown((e) => {
+            if (e.equals(3 )) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.findInput.inputBox.addToHistory();
+                this.tree.domFocus();
+                return;
+            }
+            if (e.equals(18 )) {
+                e.preventDefault();
+                e.stopPropagation();
+                if (this.findInput.inputBox.isAtLastInHistory() || this.findInput.inputBox.isNowhereInHistory()) {
+                    this.findInput.inputBox.addToHistory();
+                    this.tree.domFocus();
+                }
+                else {
+                    this.findInput.inputBox.showNextValue();
+                }
+                return;
+            }
+            if (e.equals(16 )) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.findInput.inputBox.showPreviousValue();
+                return;
+            }
+        }));
+        const closeAction = this._register(( new Action('close', ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'close', "Close")), 'codicon codicon-close', true, () => this.dispose())));
+        this.actionbar.push(closeAction, { icon: true, label: false });
+        const onGrabMouseDown = this._register(( new DomEmitter(this.elements.grab, 'mousedown')));
+        this._register(onGrabMouseDown.event(e => {
+            const disposables = ( new DisposableStore());
+            const onWindowMouseMove = disposables.add(( new DomEmitter(getWindow(e), 'mousemove')));
+            const onWindowMouseUp = disposables.add(( new DomEmitter(getWindow(e), 'mouseup')));
+            const startRight = this.right;
+            const startX = e.pageX;
+            const startTop = this.top;
+            const startY = e.pageY;
+            this.elements.grab.classList.add('grabbing');
+            const transition = this.elements.root.style.transition;
+            this.elements.root.style.transition = 'unset';
+            const update = (e) => {
+                const deltaX = e.pageX - startX;
+                this.right = startRight - deltaX;
+                const deltaY = e.pageY - startY;
+                this.top = startTop + deltaY;
+                this.layout();
+            };
+            disposables.add(onWindowMouseMove.event(update));
+            disposables.add(onWindowMouseUp.event(e => {
+                update(e);
+                this.elements.grab.classList.remove('grabbing');
+                this.elements.root.style.transition = transition;
+                disposables.dispose();
+            }));
+        }));
+        const onGrabKeyDown = Event.chain(this._register(( new DomEmitter(this.elements.grab, 'keydown'))).event, $ => ( $.map(e => ( new StandardKeyboardEvent(e)))));
+        this._register(onGrabKeyDown((e) => {
+            let right;
+            let top;
+            if (e.keyCode === 15 ) {
+                right = Number.POSITIVE_INFINITY;
+            }
+            else if (e.keyCode === 17 ) {
+                right = 0;
+            }
+            else if (e.keyCode === 10 ) {
+                right = this.right === 0 ? Number.POSITIVE_INFINITY : 0;
+            }
+            if (e.keyCode === 16 ) {
+                top = 0;
+            }
+            else if (e.keyCode === 18 ) {
+                top = Number.POSITIVE_INFINITY;
+            }
+            if (right !== undefined) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.right = right;
+                this.layout();
+            }
+            if (top !== undefined) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.top = top;
+                const transition = this.elements.root.style.transition;
+                this.elements.root.style.transition = 'unset';
+                this.layout();
+                setTimeout(() => {
+                    this.elements.root.style.transition = transition;
+                }, 0);
+            }
+        }));
+        this.onDidChangeValue = this.findInput.onDidChange;
+    }
+    getHistory() {
+        return this.findInput.inputBox.getHistory();
+    }
+    focus() {
+        this.findInput.focus();
+    }
+    select() {
+        this.findInput.select();
+        this.findInput.inputBox.addToHistory(true);
+    }
+    layout(width = this.width) {
+        this.width = width;
+        this.right = clamp(this.right, 0, Math.max(0, width - 212));
+        this.elements.root.style.right = `${this.right}px`;
+        this.top = clamp(this.top, 0, 24);
+        this.elements.root.style.top = `${this.top}px`;
+    }
+    showMessage(message) {
+        this.findInput.showMessage(message);
+    }
+    clearMessage() {
+        this.findInput.clearMessage();
+    }
+    async dispose() {
+        this._onDidDisable.fire();
+        this.elements.root.classList.add('disabled');
+        await timeout(300);
+        super.dispose();
+    }
+}
+class FindController {
+    get pattern() { return this._pattern; }
+    get mode() { return this._mode; }
+    set mode(mode) {
+        if (mode === this._mode) {
+            return;
+        }
+        this._mode = mode;
+        if (this.widget) {
+            this.widget.mode = this._mode;
+        }
+        this.tree.refilter();
+        this.render();
+        this._onDidChangeMode.fire(mode);
+    }
+    get matchType() { return this._matchType; }
+    set matchType(matchType) {
+        if (matchType === this._matchType) {
+            return;
+        }
+        this._matchType = matchType;
+        if (this.widget) {
+            this.widget.matchType = this._matchType;
+        }
+        this.tree.refilter();
+        this.render();
+        this._onDidChangeMatchType.fire(matchType);
+    }
+    constructor(tree, model, view, filter, contextViewProvider, options = {}) {
+        this.tree = tree;
+        this.view = view;
+        this.filter = filter;
+        this.contextViewProvider = contextViewProvider;
+        this.options = options;
+        this._pattern = '';
+        this.previousPattern = '';
+        this.width = 0;
+        this._onDidChangeMode = ( new Emitter());
+        this.onDidChangeMode = this._onDidChangeMode.event;
+        this._onDidChangeMatchType = ( new Emitter());
+        this.onDidChangeMatchType = this._onDidChangeMatchType.event;
+        this._onDidChangePattern = ( new Emitter());
+        this.onDidChangePattern = this._onDidChangePattern.event;
+        this._onDidChangeOpenState = ( new Emitter());
+        this.onDidChangeOpenState = this._onDidChangeOpenState.event;
+        this.enabledDisposables = ( new DisposableStore());
+        this.disposables = ( new DisposableStore());
+        this._mode = tree.options.defaultFindMode ?? TreeFindMode.Highlight;
+        this._matchType = tree.options.defaultFindMatchType ?? TreeFindMatchType.Fuzzy;
+        model.onDidSplice(this.onDidSpliceModel, this, this.disposables);
+    }
+    updateOptions(optionsUpdate = {}) {
+        if (optionsUpdate.defaultFindMode !== undefined) {
+            this.mode = optionsUpdate.defaultFindMode;
+        }
+        if (optionsUpdate.defaultFindMatchType !== undefined) {
+            this.matchType = optionsUpdate.defaultFindMatchType;
+        }
+    }
+    open() {
+        if (this.widget) {
+            this.widget.focus();
+            this.widget.select();
+            return;
+        }
+        this.widget = ( new FindWidget(
+            this.view.getHTMLElement(),
+            this.tree,
+            this.contextViewProvider,
+            this.mode,
+            this.matchType,
+            { ...this.options, history: this._history }
+        ));
+        this.enabledDisposables.add(this.widget);
+        this.widget.onDidChangeValue(this.onDidChangeValue, this, this.enabledDisposables);
+        this.widget.onDidChangeMode(mode => this.mode = mode, undefined, this.enabledDisposables);
+        this.widget.onDidChangeMatchType(matchType => this.matchType = matchType, undefined, this.enabledDisposables);
+        this.widget.onDidDisable(this.close, this, this.enabledDisposables);
+        this.widget.layout(this.width);
+        this.widget.focus();
+        this.widget.value = this.previousPattern;
+        this.widget.select();
+        this._onDidChangeOpenState.fire(true);
+    }
+    close() {
+        if (!this.widget) {
+            return;
+        }
+        this._history = this.widget.getHistory();
+        this.widget = undefined;
+        this.enabledDisposables.clear();
+        this.previousPattern = this.pattern;
+        this.onDidChangeValue('');
+        this.tree.domFocus();
+        this._onDidChangeOpenState.fire(false);
+    }
+    onDidChangeValue(pattern) {
+        this._pattern = pattern;
+        this._onDidChangePattern.fire(pattern);
+        this.filter.pattern = pattern;
+        this.tree.refilter();
+        if (pattern) {
+            this.tree.focusNext(0, true, undefined, node => !FuzzyScore.isDefault(node.filterData));
+        }
+        const focus = this.tree.getFocus();
+        if (focus.length > 0) {
+            const element = focus[0];
+            if (this.tree.getRelativeTop(element) === null) {
+                this.tree.reveal(element, 0.5);
+            }
+        }
+        this.render();
+    }
+    onDidSpliceModel() {
+        if (!this.widget || this.pattern.length === 0) {
+            return;
+        }
+        this.tree.refilter();
+        this.render();
+    }
+    render() {
+        const noMatches = this.filter.totalCount > 0 && this.filter.matchCount === 0;
+        if (this.pattern && noMatches) {
+            if (this.tree.options.showNotFoundMessage ?? true) {
+                this.widget?.showMessage({ type: 2 , content: ( localizeWithPath('vs/base/browser/ui/tree/abstractTree', 'not found', "No elements found.")) });
+            }
+            else {
+                this.widget?.showMessage({ type: 2  });
+            }
+        }
+        else {
+            this.widget?.clearMessage();
+        }
+    }
+    shouldAllowFocus(node) {
+        if (!this.widget || !this.pattern || this._mode === TreeFindMode.Filter) {
+            return true;
+        }
+        if (this.filter.totalCount > 0 && this.filter.matchCount <= 1) {
+            return true;
+        }
+        return !FuzzyScore.isDefault(node.filterData);
+    }
+    layout(width) {
+        this.width = width;
+        this.widget?.layout(width);
+    }
+    dispose() {
+        this._history = undefined;
+        this._onDidChangePattern.dispose();
+        this.enabledDisposables.dispose();
+        this.disposables.dispose();
+    }
+}
+function stickyScrollNodeEquals(node1, node2) {
+    return node1.position === node2.position &&
+        node1.node.element === node2.node.element &&
+        node1.startIndex === node2.startIndex &&
+        node1.height === node2.height &&
+        node1.endIndex === node2.endIndex;
+}
+class StickyScrollState extends Disposable {
+    constructor(stickyNodes = []) {
+        super();
+        this.stickyNodes = stickyNodes;
+    }
+    get count() { return this.stickyNodes.length; }
+    equal(state) {
+        return equals(this.stickyNodes, state.stickyNodes, stickyScrollNodeEquals);
+    }
+    addDisposable(disposable) {
+        this._register(disposable);
+    }
+}
+class StickyScrollController extends Disposable {
+    get firstVisibleNode() {
+        const index = this.view.firstVisibleIndex;
+        if (index < 0 || index >= this.view.length) {
+            return undefined;
+        }
+        return this.view.element(index);
+    }
+    constructor(tree, model, view, renderers, treeDelegate, options = {}) {
+        super();
+        this.tree = tree;
+        this.model = model;
+        this.view = view;
+        this.treeDelegate = treeDelegate;
+        this.maxWidgetViewRatio = 0.4;
+        const stickyScrollOptions = this.validateStickySettings(options);
+        this.stickyScrollMaxItemCount = stickyScrollOptions.stickyScrollMaxItemCount;
+        this._widget = this._register(( new StickyScrollWidget(view.getScrollableElement(), view, model, renderers, treeDelegate)));
+        this._register(view.onDidScroll(() => this.update()));
+        this._register(view.onDidChangeContentHeight(() => this.update()));
+        this._register(tree.onDidChangeCollapseState(() => this.update()));
+        this.update();
+    }
+    get height() {
+        return this._widget.height;
+    }
+    get count() {
+        return this._widget.count;
+    }
+    getNode(node) {
+        return this._widget.getNode(node);
+    }
+    update() {
+        const firstVisibleNode = this.firstVisibleNode;
+        if (!firstVisibleNode || this.tree.scrollTop === 0) {
+            this._widget.setState(undefined);
+            return;
+        }
+        const stickyState = this.findStickyState(firstVisibleNode);
+        this._widget.setState(stickyState);
+    }
+    findStickyState(firstVisibleNode) {
+        const stickyNodes = [];
+        const maximumStickyWidgetHeight = this.view.renderHeight * this.maxWidgetViewRatio;
+        let firstVisibleNodeUnderWidget = firstVisibleNode;
+        let stickyNodesHeight = 0;
+        let nextStickyNode = this.getNextStickyNode(firstVisibleNodeUnderWidget, undefined, stickyNodesHeight);
+        while (nextStickyNode && stickyNodesHeight + nextStickyNode.height < maximumStickyWidgetHeight) {
+            stickyNodes.push(nextStickyNode);
+            stickyNodesHeight += nextStickyNode.height;
+            if (stickyNodes.length >= this.stickyScrollMaxItemCount) {
+                break;
+            }
+            firstVisibleNodeUnderWidget = this.getNextVisibleNode(firstVisibleNodeUnderWidget);
+            if (!firstVisibleNodeUnderWidget) {
+                break;
+            }
+            nextStickyNode = this.getNextStickyNode(firstVisibleNodeUnderWidget, nextStickyNode.node, stickyNodesHeight);
+        }
+        return stickyNodes.length ? ( new StickyScrollState(stickyNodes)) : undefined;
+    }
+    getNextVisibleNode(node) {
+        const nodeIndex = this.getNodeIndex(node);
+        if (nodeIndex === -1 || nodeIndex === this.view.length - 1) {
+            return undefined;
+        }
+        const nextNode = this.view.element(nodeIndex + 1);
+        return nextNode;
+    }
+    getNextStickyNode(firstVisibleNodeUnderWidget, previousStickyNode, stickyNodesHeight) {
+        const nextStickyNode = this.getAncestorUnderPrevious(firstVisibleNodeUnderWidget, previousStickyNode);
+        if (!nextStickyNode) {
+            return undefined;
+        }
+        if (nextStickyNode === firstVisibleNodeUnderWidget) {
+            if (!this.nodeIsUncollapsedParent(firstVisibleNodeUnderWidget)) {
+                return undefined;
+            }
+            if (this.nodeTopAlignsWithStickyNodesBottom(firstVisibleNodeUnderWidget, stickyNodesHeight)) {
+                return undefined;
+            }
+        }
+        return this.createStickyScrollNode(nextStickyNode, stickyNodesHeight);
+    }
+    nodeTopAlignsWithStickyNodesBottom(node, stickyNodesHeight) {
+        const nodeIndex = this.getNodeIndex(node);
+        const elementTop = this.view.getElementTop(nodeIndex);
+        const stickyPosition = stickyNodesHeight;
+        return this.view.scrollTop === elementTop - stickyPosition;
+    }
+    createStickyScrollNode(node, currentStickyNodesHeight) {
+        const height = this.treeDelegate.getHeight(node);
+        const { startIndex, endIndex } = this.getNodeRange(node);
+        const position = this.calculateStickyNodePosition(endIndex, currentStickyNodesHeight);
+        return { node, position, height, startIndex, endIndex };
+    }
+    getAncestorUnderPrevious(node, previousAncestor = undefined) {
+        let currentAncestor = node;
+        let parentOfcurrentAncestor = this.getParentNode(currentAncestor);
+        while (parentOfcurrentAncestor) {
+            if (parentOfcurrentAncestor === previousAncestor) {
+                return currentAncestor;
+            }
+            currentAncestor = parentOfcurrentAncestor;
+            parentOfcurrentAncestor = this.getParentNode(currentAncestor);
+        }
+        if (previousAncestor === undefined) {
+            return currentAncestor;
+        }
+        return undefined;
+    }
+    calculateStickyNodePosition(lastDescendantIndex, stickyRowPositionTop) {
+        let lastChildRelativeTop = this.view.getRelativeTop(lastDescendantIndex);
+        if (lastChildRelativeTop === null && this.view.firstVisibleIndex === lastDescendantIndex && lastDescendantIndex + 1 < this.view.length) {
+            const nodeHeight = this.treeDelegate.getHeight(this.view.element(lastDescendantIndex));
+            const nextNodeRelativeTop = this.view.getRelativeTop(lastDescendantIndex + 1);
+            lastChildRelativeTop = nextNodeRelativeTop ? nextNodeRelativeTop - nodeHeight / this.view.renderHeight : null;
+        }
+        if (lastChildRelativeTop === null) {
+            return stickyRowPositionTop;
+        }
+        const lastChildNode = this.view.element(lastDescendantIndex);
+        const lastChildHeight = this.treeDelegate.getHeight(lastChildNode);
+        const topOfLastChild = lastChildRelativeTop * this.view.renderHeight;
+        const bottomOfLastChild = topOfLastChild + lastChildHeight;
+        if (stickyRowPositionTop > topOfLastChild && stickyRowPositionTop <= bottomOfLastChild) {
+            return topOfLastChild;
+        }
+        return stickyRowPositionTop;
+    }
+    getParentNode(node) {
+        const nodeLocation = this.model.getNodeLocation(node);
+        const parentLocation = this.model.getParentNodeLocation(nodeLocation);
+        return parentLocation ? this.model.getNode(parentLocation) : undefined;
+    }
+    nodeIsUncollapsedParent(node) {
+        const nodeLocation = this.model.getNodeLocation(node);
+        return this.model.getListRenderCount(nodeLocation) > 1;
+    }
+    getNodeIndex(node, nodeLocation) {
+        if (nodeLocation === undefined) {
+            nodeLocation = this.model.getNodeLocation(node);
+        }
+        const nodeIndex = this.model.getListIndex(nodeLocation);
+        return nodeIndex;
+    }
+    getNodeRange(node) {
+        const nodeLocation = this.model.getNodeLocation(node);
+        const startIndex = this.model.getListIndex(nodeLocation);
+        if (startIndex < 0) {
+            throw new Error('Node not found in tree');
+        }
+        const renderCount = this.model.getListRenderCount(nodeLocation);
+        const endIndex = startIndex + renderCount - 1;
+        return { startIndex, endIndex };
+    }
+    nodePositionTopBelowWidget(node) {
+        const ancestors = [];
+        let currentAncestor = this.getParentNode(node);
+        while (currentAncestor) {
+            ancestors.push(currentAncestor);
+            currentAncestor = this.getParentNode(currentAncestor);
+        }
+        let widgetHeight = 0;
+        for (let i = 0; i < ancestors.length && i < this.stickyScrollMaxItemCount; i++) {
+            widgetHeight += this.treeDelegate.getHeight(ancestors[i]);
+        }
+        return widgetHeight;
+    }
+    updateOptions(optionsUpdate = {}) {
+        const validatedOptions = this.validateStickySettings(optionsUpdate);
+        if (this.stickyScrollMaxItemCount !== validatedOptions.stickyScrollMaxItemCount) {
+            this.stickyScrollMaxItemCount = validatedOptions.stickyScrollMaxItemCount;
+            this.update();
+        }
+    }
+    validateStickySettings(options) {
+        let stickyScrollMaxItemCount = 5;
+        if (typeof options.stickyScrollMaxItemCount === 'number') {
+            stickyScrollMaxItemCount = Math.max(options.stickyScrollMaxItemCount, 1);
+        }
+        return { stickyScrollMaxItemCount };
+    }
+}
+class StickyScrollWidget {
+    constructor(container, view, model, treeRenderers, treeDelegate) {
+        this.view = view;
+        this.model = model;
+        this.treeRenderers = treeRenderers;
+        this.treeDelegate = treeDelegate;
+        this._rootDomNode = document.createElement('div');
+        this._rootDomNode.classList.add('monaco-tree-sticky-container');
+        container.appendChild(this._rootDomNode);
+    }
+    get height() {
+        if (!this._previousState) {
+            return 0;
+        }
+        const lastElement = this._previousState.stickyNodes[this._previousState.count - 1];
+        return lastElement.position + lastElement.height;
+    }
+    get count() {
+        return this._previousState?.count ?? 0;
+    }
+    getNode(node) {
+        return this._previousState?.stickyNodes.find(stickyNode => stickyNode.node === node);
+    }
+    setState(state) {
+        const wasVisible = !!this._previousState && this._previousState.count > 0;
+        const isVisible = !!state && state.count > 0;
+        if ((!wasVisible && !isVisible) || (wasVisible && isVisible && this._previousState.equal(state))) {
+            return;
+        }
+        if (wasVisible !== isVisible) {
+            this.setVisible(isVisible);
+        }
+        this._previousState?.dispose();
+        this._previousState = state;
+        if (!isVisible) {
+            return;
+        }
+        for (let stickyIndex = state.count - 1; stickyIndex >= 0; stickyIndex--) {
+            const stickyNode = state.stickyNodes[stickyIndex];
+            const previousStickyNode = stickyIndex ? state.stickyNodes[stickyIndex - 1] : undefined;
+            const currentWidgetHieght = previousStickyNode ? previousStickyNode.position + previousStickyNode.height : 0;
+            const { element, disposable } = this.createElement(stickyNode, currentWidgetHieght);
+            this._rootDomNode.appendChild(element);
+            state.addDisposable(disposable);
+        }
+        const shadow = $('.monaco-tree-sticky-container-shadow');
+        this._rootDomNode.appendChild(shadow);
+        state.addDisposable(toDisposable(() => shadow.remove()));
+        const lastStickyNode = state.stickyNodes[state.count - 1];
+        this._rootDomNode.style.height = `${lastStickyNode.position + lastStickyNode.height}px`;
+    }
+    createElement(stickyNode, currentWidgetHeight) {
+        const nodeLocation = this.model.getNodeLocation(stickyNode.node);
+        const nodeIndex = this.model.getListIndex(nodeLocation);
+        const stickyElement = document.createElement('div');
+        stickyElement.style.top = `${stickyNode.position}px`;
+        stickyElement.style.height = `${stickyNode.height}px`;
+        stickyElement.style.lineHeight = `${stickyNode.height}px`;
+        stickyElement.classList.add('monaco-tree-sticky-row');
+        stickyElement.classList.add('monaco-list-row');
+        stickyElement.setAttribute('data-index', `${nodeIndex}`);
+        stickyElement.setAttribute('data-parity', nodeIndex % 2 === 0 ? 'even' : 'odd');
+        stickyElement.setAttribute('id', this.view.getElementID(nodeIndex));
+        const nodeTemplateId = this.treeDelegate.getTemplateId(stickyNode.node);
+        const renderer = this.treeRenderers.find((renderer) => renderer.templateId === nodeTemplateId);
+        if (!renderer) {
+            throw new Error(`No renderer found for template id ${nodeTemplateId}`);
+        }
+        const nodeCopy = ( new Proxy(stickyNode.node, {}));
+        const templateData = renderer.renderTemplate(stickyElement);
+        renderer.renderElement(nodeCopy, stickyNode.startIndex, templateData, stickyNode.height);
+        const disposable = toDisposable(() => {
+            renderer.disposeElement(nodeCopy, stickyNode.startIndex, templateData, stickyNode.height);
+            renderer.disposeTemplate(templateData);
+            stickyElement.remove();
+        });
+        return { element: stickyElement, disposable };
+    }
+    setVisible(visible) {
+        this._rootDomNode.style.display = visible ? 'block' : 'none';
+    }
+    dispose() {
+        this._previousState?.dispose();
+        this._rootDomNode.remove();
+    }
+}
+function asTreeMouseEvent(event) {
+    let target = TreeMouseEventTarget.Unknown;
+    if (hasParentWithClass(event.browserEvent.target, 'monaco-tl-twistie', 'monaco-tl-row')) {
+        target = TreeMouseEventTarget.Twistie;
+    }
+    else if (hasParentWithClass(event.browserEvent.target, 'monaco-tl-contents', 'monaco-tl-row')) {
+        target = TreeMouseEventTarget.Element;
+    }
+    else if (hasParentWithClass(event.browserEvent.target, 'monaco-tree-type-filter', 'monaco-list')) {
+        target = TreeMouseEventTarget.Filter;
+    }
+    return {
+        browserEvent: event.browserEvent,
+        element: event.element ? event.element.element : null,
+        target
+    };
+}
+function asTreeContextMenuEvent(event) {
+    return {
+        element: event.element ? event.element.element : null,
+        browserEvent: event.browserEvent,
+        anchor: event.anchor
+    };
+}
+function dfs(node, fn) {
+    fn(node);
+    node.children.forEach(child => dfs(child, fn));
+}
+class Trait {
+    get nodeSet() {
+        if (!this._nodeSet) {
+            this._nodeSet = this.createNodeSet();
+        }
+        return this._nodeSet;
+    }
+    constructor(getFirstViewElementWithTrait, identityProvider) {
+        this.getFirstViewElementWithTrait = getFirstViewElementWithTrait;
+        this.identityProvider = identityProvider;
+        this.nodes = [];
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+    }
+    set(nodes, browserEvent) {
+        if (!browserEvent?.__forceEvent && equals(this.nodes, nodes)) {
+            return;
+        }
+        this._set(nodes, false, browserEvent);
+    }
+    _set(nodes, silent, browserEvent) {
+        this.nodes = [...nodes];
+        this.elements = undefined;
+        this._nodeSet = undefined;
+        if (!silent) {
+            const that = this;
+            this._onDidChange.fire({ get elements() { return that.get(); }, browserEvent });
+        }
+    }
+    get() {
+        if (!this.elements) {
+            this.elements = ( this.nodes.map(node => node.element));
+        }
+        return [...this.elements];
+    }
+    getNodes() {
+        return this.nodes;
+    }
+    has(node) {
+        return ( this.nodeSet.has(node));
+    }
+    onDidModelSplice({ insertedNodes, deletedNodes }) {
+        if (!this.identityProvider) {
+            const set = this.createNodeSet();
+            const visit = (node) => set.delete(node);
+            deletedNodes.forEach(node => dfs(node, visit));
+            this.set([...( set.values())]);
+            return;
+        }
+        const deletedNodesIdSet = ( new Set());
+        const deletedNodesVisitor = (node) => deletedNodesIdSet.add(( this.identityProvider.getId(node.element).toString()));
+        deletedNodes.forEach(node => dfs(node, deletedNodesVisitor));
+        const insertedNodesMap = ( new Map());
+        const insertedNodesVisitor = (node) => insertedNodesMap.set(( this.identityProvider.getId(node.element).toString()), node);
+        insertedNodes.forEach(node => dfs(node, insertedNodesVisitor));
+        const nodes = [];
+        for (const node of this.nodes) {
+            const id = ( this.identityProvider.getId(node.element).toString());
+            const wasDeleted = ( deletedNodesIdSet.has(id));
+            if (!wasDeleted) {
+                nodes.push(node);
+            }
+            else {
+                const insertedNode = insertedNodesMap.get(id);
+                if (insertedNode && insertedNode.visible) {
+                    nodes.push(insertedNode);
+                }
+            }
+        }
+        if (this.nodes.length > 0 && nodes.length === 0) {
+            const node = this.getFirstViewElementWithTrait();
+            if (node) {
+                nodes.push(node);
+            }
+        }
+        this._set(nodes, true);
+    }
+    createNodeSet() {
+        const set = ( new Set());
+        for (const node of this.nodes) {
+            set.add(node);
+        }
+        return set;
+    }
+}
+class TreeNodeListMouseController extends MouseController {
+    constructor(list, tree, stickyScrollProvider) {
+        super(list);
+        this.tree = tree;
+        this.stickyScrollProvider = stickyScrollProvider;
+    }
+    onViewPointer(e) {
+        if (isButton(e.browserEvent.target) ||
+            isInputElement(e.browserEvent.target) ||
+            isMonacoEditor(e.browserEvent.target)) {
+            return;
+        }
+        if (e.browserEvent.isHandledByList) {
+            return;
+        }
+        const node = e.element;
+        if (!node) {
+            return super.onViewPointer(e);
+        }
+        if (this.isSelectionRangeChangeEvent(e) || this.isSelectionSingleChangeEvent(e)) {
+            return super.onViewPointer(e);
+        }
+        const target = e.browserEvent.target;
+        const onTwistie = target.classList.contains('monaco-tl-twistie')
+            || (target.classList.contains('monaco-icon-label') && target.classList.contains('folder-icon') && e.browserEvent.offsetX < 16);
+        const isStickyElement = isStickyScrollElement(e.browserEvent.target);
+        let expandOnlyOnTwistieClick = false;
+        if (isStickyElement) {
+            expandOnlyOnTwistieClick = true;
+        }
+        else if (typeof this.tree.expandOnlyOnTwistieClick === 'function') {
+            expandOnlyOnTwistieClick = this.tree.expandOnlyOnTwistieClick(node.element);
+        }
+        else {
+            expandOnlyOnTwistieClick = !!this.tree.expandOnlyOnTwistieClick;
+        }
+        if (!isStickyElement) {
+            if (expandOnlyOnTwistieClick && !onTwistie && e.browserEvent.detail !== 2) {
+                return super.onViewPointer(e);
+            }
+            if (!this.tree.expandOnDoubleClick && e.browserEvent.detail === 2) {
+                return super.onViewPointer(e);
+            }
+        }
+        else {
+            this.handleStickyScrollMouseEvent(e, node);
+        }
+        if (node.collapsible && (!isStickyElement || onTwistie)) {
+            const location = this.tree.getNodeLocation(node);
+            const recursive = e.browserEvent.altKey;
+            this.tree.setFocus([location]);
+            this.tree.toggleCollapsed(location, recursive);
+            if (expandOnlyOnTwistieClick && onTwistie) {
+                e.browserEvent.isHandledByList = true;
+                return;
+            }
+        }
+        if (!isStickyElement) {
+            super.onViewPointer(e);
+        }
+    }
+    handleStickyScrollMouseEvent(e, node) {
+        if (isMonacoCustomToggle(e.browserEvent.target) || isActionItem(e.browserEvent.target)) {
+            return;
+        }
+        const stickyScrollController = this.stickyScrollProvider();
+        if (!stickyScrollController) {
+            throw new Error('Sticky scroll controller not found');
+        }
+        const nodeIndex = this.list.indexOf(node);
+        const elementScrollTop = this.list.getElementTop(nodeIndex);
+        const elementTargetViewTop = stickyScrollController.nodePositionTopBelowWidget(node);
+        this.tree.scrollTop = elementScrollTop - elementTargetViewTop;
+        this.list.setFocus([nodeIndex]);
+        this.list.setSelection([nodeIndex]);
+    }
+    onDoubleClick(e) {
+        const onTwistie = e.browserEvent.target.classList.contains('monaco-tl-twistie');
+        if (onTwistie || !this.tree.expandOnDoubleClick) {
+            return;
+        }
+        if (e.browserEvent.isHandledByList) {
+            return;
+        }
+        super.onDoubleClick(e);
+    }
+}
+class TreeNodeList extends List {
+    constructor(user, container, virtualDelegate, renderers, focusTrait, selectionTrait, anchorTrait, options) {
+        super(user, container, virtualDelegate, renderers, options);
+        this.focusTrait = focusTrait;
+        this.selectionTrait = selectionTrait;
+        this.anchorTrait = anchorTrait;
+    }
+    createMouseController(options) {
+        return ( new TreeNodeListMouseController(this, options.tree, options.stickyScrollProvider));
+    }
+    splice(start, deleteCount, elements = []) {
+        super.splice(start, deleteCount, elements);
+        if (elements.length === 0) {
+            return;
+        }
+        const additionalFocus = [];
+        const additionalSelection = [];
+        let anchor;
+        elements.forEach((node, index) => {
+            if (( this.focusTrait.has(node))) {
+                additionalFocus.push(start + index);
+            }
+            if (( this.selectionTrait.has(node))) {
+                additionalSelection.push(start + index);
+            }
+            if (( this.anchorTrait.has(node))) {
+                anchor = start + index;
+            }
+        });
+        if (additionalFocus.length > 0) {
+            super.setFocus(distinct([...super.getFocus(), ...additionalFocus]));
+        }
+        if (additionalSelection.length > 0) {
+            super.setSelection(distinct([...super.getSelection(), ...additionalSelection]));
+        }
+        if (typeof anchor === 'number') {
+            super.setAnchor(anchor);
+        }
+    }
+    setFocus(indexes, browserEvent, fromAPI = false) {
+        super.setFocus(indexes, browserEvent);
+        if (!fromAPI) {
+            this.focusTrait.set(( indexes.map(i => this.element(i))), browserEvent);
+        }
+    }
+    setSelection(indexes, browserEvent, fromAPI = false) {
+        super.setSelection(indexes, browserEvent);
+        if (!fromAPI) {
+            this.selectionTrait.set(( indexes.map(i => this.element(i))), browserEvent);
+        }
+    }
+    setAnchor(index, fromAPI = false) {
+        super.setAnchor(index);
+        if (!fromAPI) {
+            if (typeof index === 'undefined') {
+                this.anchorTrait.set([]);
+            }
+            else {
+                this.anchorTrait.set([this.element(index)]);
+            }
+        }
+    }
+}
+class AbstractTree {
+    get onDidScroll() { return this.view.onDidScroll; }
+    get onDidChangeFocus() { return this.eventBufferer.wrapEvent(this.focus.onDidChange); }
+    get onDidChangeSelection() { return this.eventBufferer.wrapEvent(this.selection.onDidChange); }
+    get onMouseClick() { return ( Event.map(this.view.onMouseClick, asTreeMouseEvent)); }
+    get onMouseDblClick() { return Event.filter(( Event.map(this.view.onMouseDblClick, asTreeMouseEvent)), e => e.target !== TreeMouseEventTarget.Filter); }
+    get onContextMenu() { return ( Event.map(this.view.onContextMenu, asTreeContextMenuEvent)); }
+    get onTap() { return ( Event.map(this.view.onTap, asTreeMouseEvent)); }
+    get onPointer() { return ( Event.map(this.view.onPointer, asTreeMouseEvent)); }
+    get onKeyDown() { return this.view.onKeyDown; }
+    get onKeyUp() { return this.view.onKeyUp; }
+    get onKeyPress() { return this.view.onKeyPress; }
+    get onDidFocus() { return this.view.onDidFocus; }
+    get onDidBlur() { return this.view.onDidBlur; }
+    get onDidChangeModel() { return Event.signal(this.model.onDidSplice); }
+    get onDidChangeCollapseState() { return this.model.onDidChangeCollapseState; }
+    get onDidChangeRenderNodeCount() { return this.model.onDidChangeRenderNodeCount; }
+    get findMode() { return this.findController?.mode ?? TreeFindMode.Highlight; }
+    set findMode(findMode) { if (this.findController) {
+        this.findController.mode = findMode;
+    } }
+    get findMatchType() { return this.findController?.matchType ?? TreeFindMatchType.Fuzzy; }
+    set findMatchType(findFuzzy) { if (this.findController) {
+        this.findController.matchType = findFuzzy;
+    } }
+    get onDidChangeFindPattern() { return this.findController ? this.findController.onDidChangePattern : Event.None; }
+    get expandOnDoubleClick() { return typeof this._options.expandOnDoubleClick === 'undefined' ? true : this._options.expandOnDoubleClick; }
+    get expandOnlyOnTwistieClick() { return typeof this._options.expandOnlyOnTwistieClick === 'undefined' ? true : this._options.expandOnlyOnTwistieClick; }
+    get onDidDispose() { return this.view.onDidDispose; }
+    constructor(_user, container, delegate, renderers, _options = {}) {
+        this._user = _user;
+        this._options = _options;
+        this.eventBufferer = ( new EventBufferer());
+        this.onDidChangeFindOpenState = Event.None;
+        this.disposables = ( new DisposableStore());
+        this._onWillRefilter = ( new Emitter());
+        this.onWillRefilter = this._onWillRefilter.event;
+        this._onDidUpdateOptions = ( new Emitter());
+        this.onDidUpdateOptions = this._onDidUpdateOptions.event;
+        this.treeDelegate = ( new ComposedTreeDelegate(delegate));
+        const onDidChangeCollapseStateRelay = ( new Relay());
+        const onDidChangeActiveNodes = ( new Relay());
+        const activeNodes = this.disposables.add(( new EventCollection(onDidChangeActiveNodes.event)));
+        const renderedIndentGuides = ( new SetMap());
+        this.renderers = ( renderers.map(r => ( new TreeRenderer(
+            r,
+            () => this.model,
+            onDidChangeCollapseStateRelay.event,
+            activeNodes,
+            renderedIndentGuides,
+            _options
+        ))));
+        for (const r of this.renderers) {
+            this.disposables.add(r);
+        }
+        let filter;
+        if (_options.keyboardNavigationLabelProvider) {
+            filter = ( new FindFilter(this, _options.keyboardNavigationLabelProvider, _options.filter));
+            _options = { ..._options, filter: filter };
+            this.disposables.add(filter);
+        }
+        this.focus = ( new Trait(() => this.view.getFocusedElements()[0], _options.identityProvider));
+        this.selection = ( new Trait(() => this.view.getSelectedElements()[0], _options.identityProvider));
+        this.anchor = ( new Trait(() => this.view.getAnchorElement(), _options.identityProvider));
+        this.view = ( new TreeNodeList(
+            _user,
+            container,
+            this.treeDelegate,
+            this.renderers,
+            this.focus,
+            this.selection,
+            this.anchor,
+            { ...asListOptions(() => this.model, _options), tree: this, stickyScrollProvider: () => this.stickyScrollController }
+        ));
+        this.model = this.createModel(_user, this.view, _options);
+        onDidChangeCollapseStateRelay.input = this.model.onDidChangeCollapseState;
+        const onDidModelSplice = Event.forEach(this.model.onDidSplice, e => {
+            this.eventBufferer.bufferEvents(() => {
+                this.focus.onDidModelSplice(e);
+                this.selection.onDidModelSplice(e);
+            });
+        }, this.disposables);
+        onDidModelSplice(() => null, null, this.disposables);
+        const activeNodesEmitter = this.disposables.add(( new Emitter()));
+        const activeNodesDebounce = this.disposables.add(( new Delayer(0)));
+        this.disposables.add(Event.any(onDidModelSplice, this.focus.onDidChange, this.selection.onDidChange)(() => {
+            activeNodesDebounce.trigger(() => {
+                const set = ( new Set());
+                for (const node of this.focus.getNodes()) {
+                    set.add(node);
+                }
+                for (const node of this.selection.getNodes()) {
+                    set.add(node);
+                }
+                activeNodesEmitter.fire([...( set.values())]);
+            });
+        }));
+        onDidChangeActiveNodes.input = activeNodesEmitter.event;
+        if (_options.keyboardSupport !== false) {
+            const onKeyDown = Event.chain(this.view.onKeyDown, $ => ( $.filter(e => !isInputElement(e.target))
+                .map(e => ( new StandardKeyboardEvent(e)))));
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 15 ))(this.onLeftArrow, this, this.disposables);
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 17 ))(this.onRightArrow, this, this.disposables);
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 10 ))(this.onSpace, this, this.disposables);
+        }
+        if ((_options.findWidgetEnabled ?? true) && _options.keyboardNavigationLabelProvider && _options.contextViewProvider) {
+            const opts = this.options.findWidgetStyles ? { styles: this.options.findWidgetStyles } : undefined;
+            this.findController = ( new FindController(this, this.model, this.view, filter, _options.contextViewProvider, opts));
+            this.focusNavigationFilter = node => this.findController.shouldAllowFocus(node);
+            this.onDidChangeFindOpenState = this.findController.onDidChangeOpenState;
+            this.disposables.add(this.findController);
+            this.onDidChangeFindMode = this.findController.onDidChangeMode;
+            this.onDidChangeFindMatchType = this.findController.onDidChangeMatchType;
+        }
+        else {
+            this.onDidChangeFindMode = Event.None;
+            this.onDidChangeFindMatchType = Event.None;
+        }
+        if (_options.enableStickyScroll) {
+            this.stickyScrollController = ( new StickyScrollController(this, this.model, this.view, this.renderers, this.treeDelegate, _options));
+        }
+        this.styleElement = createStyleSheet(this.view.getHTMLElement());
+        this.getHTMLElement().classList.toggle('always', this._options.renderIndentGuides === RenderIndentGuides.Always);
+    }
+    updateOptions(optionsUpdate = {}) {
+        this._options = { ...this._options, ...optionsUpdate };
+        for (const renderer of this.renderers) {
+            renderer.updateOptions(optionsUpdate);
+        }
+        this.view.updateOptions(this._options);
+        this.findController?.updateOptions(optionsUpdate);
+        this.updateStickyScroll(optionsUpdate);
+        this._onDidUpdateOptions.fire(this._options);
+        this.getHTMLElement().classList.toggle('always', this._options.renderIndentGuides === RenderIndentGuides.Always);
+    }
+    get options() {
+        return this._options;
+    }
+    updateStickyScroll(optionsUpdate) {
+        if (!this.stickyScrollController && this._options.enableStickyScroll) {
+            this.stickyScrollController = ( new StickyScrollController(
+                this,
+                this.model,
+                this.view,
+                this.renderers,
+                this.treeDelegate,
+                this._options
+            ));
+        }
+        else if (this.stickyScrollController && !this._options.enableStickyScroll) {
+            this.stickyScrollController.dispose();
+            this.stickyScrollController = undefined;
+        }
+        this.stickyScrollController?.updateOptions(optionsUpdate);
+    }
+    updateWidth(element) {
+        const index = this.model.getListIndex(element);
+        if (index === -1) {
+            return;
+        }
+        this.view.updateWidth(index);
+    }
+    getHTMLElement() {
+        return this.view.getHTMLElement();
+    }
+    get contentHeight() {
+        return this.view.contentHeight;
+    }
+    get contentWidth() {
+        return this.view.contentWidth;
+    }
+    get onDidChangeContentHeight() {
+        return this.view.onDidChangeContentHeight;
+    }
+    get onDidChangeContentWidth() {
+        return this.view.onDidChangeContentWidth;
+    }
+    get scrollTop() {
+        return this.view.scrollTop;
+    }
+    set scrollTop(scrollTop) {
+        this.view.scrollTop = scrollTop;
+    }
+    get scrollLeft() {
+        return this.view.scrollLeft;
+    }
+    set scrollLeft(scrollLeft) {
+        this.view.scrollLeft = scrollLeft;
+    }
+    get scrollHeight() {
+        return this.view.scrollHeight;
+    }
+    get renderHeight() {
+        return this.view.renderHeight;
+    }
+    get firstVisibleElement() {
+        let index = this.view.firstVisibleIndex;
+        if (this.stickyScrollController) {
+            index += this.stickyScrollController.count;
+        }
+        if (index < 0 || index >= this.view.length) {
+            return undefined;
+        }
+        const node = this.view.element(index);
+        return node.element;
+    }
+    get lastVisibleElement() {
+        const index = this.view.lastVisibleIndex;
+        const node = this.view.element(index);
+        return node.element;
+    }
+    get ariaLabel() {
+        return this.view.ariaLabel;
+    }
+    set ariaLabel(value) {
+        this.view.ariaLabel = value;
+    }
+    get selectionSize() {
+        return this.selection.getNodes().length;
+    }
+    domFocus() {
+        this.view.domFocus();
+    }
+    isDOMFocused() {
+        return isActiveElement(this.getHTMLElement());
+    }
+    layout(height, width) {
+        this.view.layout(height, width);
+        if (isNumber(width)) {
+            this.findController?.layout(width);
+        }
+    }
+    style(styles) {
+        const suffix = `.${this.view.domId}`;
+        const content = [];
+        if (styles.treeIndentGuidesStroke) {
+            content.push(`.monaco-list${suffix}:hover .monaco-tl-indent > .indent-guide, .monaco-list${suffix}.always .monaco-tl-indent > .indent-guide  { border-color: ${styles.treeInactiveIndentGuidesStroke}; }`);
+            content.push(`.monaco-list${suffix} .monaco-tl-indent > .indent-guide.active { border-color: ${styles.treeIndentGuidesStroke}; }`);
+        }
+        if (styles.listBackground) {
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container { background-color: ${styles.listBackground}; }`);
+            content.push(`.monaco-list${suffix} .monaco-scrollable-element .monaco-tree-sticky-container .monaco-tree-sticky-row { background-color: ${styles.listBackground}; }`);
+        }
+        this.styleElement.textContent = content.join('\n');
+        this.view.style(styles);
+    }
+    getParentElement(location) {
+        const parentRef = this.model.getParentNodeLocation(location);
+        const parentNode = this.model.getNode(parentRef);
+        return parentNode.element;
+    }
+    getFirstElementChild(location) {
+        return this.model.getFirstElementChild(location);
+    }
+    getNode(location) {
+        return this.model.getNode(location);
+    }
+    getNodeLocation(node) {
+        return this.model.getNodeLocation(node);
+    }
+    collapse(location, recursive = false) {
+        return this.model.setCollapsed(location, true, recursive);
+    }
+    expand(location, recursive = false) {
+        return this.model.setCollapsed(location, false, recursive);
+    }
+    toggleCollapsed(location, recursive = false) {
+        return this.model.setCollapsed(location, undefined, recursive);
+    }
+    expandAll() {
+        this.model.setCollapsed(this.model.rootRef, false, true);
+    }
+    collapseAll() {
+        this.model.setCollapsed(this.model.rootRef, true, true);
+    }
+    isCollapsible(location) {
+        return this.model.isCollapsible(location);
+    }
+    setCollapsible(location, collapsible) {
+        return this.model.setCollapsible(location, collapsible);
+    }
+    isCollapsed(location) {
+        return this.model.isCollapsed(location);
+    }
+    expandTo(location) {
+        this.model.expandTo(location);
+    }
+    triggerTypeNavigation() {
+        this.view.triggerTypeNavigation();
+    }
+    openFind() {
+        this.findController?.open();
+    }
+    closeFind() {
+        this.findController?.close();
+    }
+    refilter() {
+        this._onWillRefilter.fire(undefined);
+        this.model.refilter();
+    }
+    setAnchor(element) {
+        if (typeof element === 'undefined') {
+            return this.view.setAnchor(undefined);
+        }
+        const node = this.model.getNode(element);
+        this.anchor.set([node]);
+        const index = this.model.getListIndex(element);
+        if (index > -1) {
+            this.view.setAnchor(index, true);
+        }
+    }
+    getAnchor() {
+        return firstOrDefault(this.anchor.get(), undefined);
+    }
+    setSelection(elements, browserEvent) {
+        const nodes = ( elements.map(e => this.model.getNode(e)));
+        this.selection.set(nodes, browserEvent);
+        const indexes = ( elements.map(e => this.model.getListIndex(e))).filter(i => i > -1);
+        this.view.setSelection(indexes, browserEvent, true);
+    }
+    getSelection() {
+        return this.selection.get();
+    }
+    setFocus(elements, browserEvent) {
+        const nodes = ( elements.map(e => this.model.getNode(e)));
+        this.focus.set(nodes, browserEvent);
+        const indexes = ( elements.map(e => this.model.getListIndex(e))).filter(i => i > -1);
+        this.view.setFocus(indexes, browserEvent, true);
+    }
+    focusNext(n = 1, loop = false, browserEvent, filter = this.focusNavigationFilter) {
+        this.view.focusNext(n, loop, browserEvent, filter);
+    }
+    focusPrevious(n = 1, loop = false, browserEvent, filter = this.focusNavigationFilter) {
+        this.view.focusPrevious(n, loop, browserEvent, filter);
+    }
+    focusNextPage(browserEvent, filter = this.focusNavigationFilter) {
+        return this.view.focusNextPage(browserEvent, filter);
+    }
+    focusPreviousPage(browserEvent, filter = this.focusNavigationFilter) {
+        return this.view.focusPreviousPage(browserEvent, filter);
+    }
+    focusLast(browserEvent, filter = this.focusNavigationFilter) {
+        this.view.focusLast(browserEvent, filter);
+    }
+    focusFirst(browserEvent, filter = this.focusNavigationFilter) {
+        this.view.focusFirst(browserEvent, filter);
+    }
+    getFocus() {
+        return this.focus.get();
+    }
+    reveal(location, relativeTop) {
+        this.model.expandTo(location);
+        const index = this.model.getListIndex(location);
+        if (index === -1) {
+            return;
+        }
+        if (!this.stickyScrollController) {
+            this.view.reveal(index, relativeTop);
+        }
+        else {
+            const paddingTop = this.stickyScrollController.nodePositionTopBelowWidget(this.getNode(location));
+            this.view.reveal(index, relativeTop, paddingTop);
+        }
+    }
+    getRelativeTop(location) {
+        const index = this.model.getListIndex(location);
+        if (index === -1) {
+            return null;
+        }
+        const stickyScrollNode = this.stickyScrollController?.getNode(this.getNode(location));
+        return this.view.getRelativeTop(index, stickyScrollNode?.position ?? this.stickyScrollController?.height);
+    }
+    getViewState(identityProvider = this.options.identityProvider) {
+        if (!identityProvider) {
+            throw new TreeError(this._user, 'Can\'t get tree view state without an identity provider');
+        }
+        const getId = (element) => ( identityProvider.getId(element).toString());
+        const state = AbstractTreeViewState.empty(this.scrollTop);
+        for (const focus of this.getFocus()) {
+            state.focus.add(getId(focus));
+        }
+        for (const selection of this.getSelection()) {
+            state.selection.add(getId(selection));
+        }
+        const root = this.model.getNode();
+        const queue = [root];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (node !== root && node.collapsible) {
+                state.expanded[getId(node.element)] = node.collapsed ? 0 : 1;
+            }
+            queue.push(...node.children);
+        }
+        return state;
+    }
+    onLeftArrow(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        const nodes = this.view.getFocusedElements();
+        if (nodes.length === 0) {
+            return;
+        }
+        const node = nodes[0];
+        const location = this.model.getNodeLocation(node);
+        const didChange = this.model.setCollapsed(location, true);
+        if (!didChange) {
+            const parentLocation = this.model.getParentNodeLocation(location);
+            if (!parentLocation) {
+                return;
+            }
+            const parentListIndex = this.model.getListIndex(parentLocation);
+            this.view.reveal(parentListIndex);
+            this.view.setFocus([parentListIndex]);
+        }
+    }
+    onRightArrow(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        const nodes = this.view.getFocusedElements();
+        if (nodes.length === 0) {
+            return;
+        }
+        const node = nodes[0];
+        const location = this.model.getNodeLocation(node);
+        const didChange = this.model.setCollapsed(location, false);
+        if (!didChange) {
+            if (!( node.children.some(child => child.visible))) {
+                return;
+            }
+            const [focusedIndex] = this.view.getFocus();
+            const firstChildIndex = focusedIndex + 1;
+            this.view.reveal(firstChildIndex);
+            this.view.setFocus([firstChildIndex]);
+        }
+    }
+    onSpace(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        const nodes = this.view.getFocusedElements();
+        if (nodes.length === 0) {
+            return;
+        }
+        const node = nodes[0];
+        const location = this.model.getNodeLocation(node);
+        const recursive = e.browserEvent.altKey;
+        this.model.setCollapsed(location, undefined, recursive);
+    }
+    navigate(start) {
+        return ( new TreeNavigator(this.view, this.model, start));
+    }
+    dispose() {
+        dispose(this.disposables);
+        this.stickyScrollController?.dispose();
+        this.view.dispose();
+    }
+}
+class TreeNavigator {
+    constructor(view, model, start) {
+        this.view = view;
+        this.model = model;
+        if (start) {
+            this.index = this.model.getListIndex(start);
+        }
+        else {
+            this.index = -1;
+        }
+    }
+    current() {
+        if (this.index < 0 || this.index >= this.view.length) {
+            return null;
+        }
+        return this.view.element(this.index).element;
+    }
+    previous() {
+        this.index--;
+        return this.current();
+    }
+    next() {
+        this.index++;
+        return this.current();
+    }
+    first() {
+        this.index = 0;
+        return this.current();
+    }
+    last() {
+        this.index = this.view.length - 1;
+        return this.current();
+    }
+}
+export { AbstractTree, AbstractTreeViewState, ComposedTreeDelegate, FuzzyToggle, ModeToggle, RenderIndentGuides, TreeFindMatchType, TreeFindMode, TreeRenderer };