@codingame/monaco-vscode-scm-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/scm/browser/scmViewPaneContainer.js

@@ -1,54 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/scm.css.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { VIEWLET_ID, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
-
-let SCMViewPaneContainer = class SCMViewPaneContainer extends ViewPaneContainer {
-    constructor(scmViewService, layoutService, telemetryService, instantiationService, contextMenuService, themeService, storageService, configurationService, extensionService, contextService, viewDescriptorService) {
-        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
-        this.scmViewService = scmViewService;
-    }
-    create(parent) {
-        super.create(parent);
-        parent.classList.add('scm-viewlet');
-    }
-    getOptimalWidth() {
-        return 400;
-    }
-    getTitle() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPaneContainer',
-            'source control',
-            "Source Control"
-        ));
-    }
-    getActionsContext() {
-        return this.scmViewService.visibleRepositories.length === 1 ? this.scmViewService.visibleRepositories[0].provider : undefined;
-    }
-};
-SCMViewPaneContainer = ( __decorate([
-    ( __param(0, ISCMViewService)),
-    ( __param(1, IWorkbenchLayoutService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IWorkspaceContextService)),
-    ( __param(10, IViewDescriptorService))
-], SCMViewPaneContainer));
-
-export { SCMViewPaneContainer };

package/vscode/src/vs/workbench/contrib/scm/browser/scmViewService.js

