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

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

@@ -1,311 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { IRemoteAuthorityResolverService } from '../../../../platform/remote/common/remoteAuthorityResolver.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { TerminalExtensions, ITerminalLogService } from '../../../../platform/terminal/common/terminal.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { BaseTerminalBackend } from './baseTerminalBackend.js';
-import { RemotePty } from './remotePty.js';
-import { ITerminalInstanceService } from './terminal.js';
-import { RemoteTerminalChannelClient, REMOTE_TERMINAL_CHANNEL_NAME } from '../common/remote/remoteTerminalChannel.js';
-import { TERMINAL_CONFIG_SECTION } from '../common/terminal.js';
-import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
-import { IHistoryService } from '../../../services/history/common/history.js';
-import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
-import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
-let RemoteTerminalBackendContribution = class RemoteTerminalBackendContribution {
-    constructor(instantiationService, remoteAgentService, terminalInstanceService) {
-        const connection = remoteAgentService.getConnection();
-        if (connection?.remoteAuthority) {
-            const channel = instantiationService.createInstance(RemoteTerminalChannelClient, connection.remoteAuthority, connection.getChannel(REMOTE_TERMINAL_CHANNEL_NAME));
-            const backend = instantiationService.createInstance(RemoteTerminalBackend, connection.remoteAuthority, channel);
-            ( Registry.as(TerminalExtensions.Backend)).registerTerminalBackend(backend);
-            terminalInstanceService.didRegisterBackend(backend.remoteAuthority);
-        }
-    }
-};
-RemoteTerminalBackendContribution = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IRemoteAgentService)),
-    ( __param(2, ITerminalInstanceService))
-], RemoteTerminalBackendContribution));
-let RemoteTerminalBackend = class RemoteTerminalBackend extends BaseTerminalBackend {
-    get whenReady() { return this._whenConnected.p; }
-    setReady() { this._whenConnected.complete(); }
-    constructor(remoteAuthority, _remoteTerminalChannel, _remoteAgentService, _instantiationService, logService, _commandService, _storageService, _remoteAuthorityResolverService, workspaceContextService, configurationResolverService, _historyService, _configurationService, statusBarService) {
-        super(_remoteTerminalChannel, logService, _historyService, configurationResolverService, statusBarService, workspaceContextService);
-        this.remoteAuthority = remoteAuthority;
-        this._remoteTerminalChannel = _remoteTerminalChannel;
-        this._remoteAgentService = _remoteAgentService;
-        this._instantiationService = _instantiationService;
-        this._commandService = _commandService;
-        this._storageService = _storageService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        this._historyService = _historyService;
-        this._configurationService = _configurationService;
-        this._ptys = ( new Map());
-        this._whenConnected = ( new DeferredPromise());
-        this._onDidRequestDetach = this._register(( new Emitter()));
-        this.onDidRequestDetach = this._onDidRequestDetach.event;
-        this._onRestoreCommands = this._register(( new Emitter()));
-        this.onRestoreCommands = this._onRestoreCommands.event;
-        this._remoteTerminalChannel.onProcessData(e => this._ptys.get(e.id)?.handleData(e.event));
-        this._remoteTerminalChannel.onProcessReplay(e => {
-            this._ptys.get(e.id)?.handleReplay(e.event);
-            if (e.event.commands.commands.length > 0) {
-                this._onRestoreCommands.fire({ id: e.id, commands: e.event.commands.commands });
-            }
-        });
-        this._remoteTerminalChannel.onProcessOrphanQuestion(e => this._ptys.get(e.id)?.handleOrphanQuestion());
-        this._remoteTerminalChannel.onDidRequestDetach(e => this._onDidRequestDetach.fire(e));
-        this._remoteTerminalChannel.onProcessReady(e => this._ptys.get(e.id)?.handleReady(e.event));
-        this._remoteTerminalChannel.onDidChangeProperty(e => this._ptys.get(e.id)?.handleDidChangeProperty(e.property));
-        this._remoteTerminalChannel.onProcessExit(e => {
-            const pty = this._ptys.get(e.id);
-            if (pty) {
-                pty.handleExit(e.event);
-                this._ptys.delete(e.id);
-            }
-        });
-        const allowedCommands = ['_remoteCLI.openExternal', '_remoteCLI.windowOpen', '_remoteCLI.getSystemStatus', '_remoteCLI.manageExtensions'];
-        this._remoteTerminalChannel.onExecuteCommand(async (e) => {
-            const pty = this._ptys.get(e.persistentProcessId);
-            if (!pty) {
-                return;
-            }
-            const reqId = e.reqId;
-            const commandId = e.commandId;
-            if (!allowedCommands.includes(commandId)) {
-                this._remoteTerminalChannel.sendCommandResult(reqId, true, 'Invalid remote cli command: ' + commandId);
-                return;
-            }
-            const commandArgs = ( e.commandArgs.map(arg => revive(arg)));
-            try {
-                const result = await this._commandService.executeCommand(e.commandId, ...commandArgs);
-                this._remoteTerminalChannel.sendCommandResult(reqId, false, result);
-            }
-            catch (err) {
-                this._remoteTerminalChannel.sendCommandResult(reqId, true, err);
-            }
-        });
-        const initialConfig = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
-        for (const match of ( Object.keys(initialConfig.autoReplies))) {
-            const reply = initialConfig.autoReplies[match];
-            if (reply) {
-                this._remoteTerminalChannel.installAutoReply(match, reply);
-            }
-        }
-        this._register(this._configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration("terminal.integrated.autoReplies" )) {
-                this._remoteTerminalChannel.uninstallAllAutoReplies();
-                const config = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
-                for (const match of ( Object.keys(config.autoReplies))) {
-                    const reply = config.autoReplies[match];
-                    if (reply) {
-                        await this._remoteTerminalChannel.installAutoReply(match, reply);
-                    }
-                }
-            }
-        }));
-        this._onPtyHostConnected.fire();
-    }
-    async requestDetachInstance(workspaceId, instanceId) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot request detach instance when there is no remote!`);
-        }
-        return this._remoteTerminalChannel.requestDetachInstance(workspaceId, instanceId);
-    }
-    async acceptDetachInstanceReply(requestId, persistentProcessId) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot accept detached instance when there is no remote!`);
-        }
-        else if (!persistentProcessId) {
-            this._logService.warn('Cannot attach to feature terminals, custom pty terminals, or those without a persistentProcessId');
-            return;
-        }
-        return this._remoteTerminalChannel.acceptDetachInstanceReply(requestId, persistentProcessId);
-    }
-    async persistTerminalState() {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot persist terminal state when there is no remote!`);
-        }
-        const ids = Array.from(( this._ptys.keys()));
-        const serialized = await this._remoteTerminalChannel.serializeTerminalState(ids);
-        this._storageService.store("terminal.integrated.bufferState" , serialized, 1 , 1 );
-    }
-    async createProcess(shellLaunchConfig, cwd,
-    cols, rows, unicodeVersion, env,
-    options, shouldPersist) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot create remote terminal when there is no remote!`);
-        }
-        const remoteEnv = await this._remoteAgentService.getEnvironment();
-        if (!remoteEnv) {
-            throw new Error('Could not fetch remote environment');
-        }
-        const terminalConfig = this._configurationService.getValue(TERMINAL_CONFIG_SECTION);
-        const configuration = {
-            'terminal.integrated.env.windows': this._configurationService.getValue("terminal.integrated.env.windows" ),
-            'terminal.integrated.env.osx': this._configurationService.getValue("terminal.integrated.env.osx" ),
-            'terminal.integrated.env.linux': this._configurationService.getValue("terminal.integrated.env.linux" ),
-            'terminal.integrated.cwd': this._configurationService.getValue("terminal.integrated.cwd" ),
-            'terminal.integrated.detectLocale': terminalConfig.detectLocale
-        };
-        const shellLaunchConfigDto = {
-            name: shellLaunchConfig.name,
-            executable: shellLaunchConfig.executable,
-            args: shellLaunchConfig.args,
-            cwd: shellLaunchConfig.cwd,
-            env: shellLaunchConfig.env,
-            useShellEnvironment: shellLaunchConfig.useShellEnvironment,
-            reconnectionProperties: shellLaunchConfig.reconnectionProperties,
-            type: shellLaunchConfig.type,
-            isFeatureTerminal: shellLaunchConfig.isFeatureTerminal
-        };
-        const activeWorkspaceRootUri = this._historyService.getLastActiveWorkspaceRoot();
-        const result = await this._remoteTerminalChannel.createProcess(shellLaunchConfigDto, configuration, activeWorkspaceRootUri, options, shouldPersist, cols, rows, unicodeVersion);
-        const pty = this._instantiationService.createInstance(RemotePty, result.persistentTerminalId, shouldPersist, this._remoteTerminalChannel);
-        this._ptys.set(result.persistentTerminalId, pty);
-        return pty;
-    }
-    async attachToProcess(id) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot create remote terminal when there is no remote!`);
-        }
-        try {
-            await this._remoteTerminalChannel.attachToProcess(id);
-            const pty = this._instantiationService.createInstance(RemotePty, id, true, this._remoteTerminalChannel);
-            this._ptys.set(id, pty);
-            return pty;
-        }
-        catch (e) {
-            this._logService.trace(`Couldn't attach to process ${e.message}`);
-        }
-        return undefined;
-    }
-    async attachToRevivedProcess(id) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot create remote terminal when there is no remote!`);
-        }
-        try {
-            const newId = (await this._remoteTerminalChannel.getRevivedPtyNewId(id)) ?? id;
-            return await this.attachToProcess(newId);
-        }
-        catch (e) {
-            this._logService.trace(`Couldn't attach to process ${e.message}`);
-        }
-        return undefined;
-    }
-    async listProcesses() {
-        return this._remoteTerminalChannel.listProcesses();
-    }
-    async getLatency() {
-        const sw = ( new StopWatch());
-        const results = await this._remoteTerminalChannel.getLatency();
-        sw.stop();
-        return [
-            {
-                label: 'window<->ptyhostservice<->ptyhost',
-                latency: sw.elapsed()
-            },
-            ...results
-        ];
-    }
-    async updateProperty(id, property, value) {
-        await this._remoteTerminalChannel.updateProperty(id, property, value);
-    }
-    async updateTitle(id, title, titleSource) {
-        await this._remoteTerminalChannel.updateTitle(id, title, titleSource);
-    }
-    async updateIcon(id, userInitiated, icon, color) {
-        await this._remoteTerminalChannel.updateIcon(id, userInitiated, icon, color);
-    }
-    async getDefaultSystemShell(osOverride) {
-        return this._remoteTerminalChannel.getDefaultSystemShell(osOverride) || '';
-    }
-    async getProfiles(profiles, defaultProfile, includeDetectedProfiles) {
-        return this._remoteTerminalChannel.getProfiles(profiles, defaultProfile, includeDetectedProfiles) || [];
-    }
-    async getEnvironment() {
-        return this._remoteTerminalChannel.getEnvironment() || {};
-    }
-    async getShellEnvironment() {
-        const connection = this._remoteAgentService.getConnection();
-        if (!connection) {
-            return undefined;
-        }
-        const resolverResult = await this._remoteAuthorityResolverService.resolveAuthority(connection.remoteAuthority);
-        return resolverResult.options?.extensionHostEnv;
-    }
-    async getWslPath(original, direction) {
-        const env = await this._remoteAgentService.getEnvironment();
-        if (env?.os !== 1 ) {
-            return original;
-        }
-        return this._remoteTerminalChannel.getWslPath(original, direction) || original;
-    }
-    async setTerminalLayoutInfo(layout) {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot call setActiveInstanceId when there is no remote`);
-        }
-        return this._remoteTerminalChannel.setTerminalLayoutInfo(layout);
-    }
-    async reduceConnectionGraceTime() {
-        if (!this._remoteTerminalChannel) {
-            throw new Error('Cannot reduce grace time when there is no remote');
-        }
-        return this._remoteTerminalChannel.reduceConnectionGraceTime();
-    }
-    async getTerminalLayoutInfo() {
-        if (!this._remoteTerminalChannel) {
-            throw new Error(`Cannot call getActiveInstanceId when there is no remote`);
-        }
-        const workspaceId = this._getWorkspaceId();
-        const serializedState = this._storageService.get("terminal.integrated.bufferState" , 1 );
-        const reviveBufferState = this._deserializeTerminalState(serializedState);
-        if (reviveBufferState && reviveBufferState.length > 0) {
-            try {
-                mark('code/terminal/willReviveTerminalProcessesRemote');
-                await this._remoteTerminalChannel.reviveTerminalProcesses(workspaceId, reviveBufferState, Intl.DateTimeFormat().resolvedOptions().locale);
-                mark('code/terminal/didReviveTerminalProcessesRemote');
-                this._storageService.remove("terminal.integrated.bufferState" , 1 );
-                const layoutInfo = this._storageService.get("terminal.integrated.layoutInfo" , 1 );
-                if (layoutInfo) {
-                    mark('code/terminal/willSetTerminalLayoutInfoRemote');
-                    await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo));
-                    mark('code/terminal/didSetTerminalLayoutInfoRemote');
-                    this._storageService.remove("terminal.integrated.layoutInfo" , 1 );
-                }
-            }
-            catch (e) {
-                this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e);
-            }
-        }
-        return this._remoteTerminalChannel.getTerminalLayoutInfo();
-    }
-    async getPerformanceMarks() {
-        return this._remoteTerminalChannel.getPerformanceMarks();
-    }
-};
-RemoteTerminalBackend = ( __decorate([
-    ( __param(2, IRemoteAgentService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITerminalLogService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IRemoteAuthorityResolverService)),
-    ( __param(8, IWorkspaceContextService)),
-    ( __param(9, IConfigurationResolverService)),
-    ( __param(10, IHistoryService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, IStatusbarService))
-], RemoteTerminalBackend));
-export { RemoteTerminalBackendContribution };

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

@@ -1,240 +0,0 @@
-import './media/scrollbar.css.js';
-import './media/widgets.css.js';
-import './media/xterm.css.js';
-import './media/terminal.css.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { KeybindingsRegistry } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingsRegistry.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { getQuickNavigateHandler } from '../../../browser/quickaccess.js';
-import { Extensions as Extensions$1 } from '../../../common/views.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
-import { registerTerminalActions, terminalSendSequenceCommand } from './terminalActions.js';
-import { TerminalViewPane } from './terminalView.js';
-import { TERMINAL_VIEW_ID } from '../common/terminal.js';
-import { registerColors } from '../common/terminalColorRegistry.js';
-import { setupTerminalCommands } from './terminalCommands.js';
-import { terminalEditorId } from './terminal.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
-import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
-import { TerminalQuickAccessProvider } from './terminalQuickAccess.js';
-import { registerTerminalConfiguration } from '../common/terminalConfiguration.js';
-import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { terminalViewIcon } from './terminalIcons.js';
-import { isWindows, isIOS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { setupTerminalMenus } from './terminalMenus.js';
-import { registerTerminalPlatformConfiguration } from '../../../../platform/terminal/common/terminalPlatformConfiguration.js';
-import { EditorExtensions } from '../../../common/editor.js';
-import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { TerminalEditor } from './terminalEditor.js';
-import { TerminalEditorInput } from './terminalEditorInput.js';
-import { terminalStrings } from '../common/terminalStrings.js';
-import { TerminalContextKeys } from '../common/terminalContextKey.js';
-import { Extensions as Extensions$3 } from '../../../common/contributions.js';
-import { RemoteTerminalBackendContribution } from './remoteTerminalBackend.js';
-import { TerminalMainContribution } from './terminalMainContribution.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-const quickAccessRegistry = (( Registry.as(Extensions$2.Quickaccess)));
-const inTerminalsPicker = 'inTerminalPicker';
-quickAccessRegistry.registerQuickAccessProvider({
-    ctor: TerminalQuickAccessProvider,
-    prefix: TerminalQuickAccessProvider.PREFIX,
-    contextKey: inTerminalsPicker,
-    placeholder: ( nls.localize('tasksQuickAccessPlaceholder', "Type the name of a terminal to open.")),
-    helpEntries: [{ description: ( nls.localize('tasksQuickAccessHelp', "Show All Opened Terminals")), commandId: "workbench.action.quickOpenTerm"  }]
-});
-const quickAccessNavigateNextInTerminalPickerId = 'workbench.action.quickOpenNavigateNextInTerminalPicker';
-CommandsRegistry.registerCommand({ id: quickAccessNavigateNextInTerminalPickerId, handler: getQuickNavigateHandler(quickAccessNavigateNextInTerminalPickerId, true) });
-const quickAccessNavigatePreviousInTerminalPickerId = 'workbench.action.quickOpenNavigatePreviousInTerminalPicker';
-CommandsRegistry.registerCommand({ id: quickAccessNavigatePreviousInTerminalPickerId, handler: getQuickNavigateHandler(quickAccessNavigatePreviousInTerminalPickerId, false) });
-const workbenchRegistry = ( Registry.as(Extensions$3.Workbench));
-workbenchRegistry.registerWorkbenchContribution(TerminalMainContribution, 3 );
-workbenchRegistry.registerWorkbenchContribution(RemoteTerminalBackendContribution, 3 );
-registerTerminalPlatformConfiguration();
-registerTerminalConfiguration();
-( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(TerminalEditor, terminalEditorId, terminalStrings.terminal), [
-    ( new SyncDescriptor(TerminalEditorInput))
-]);
-( Registry.as(Extensions.DragAndDropContribution)).register({
-    dataFormatKey: "Terminals" ,
-    getEditorInputs(data) {
-        const editors = [];
-        try {
-            const terminalEditors = JSON.parse(data);
-            for (const terminalEditor of terminalEditors) {
-                editors.push({ resource: ( URI.parse(terminalEditor)) });
-            }
-        }
-        catch (error) {
-        }
-        return editors;
-    },
-    setData(resources, event) {
-        const terminalResources = resources.filter(({ resource }) => resource.scheme === Schemas.vscodeTerminal);
-        if (terminalResources.length) {
-            event.dataTransfer?.setData("Terminals" , JSON.stringify(( terminalResources.map(({ resource }) => ( resource.toString())))));
-        }
-    }
-});
-const VIEW_CONTAINER = ( Registry.as(Extensions$1.ViewContainersRegistry)).registerViewContainer({
-    id: TERMINAL_VIEW_ID,
-    title: ( nls.localize('terminal', "Terminal")),
-    icon: terminalViewIcon,
-    ctorDescriptor: ( new SyncDescriptor(
-        ViewPaneContainer,
-        [TERMINAL_VIEW_ID, { mergeViewWithContainerWhenSingleView: true }]
-    )),
-    storageId: TERMINAL_VIEW_ID,
-    hideIfEmpty: true,
-    order: 3,
-}, 1 , { doNotRegisterOpenCommand: true, isDefault: true });
-( Registry.as(Extensions$1.ViewsRegistry)).registerViews([{
-        id: TERMINAL_VIEW_ID,
-        name: ( nls.localize('terminal', "Terminal")),
-        containerIcon: terminalViewIcon,
-        canToggleVisibility: false,
-        canMoveView: true,
-        ctorDescriptor: ( new SyncDescriptor(TerminalViewPane)),
-        openCommandActionDescriptor: {
-            id: "workbench.action.terminal.toggleTerminal" ,
-            mnemonicTitle: ( nls.localize(
-                { key: 'miToggleIntegratedTerminal', comment: ['&& denotes a mnemonic'] },
-                "&&Terminal"
-            )),
-            keybindings: {
-                primary: 2048  | 91 ,
-                mac: { primary: 256  | 91  }
-            },
-            order: 3
-        }
-    }], VIEW_CONTAINER);
-registerTerminalActions();
-function registerSendSequenceKeybinding(text, rule) {
-    KeybindingsRegistry.registerCommandAndKeybindingRule({
-        id: "workbench.action.terminal.sendSequence" ,
-        weight: 200 ,
-        when: rule.when || TerminalContextKeys.focus,
-        primary: rule.primary,
-        mac: rule.mac,
-        linux: rule.linux,
-        win: rule.win,
-        handler: terminalSendSequenceCommand,
-        args: { text }
-    });
-}
-if (isWindows) {
-    registerSendSequenceKeybinding(String.fromCharCode('V'.charCodeAt(0) - 64 ), {
-        when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-            "terminalShellType",
-            "pwsh"
-        )), ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-        primary: 2048  | 52
-    });
-}
-registerSendSequenceKeybinding('\x1b[24~a', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-    primary: 2048  | 10 ,
-    mac: { primary: 256  | 10  }
-});
-registerSendSequenceKeybinding('\x1b[24~b', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-    primary: 512  | 10
-});
-registerSendSequenceKeybinding('\x1b[24~c', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-    primary: 1024  | 3
-});
-registerSendSequenceKeybinding('\x1b[24~d', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
-    mac: { primary: 1024  | 2048  | 17  }
-});
-registerSendSequenceKeybinding('\x1b[24~e', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )), TerminalContextKeys.terminalShellIntegrationEnabled, ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()), ( ContextKeyExpr.equals(
-        `config.${"terminal.integrated.shellIntegration.suggestEnabled" }`,
-        true
-    )))),
-    primary: 2048  | 10 ,
-    mac: { primary: 256  | 10  }
-});
-registerSendSequenceKeybinding('\x1b[1;2H', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-        "terminalShellType",
-        "pwsh"
-    )))),
-    mac: { primary: 1024  | 2048  | 15  }
-});
-registerSendSequenceKeybinding('\x12', {
-    when: ( ContextKeyExpr.and(TerminalContextKeys.focus, CONTEXT_ACCESSIBILITY_MODE_ENABLED)),
-    primary: 2048  | 512  | 48 ,
-    mac: { primary: 256  | 512  | 48  }
-});
-registerSendSequenceKeybinding('\x07', {
-    when: TerminalContextKeys.focus,
-    primary: 2048  | 512  | 37 ,
-    mac: { primary: 256  | 512  | 37  }
-});
-if (isIOS) {
-    registerSendSequenceKeybinding(String.fromCharCode('C'.charCodeAt(0) - 64 ), {
-        when: ( ContextKeyExpr.and(TerminalContextKeys.focus)),
-        primary: 256  | 33
-    });
-}
-registerSendSequenceKeybinding(String.fromCharCode('W'.charCodeAt(0) - 64 ), {
-    primary: 2048  | 1 ,
-    mac: { primary: 512  | 1  }
-});
-if (isWindows) {
-    registerSendSequenceKeybinding(String.fromCharCode('H'.charCodeAt(0) - 64 ), {
-        when: ( ContextKeyExpr.and(TerminalContextKeys.focus, ( ContextKeyExpr.equals(
-            "terminalShellType",
-            "cmd"
-        )))),
-        primary: 2048  | 1 ,
-    });
-}
-registerSendSequenceKeybinding('\u001bd', {
-    primary: 2048  | 20 ,
-    mac: { primary: 512  | 20  }
-});
-registerSendSequenceKeybinding('\u0015', {
-    mac: { primary: 2048  | 1  }
-});
-registerSendSequenceKeybinding(String.fromCharCode('A'.charCodeAt(0) - 64), {
-    mac: { primary: 2048  | 15  }
-});
-registerSendSequenceKeybinding(String.fromCharCode('E'.charCodeAt(0) - 64), {
-    mac: { primary: 2048  | 17  }
-});
-registerSendSequenceKeybinding('\u0000', {
-    primary: 2048  | 1024  | 23 ,
-    mac: { primary: 256  | 1024  | 23  }
-});
-registerSendSequenceKeybinding('\u001e', {
-    primary: 2048  | 1024  | 27 ,
-    mac: { primary: 256  | 1024  | 27  }
-});
-registerSendSequenceKeybinding('\u001f', {
-    primary: 2048  | 90 ,
-    mac: { primary: 256  | 90  }
-});
-setupTerminalCommands();
-setupTerminalMenus();
-registerColors();