@codingame/monaco-vscode-api 3.2.3 → 4.0.0

package/vscode/src/vs/platform/quickinput/browser/quickInputTree.js

@@ -0,0 +1,1348 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { addStandardDisposableListener, asCSSUrl, append, EventType, prepend, addDisposableListener, isAncestor, $ as $$1 } from '../../../base/browser/dom.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { localizeWithPath } from '../../../nls.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { WorkbenchObjectTree } from '../../list/browser/listService.js';
+import { IThemeService } from '../../theme/common/themeService.js';
+import { DisposableStore, Disposable } from '../../../base/common/lifecycle.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { OS, isMacintosh } from '../../../base/common/platform.js';
+import { memoize } from '../../../base/common/decorators.js';
+import { IconLabel } from '../../../base/browser/ui/iconLabel/iconLabel.js';
+import { KeybindingLabel } from '../../../base/browser/ui/keybindingLabel/keybindingLabel.js';
+import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
+import { isDark } from '../../theme/common/theme.js';
+import { URI } from '../../../base/common/uri.js';
+import { quickInputButtonToAction } from './quickInputUtils.js';
+import { Lazy } from '../../../base/common/lazy.js';
+import { matchesFuzzyIconAware, parseLabelWithIcons, getCodiconAriaLabel } from '../../../base/common/iconLabels.js';
+import { compareAnything } from '../../../base/common/comparers.js';
+import { ltrim } from '../../../base/common/strings.js';
+import { RenderIndentGuides } from '../../../base/browser/ui/tree/abstractTree.js';
+import { ThrottledDelayer } from '../../../base/common/async.js';
+import { isCancellationError } from '../../../base/common/errors.js';
+var QuickPickItemElementRenderer_1;
+const $ = $$1;
+var QuickInputListFocus;
+( (function(QuickInputListFocus) {
+    QuickInputListFocus[QuickInputListFocus["First"] = 1] = "First";
+    QuickInputListFocus[QuickInputListFocus["Second"] = 2] = "Second";
+    QuickInputListFocus[QuickInputListFocus["Last"] = 3] = "Last";
+    QuickInputListFocus[QuickInputListFocus["Next"] = 4] = "Next";
+    QuickInputListFocus[QuickInputListFocus["Previous"] = 5] = "Previous";
+    QuickInputListFocus[QuickInputListFocus["NextPage"] = 6] = "NextPage";
+    QuickInputListFocus[QuickInputListFocus["PreviousPage"] = 7] = "PreviousPage";
+    QuickInputListFocus[QuickInputListFocus["NextSeparator"] = 8] = "NextSeparator";
+    QuickInputListFocus[QuickInputListFocus["PreviousSeparator"] = 9] = "PreviousSeparator";
+})(QuickInputListFocus || (QuickInputListFocus = {})));
+class BaseQuickPickItemElement {
+    constructor(index, hasCheckbox, mainItem) {
+        this.index = index;
+        this.hasCheckbox = hasCheckbox;
+        this._hidden = false;
+        this._init = ( new Lazy(() => {
+            const saneLabel = mainItem.label ?? '';
+            const saneSortLabel = parseLabelWithIcons(saneLabel).text.trim();
+            const saneAriaLabel = mainItem.ariaLabel || ( [saneLabel, this.saneDescription, this.saneDetail]
+                .map(s => getCodiconAriaLabel(s)))
+                .filter(s => !!s)
+                .join(', ');
+            return {
+                saneLabel,
+                saneSortLabel,
+                saneAriaLabel
+            };
+        }));
+        this._saneDescription = mainItem.description;
+        this._saneTooltip = mainItem.tooltip;
+    }
+    get saneLabel() {
+        return this._init.value.saneLabel;
+    }
+    get saneSortLabel() {
+        return this._init.value.saneSortLabel;
+    }
+    get saneAriaLabel() {
+        return this._init.value.saneAriaLabel;
+    }
+    get element() {
+        return this._element;
+    }
+    set element(value) {
+        this._element = value;
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    set hidden(value) {
+        this._hidden = value;
+    }
+    get saneDescription() {
+        return this._saneDescription;
+    }
+    set saneDescription(value) {
+        this._saneDescription = value;
+    }
+    get saneDetail() {
+        return this._saneDetail;
+    }
+    set saneDetail(value) {
+        this._saneDetail = value;
+    }
+    get saneTooltip() {
+        return this._saneTooltip;
+    }
+    set saneTooltip(value) {
+        this._saneTooltip = value;
+    }
+    get labelHighlights() {
+        return this._labelHighlights;
+    }
+    set labelHighlights(value) {
+        this._labelHighlights = value;
+    }
+    get descriptionHighlights() {
+        return this._descriptionHighlights;
+    }
+    set descriptionHighlights(value) {
+        this._descriptionHighlights = value;
+    }
+    get detailHighlights() {
+        return this._detailHighlights;
+    }
+    set detailHighlights(value) {
+        this._detailHighlights = value;
+    }
+}
+class QuickPickItemElement extends BaseQuickPickItemElement {
+    constructor(index, hasCheckbox, fireButtonTriggered, _onChecked, item, _separator) {
+        super(index, hasCheckbox, item);
+        this.fireButtonTriggered = fireButtonTriggered;
+        this._onChecked = _onChecked;
+        this.item = item;
+        this._separator = _separator;
+        this._checked = false;
+        this.onChecked = hasCheckbox
+            ? ( Event.map(
+            Event.filter(this._onChecked.event, e => e.element === this),
+            e => e.checked
+        ))
+            : Event.None;
+        this._saneDetail = item.detail;
+        this._labelHighlights = item.highlights?.label;
+        this._descriptionHighlights = item.highlights?.description;
+        this._detailHighlights = item.highlights?.detail;
+    }
+    get separator() {
+        return this._separator;
+    }
+    set separator(value) {
+        this._separator = value;
+    }
+    get checked() {
+        return this._checked;
+    }
+    set checked(value) {
+        if (value !== this._checked) {
+            this._checked = value;
+            this._onChecked.fire({ element: this, checked: value });
+        }
+    }
+    get checkboxDisabled() {
+        return !!this.item.disabled;
+    }
+}
+var QuickPickSeparatorFocusReason;
+( (function(QuickPickSeparatorFocusReason) {
+    QuickPickSeparatorFocusReason[QuickPickSeparatorFocusReason["NONE"] = 0] = "NONE";
+    QuickPickSeparatorFocusReason[QuickPickSeparatorFocusReason["MOUSE_HOVER"] = 1] = "MOUSE_HOVER";
+    QuickPickSeparatorFocusReason[QuickPickSeparatorFocusReason["ACTIVE_ITEM"] = 2] = "ACTIVE_ITEM";
+})(QuickPickSeparatorFocusReason || (QuickPickSeparatorFocusReason = {})));
+class QuickPickSeparatorElement extends BaseQuickPickItemElement {
+    constructor(index, fireSeparatorButtonTriggered, separator) {
+        super(index, false, separator);
+        this.fireSeparatorButtonTriggered = fireSeparatorButtonTriggered;
+        this.separator = separator;
+        this.children = ( new Array());
+        this.focusInsideSeparator = QuickPickSeparatorFocusReason.NONE;
+    }
+}
+class QuickInputItemDelegate {
+    getHeight(element) {
+        if (element instanceof QuickPickSeparatorElement) {
+            return 30;
+        }
+        return element.saneDetail ? 44 : 22;
+    }
+    getTemplateId(element) {
+        if (element instanceof QuickPickItemElement) {
+            return QuickPickItemElementRenderer.ID;
+        }
+        else {
+            return QuickPickSeparatorElementRenderer.ID;
+        }
+    }
+}
+class QuickInputAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/platform/quickinput/browser/quickInputTree',
+            'quickInput',
+            "Quick Input"
+        ));
+    }
+    getAriaLabel(element) {
+        return element.separator?.label
+            ? `${element.saneAriaLabel}, ${element.separator.label}`
+            : element.saneAriaLabel;
+    }
+    getWidgetRole() {
+        return 'listbox';
+    }
+    getRole(element) {
+        return element.hasCheckbox ? 'checkbox' : 'option';
+    }
+    isChecked(element) {
+        if (!element.hasCheckbox || !(element instanceof QuickPickItemElement)) {
+            return undefined;
+        }
+        return {
+            value: element.checked,
+            onDidChange: element.onChecked
+        };
+    }
+}
+class BaseQuickInputListRenderer {
+    constructor(hoverDelegate) {
+        this.hoverDelegate = hoverDelegate;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDisposeElement = ( new DisposableStore());
+        data.toDisposeTemplate = ( new DisposableStore());
+        data.entry = append(container, $('.quick-input-list-entry'));
+        const label = append(data.entry, $('label.quick-input-list-label'));
+        data.toDisposeTemplate.add(addStandardDisposableListener(label, EventType.CLICK, e => {
+            if (!data.checkbox.offsetParent) {
+                e.preventDefault();
+            }
+        }));
+        data.checkbox = append(label, $('input.quick-input-list-checkbox'));
+        data.checkbox.type = 'checkbox';
+        const rows = append(label, $('.quick-input-list-rows'));
+        const row1 = append(rows, $('.quick-input-list-row'));
+        const row2 = append(rows, $('.quick-input-list-row'));
+        data.label = ( new IconLabel(
+            row1,
+            { supportHighlights: true, supportDescriptionHighlights: true, supportIcons: true, hoverDelegate: this.hoverDelegate }
+        ));
+        data.toDisposeTemplate.add(data.label);
+        data.icon = prepend(data.label.element, $('.quick-input-list-icon'));
+        const keybindingContainer = append(row1, $('.quick-input-list-entry-keybinding'));
+        data.keybinding = ( new KeybindingLabel(keybindingContainer, OS));
+        data.toDisposeTemplate.add(data.keybinding);
+        const detailContainer = append(row2, $('.quick-input-list-label-meta'));
+        data.detail = ( new IconLabel(
+            detailContainer,
+            { supportHighlights: true, supportIcons: true, hoverDelegate: this.hoverDelegate }
+        ));
+        data.toDisposeTemplate.add(data.detail);
+        data.separator = append(data.entry, $('.quick-input-list-separator'));
+        data.actionBar = ( new ActionBar(
+            data.entry,
+            this.hoverDelegate ? { hoverDelegate: this.hoverDelegate } : undefined
+        ));
+        data.actionBar.domNode.classList.add('quick-input-list-entry-action-bar');
+        data.toDisposeTemplate.add(data.actionBar);
+        return data;
+    }
+    disposeTemplate(data) {
+        data.toDisposeElement.dispose();
+        data.toDisposeTemplate.dispose();
+    }
+    disposeElement(_element, _index, data) {
+        data.toDisposeElement.clear();
+        data.actionBar.clear();
+    }
+}
+let QuickPickItemElementRenderer = class QuickPickItemElementRenderer extends BaseQuickInputListRenderer {
+    static { QuickPickItemElementRenderer_1 = this; }
+    static { this.ID = 'quickpickitem'; }
+    constructor(hoverDelegate, themeService) {
+        super(hoverDelegate);
+        this.themeService = themeService;
+        this._itemsWithSeparatorsFrequency = ( new Map());
+    }
+    get templateId() {
+        return QuickPickItemElementRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const data = super.renderTemplate(container);
+        data.toDisposeTemplate.add(addStandardDisposableListener(data.checkbox, EventType.CHANGE, e => {
+            data.element.checked = data.checkbox.checked;
+        }));
+        return data;
+    }
+    renderElement(node, index, data) {
+        const element = node.element;
+        data.element = element;
+        element.element = data.entry ?? undefined;
+        const mainItem = element.item;
+        data.checkbox.checked = element.checked;
+        data.toDisposeElement.add(element.onChecked(checked => data.checkbox.checked = checked));
+        data.checkbox.disabled = element.checkboxDisabled;
+        const { labelHighlights, descriptionHighlights, detailHighlights } = element;
+        if (mainItem.iconPath) {
+            const icon = isDark(this.themeService.getColorTheme().type) ? mainItem.iconPath.dark : (mainItem.iconPath.light ?? mainItem.iconPath.dark);
+            const iconUrl = URI.revive(icon);
+            data.icon.className = 'quick-input-list-icon';
+            data.icon.style.backgroundImage = asCSSUrl(iconUrl);
+        }
+        else {
+            data.icon.style.backgroundImage = '';
+            data.icon.className = mainItem.iconClass ? `quick-input-list-icon ${mainItem.iconClass}` : '';
+        }
+        let descriptionTitle;
+        if (!element.saneTooltip && element.saneDescription) {
+            descriptionTitle = {
+                markdown: {
+                    value: element.saneDescription,
+                    supportThemeIcons: true
+                },
+                markdownNotSupportedFallback: element.saneDescription
+            };
+        }
+        const options = {
+            matches: labelHighlights || [],
+            descriptionTitle,
+            descriptionMatches: descriptionHighlights || [],
+            labelEscapeNewLines: true
+        };
+        options.extraClasses = mainItem.iconClasses;
+        options.italic = mainItem.italic;
+        options.strikethrough = mainItem.strikethrough;
+        data.entry.classList.remove('quick-input-list-separator-as-item');
+        data.label.setLabel(element.saneLabel, element.saneDescription, options);
+        data.keybinding.set(mainItem.keybinding);
+        if (element.saneDetail) {
+            let title;
+            if (!element.saneTooltip) {
+                title = {
+                    markdown: {
+                        value: element.saneDetail,
+                        supportThemeIcons: true
+                    },
+                    markdownNotSupportedFallback: element.saneDetail
+                };
+            }
+            data.detail.element.style.display = '';
+            data.detail.setLabel(element.saneDetail, undefined, {
+                matches: detailHighlights,
+                title,
+                labelEscapeNewLines: true
+            });
+        }
+        else {
+            data.detail.element.style.display = 'none';
+        }
+        if (element.separator?.label) {
+            data.separator.textContent = element.separator.label;
+            data.separator.style.display = '';
+            this.addItemWithSeparator(element);
+        }
+        else {
+            data.separator.style.display = 'none';
+        }
+        data.entry.classList.toggle('quick-input-list-separator-border', !!element.separator);
+        const buttons = mainItem.buttons;
+        if (buttons && buttons.length) {
+            data.actionBar.push(( buttons.map(
+                (button, index) => quickInputButtonToAction(button, `id-${index}`, () => element.fireButtonTriggered({ button, item: element.item }))
+            )), { icon: true, label: false });
+            data.entry.classList.add('has-actions');
+        }
+        else {
+            data.entry.classList.remove('has-actions');
+        }
+    }
+    disposeElement(element, _index, data) {
+        this.removeItemWithSeparator(element.element);
+        super.disposeElement(element, _index, data);
+    }
+    isItemWithSeparatorVisible(item) {
+        return ( this._itemsWithSeparatorsFrequency.has(item));
+    }
+    addItemWithSeparator(item) {
+        this._itemsWithSeparatorsFrequency.set(item, (this._itemsWithSeparatorsFrequency.get(item) || 0) + 1);
+    }
+    removeItemWithSeparator(item) {
+        const frequency = this._itemsWithSeparatorsFrequency.get(item) || 0;
+        if (frequency > 1) {
+            this._itemsWithSeparatorsFrequency.set(item, frequency - 1);
+        }
+        else {
+            this._itemsWithSeparatorsFrequency.delete(item);
+        }
+    }
+};
+QuickPickItemElementRenderer = QuickPickItemElementRenderer_1 = ( __decorate([
+    ( __param(1, IThemeService))
+], QuickPickItemElementRenderer));
+class QuickPickSeparatorElementRenderer extends BaseQuickInputListRenderer {
+    constructor() {
+        super(...arguments);
+        this._visibleSeparatorsFrequency = ( new Map());
+    }
+    static { this.ID = 'quickpickseparator'; }
+    get templateId() {
+        return QuickPickSeparatorElementRenderer.ID;
+    }
+    get visibleSeparators() {
+        return [...( this._visibleSeparatorsFrequency.keys())];
+    }
+    isSeparatorVisible(separator) {
+        return ( this._visibleSeparatorsFrequency.has(separator));
+    }
+    renderElement(node, index, data) {
+        const element = node.element;
+        data.element = element;
+        element.element = data.entry ?? undefined;
+        element.element.classList.toggle('focus-inside', !!element.focusInsideSeparator);
+        const mainItem = element.separator;
+        const { labelHighlights, descriptionHighlights, detailHighlights } = element;
+        data.icon.style.backgroundImage = '';
+        data.icon.className = '';
+        let descriptionTitle;
+        if (!element.saneTooltip && element.saneDescription) {
+            descriptionTitle = {
+                markdown: {
+                    value: element.saneDescription,
+                    supportThemeIcons: true
+                },
+                markdownNotSupportedFallback: element.saneDescription
+            };
+        }
+        const options = {
+            matches: labelHighlights || [],
+            descriptionTitle,
+            descriptionMatches: descriptionHighlights || [],
+            labelEscapeNewLines: true
+        };
+        data.entry.classList.add('quick-input-list-separator-as-item');
+        data.label.setLabel(element.saneLabel, element.saneDescription, options);
+        if (element.saneDetail) {
+            let title;
+            if (!element.saneTooltip) {
+                title = {
+                    markdown: {
+                        value: element.saneDetail,
+                        supportThemeIcons: true
+                    },
+                    markdownNotSupportedFallback: element.saneDetail
+                };
+            }
+            data.detail.element.style.display = '';
+            data.detail.setLabel(element.saneDetail, undefined, {
+                matches: detailHighlights,
+                title,
+                labelEscapeNewLines: true
+            });
+        }
+        else {
+            data.detail.element.style.display = 'none';
+        }
+        data.separator.style.display = 'none';
+        data.entry.classList.add('quick-input-list-separator-border');
+        const buttons = mainItem.buttons;
+        if (buttons && buttons.length) {
+            data.actionBar.push(( buttons.map(
+                (button, index) => quickInputButtonToAction(button, `id-${index}`, () => element.fireSeparatorButtonTriggered({ button, separator: element.separator }))
+            )), { icon: true, label: false });
+            data.entry.classList.add('has-actions');
+        }
+        else {
+            data.entry.classList.remove('has-actions');
+        }
+        this.addSeparator(element);
+    }
+    disposeElement(element, _index, data) {
+        this.removeSeparator(element.element);
+        if (!this.isSeparatorVisible(element.element)) {
+            element.element.element?.classList.remove('focus-inside');
+        }
+        super.disposeElement(element, _index, data);
+    }
+    addSeparator(separator) {
+        this._visibleSeparatorsFrequency.set(separator, (this._visibleSeparatorsFrequency.get(separator) || 0) + 1);
+    }
+    removeSeparator(separator) {
+        const frequency = this._visibleSeparatorsFrequency.get(separator) || 0;
+        if (frequency > 1) {
+            this._visibleSeparatorsFrequency.set(separator, frequency - 1);
+        }
+        else {
+            this._visibleSeparatorsFrequency.delete(separator);
+        }
+    }
+}
+let QuickInputTree = class QuickInputTree extends Disposable {
+    constructor(parent, hoverDelegate, linkOpenerDelegate, id, instantiationService) {
+        super();
+        this.parent = parent;
+        this.hoverDelegate = hoverDelegate;
+        this.linkOpenerDelegate = linkOpenerDelegate;
+        this._onKeyDown = ( new Emitter());
+        this.onKeyDown = this._onKeyDown.event;
+        this._onLeave = ( new Emitter());
+        this.onLeave = this._onLeave.event;
+        this._onChangedAllVisibleChecked = ( new Emitter());
+        this.onChangedAllVisibleChecked = this._onChangedAllVisibleChecked.event;
+        this._onChangedCheckedCount = ( new Emitter());
+        this.onChangedCheckedCount = this._onChangedCheckedCount.event;
+        this._onChangedVisibleCount = ( new Emitter());
+        this.onChangedVisibleCount = this._onChangedVisibleCount.event;
+        this._onChangedCheckedElements = ( new Emitter());
+        this.onChangedCheckedElements = this._onChangedCheckedElements.event;
+        this._onButtonTriggered = ( new Emitter());
+        this.onButtonTriggered = this._onButtonTriggered.event;
+        this._onSeparatorButtonTriggered = ( new Emitter());
+        this.onSeparatorButtonTriggered = this._onSeparatorButtonTriggered.event;
+        this._onTriggerEmptySelectionOrFocus = ( new Emitter());
+        this._elementChecked = ( new Emitter());
+        this._inputElements = ( new Array());
+        this._elementTree = ( new Array());
+        this._itemElements = ( new Array());
+        this._elementDisposable = this._register(( new DisposableStore()));
+        this._shouldFireCheckedEvents = true;
+        this._matchOnDescription = false;
+        this._matchOnDetail = false;
+        this._matchOnLabel = true;
+        this._matchOnLabelMode = 'fuzzy';
+        this._matchOnMeta = true;
+        this._sortByLabel = true;
+        this._container = append(this.parent, $('.quick-input-list'));
+        this._separatorRenderer = ( new QuickPickSeparatorElementRenderer(hoverDelegate));
+        this._itemRenderer = instantiationService.createInstance(QuickPickItemElementRenderer, hoverDelegate);
+        this._tree = this._register(instantiationService.createInstance((WorkbenchObjectTree), 'QuickInput', this._container, ( new QuickInputItemDelegate()), [this._itemRenderer, this._separatorRenderer], {
+            accessibilityProvider: ( new QuickInputAccessibilityProvider()),
+            setRowLineHeight: false,
+            multipleSelectionSupport: false,
+            hideTwistiesOfChildlessElements: true,
+            renderIndentGuides: RenderIndentGuides.None,
+            findWidgetEnabled: false,
+            indent: 0,
+            horizontalScrolling: false,
+            allowNonCollapsibleParents: true,
+            identityProvider: {
+                getId: element => {
+                    return element.item?.id
+                        ?? element.item?.label
+                        ?? element.separator?.id
+                        ?? element.separator?.label
+                        ?? '';
+                },
+            },
+            alwaysConsumeMouseWheel: true
+        }));
+        this._tree.getHTMLElement().id = id;
+        this._registerListeners();
+    }
+    get onDidChangeFocus() {
+        return ( Event.map(
+            Event.any(this._tree.onDidChangeFocus, this._onTriggerEmptySelectionOrFocus.event),
+            e => ( e.elements.filter((e) => e instanceof QuickPickItemElement).map(e => e.item))
+        ));
+    }
+    get onDidChangeSelection() {
+        return ( Event.map(
+            Event.any(this._tree.onDidChangeSelection, this._onTriggerEmptySelectionOrFocus.event),
+            e => ({
+                items: ( e.elements.filter((e) => e instanceof QuickPickItemElement).map(e => e.item)),
+                event: e.browserEvent
+            })
+        ));
+    }
+    get scrollTop() {
+        return this._tree.scrollTop;
+    }
+    set scrollTop(scrollTop) {
+        this._tree.scrollTop = scrollTop;
+    }
+    get ariaLabel() {
+        return this._tree.ariaLabel;
+    }
+    set ariaLabel(label) {
+        this._tree.ariaLabel = label ?? '';
+    }
+    set enabled(value) {
+        this._tree.getHTMLElement().style.pointerEvents = value ? '' : 'none';
+    }
+    get matchOnDescription() {
+        return this._matchOnDescription;
+    }
+    set matchOnDescription(value) {
+        this._matchOnDescription = value;
+    }
+    get matchOnDetail() {
+        return this._matchOnDetail;
+    }
+    set matchOnDetail(value) {
+        this._matchOnDetail = value;
+    }
+    get matchOnLabel() {
+        return this._matchOnLabel;
+    }
+    set matchOnLabel(value) {
+        this._matchOnLabel = value;
+    }
+    get matchOnLabelMode() {
+        return this._matchOnLabelMode;
+    }
+    set matchOnLabelMode(value) {
+        this._matchOnLabelMode = value;
+    }
+    get matchOnMeta() {
+        return this._matchOnMeta;
+    }
+    set matchOnMeta(value) {
+        this._matchOnMeta = value;
+    }
+    get sortByLabel() {
+        return this._sortByLabel;
+    }
+    set sortByLabel(value) {
+        this._sortByLabel = value;
+    }
+    _registerListeners() {
+        this._registerOnKeyDown();
+        this._registerOnContainerClick();
+        this._registerOnMouseMiddleClick();
+        this._registerOnElementChecked();
+        this._registerOnContextMenu();
+        this._registerHoverListeners();
+        this._registerSelectionChangeListener();
+        this._registerSeparatorActionShowingListeners();
+    }
+    _registerOnKeyDown() {
+        this._register(this._tree.onKeyDown(e => {
+            const event = ( new StandardKeyboardEvent(e));
+            switch (event.keyCode) {
+                case 10 :
+                    this.toggleCheckbox();
+                    break;
+                case 31 :
+                    if (isMacintosh ? e.metaKey : e.ctrlKey) {
+                        this._tree.setFocus(this._itemElements);
+                    }
+                    break;
+                case 16 : {
+                    const focus1 = this._tree.getFocus();
+                    if (focus1.length === 1 && focus1[0] === this._itemElements[0]) {
+                        this._onLeave.fire();
+                    }
+                    break;
+                }
+                case 18 : {
+                    const focus2 = this._tree.getFocus();
+                    if (focus2.length === 1 && focus2[0] === this._itemElements[this._itemElements.length - 1]) {
+                        this._onLeave.fire();
+                    }
+                    break;
+                }
+            }
+            this._onKeyDown.fire(event);
+        }));
+    }
+    _registerOnContainerClick() {
+        this._register(addDisposableListener(this._container, EventType.CLICK, e => {
+            if (e.x || e.y) {
+                this._onLeave.fire();
+            }
+        }));
+    }
+    _registerOnMouseMiddleClick() {
+        this._register(addDisposableListener(this._container, EventType.AUXCLICK, e => {
+            if (e.button === 1) {
+                this._onLeave.fire();
+            }
+        }));
+    }
+    _registerOnElementChecked() {
+        this._register(this._elementChecked.event(_ => this._fireCheckedEvents()));
+    }
+    _registerOnContextMenu() {
+        this._register(this._tree.onContextMenu(e => {
+            if (e.element) {
+                e.browserEvent.preventDefault();
+                this._tree.setSelection([e.element]);
+            }
+        }));
+    }
+    _registerHoverListeners() {
+        const delayer = this._register(( new ThrottledDelayer(this.hoverDelegate.delay)));
+        this._register(this._tree.onMouseOver(async (e) => {
+            if (e.browserEvent.target instanceof HTMLAnchorElement) {
+                delayer.cancel();
+                return;
+            }
+            if (
+            !(e.browserEvent.relatedTarget instanceof HTMLAnchorElement) &&
+                isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
+                return;
+            }
+            try {
+                await delayer.trigger(async () => {
+                    if (e.element instanceof QuickPickItemElement) {
+                        this.showHover(e.element);
+                    }
+                });
+            }
+            catch (e) {
+                if (!isCancellationError(e)) {
+                    throw e;
+                }
+            }
+        }));
+        this._register(this._tree.onMouseOut(e => {
+            if (isAncestor(e.browserEvent.relatedTarget, e.element?.element)) {
+                return;
+            }
+            delayer.cancel();
+        }));
+    }
+    _registerSeparatorActionShowingListeners() {
+        this._register(this._tree.onDidChangeFocus(e => {
+            const parent = e.elements[0]
+                ? this._tree.getParentElement(e.elements[0])
+                : null;
+            for (const separator of this._separatorRenderer.visibleSeparators) {
+                const value = separator === parent;
+                const currentActive = !!(separator.focusInsideSeparator & QuickPickSeparatorFocusReason.ACTIVE_ITEM);
+                if (currentActive !== value) {
+                    if (value) {
+                        separator.focusInsideSeparator |= QuickPickSeparatorFocusReason.ACTIVE_ITEM;
+                    }
+                    else {
+                        separator.focusInsideSeparator &= ~QuickPickSeparatorFocusReason.ACTIVE_ITEM;
+                    }
+                    this._tree.rerender(separator);
+                }
+            }
+        }));
+        this._register(this._tree.onMouseOver(e => {
+            const parent = e.element
+                ? this._tree.getParentElement(e.element)
+                : null;
+            for (const separator of this._separatorRenderer.visibleSeparators) {
+                if (separator !== parent) {
+                    continue;
+                }
+                const currentMouse = !!(separator.focusInsideSeparator & QuickPickSeparatorFocusReason.MOUSE_HOVER);
+                if (!currentMouse) {
+                    separator.focusInsideSeparator |= QuickPickSeparatorFocusReason.MOUSE_HOVER;
+                    this._tree.rerender(separator);
+                }
+            }
+        }));
+        this._register(this._tree.onMouseOut(e => {
+            const parent = e.element
+                ? this._tree.getParentElement(e.element)
+                : null;
+            for (const separator of this._separatorRenderer.visibleSeparators) {
+                if (separator !== parent) {
+                    continue;
+                }
+                const currentMouse = !!(separator.focusInsideSeparator & QuickPickSeparatorFocusReason.MOUSE_HOVER);
+                if (currentMouse) {
+                    separator.focusInsideSeparator &= ~QuickPickSeparatorFocusReason.MOUSE_HOVER;
+                    this._tree.rerender(separator);
+                }
+            }
+        }));
+    }
+    _registerSelectionChangeListener() {
+        this._register(this._tree.onDidChangeSelection(e => {
+            const elementsWithoutSeparators = e.elements.filter((e) => e instanceof QuickPickItemElement);
+            if (elementsWithoutSeparators.length !== e.elements.length) {
+                if (e.elements.length === 1 && e.elements[0] instanceof QuickPickSeparatorElement) {
+                    this._tree.setFocus([e.elements[0].children[0]]);
+                    this._tree.reveal(e.elements[0], 0);
+                }
+                this._tree.setSelection(elementsWithoutSeparators);
+            }
+        }));
+    }
+    getAllVisibleChecked() {
+        return this._allVisibleChecked(this._itemElements, false);
+    }
+    getCheckedCount() {
+        return this._itemElements.filter(element => element.checked).length;
+    }
+    getVisibleCount() {
+        return this._itemElements.filter(e => !e.hidden).length;
+    }
+    setAllVisibleChecked(checked) {
+        try {
+            this._shouldFireCheckedEvents = false;
+            this._itemElements.forEach(element => {
+                if (!element.hidden && !element.checkboxDisabled) {
+                    element.checked = checked;
+                }
+            });
+        }
+        finally {
+            this._shouldFireCheckedEvents = true;
+            this._fireCheckedEvents();
+        }
+    }
+    setElements(inputElements) {
+        this._elementDisposable.clear();
+        this._inputElements = inputElements;
+        const hasCheckbox = this.parent.classList.contains('show-checkboxes');
+        let currentSeparatorElement;
+        this._itemElements = ( new Array());
+        this._elementTree = inputElements.reduce((result, item, index) => {
+            let element;
+            if (item.type === 'separator') {
+                if (!item.buttons) {
+                    return result;
+                }
+                currentSeparatorElement = ( new QuickPickSeparatorElement(index, (event) => this.fireSeparatorButtonTriggered(event), item));
+                element = currentSeparatorElement;
+            }
+            else {
+                const previous = index > 0 ? inputElements[index - 1] : undefined;
+                let separator;
+                if (previous && previous.type === 'separator' && !previous.buttons) {
+                    currentSeparatorElement = undefined;
+                    separator = previous;
+                }
+                const qpi = ( new QuickPickItemElement(
+                    index,
+                    hasCheckbox,
+                    (event) => this.fireButtonTriggered(event),
+                    this._elementChecked,
+                    item,
+                    separator
+                ));
+                this._itemElements.push(qpi);
+                if (currentSeparatorElement) {
+                    currentSeparatorElement.children.push(qpi);
+                    return result;
+                }
+                element = qpi;
+            }
+            result.push(element);
+            return result;
+        }, ( new Array()));
+        const elements = ( new Array());
+        let visibleCount = 0;
+        for (const element of this._elementTree) {
+            if (element instanceof QuickPickSeparatorElement) {
+                elements.push({
+                    element,
+                    collapsible: false,
+                    collapsed: false,
+                    children: ( element.children.map(e => ({
+                        element: e,
+                        collapsible: false,
+                        collapsed: false,
+                    }))),
+                });
+                visibleCount += element.children.length + 1;
+            }
+            else {
+                elements.push({
+                    element,
+                    collapsible: false,
+                    collapsed: false,
+                });
+                visibleCount++;
+            }
+        }
+        this._tree.setChildren(null, elements);
+        this._onChangedVisibleCount.fire(visibleCount);
+    }
+    getElementsCount() {
+        return this._inputElements.length;
+    }
+    getFocusedElements() {
+        return ( this._tree.getFocus()
+            .filter((e) => !!e)
+            .map(e => e.item))
+            .filter((e) => !!e);
+    }
+    setFocusedElements(items) {
+        const elements = ( items.map(item => this._itemElements.find(e => e.item === item)))
+            .filter((e) => !!e);
+        this._tree.setFocus(elements);
+        if (items.length > 0) {
+            const focused = this._tree.getFocus()[0];
+            if (focused) {
+                this._tree.reveal(focused);
+            }
+        }
+    }
+    getActiveDescendant() {
+        return this._tree.getHTMLElement().getAttribute('aria-activedescendant');
+    }
+    getSelectedElements() {
+        return ( this._tree.getSelection()
+            .filter((e) => !!e && !!e.item)
+            .map(e => e.item));
+    }
+    setSelectedElements(items) {
+        const elements = ( items.map(item => this._itemElements.find(e => e.item === item)))
+            .filter((e) => !!e);
+        this._tree.setSelection(elements);
+    }
+    getCheckedElements() {
+        return ( this._itemElements.filter(e => e.checked)
+            .map(e => e.item));
+    }
+    setCheckedElements(items) {
+        try {
+            this._shouldFireCheckedEvents = false;
+            const checked = ( new Set());
+            for (const item of items) {
+                checked.add(item);
+            }
+            for (const element of this._itemElements) {
+                element.checked = ( checked.has(element.item));
+            }
+        }
+        finally {
+            this._shouldFireCheckedEvents = true;
+            this._fireCheckedEvents();
+        }
+    }
+    focus(what) {
+        if (!this._itemElements.length) {
+            return;
+        }
+        if (what === QuickInputListFocus.Second && this._itemElements.length < 2) {
+            what = QuickInputListFocus.First;
+        }
+        switch (what) {
+            case QuickInputListFocus.First:
+                this._tree.scrollTop = 0;
+                this._tree.focusFirst(undefined, (e) => e.element instanceof QuickPickItemElement);
+                break;
+            case QuickInputListFocus.Second:
+                this._tree.scrollTop = 0;
+                this._tree.setFocus([this._itemElements[1]]);
+                break;
+            case QuickInputListFocus.Last:
+                this._tree.scrollTop = this._tree.scrollHeight;
+                this._tree.setFocus([this._itemElements[this._itemElements.length - 1]]);
+                break;
+            case QuickInputListFocus.Next:
+                this._tree.focusNext(undefined, true, undefined, (e) => {
+                    if (!(e.element instanceof QuickPickItemElement)) {
+                        return false;
+                    }
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                break;
+            case QuickInputListFocus.Previous:
+                this._tree.focusPrevious(undefined, true, undefined, (e) => {
+                    if (!(e.element instanceof QuickPickItemElement)) {
+                        return false;
+                    }
+                    const parent = this._tree.getParentElement(e.element);
+                    if (parent === null || parent.children[0] !== e.element) {
+                        this._tree.reveal(e.element);
+                    }
+                    else {
+                        this._tree.reveal(parent);
+                    }
+                    return true;
+                });
+                break;
+            case QuickInputListFocus.NextPage:
+                this._tree.focusNextPage(undefined, (e) => {
+                    if (!(e.element instanceof QuickPickItemElement)) {
+                        return false;
+                    }
+                    this._tree.reveal(e.element);
+                    return true;
+                });
+                break;
+            case QuickInputListFocus.PreviousPage:
+                this._tree.focusPreviousPage(undefined, (e) => {
+                    if (!(e.element instanceof QuickPickItemElement)) {
+                        return false;
+                    }
+                    const parent = this._tree.getParentElement(e.element);
+                    if (parent === null || parent.children[0] !== e.element) {
+                        this._tree.reveal(e.element);
+                    }
+                    else {
+                        this._tree.reveal(parent);
+                    }
+                    return true;
+                });
+                break;
+            case QuickInputListFocus.NextSeparator: {
+                let foundSeparatorAsItem = false;
+                const before = this._tree.getFocus()[0];
+                this._tree.focusNext(undefined, true, undefined, (e) => {
+                    if (foundSeparatorAsItem) {
+                        return true;
+                    }
+                    if (e.element instanceof QuickPickSeparatorElement) {
+                        foundSeparatorAsItem = true;
+                        if (this._separatorRenderer.isSeparatorVisible(e.element)) {
+                            this._tree.reveal(e.element.children[0]);
+                        }
+                        else {
+                            this._tree.reveal(e.element, 0);
+                        }
+                    }
+                    else if (e.element instanceof QuickPickItemElement) {
+                        if (e.element.separator) {
+                            if (this._itemRenderer.isItemWithSeparatorVisible(e.element)) {
+                                this._tree.reveal(e.element);
+                            }
+                            else {
+                                this._tree.reveal(e.element, 0);
+                            }
+                            return true;
+                        }
+                        else if (e.element === this._elementTree[0]) {
+                            this._tree.reveal(e.element, 0);
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+                const after = this._tree.getFocus()[0];
+                if (before === after) {
+                    this._tree.scrollTop = this._tree.scrollHeight;
+                    this._tree.setFocus([this._itemElements[this._itemElements.length - 1]]);
+                }
+                break;
+            }
+            case QuickInputListFocus.PreviousSeparator: {
+                let focusElement;
+                let foundSeparator = !!this._tree.getFocus()[0]?.separator;
+                this._tree.focusPrevious(undefined, true, undefined, (e) => {
+                    if (e.element instanceof QuickPickSeparatorElement) {
+                        if (foundSeparator) {
+                            if (!focusElement) {
+                                if (this._separatorRenderer.isSeparatorVisible(e.element)) {
+                                    this._tree.reveal(e.element);
+                                }
+                                else {
+                                    this._tree.reveal(e.element, 0);
+                                }
+                                focusElement = e.element.children[0];
+                            }
+                        }
+                        else {
+                            foundSeparator = true;
+                        }
+                    }
+                    else if (e.element instanceof QuickPickItemElement) {
+                        if (!focusElement) {
+                            if (e.element.separator) {
+                                if (this._itemRenderer.isItemWithSeparatorVisible(e.element)) {
+                                    this._tree.reveal(e.element);
+                                }
+                                else {
+                                    this._tree.reveal(e.element, 0);
+                                }
+                                focusElement = e.element;
+                            }
+                            else if (e.element === this._elementTree[0]) {
+                                this._tree.reveal(e.element, 0);
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                });
+                if (focusElement) {
+                    this._tree.setFocus([focusElement]);
+                }
+                break;
+            }
+        }
+    }
+    clearFocus() {
+        this._tree.setFocus([]);
+    }
+    domFocus() {
+        this._tree.domFocus();
+    }
+    layout(maxHeight) {
+        this._tree.getHTMLElement().style.maxHeight = maxHeight ? `${
+        Math.floor(maxHeight / 44) * 44
+            + 6}px` : '';
+        this._tree.layout();
+    }
+    filter(query) {
+        if (!(this._sortByLabel || this._matchOnLabel || this._matchOnDescription || this._matchOnDetail)) {
+            this._tree.layout();
+            return false;
+        }
+        const queryWithWhitespace = query;
+        query = query.trim();
+        if (!query || !(this.matchOnLabel || this.matchOnDescription || this.matchOnDetail)) {
+            this._itemElements.forEach(element => {
+                element.labelHighlights = undefined;
+                element.descriptionHighlights = undefined;
+                element.detailHighlights = undefined;
+                element.hidden = false;
+                const previous = element.index && this._inputElements[element.index - 1];
+                if (element.item) {
+                    element.separator = previous && previous.type === 'separator' && !previous.buttons ? previous : undefined;
+                }
+            });
+        }
+        else {
+            let currentSeparator;
+            this._elementTree.forEach(element => {
+                let labelHighlights;
+                if (this.matchOnLabelMode === 'fuzzy') {
+                    labelHighlights = this.matchOnLabel ? matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneLabel)) ?? undefined : undefined;
+                }
+                else {
+                    labelHighlights = this.matchOnLabel ? matchesContiguousIconAware(queryWithWhitespace, parseLabelWithIcons(element.saneLabel)) ?? undefined : undefined;
+                }
+                const descriptionHighlights = this.matchOnDescription ? matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneDescription || '')) ?? undefined : undefined;
+                const detailHighlights = this.matchOnDetail ? matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneDetail || '')) ?? undefined : undefined;
+                if (labelHighlights || descriptionHighlights || detailHighlights) {
+                    element.labelHighlights = labelHighlights;
+                    element.descriptionHighlights = descriptionHighlights;
+                    element.detailHighlights = detailHighlights;
+                    element.hidden = false;
+                }
+                else {
+                    element.labelHighlights = undefined;
+                    element.descriptionHighlights = undefined;
+                    element.detailHighlights = undefined;
+                    element.hidden = element.item ? !element.item.alwaysShow : true;
+                }
+                if (element.item) {
+                    element.separator = undefined;
+                }
+                else if (element.separator) {
+                    element.hidden = true;
+                }
+                if (!this.sortByLabel) {
+                    const previous = element.index && this._inputElements[element.index - 1];
+                    currentSeparator = previous && previous.type === 'separator' ? previous : currentSeparator;
+                    if (currentSeparator && !element.hidden) {
+                        element.separator = currentSeparator;
+                        currentSeparator = undefined;
+                    }
+                }
+            });
+        }
+        const shownElements = this._elementTree.filter(element => !element.hidden);
+        if (this.sortByLabel && query) {
+            const normalizedSearchValue = query.toLowerCase();
+            shownElements.sort((a, b) => {
+                return compareEntries(a, b, normalizedSearchValue);
+            });
+        }
+        let currentSeparator;
+        const finalElements = shownElements.reduce((result, element, index) => {
+            if (element instanceof QuickPickItemElement) {
+                if (currentSeparator) {
+                    currentSeparator.children.push(element);
+                }
+                else {
+                    result.push(element);
+                }
+            }
+            else if (element instanceof QuickPickSeparatorElement) {
+                element.children = [];
+                currentSeparator = element;
+                result.push(element);
+            }
+            return result;
+        }, ( new Array()));
+        const elements = ( new Array());
+        for (const element of finalElements) {
+            if (element instanceof QuickPickSeparatorElement) {
+                elements.push({
+                    element,
+                    collapsible: false,
+                    collapsed: false,
+                    children: ( element.children.map(e => ({
+                        element: e,
+                        collapsible: false,
+                        collapsed: false,
+                    }))),
+                });
+            }
+            else {
+                elements.push({
+                    element,
+                    collapsible: false,
+                    collapsed: false,
+                });
+            }
+        }
+        const before = this._tree.getFocus().length;
+        this._tree.setChildren(null, elements);
+        if (before > 0 && elements.length === 0) {
+            this._onTriggerEmptySelectionOrFocus.fire({
+                elements: []
+            });
+        }
+        this._tree.layout();
+        this._onChangedAllVisibleChecked.fire(this.getAllVisibleChecked());
+        this._onChangedVisibleCount.fire(shownElements.length);
+        return true;
+    }
+    toggleCheckbox() {
+        try {
+            this._shouldFireCheckedEvents = false;
+            const elements = this._tree.getFocus().filter((e) => e instanceof QuickPickItemElement);
+            const allChecked = this._allVisibleChecked(elements);
+            for (const element of elements) {
+                if (!element.checkboxDisabled) {
+                    element.checked = !allChecked;
+                }
+            }
+        }
+        finally {
+            this._shouldFireCheckedEvents = true;
+            this._fireCheckedEvents();
+        }
+    }
+    display(display) {
+        this._container.style.display = display ? '' : 'none';
+    }
+    isDisplayed() {
+        return this._container.style.display !== 'none';
+    }
+    style(styles) {
+        this._tree.style(styles);
+    }
+    toggleHover() {
+        const focused = this._tree.getFocus()[0];
+        if (!focused?.saneTooltip || !(focused instanceof QuickPickItemElement)) {
+            return;
+        }
+        if (this._lastHover && !this._lastHover.isDisposed) {
+            this._lastHover.dispose();
+            return;
+        }
+        this.showHover(focused);
+        const store = ( new DisposableStore());
+        store.add(this._tree.onDidChangeFocus(e => {
+            if (e.elements[0] instanceof QuickPickItemElement) {
+                this.showHover(e.elements[0]);
+            }
+        }));
+        if (this._lastHover) {
+            store.add(this._lastHover);
+        }
+        this._elementDisposable.add(store);
+    }
+    _allVisibleChecked(elements, whenNoneVisible = true) {
+        for (let i = 0, n = elements.length; i < n; i++) {
+            const element = elements[i];
+            if (!element.hidden) {
+                if (!element.checked) {
+                    return false;
+                }
+                else {
+                    whenNoneVisible = true;
+                }
+            }
+        }
+        return whenNoneVisible;
+    }
+    _fireCheckedEvents() {
+        if (!this._shouldFireCheckedEvents) {
+            return;
+        }
+        this._onChangedAllVisibleChecked.fire(this.getAllVisibleChecked());
+        this._onChangedCheckedCount.fire(this.getCheckedCount());
+        this._onChangedCheckedElements.fire(this.getCheckedElements());
+    }
+    fireButtonTriggered(event) {
+        this._onButtonTriggered.fire(event);
+    }
+    fireSeparatorButtonTriggered(event) {
+        this._onSeparatorButtonTriggered.fire(event);
+    }
+    showHover(element) {
+        if (this._lastHover && !this._lastHover.isDisposed) {
+            this.hoverDelegate.onDidHideHover?.();
+            this._lastHover?.dispose();
+        }
+        if (!element.element || !element.saneTooltip) {
+            return;
+        }
+        this._lastHover = this.hoverDelegate.showHover({
+            content: element.saneTooltip,
+            target: element.element,
+            linkHandler: (url) => {
+                this.linkOpenerDelegate(url);
+            },
+            appearance: {
+                showPointer: true,
+            },
+            container: this._container,
+            position: {
+                hoverPosition: 1
+            }
+        }, false);
+    }
+};
+QuickInputTree.__decorator = ( __decorate([
+    memoize
+], QuickInputTree.prototype, "onDidChangeFocus", null));
+QuickInputTree.__decorator = ( __decorate([
+    memoize
+], QuickInputTree.prototype, "onDidChangeSelection", null));
+QuickInputTree = ( __decorate([
+    ( __param(4, IInstantiationService))
+], QuickInputTree));
+function matchesContiguousIconAware(query, target) {
+    const { text, iconOffsets } = target;
+    if (!iconOffsets || iconOffsets.length === 0) {
+        return matchesContiguous(query, text);
+    }
+    const wordToMatchAgainstWithoutIconsTrimmed = ltrim(text, ' ');
+    const leadingWhitespaceOffset = text.length - wordToMatchAgainstWithoutIconsTrimmed.length;
+    const matches = matchesContiguous(query, wordToMatchAgainstWithoutIconsTrimmed);
+    if (matches) {
+        for (const match of matches) {
+            const iconOffset = iconOffsets[match.start + leadingWhitespaceOffset]  + leadingWhitespaceOffset ;
+            match.start += iconOffset;
+            match.end += iconOffset;
+        }
+    }
+    return matches;
+}
+function matchesContiguous(word, wordToMatchAgainst) {
+    const matchIndex = wordToMatchAgainst.toLowerCase().indexOf(word.toLowerCase());
+    if (matchIndex !== -1) {
+        return [{ start: matchIndex, end: matchIndex + word.length }];
+    }
+    return null;
+}
+function compareEntries(elementA, elementB, lookFor) {
+    const labelHighlightsA = elementA.labelHighlights || [];
+    const labelHighlightsB = elementB.labelHighlights || [];
+    if (labelHighlightsA.length && !labelHighlightsB.length) {
+        return -1;
+    }
+    if (!labelHighlightsA.length && labelHighlightsB.length) {
+        return 1;
+    }
+    if (labelHighlightsA.length === 0 && labelHighlightsB.length === 0) {
+        return 0;
+    }
+    return compareAnything(elementA.saneSortLabel, elementB.saneSortLabel, lookFor);
+}
+export { QuickInputListFocus, QuickInputTree };