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

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

@@ -1,278 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { getUriClasses, getColorClass, getColorStyleElement } from './terminalIcon.js';
-import { configureTerminalProfileIcon } from './terminalIcons.js';
-import * as nls from 'monaco-editor/esm/vs/nls.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 { ITerminalProfileService, ITerminalProfileResolverService } from '../common/terminal.js';
-import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-let TerminalProfileQuickpick = class TerminalProfileQuickpick {
-    constructor(_terminalProfileService, _terminalProfileResolverService, _configurationService, _quickInputService, _themeService, _notificationService) {
-        this._terminalProfileService = _terminalProfileService;
-        this._terminalProfileResolverService = _terminalProfileResolverService;
-        this._configurationService = _configurationService;
-        this._quickInputService = _quickInputService;
-        this._themeService = _themeService;
-        this._notificationService = _notificationService;
-    }
-    async showAndGetResult(type) {
-        const platformKey = await this._terminalProfileService.getPlatformKey();
-        const profilesKey = "terminal.integrated.profiles."  + platformKey;
-        const result = await this._createAndShow(type);
-        const defaultProfileKey = `${"terminal.integrated.defaultProfile." }${platformKey}`;
-        if (!result) {
-            return;
-        }
-        if (type === 'setDefault') {
-            if ('command' in result.profile) {
-                return;
-            }
-            else if ('id' in result.profile) {
-                await this._configurationService.updateValue(defaultProfileKey, result.profile.title, 2 );
-                return {
-                    config: {
-                        extensionIdentifier: result.profile.extensionIdentifier,
-                        id: result.profile.id,
-                        title: result.profile.title,
-                        options: {
-                            color: result.profile.color,
-                            icon: result.profile.icon
-                        }
-                    },
-                    keyMods: result.keyMods
-                };
-            }
-            if ('isAutoDetected' in result.profile) {
-                const profilesConfig = await this._configurationService.getValue(profilesKey);
-                if (typeof profilesConfig === 'object') {
-                    const newProfile = {
-                        path: result.profile.path
-                    };
-                    if (result.profile.args) {
-                        newProfile.args = result.profile.args;
-                    }
-                    profilesConfig[result.profile.profileName] = newProfile;
-                }
-                await this._configurationService.updateValue(profilesKey, profilesConfig, 2 );
-            }
-            await this._configurationService.updateValue(defaultProfileKey, result.profileName, 2 );
-        }
-        else if (type === 'createInstance') {
-            if ('id' in result.profile) {
-                return {
-                    config: {
-                        extensionIdentifier: result.profile.extensionIdentifier,
-                        id: result.profile.id,
-                        title: result.profile.title,
-                        options: {
-                            icon: result.profile.icon,
-                            color: result.profile.color,
-                        }
-                    },
-                    keyMods: result.keyMods
-                };
-            }
-            else {
-                return { config: result.profile, keyMods: result.keyMods };
-            }
-        }
-        return 'profileName' in result.profile ? result.profile.profileName : result.profile.title;
-    }
-    async _createAndShow(type) {
-        const platformKey = await this._terminalProfileService.getPlatformKey();
-        const profiles = this._terminalProfileService.availableProfiles;
-        const profilesKey = "terminal.integrated.profiles."  + platformKey;
-        const defaultProfileName = this._terminalProfileService.getDefaultProfileName();
-        let keyMods;
-        const options = {
-            placeHolder: type === 'createInstance' ? ( nls.localize(
-                'terminal.integrated.selectProfileToCreate',
-                "Select the terminal profile to create"
-            )) : ( nls.localize(
-                'terminal.integrated.chooseDefaultProfile',
-                "Select your default terminal profile"
-            )),
-            onDidTriggerItemButton: async (context) => {
-                if (!(await this._isProfileSafe(context.item.profile))) {
-                    return;
-                }
-                if ('command' in context.item.profile) {
-                    return;
-                }
-                if ('id' in context.item.profile) {
-                    return;
-                }
-                const configProfiles = this._configurationService.getValue("terminal.integrated.profiles."  + platformKey);
-                const existingProfiles = !!configProfiles ? ( Object.keys(configProfiles)) : [];
-                const name = await this._quickInputService.input({
-                    prompt: ( nls.localize('enterTerminalProfileName', "Enter terminal profile name")),
-                    value: context.item.profile.profileName,
-                    validateInput: async (input) => {
-                        if (existingProfiles.includes(input)) {
-                            return ( nls.localize(
-                                'terminalProfileAlreadyExists',
-                                "A terminal profile already exists with that name"
-                            ));
-                        }
-                        return undefined;
-                    }
-                });
-                if (!name) {
-                    return;
-                }
-                const newConfigValue = { ...configProfiles };
-                newConfigValue[name] = {
-                    path: context.item.profile.path,
-                    args: context.item.profile.args
-                };
-                await this._configurationService.updateValue(profilesKey, newConfigValue, 2 );
-            },
-            onKeyMods: mods => keyMods = mods
-        };
-        const quickPickItems = [];
-        const configProfiles = profiles.filter(e => !e.isAutoDetected);
-        const autoDetectedProfiles = profiles.filter(e => e.isAutoDetected);
-        if (configProfiles.length > 0) {
-            quickPickItems.push({ type: 'separator', label: ( nls.localize('terminalProfiles', "profiles")) });
-            quickPickItems.push(...this._sortProfileQuickPickItems(( configProfiles.map(e => this._createProfileQuickPickItem(e))), defaultProfileName));
-        }
-        quickPickItems.push({ type: 'separator', label: ( nls.localize('ICreateContributedTerminalProfileOptions', "contributed")) });
-        const contributedProfiles = [];
-        for (const contributed of this._terminalProfileService.contributedProfiles) {
-            let icon;
-            if (typeof contributed.icon === 'string') {
-                if (contributed.icon.startsWith('$(')) {
-                    icon = ThemeIcon.fromString(contributed.icon);
-                }
-                else {
-                    icon = ThemeIcon.fromId(contributed.icon);
-                }
-            }
-            if (!icon || !getIconRegistry().getIcon(icon.id)) {
-                icon = this._terminalProfileResolverService.getDefaultIcon();
-            }
-            const uriClasses = getUriClasses(contributed, this._themeService.getColorTheme().type, true);
-            const colorClass = getColorClass(contributed);
-            const iconClasses = [];
-            if (uriClasses) {
-                iconClasses.push(...uriClasses);
-            }
-            if (colorClass) {
-                iconClasses.push(colorClass);
-            }
-            contributedProfiles.push({
-                label: `$(${icon.id}) ${contributed.title}`,
-                profile: {
-                    extensionIdentifier: contributed.extensionIdentifier,
-                    title: contributed.title,
-                    icon: contributed.icon,
-                    id: contributed.id,
-                    color: contributed.color
-                },
-                profileName: contributed.title,
-                iconClasses
-            });
-        }
-        if (contributedProfiles.length > 0) {
-            quickPickItems.push(...this._sortProfileQuickPickItems(contributedProfiles, defaultProfileName));
-        }
-        if (autoDetectedProfiles.length > 0) {
-            quickPickItems.push({ type: 'separator', label: ( nls.localize('terminalProfiles.detected', "detected")) });
-            quickPickItems.push(...this._sortProfileQuickPickItems(( autoDetectedProfiles.map(e => this._createProfileQuickPickItem(e))), defaultProfileName));
-        }
-        const styleElement = getColorStyleElement(this._themeService.getColorTheme());
-        document.body.appendChild(styleElement);
-        const result = await this._quickInputService.pick(quickPickItems, options);
-        document.body.removeChild(styleElement);
-        if (!result) {
-            return undefined;
-        }
-        if (!(await this._isProfileSafe(result.profile))) {
-            return undefined;
-        }
-        if (keyMods) {
-            result.keyMods = keyMods;
-        }
-        return result;
-    }
-    async _isProfileSafe(profile) {
-        const isUnsafePath = 'isUnsafePath' in profile && profile.isUnsafePath;
-        const requiresUnsafePath = 'requiresUnsafePath' in profile && profile.requiresUnsafePath;
-        if (!isUnsafePath && !requiresUnsafePath) {
-            return true;
-        }
-        return await ( new Promise(r => {
-            const unsafePaths = [];
-            if (isUnsafePath) {
-                unsafePaths.push(profile.path);
-            }
-            if (requiresUnsafePath) {
-                unsafePaths.push(requiresUnsafePath);
-            }
-            const handle = this._notificationService.prompt(Severity.Warning, ( nls.localize(
-                'unsafePathWarning',
-                'This terminal profile uses a potentially unsafe path that can be modified by another user: {0}. Are you sure you want to use it?',
-                `"${unsafePaths.join(',')}"`
-            )), [{
-                    label: ( nls.localize('yes', 'Yes')),
-                    run: () => r(true)
-                }, {
-                    label: ( nls.localize('cancel', 'Cancel')),
-                    run: () => r(false)
-                }]);
-            handle.onDidClose(() => r(false));
-        }));
-    }
-    _createProfileQuickPickItem(profile) {
-        const buttons = [{
-                iconClass: ThemeIcon.asClassName(configureTerminalProfileIcon),
-                tooltip: ( nls.localize('createQuickLaunchProfile', "Configure Terminal Profile"))
-            }];
-        const icon = (profile.icon && ThemeIcon.isThemeIcon(profile.icon)) ? profile.icon : Codicon.terminal;
-        const label = `$(${icon.id}) ${profile.profileName}`;
-        const friendlyPath = profile.isFromPath ? basename(profile.path) : profile.path;
-        const colorClass = getColorClass(profile);
-        const iconClasses = [];
-        if (colorClass) {
-            iconClasses.push(colorClass);
-        }
-        if (profile.args) {
-            if (typeof profile.args === 'string') {
-                return { label, description: `${profile.path} ${profile.args}`, profile, profileName: profile.profileName, buttons, iconClasses };
-            }
-            const argsString = ( profile.args.map(e => {
-                if (e.includes(' ')) {
-                    return `"${e.replace(/"/g, '\\"')}"`;
-                }
-                return e;
-            })).join(' ');
-            return { label, description: `${friendlyPath} ${argsString}`, profile, profileName: profile.profileName, buttons, iconClasses };
-        }
-        return { label, description: friendlyPath, profile, profileName: profile.profileName, buttons, iconClasses };
-    }
-    _sortProfileQuickPickItems(items, defaultProfileName) {
-        return items.sort((a, b) => {
-            if (b.profileName === defaultProfileName) {
-                return 1;
-            }
-            if (a.profileName === defaultProfileName) {
-                return -1;
-            }
-            return a.profileName.localeCompare(b.profileName);
-        });
-    }
-};
-TerminalProfileQuickpick = ( __decorate([
-    ( __param(0, ITerminalProfileService)),
-    ( __param(1, ITerminalProfileResolverService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IThemeService)),
-    ( __param(5, INotificationService))
-], TerminalProfileQuickpick));
-export { TerminalProfileQuickpick };

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

