@codingame/monaco-vscode-api 25.1.2 → 26.0.0

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

@@ -7,7 +7,7 @@ import { ProgressLocation } from '../../../../../platform/progress/common/progre
 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 { FileKind, FileChangeType, FileSystemProviderCapabilities, 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';
@@ -78,7 +78,9 @@ import Severity$1 from '../../../../../base/common/severity.js';
 
 var FilesRenderer_1, FileDragAndDrop_1;
 class ExplorerDelegate {
-    static { this.ITEM_HEIGHT = 22; }
+    static {
+        this.ITEM_HEIGHT = 22;
+    }
     getHeight(element) {
         return ExplorerDelegate.ITEM_HEIGHT;
     }
@@ -88,7 +90,18 @@ class ExplorerDelegate {
 }
 const explorerRootErrorEmitter = ( new Emitter());
 let ExplorerDataSource = class ExplorerDataSource {
-    constructor(fileFilter, findProvider, progressService, configService, notificationService, layoutService, fileService, explorerService, contextService, filesConfigService) {
+    constructor(
+        fileFilter,
+        findProvider,
+        progressService,
+        configService,
+        notificationService,
+        layoutService,
+        fileService,
+        explorerService,
+        contextService,
+        filesConfigService
+    ) {
         this.fileFilter = fileFilter;
         this.findProvider = findProvider;
         this.progressService = progressService;
@@ -104,10 +117,10 @@ let ExplorerDataSource = class ExplorerDataSource {
         if (element.parent) {
             return element.parent;
         }
-        throw ( new Error('getParent only supported for cached parents'));
+        throw ( new Error("getParent only supported for cached parents"));
     }
     hasChildren(element) {
-        return Array.isArray(element) || element.hasChildren((stat) => this.fileFilter.filter(stat, TreeVisibility.Visible));
+        return Array.isArray(element) || element.hasChildren(stat => this.fileFilter.filter(stat, TreeVisibility.Visible));
     }
     getChildren(element) {
         if (Array.isArray(element)) {
@@ -141,12 +154,10 @@ let ExplorerDataSource = class ExplorerDataSource {
                     ));
                     placeholder.error = e;
                     return [placeholder];
-                }
-                else {
+                } else {
                     explorerRootErrorEmitter.fire(element.resource);
                 }
-            }
-            else {
+            } else {
                 this.notificationService.error(e);
             }
             return [];
@@ -158,18 +169,8 @@ let ExplorerDataSource = class ExplorerDataSource {
         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 {
-}
+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());
@@ -183,7 +184,10 @@ class ExplorerFindHighlightTree {
         if (result === undefined) {
             return 0;
         }
-        const { treeLayer, relPath } = result;
+        const {
+            treeLayer,
+            relPath
+        } = result;
         this._highlightedItems.set(relPath, item);
         return treeLayer.childMatches;
     }
@@ -193,36 +197,50 @@ class ExplorerFindHighlightTree {
             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 === undefined || relPath.startsWith("..")) {
+            throw ( new Error("Resource is not a child of the root"));
         }
-        if (relPath === '') {
-            return { treeLayer: rootLayer, relPath };
+        if (relPath === "") {
+            return {
+                treeLayer: rootLayer,
+                relPath
+            };
         }
         let treeLayer = rootLayer;
-        for (const segment of relPath.split('/')) {
+        for (const segment of relPath.split("/")) {
             if (!treeLayer.stats[segment]) {
                 return undefined;
             }
             treeLayer = treeLayer.stats[segment];
         }
-        return { treeLayer, relPath };
+        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'));
+        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 };
+            rootLayer = {
+                childMatches: 0,
+                stats: {},
+                isMatch: false
+            };
             this._tree.set(root.name, rootLayer);
         }
         rootLayer.childMatches++;
         let treeLayer = rootLayer;
-        for (const stat of relPath.split('/')) {
+        for (const stat of relPath.split("/")) {
             if (!treeLayer.stats[stat]) {
-                treeLayer.stats[stat] = { childMatches: 0, stats: {}, isMatch: false };
+                treeLayer.stats[stat] = {
+                    childMatches: 0,
+                    stats: {},
+                    isMatch: false
+                };
             }
             treeLayer = treeLayer.stats[stat];
             treeLayer.childMatches++;
@@ -235,7 +253,9 @@ class ExplorerFindHighlightTree {
         if (result === undefined) {
             return false;
         }
-        const { treeLayer } = result;
+        const {
+            treeLayer
+        } = result;
         return treeLayer.isMatch;
     }
     clear() {
@@ -246,7 +266,17 @@ let ExplorerFindProvider = class ExplorerFindProvider {
     get highlightTree() {
         return this.findHighlightTree;
     }
-    constructor(filesFilter, treeProvider, searchService, fileService, configurationService, filesConfigService, progressService, explorerService, contextKeyService) {
+    constructor(
+        filesFilter,
+        treeProvider,
+        searchService,
+        fileService,
+        configurationService,
+        filesConfigService,
+        progressService,
+        explorerService,
+        contextKeyService
+    ) {
         this.filesFilter = filesFilter;
         this.treeProvider = treeProvider;
         this.searchService = searchService;
@@ -287,7 +317,7 @@ let ExplorerFindProvider = class ExplorerFindProvider {
         const promise = this.doFind(pattern, toggles, token);
         return await this.progressService.withProgress({
             location: ProgressLocation.Explorer,
-            delay: 750,
+            delay: 750
         }, _progress => promise);
     }
     async doFind(pattern, toggles, token) {
@@ -315,12 +345,16 @@ let ExplorerFindProvider = class ExplorerFindProvider {
             return;
         }
         const roots = this.explorerService.roots.filter(root => this.searchSupportsScheme(root.resource.scheme));
-        this.filterSessionStartState = { viewState: tree.getViewState(), input, rootsWithProviders: ( new Set(roots)) };
+        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'));
+            throw ( new Error("ExplorerFindProvider: no session state"));
         }
         const roots = Array.from(this.filterSessionStartState.rootsWithProviders);
         const searchResults = await this.getSearchResults(pattern, roots, matchType, token);
@@ -328,27 +362,47 @@ let ExplorerFindProvider = class ExplorerFindProvider {
             return undefined;
         }
         this.clearPhantomElements();
-        for (const { explorerRoot, files, directories } of searchResults) {
+        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));
+        const hitMaxResults = ( searchResults.some((
+            {
+                hitMaxResults
+            }
+        ) => hitMaxResults));
         return {
-            isMatch: (item) => item.isMarkedAsFiltered(),
-            matchCount: searchResults.reduce((acc, { files, directories }) => acc + files.length + directories.length, 0),
+            isMatch: item => item.isMarkedAsFiltered(),
+            matchCount: searchResults.reduce((
+                acc,
+                {
+                    files,
+                    directories
+                }
+            ) => acc + files.length + directories.length, 0),
             warningMessage: hitMaxResults ? ( localize(
-                8231,
+                8543,
                 "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 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();
@@ -356,7 +410,7 @@ let ExplorerFindProvider = class ExplorerFindProvider {
             }
             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'));
+                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)) {
@@ -369,14 +423,16 @@ let ExplorerFindProvider = class ExplorerFindProvider {
     createPhantomItems(resource, root, resourceIsDirectory) {
         const relativePathToRoot = relativePath(root.resource, resource);
         if (!relativePathToRoot) {
-            throw ( new Error('Resource is not a child of the root'));
+            throw ( new Error("Resource is not a child of the root"));
         }
         const phantomElements = [];
         let currentItem = root;
         let currentResource = root.resource;
-        const pathSegments = relativePathToRoot.split('/');
+        const pathSegments = relativePathToRoot.split("/");
         for (const stat of pathSegments) {
-            currentResource = currentResource.with({ path: `${currentResource.path}/${stat}` });
+            currentResource = currentResource.with({
+                path: `${currentResource.path}/${stat}`
+            });
             let child = currentItem.getChild(stat);
             if (!child) {
                 const isDirectory = pathSegments[pathSegments.length - 1] === stat ? resourceIsDirectory : true;
@@ -399,7 +455,7 @@ let ExplorerFindProvider = class ExplorerFindProvider {
         this.clearPhantomElements();
         this.explorerFindActiveContextKey.set(false);
         if (!this.filterSessionStartState) {
-            throw ( new Error('ExplorerFindProvider: no session state to restore'));
+            throw ( new Error("ExplorerFindProvider: no session state to restore"));
         }
         const tree = this.treeProvider();
         await tree.setInput(this.filterSessionStartState.input, this.filterSessionStartState.viewState);
@@ -415,11 +471,13 @@ let ExplorerFindProvider = class ExplorerFindProvider {
     }
     startHighlightSession() {
         const roots = this.explorerService.roots.filter(root => this.searchSupportsScheme(root.resource.scheme));
-        this.highlightSessionStartState = { rootsWithProviders: ( new Set(roots)) };
+        this.highlightSessionStartState = {
+            rootsWithProviders: ( new Set(roots))
+        };
     }
     async doHighlightFind(pattern, matchType, token) {
         if (!this.highlightSessionStartState) {
-            throw ( new Error('ExplorerFindProvider: no highlight session state'));
+            throw ( new Error("ExplorerFindProvider: no highlight session state"));
         }
         const roots = Array.from(this.highlightSessionStartState.rootsWithProviders);
         const searchResults = await this.getSearchResults(pattern, roots, matchType, token);
@@ -427,22 +485,36 @@ let ExplorerFindProvider = class ExplorerFindProvider {
             return undefined;
         }
         this.clearHighlights();
-        for (const { explorerRoot, files, directories } of searchResults) {
+        for (const {
+            explorerRoot,
+            files,
+            directories
+        } of searchResults) {
             this.addWorkspaceHighlightResults(explorerRoot, files.concat(directories));
         }
-        const hitMaxResults = ( searchResults.some(({ hitMaxResults }) => hitMaxResults));
+        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),
+            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(
-                8231,
+                8543,
                 "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) => {
+        const storeDirectories = item => {
             while (item) {
                 highlightedDirectories.add(item);
                 item = item.parent;
@@ -495,69 +567,81 @@ let ExplorerFindProvider = class ExplorerFindProvider {
         )));
     }
     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 segmentMatchPattern = 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'),
-                }],
+                folder: root.resource,
+                disregardIgnoreFiles: !this.configurationService.getValue("explorer.excludeGitIgnore")
+            }],
             type: QueryType.File,
             shouldGlobMatchFilePattern: true,
             cacheKey: `explorerfindprovider:${root.name}:${rootIndex}:${this.sessionId}`,
             excludePattern: searchExcludePattern,
+            ignoreGlobCase: true
         };
         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) {
+            [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 };
+            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 };
+        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));
+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'));
+            throw ( new Error("Resource is not a child of the root"));
         }
         let dirResource = root.resource;
-        const stats = relativePathToRoot.split('/').slice(0, -1);
+        const stats = relativePathToRoot.split("/").slice(0, -1);
         for (const stat of stats) {
-            dirResource = dirResource.with({ path: `${dirResource.path}/${stat}` });
+            dirResource = dirResource.with({
+                path: `${dirResource.path}/${stat}`
+            });
             uniqueDirectories.add(dirResource);
         }
     }
     const matchingDirectories = [];
     for (const dirResource of uniqueDirectories) {
-        const stats = dirResource.path.split('/');
+        const stats = dirResource.path.split("/");
         const dirStat = stats[stats.length - 1];
-        if (!dirStat || !match(segmentMatchPattern, dirStat)) {
+        if (!dirStat || !match(segmentMatchPattern, dirStat, {
+            ignoreCase: true
+        })) {
             continue;
         }
         matchingDirectories.push(dirResource);
@@ -567,13 +651,15 @@ function getMatchingDirectoriesFromFiles(resources, root, segmentMatchPattern) {
 function findFirstParent(resource, root) {
     const relativePathToRoot = relativePath(root.resource, resource);
     if (!relativePathToRoot) {
-        throw ( new Error('Resource is not a child of the root'));
+        throw ( new Error("Resource is not a child of the root"));
     }
     let currentItem = root;
     let currentResource = root.resource;
-    const pathSegments = relativePathToRoot.split('/');
+    const pathSegments = relativePathToRoot.split("/");
     for (const stat of pathSegments) {
-        currentResource = currentResource.with({ path: `${currentResource.path}/${stat}` });
+        currentResource = currentResource.with({
+            path: `${currentResource.path}/${stat}`
+        });
         const child = currentItem.getChild(stat);
         if (!child) {
             return currentItem;
@@ -584,36 +670,35 @@ function findFirstParent(resource, root) {
 }
 function fuzzyMatchingGlobPattern(pattern) {
     if (!pattern) {
-        return '*';
+        return "*";
     }
-    return '*' + pattern.split('').join('*') + '*';
+    return "*" + pattern.split("").join("*") + "*";
 }
 function continousMatchingGlobPattern(pattern) {
     if (!pattern) {
-        return '*';
+        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;
+    return "*" + pattern + "*";
 }
 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; }
+    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;
@@ -626,17 +711,17 @@ class CompressedNavigationController {
         this._updateLabelDisposable = templateData.label.onDidRender(() => this.updateLabels(templateData));
     }
     updateLabels(templateData) {
-        this._labels = Array.from(templateData.container.querySelectorAll('.label-name'));
-        let parents = '';
+        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}`);
+            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');
+            this.labels[this._index].classList.add("active");
         }
     }
     previous() {
@@ -667,15 +752,15 @@ class CompressedNavigationController {
         if (index < 0 || index >= this.items.length) {
             return;
         }
-        this.labels[this._index].classList.remove('active');
+        this.labels[this._index].classList.remove("active");
         this._index = index;
-        this.labels[this._index].classList.add('active');
+        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');
+            this.labels[i].setAttribute("aria-expanded", collapsed ? "false" : "true");
         }
     }
     dispose() {
@@ -684,9 +769,26 @@ class CompressedNavigationController {
     }
 }
 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) {
+    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;
@@ -703,38 +805,38 @@ let FilesRenderer = class FilesRenderer {
         this.onDidChangeActiveDescendant = this._onDidChangeActiveDescendant.event;
         this.config = this.configurationService.getValue();
         const updateOffsetStyles = () => {
-            const indent = this.configurationService.getValue('workbench.tree.indent');
+            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')) {
+            if (e.affectsConfiguration("explorer")) {
                 this.config = this.configurationService.getValue();
             }
-            if (e.affectsConfiguration('workbench.tree.indent')) {
+            if (e.affectsConfiguration("workbench.tree.indent")) {
                 updateOffsetStyles();
             }
         });
         updateOffsetStyles();
     }
     getWidgetAriaLabel() {
-        return localize(8232, "Files Explorer");
+        return localize(8544, "Files Explorer");
     }
     get templateId() {
         return FilesRenderer_1.ID;
     }
     renderTemplate(container) {
         const templateDisposables = ( new DisposableStore());
-        const label = templateDisposables.add(this.labels.create(container, { supportHighlights: true }));
+        const label = templateDisposables.add(this.labels.create(container, {
+            supportHighlights: true
+        }));
         templateDisposables.add(label.onDidRender(() => {
             scheduleAtNextAnimationFrame(getWindow(templateData.container), () => {
                 try {
                     if (templateData.currentContext) {
                         this.updateWidth(templateData.currentContext);
                     }
-                }
-                catch (e) {
-                }
+                } catch (e) {}
             });
         }));
         const contribs = explorerFileContribRegistry.create(this.instantiationService, container, templateDisposables);
@@ -743,20 +845,26 @@ let FilesRenderer = class FilesRenderer {
             contribs.push(templateDisposables.add(contr));
             contr.setResource(templateData.currentContext?.resource);
         }));
-        const templateData = { templateDisposables, elementDisposables: templateDisposables.add(( new DisposableStore())), label, container, contribs };
+        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');
+        templateData.label.element.classList.remove("compressed");
         if (!editableData) {
-            templateData.label.element.style.display = 'flex';
+            templateData.label.element.style.display = "flex";
             this.renderStat(stat, stat.name, undefined, node.filterData, templateData);
         }
         else {
-            templateData.label.element.style.display = 'none';
+            templateData.label.element.style.display = "none";
             templateData.contribs.forEach(c => c.setResource(undefined));
             templateData.elementDisposables.add(this.renderInputBox(templateData.container, stat, editableData));
         }
@@ -767,13 +875,13 @@ let FilesRenderer = class FilesRenderer {
         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';
+            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;
+                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);
@@ -781,8 +889,10 @@ let FilesRenderer = class FilesRenderer {
             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 => {
+            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);
@@ -792,38 +902,40 @@ let FilesRenderer = class FilesRenderer {
                 const nodeControllers = this.compressedNavigationControllers.get(stat) ?? [];
                 const renderedIndex = nodeControllers.findIndex(controller => controller === compressedNavigationController);
                 if (renderedIndex < 0) {
-                    throw ( new Error('Disposing unknown navigation controller'));
+                    throw ( new Error("Disposing unknown navigation controller"));
                 }
                 if (nodeControllers.length === 1) {
                     this.compressedNavigationControllers.delete(stat);
-                }
-                else {
+                } else {
                     nodeControllers.splice(renderedIndex, 1);
                 }
             }));
         }
         else {
-            templateData.label.element.classList.remove('compressed');
-            templateData.label.element.style.display = 'none';
+            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'];
+        templateData.label.element.style.display = "flex";
+        const extraClasses = ["explorer-item"];
         if (this.explorerService.isCut(stat)) {
-            extraClasses.push('cut');
+            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 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 }, {
+        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,
+            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),
@@ -831,20 +943,20 @@ let FilesRenderer = class FilesRenderer {
         });
         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) }
-            ));
+            const badge = ( new CountBadge(templateData.label.element.lastElementChild, {}, {
+                ...defaultCountBadgeStyles,
+                badgeBackground: asCssVariable(listFilterMatchHighlight),
+                badgeBorder: asCssVariable(listFilterMatchHighlightBorder)
+            }));
             badge.setCount(highlightResults);
-            badge.setTitleFormat(( localize(8233, "Directory contains {0} matches", highlightResults)));
+            badge.setTitleFormat(( localize(8545, "Directory contains {0} matches", highlightResults)));
             templateData.elementDisposables.add(badge);
         }
-        templateData.label.element.classList.toggle('highlight-badge', highlightResults > 0);
+        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 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);
@@ -853,15 +965,15 @@ let FilesRenderer = class FilesRenderer {
             hidePath: true,
             hideLabel: true,
             fileKind,
-            extraClasses: realignNestedChildren ? [...extraClasses, 'align-nest-icon-with-parent-icon'] : extraClasses,
+            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 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) => {
+                validation: value => {
                     const message = editableData.validationMessage(value);
                     if (!message || message.severity !== Severity$1.Error) {
                         return null;
@@ -873,16 +985,19 @@ let FilesRenderer = class FilesRenderer {
                     };
                 }
             },
-            ariaLabel: ( localize(8234, "Type file name. Press Enter to confirm or Escape to cancel.")),
-            inputBoxStyles: defaultInputBoxStyles,
+            ariaLabel: ( localize(8546, "Type file name. Press Enter to confirm or Escape to cancel.")),
+            inputBoxStyles: defaultInputBoxStyles
         }));
-        const lastDot = value.lastIndexOf('.');
-        let currentSelectionState = 'prefix';
+        const lastDot = value.lastIndexOf(".");
+        let currentSelectionState = "prefix";
         inputBox.value = value;
         inputBox.focus();
-        inputBox.select({ start: 0, end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length });
+        inputBox.select({
+            start: 0,
+            end: lastDot > 0 && !stat.isDirectory ? lastDot : value.length
+        });
         const done = createSingleCallFunction((success, finishEditing) => {
-            label.element.style.display = 'none';
+            label.element.style.display = "none";
             const value = inputBox.value;
             dispose(toDispose);
             label.element.remove();
@@ -899,71 +1014,66 @@ let FilesRenderer = class FilesRenderer {
                         formatContent: true,
                         type: message.severity === Severity$1.Info ? MessageType.INFO : message.severity === Severity$1.Warning ? MessageType.WARNING : MessageType.ERROR
                     });
-                }
-                else {
+                } 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 });
-                    }
+        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;
                 }
-                else if (e.equals(KeyCode.Enter)) {
-                    if (!inputBox.validate()) {
-                        done(true, true);
-                    }
+                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.Escape)) {
-                    done(false, true);
+            } else if (e.equals(KeyCode.Enter)) {
+                if (!inputBox.validate()) {
+                    done(true, 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;
-                    }
+            } 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;
                 }
-                done(inputBox.isInputValid(), true);
-            }),
-            label
-        ];
+                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);
         });
@@ -1004,18 +1114,16 @@ let FilesRenderer = class FilesRenderer {
         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));
+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) {
+    constructor(
+        contextService,
+        configurationService,
+        explorerService,
+        editorService,
+        uriIdentityService,
+        fileService
+    ) {
         this.contextService = contextService;
         this.configurationService = configurationService;
         this.explorerService = explorerService;
@@ -1028,15 +1136,17 @@ let FilesFilter = class FilesFilter {
         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.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) => {
+                ignoreFileResourceSet.forEach(async ignoreResource => {
                     if (e.contains(ignoreResource, FileChangeType.UPDATED)) {
                         await this.processIgnoreFile(root, ignoreResource, true);
                     }
@@ -1081,13 +1191,15 @@ let FilesFilter = class FilesFilter {
         let shouldFire = false;
         let updatedGitIgnoreSetting = false;
         this.contextService.getWorkspace().folders.forEach(folder => {
-            const configuration = this.configurationService.getValue({ resource: folder.uri });
+            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)));
+                this.ignoreTreesPerRoot.set(( folder.uri.toString()), TernarySearchTree.forUris(uri => this.uriIdentityService.extUri.ignorePathCasing(uri)));
             }
             if (!parseIgnoreFile && ( this.ignoreTreesPerRoot.has(( folder.uri.toString())))) {
                 updatedGitIgnoreSetting = true;
@@ -1099,7 +1211,10 @@ let FilesFilter = class FilesFilter {
                 shouldFire = !cached || !equals(cached.original, excludesConfig);
             }
             const excludesConfigCopy = deepClone(excludesConfig);
-            this.hiddenExpressionPerRoot.set(( folder.uri.toString()), { original: excludesConfigCopy, parsed: parse(excludesConfigCopy) });
+            this.hiddenExpressionPerRoot.set(( folder.uri.toString()), {
+                original: excludesConfigCopy,
+                parsed: parse(excludesConfigCopy)
+            });
         });
         if (shouldFire || updatedGitIgnoreSetting) {
             this.editorsAffectingFilter.clear();
@@ -1119,10 +1234,10 @@ let FilesFilter = class FilesFilter {
         if (update) {
             const ignoreFile = ignoreTree.get(dirUri);
             ignoreFile?.updateContents(( content.value.toString()));
-        }
-        else {
+        } else {
             const ignoreParent = ignoreTree.findSubstr(dirUri);
-            const ignoreFile = ( new IgnoreFile(( content.value.toString()), dirUri.path, ignoreParent));
+            const ignoreCase = !this.fileService.hasCapability(ignoreFileResource, FileSystemProviderCapabilities.PathCaseSensitive);
+            const ignoreFile = ( new IgnoreFile(( content.value.toString()), dirUri.path, ignoreParent, ignoreCase));
             ignoreTree.set(dirUri, ignoreFile);
             if (!this.ignoreFileResourcesPerRoot.get(root)?.has(ignoreFileResource)) {
                 this.ignoreFileResourcesPerRoot.get(root)?.add(ignoreFileResource);
@@ -1131,7 +1246,7 @@ let FilesFilter = class FilesFilter {
         this._onDidChange.fire();
     }
     filter(stat, parentVisibility) {
-        if (stat.name === '.gitignore' && ( this.ignoreTreesPerRoot.has(( stat.root.resource.toString())))) {
+        if (stat.name === ".gitignore" && ( this.ignoreTreesPerRoot.has(( stat.root.resource.toString())))) {
             this.processIgnoreFile(( stat.root.resource.toString()), stat.resource, false);
             return true;
         }
@@ -1147,12 +1262,18 @@ let FilesFilter = class FilesFilter {
             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 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));
+            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;
@@ -1170,14 +1291,7 @@ let FilesFilter = class FilesFilter {
         dispose(this.toDispose);
     }
 };
-FilesFilter = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IExplorerService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IUriIdentityService)),
-    ( __param(5, IFileService))
-], FilesFilter));
+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;
@@ -1204,88 +1318,100 @@ let FileSorter = class FileSorter {
         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;
+        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;
+        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);
+        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));
+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) {
+    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;
@@ -1299,13 +1425,15 @@ let FileDragAndDrop = class FileDragAndDrop {
         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');
+        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)));
+        this.disposables.add(
+            this.configurationService.onDidChangeConfiguration(e => updateDropEnablement(e))
+        );
     }
     onDragOver(data, target, targetIndex, targetSector, originalEvent) {
         if (!this.dropEnabled) {
@@ -1322,12 +1450,15 @@ let FileDragAndDrop = class FileDragAndDrop {
                             this.compressedDragOverElement = iconLabelName.element;
                             this.compressedDropTargetDisposable.dispose();
                             this.compressedDropTargetDisposable = toDisposable(() => {
-                                iconLabelName.element.classList.remove('drop-target');
+                                iconLabelName.element.classList.remove("drop-target");
                                 this.compressedDragOverElement = undefined;
                             });
-                            iconLabelName.element.classList.add('drop-target');
+                            iconLabelName.element.classList.add("drop-target");
                         }
-                        return typeof result === 'boolean' ? result : { ...result, feedback: [] };
+                        return typeof result === "boolean" ? result : {
+                            ...result,
+                            feedback: []
+                        };
                     }
                     this.compressedDropTargetDisposable.dispose();
                     return false;
@@ -1341,9 +1472,17 @@ let FileDragAndDrop = class FileDragAndDrop {
         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 };
+        const effect = {
+            type: effectType,
+            position: ListDragOverEffectPosition.Over
+        };
         if (isNative) {
-            if (!containsDragType(originalEvent, DataTransfers.FILES, CodeDataTransfers.FILES, DataTransfers.RESOURCES)) {
+            if (!containsDragType(
+                originalEvent,
+                DataTransfers.FILES,
+                CodeDataTransfers.FILES,
+                DataTransfers.RESOURCES
+            )) {
                 return false;
             }
         }
@@ -1358,17 +1497,28 @@ let FileDragAndDrop = class FileDragAndDrop {
                     return false;
                 }
                 if (isRootsReorder) {
-                    return { accept: true, effect: { type: ListDragOverEffectType.Move, position: ListDragOverEffectPosition.After } };
+                    return {
+                        accept: true,
+                        effect: {
+                            type: ListDragOverEffectType.Move,
+                            position: ListDragOverEffectPosition.After
+                        }
+                    };
                 }
-                return { accept: true, bubble: TreeDragOverBubble.Down, effect, autoExpand: false };
+                return {
+                    accept: true,
+                    bubble: TreeDragOverBubble.Down,
+                    effect,
+                    autoExpand: false
+                };
             }
             if (!Array.isArray(items)) {
                 return false;
             }
-            if (!isCopy && items.every((source) => source.isReadonly)) {
+            if (!isCopy && items.every(source => source.isReadonly)) {
                 return false;
             }
-            if (( items.some((source) => {
+            if (( items.some(source => {
                 if (source.isRoot) {
                     return false;
                 }
@@ -1391,30 +1541,49 @@ let FileDragAndDrop = class FileDragAndDrop {
                 }
                 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;
+                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 } };
+                return {
+                    accept: true,
+                    effect: {
+                        type: ListDragOverEffectType.Move,
+                        position: dropEffectPosition
+                    }
+                };
             }
         }
         if (!target) {
-            return { accept: true, bubble: TreeDragOverBubble.Down, effect };
+            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 };
+                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 {
+                    accept: true,
+                    bubble: TreeDragOverBubble.Up,
+                    effect
+                };
             }
         }
         return false;
@@ -1478,8 +1647,7 @@ let FileDragAndDrop = class FileDragAndDrop {
             else {
                 await this.handleExplorerDrop(data, resolvedTarget, targetIndex, targetSector, originalEvent);
             }
-        }
-        catch (error) {
+        } catch (error) {
             this.dialogService.error(toErrorMessage(error));
         }
     }
@@ -1501,22 +1669,19 @@ let FileDragAndDrop = class FileDragAndDrop {
         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(
-                8235,
+                8547,
                 "Are you sure you want to change the order of multiple root folders in your workspace?"
-            ))
-                : items.length > 1 ? ( localize(
-                8236,
+            )) : items.length > 1 ? ( localize(
+                8548,
                 "Are you sure you want to move the following {0} files into '{1}'?",
                 items.length,
                 target.name
-            ))
-                    : items[0].isRoot ? ( localize(
-                8237,
+            )) : items[0].isRoot ? ( localize(
+                8549,
                 "Are you sure you want to change the order of root folder '{0}' in your workspace?",
                 items[0].name
-            ))
-                        : ( localize(
-                8238,
+            )) : ( localize(
+                8550,
                 "Are you sure you want to move '{0}' into '{1}'?",
                 items[0].name,
                 target.name
@@ -1526,9 +1691,9 @@ let FileDragAndDrop = class FileDragAndDrop {
                 message,
                 detail,
                 checkbox: {
-                    label: ( localize(8239, "Do not ask me again"))
+                    label: ( localize(8551, "Do not ask me again"))
                 },
-                primaryButton: ( localize(8240, "&&Move"))
+                primaryButton: ( localize(8552, "&&Move"))
             });
             if (!confirmation.confirmed) {
                 return;
@@ -1569,20 +1734,18 @@ let FileDragAndDrop = class FileDragAndDrop {
             }
             if (roots.every(r => ( r.resource.toString()) !== ( folders[index].uri.toString()))) {
                 workspaceCreationData.push(data);
-            }
-            else {
+            } else {
                 rootsToMove.push(data);
             }
         }
         if (targetIndex === undefined) {
             targetIndex = workspaceCreationData.length;
-        }
-        else {
+        } else {
             switch (targetSector) {
-                case ListViewTargetSector.BOTTOM:
-                case ListViewTargetSector.CENTER_BOTTOM:
-                    targetIndex++;
-                    break;
+            case ListViewTargetSector.BOTTOM:
+            case ListViewTargetSector.CENTER_BOTTOM:
+                targetIndex++;
+                break;
             }
             for (const sourceIndex of sourceIndices) {
                 if (sourceIndex < targetIndex) {
@@ -1596,25 +1759,40 @@ let FileDragAndDrop = class FileDragAndDrop {
     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);
+        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 }));
+            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(8241, "Copy {0}", labelSuffix)),
-            progressLabel: ( localize(8242, "Copying {0}", labelSuffix)),
+            undoLabel: ( localize(8553, "Copy {0}", labelSuffix)),
+            progressLabel: ( localize(8554, "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 } })));
+        }).map(edit => ({
+            resource: edit.newResource,
+            options: {
+                pinned: true
+            }
+        })));
         await this.editorService.openEditors(editors);
     }
     async doHandleExplorerDropOnMove(sources, target) {
@@ -1622,13 +1800,12 @@ let FileDragAndDrop = class FileDragAndDrop {
         const labelSuffix = getFileOrFolderLabelSuffix(sources);
         const options = {
             confirmBeforeUndo: this.configurationService.getValue().explorer.confirmUndo === UndoConfirmLevel.Verbose,
-            undoLabel: ( localize(8243, "Move {0}", labelSuffix)),
-            progressLabel: ( localize(8244, "Moving {0}", labelSuffix))
+            undoLabel: ( localize(8555, "Move {0}", labelSuffix)),
+            progressLabel: ( localize(8556, "Moving {0}", labelSuffix))
         };
         try {
             await this.explorerService.applyBulkEdit(resourceFileEdits, options);
-        }
-        catch (error) {
+        } catch (error) {
             if (error.fileOperationResult === FileOperationResult.FILE_MOVE_CONFLICT) {
                 const overwrites = [];
                 for (const edit of resourceFileEdits) {
@@ -1637,9 +1814,13 @@ let FileDragAndDrop = class FileDragAndDrop {
                     }
                 }
                 const confirm = getMultipleFilesOverwriteConfirm(overwrites);
-                const { confirmed } = await this.dialogService.confirm(confirm);
+                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);
+                    await this.explorerService.applyBulkEdit(( resourceFileEdits.map(re => ( new ResourceFileEdit(re.oldResource, re.newResource, {
+                        overwrite: true
+                    })))), options);
                 }
             }
             else {
@@ -1652,7 +1833,9 @@ let FileDragAndDrop = class FileDragAndDrop {
             return data.context;
         }
         if (dragStartEvent && data.elements.length === 1) {
-            data.context = [FileDragAndDrop_1.getCompressedStatFromDragEvent(data.elements[0], dragStartEvent)];
+            data.context = [
+                FileDragAndDrop_1.getCompressedStatFromDragEvent(data.elements[0], dragStartEvent)
+            ];
             return data.context;
         }
         return data.elements;
@@ -1661,7 +1844,10 @@ let FileDragAndDrop = class FileDragAndDrop {
         const target = getWindow(dragEvent).document.elementFromPoint(dragEvent.clientX, dragEvent.clientY);
         const iconLabelName = getIconLabelNameFromHTMLElement(target);
         if (iconLabelName) {
-            const { count, index } = iconLabelName;
+            const {
+                count,
+                index
+            } = iconLabelName;
             let i = count - 1;
             while (i > index && stat.parent) {
                 stat = stat.parent;
@@ -1678,28 +1864,22 @@ let FileDragAndDrop = class FileDragAndDrop {
         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));
+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'));
+    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 };
+                return {
+                    element: element,
+                    count,
+                    index
+                };
             }
         }
         element = element.parentElement;
@@ -1719,10 +1899,10 @@ function getFileOrFolderLabelSuffix(items) {
         return items[0].name;
     }
     if (items.every(i => i.isDirectory)) {
-        return localize(8245, "{0} folders", items.length);
+        return localize(8557, "{0} folders", items.length);
     }
     if (items.every(i => !i.isDirectory)) {
-        return localize(8246, "{0} files", items.length);
+        return localize(8558, "{0} files", items.length);
     }
     return `${items.length} files and folders`;
 }