@@ -1,305 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { ISCMService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { SCMMenus } from './menus.js';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { debounce } from 'vscode/vscode/vs/base/common/decorators';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { comparePaths, compareFileNames } from 'vscode/vscode/vs/base/common/comparers';
-import { basename } from 'vscode/vscode/vs/base/common/resources';
-import { binarySearch } from 'vscode/vscode/vs/base/common/arrays';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { RawContextKey, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-
-function getProviderStorageKey(provider) {
-    return `${provider.contextValue}:${provider.label}${provider.rootUri ? `:${( provider.rootUri.toString())}` : ''}`;
-}
-function getRepositoryName(workspaceContextService, repository) {
-    if (!repository.provider.rootUri) {
-        return repository.provider.label;
-    }
-    const folder = workspaceContextService.getWorkspaceFolder(repository.provider.rootUri);
-    return folder?.uri.toString() === ( repository.provider.rootUri.toString()) ? folder.name : basename(repository.provider.rootUri);
-}
-const RepositoryContextKeys = {
-    RepositorySortKey: ( new RawContextKey(
-        'scmRepositorySortKey',
-        "discoveryTime"
-    )),
-};
-let SCMViewService = class SCMViewService {
-    get repositories() {
-        return ( this._repositories.map(r => r.repository));
-    }
-    get visibleRepositories() {
-        if (this._repositoriesSortKey === "discoveryTime" ) {
-            return ( this._repositories.filter(r => r.selectionIndex !== -1)
-                .sort((r1, r2) => r1.selectionIndex - r2.selectionIndex)
-                .map(r => r.repository));
-        }
-        return ( this._repositories
-            .filter(r => r.selectionIndex !== -1)
-            .map(r => r.repository));
-    }
-    set visibleRepositories(visibleRepositories) {
-        const set = ( new Set(visibleRepositories));
-        const added = ( new Set());
-        const removed = ( new Set());
-        for (const repositoryView of this._repositories) {
-            if (!( set.has(repositoryView.repository)) && repositoryView.selectionIndex !== -1) {
-                repositoryView.selectionIndex = -1;
-                removed.add(repositoryView.repository);
-            }
-            if (( set.has(repositoryView.repository))) {
-                if (repositoryView.selectionIndex === -1) {
-                    added.add(repositoryView.repository);
-                }
-                repositoryView.selectionIndex = visibleRepositories.indexOf(repositoryView.repository);
-            }
-        }
-        if (added.size === 0 && removed.size === 0) {
-            return;
-        }
-        this._onDidSetVisibleRepositories.fire({ added, removed });
-        if (this._repositories.find(r => r.focused && r.selectionIndex === -1)) {
-            this.focus(this._repositories.find(r => r.selectionIndex !== -1)?.repository);
-        }
-    }
-    get focusedRepository() {
-        return this._repositories.find(r => r.focused)?.repository;
-    }
-    constructor(scmService, contextKeyService, instantiationService, configurationService, storageService, workspaceContextService) {
-        this.configurationService = configurationService;
-        this.storageService = storageService;
-        this.workspaceContextService = workspaceContextService;
-        this.didFinishLoading = false;
-        this.didSelectRepository = false;
-        this.disposables = ( new DisposableStore());
-        this._repositories = [];
-        this._onDidChangeRepositories = ( new Emitter());
-        this.onDidChangeRepositories = this._onDidChangeRepositories.event;
-        this._onDidSetVisibleRepositories = ( new Emitter());
-        this.onDidChangeVisibleRepositories = Event.any(this._onDidSetVisibleRepositories.event, Event.debounce(this._onDidChangeRepositories.event, (last, e) => {
-            if (!last) {
-                return e;
-            }
-            const added = ( new Set(last.added));
-            const removed = ( new Set(last.removed));
-            for (const repository of e.added) {
-                if (( removed.has(repository))) {
-                    removed.delete(repository);
-                }
-                else {
-                    added.add(repository);
-                }
-            }
-            for (const repository of e.removed) {
-                if (( added.has(repository))) {
-                    added.delete(repository);
-                }
-                else {
-                    removed.add(repository);
-                }
-            }
-            return { added, removed };
-        }, 0, undefined, undefined, undefined, this.disposables));
-        this._onDidFocusRepository = ( new Emitter());
-        this.onDidFocusRepository = this._onDidFocusRepository.event;
-        this.menus = instantiationService.createInstance(SCMMenus);
-        try {
-            this.previousState = JSON.parse(storageService.get('scm:view:visibleRepositories', 1 , ''));
-        }
-        catch {
-        }
-        this._repositoriesSortKey = this.previousState?.sortKey ?? this.getViewSortOrder();
-        this._sortKeyContextKey = RepositoryContextKeys.RepositorySortKey.bindTo(contextKeyService);
-        this._sortKeyContextKey.set(this._repositoriesSortKey);
-        scmService.onDidAddRepository(this.onDidAddRepository, this, this.disposables);
-        scmService.onDidRemoveRepository(this.onDidRemoveRepository, this, this.disposables);
-        for (const repository of scmService.repositories) {
-            this.onDidAddRepository(repository);
-        }
-        storageService.onWillSaveState(this.onWillSaveState, this, this.disposables);
-    }
-    onDidAddRepository(repository) {
-        if (!this.didFinishLoading) {
-            this.eventuallyFinishLoading();
-        }
-        const repositoryView = {
-            repository, discoveryTime: Date.now(), focused: false, selectionIndex: -1
-        };
-        let removed = Iterable.empty();
-        if (this.previousState) {
-            const index = this.previousState.all.indexOf(getProviderStorageKey(repository.provider));
-            if (index === -1) {
-                const added = [];
-                this.insertRepositoryView(this._repositories, repositoryView);
-                this._repositories.forEach((repositoryView, index) => {
-                    if (repositoryView.selectionIndex === -1) {
-                        added.push(repositoryView.repository);
-                    }
-                    repositoryView.selectionIndex = index;
-                });
-                this._onDidChangeRepositories.fire({ added, removed: Iterable.empty() });
-                this.didSelectRepository = false;
-                return;
-            }
-            if (this.previousState.visible.indexOf(index) === -1) {
-                if (this.didSelectRepository) {
-                    this.insertRepositoryView(this._repositories, repositoryView);
-                    this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
-                    return;
-                }
-            }
-            else {
-                if (!this.didSelectRepository) {
-                    removed = [...this.visibleRepositories];
-                    this._repositories.forEach(r => {
-                        r.focused = false;
-                        r.selectionIndex = -1;
-                    });
-                    this.didSelectRepository = true;
-                }
-            }
-        }
-        const maxSelectionIndex = this.getMaxSelectionIndex();
-        this.insertRepositoryView(this._repositories, { ...repositoryView, selectionIndex: maxSelectionIndex + 1 });
-        this._onDidChangeRepositories.fire({ added: [repositoryView.repository], removed });
-        if (!this._repositories.find(r => r.focused)) {
-            this.focus(repository);
-        }
-    }
-    onDidRemoveRepository(repository) {
-        if (!this.didFinishLoading) {
-            this.eventuallyFinishLoading();
-        }
-        const repositoriesIndex = this._repositories.findIndex(r => r.repository === repository);
-        if (repositoriesIndex === -1) {
-            return;
-        }
-        let added = Iterable.empty();
-        const repositoryView = this._repositories.splice(repositoriesIndex, 1);
-        if (this._repositories.length > 0 && this.visibleRepositories.length === 0) {
-            this._repositories[0].selectionIndex = 0;
-            added = [this._repositories[0].repository];
-        }
-        this._onDidChangeRepositories.fire({ added, removed: ( repositoryView.map(r => r.repository)) });
-        if (repositoryView.length === 1 && repositoryView[0].focused && this.visibleRepositories.length > 0) {
-            this.focus(this.visibleRepositories[0]);
-        }
-    }
-    isVisible(repository) {
-        return this._repositories.find(r => r.repository === repository)?.selectionIndex !== -1;
-    }
-    toggleVisibility(repository, visible) {
-        if (typeof visible === 'undefined') {
-            visible = !this.isVisible(repository);
-        }
-        else if (this.isVisible(repository) === visible) {
-            return;
-        }
-        if (visible) {
-            this.visibleRepositories = [...this.visibleRepositories, repository];
-        }
-        else {
-            const index = this.visibleRepositories.indexOf(repository);
-            if (index > -1) {
-                this.visibleRepositories = [
-                    ...this.visibleRepositories.slice(0, index),
-                    ...this.visibleRepositories.slice(index + 1)
-                ];
-            }
-        }
-    }
-    toggleSortKey(sortKey) {
-        this._repositoriesSortKey = sortKey;
-        this._sortKeyContextKey.set(this._repositoriesSortKey);
-        this._repositories.sort(this.compareRepositories.bind(this));
-        this._onDidChangeRepositories.fire({ added: Iterable.empty(), removed: Iterable.empty() });
-    }
-    focus(repository) {
-        if (repository && !this.isVisible(repository)) {
-            return;
-        }
-        this._repositories.forEach(r => r.focused = r.repository === repository);
-        if (this._repositories.find(r => r.focused)) {
-            this._onDidFocusRepository.fire(repository);
-        }
-    }
-    compareRepositories(op1, op2) {
-        if (this._repositoriesSortKey === "discoveryTime" ) {
-            return op1.discoveryTime - op2.discoveryTime;
-        }
-        if (this._repositoriesSortKey === 'path' && op1.repository.provider.rootUri && op2.repository.provider.rootUri) {
-            return comparePaths(op1.repository.provider.rootUri.fsPath, op2.repository.provider.rootUri.fsPath);
-        }
-        const name1 = getRepositoryName(this.workspaceContextService, op1.repository);
-        const name2 = getRepositoryName(this.workspaceContextService, op2.repository);
-        const nameComparison = compareFileNames(name1, name2);
-        if (nameComparison === 0 && op1.repository.provider.rootUri && op2.repository.provider.rootUri) {
-            return comparePaths(op1.repository.provider.rootUri.fsPath, op2.repository.provider.rootUri.fsPath);
-        }
-        return nameComparison;
-    }
-    getMaxSelectionIndex() {
-        return this._repositories.length === 0 ? -1 :
-            Math.max(...( this._repositories.map(r => r.selectionIndex)));
-    }
-    getViewSortOrder() {
-        const sortOder = this.configurationService.getValue('scm.repositories.sortOrder');
-        switch (sortOder) {
-            case 'discovery time':
-                return "discoveryTime" ;
-            case 'name':
-                return "name" ;
-            case 'path':
-                return "path" ;
-            default:
-                return "discoveryTime" ;
-        }
-    }
-    insertRepositoryView(repositories, repositoryView) {
-        const index = binarySearch(repositories, repositoryView, this.compareRepositories.bind(this));
-        repositories.splice(index < 0 ? ~index : index, 0, repositoryView);
-    }
-    onWillSaveState() {
-        if (!this.didFinishLoading) {
-            return;
-        }
-        const all = ( this.repositories.map(r => getProviderStorageKey(r.provider)));
-        const visible = ( this.visibleRepositories.map(r => all.indexOf(getProviderStorageKey(r.provider))));
-        const raw = JSON.stringify({ all, sortKey: this._repositoriesSortKey, visible });
-        this.storageService.store('scm:view:visibleRepositories', raw, 1 , 1 );
-    }
-    eventuallyFinishLoading() {
-        this.finishLoading();
-    }
-    finishLoading() {
-        if (this.didFinishLoading) {
-            return;
-        }
-        this.didFinishLoading = true;
-        this.previousState = undefined;
-    }
-    dispose() {
-        this.disposables.dispose();
-        this._onDidChangeRepositories.dispose();
-        this._onDidSetVisibleRepositories.dispose();
-    }
-};
-SCMViewService.__decorator = ( __decorate([
-    debounce(5000)
-], SCMViewService.prototype, "eventuallyFinishLoading", null));
-SCMViewService = ( __decorate([
-    ( __param(0, ISCMService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IWorkspaceContextService))
-], SCMViewService));
-
-export { RepositoryContextKeys, SCMViewService };

package/vscode/src/vs/workbench/contrib/scm/browser/util.js

@@ -1,121 +0,0 @@
-import { basename } from 'vscode/vscode/vs/base/common/path';
-import { MenuItemAction } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { createAndFillInActionBarActions, createAndFillInContextMenuActions, createActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { equals } from 'vscode/vscode/vs/base/common/arrays';
-import { ActionViewItem } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems';
-import { renderLabelWithIcons } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
-import { reset } from 'vscode/vscode/vs/base/browser/dom';
-import { ResourceTree } from 'vscode/vscode/vs/base/common/resourceTree';
-
-function isSCMViewService(element) {
-    return Array.isArray(element.repositories) && Array.isArray(element.visibleRepositories);
-}
-function isSCMRepository(element) {
-    return !!element.provider && !!element.input;
-}
-function isSCMInput(element) {
-    return !!element.validateInput && typeof element.value === 'string';
-}
-function isSCMActionButton(element) {
-    return element.type === 'actionButton';
-}
-function isSCMResourceGroup(element) {
-    return !!element.provider && !!element.resources;
-}
-function isSCMResource(element) {
-    return !!element.sourceUri && isSCMResourceGroup(element.resourceGroup);
-}
-function isSCMResourceNode(element) {
-    return ResourceTree.isResourceNode(element) && isSCMResourceGroup(element.context);
-}
-function isSCMHistoryItemGroupTreeElement(element) {
-    return element.type === 'historyItemGroup';
-}
-function isSCMHistoryItemTreeElement(element) {
-    return element.type === 'allChanges' ||
-        element.type === 'historyItem';
-}
-function isSCMHistoryItemChangeTreeElement(element) {
-    return element.type === 'historyItemChange';
-}
-function isSCMHistoryItemChangeNode(element) {
-    return ResourceTree.isResourceNode(element) && isSCMHistoryItemTreeElement(element.context);
-}
-function isSCMViewSeparator(element) {
-    return element.type === 'separator';
-}
-function toDiffEditorArguments(uri, originalUri, modifiedUri) {
-    const basename$1 = basename(uri.fsPath);
-    const originalQuery = JSON.parse(originalUri.query);
-    const modifiedQuery = JSON.parse(modifiedUri.query);
-    const originalShortRef = originalQuery.ref.substring(0, 8).concat(originalQuery.ref.endsWith('^') ? '^' : '');
-    const modifiedShortRef = modifiedQuery.ref.substring(0, 8).concat(modifiedQuery.ref.endsWith('^') ? '^' : '');
-    return [originalUri, modifiedUri, `${basename$1} (${originalShortRef}) ↔ ${basename$1} (${modifiedShortRef})`, null];
-}
-const compareActions = (a, b) => {
-    if (a instanceof MenuItemAction && b instanceof MenuItemAction) {
-        return a.id === b.id && a.enabled === b.enabled && a.hideActions?.isHidden === b.hideActions?.isHidden;
-    }
-    return a.id === b.id && a.enabled === b.enabled;
-};
-function connectPrimaryMenu(menu, callback, primaryGroup) {
-    let cachedPrimary = [];
-    let cachedSecondary = [];
-    const updateActions = () => {
-        const primary = [];
-        const secondary = [];
-        createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, { primary, secondary }, primaryGroup);
-        if (equals(cachedPrimary, primary, compareActions) && equals(cachedSecondary, secondary, compareActions)) {
-            return;
-        }
-        cachedPrimary = primary;
-        cachedSecondary = secondary;
-        callback(primary, secondary);
-    };
-    updateActions();
-    return menu.onDidChange(updateActions);
-}
-function connectPrimaryMenuToInlineActionBar(menu, actionBar) {
-    return connectPrimaryMenu(menu, (primary) => {
-        actionBar.clear();
-        actionBar.push(primary, { icon: true, label: false });
-    }, 'inline');
-}
-function collectContextMenuActions(menu) {
-    const primary = [];
-    const actions = [];
-    createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, { primary, secondary: actions }, 'inline');
-    return actions;
-}
-class StatusBarAction extends Action {
-    constructor(command, commandService) {
-        super(`statusbaraction{${command.id}}`, command.title, '', true);
-        this.command = command;
-        this.commandService = commandService;
-        this.tooltip = command.tooltip || '';
-    }
-    run() {
-        return this.commandService.executeCommand(this.command.id, ...(this.command.arguments || []));
-    }
-}
-class StatusBarActionViewItem extends ActionViewItem {
-    constructor(action, options) {
-        super(null, action, { ...options, icon: false, label: true });
-    }
-    updateLabel() {
-        if (this.options.label && this.label) {
-            reset(this.label, ...renderLabelWithIcons(this.action.label));
-        }
-    }
-}
-function getActionViewItemProvider(instaService) {
-    return (action, options) => {
-        if (action instanceof StatusBarAction) {
-            return ( new StatusBarActionViewItem(action, options));
-        }
-        return createActionViewItem(instaService, action, options);
-    };
-}
-
-export { StatusBarAction, collectContextMenuActions, connectPrimaryMenu, connectPrimaryMenuToInlineActionBar, getActionViewItemProvider, isSCMActionButton, isSCMHistoryItemChangeNode, isSCMHistoryItemChangeTreeElement, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMInput, isSCMRepository, isSCMResource, isSCMResourceGroup, isSCMResourceNode, isSCMViewSeparator, isSCMViewService, toDiffEditorArguments };

package/vscode/src/vs/workbench/contrib/scm/common/quickDiffService.js

@@ -1,76 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isEqualOrParent } from 'vscode/vscode/vs/base/common/resources';
-import { score } from 'vscode/vscode/vs/editor/common/languageSelector';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-
-function createProviderComparer(uri) {
-    return (a, b) => {
-        if (a.rootUri && !b.rootUri) {
-            return -1;
-        }
-        else if (!a.rootUri && b.rootUri) {
-            return 1;
-        }
-        else if (!a.rootUri && !b.rootUri) {
-            return 0;
-        }
-        const aIsParent = isEqualOrParent(uri, a.rootUri);
-        const bIsParent = isEqualOrParent(uri, b.rootUri);
-        if (aIsParent && bIsParent) {
-            return a.rootUri.fsPath.length - b.rootUri.fsPath.length;
-        }
-        else if (aIsParent) {
-            return -1;
-        }
-        else if (bIsParent) {
-            return 1;
-        }
-        else {
-            return 0;
-        }
-    };
-}
-let QuickDiffService = class QuickDiffService extends Disposable {
-    constructor(uriIdentityService) {
-        super();
-        this.uriIdentityService = uriIdentityService;
-        this.quickDiffProviders = ( new Set());
-        this._onDidChangeQuickDiffProviders = this._register(( new Emitter()));
-        this.onDidChangeQuickDiffProviders = this._onDidChangeQuickDiffProviders.event;
-    }
-    addQuickDiffProvider(quickDiff) {
-        this.quickDiffProviders.add(quickDiff);
-        this._onDidChangeQuickDiffProviders.fire();
-        return {
-            dispose: () => {
-                this.quickDiffProviders.delete(quickDiff);
-                this._onDidChangeQuickDiffProviders.fire();
-            }
-        };
-    }
-    isQuickDiff(diff) {
-        return !!diff.originalResource && (typeof diff.label === 'string') && (typeof diff.isSCM === 'boolean');
-    }
-    async getQuickDiffs(uri, language = '', isSynchronized = false) {
-        const providers = Array.from(this.quickDiffProviders)
-            .filter(provider => !provider.rootUri || this.uriIdentityService.extUri.isEqualOrParent(uri, provider.rootUri))
-            .sort(createProviderComparer(uri));
-        const diffs = await Promise.all(( providers.map(async (provider) => {
-            const scoreValue = provider.selector ? score(provider.selector, uri, language, isSynchronized, undefined, undefined) : 10;
-            const diff = {
-                originalResource: scoreValue > 0 ? (await provider.getOriginalResource(uri)) ?? undefined : undefined,
-                label: provider.label,
-                isSCM: provider.isSCM
-            };
-            return diff;
-        })));
-        return diffs.filter(this.isQuickDiff);
-    }
-};
-QuickDiffService = ( __decorate([
-    ( __param(0, IUriIdentityService))
-], QuickDiffService));
-
-export { QuickDiffService };