@@ -1,316 +0,0 @@
-import { __decorate } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { isUriComponents, terminalProfileArgsMatch } from '../../../../platform/terminal/common/terminalProfiles.js';
-const generatedProfileName = 'Generated';
-class BaseTerminalProfileResolverService {
-    get defaultProfileName() { return this._defaultProfileName; }
-    constructor(_context, _configurationService, _configurationResolverService, _historyService, _logService, _terminalProfileService, _workspaceContextService, _remoteAgentService) {
-        this._context = _context;
-        this._configurationService = _configurationService;
-        this._configurationResolverService = _configurationResolverService;
-        this._historyService = _historyService;
-        this._logService = _logService;
-        this._terminalProfileService = _terminalProfileService;
-        this._workspaceContextService = _workspaceContextService;
-        this._remoteAgentService = _remoteAgentService;
-        this._iconRegistry = getIconRegistry();
-        if (this._remoteAgentService.getConnection()) {
-            this._remoteAgentService.getEnvironment().then(env => this._primaryBackendOs = env?.os || OS);
-        }
-        else {
-            this._primaryBackendOs = OS;
-        }
-        this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration("terminal.integrated.defaultProfile.windows" ) ||
-                e.affectsConfiguration("terminal.integrated.defaultProfile.osx" ) ||
-                e.affectsConfiguration("terminal.integrated.defaultProfile.linux" )) {
-                this._refreshDefaultProfileName();
-            }
-        });
-        this._terminalProfileService.onDidChangeAvailableProfiles(() => this._refreshDefaultProfileName());
-    }
-    async _refreshDefaultProfileName() {
-        if (this._primaryBackendOs) {
-            this._defaultProfileName = (await this.getDefaultProfile({
-                remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority,
-                os: this._primaryBackendOs
-            }))?.profileName;
-        }
-    }
-    resolveIcon(shellLaunchConfig, os) {
-        if (shellLaunchConfig.icon) {
-            shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon) || this.getDefaultIcon();
-            return;
-        }
-        if (shellLaunchConfig.customPtyImplementation) {
-            shellLaunchConfig.icon = this.getDefaultIcon();
-            return;
-        }
-        if (shellLaunchConfig.executable) {
-            return;
-        }
-        const defaultProfile = this._getUnresolvedRealDefaultProfile(os);
-        if (defaultProfile) {
-            shellLaunchConfig.icon = defaultProfile.icon;
-        }
-        if (!shellLaunchConfig.icon) {
-            shellLaunchConfig.icon = this.getDefaultIcon();
-        }
-    }
-    getDefaultIcon(resource) {
-        return this._iconRegistry.getIcon(this._configurationService.getValue("terminal.integrated.tabs.defaultIcon" , { resource })) || Codicon.terminal;
-    }
-    async resolveShellLaunchConfig(shellLaunchConfig, options) {
-        let resolvedProfile;
-        if (shellLaunchConfig.executable) {
-            resolvedProfile = await this._resolveProfile({
-                path: shellLaunchConfig.executable,
-                args: shellLaunchConfig.args,
-                profileName: generatedProfileName,
-                isDefault: false
-            }, options);
-        }
-        else {
-            resolvedProfile = await this.getDefaultProfile(options);
-        }
-        shellLaunchConfig.executable = resolvedProfile.path;
-        shellLaunchConfig.args = resolvedProfile.args;
-        if (resolvedProfile.env) {
-            if (shellLaunchConfig.env) {
-                shellLaunchConfig.env = { ...shellLaunchConfig.env, ...resolvedProfile.env };
-            }
-            else {
-                shellLaunchConfig.env = resolvedProfile.env;
-            }
-        }
-        const resource = shellLaunchConfig === undefined || typeof shellLaunchConfig.cwd === 'string' ? undefined : shellLaunchConfig.cwd;
-        shellLaunchConfig.icon = this._getCustomIcon(shellLaunchConfig.icon)
-            || this._getCustomIcon(resolvedProfile.icon)
-            || this.getDefaultIcon(resource);
-        if (resolvedProfile.overrideName) {
-            shellLaunchConfig.name = resolvedProfile.profileName;
-        }
-        shellLaunchConfig.color = shellLaunchConfig.color
-            || resolvedProfile.color
-            || this._configurationService.getValue("terminal.integrated.tabs.defaultColor" , { resource });
-        if (shellLaunchConfig.useShellEnvironment === undefined) {
-            shellLaunchConfig.useShellEnvironment = this._configurationService.getValue("terminal.integrated.inheritEnv" );
-        }
-    }
-    async getDefaultShell(options) {
-        return (await this.getDefaultProfile(options)).path;
-    }
-    async getDefaultShellArgs(options) {
-        return (await this.getDefaultProfile(options)).args || [];
-    }
-    async getDefaultProfile(options) {
-        return this._resolveProfile(await this._getUnresolvedDefaultProfile(options), options);
-    }
-    getEnvironment(remoteAuthority) {
-        return this._context.getEnvironment(remoteAuthority);
-    }
-    _getCustomIcon(icon) {
-        if (!icon) {
-            return undefined;
-        }
-        if (typeof icon === 'string') {
-            return ThemeIcon.fromId(icon);
-        }
-        if (ThemeIcon.isThemeIcon(icon)) {
-            return icon;
-        }
-        if (URI.isUri(icon) || isUriComponents(icon)) {
-            return URI.revive(icon);
-        }
-        if (typeof icon === 'object' && 'light' in icon && 'dark' in icon) {
-            const castedIcon = icon;
-            if ((URI.isUri(castedIcon.light) || isUriComponents(castedIcon.light)) && (URI.isUri(castedIcon.dark) || isUriComponents(castedIcon.dark))) {
-                return { light: URI.revive(castedIcon.light), dark: URI.revive(castedIcon.dark) };
-            }
-        }
-        return undefined;
-    }
-    async _getUnresolvedDefaultProfile(options) {
-        if (options.allowAutomationShell) {
-            const automationShellProfile = this._getUnresolvedAutomationShellProfile(options);
-            if (automationShellProfile) {
-                return automationShellProfile;
-            }
-        }
-        await this._terminalProfileService.profilesReady;
-        const defaultProfile = this._getUnresolvedRealDefaultProfile(options.os);
-        if (defaultProfile) {
-            return this._setIconForAutomation(options, defaultProfile);
-        }
-        return this._setIconForAutomation(options, await this._getUnresolvedFallbackDefaultProfile(options));
-    }
-    _setIconForAutomation(options, profile) {
-        if (options.allowAutomationShell) {
-            const profileClone = deepClone(profile);
-            profileClone.icon = Codicon.tools;
-            return profileClone;
-        }
-        return profile;
-    }
-    _getUnresolvedRealDefaultProfile(os) {
-        return this._terminalProfileService.getDefaultProfile(os);
-    }
-    async _getUnresolvedFallbackDefaultProfile(options) {
-        const executable = await this._context.getDefaultSystemShell(options.remoteAuthority, options.os);
-        if (options.os === OS) {
-            let existingProfile = this._terminalProfileService.availableProfiles.find(e => path.parse(e.path).name === path.parse(executable).name);
-            if (existingProfile) {
-                if (options.allowAutomationShell) {
-                    existingProfile = deepClone(existingProfile);
-                    existingProfile.icon = Codicon.tools;
-                }
-                return existingProfile;
-            }
-        }
-        let args;
-        if (options.os === 2  && path.parse(executable).name.match(/(zsh|bash)/)) {
-            args = ['--login'];
-        }
-        else {
-            args = [];
-        }
-        const icon = this._guessProfileIcon(executable);
-        return {
-            profileName: generatedProfileName,
-            path: executable,
-            args,
-            icon,
-            isDefault: false
-        };
-    }
-    _getUnresolvedAutomationShellProfile(options) {
-        const automationProfile = this._configurationService.getValue(`terminal.integrated.automationProfile.${this._getOsKey(options.os)}`);
-        if (this._isValidAutomationProfile(automationProfile, options.os)) {
-            automationProfile.icon = this._getCustomIcon(automationProfile.icon) || Codicon.tools;
-            return automationProfile;
-        }
-        return undefined;
-    }
-    async _resolveProfile(profile, options) {
-        const env = await this._context.getEnvironment(options.remoteAuthority);
-        if (options.os === 1 ) {
-            const isWoW64 = !!env.hasOwnProperty('PROCESSOR_ARCHITEW6432');
-            const windir = env.windir;
-            if (!isWoW64 && windir) {
-                const sysnativePath = path.join(windir, 'Sysnative').replace(/\//g, '\\').toLowerCase();
-                if (profile.path && profile.path.toLowerCase().indexOf(sysnativePath) === 0) {
-                    profile.path = path.join(windir, 'System32', profile.path.substr(sysnativePath.length + 1));
-                }
-            }
-            if (profile.path) {
-                profile.path = profile.path.replace(/\//g, '\\');
-            }
-        }
-        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot(options.remoteAuthority ? Schemas.vscodeRemote : Schemas.file);
-        const lastActiveWorkspace = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-        profile.path = await this._resolveVariables(profile.path, env, lastActiveWorkspace);
-        if (profile.args) {
-            if (typeof profile.args === 'string') {
-                profile.args = await this._resolveVariables(profile.args, env, lastActiveWorkspace);
-            }
-            else {
-                profile.args = await Promise.all(( profile.args.map(arg => this._resolveVariables(arg, env, lastActiveWorkspace))));
-            }
-        }
-        return profile;
-    }
-    async _resolveVariables(value, env, lastActiveWorkspace) {
-        try {
-            value = await this._configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, value);
-        }
-        catch (e) {
-            this._logService.error(`Could not resolve shell`, e);
-        }
-        return value;
-    }
-    _getOsKey(os) {
-        switch (os) {
-            case 3 : return 'linux';
-            case 2 : return 'osx';
-            case 1 : return 'windows';
-        }
-    }
-    _guessProfileIcon(shell) {
-        const file = path.parse(shell).name;
-        switch (file) {
-            case 'bash':
-                return Codicon.terminalBash;
-            case 'pwsh':
-            case 'powershell':
-                return Codicon.terminalPowershell;
-            case 'tmux':
-                return Codicon.terminalTmux;
-            case 'cmd':
-                return Codicon.terminalCmd;
-            default:
-                return undefined;
-        }
-    }
-    _isValidShellArgs(shellArgs, os) {
-        if (shellArgs === undefined) {
-            return true;
-        }
-        if (os === 1  && typeof shellArgs === 'string') {
-            return true;
-        }
-        if (Array.isArray(shellArgs) && shellArgs.every(e => typeof e === 'string')) {
-            return true;
-        }
-        return false;
-    }
-    async createProfileFromShellAndShellArgs(shell, shellArgs) {
-        const detectedProfile = this._terminalProfileService.availableProfiles?.find(p => {
-            if (p.path !== shell) {
-                return false;
-            }
-            if (p.args === undefined || typeof p.args === 'string') {
-                return p.args === shellArgs;
-            }
-            return p.path === shell && equals(p.args, (shellArgs || []));
-        });
-        const fallbackProfile = (await this.getDefaultProfile({
-            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority,
-            os: this._primaryBackendOs
-        }));
-        fallbackProfile.profileName = `${fallbackProfile.path} (migrated)`;
-        const profile = detectedProfile || fallbackProfile;
-        const args = this._isValidShellArgs(shellArgs, this._primaryBackendOs) ? shellArgs : profile.args;
-        const createdProfile = {
-            profileName: profile.profileName,
-            path: profile.path,
-            args,
-            isDefault: true
-        };
-        if (detectedProfile && detectedProfile.profileName === createdProfile.profileName && detectedProfile.path === createdProfile.path && terminalProfileArgsMatch(detectedProfile.args, createdProfile.args)) {
-            return detectedProfile.profileName;
-        }
-        return createdProfile;
-    }
-    _isValidAutomationProfile(profile, os) {
-        if (profile === null || profile === undefined || typeof profile !== 'object') {
-            return false;
-        }
-        if ('path' in profile && typeof profile.path === 'string') {
-            return true;
-        }
-        return false;
-    }
-}
-BaseTerminalProfileResolverService.__decorator = ( __decorate([
-    debounce(200)
-], BaseTerminalProfileResolverService.prototype, "_refreshDefaultProfileName", null));
-export { BaseTerminalProfileResolverService };