@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalProfileService.js

@@ -1,218 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { AutoOpenBarrier } from 'monaco-editor/esm/vs/base/common/async.js';
-import { throttle } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isWeb, isWindows, isMacintosh, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { registerTerminalDefaultProfileConfiguration } from '../../../../platform/terminal/common/terminalPlatformConfiguration.js';
-import { terminalProfileArgsMatch, terminalIconsEqual } from '../../../../platform/terminal/common/terminalProfiles.js';
-import { ITerminalInstanceService } from './terminal.js';
-import { refreshTerminalActions } from './terminalActions.js';
-import { TerminalContextKeys } from '../common/terminalContextKey.js';
-import { ITerminalContributionService } from '../common/terminalExtensionPoints.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
-let TerminalProfileService = class TerminalProfileService extends Disposable {
-    get onDidChangeAvailableProfiles() { return this._onDidChangeAvailableProfiles.event; }
-    get profilesReady() { return this._profilesReadyPromise; }
-    get availableProfiles() {
-        if (!this._platformConfigJustRefreshed) {
-            this.refreshAvailableProfiles();
-        }
-        return this._availableProfiles || [];
-    }
-    get contributedProfiles() {
-        return this._contributedProfiles || [];
-    }
-    constructor(_contextKeyService, _configurationService, _terminalContributionService, _extensionService, _remoteAgentService, _environmentService, _terminalInstanceService) {
-        super();
-        this._contextKeyService = _contextKeyService;
-        this._configurationService = _configurationService;
-        this._terminalContributionService = _terminalContributionService;
-        this._extensionService = _extensionService;
-        this._remoteAgentService = _remoteAgentService;
-        this._environmentService = _environmentService;
-        this._terminalInstanceService = _terminalInstanceService;
-        this._contributedProfiles = [];
-        this._platformConfigJustRefreshed = false;
-        this._profileProviders = ( new Map());
-        this._onDidChangeAvailableProfiles = this._register(( new Emitter()));
-        this._extensionService.onDidChangeExtensions(() => this.refreshAvailableProfiles());
-        this._webExtensionContributedProfileContextKey = TerminalContextKeys.webExtensionContributedProfile.bindTo(this._contextKeyService);
-        this._updateWebContextKey();
-        this._profilesReadyPromise = this._remoteAgentService.getEnvironment()
-            .then(() => {
-            this._profilesReadyBarrier = ( new AutoOpenBarrier(20000));
-            return this._profilesReadyBarrier.wait().then(() => { });
-        });
-        this.refreshAvailableProfiles();
-        this._setupConfigListener();
-    }
-    async _setupConfigListener() {
-        const platformKey = await this.getPlatformKey();
-        this._configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration("terminal.integrated.defaultProfile."  + platformKey) ||
-                e.affectsConfiguration("terminal.integrated.profiles."  + platformKey) ||
-                e.affectsConfiguration("terminal.integrated.useWslProfiles" )) {
-                if (e.source !== 7 ) {
-                    this.refreshAvailableProfiles();
-                    this._platformConfigJustRefreshed = false;
-                }
-                else {
-                    this._platformConfigJustRefreshed = true;
-                }
-            }
-        });
-    }
-    getDefaultProfileName() {
-        return this._defaultProfileName;
-    }
-    getDefaultProfile(os) {
-        let defaultProfileName;
-        if (os) {
-            defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${this._getOsKey(os)}`);
-            if (!defaultProfileName || typeof defaultProfileName !== 'string') {
-                return undefined;
-            }
-        }
-        else {
-            defaultProfileName = this._defaultProfileName;
-        }
-        if (!defaultProfileName) {
-            return undefined;
-        }
-        return this.availableProfiles.find(e => e.profileName === defaultProfileName && !e.isAutoDetected);
-    }
-    _getOsKey(os) {
-        switch (os) {
-            case 3 : return 'linux';
-            case 2 : return 'osx';
-            case 1 : return 'windows';
-        }
-    }
-    refreshAvailableProfiles() {
-        this._refreshAvailableProfilesNow();
-    }
-    async _refreshAvailableProfilesNow() {
-        const profiles = await this._detectProfiles(true);
-        const profilesChanged = !(equals(profiles, this._availableProfiles, profilesEqual));
-        const contributedProfilesChanged = await this._updateContributedProfiles();
-        if (profilesChanged || contributedProfilesChanged) {
-            this._availableProfiles = profiles;
-            this._onDidChangeAvailableProfiles.fire(this._availableProfiles);
-            this._profilesReadyBarrier.open();
-            this._updateWebContextKey();
-            await this._refreshPlatformConfig(this._availableProfiles);
-        }
-    }
-    async _updateContributedProfiles() {
-        const platformKey = await this.getPlatformKey();
-        const excludedContributedProfiles = [];
-        const configProfiles = this._configurationService.getValue("terminal.integrated.profiles."  + platformKey);
-        for (const [profileName, value] of Object.entries(configProfiles)) {
-            if (value === null) {
-                excludedContributedProfiles.push(profileName);
-            }
-        }
-        const filteredContributedProfiles = Array.from(this._terminalContributionService.terminalProfiles.filter(p => !excludedContributedProfiles.includes(p.title)));
-        const contributedProfilesChanged = !equals(filteredContributedProfiles, this._contributedProfiles, contributedProfilesEqual);
-        this._contributedProfiles = filteredContributedProfiles;
-        return contributedProfilesChanged;
-    }
-    getContributedProfileProvider(extensionIdentifier, id) {
-        const extMap = this._profileProviders.get(extensionIdentifier);
-        return extMap?.get(id);
-    }
-    async _detectProfiles(includeDetectedProfiles) {
-        const primaryBackend = await this._terminalInstanceService.getBackend(this._environmentService.remoteAuthority);
-        if (!primaryBackend) {
-            return this._availableProfiles || [];
-        }
-        const platform = await this.getPlatformKey();
-        this._defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${platform}`) ?? undefined;
-        return primaryBackend.getProfiles(this._configurationService.getValue(`${"terminal.integrated.profiles." }${platform}`), this._defaultProfileName, includeDetectedProfiles);
-    }
-    _updateWebContextKey() {
-        this._webExtensionContributedProfileContextKey.set(isWeb && this._contributedProfiles.length > 0);
-    }
-    async _refreshPlatformConfig(profiles) {
-        const env = await this._remoteAgentService.getEnvironment();
-        registerTerminalDefaultProfileConfiguration({ os: env?.os || OS, profiles }, this._contributedProfiles);
-        refreshTerminalActions(profiles);
-    }
-    async getPlatformKey() {
-        const env = await this._remoteAgentService.getEnvironment();
-        if (env) {
-            return env.os === 1  ? 'windows' : (env.os === 2  ? 'osx' : 'linux');
-        }
-        return isWindows ? 'windows' : (isMacintosh ? 'osx' : 'linux');
-    }
-    registerTerminalProfileProvider(extensionIdentifier, id, profileProvider) {
-        let extMap = this._profileProviders.get(extensionIdentifier);
-        if (!extMap) {
-            extMap = ( new Map());
-            this._profileProviders.set(extensionIdentifier, extMap);
-        }
-        extMap.set(id, profileProvider);
-        return toDisposable(() => this._profileProviders.delete(id));
-    }
-    async registerContributedProfile(args) {
-        const platformKey = await this.getPlatformKey();
-        const profilesConfig = await this._configurationService.getValue(`${"terminal.integrated.profiles." }${platformKey}`);
-        if (typeof profilesConfig === 'object') {
-            const newProfile = {
-                extensionIdentifier: args.extensionIdentifier,
-                icon: args.options.icon,
-                id: args.id,
-                title: args.title,
-                color: args.options.color
-            };
-            profilesConfig[args.title] = newProfile;
-        }
-        await this._configurationService.updateValue(`${"terminal.integrated.profiles." }${platformKey}`, profilesConfig, 2 );
-        return;
-    }
-    async getContributedDefaultProfile(shellLaunchConfig) {
-        if (shellLaunchConfig && !shellLaunchConfig.extHostTerminalId && !('executable' in shellLaunchConfig)) {
-            const key = await this.getPlatformKey();
-            const defaultProfileName = this._configurationService.getValue(`${"terminal.integrated.defaultProfile." }${key}`);
-            const contributedDefaultProfile = this.contributedProfiles.find(p => p.title === defaultProfileName);
-            return contributedDefaultProfile;
-        }
-        return undefined;
-    }
-};
-TerminalProfileService.__decorator = ( __decorate([
-    throttle(2000)
-], TerminalProfileService.prototype, "refreshAvailableProfiles", null));
-TerminalProfileService = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ITerminalContributionService)),
-    ( __param(3, IExtensionService)),
-    ( __param(4, IRemoteAgentService)),
-    ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, ITerminalInstanceService))
-], TerminalProfileService));
-function profilesEqual(one, other) {
-    return one.profileName === other.profileName &&
-        terminalProfileArgsMatch(one.args, other.args) &&
-        one.color === other.color &&
-        terminalIconsEqual(one.icon, other.icon) &&
-        one.isAutoDetected === other.isAutoDetected &&
-        one.isDefault === other.isDefault &&
-        one.overrideName === other.overrideName &&
-        one.path === other.path;
-}
-function contributedProfilesEqual(one, other) {
-    return one.extensionIdentifier === other.extensionIdentifier &&
-        one.color === other.color &&
-        one.icon === other.icon &&
-        one.id === other.id &&
-        one.title === other.title;
-}
-export { TerminalProfileService };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalQuickAccess.js

