@codingame/monaco-vscode-api 23.2.2 → 24.1.0

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

@@ -0,0 +1,1728 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { addDisposableListener, addStandardDisposableListener, EventType, getActiveElement, isActiveElement, isHTMLElement, hasParentWithClass, getWindow } from '../../../../../base/browser/dom.js';
+import { match, parse } from '../../../../../base/common/glob.js';
+import { ListDragOverEffectType, ListDragOverEffectPosition } from '../../../../../base/browser/ui/list/list.js';
+import { ProgressLocation } from '../../../../../platform/progress/common/progress.js';
+import { IProgressService } from '../../../../../platform/progress/common/progress.service.js';
+import '../../../../../platform/notification/common/notification.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { FileKind, FileChangeType, FileOperationResult } from '../../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../../platform/files/common/files.service.js';
+import { IWorkbenchLayoutService } from '../../../../services/layout/browser/layoutService.service.js';
+import { WorkbenchState, isTemporaryWorkspace } from '../../../../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.service.js';
+import { DisposableStore, toDisposable, dispose, Disposable } from '../../../../../base/common/lifecycle.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
+import { TreeVisibility, TreeDragOverBubble } from '../../../../../base/browser/ui/tree/tree.js';
+import { IContextViewService, IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { ExplorerFindProviderActive, UndoConfirmLevel } from '../../common/files.js';
+import { relativePath, dirname, joinPath, distinctParents } from '../../../../../base/common/resources.js';
+import { InputBox, MessageType } from '../../../../../base/browser/ui/inputbox/inputBox.js';
+import { localize } from '../../../../../nls.js';
+import { createSingleCallFunction } from '../../../../../base/common/functional.js';
+import { equals, deepClone } from '../../../../../base/common/objects.js';
+import { relative } from '../../../../../base/common/path.js';
+import { ExplorerItem, NewExplorerItem } from '../../common/explorerModel.js';
+import { compareFileNamesDefault, compareFileExtensionsDefault, compareFileNamesUnicode, compareFileExtensionsUnicode, compareFileNamesLower, compareFileExtensionsLower, compareFileNamesUpper, compareFileExtensionsUpper } from '../../../../../base/common/comparers.js';
+import { containsDragType, CodeDataTransfers } from '../../../../../platform/dnd/browser/dnd.js';
+import { fillEditorsDragData } from '../../../../browser/dnd.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { DataTransfers } from '../../../../../base/browser/dnd.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { NativeDragAndDropData, ExternalElementsDragAndDropData, ListViewTargetSector } from '../../../../../base/browser/ui/list/listView.js';
+import { isMacintosh, isWeb } from '../../../../../base/common/platform.js';
+import { getFileNamesMessage } from '../../../../../platform/dialogs/common/dialogs.js';
+import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
+import { IWorkspaceEditingService } from '../../../../services/workspaces/common/workspaceEditing.service.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
+import { findValidPasteFileTarget } from '../fileActions.js';
+import { createMatches } from '../../../../../base/common/filters.js';
+import { Emitter, EventMultiplexer, Event } from '../../../../../base/common/event.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { isNumber } from '../../../../../base/common/types.js';
+import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.service.js';
+import { ResourceFileEdit } from '../../../../../editor/browser/services/bulkEditService.js';
+import { IExplorerService } from '../files.service.js';
+import { ExternalFileImport, BrowserFileUpload, getMultipleFilesOverwriteConfirm } from '../fileImportExport.js';
+import { toErrorMessage } from '../../../../../base/common/errorMessage.js';
+import { WebFileSystemAccess } from '../../../../../platform/files/browser/webFileSystemAccess.js';
+import { IgnoreFile } from '../../../../services/search/common/ignoreFile.js';
+import { ResourceSet } from '../../../../../base/common/map.js';
+import { TernarySearchTree } from '../../../../../base/common/ternarySearchTree.js';
+import { defaultCountBadgeStyles, defaultInputBoxStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { timeout } from '../../../../../base/common/async.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.service.js';
+import { mainWindow } from '../../../../../base/browser/window.js';
+import { explorerFileContribRegistry } from '../explorerFileContrib.js';
+import { getExcludes, QueryType } from '../../../../services/search/common/search.js';
+import { ISearchService } from '../../../../services/search/common/search.service.js';
+import { TreeFindMode, TreeFindMatchType } from '../../../../../base/browser/ui/tree/abstractTree.js';
+import { isCancellationError } from '../../../../../base/common/errors.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
+import { CountBadge } from '../../../../../base/browser/ui/countBadge/countBadge.js';
+import { asCssVariable } from '../../../../../platform/theme/common/colorUtils.js';
+import '../../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../../platform/theme/common/colors/inputColors.js';
+import { listFilterMatchHighlightBorder, listFilterMatchHighlight } from '../../../../../platform/theme/common/colors/listColors.js';
+import '../../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../../platform/theme/common/colors/searchColors.js';
+import Severity$1 from '../../../../../base/common/severity.js';
+
+var FilesRenderer_1, FileDragAndDrop_1;
+class ExplorerDelegate {
+    static { this.ITEM_HEIGHT = 22; }
+    getHeight(element) {
+        return ExplorerDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return FilesRenderer.ID;
+    }
+}
+const explorerRootErrorEmitter = ( new Emitter());
+let ExplorerDataSource = class ExplorerDataSource {
+    constructor(fileFilter, findProvider, progressService, configService, notificationService, layoutService, fileService, explorerService, contextService, filesConfigService) {
+        this.fileFilter = fileFilter;
+        this.findProvider = findProvider;
+        this.progressService = progressService;
+        this.configService = configService;
+        this.notificationService = notificationService;
+        this.layoutService = layoutService;
+        this.fileService = fileService;
+        this.explorerService = explorerService;
+        this.contextService = contextService;
+        this.filesConfigService = filesConfigService;
+    }
+    getParent(element) {
+        if (element.parent) {
+            return element.parent;
+        }
+        throw ( new Error('getParent only supported for cached parents'));
+    }
+    hasChildren(element) {
+        return Array.isArray(element) || element.hasChildren((stat) => this.fileFilter.filter(stat, TreeVisibility.Visible));
+    }
+    getChildren(element) {
+        if (Array.isArray(element)) {
+            return element;
+        }
+        if (this.findProvider.isShowingFilterResults()) {
+            return Array.from(( element.children.values()));
+        }
+        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() !== WorkbenchState.FOLDER) {
+                explorerRootErrorEmitter.fire(element.resource);
+            }
+            return children;
+        }, e => {
+            if (element instanceof ExplorerItem && element.isRoot) {
+                if (this.contextService.getWorkbenchState() === WorkbenchState.FOLDER) {
+                    const placeholder = ( new ExplorerItem(
+                        element.resource,
+                        this.fileService,
+                        this.configService,
+                        this.filesConfigService,
+                        undefined,
+                        undefined,
+                        false
+                    ));
+                    placeholder.error = e;
+                    return [placeholder];
+                }
+                else {
+                    explorerRootErrorEmitter.fire(element.resource);
+                }
+            }
+            else {
+                this.notificationService.error(e);
+            }
+            return [];
+        });
+        this.progressService.withProgress({
+            location: ProgressLocation.Explorer,
+            delay: this.layoutService.isRestored() ? 800 : 1500
+        }, _progress => promise);
+        return promise;
+    }
+};
+ExplorerDataSource = ( __decorate([
+    ( __param(2, IProgressService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IWorkbenchLayoutService)),
+    ( __param(6, IFileService)),
+    ( __param(7, IExplorerService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, IFilesConfigurationService))
+], ExplorerDataSource));
+class PhantomExplorerItem extends ExplorerItem {
+}
+class ExplorerFindHighlightTree {
+    constructor() {
+        this._tree = ( new Map());
+        this._highlightedItems = ( new Map());
+    }
+    get highlightedItems() {
+        return Array.from(( this._highlightedItems.values()));
+    }
+    get(item) {
+        const result = this.find(item);
+        if (result === undefined) {
+            return 0;
+        }
+        const { treeLayer, relPath } = result;
+        this._highlightedItems.set(relPath, item);
+        return treeLayer.childMatches;
+    }
+    find(item) {
+        const rootLayer = this._tree.get(item.root.name);
+        if (rootLayer === undefined) {
+            return undefined;
+        }
+        const relPath = relativePath(item.root.resource, item.resource);
+        if (relPath === undefined || relPath.startsWith('..')) {
+            throw ( new Error('Resource is not a child of the root'));
+        }
+        if (relPath === '') {
+            return { treeLayer: rootLayer, relPath };
+        }
+        let treeLayer = rootLayer;
+        for (const segment of relPath.split('/')) {
+            if (!treeLayer.stats[segment]) {
+                return undefined;
+            }
+            treeLayer = treeLayer.stats[segment];
+        }
+        return { treeLayer, relPath };
+    }
+    add(resource, root) {
+        const relPath = relativePath(root.resource, resource);
+        if (relPath === undefined || relPath.startsWith('..')) {
+            throw ( new Error('Resource is not a child of the root'));
+        }
+        let rootLayer = this._tree.get(root.name);
+        if (!rootLayer) {
+            rootLayer = { childMatches: 0, stats: {}, isMatch: false };
+            this._tree.set(root.name, rootLayer);
+        }
+        rootLayer.childMatches++;
+        let treeLayer = rootLayer;
+        for (const stat of relPath.split('/')) {
+            if (!treeLayer.stats[stat]) {
+                treeLayer.stats[stat] = { childMatches: 0, stats: {}, isMatch: false };
+            }
+            treeLayer = treeLayer.stats[stat];
+            treeLayer.childMatches++;
+        }
+        treeLayer.childMatches--;
+        treeLayer.isMatch = true;
+    }
+    isMatch(item) {
+        const result = this.find(item);
+        if (result === undefined) {
+            return false;
+        }
+        const { treeLayer } = result;
+        return treeLayer.isMatch;
+    }
+    clear() {
+        this._tree.clear();
+    }
+}
+let ExplorerFindProvider = class ExplorerFindProvider {
+    get highlightTree() {
+        return this.findHighlightTree;
+    }
+    constructor(filesFilter, treeProvider, searchService, fileService, configurationService, filesConfigService, progressService, explorerService, contextKeyService) {
+        this.filesFilter = filesFilter;
+        this.treeProvider = treeProvider;
+        this.searchService = searchService;
+        this.fileService = fileService;
+        this.configurationService = configurationService;
+        this.filesConfigService = filesConfigService;
+        this.progressService = progressService;
+        this.explorerService = explorerService;
+        this.sessionId = 0;
+        this.phantomParents = ( new Set());
+        this.findHighlightTree = ( new ExplorerFindHighlightTree());
+        this.explorerFindActiveContextKey = ExplorerFindProviderActive.bindTo(contextKeyService);
+    }
+    isShowingFilterResults() {
+        return !!this.filterSessionStartState;
+    }
+    isVisible(element) {
+        if (!this.filterSessionStartState) {
+            return true;
+        }
+        if (this.explorerService.isEditable(element)) {
+            return true;
+        }
+        return ( this.filterSessionStartState.rootsWithProviders.has(element.root)) ? element.isMarkedAsFiltered() : true;
+    }
+    startSession() {
+        this.sessionId++;
+    }
+    async endSession() {
+        if (this.filterSessionStartState) {
+            await this.endFilterSession();
+        }
+        if (this.highlightSessionStartState) {
+            this.endHighlightSession();
+        }
+    }
+    async find(pattern, toggles, token) {
+        const promise = this.doFind(pattern, toggles, token);
+        return await this.progressService.withProgress({
+            location: ProgressLocation.Explorer,
+            delay: 750,
+        }, _progress => promise);
+    }
+    async doFind(pattern, toggles, token) {
+        if (toggles.findMode === TreeFindMode.Highlight) {
+            if (this.filterSessionStartState) {
+                await this.endFilterSession();
+            }
+            if (!this.highlightSessionStartState) {
+                this.startHighlightSession();
+            }
+            return await this.doHighlightFind(pattern, toggles.matchType, token);
+        }
+        if (this.highlightSessionStartState) {
+            this.endHighlightSession();
+        }
+        if (!this.filterSessionStartState) {
+            this.startFilterSession();
+        }
+        return await this.doFilterFind(pattern, toggles.matchType, token);
+    }
+    startFilterSession() {
+        const tree = this.treeProvider();
+        const input = tree.getInput();
+        if (!input) {
+            return;
+        }
+        const roots = this.explorerService.roots.filter(root => this.searchSupportsScheme(root.resource.scheme));
+        this.filterSessionStartState = { viewState: tree.getViewState(), input, rootsWithProviders: ( new Set(roots)) };
+        this.explorerFindActiveContextKey.set(true);
+    }
+    async doFilterFind(pattern, matchType, token) {
+        if (!this.filterSessionStartState) {
+            throw ( new Error('ExplorerFindProvider: no session state'));
+        }
+        const roots = Array.from(this.filterSessionStartState.rootsWithProviders);
+        const searchResults = await this.getSearchResults(pattern, roots, matchType, token);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        this.clearPhantomElements();
+        for (const { explorerRoot, files, directories } of searchResults) {
+            this.addWorkspaceFilterResults(explorerRoot, files, directories);
+        }
+        const tree = this.treeProvider();
+        await tree.setInput(this.filterSessionStartState.input);
+        const hitMaxResults = ( searchResults.some(({ hitMaxResults }) => hitMaxResults));
+        return {
+            isMatch: (item) => item.isMarkedAsFiltered(),
+            matchCount: searchResults.reduce((acc, { files, directories }) => acc + files.length + directories.length, 0),
+            warningMessage: hitMaxResults ? ( localize(
+                8201,
+                "The result set only contains a subset of all matches. Be more specific in your search to narrow down the results."
+            )) : undefined
+        };
+    }
+    addWorkspaceFilterResults(root, files, directories) {
+        const results = [
+            ...( files.map(file => ({ resource: file, isDirectory: false }))),
+            ...( directories.map(directory => ({ resource: directory, isDirectory: true })))
+        ];
+        for (const { resource, isDirectory } of results) {
+            const element = root.find(resource);
+            if (element && element.root === root) {
+                element.markItemAndParentsAsFiltered();
+                continue;
+            }
+            const phantomElements = this.createPhantomItems(resource, root, isDirectory);
+            if (phantomElements.length === 0) {
+                throw ( new Error('Phantom item was not created even though it is not in the model'));
+            }
+            const firstPhantomParent = phantomElements[0].parent;
+            if (!(firstPhantomParent instanceof PhantomExplorerItem)) {
+                this.phantomParents.add(firstPhantomParent);
+            }
+            const phantomFileElement = phantomElements[phantomElements.length - 1];
+            phantomFileElement.markItemAndParentsAsFiltered();
+        }
+    }
+    createPhantomItems(resource, root, resourceIsDirectory) {
+        const relativePathToRoot = relativePath(root.resource, resource);
+        if (!relativePathToRoot) {
+            throw ( new Error('Resource is not a child of the root'));
+        }
+        const phantomElements = [];
+        let currentItem = root;
+        let currentResource = root.resource;
+        const pathSegments = relativePathToRoot.split('/');
+        for (const stat of pathSegments) {
+            currentResource = currentResource.with({ path: `${currentResource.path}/${stat}` });
+            let child = currentItem.getChild(stat);
+            if (!child) {
+                const isDirectory = pathSegments[pathSegments.length - 1] === stat ? resourceIsDirectory : true;
+                child = ( new PhantomExplorerItem(
+                    currentResource,
+                    this.fileService,
+                    this.configurationService,
+                    this.filesConfigService,
+                    currentItem,
+                    isDirectory
+                ));
+                currentItem.addChild(child);
+                phantomElements.push(child);
+            }
+            currentItem = child;
+        }
+        return phantomElements;
+    }
+    async endFilterSession() {
+        this.clearPhantomElements();
+        this.explorerFindActiveContextKey.set(false);
+        if (!this.filterSessionStartState) {
+            throw ( new Error('ExplorerFindProvider: no session state to restore'));
+        }
+        const tree = this.treeProvider();
+        await tree.setInput(this.filterSessionStartState.input, this.filterSessionStartState.viewState);
+        this.filterSessionStartState = undefined;
+        this.explorerService.refresh();
+    }
+    clearPhantomElements() {
+        for (const phantomParent of this.phantomParents) {
+            phantomParent.forgetChildren();
+        }
+        this.phantomParents.clear();
+        this.explorerService.roots.forEach(root => root.unmarkItemAndChildren());
+    }
+    startHighlightSession() {
+        const roots = this.explorerService.roots.filter(root => this.searchSupportsScheme(root.resource.scheme));
+        this.highlightSessionStartState = { rootsWithProviders: ( new Set(roots)) };
+    }
+    async doHighlightFind(pattern, matchType, token) {
+        if (!this.highlightSessionStartState) {
+            throw ( new Error('ExplorerFindProvider: no highlight session state'));
+        }
+        const roots = Array.from(this.highlightSessionStartState.rootsWithProviders);
+        const searchResults = await this.getSearchResults(pattern, roots, matchType, token);
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        this.clearHighlights();
+        for (const { explorerRoot, files, directories } of searchResults) {
+            this.addWorkspaceHighlightResults(explorerRoot, files.concat(directories));
+        }
+        const hitMaxResults = ( searchResults.some(({ hitMaxResults }) => hitMaxResults));
+        return {
+            isMatch: (item) => this.findHighlightTree.isMatch(item) || (this.findHighlightTree.get(item) > 0 && this.treeProvider().isCollapsed(item)),
+            matchCount: searchResults.reduce((acc, { files, directories }) => acc + files.length + directories.length, 0),
+            warningMessage: hitMaxResults ? ( localize(
+                8201,
+                "The result set only contains a subset of all matches. Be more specific in your search to narrow down the results."
+            )) : undefined
+        };
+    }
+    addWorkspaceHighlightResults(root, resources) {
+        const highlightedDirectories = ( new Set());
+        const storeDirectories = (item) => {
+            while (item) {
+                highlightedDirectories.add(item);
+                item = item.parent;
+            }
+        };
+        for (const resource of resources) {
+            const element = root.find(resource);
+            if (element && element.root === root) {
+                this.findHighlightTree.add(resource, root);
+                storeDirectories(element.parent);
+                continue;
+            }
+            const firstParent = findFirstParent(resource, root);
+            if (firstParent) {
+                this.findHighlightTree.add(resource, root);
+                storeDirectories(firstParent.parent);
+            }
+        }
+        const tree = this.treeProvider();
+        for (const directory of highlightedDirectories) {
+            if (tree.hasNode(directory)) {
+                tree.rerender(directory);
+            }
+        }
+    }
+    endHighlightSession() {
+        this.highlightSessionStartState = undefined;
+        this.clearHighlights();
+    }
+    clearHighlights() {
+        const tree = this.treeProvider();
+        for (const item of this.findHighlightTree.highlightedItems) {
+            if (tree.hasNode(item)) {
+                tree.rerender(item);
+            }
+        }
+        this.findHighlightTree.clear();
+    }
+    searchSupportsScheme(scheme) {
+        if (scheme !== Schemas.file && scheme !== Schemas.vscodeRemote) {
+            return false;
+        }
+        return this.searchService.schemeHasFileSearchProvider(scheme);
+    }
+    async getSearchResults(pattern, roots, matchType, token) {
+        const patternLowercase = pattern.toLowerCase();
+        const isFuzzyMatch = matchType === TreeFindMatchType.Fuzzy;
+        return await Promise.all(( roots.map(
+            (root, index) => this.searchInWorkspace(patternLowercase, root, index, isFuzzyMatch, token)
+        )));
+    }
+    async searchInWorkspace(patternLowercase, root, rootIndex, isFuzzyMatch, token) {
+        const segmentMatchPattern = caseInsensitiveGlobPattern(isFuzzyMatch ? fuzzyMatchingGlobPattern(patternLowercase) : continousMatchingGlobPattern(patternLowercase));
+        const searchExcludePattern = getExcludes(this.configurationService.getValue({ resource: root.resource })) || {};
+        const searchOptions = {
+            folderQueries: [{
+                    folder: root.resource,
+                    disregardIgnoreFiles: !this.configurationService.getValue('explorer.excludeGitIgnore'),
+                }],
+            type: QueryType.File,
+            shouldGlobMatchFilePattern: true,
+            cacheKey: `explorerfindprovider:${root.name}:${rootIndex}:${this.sessionId}`,
+            excludePattern: searchExcludePattern,
+        };
+        let fileResults;
+        let folderResults;
+        try {
+            [fileResults, folderResults] = await Promise.all([
+                this.searchService.fileSearch({ ...searchOptions, filePattern: `**/${segmentMatchPattern}`, maxResults: 512 }, token),
+                this.searchService.fileSearch({ ...searchOptions, filePattern: `**/${segmentMatchPattern}/**` }, token)
+            ]);
+        }
+        catch (e) {
+            if (!isCancellationError(e)) {
+                throw e;
+            }
+        }
+        if (!fileResults || !folderResults || token.isCancellationRequested) {
+            return { explorerRoot: root, files: [], directories: [], hitMaxResults: false };
+        }
+        const fileResultResources = ( fileResults.results.map(result => result.resource));
+        const directoryResources = getMatchingDirectoriesFromFiles(( folderResults.results.map(result => result.resource)), root, segmentMatchPattern);
+        const filteredFileResources = fileResultResources.filter(resource => !this.filesFilter.isIgnored(resource, root.resource, false));
+        const filteredDirectoryResources = directoryResources.filter(resource => !this.filesFilter.isIgnored(resource, root.resource, true));
+        return { explorerRoot: root, files: filteredFileResources, directories: filteredDirectoryResources, hitMaxResults: !!fileResults.limitHit || !!folderResults.limitHit };
+    }
+};
+ExplorerFindProvider = ( __decorate([
+    ( __param(2, ISearchService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IFilesConfigurationService)),
+    ( __param(6, IProgressService)),
+    ( __param(7, IExplorerService)),
+    ( __param(8, IContextKeyService))
+], ExplorerFindProvider));
+function getMatchingDirectoriesFromFiles(resources, root, segmentMatchPattern) {
+    const uniqueDirectories = ( new ResourceSet());
+    for (const resource of resources) {
+        const relativePathToRoot = relativePath(root.resource, resource);
+        if (!relativePathToRoot) {
+            throw ( new Error('Resource is not a child of the root'));
+        }
+        let dirResource = root.resource;
+        const stats = relativePathToRoot.split('/').slice(0, -1);
+        for (const stat of stats) {
+            dirResource = dirResource.with({ path: `${dirResource.path}/${stat}` });
+            uniqueDirectories.add(dirResource);
+        }
+    }
+    const matchingDirectories = [];
+    for (const dirResource of uniqueDirectories) {
+        const stats = dirResource.path.split('/');
+        const dirStat = stats[stats.length - 1];
+        if (!dirStat || !match(segmentMatchPattern, dirStat)) {
+            continue;
+        }
+        matchingDirectories.push(dirResource);
+    }
+    return matchingDirectories;
+}
+function findFirstParent(resource, root) {
+    const relativePathToRoot = relativePath(root.resource, resource);
+    if (!relativePathToRoot) {
+        throw ( new Error('Resource is not a child of the root'));
+    }
+    let currentItem = root;
+    let currentResource = root.resource;
+    const pathSegments = relativePathToRoot.split('/');
+    for (const stat of pathSegments) {
+        currentResource = currentResource.with({ path: `${currentResource.path}/${stat}` });
+        const child = currentItem.getChild(stat);
+        if (!child) {
+            return currentItem;
+        }
+        currentItem = child;
+    }
+    return undefined;
+}
+function fuzzyMatchingGlobPattern(pattern) {
+    if (!pattern) {
+        return '*';
+    }
+    return '*' + pattern.split('').join('*') + '*';
+}
+function continousMatchingGlobPattern(pattern) {
+    if (!pattern) {
+        return '*';
+    }
+    return '*' + pattern + '*';
+}
+function caseInsensitiveGlobPattern(pattern) {
+    let caseInsensitiveFilePattern = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (/[a-zA-Z]/.test(char)) {
+            caseInsensitiveFilePattern += `[${char.toLowerCase()}${char.toUpperCase()}]`;
+        }
+        else {
+            caseInsensitiveFilePattern += char;
+        }
+    }
+    return caseInsensitiveFilePattern;
+}
+class CompressedNavigationController {
+    static { this.ID = 0; }
+    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();
+    }
+}
+let FilesRenderer = class FilesRenderer {
+    static { FilesRenderer_1 = this; }
+    static { this.ID = 'file'; }
+    constructor(container, labels, highlightTree, updateWidth, contextViewService, themeService, configurationService, explorerService, labelService, contextService, contextMenuService, instantiationService) {
+        this.labels = labels;
+        this.highlightTree = highlightTree;
+        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.instantiationService = instantiationService;
+        this.compressedNavigationControllers = ( new Map());
+        this._onDidChangeActiveDescendant = ( new EventMultiplexer());
+        this.onDidChangeActiveDescendant = this._onDidChangeActiveDescendant.event;
+        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(8202, "Files Explorer");
+    }
+    get templateId() {
+        return FilesRenderer_1.ID;
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        const label = templateDisposables.add(this.labels.create(container, { supportHighlights: true }));
+        templateDisposables.add(label.onDidRender(() => {
+            try {
+                if (templateData.currentContext) {
+                    this.updateWidth(templateData.currentContext);
+                }
+            }
+            catch (e) {
+            }
+        }));
+        const contribs = explorerFileContribRegistry.create(this.instantiationService, container, templateDisposables);
+        templateDisposables.add(explorerFileContribRegistry.onDidRegisterDescriptor(d => {
+            const contr = d.create(this.instantiationService, container);
+            contribs.push(templateDisposables.add(contr));
+            contr.setResource(templateData.currentContext?.resource);
+        }));
+        const templateData = { templateDisposables, elementDisposables: templateDisposables.add(( new DisposableStore())), label, container, contribs };
+        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.contribs.forEach(c => c.setResource(undefined));
+            templateData.elementDisposables.add(this.renderInputBox(templateData.container, stat, editableData));
+        }
+    }
+    renderCompressedElements(node, index, templateData) {
+        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 labels = ( node.element.elements.map(e => e.name));
+            let fuzzyScore = node.filterData;
+            if (fuzzyScore && fuzzyScore.length > 2) {
+                const filterDataOffset = labels.join('/').length - labels[labels.length - 1].length;
+                fuzzyScore = [fuzzyScore[0], fuzzyScore[1] + filterDataOffset, ...fuzzyScore.slice(2)];
+            }
+            this.renderStat(stat, labels, id, fuzzyScore, templateData);
+            const compressedNavigationController = ( new CompressedNavigationController(id, node.element.elements, templateData, node.depth, node.collapsed));
+            templateData.elementDisposables.add(compressedNavigationController);
+            const nodeControllers = this.compressedNavigationControllers.get(stat) ?? [];
+            this.compressedNavigationControllers.set(stat, [...nodeControllers, compressedNavigationController]);
+            templateData.elementDisposables.add(this._onDidChangeActiveDescendant.add(compressedNavigationController.onDidChange));
+            templateData.elementDisposables.add(addDisposableListener(templateData.container, 'mousedown', e => {
+                const result = getIconLabelNameFromHTMLElement(e.target);
+                if (result) {
+                    compressedNavigationController.setIndex(result.index);
+                }
+            }));
+            templateData.elementDisposables.add(toDisposable(() => {
+                const nodeControllers = this.compressedNavigationControllers.get(stat) ?? [];
+                const renderedIndex = nodeControllers.findIndex(controller => controller === compressedNavigationController);
+                if (renderedIndex < 0) {
+                    throw ( new Error('Disposing unknown navigation controller'));
+                }
+                if (nodeControllers.length === 1) {
+                    this.compressedNavigationControllers.delete(stat);
+                }
+                else {
+                    nodeControllers.splice(renderedIndex, 1);
+                }
+            }));
+        }
+        else {
+            templateData.label.element.classList.remove('compressed');
+            templateData.label.element.style.display = 'none';
+            templateData.contribs.forEach(c => c.setResource(undefined));
+            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;
+        templateData.contribs.forEach(c => c.setResource(stat.resource));
+        templateData.label.setResource({ resource: stat.resource, name: label }, {
+            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
+        });
+        const highlightResults = stat.isDirectory ? this.highlightTree.get(stat) : 0;
+        if (highlightResults > 0) {
+            const badge = ( new CountBadge(
+                templateData.label.element.lastElementChild,
+                {},
+                { ...defaultCountBadgeStyles, badgeBackground: asCssVariable(listFilterMatchHighlight), badgeBorder: asCssVariable(listFilterMatchHighlightBorder) }
+            ));
+            badge.setCount(highlightResults);
+            badge.setTitleFormat(( localize(8203, "Directory contains {0} matches", highlightResults)));
+            templateData.elementDisposables.add(badge);
+        }
+        templateData.label.element.classList.toggle('highlight-badge', highlightResults > 0);
+    }
+    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$1.Error) {
+                        return null;
+                    }
+                    return {
+                        content: message.content,
+                        formatContent: true,
+                        type: MessageType.ERROR
+                    };
+                }
+            },
+            ariaLabel: ( localize(8204, "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 = createSingleCallFunction((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$1.Info ? MessageType.INFO : message.severity === Severity$1.Warning ? MessageType.WARNING : MessageType.ERROR
+                    });
+                }
+                else {
+                    inputBox.hideMessage();
+                }
+            }
+        };
+        showInputBoxNotification();
+        const toDispose = [
+            inputBox,
+            inputBox.onDidChange(value => {
+                label.setFile(joinPath(parent, value || ' '), labelOptions);
+            }),
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_DOWN, (e) => {
+                if (e.equals(KeyCode.F2)) {
+                    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(KeyCode.Enter)) {
+                    if (!inputBox.validate()) {
+                        done(true, true);
+                    }
+                }
+                else if (e.equals(KeyCode.Escape)) {
+                    done(false, true);
+                }
+            }),
+            addStandardDisposableListener(inputBox.inputElement, EventType.KEY_UP, (e) => {
+                showInputBoxNotification();
+            }),
+            addDisposableListener(inputBox.inputElement, EventType.BLUR, async () => {
+                while (true) {
+                    await timeout(0);
+                    const ownerDocument = inputBox.inputElement.ownerDocument;
+                    const activeElement = getActiveElement(ownerDocument);
+                    if (!ownerDocument.hasFocus()) {
+                        break;
+                    }
+                    if (isActiveElement(inputBox.inputElement)) {
+                        return;
+                    }
+                    else if (isHTMLElement(activeElement) && hasParentWithClass(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() === WorkbenchState.WORKSPACE) {
+            depth = depth + 1;
+        }
+        return depth;
+    }
+    getActiveDescendantId(stat) {
+        return this.compressedNavigationControllers.get(stat)?.[0]?.currentId ?? undefined;
+    }
+    dispose() {
+        this.configListener.dispose();
+    }
+};
+FilesRenderer = FilesRenderer_1 = ( __decorate([
+    ( __param(4, IContextViewService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IExplorerService)),
+    ( __param(8, ILabelService)),
+    ( __param(9, IWorkspaceContextService)),
+    ( __param(10, IContextMenuService)),
+    ( __param(11, IInstantiationService))
+], 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, FileChangeType.UPDATED)) {
+                        await this.processIgnoreFile(root, ignoreResource, true);
+                    }
+                    if (e.contains(ignoreResource, FileChangeType.DELETED)) {
+                        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?.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: 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 === TreeVisibility.Hidden) {
+            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(relative(stat.root.resource.path, stat.resource.path), stat.name, name => !!(stat.parent?.getChild(name)));
+        const isHiddenResource = globMatch ? true : this.isIgnored(stat.resource, stat.root.resource, stat.isDirectory);
+        if (isHiddenResource || 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;
+    }
+    isIgnored(resource, rootResource, isDirectory) {
+        const ignoreFile = this.ignoreTreesPerRoot.get(( rootResource.toString()))?.findSubstr(resource);
+        const isIncludedInTraversal = ignoreFile?.isPathIncludedInTraversal(resource.path, isDirectory);
+        return isIncludedInTraversal === undefined ? false : !isIncludedInTraversal;
+    }
+    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;
+        const reverse = this.explorerService.sortOrderConfiguration.reverse;
+        if (reverse) {
+            [statA, statB] = [statB, statA];
+        }
+        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 {
+    static { FileDragAndDrop_1 = this; }
+    static { this.CONFIRM_DND_SETTING_KEY = 'explorer.confirmDragAndDrop'; }
+    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.disposables = ( new DisposableStore());
+        this.dropEnabled = false;
+        const updateDropEnablement = (e) => {
+            if (!e || e.affectsConfiguration('explorer.enableDragAndDrop')) {
+                this.dropEnabled = this.configurationService.getValue('explorer.enableDragAndDrop');
+            }
+        };
+        updateDropEnablement(undefined);
+        this.disposables.add(this.configurationService.onDidChangeConfiguration(e => updateDropEnablement(e)));
+    }
+    onDragOver(data, target, targetIndex, targetSector, originalEvent) {
+        if (!this.dropEnabled) {
+            return false;
+        }
+        if (target) {
+            const compressedTarget = FileDragAndDrop_1.getCompressedStatFromDragEvent(target, originalEvent);
+            if (compressedTarget) {
+                const iconLabelName = getIconLabelNameFromHTMLElement(originalEvent.target);
+                if (iconLabelName && iconLabelName.index < iconLabelName.count - 1) {
+                    const result = this.handleDragOver(data, compressedTarget, targetIndex, targetSector, 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, targetSector, originalEvent);
+    }
+    handleDragOver(data, target, targetIndex, targetSector, originalEvent) {
+        const isCopy = originalEvent && ((originalEvent.ctrlKey && !isMacintosh) || (originalEvent.altKey && isMacintosh));
+        const isNative = data instanceof NativeDragAndDropData;
+        const effectType = (isNative || isCopy) ? ListDragOverEffectType.Copy : ListDragOverEffectType.Move;
+        const effect = { type: effectType, position: ListDragOverEffectPosition.Over };
+        if (isNative) {
+            if (!containsDragType(originalEvent, DataTransfers.FILES, CodeDataTransfers.FILES, DataTransfers.RESOURCES)) {
+                return false;
+            }
+        }
+        else if (data instanceof ExternalElementsDragAndDropData) {
+            return false;
+        }
+        else {
+            const items = FileDragAndDrop_1.getStatsFromDragAndDropData(data);
+            const isRootsReorder = items.every(item => item.isRoot);
+            if (!target) {
+                if (!isCopy && items.every(i => !!i.parent && i.parent.isRoot)) {
+                    return false;
+                }
+                if (isRootsReorder) {
+                    return { accept: true, effect: { type: ListDragOverEffectType.Move, position: ListDragOverEffectPosition.After } };
+                }
+                return { accept: true, bubble: TreeDragOverBubble.Down, effect, autoExpand: false };
+            }
+            if (!Array.isArray(items)) {
+                return false;
+            }
+            if (!isCopy && items.every((source) => source.isReadonly)) {
+                return false;
+            }
+            if (( items.some((source) => {
+                if (source.isRoot) {
+                    return false;
+                }
+                if (this.uriIdentityService.extUri.isEqual(source.resource, target.resource)) {
+                    return true;
+                }
+                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 (isRootsReorder) {
+                if (!target.isRoot) {
+                    return false;
+                }
+                let dropEffectPosition = undefined;
+                switch (targetSector) {
+                    case ListViewTargetSector.TOP:
+                    case ListViewTargetSector.CENTER_TOP:
+                        dropEffectPosition = ListDragOverEffectPosition.Before;
+                        break;
+                    case ListViewTargetSector.CENTER_BOTTOM:
+                    case ListViewTargetSector.BOTTOM:
+                        dropEffectPosition = ListDragOverEffectPosition.After;
+                        break;
+                }
+                return { accept: true, effect: { type: ListDragOverEffectType.Move, position: dropEffectPosition } };
+            }
+        }
+        if (!target) {
+            return { accept: true, bubble: TreeDragOverBubble.Down, effect };
+        }
+        else {
+            if (target.isDirectory) {
+                if (target.isReadonly) {
+                    return false;
+                }
+                return { accept: true, bubble: TreeDragOverBubble.Down, effect, autoExpand: true };
+            }
+            if (this.contextService.getWorkspace().folders.every(folder => ( folder.uri.toString()) !== ( target.resource.toString()))) {
+                return { accept: true, bubble: TreeDragOverBubble.Up, 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_1.getCompressedStatFromDragEvent(elements[0], originalEvent);
+            return stat.name;
+        }
+        return String(elements.length);
+    }
+    onDragStart(data, originalEvent) {
+        const items = FileDragAndDrop_1.getStatsFromDragAndDropData(data, originalEvent);
+        if (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, targetSector, originalEvent) {
+        this.compressedDropTargetDisposable.dispose();
+        if (target) {
+            const compressedTarget = FileDragAndDrop_1.getCompressedStatFromDragEvent(target, originalEvent);
+            if (compressedTarget) {
+                target = compressedTarget;
+            }
+        }
+        if (!target) {
+            target = this.explorerService.roots[this.explorerService.roots.length - 1];
+            targetSector = ListViewTargetSector.BOTTOM;
+        }
+        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(mainWindow))) {
+                    const fileImport = this.instantiationService.createInstance(ExternalFileImport);
+                    await fileImport.import(resolvedTarget, originalEvent, mainWindow);
+                }
+                else {
+                    const browserUpload = this.instantiationService.createInstance(BrowserFileUpload);
+                    await browserUpload.upload(target, originalEvent);
+                }
+            }
+            else {
+                await this.handleExplorerDrop(data, resolvedTarget, targetIndex, targetSector, originalEvent);
+            }
+        }
+        catch (error) {
+            this.dialogService.error(toErrorMessage(error));
+        }
+    }
+    async handleExplorerDrop(data, target, targetIndex, targetSector, originalEvent) {
+        const elementsData = FileDragAndDrop_1.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_1.CONFIRM_DND_SETTING_KEY);
+        if (confirmDragAndDrop) {
+            const message = items.length > 1 && items.every(s => s.isRoot) ? ( localize(
+                8205,
+                "Are you sure you want to change the order of multiple root folders in your workspace?"
+            ))
+                : items.length > 1 ? ( localize(
+                8206,
+                "Are you sure you want to move the following {0} files into '{1}'?",
+                items.length,
+                target.name
+            ))
+                    : items[0].isRoot ? ( localize(
+                8207,
+                "Are you sure you want to change the order of root folder '{0}' in your workspace?",
+                items[0].name
+            ))
+                        : ( localize(
+                8208,
+                "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(8209, "Do not ask me again"))
+                },
+                primaryButton: ( localize(8210, "&&Move"))
+            });
+            if (!confirmation.confirmed) {
+                return;
+            }
+            if (confirmation.checkboxChecked === true) {
+                await this.configurationService.updateValue(FileDragAndDrop_1.CONFIRM_DND_SETTING_KEY, false);
+            }
+        }
+        await this.doHandleRootDrop(items.filter(s => s.isRoot), target, targetSector);
+        const sources = items.filter(s => !s.isRoot);
+        if (isCopy) {
+            return this.doHandleExplorerDropOnCopy(sources, target);
+        }
+        return this.doHandleExplorerDropOnMove(sources, target);
+    }
+    async doHandleRootDrop(roots, target, targetSector) {
+        if (roots.length === 0) {
+            return;
+        }
+        const folders = this.contextService.getWorkspace().folders;
+        let targetIndex;
+        const sourceIndices = [];
+        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;
+            }
+            for (const root of roots) {
+                if (this.uriIdentityService.extUri.isEqual(folders[index].uri, root.resource)) {
+                    sourceIndices.push(index);
+                    break;
+                }
+            }
+            if (roots.every(r => ( r.resource.toString()) !== ( folders[index].uri.toString()))) {
+                workspaceCreationData.push(data);
+            }
+            else {
+                rootsToMove.push(data);
+            }
+        }
+        if (targetIndex === undefined) {
+            targetIndex = workspaceCreationData.length;
+        }
+        else {
+            switch (targetSector) {
+                case ListViewTargetSector.BOTTOM:
+                case ListViewTargetSector.CENTER_BOTTOM:
+                    targetIndex++;
+                    break;
+            }
+            for (const sourceIndex of sourceIndices) {
+                if (sourceIndex < targetIndex) {
+                    targetIndex--;
+                }
+            }
+        }
+        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 labelSuffix = getFileOrFolderLabelSuffix(sources);
+        await this.explorerService.applyBulkEdit(resourceFileEdits, {
+            confirmBeforeUndo: explorerConfig.confirmUndo === UndoConfirmLevel.Default || explorerConfig.confirmUndo === UndoConfirmLevel.Verbose,
+            undoLabel: ( localize(8211, "Copy {0}", labelSuffix)),
+            progressLabel: ( localize(8212, "Copying {0}", labelSuffix)),
+        });
+        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 labelSuffix = getFileOrFolderLabelSuffix(sources);
+        const options = {
+            confirmBeforeUndo: this.configurationService.getValue().explorer.confirmUndo === UndoConfirmLevel.Verbose,
+            undoLabel: ( localize(8213, "Move {0}", labelSuffix)),
+            progressLabel: ( localize(8214, "Moving {0}", labelSuffix))
+        };
+        try {
+            await this.explorerService.applyBulkEdit(resourceFileEdits, options);
+        }
+        catch (error) {
+            if (error.fileOperationResult === FileOperationResult.FILE_MOVE_CONFLICT) {
+                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_1.getCompressedStatFromDragEvent(data.elements[0], dragStartEvent)];
+            return data.context;
+        }
+        return data.elements;
+    }
+    static getCompressedStatFromDragEvent(stat, dragEvent) {
+        const target = getWindow(dragEvent).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();
+    }
+    dispose() {
+        this.compressedDropTargetDisposable.dispose();
+    }
+};
+FileDragAndDrop = FileDragAndDrop_1 = ( __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 (!(isHTMLElement(target))) {
+        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 getFileOrFolderLabelSuffix(items) {
+    if (items.length === 1) {
+        return items[0].name;
+    }
+    if (items.every(i => i.isDirectory)) {
+        return localize(8215, "{0} folders", items.length);
+    }
+    if (items.every(i => !i.isDirectory)) {
+        return localize(8216, "{0} files", items.length);
+    }
+    return `${items.length} files and folders`;
+}
+
+export { CompressedNavigationController, ExplorerCompressionDelegate, ExplorerDataSource, ExplorerDelegate, ExplorerFindProvider, FileDragAndDrop, FileSorter, FilesFilter, FilesRenderer, PhantomExplorerItem, explorerRootErrorEmitter, isCompressedFolderName };