@codingame/monaco-vscode-quickaccess-service-override 4.1.0 → 4.1.1

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,10 @@
+export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-quickaccess-service-override",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.1"
   }
 }

package/quickaccess.js

@@ -5,15 +5,15 @@ import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { StandaloneQuickInputService } from 'vscode/vscode/vs/editor/standalone/browser/quickInput/standaloneQuickInputService';
 import { StandaloneServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { QuickInputService } from 'vscode/vscode/vs/workbench/services/quickinput/browser/quickInputService';
+import { QuickInputService } from './vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { StandaloneCodeEditor } from 'vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor';
-import { CommandsQuickAccessProvider } from 'vscode/vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess';
-import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLineQuickAccess';
+import { CommandsQuickAccessProvider } from './vscode/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
+import './vscode/src/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLineQuickAccess.js';
 import 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoSymbolQuickAccess';
-import 'vscode/vscode/vs/workbench/browser/actions/quickAccessActions';
-import 'vscode/vscode/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution';
-import 'vscode/vscode/vs/workbench/contrib/url/browser/url.contribution';
+import './vscode/src/vs/workbench/browser/actions/quickAccessActions.js';
+import './vscode/src/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js';
+import './vscode/src/vs/workbench/contrib/url/browser/url.contribution.js';
 import 'vscode/vscode/vs/workbench/browser/workbench.contribution';
 
 let isKeybindingConfigurationVisible = () => {

package/vscode/src/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js

@@ -0,0 +1,25 @@
+import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
+import { AbstractCommandsQuickAccessProvider } from '../../../../platform/quickinput/browser/commandsQuickAccess.js';
+
+class AbstractEditorCommandsQuickAccessProvider extends AbstractCommandsQuickAccessProvider {
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(options, instantiationService, keybindingService, commandService, telemetryService, dialogService);
+    }
+    getCodeEditorCommandPicks() {
+        const activeTextEditorControl = this.activeTextEditorControl;
+        if (!activeTextEditorControl) {
+            return [];
+        }
+        const editorCommandPicks = [];
+        for (const editorAction of activeTextEditorControl.getSupportedActions()) {
+            editorCommandPicks.push({
+                commandId: editorAction.id,
+                commandAlias: editorAction.alias,
+                label: stripIcons(editorAction.label) || editorAction.id,
+            });
+        }
+        return editorCommandPicks;
+    }
+}
+
+export { AbstractEditorCommandsQuickAccessProvider };

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

@@ -0,0 +1,357 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString } from 'vscode/vscode/vs/base/common/filters';
+import { createSingleCallFunction } from 'vscode/vscode/vs/base/common/functional';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { LRUCache } from 'vscode/vscode/vs/base/common/map';
+import { TfIdfCalculator, normalizeTfIdfScores } from 'vscode/vscode/vs/base/common/tfIdf';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { PickerQuickAccessProvider } from 'vscode/vscode/vs/platform/quickinput/browser/pickerQuickAccess';
+import { WillSaveStateReason, IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var AbstractCommandsQuickAccessProvider_1, CommandsHistory_1;
+let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
+    static { AbstractCommandsQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '>'; }
+    static { this.TFIDF_THRESHOLD = 0.5; }
+    static { this.TFIDF_MAX_RESULTS = 5; }
+    static { this.WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString); }
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(AbstractCommandsQuickAccessProvider_1.PREFIX, options);
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.dialogService = dialogService;
+        this.commandsHistory = this._register(this.instantiationService.createInstance(CommandsHistory));
+        this.options = options;
+    }
+    async _getPicks(filter, _disposables, token, runOptions) {
+        const allCommandPicks = await this.getCommandPicks(token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const runTfidf = createSingleCallFunction(() => {
+            const tfidf = ( new TfIdfCalculator());
+            tfidf.updateDocuments(( allCommandPicks.map(commandPick => ({
+                key: commandPick.commandId,
+                textChunks: [this.getTfIdfChunk(commandPick)]
+            }))));
+            const result = tfidf.calculateScores(filter, token);
+            return normalizeTfIdfScores(result)
+                .filter(score => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD)
+                .slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
+        });
+        const filteredCommandPicks = [];
+        for (const commandPick of allCommandPicks) {
+            const labelHighlights = AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.label) ?? undefined;
+            const aliasHighlights = commandPick.commandAlias ? AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.commandAlias) ?? undefined : undefined;
+            if (labelHighlights || aliasHighlights) {
+                commandPick.highlights = {
+                    label: labelHighlights,
+                    detail: this.options.showAlias ? aliasHighlights : undefined
+                };
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter === commandPick.commandId) {
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter.length >= 3) {
+                const tfidf = runTfidf();
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const tfidfScore = tfidf.find(score => score.key === commandPick.commandId);
+                if (tfidfScore) {
+                    commandPick.tfIdfScore = tfidfScore.score;
+                    filteredCommandPicks.push(commandPick);
+                }
+            }
+        }
+        const mapLabelToCommand = ( new Map());
+        for (const commandPick of filteredCommandPicks) {
+            const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
+            if (existingCommandForLabel) {
+                commandPick.description = commandPick.commandId;
+                existingCommandForLabel.description = existingCommandForLabel.commandId;
+            }
+            else {
+                mapLabelToCommand.set(commandPick.label, commandPick);
+            }
+        }
+        filteredCommandPicks.sort((commandPickA, commandPickB) => {
+            if (commandPickA.tfIdfScore && commandPickB.tfIdfScore) {
+                if (commandPickA.tfIdfScore === commandPickB.tfIdfScore) {
+                    return commandPickA.label.localeCompare(commandPickB.label);
+                }
+                return commandPickB.tfIdfScore - commandPickA.tfIdfScore;
+            }
+            else if (commandPickA.tfIdfScore) {
+                return 1;
+            }
+            else if (commandPickB.tfIdfScore) {
+                return -1;
+            }
+            const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
+            const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
+            if (commandACounter && commandBCounter) {
+                return commandACounter > commandBCounter ? -1 : 1;
+            }
+            if (commandACounter) {
+                return -1;
+            }
+            if (commandBCounter) {
+                return 1;
+            }
+            if (this.options.suggestedCommandIds) {
+                const commandASuggestion = ( this.options.suggestedCommandIds.has(commandPickA.commandId));
+                const commandBSuggestion = ( this.options.suggestedCommandIds.has(commandPickB.commandId));
+                if (commandASuggestion && commandBSuggestion) {
+                    return 0;
+                }
+                if (commandASuggestion) {
+                    return -1;
+                }
+                if (commandBSuggestion) {
+                    return 1;
+                }
+            }
+            return commandPickA.label.localeCompare(commandPickB.label);
+        });
+        const commandPicks = [];
+        let addOtherSeparator = false;
+        let addSuggestedSeparator = true;
+        let addCommonlyUsedSeparator = !!this.options.suggestedCommandIds;
+        for (let i = 0; i < filteredCommandPicks.length; i++) {
+            const commandPick = filteredCommandPicks[i];
+            if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'recentlyUsed',
+                    "recently used"
+                )) });
+                addOtherSeparator = true;
+            }
+            if (addSuggestedSeparator && commandPick.tfIdfScore !== undefined) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'suggested',
+                    "similar commands"
+                )) });
+                addSuggestedSeparator = false;
+            }
+            if (addCommonlyUsedSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'commonlyUsed',
+                    "commonly used"
+                )) });
+                addOtherSeparator = true;
+                addCommonlyUsedSeparator = false;
+            }
+            if (addOtherSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && !this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'morecCommands',
+                    "other commands"
+                )) });
+                addOtherSeparator = false;
+            }
+            commandPicks.push(this.toCommandPick(commandPick, runOptions));
+        }
+        if (!this.hasAdditionalCommandPicks(filter, token)) {
+            return commandPicks;
+        }
+        return {
+            picks: commandPicks,
+            additionalPicks: (async () => {
+                const additionalCommandPicks = await this.getAdditionalCommandPicks(allCommandPicks, filteredCommandPicks, filter, token);
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const commandPicks = ( additionalCommandPicks.map(commandPick => this.toCommandPick(commandPick, runOptions)));
+                if (addSuggestedSeparator && commandPicks[0]?.type !== 'separator') {
+                    commandPicks.unshift({ type: 'separator', label: ( localizeWithPath(
+                        'vs/platform/quickinput/browser/commandsQuickAccess',
+                        'suggested',
+                        "similar commands"
+                    )) });
+                }
+                return commandPicks;
+            })()
+        };
+    }
+    toCommandPick(commandPick, runOptions) {
+        if (commandPick.type === 'separator') {
+            return commandPick;
+        }
+        const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
+        const ariaLabel = keybinding ?
+            ( localizeWithPath(
+                'vs/platform/quickinput/browser/commandsQuickAccess',
+                'commandPickAriaLabelWithKeybinding',
+                "{0}, {1}",
+                commandPick.label,
+                keybinding.getAriaLabel()
+            )) :
+            commandPick.label;
+        return {
+            ...commandPick,
+            ariaLabel,
+            detail: this.options.showAlias && commandPick.commandAlias !== commandPick.label ? commandPick.commandAlias : undefined,
+            keybinding,
+            accept: async () => {
+                this.commandsHistory.push(commandPick.commandId);
+                this.telemetryService.publicLog2('workbenchActionExecuted', {
+                    id: commandPick.commandId,
+                    from: runOptions?.from ?? 'quick open'
+                });
+                try {
+                    commandPick.args?.length
+                        ? await this.commandService.executeCommand(commandPick.commandId, ...commandPick.args)
+                        : await this.commandService.executeCommand(commandPick.commandId);
+                }
+                catch (error) {
+                    if (!isCancellationError(error)) {
+                        this.dialogService.error(( localizeWithPath(
+                            'vs/platform/quickinput/browser/commandsQuickAccess',
+                            'canNotRun',
+                            "Command '{0}' resulted in an error",
+                            commandPick.label
+                        )), toErrorMessage(error));
+                    }
+                }
+            }
+        };
+    }
+    getTfIdfChunk({ label, commandAlias, commandDescription }) {
+        let chunk = label;
+        if (commandAlias && commandAlias !== label) {
+            chunk += ` - ${commandAlias}`;
+        }
+        if (commandDescription && commandDescription.value !== label) {
+            chunk += ` - ${commandDescription.value === commandDescription.original ? commandDescription.value : `${commandDescription.value} (${commandDescription.original})`}`;
+        }
+        return chunk;
+    }
+};
+AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IDialogService))
+], AbstractCommandsQuickAccessProvider));
+let CommandsHistory = class CommandsHistory extends Disposable {
+    static { CommandsHistory_1 = this; }
+    static { this.DEFAULT_COMMANDS_HISTORY_LENGTH = 50; }
+    static { this.PREF_KEY_CACHE = 'commandPalette.mru.cache'; }
+    static { this.PREF_KEY_COUNTER = 'commandPalette.mru.counter'; }
+    static { this.counter = 1; }
+    static { this.hasChanges = false; }
+    constructor(storageService, configurationService, logService) {
+        super();
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.configuredCommandsHistoryLength = 0;
+        this.updateConfiguration();
+        this.load();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
+        this._register(this.storageService.onWillSaveState(e => {
+            if (e.reason === WillSaveStateReason.SHUTDOWN) {
+                this.saveState();
+            }
+        }));
+    }
+    updateConfiguration(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.history')) {
+            return;
+        }
+        this.configuredCommandsHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(this.configurationService);
+        if (CommandsHistory_1.cache && CommandsHistory_1.cache.limit !== this.configuredCommandsHistoryLength) {
+            CommandsHistory_1.cache.limit = this.configuredCommandsHistoryLength;
+            CommandsHistory_1.hasChanges = true;
+        }
+    }
+    load() {
+        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
+        let serializedCache;
+        if (raw) {
+            try {
+                serializedCache = JSON.parse(raw);
+            }
+            catch (error) {
+                this.logService.error(`[CommandsHistory] invalid data: ${error}`);
+            }
+        }
+        const cache = CommandsHistory_1.cache = ( new LRUCache(this.configuredCommandsHistoryLength, 1));
+        if (serializedCache) {
+            let entries;
+            if (serializedCache.usesLRU) {
+                entries = serializedCache.entries;
+            }
+            else {
+                entries = serializedCache.entries.sort((a, b) => a.value - b.value);
+            }
+            entries.forEach(entry => cache.set(entry.key, entry.value));
+        }
+        CommandsHistory_1.counter = this.storageService.getNumber(CommandsHistory_1.PREF_KEY_COUNTER, 0 , CommandsHistory_1.counter);
+    }
+    push(commandId) {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        CommandsHistory_1.cache.set(commandId, CommandsHistory_1.counter++);
+        CommandsHistory_1.hasChanges = true;
+    }
+    peek(commandId) {
+        return CommandsHistory_1.cache?.peek(commandId);
+    }
+    saveState() {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        if (!CommandsHistory_1.hasChanges) {
+            return;
+        }
+        const serializedCache = { usesLRU: true, entries: [] };
+        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
+        this.storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
+        this.storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
+        CommandsHistory_1.hasChanges = false;
+    }
+    static getConfiguredCommandHistoryLength(configurationService) {
+        const config = configurationService.getValue();
+        const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
+        if (typeof configuredCommandHistoryLength === 'number') {
+            return configuredCommandHistoryLength;
+        }
+        return CommandsHistory_1.DEFAULT_COMMANDS_HISTORY_LENGTH;
+    }
+    static clearHistory(configurationService, storageService) {
+        const commandHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(configurationService);
+        CommandsHistory_1.cache = ( new LRUCache(commandHistoryLength));
+        CommandsHistory_1.counter = 1;
+        CommandsHistory_1.hasChanges = true;
+    }
+};
+CommandsHistory = CommandsHistory_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ILogService))
+], CommandsHistory));
+
+export { AbstractCommandsQuickAccessProvider, CommandsHistory };

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

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { Extensions } from 'vscode/vscode/vs/platform/quickinput/common/quickAccess';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
+
+var HelpQuickAccessProvider_1;
+let HelpQuickAccessProvider = class HelpQuickAccessProvider {
+    static { HelpQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '?'; }
+    constructor(quickInputService, keybindingService) {
+        this.quickInputService = quickInputService;
+        this.keybindingService = keybindingService;
+        this.registry = ( Registry.as(Extensions.Quickaccess));
+    }
+    provide(picker) {
+        const disposables = ( new DisposableStore());
+        disposables.add(picker.onDidAccept(() => {
+            const [item] = picker.selectedItems;
+            if (item) {
+                this.quickInputService.quickAccess.show(item.prefix, { preserveValue: true });
+            }
+        }));
+        disposables.add(picker.onDidChangeValue(value => {
+            const providerDescriptor = this.registry.getQuickAccessProvider(value.substr(HelpQuickAccessProvider_1.PREFIX.length));
+            if (providerDescriptor && providerDescriptor.prefix && providerDescriptor.prefix !== HelpQuickAccessProvider_1.PREFIX) {
+                this.quickInputService.quickAccess.show(providerDescriptor.prefix, { preserveValue: true });
+            }
+        }));
+        picker.items = this.getQuickAccessProviders().filter(p => p.prefix !== HelpQuickAccessProvider_1.PREFIX);
+        return disposables;
+    }
+    getQuickAccessProviders() {
+        const providers = this.registry
+            .getQuickAccessProviders()
+            .sort((providerA, providerB) => providerA.prefix.localeCompare(providerB.prefix))
+            .flatMap(provider => this.createPicks(provider));
+        return providers;
+    }
+    createPicks(provider) {
+        return ( provider.helpEntries.map(helpEntry => {
+            const prefix = helpEntry.prefix || provider.prefix;
+            const label = prefix || '\u2026' ;
+            return {
+                prefix,
+                label,
+                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
+                ariaLabel: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/helpQuickAccess',
+                    'helpPickAriaLabel',
+                    "{0}, {1}",
+                    label,
+                    helpEntry.description
+                )),
+                description: helpEntry.description
+            };
+        }));
+    }
+};
+HelpQuickAccessProvider = HelpQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IKeybindingService))
+], HelpQuickAccessProvider));
+
+export { HelpQuickAccessProvider };