@@ -1,146 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
-import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { ITerminalEditorService, ITerminalGroupService } from './terminal.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { renameTerminalIcon, killTerminalIcon } from './terminalIcons.js';
-import { getIconId, getColorClass, getUriClasses } from './terminalIcon.js';
-import { terminalStrings } from '../common/terminalStrings.js';
-import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-var TerminalQuickAccessProvider_1;
-let terminalPicks = [];
-let TerminalQuickAccessProvider = class TerminalQuickAccessProvider extends PickerQuickAccessProvider {
-    static { TerminalQuickAccessProvider_1 = this; }
-    static { this.PREFIX = 'term '; }
-    constructor(_editorService, _terminalService, _terminalEditorService, _terminalGroupService, _commandService, _themeService, _instantiationService) {
-        super(TerminalQuickAccessProvider_1.PREFIX, { canAcceptInBackground: true });
-        this._editorService = _editorService;
-        this._terminalService = _terminalService;
-        this._terminalEditorService = _terminalEditorService;
-        this._terminalGroupService = _terminalGroupService;
-        this._commandService = _commandService;
-        this._themeService = _themeService;
-        this._instantiationService = _instantiationService;
-    }
-    _getPicks(filter) {
-        terminalPicks = [];
-        terminalPicks.push({ type: 'separator', label: 'panel' });
-        const terminalGroups = this._terminalGroupService.groups;
-        for (let groupIndex = 0; groupIndex < terminalGroups.length; groupIndex++) {
-            const terminalGroup = terminalGroups[groupIndex];
-            for (let terminalIndex = 0; terminalIndex < terminalGroup.terminalInstances.length; terminalIndex++) {
-                const terminal = terminalGroup.terminalInstances[terminalIndex];
-                const pick = this._createPick(terminal, terminalIndex, filter, { groupIndex, groupSize: terminalGroup.terminalInstances.length });
-                if (pick) {
-                    terminalPicks.push(pick);
-                }
-            }
-        }
-        if (terminalPicks.length > 0) {
-            terminalPicks.push({ type: 'separator', label: 'editor' });
-        }
-        const terminalEditors = this._terminalEditorService.instances;
-        for (let editorIndex = 0; editorIndex < terminalEditors.length; editorIndex++) {
-            const term = terminalEditors[editorIndex];
-            term.target = TerminalLocation.Editor;
-            const pick = this._createPick(term, editorIndex, filter);
-            if (pick) {
-                terminalPicks.push(pick);
-            }
-        }
-        if (terminalPicks.length > 0) {
-            terminalPicks.push({ type: 'separator' });
-        }
-        const createTerminalLabel = ( localize("workbench.action.terminal.newplus", "Create New Terminal"));
-        terminalPicks.push({
-            label: `$(plus) ${createTerminalLabel}`,
-            ariaLabel: createTerminalLabel,
-            accept: () => this._commandService.executeCommand("workbench.action.terminal.new" )
-        });
-        const createWithProfileLabel = ( localize(
-            "workbench.action.terminal.newWithProfilePlus",
-            "Create New Terminal With Profile"
-        ));
-        terminalPicks.push({
-            label: `$(plus) ${createWithProfileLabel}`,
-            ariaLabel: createWithProfileLabel,
-            accept: () => this._commandService.executeCommand("workbench.action.terminal.newWithProfile" )
-        });
-        return terminalPicks;
-    }
-    _createPick(terminal, terminalIndex, filter, groupInfo) {
-        const iconId = this._instantiationService.invokeFunction(getIconId, terminal);
-        const index = groupInfo
-            ? (groupInfo.groupSize > 1
-                ? `${groupInfo.groupIndex + 1}.${terminalIndex + 1}`
-                : `${groupInfo.groupIndex + 1}`)
-            : `${terminalIndex + 1}`;
-        const label = `$(${iconId}) ${index}: ${terminal.title}`;
-        const iconClasses = [];
-        const colorClass = getColorClass(terminal);
-        if (colorClass) {
-            iconClasses.push(colorClass);
-        }
-        const uriClasses = getUriClasses(terminal, this._themeService.getColorTheme().type);
-        if (uriClasses) {
-            iconClasses.push(...uriClasses);
-        }
-        const highlights = matchesFuzzy(filter, label, true);
-        if (highlights) {
-            return {
-                label,
-                description: terminal.description,
-                highlights: { label: highlights },
-                buttons: [
-                    {
-                        iconClass: ThemeIcon.asClassName(renameTerminalIcon),
-                        tooltip: ( localize('renameTerminal', "Rename Terminal"))
-                    },
-                    {
-                        iconClass: ThemeIcon.asClassName(killTerminalIcon),
-                        tooltip: terminalStrings.kill.value
-                    }
-                ],
-                iconClasses,
-                trigger: buttonIndex => {
-                    switch (buttonIndex) {
-                        case 0:
-                            this._commandService.executeCommand("workbench.action.terminal.rename" , terminal);
-                            return TriggerAction.NO_ACTION;
-                        case 1:
-                            this._terminalService.safeDisposeTerminal(terminal);
-                            return TriggerAction.REMOVE_ITEM;
-                    }
-                    return TriggerAction.NO_ACTION;
-                },
-                accept: (keyMod, event) => {
-                    if (terminal.target === TerminalLocation.Editor) {
-                        const existingEditors = this._editorService.findEditors(terminal.resource);
-                        this._terminalEditorService.openEditor(terminal, { viewColumn: existingEditors?.[0].groupId });
-                        this._terminalEditorService.setActiveInstance(terminal);
-                    }
-                    else {
-                        this._terminalGroupService.showPanel(!event.inBackground);
-                        this._terminalGroupService.setActiveInstance(terminal);
-                    }
-                }
-            };
-        }
-        return undefined;
-    }
-};
-TerminalQuickAccessProvider = TerminalQuickAccessProvider_1 = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, ITerminalEditorService)),
-    ( __param(2, ITerminalEditorService)),
-    ( __param(3, ITerminalGroupService)),
-    ( __param(4, ICommandService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IInstantiationService))
-], TerminalQuickAccessProvider));
-export { TerminalQuickAccessProvider };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalRunRecentQuickPick.js

