@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

package/dist/vscode/vs/workbench/contrib/files/browser/views/explorerViewer.js

@@ -1,1209 +0,0 @@
-import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IFileService, FileKind } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IWorkbenchLayoutService } from '../../../../services/layout/browser/layoutService.js';
-import { IWorkspaceContextService, isTemporaryWorkspace } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { DisposableStore, toDisposable, dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { dirname, joinPath, distinctParents } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
-import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { ExplorerItem, NewExplorerItem } from '../../common/explorerModel.js';
-import { compareFileNamesDefault, compareFileExtensionsDefault, compareFileNamesUnicode, compareFileExtensionsUnicode, compareFileNamesLower, compareFileExtensionsLower, compareFileNamesUpper, compareFileExtensionsUpper } from 'monaco-editor/esm/vs/base/common/comparers.js';
-import { containsDragType, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
-import { fillEditorsDragData } from '../../../../browser/dnd.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { ExternalElementsDragAndDropData, NativeDragAndDropData } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
-import { isWeb, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { getFileNamesMessage, IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
-import { IWorkspaceEditingService } from '../../../../services/workspaces/common/workspaceEditing.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.js';
-import { findValidPasteFileTarget } from '../fileActions.js';
-import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { EventMultiplexer, Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { isStringArray, isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
-import { IExplorerService } from '../files.js';
-import { ExternalFileImport, BrowserFileUpload, getMultipleFilesOverwriteConfirm } from '../fileImportExport.js';
-import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { WebFileSystemAccess } from 'monaco-editor/esm/vs/platform/files/browser/webFileSystemAccess.js';
-import { IgnoreFile } from '../../../../services/search/common/ignoreFile.js';
-import { ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
-import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
-import { defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
-import { IHoverService } from '../../../../services/hover/browser/hover.js';
-class ExplorerDelegate {
-    getHeight(element) {
-        return ExplorerDelegate.ITEM_HEIGHT;
-    }
-    getTemplateId(element) {
-        return FilesRenderer.ID;
-    }
-}
-ExplorerDelegate.ITEM_HEIGHT = 22;
-const explorerRootErrorEmitter = ( new Emitter());
-let ExplorerDataSource = class ExplorerDataSource {
-    constructor(fileFilter, progressService, configService, notificationService, layoutService, fileService, explorerService, contextService) {
-        this.fileFilter = fileFilter;
-        this.progressService = progressService;
-        this.configService = configService;
-        this.notificationService = notificationService;
-        this.layoutService = layoutService;
-        this.fileService = fileService;
-        this.explorerService = explorerService;
-        this.contextService = contextService;
-    }
-    hasChildren(element) {
-        return Array.isArray(element) || element.hasChildren((stat) => this.fileFilter.filter(stat, 1 ));
-    }
-    getChildren(element) {
-        if (Array.isArray(element)) {
-            return element;
-        }
-        const hasError = element.error;
-        const sortOrder = this.explorerService.sortOrderConfiguration.sortOrder;
-        const children = element.fetchChildren(sortOrder);
-        if (Array.isArray(children)) {
-            return children;
-        }
-        const promise = children.then(children => {
-            if (element instanceof ExplorerItem && element.isRoot && !element.error && hasError && this.contextService.getWorkbenchState() !== 2 ) {
-                explorerRootErrorEmitter.fire(element.resource);
-            }
-            return children;
-        }, e => {
-            if (element instanceof ExplorerItem && element.isRoot) {
-                if (this.contextService.getWorkbenchState() === 2 ) {
-                    const placeholder = ( new ExplorerItem(
-                        element.resource,
-                        this.fileService,
-                        this.configService,
-                        undefined,
-                        undefined,
-                        false
-                    ));
-                    placeholder.error = e;
-                    return [placeholder];
-                }
-                else {
-                    explorerRootErrorEmitter.fire(element.resource);
-                }
-            }
-            else {
-                this.notificationService.error(e);
-            }
-            return [];
-        });
-        this.progressService.withProgress({
-            location: 1 ,
-            delay: this.layoutService.isRestored() ? 800 : 1500
-        }, _progress => promise);
-        return promise;
-    }
-};
-ExplorerDataSource = ( __decorate([
-    ( __param(1, IProgressService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, IWorkbenchLayoutService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IExplorerService)),
-    ( __param(7, IWorkspaceContextService))
-], ExplorerDataSource));
-class CompressedNavigationController {
-    get index() { return this._index; }
-    get count() { return this.items.length; }
-    get current() { return this.items[this._index]; }
-    get currentId() { return `${this.id}_${this.index}`; }
-    get labels() { return this._labels; }
-    constructor(id, items, templateData, depth, collapsed) {
-        this.id = id;
-        this.items = items;
-        this.depth = depth;
-        this.collapsed = collapsed;
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this._index = items.length - 1;
-        this.updateLabels(templateData);
-        this._updateLabelDisposable = templateData.label.onDidRender(() => this.updateLabels(templateData));
-    }
-    updateLabels(templateData) {
-        this._labels = Array.from(templateData.container.querySelectorAll('.label-name'));
-        let parents = '';
-        for (let i = 0; i < this.labels.length; i++) {
-            const ariaLabel = parents.length ? `${this.items[i].name}, compact, ${parents}` : this.items[i].name;
-            this.labels[i].setAttribute('aria-label', ariaLabel);
-            this.labels[i].setAttribute('aria-level', `${this.depth + i}`);
-            parents = parents.length ? `${this.items[i].name} ${parents}` : this.items[i].name;
-        }
-        this.updateCollapsed(this.collapsed);
-        if (this._index < this.labels.length) {
-            this.labels[this._index].classList.add('active');
-        }
-    }
-    previous() {
-        if (this._index <= 0) {
-            return;
-        }
-        this.setIndex(this._index - 1);
-    }
-    next() {
-        if (this._index >= this.items.length - 1) {
-            return;
-        }
-        this.setIndex(this._index + 1);
-    }
-    first() {
-        if (this._index === 0) {
-            return;
-        }
-        this.setIndex(0);
-    }
-    last() {
-        if (this._index === this.items.length - 1) {
-            return;
-        }
-        this.setIndex(this.items.length - 1);
-    }
-    setIndex(index) {
-        if (index < 0 || index >= this.items.length) {
-            return;
-        }
-        this.labels[this._index].classList.remove('active');
-        this._index = index;
-        this.labels[this._index].classList.add('active');
-        this._onDidChange.fire();
-    }
-    updateCollapsed(collapsed) {
-        this.collapsed = collapsed;
-        for (let i = 0; i < this.labels.length; i++) {
-            this.labels[i].setAttribute('aria-expanded', collapsed ? 'false' : 'true');
-        }
-    }
-    dispose() {
-        this._onDidChange.dispose();
-        this._updateLabelDisposable.dispose();
-    }
-}
-CompressedNavigationController.ID = 0;
-let FilesRenderer = class FilesRenderer {
-    constructor(container, labels, updateWidth, contextViewService, themeService, configurationService, explorerService, labelService, contextService, contextMenuService, hoverService) {
-        this.labels = labels;
-        this.updateWidth = updateWidth;
-        this.contextViewService = contextViewService;
-        this.themeService = themeService;
-        this.configurationService = configurationService;
-        this.explorerService = explorerService;
-        this.labelService = labelService;
-        this.contextService = contextService;
-        this.contextMenuService = contextMenuService;
-        this.hoverService = hoverService;
-        this.compressedNavigationControllers = ( new Map());
-        this._onDidChangeActiveDescendant = ( new EventMultiplexer());
-        this.onDidChangeActiveDescendant = this._onDidChangeActiveDescendant.event;
-        this.hoverDelegate = new (class {
-            get delay() {
-                if (Date.now() - this.lastHoverHideTime < 500) {
-                    return 0;
-                }
-                return this.configurationService.getValue('workbench.hover.delay');
-            }
-            constructor(configurationService, hoverService) {
-                this.configurationService = configurationService;
-                this.hoverService = hoverService;
-                this.lastHoverHideTime = 0;
-                this.hiddenFromClick = false;
-                this.placement = 'element';
-            }
-            showHover(options, focus) {
-                let element;
-                if (options.target instanceof HTMLElement) {
-                    element = options.target;
-                }
-                else {
-                    element = options.target.targetElements[0];
-                }
-                const tlRow = element.closest('.monaco-tl-row');
-                const listRow = tlRow?.closest('.monaco-list-row');
-                const child = element.querySelector('div.monaco-icon-label-container');
-                const childOfChild = child?.querySelector('span.monaco-icon-name-container');
-                let overflowed = false;
-                if (childOfChild && child) {
-                    const width = child.clientWidth;
-                    const childWidth = childOfChild.offsetWidth;
-                    overflowed = width <= childWidth;
-                }
-                const hasDecoration = ( options.content.toString()).includes('•');
-                overflowed = overflowed || hasDecoration;
-                const indentGuideElement = tlRow?.querySelector('.monaco-tl-indent');
-                if (!indentGuideElement) {
-                    return;
-                }
-                return overflowed ? this.hoverService.showHover({
-                    ...options,
-                    target: indentGuideElement,
-                    compact: true,
-                    container: listRow,
-                    additionalClasses: ['explorer-item-hover'],
-                    skipFadeInAnimation: true,
-                    showPointer: false,
-                    hoverPosition: 1 ,
-                }, focus) : undefined;
-            }
-            onDidHideHover() {
-                if (!this.hiddenFromClick) {
-                    this.lastHoverHideTime = Date.now();
-                }
-                this.hiddenFromClick = false;
-            }
-        })(this.configurationService, this.hoverService);
-        this.config = this.configurationService.getValue();
-        const updateOffsetStyles = () => {
-            const indent = this.configurationService.getValue('workbench.tree.indent');
-            const offset = Math.max(22 - indent, 0);
-            container.style.setProperty(`--vscode-explorer-align-offset-margin-left`, `${offset}px`);
-        };
-        this.configListener = this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('explorer')) {
-                this.config = this.configurationService.getValue();
-            }
-            if (e.affectsConfiguration('workbench.tree.indent')) {
-                updateOffsetStyles();
-            }
-        });
-        updateOffsetStyles();
-    }
-    getWidgetAriaLabel() {
-        return ( localize('treeAriaLabel', "Files Explorer"));
-    }
-    get templateId() {
-        return FilesRenderer.ID;
-    }
-    renderTemplate(container) {
-        const templateDisposables = ( new DisposableStore());
-        const experimentalHover = this.configurationService.getValue('explorer.experimental.hover');
-        const label = templateDisposables.add(this.labels.create(container, { supportHighlights: true, hoverDelegate: experimentalHover ? this.hoverDelegate : undefined }));
-        templateDisposables.add(label.onDidRender(() => {
-            try {
-                if (templateData.currentContext) {
-                    this.updateWidth(templateData.currentContext);
-                }
-            }
-            catch (e) {
-            }
-        }));
-        const templateData = { templateDisposables, elementDisposables: templateDisposables.add(( new DisposableStore())), label, container };
-        return templateData;
-    }
-    renderElement(node, index, templateData) {
-        const stat = node.element;
-        templateData.currentContext = stat;
-        const editableData = this.explorerService.getEditableData(stat);
-        templateData.label.element.classList.remove('compressed');
-        if (!editableData) {
-            templateData.label.element.style.display = 'flex';
-            this.renderStat(stat, stat.name, undefined, node.filterData, templateData);
-        }
-        else {
-            templateData.label.element.style.display = 'none';
-            templateData.elementDisposables.add(this.renderInputBox(templateData.container, stat, editableData));
-        }
-    }
-    renderCompressedElements(node, index, templateData, height) {
-        const stat = node.element.elements[node.element.elements.length - 1];
-        templateData.currentContext = stat;
-        const editable = node.element.elements.filter(e => this.explorerService.isEditable(e));
-        const editableData = editable.length === 0 ? undefined : this.explorerService.getEditableData(editable[0]);
-        if (!editableData) {
-            templateData.label.element.classList.add('compressed');
-            templateData.label.element.style.display = 'flex';
-            const id = `compressed-explorer_${CompressedNavigationController.ID++}`;
-            const label = ( node.element.elements.map(e => e.name));
-            this.renderStat(stat, label, id, node.filterData, templateData);
-            const compressedNavigationController = ( new CompressedNavigationController(id, node.element.elements, templateData, node.depth, node.collapsed));
-            templateData.elementDisposables.add(compressedNavigationController);
-            this.compressedNavigationControllers.set(stat, compressedNavigationController);
-            templateData.elementDisposables.add(this._onDidChangeActiveDescendant.add(compressedNavigationController.onDidChange));
-            templateData.elementDisposables.add(dom.addDisposableListener(templateData.container, 'mousedown', e => {
-                const result = getIconLabelNameFromHTMLElement(e.target);
-                if (result) {
-                    compressedNavigationController.setIndex(result.index);
-                }
-            }));
-            templateData.elementDisposables.add(toDisposable(() => this.compressedNavigationControllers.delete(stat)));
-        }
-        else {
-            templateData.label.element.classList.remove('compressed');
-            templateData.label.element.style.display = 'none';
-            templateData.elementDisposables.add(this.renderInputBox(templateData.container, editable[0], editableData));
-        }
-    }
-    renderStat(stat, label, domId, filterData, templateData) {
-        templateData.label.element.style.display = 'flex';
-        const extraClasses = ['explorer-item'];
-        if (this.explorerService.isCut(stat)) {
-            extraClasses.push('cut');
-        }
-        const theme = this.themeService.getFileIconTheme();
-        const twistieContainer = templateData.container.parentElement?.parentElement?.querySelector('.monaco-tl-twistie');
-        twistieContainer?.classList.toggle('force-twistie', stat.hasNests && theme.hidesExplorerArrows);
-        const themeIsUnhappyWithNesting = theme.hasFileIcons && (theme.hidesExplorerArrows || !theme.hasFolderIcons);
-        const realignNestedChildren = stat.nestedParent && themeIsUnhappyWithNesting;
-        const experimentalHover = this.configurationService.getValue('explorer.experimental.hover');
-        templateData.label.setResource({ resource: stat.resource, name: label }, {
-            title: experimentalHover ? isStringArray(label) ? label[0] : label : undefined,
-            fileKind: stat.isRoot ? FileKind.ROOT_FOLDER : stat.isDirectory ? FileKind.FOLDER : FileKind.FILE,
-            extraClasses: realignNestedChildren ? [...extraClasses, 'align-nest-icon-with-parent-icon'] : extraClasses,
-            fileDecorations: this.config.explorer.decorations,
-            matches: createMatches(filterData),
-            separator: this.labelService.getSeparator(stat.resource.scheme, stat.resource.authority),
-            domId
-        });
-    }
-    renderInputBox(container, stat, editableData) {
-        const label = this.labels.create(container);
-        const extraClasses = ['explorer-item', 'explorer-item-edited'];
-        const fileKind = stat.isRoot ? FileKind.ROOT_FOLDER : stat.isDirectory ? FileKind.FOLDER : FileKind.FILE;
-        const theme = this.themeService.getFileIconTheme();
-        const themeIsUnhappyWithNesting = theme.hasFileIcons && (theme.hidesExplorerArrows || !theme.hasFolderIcons);
-        const realignNestedChildren = stat.nestedParent && themeIsUnhappyWithNesting;
-        const labelOptions = {
-            hidePath: true,
-            hideLabel: true,
-            fileKind,
-            extraClasses: realignNestedChildren ? [...extraClasses, 'align-nest-icon-with-parent-icon'] : extraClasses,
-        };
-        const parent = stat.name ? dirname(stat.resource) : stat.resource;
-        const value = stat.name || '';
-        label.setFile(joinPath(parent, value || ' '), labelOptions);
-        label.element.firstElementChild.style.display = 'none';
-        const inputBox = ( new InputBox(label.element, this.contextViewService, {
-            validationOptions: {
-                validation: (value) => {
-                    const message = editableData.validationMessage(value);
-                    if (!message || message.severity !== Severity.Error) {
-                        return null;
-                    }
-                    return {
-                        content: message.content,
-                        formatContent: true,
-                        type: 3
-                    };
-                }
-            },
-            ariaLabel: ( localize(
-                'fileInputAriaLabel',
-                "Type file name. Press Enter to confirm or Escape to cancel."
-            )),
-            inputBoxStyles: defaultInputBoxStyles
-        }));
-        const lastDot = value.lastIndexOf('.');
-        let currentSelectionState = 'prefix';
-        inputBox.value = value;
-        inputBox.focus();
-        inputBox.select({ start: 0, end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length });
-        const done = once((success, finishEditing) => {
-            label.element.style.display = 'none';
-            const value = inputBox.value;
-            dispose(toDispose);
-            label.element.remove();
-            if (finishEditing) {
-                editableData.onFinish(value, success);
-            }
-        });
-        const showInputBoxNotification = () => {
-            if (inputBox.isInputValid()) {
-                const message = editableData.validationMessage(inputBox.value);
-                if (message) {
-                    inputBox.showMessage({
-                        content: message.content,
-                        formatContent: true,
-                        type: message.severity === Severity.Info ? 1  : message.severity === Severity.Warning ? 2  : 3
-                    });
-                }
-                else {
-                    inputBox.hideMessage();
-                }
-            }
-        };
-        showInputBoxNotification();
-        const toDispose = [
-            inputBox,
-            inputBox.onDidChange(value => {
-                label.setFile(joinPath(parent, value || ' '), labelOptions);
-            }),
-            dom.addStandardDisposableListener(inputBox.inputElement, dom.EventType.KEY_DOWN, (e) => {
-                if (e.equals(60 )) {
-                    const dotIndex = inputBox.value.lastIndexOf('.');
-                    if (stat.isDirectory || dotIndex === -1) {
-                        return;
-                    }
-                    if (currentSelectionState === 'prefix') {
-                        currentSelectionState = 'all';
-                        inputBox.select({ start: 0, end: inputBox.value.length });
-                    }
-                    else if (currentSelectionState === 'all') {
-                        currentSelectionState = 'suffix';
-                        inputBox.select({ start: dotIndex + 1, end: inputBox.value.length });
-                    }
-                    else {
-                        currentSelectionState = 'prefix';
-                        inputBox.select({ start: 0, end: dotIndex });
-                    }
-                }
-                else if (e.equals(3 )) {
-                    if (!inputBox.validate()) {
-                        done(true, true);
-                    }
-                }
-                else if (e.equals(9 )) {
-                    done(false, true);
-                }
-            }),
-            dom.addStandardDisposableListener(inputBox.inputElement, dom.EventType.KEY_UP, (e) => {
-                showInputBoxNotification();
-            }),
-            dom.addDisposableListener(inputBox.inputElement, dom.EventType.BLUR, async () => {
-                while (true) {
-                    await timeout(0);
-                    if (!document.hasFocus()) {
-                        break;
-                    }
-                    if (document.activeElement === inputBox.inputElement) {
-                        return;
-                    }
-                    else if (document.activeElement instanceof HTMLElement && dom.hasParentWithClass(document.activeElement, 'context-view')) {
-                        await Event.toPromise(this.contextMenuService.onDidHideContextMenu);
-                    }
-                    else {
-                        break;
-                    }
-                }
-                done(inputBox.isInputValid(), true);
-            }),
-            label
-        ];
-        return toDisposable(() => {
-            done(false, false);
-        });
-    }
-    disposeElement(element, index, templateData) {
-        templateData.currentContext = undefined;
-        templateData.elementDisposables.clear();
-    }
-    disposeCompressedElements(node, index, templateData) {
-        templateData.currentContext = undefined;
-        templateData.elementDisposables.clear();
-    }
-    disposeTemplate(templateData) {
-        templateData.templateDisposables.dispose();
-    }
-    getCompressedNavigationController(stat) {
-        return this.compressedNavigationControllers.get(stat);
-    }
-    getAriaLabel(element) {
-        return element.name;
-    }
-    getAriaLevel(element) {
-        let depth = 0;
-        let parent = element.parent;
-        while (parent) {
-            parent = parent.parent;
-            depth++;
-        }
-        if (this.contextService.getWorkbenchState() === 3 ) {
-            depth = depth + 1;
-        }
-        return depth;
-    }
-    getActiveDescendantId(stat) {
-        const compressedNavigationController = this.compressedNavigationControllers.get(stat);
-        return compressedNavigationController?.currentId;
-    }
-    dispose() {
-        this.configListener.dispose();
-    }
-};
-FilesRenderer.ID = 'file';
-FilesRenderer = ( __decorate([
-    ( __param(3, IContextViewService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IExplorerService)),
-    ( __param(7, ILabelService)),
-    ( __param(8, IWorkspaceContextService)),
-    ( __param(9, IContextMenuService)),
-    ( __param(10, IHoverService))
-], FilesRenderer));
-let FilesFilter = class FilesFilter {
-    constructor(contextService, configurationService, explorerService, editorService, uriIdentityService, fileService) {
-        this.contextService = contextService;
-        this.configurationService = configurationService;
-        this.explorerService = explorerService;
-        this.editorService = editorService;
-        this.uriIdentityService = uriIdentityService;
-        this.fileService = fileService;
-        this.hiddenExpressionPerRoot = ( new Map());
-        this.editorsAffectingFilter = ( new Set());
-        this._onDidChange = ( new Emitter());
-        this.toDispose = [];
-        this.ignoreFileResourcesPerRoot = ( new Map());
-        this.ignoreTreesPerRoot = ( new Map());
-        this.toDispose.push(this.contextService.onDidChangeWorkspaceFolders(() => this.updateConfiguration()));
-        this.toDispose.push(this.configurationService.onDidChangeConfiguration((e) => {
-            if (e.affectsConfiguration('files.exclude') || e.affectsConfiguration('explorer.excludeGitIgnore')) {
-                this.updateConfiguration();
-            }
-        }));
-        this.toDispose.push(this.fileService.onDidFilesChange(e => {
-            for (const [root, ignoreFileResourceSet] of this.ignoreFileResourcesPerRoot.entries()) {
-                ignoreFileResourceSet.forEach(async (ignoreResource) => {
-                    if (e.contains(ignoreResource, 0 )) {
-                        await this.processIgnoreFile(root, ignoreResource, true);
-                    }
-                    if (e.contains(ignoreResource, 2 )) {
-                        this.ignoreTreesPerRoot.get(root)?.delete(dirname(ignoreResource));
-                        ignoreFileResourceSet.delete(ignoreResource);
-                        this._onDidChange.fire();
-                    }
-                });
-            }
-        }));
-        this.toDispose.push(this.editorService.onDidVisibleEditorsChange(() => {
-            const editors = this.editorService.visibleEditors;
-            let shouldFire = false;
-            for (const e of editors) {
-                if (!e.resource) {
-                    continue;
-                }
-                const stat = this.explorerService.findClosest(e.resource);
-                if (stat && stat.isExcluded) {
-                    shouldFire = true;
-                    break;
-                }
-            }
-            for (const e of this.editorsAffectingFilter) {
-                if (!editors.includes(e)) {
-                    shouldFire = true;
-                    break;
-                }
-            }
-            if (shouldFire) {
-                this.editorsAffectingFilter.clear();
-                this._onDidChange.fire();
-            }
-        }));
-        this.updateConfiguration();
-    }
-    get onDidChange() {
-        return this._onDidChange.event;
-    }
-    updateConfiguration() {
-        let shouldFire = false;
-        let updatedGitIgnoreSetting = false;
-        this.contextService.getWorkspace().folders.forEach(folder => {
-            const configuration = this.configurationService.getValue({ resource: folder.uri });
-            const excludesConfig = configuration?.files?.exclude || Object.create(null);
-            const parseIgnoreFile = configuration.explorer.excludeGitIgnore;
-            if (parseIgnoreFile && !( this.ignoreTreesPerRoot.has(( folder.uri.toString())))) {
-                updatedGitIgnoreSetting = true;
-                this.ignoreFileResourcesPerRoot.set(( folder.uri.toString()), ( new ResourceSet()));
-                this.ignoreTreesPerRoot.set(( folder.uri.toString()), TernarySearchTree.forUris((uri) => this.uriIdentityService.extUri.ignorePathCasing(uri)));
-            }
-            if (!parseIgnoreFile && ( this.ignoreTreesPerRoot.has(( folder.uri.toString())))) {
-                updatedGitIgnoreSetting = true;
-                this.ignoreFileResourcesPerRoot.delete(( folder.uri.toString()));
-                this.ignoreTreesPerRoot.delete(( folder.uri.toString()));
-            }
-            if (!shouldFire) {
-                const cached = this.hiddenExpressionPerRoot.get(( folder.uri.toString()));
-                shouldFire = !cached || !equals(cached.original, excludesConfig);
-            }
-            const excludesConfigCopy = deepClone(excludesConfig);
-            this.hiddenExpressionPerRoot.set(( folder.uri.toString()), { original: excludesConfigCopy, parsed: glob.parse(excludesConfigCopy) });
-        });
-        if (shouldFire || updatedGitIgnoreSetting) {
-            this.editorsAffectingFilter.clear();
-            this._onDidChange.fire();
-        }
-    }
-    async processIgnoreFile(root, ignoreFileResource, update) {
-        const dirUri = dirname(ignoreFileResource);
-        const ignoreTree = this.ignoreTreesPerRoot.get(root);
-        if (!ignoreTree) {
-            return;
-        }
-        if (!update && ( ignoreTree.has(dirUri))) {
-            return;
-        }
-        const content = await this.fileService.readFile(ignoreFileResource);
-        if (update) {
-            const ignoreFile = ignoreTree.get(dirUri);
-            ignoreFile?.updateContents(( content.value.toString()));
-        }
-        else {
-            const ignoreParent = ignoreTree.findSubstr(dirUri);
-            const ignoreFile = ( new IgnoreFile(( content.value.toString()), dirUri.path, ignoreParent));
-            ignoreTree.set(dirUri, ignoreFile);
-            if (!this.ignoreFileResourcesPerRoot.get(root)?.has(ignoreFileResource)) {
-                this.ignoreFileResourcesPerRoot.get(root)?.add(ignoreFileResource);
-            }
-        }
-        this._onDidChange.fire();
-    }
-    filter(stat, parentVisibility) {
-        if (stat.name === '.gitignore' && ( this.ignoreTreesPerRoot.has(( stat.root.resource.toString())))) {
-            this.processIgnoreFile(( stat.root.resource.toString()), stat.resource, false);
-            return true;
-        }
-        return this.isVisible(stat, parentVisibility);
-    }
-    isVisible(stat, parentVisibility) {
-        stat.isExcluded = false;
-        if (parentVisibility === 0 ) {
-            stat.isExcluded = true;
-            return false;
-        }
-        if (this.explorerService.getEditableData(stat)) {
-            return true;
-        }
-        const cached = this.hiddenExpressionPerRoot.get(( stat.root.resource.toString()));
-        const globMatch = cached?.parsed(path.relative(stat.root.resource.path, stat.resource.path), stat.name, name => !!(stat.parent && stat.parent.getChild(name)));
-        const ignoreFile = globMatch ? undefined : this.ignoreTreesPerRoot.get(( stat.root.resource.toString()))?.findSubstr(stat.resource);
-        const isIncludedInTraversal = ignoreFile?.isPathIncludedInTraversal(stat.resource.path, stat.isDirectory);
-        const isIgnoredByIgnoreFile = isIncludedInTraversal === undefined ? false : !isIncludedInTraversal;
-        if (isIgnoredByIgnoreFile || globMatch || stat.parent?.isExcluded) {
-            stat.isExcluded = true;
-            const editors = this.editorService.visibleEditors;
-            const editor = editors.find(e => e.resource && this.uriIdentityService.extUri.isEqualOrParent(e.resource, stat.resource));
-            if (editor && stat.root === this.explorerService.findClosestRoot(stat.resource)) {
-                this.editorsAffectingFilter.add(editor);
-                return true;
-            }
-            return false;
-        }
-        return true;
-    }
-    dispose() {
-        dispose(this.toDispose);
-    }
-};
-FilesFilter = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IExplorerService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, IFileService))
-], FilesFilter));
-let FileSorter = class FileSorter {
-    constructor(explorerService, contextService) {
-        this.explorerService = explorerService;
-        this.contextService = contextService;
-    }
-    compare(statA, statB) {
-        if (statA.isRoot) {
-            if (statB.isRoot) {
-                const workspaceA = this.contextService.getWorkspaceFolder(statA.resource);
-                const workspaceB = this.contextService.getWorkspaceFolder(statB.resource);
-                return workspaceA && workspaceB ? (workspaceA.index - workspaceB.index) : -1;
-            }
-            return -1;
-        }
-        if (statB.isRoot) {
-            return 1;
-        }
-        const sortOrder = this.explorerService.sortOrderConfiguration.sortOrder;
-        const lexicographicOptions = this.explorerService.sortOrderConfiguration.lexicographicOptions;
-        let compareFileNames;
-        let compareFileExtensions;
-        switch (lexicographicOptions) {
-            case 'upper':
-                compareFileNames = compareFileNamesUpper;
-                compareFileExtensions = compareFileExtensionsUpper;
-                break;
-            case 'lower':
-                compareFileNames = compareFileNamesLower;
-                compareFileExtensions = compareFileExtensionsLower;
-                break;
-            case 'unicode':
-                compareFileNames = compareFileNamesUnicode;
-                compareFileExtensions = compareFileExtensionsUnicode;
-                break;
-            default:
-                compareFileNames = compareFileNamesDefault;
-                compareFileExtensions = compareFileExtensionsDefault;
-        }
-        switch (sortOrder) {
-            case 'type':
-                if (statA.isDirectory && !statB.isDirectory) {
-                    return -1;
-                }
-                if (statB.isDirectory && !statA.isDirectory) {
-                    return 1;
-                }
-                if (statA.isDirectory && statB.isDirectory) {
-                    return compareFileNames(statA.name, statB.name);
-                }
-                break;
-            case 'filesFirst':
-                if (statA.isDirectory && !statB.isDirectory) {
-                    return 1;
-                }
-                if (statB.isDirectory && !statA.isDirectory) {
-                    return -1;
-                }
-                break;
-            case 'foldersNestsFiles':
-                if (statA.isDirectory && !statB.isDirectory) {
-                    return -1;
-                }
-                if (statB.isDirectory && !statA.isDirectory) {
-                    return 1;
-                }
-                if (statA.hasNests && !statB.hasNests) {
-                    return -1;
-                }
-                if (statB.hasNests && !statA.hasNests) {
-                    return 1;
-                }
-                break;
-            case 'mixed':
-                break;
-            default:
-                if (statA.isDirectory && !statB.isDirectory) {
-                    return -1;
-                }
-                if (statB.isDirectory && !statA.isDirectory) {
-                    return 1;
-                }
-                break;
-        }
-        switch (sortOrder) {
-            case 'type':
-                return compareFileExtensions(statA.name, statB.name);
-            case 'modified':
-                if (statA.mtime !== statB.mtime) {
-                    return (statA.mtime && statB.mtime && statA.mtime < statB.mtime) ? 1 : -1;
-                }
-                return compareFileNames(statA.name, statB.name);
-            default:
-                return compareFileNames(statA.name, statB.name);
-        }
-    }
-};
-FileSorter = ( __decorate([
-    ( __param(0, IExplorerService)),
-    ( __param(1, IWorkspaceContextService))
-], FileSorter));
-let FileDragAndDrop = class FileDragAndDrop {
-    constructor(isCollapsed, explorerService, editorService, dialogService, contextService, fileService, configurationService, instantiationService, workspaceEditingService, uriIdentityService) {
-        this.isCollapsed = isCollapsed;
-        this.explorerService = explorerService;
-        this.editorService = editorService;
-        this.dialogService = dialogService;
-        this.contextService = contextService;
-        this.fileService = fileService;
-        this.configurationService = configurationService;
-        this.instantiationService = instantiationService;
-        this.workspaceEditingService = workspaceEditingService;
-        this.uriIdentityService = uriIdentityService;
-        this.compressedDropTargetDisposable = Disposable.None;
-        this.dropEnabled = false;
-        this.toDispose = [];
-        const updateDropEnablement = (e) => {
-            if (!e || e.affectsConfiguration('explorer.enableDragAndDrop')) {
-                this.dropEnabled = this.configurationService.getValue('explorer.enableDragAndDrop');
-            }
-        };
-        updateDropEnablement(undefined);
-        this.toDispose.push(this.configurationService.onDidChangeConfiguration(e => updateDropEnablement(e)));
-    }
-    onDragOver(data, target, targetIndex, originalEvent) {
-        if (!this.dropEnabled) {
-            return false;
-        }
-        if (target) {
-            const compressedTarget = FileDragAndDrop.getCompressedStatFromDragEvent(target, originalEvent);
-            if (compressedTarget) {
-                const iconLabelName = getIconLabelNameFromHTMLElement(originalEvent.target);
-                if (iconLabelName && iconLabelName.index < iconLabelName.count - 1) {
-                    const result = this.handleDragOver(data, compressedTarget, targetIndex, originalEvent);
-                    if (result) {
-                        if (iconLabelName.element !== this.compressedDragOverElement) {
-                            this.compressedDragOverElement = iconLabelName.element;
-                            this.compressedDropTargetDisposable.dispose();
-                            this.compressedDropTargetDisposable = toDisposable(() => {
-                                iconLabelName.element.classList.remove('drop-target');
-                                this.compressedDragOverElement = undefined;
-                            });
-                            iconLabelName.element.classList.add('drop-target');
-                        }
-                        return typeof result === 'boolean' ? result : { ...result, feedback: [] };
-                    }
-                    this.compressedDropTargetDisposable.dispose();
-                    return false;
-                }
-            }
-        }
-        this.compressedDropTargetDisposable.dispose();
-        return this.handleDragOver(data, target, targetIndex, originalEvent);
-    }
-    handleDragOver(data, target, targetIndex, originalEvent) {
-        const isCopy = originalEvent && ((originalEvent.ctrlKey && !isMacintosh) || (originalEvent.altKey && isMacintosh));
-        const isNative = data instanceof NativeDragAndDropData;
-        const effect = (isNative || isCopy) ? 0  : 1 ;
-        if (isNative) {
-            if (!containsDragType(originalEvent, DataTransfers.FILES, CodeDataTransfers.FILES, DataTransfers.RESOURCES)) {
-                return false;
-            }
-        }
-        else if (data instanceof ExternalElementsDragAndDropData) {
-            return false;
-        }
-        else {
-            const items = FileDragAndDrop.getStatsFromDragAndDropData(data);
-            if (!target) {
-                if (!isCopy && items.every(i => !!i.parent && i.parent.isRoot)) {
-                    return false;
-                }
-                return { accept: true, bubble: 0 , effect, autoExpand: false };
-            }
-            if (!Array.isArray(items)) {
-                return false;
-            }
-            if (( items.some((source) => {
-                if (source.isRoot && target instanceof ExplorerItem && !target.isRoot) {
-                    return true;
-                }
-                if (this.uriIdentityService.extUri.isEqual(source.resource, target.resource)) {
-                    return true;
-                }
-                if (source.isRoot && target instanceof ExplorerItem && target.isRoot) {
-                    return false;
-                }
-                if (!isCopy && this.uriIdentityService.extUri.isEqual(dirname(source.resource), target.resource)) {
-                    return true;
-                }
-                if (this.uriIdentityService.extUri.isEqualOrParent(target.resource, source.resource)) {
-                    return true;
-                }
-                return false;
-            }))) {
-                return false;
-            }
-        }
-        if (!target) {
-            return { accept: true, bubble: 0 , effect };
-        }
-        else {
-            if (target.isDirectory) {
-                if (target.isReadonly) {
-                    return false;
-                }
-                return { accept: true, bubble: 0 , effect, autoExpand: true };
-            }
-            if (this.contextService.getWorkspace().folders.every(folder => ( folder.uri.toString()) !== ( target.resource.toString()))) {
-                return { accept: true, bubble: 1 , effect };
-            }
-        }
-        return false;
-    }
-    getDragURI(element) {
-        if (this.explorerService.isEditable(element)) {
-            return null;
-        }
-        return ( element.resource.toString());
-    }
-    getDragLabel(elements, originalEvent) {
-        if (elements.length === 1) {
-            const stat = FileDragAndDrop.getCompressedStatFromDragEvent(elements[0], originalEvent);
-            return stat.name;
-        }
-        return String(elements.length);
-    }
-    onDragStart(data, originalEvent) {
-        const items = FileDragAndDrop.getStatsFromDragAndDropData(data, originalEvent);
-        if (items && items.length && originalEvent.dataTransfer) {
-            this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, items, originalEvent));
-            const fileResources = ( items.filter(s => s.resource.scheme === Schemas.file).map(r => r.resource.fsPath));
-            if (fileResources.length) {
-                originalEvent.dataTransfer.setData(CodeDataTransfers.FILES, JSON.stringify(fileResources));
-            }
-        }
-    }
-    async drop(data, target, targetIndex, originalEvent) {
-        this.compressedDropTargetDisposable.dispose();
-        if (target) {
-            const compressedTarget = FileDragAndDrop.getCompressedStatFromDragEvent(target, originalEvent);
-            if (compressedTarget) {
-                target = compressedTarget;
-            }
-        }
-        if (!target) {
-            target = this.explorerService.roots[this.explorerService.roots.length - 1];
-        }
-        if (!target.isDirectory && target.parent) {
-            target = target.parent;
-        }
-        if (target.isReadonly) {
-            return;
-        }
-        const resolvedTarget = target;
-        if (!resolvedTarget) {
-            return;
-        }
-        try {
-            if (data instanceof NativeDragAndDropData) {
-                if (!isWeb || (isTemporaryWorkspace(this.contextService.getWorkspace()) && WebFileSystemAccess.supported(window))) {
-                    const fileImport = this.instantiationService.createInstance(ExternalFileImport);
-                    await fileImport.import(resolvedTarget, originalEvent);
-                }
-                else {
-                    const browserUpload = this.instantiationService.createInstance(BrowserFileUpload);
-                    await browserUpload.upload(target, originalEvent);
-                }
-            }
-            else {
-                await this.handleExplorerDrop(data, resolvedTarget, originalEvent);
-            }
-        }
-        catch (error) {
-            this.dialogService.error(toErrorMessage(error));
-        }
-    }
-    async handleExplorerDrop(data, target, originalEvent) {
-        const elementsData = FileDragAndDrop.getStatsFromDragAndDropData(data);
-        const distinctItems = ( new Map(( elementsData.map(element => [element, this.isCollapsed(element)]))));
-        for (const [item, collapsed] of distinctItems) {
-            if (collapsed) {
-                const nestedChildren = item.nestedChildren;
-                if (nestedChildren) {
-                    for (const child of nestedChildren) {
-                        distinctItems.set(child, true);
-                    }
-                }
-            }
-        }
-        const items = distinctParents([...( distinctItems.keys())], s => s.resource);
-        const isCopy = (originalEvent.ctrlKey && !isMacintosh) || (originalEvent.altKey && isMacintosh);
-        const confirmDragAndDrop = !isCopy && this.configurationService.getValue(FileDragAndDrop.CONFIRM_DND_SETTING_KEY);
-        if (confirmDragAndDrop) {
-            const message = items.length > 1 && items.every(s => s.isRoot) ? ( localize(
-                'confirmRootsMove',
-                "Are you sure you want to change the order of multiple root folders in your workspace?"
-            ))
-                : items.length > 1 ? ( localize(
-                'confirmMultiMove',
-                "Are you sure you want to move the following {0} files into '{1}'?",
-                items.length,
-                target.name
-            ))
-                    : items[0].isRoot ? ( localize(
-                'confirmRootMove',
-                "Are you sure you want to change the order of root folder '{0}' in your workspace?",
-                items[0].name
-            ))
-                        : ( localize(
-                'confirmMove',
-                "Are you sure you want to move '{0}' into '{1}'?",
-                items[0].name,
-                target.name
-            ));
-            const detail = items.length > 1 && !items.every(s => s.isRoot) ? getFileNamesMessage(( items.map(i => i.resource))) : undefined;
-            const confirmation = await this.dialogService.confirm({
-                message,
-                detail,
-                checkbox: {
-                    label: ( localize('doNotAskAgain', "Do not ask me again"))
-                },
-                primaryButton: ( localize({ key: 'moveButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Move"))
-            });
-            if (!confirmation.confirmed) {
-                return;
-            }
-            if (confirmation.checkboxChecked === true) {
-                await this.configurationService.updateValue(FileDragAndDrop.CONFIRM_DND_SETTING_KEY, false);
-            }
-        }
-        await this.doHandleRootDrop(items.filter(s => s.isRoot), target);
-        const sources = items.filter(s => !s.isRoot);
-        if (isCopy) {
-            return this.doHandleExplorerDropOnCopy(sources, target);
-        }
-        return this.doHandleExplorerDropOnMove(sources, target);
-    }
-    async doHandleRootDrop(roots, target) {
-        if (roots.length === 0) {
-            return;
-        }
-        const folders = this.contextService.getWorkspace().folders;
-        let targetIndex;
-        const workspaceCreationData = [];
-        const rootsToMove = [];
-        for (let index = 0; index < folders.length; index++) {
-            const data = {
-                uri: folders[index].uri,
-                name: folders[index].name
-            };
-            if (target instanceof ExplorerItem && this.uriIdentityService.extUri.isEqual(folders[index].uri, target.resource)) {
-                targetIndex = index;
-            }
-            if (roots.every(r => ( r.resource.toString()) !== ( folders[index].uri.toString()))) {
-                workspaceCreationData.push(data);
-            }
-            else {
-                rootsToMove.push(data);
-            }
-        }
-        if (targetIndex === undefined) {
-            targetIndex = workspaceCreationData.length;
-        }
-        workspaceCreationData.splice(targetIndex, 0, ...rootsToMove);
-        return this.workspaceEditingService.updateFolders(0, workspaceCreationData.length, workspaceCreationData);
-    }
-    async doHandleExplorerDropOnCopy(sources, target) {
-        const explorerConfig = this.configurationService.getValue().explorer;
-        const resourceFileEdits = [];
-        for (const { resource, isDirectory } of sources) {
-            const allowOverwrite = explorerConfig.incrementalNaming === 'disabled';
-            const newResource = await findValidPasteFileTarget(this.explorerService, this.fileService, this.dialogService, target, { resource, isDirectory, allowOverwrite }, explorerConfig.incrementalNaming);
-            if (!newResource) {
-                continue;
-            }
-            const resourceEdit = ( new ResourceFileEdit(resource, newResource, { copy: true, overwrite: allowOverwrite }));
-            resourceFileEdits.push(resourceEdit);
-        }
-        const labelSufix = getFileOrFolderLabelSufix(sources);
-        await this.explorerService.applyBulkEdit(resourceFileEdits, {
-            confirmBeforeUndo: explorerConfig.confirmUndo === "default"  || explorerConfig.confirmUndo === "verbose" ,
-            undoLabel: ( localize('copy', "Copy {0}", labelSufix)),
-            progressLabel: ( localize('copying', "Copying {0}", labelSufix)),
-        });
-        const editors = ( resourceFileEdits.filter(edit => {
-            const item = edit.newResource ? this.explorerService.findClosest(edit.newResource) : undefined;
-            return item && !item.isDirectory;
-        }).map(edit => ({ resource: edit.newResource, options: { pinned: true } })));
-        await this.editorService.openEditors(editors);
-    }
-    async doHandleExplorerDropOnMove(sources, target) {
-        const resourceFileEdits = ( sources.filter(source => !source.isReadonly).map(source => ( new ResourceFileEdit(source.resource, joinPath(target.resource, source.name)))));
-        const labelSufix = getFileOrFolderLabelSufix(sources);
-        const options = {
-            confirmBeforeUndo: this.configurationService.getValue().explorer.confirmUndo === "verbose" ,
-            undoLabel: ( localize('move', "Move {0}", labelSufix)),
-            progressLabel: ( localize('moving', "Moving {0}", labelSufix))
-        };
-        try {
-            await this.explorerService.applyBulkEdit(resourceFileEdits, options);
-        }
-        catch (error) {
-            if (error.fileOperationResult === 4 ) {
-                const overwrites = [];
-                for (const edit of resourceFileEdits) {
-                    if (edit.newResource && (await this.fileService.exists(edit.newResource))) {
-                        overwrites.push(edit.newResource);
-                    }
-                }
-                const confirm = getMultipleFilesOverwriteConfirm(overwrites);
-                const { confirmed } = await this.dialogService.confirm(confirm);
-                if (confirmed) {
-                    await this.explorerService.applyBulkEdit(( resourceFileEdits.map(re => ( new ResourceFileEdit(re.oldResource, re.newResource, { overwrite: true })))), options);
-                }
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    static getStatsFromDragAndDropData(data, dragStartEvent) {
-        if (data.context) {
-            return data.context;
-        }
-        if (dragStartEvent && data.elements.length === 1) {
-            data.context = [FileDragAndDrop.getCompressedStatFromDragEvent(data.elements[0], dragStartEvent)];
-            return data.context;
-        }
-        return data.elements;
-    }
-    static getCompressedStatFromDragEvent(stat, dragEvent) {
-        const target = document.elementFromPoint(dragEvent.clientX, dragEvent.clientY);
-        const iconLabelName = getIconLabelNameFromHTMLElement(target);
-        if (iconLabelName) {
-            const { count, index } = iconLabelName;
-            let i = count - 1;
-            while (i > index && stat.parent) {
-                stat = stat.parent;
-                i--;
-            }
-            return stat;
-        }
-        return stat;
-    }
-    onDragEnd() {
-        this.compressedDropTargetDisposable.dispose();
-    }
-};
-FileDragAndDrop.CONFIRM_DND_SETTING_KEY = 'explorer.confirmDragAndDrop';
-FileDragAndDrop = ( __decorate([
-    ( __param(1, IExplorerService)),
-    ( __param(2, IEditorService)),
-    ( __param(3, IDialogService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IWorkspaceEditingService)),
-    ( __param(9, IUriIdentityService))
-], FileDragAndDrop));
-function getIconLabelNameFromHTMLElement(target) {
-    if (!(target instanceof HTMLElement)) {
-        return null;
-    }
-    let element = target;
-    while (element && !element.classList.contains('monaco-list-row')) {
-        if (element.classList.contains('label-name') && element.hasAttribute('data-icon-label-count')) {
-            const count = Number(element.getAttribute('data-icon-label-count'));
-            const index = Number(element.getAttribute('data-icon-label-index'));
-            if (isNumber(count) && isNumber(index)) {
-                return { element: element, count, index };
-            }
-        }
-        element = element.parentElement;
-    }
-    return null;
-}
-function isCompressedFolderName(target) {
-    return !!getIconLabelNameFromHTMLElement(target);
-}
-class ExplorerCompressionDelegate {
-    isIncompressible(stat) {
-        return stat.isRoot || !stat.isDirectory || stat instanceof NewExplorerItem || (!stat.parent || stat.parent.isRoot);
-    }
-}
-function getFileOrFolderLabelSufix(items) {
-    if (items.length === 1) {
-        return items[0].name;
-    }
-    if (items.every(i => i.isDirectory)) {
-        return ( localize('numberOfFolders', "{0} folders", items.length));
-    }
-    if (items.every(i => !i.isDirectory)) {
-        return ( localize('numberOfFiles', "{0} files", items.length));
-    }
-    return `${items.length} files and folders`;
-}
-export { CompressedNavigationController, ExplorerCompressionDelegate, ExplorerDataSource, ExplorerDelegate, FileDragAndDrop, FileSorter, FilesFilter, FilesRenderer, explorerRootErrorEmitter, isCompressedFolderName };