@@ -1,269 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Toggle } from 'monaco-editor/esm/vs/base/browser/ui/toggle/toggle.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { collapseTildePath } from '../../../../platform/terminal/common/terminalEnvironment.js';
-import { asCssVariable, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { commandHistoryRemoveIcon, commandHistoryOutputIcon, commandHistoryFuzzySearchIcon } from './terminalIcons.js';
-import { getCommandHistory, getShellFileHistory, getDirectoryHistory } from '../common/history.js';
-import { terminalStrings } from '../common/terminalStrings.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { fromNow } from '../../../../base/common/date.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { showWithPinnedItems } from '../../../../platform/quickinput/browser/quickPickPin.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-var TerminalOutputProvider_1;
-async function showRunRecentQuickPick(accessor, instance, terminalInRunCommandPicker, type, filterMode, value) {
-    if (!instance.xterm) {
-        return;
-    }
-    const editorService = accessor.get(IEditorService);
-    const instantiationService = accessor.get(IInstantiationService);
-    const quickInputService = accessor.get(IQuickInputService);
-    const storageService = accessor.get(IStorageService);
-    const runRecentStorageKey = `${"terminal.pinnedRecentCommands" }.${instance.shellType}`;
-    let placeholder;
-    let items = [];
-    const commandMap = ( new Set());
-    const removeFromCommandHistoryButton = {
-        iconClass: ThemeIcon.asClassName(commandHistoryRemoveIcon),
-        tooltip: ( localize('removeCommand', "Remove from Command History"))
-    };
-    const commandOutputButton = {
-        iconClass: ThemeIcon.asClassName(commandHistoryOutputIcon),
-        tooltip: ( localize('viewCommandOutput', "View Command Output")),
-        alwaysVisible: false
-    };
-    if (type === 'command') {
-        placeholder = isMacintosh ? ( localize(
-            'selectRecentCommandMac',
-            'Select a command to run (hold Option-key to edit the command)'
-        )) : ( localize(
-            'selectRecentCommand',
-            'Select a command to run (hold Alt-key to edit the command)'
-        ));
-        const cmdDetection = instance.capabilities.get(2 );
-        const commands = cmdDetection?.commands;
-        const executingCommand = cmdDetection?.executingCommand;
-        if (executingCommand) {
-            commandMap.add(executingCommand);
-        }
-        function formatLabel(label) {
-            return label
-                .replace(/\r?\n/g, '\u23CE')
-                .replace(/\s\s\s+/g, '\u22EF');
-        }
-        if (commands && commands.length > 0) {
-            for (const entry of commands) {
-                const label = entry.command.trim();
-                if (label.length === 0 || ( commandMap.has(label))) {
-                    continue;
-                }
-                let description = collapseTildePath(entry.cwd, instance.userHome, instance.os === 1  ? '\\' : '/');
-                if (entry.exitCode) {
-                    if (entry.exitCode === -1) {
-                        description += ' failed';
-                    }
-                    else {
-                        description += ` exitCode: ${entry.exitCode}`;
-                    }
-                }
-                description = description.trim();
-                const buttons = [commandOutputButton];
-                const lastItem = items.length > 0 ? items[items.length - 1] : undefined;
-                if (lastItem?.type !== 'separator' && lastItem?.label === label) {
-                    lastItem.id = ( entry.timestamp.toString());
-                    lastItem.description = description;
-                    continue;
-                }
-                items.push({
-                    label: formatLabel(label),
-                    rawLabel: label,
-                    description,
-                    id: ( entry.timestamp.toString()),
-                    command: entry,
-                    buttons: entry.hasOutput() ? buttons : undefined
-                });
-                commandMap.add(label);
-            }
-            items = items.reverse();
-        }
-        if (executingCommand) {
-            items.unshift({
-                label: formatLabel(executingCommand),
-                rawLabel: executingCommand,
-                description: cmdDetection.cwd
-            });
-        }
-        if (items.length > 0) {
-            items.unshift({ type: 'separator', label: terminalStrings.currentSessionCategory });
-        }
-        const history = instantiationService.invokeFunction(getCommandHistory);
-        const previousSessionItems = [];
-        for (const [label, info] of history.entries) {
-            if (!( commandMap.has(label)) && info.shellType === instance.shellType) {
-                previousSessionItems.unshift({
-                    label: formatLabel(label),
-                    rawLabel: label,
-                    buttons: [removeFromCommandHistoryButton]
-                });
-                commandMap.add(label);
-            }
-        }
-        if (previousSessionItems.length > 0) {
-            items.push({ type: 'separator', label: terminalStrings.previousSessionCategory }, ...previousSessionItems);
-        }
-        const shellFileHistory = await instantiationService.invokeFunction(getShellFileHistory, instance.shellType);
-        const dedupedShellFileItems = [];
-        for (const label of shellFileHistory) {
-            if (!( commandMap.has(label))) {
-                dedupedShellFileItems.unshift({
-                    label: formatLabel(label),
-                    rawLabel: label
-                });
-            }
-        }
-        if (dedupedShellFileItems.length > 0) {
-            items.push({ type: 'separator', label: ( localize('shellFileHistoryCategory', '{0} history', instance.shellType)) }, ...dedupedShellFileItems);
-        }
-    }
-    else {
-        placeholder = isMacintosh
-            ? ( localize(
-            'selectRecentDirectoryMac',
-            'Select a directory to go to (hold Option-key to edit the command)'
-        ))
-            : ( localize(
-            'selectRecentDirectory',
-            'Select a directory to go to (hold Alt-key to edit the command)'
-        ));
-        const cwds = instance.capabilities.get(0 )?.cwds || [];
-        if (cwds && cwds.length > 0) {
-            for (const label of cwds) {
-                items.push({ label, rawLabel: label });
-            }
-            items = items.reverse();
-            items.unshift({ type: 'separator', label: terminalStrings.currentSessionCategory });
-        }
-        const history = instantiationService.invokeFunction(getDirectoryHistory);
-        const previousSessionItems = [];
-        for (const [label, info] of history.entries) {
-            if ((info === null || info.remoteAuthority === instance.remoteAuthority) && !cwds.includes(label)) {
-                previousSessionItems.unshift({
-                    label,
-                    rawLabel: label,
-                    buttons: [removeFromCommandHistoryButton]
-                });
-            }
-        }
-        if (previousSessionItems.length > 0) {
-            items.push({ type: 'separator', label: terminalStrings.previousSessionCategory }, ...previousSessionItems);
-        }
-    }
-    if (items.length === 0) {
-        return;
-    }
-    const fuzzySearchToggle = ( new Toggle({
-        title: 'Fuzzy search',
-        icon: commandHistoryFuzzySearchIcon,
-        isChecked: filterMode === 'fuzzy',
-        inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
-        inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
-        inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground)
-    }));
-    fuzzySearchToggle.onChange(() => {
-        instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, fuzzySearchToggle.checked ? 'fuzzy' : 'contiguous', quickPick.value);
-    });
-    const outputProvider = instantiationService.createInstance(TerminalOutputProvider);
-    const quickPick = quickInputService.createQuickPick();
-    const originalItems = items;
-    quickPick.items = [...originalItems];
-    quickPick.sortByLabel = false;
-    quickPick.placeholder = placeholder;
-    quickPick.matchOnLabelMode = filterMode || 'contiguous';
-    quickPick.toggles = [fuzzySearchToggle];
-    quickPick.onDidTriggerItemButton(async (e) => {
-        if (e.button === removeFromCommandHistoryButton) {
-            if (type === 'command') {
-                instantiationService.invokeFunction(getCommandHistory)?.remove(e.item.label);
-            }
-            else {
-                instantiationService.invokeFunction(getDirectoryHistory)?.remove(e.item.label);
-            }
-        }
-        else if (e.button === commandOutputButton) {
-            const selectedCommand = e.item.command;
-            const output = selectedCommand?.getOutput();
-            if (output && selectedCommand?.command) {
-                const textContent = await outputProvider.provideTextContent(( URI.from({
-                    scheme: TerminalOutputProvider.scheme,
-                    path: `${selectedCommand.command}... ${fromNow(selectedCommand.timestamp, true)}`,
-                    fragment: output,
-                    query: `terminal-output-${selectedCommand.timestamp}-${instance.instanceId}`
-                })));
-                if (textContent) {
-                    await editorService.openEditor({
-                        resource: textContent.uri
-                    });
-                }
-            }
-        }
-        await instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, filterMode, value);
-    });
-    quickPick.onDidChangeValue(async (value) => {
-        if (!value) {
-            await instantiationService.invokeFunction(showRunRecentQuickPick, instance, terminalInRunCommandPicker, type, filterMode, value);
-        }
-    });
-    quickPick.onDidAccept(async () => {
-        const result = quickPick.activeItems[0];
-        let text;
-        if (type === 'cwd') {
-            text = `cd ${await instance.preparePathForShell(result.rawLabel)}`;
-        }
-        else {
-            text = result.rawLabel;
-        }
-        quickPick.hide();
-        instance.runCommand(text, !quickPick.keyMods.alt);
-        if (quickPick.keyMods.alt) {
-            instance.focus();
-        }
-    });
-    if (value) {
-        quickPick.value = value;
-    }
-    return ( new Promise(r => {
-        terminalInRunCommandPicker.set(true);
-        showWithPinnedItems(storageService, runRecentStorageKey, quickPick, true);
-        quickPick.onDidHide(() => {
-            terminalInRunCommandPicker.set(false);
-            r();
-        });
-    }));
-}
-let TerminalOutputProvider = class TerminalOutputProvider {
-    static { TerminalOutputProvider_1 = this; }
-    static { this.scheme = 'TERMINAL_OUTPUT'; }
-    constructor(textModelResolverService, _modelService) {
-        this._modelService = _modelService;
-        textModelResolverService.registerTextModelContentProvider(TerminalOutputProvider_1.scheme, this);
-    }
-    async provideTextContent(resource) {
-        const existing = this._modelService.getModel(resource);
-        if (existing && !existing.isDisposed()) {
-            return existing;
-        }
-        return this._modelService.createModel(resource.fragment, null, resource, false);
-    }
-};
-TerminalOutputProvider = TerminalOutputProvider_1 = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, IModelService))
-], TerminalOutputProvider));
-export { showRunRecentQuickPick };