@codingame/monaco-vscode-xterm-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalContextMenu.d.ts

@@ -0,0 +1,19 @@
+import { ActionRunner, IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { SingleOrMany } from "@codingame/monaco-vscode-api/vscode/vs/base/common/types";
+import { IMenu } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ISerializedTerminalInstanceContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal";
+/**
+ * A context that is passed to actions as arguments to represent the terminal instance(s) being
+ * acted upon.
+ */
+export declare class InstanceContext {
+    readonly instanceId: number;
+    constructor(instance: ITerminalInstance);
+    toJSON(): ISerializedTerminalInstanceContext;
+}
+export declare class TerminalContextActionRunner extends ActionRunner {
+    protected runAction(action: IAction, context?: SingleOrMany<InstanceContext>): Promise<void>;
+}
+export declare function openContextMenu(targetWindow: Window, event: MouseEvent, contextInstances: SingleOrMany<ITerminalInstance> | undefined, menu: IMenu, contextMenuService: IContextMenuService, extraActions?: IAction[]): void;

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

@@ -0,0 +1,45 @@
+
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { ActionRunner } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import { getFlatContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+
+class InstanceContext {
+    constructor(instance) {
+        this.instanceId = instance.instanceId;
+    }
+    toJSON() {
+        return {
+            $mid: MarshalledId.TerminalContext,
+            instanceId: this.instanceId
+        };
+    }
+}
+class TerminalContextActionRunner extends ActionRunner {
+    async runAction(action, context) {
+        if (Array.isArray(context) && context.every(e => e instanceof InstanceContext)) {
+            await action.run(context?.[0], context);
+            return;
+        }
+        return super.runAction(action, context);
+    }
+}
+function openContextMenu(targetWindow, event, contextInstances, menu, contextMenuService, extraActions) {
+    const standardEvent = ( new StandardMouseEvent(targetWindow, event));
+    const actions = getFlatContextMenuActions(menu.getActions({ shouldForwardArgs: true }));
+    if (extraActions) {
+        actions.push(...extraActions);
+    }
+    const context = contextInstances ? ( asArray(contextInstances).map(e => ( new InstanceContext(e)))) : [];
+    const actionRunner = ( new TerminalContextActionRunner());
+    contextMenuService.showContextMenu({
+        actionRunner,
+        getAnchor: () => standardEvent,
+        getActions: () => actions,
+        getActionsContext: () => context,
+        onHide: () => actionRunner.dispose()
+    });
+}
+
+export { InstanceContext, TerminalContextActionRunner, openContextMenu };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalIconPicker.d.ts

@@ -0,0 +1,12 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILayoutService } from "@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service";
+export declare class TerminalIconPicker extends Disposable {
+    private readonly _hoverService;
+    private readonly _layoutService;
+    private readonly _iconSelectBox;
+    constructor(instantiationService: IInstantiationService, _hoverService: IHoverService, _layoutService: ILayoutService);
+    pickIcons(): Promise<ThemeIcon | undefined>;
+}

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

@@ -0,0 +1,82 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Dimension, getActiveDocument } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { codiconsLibrary } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codiconsLibrary';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { defaultInputBoxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { getIconRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { WorkbenchIconSelectBox } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/browser/iconSelectBox';
+
+const icons = ( new Lazy(() => {
+    const iconDefinitions = getIconRegistry().getIcons();
+    const includedChars = ( new Set());
+    const dedupedIcons = iconDefinitions.filter(e => {
+        if (e.id === codiconsLibrary.blank.id) {
+            return false;
+        }
+        if (ThemeIcon.isThemeIcon(e.defaults)) {
+            return false;
+        }
+        if (( includedChars.has(e.defaults.fontCharacter))) {
+            return false;
+        }
+        includedChars.add(e.defaults.fontCharacter);
+        return true;
+    });
+    return dedupedIcons;
+}));
+let TerminalIconPicker = class TerminalIconPicker extends Disposable {
+    constructor(instantiationService, _hoverService, _layoutService) {
+        super();
+        this._hoverService = _hoverService;
+        this._layoutService = _layoutService;
+        this._iconSelectBox = instantiationService.createInstance(WorkbenchIconSelectBox, {
+            icons: icons.value,
+            inputBoxStyles: defaultInputBoxStyles
+        });
+    }
+    async pickIcons() {
+        const dimension = ( new Dimension(486, 260));
+        return ( new Promise(resolve => {
+            this._register(this._iconSelectBox.onDidSelect(e => {
+                resolve(e);
+                this._iconSelectBox.dispose();
+            }));
+            this._iconSelectBox.clearInput();
+            const body = getActiveDocument().body;
+            const bodyRect = body.getBoundingClientRect();
+            const hoverWidget = this._hoverService.showInstantHover({
+                content: this._iconSelectBox.domNode,
+                target: {
+                    targetElements: [body],
+                    x: bodyRect.left + (bodyRect.width - dimension.width) / 2,
+                    y: bodyRect.top + this._layoutService.activeContainerOffset.quickPickTop - 2
+                },
+                position: {
+                    hoverPosition: HoverPosition.BELOW,
+                },
+                persistence: {
+                    sticky: true,
+                },
+            }, true);
+            if (hoverWidget) {
+                this._register(hoverWidget);
+            }
+            this._iconSelectBox.layout(dimension);
+            this._iconSelectBox.focus();
+        }));
+    }
+};
+TerminalIconPicker = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IHoverService)),
+    ( __param(2, ILayoutService))
+], TerminalIconPicker));
+
+export { TerminalIconPicker };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalInstance.d.ts

@@ -0,0 +1,408 @@
+import * as dom from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, DisposableStore, type IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IMarkProperties } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { TerminalCapabilityStoreMultiplexer } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/terminalCapabilityStore";
+import { IMergedEnvironmentVariableCollection } from "../../../../platform/terminal/common/environmentVariable.js";
+import { IReconnectionProperties, IShellLaunchConfig, ITerminalDimensionsOverride, ITerminalLaunchError, TerminalExitReason, TerminalIcon, TerminalLocation, TerminalShellType, TitleEventSource, type ShellIntegrationInjectionFailureReason } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import { IColorTheme } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
+import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
+import { IRequestAddInstanceToGroupEvent, ITerminalContribution, ITerminalInstance, IXtermColorProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { TerminalProcessManager } from "./terminalProcessManager.js";
+import { ITerminalStatusList } from "./terminalStatusList.js";
+import { XtermTerminal } from "@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal";
+import { ProcessState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal";
+import { ITerminalProfileResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import type { IMarker, Terminal as XTermTerminal } from "@xterm/xterm";
+import type { IMenu } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import type { IProgressState } from "@xterm/addon-progress";
+export declare class TerminalInstance extends Disposable implements ITerminalInstance {
+    private readonly _terminalShellTypeContextKey;
+    private _shellLaunchConfig;
+    private readonly _contextKeyService;
+    private readonly _contextMenuService;
+    private readonly _terminalConfigurationService;
+    private readonly _terminalProfileResolverService;
+    private readonly _pathService;
+    private readonly _fileService;
+    private readonly _keybindingService;
+    private readonly _notificationService;
+    private readonly _preferencesService;
+    private readonly _viewsService;
+    private readonly _themeService;
+    private readonly _configurationService;
+    private readonly _logService;
+    private readonly _storageService;
+    private readonly _accessibilityService;
+    private readonly _productService;
+    private readonly _quickInputService;
+    private readonly _workbenchEnvironmentService;
+    private readonly _workspaceContextService;
+    private readonly _editorService;
+    private readonly _workspaceTrustRequestService;
+    private readonly _historyService;
+    private readonly _telemetryService;
+    private readonly _openerService;
+    private readonly _commandService;
+    private readonly _accessibilitySignalService;
+    private readonly _viewDescriptorService;
+    private static _lastKnownCanvasDimensions;
+    private static _lastKnownGridDimensions;
+    private static _instanceIdCounter;
+    private readonly _scopedInstantiationService;
+    private readonly _processManager;
+    private readonly _contributions;
+    private readonly _resource;
+    /**
+     * Resolves when xterm.js is ready, this will be undefined if the terminal instance is disposed
+     * before xterm.js could be created.
+     */
+    private _xtermReadyPromise;
+    get xtermReadyPromise(): Promise<XtermTerminal | undefined>;
+    private _pressAnyKeyToCloseListener;
+    private _instanceId;
+    private _latestXtermWriteData;
+    private _latestXtermParseData;
+    private _isExiting;
+    private _hadFocusOnExit;
+    private _isVisible;
+    private _exitCode;
+    private _exitReason;
+    private _skipTerminalCommands;
+    private _shellType;
+    private _title;
+    private _titleSource;
+    private _container;
+    private _wrapperElement;
+    get domElement(): HTMLElement;
+    private _horizontalScrollbar;
+    private _terminalFocusContextKey;
+    private _terminalHasFixedWidth;
+    private _terminalHasTextContextKey;
+    private _terminalAltBufferActiveContextKey;
+    private _terminalShellIntegrationEnabledContextKey;
+    private _cols;
+    private _rows;
+    private _fixedCols;
+    private _fixedRows;
+    private _cwd;
+    private _initialCwd;
+    private _injectedArgs;
+    private _layoutSettingsChanged;
+    private _dimensionsOverride;
+    private _areLinksReady;
+    private readonly _initialDataEventsListener;
+    private _initialDataEvents;
+    private _containerReadyBarrier;
+    private _attachBarrier;
+    private _icon;
+    private readonly _messageTitleDisposable;
+    private _widgetManager;
+    private readonly _dndObserver;
+    private _lastLayoutDimensions;
+    private _hasHadInput;
+    private _description?;
+    private _processName;
+    private _sequence?;
+    private _staticTitle?;
+    private _workspaceFolder?;
+    private _labelComputer?;
+    private _userHome?;
+    private _hasScrollBar?;
+    private _usedShellIntegrationInjection;
+    get usedShellIntegrationInjection(): boolean;
+    private _shellIntegrationInjectionInfo;
+    get shellIntegrationInjectionFailureReason(): ShellIntegrationInjectionFailureReason | undefined;
+    private _lineDataEventAddon;
+    private readonly _scopedContextKeyService;
+    private _resizeDebouncer?;
+    readonly capabilities: TerminalCapabilityStoreMultiplexer;
+    readonly statusList: ITerminalStatusList;
+    get store(): DisposableStore;
+    get extEnvironmentVariableCollection(): IMergedEnvironmentVariableCollection | undefined;
+    xterm?: XtermTerminal;
+    disableLayout: boolean;
+    get waitOnExit(): ITerminalInstance["waitOnExit"];
+    set waitOnExit(value: ITerminalInstance["waitOnExit"]);
+    private _targetRef;
+    get targetRef(): IReference<TerminalLocation | undefined>;
+    get target(): TerminalLocation | undefined;
+    set target(value: TerminalLocation | undefined);
+    get instanceId(): number;
+    get resource(): URI;
+    get cols(): number;
+    get rows(): number;
+    get isDisposed(): boolean;
+    get fixedCols(): number | undefined;
+    get fixedRows(): number | undefined;
+    get maxCols(): number;
+    get maxRows(): number;
+    get processId(): number | undefined;
+    get processReady(): Promise<void>;
+    get hasChildProcesses(): boolean;
+    get reconnectionProperties(): IReconnectionProperties | undefined;
+    get areLinksReady(): boolean;
+    get initialDataEvents(): string[] | undefined;
+    get exitCode(): number | undefined;
+    get exitReason(): TerminalExitReason | undefined;
+    get hadFocusOnExit(): boolean;
+    get isTitleSetByProcess(): boolean;
+    get shellLaunchConfig(): IShellLaunchConfig;
+    get shellType(): TerminalShellType | undefined;
+    get os(): OperatingSystem | undefined;
+    get hasRemoteAuthority(): boolean;
+    get remoteAuthority(): string | undefined;
+    get hasFocus(): boolean;
+    get title(): string;
+    get titleSource(): TitleEventSource;
+    get icon(): TerminalIcon | undefined;
+    get color(): string | undefined;
+    get processName(): string;
+    get sequence(): string | undefined;
+    get staticTitle(): string | undefined;
+    get progressState(): IProgressState | undefined;
+    get workspaceFolder(): IWorkspaceFolder | undefined;
+    get cwd(): string | undefined;
+    get initialCwd(): string | undefined;
+    get description(): string | undefined;
+    get userHome(): string | undefined;
+    get shellIntegrationNonce(): string;
+    get injectedArgs(): string[] | undefined;
+    private readonly _onExit;
+    readonly onExit: Event<number | ITerminalLaunchError | undefined>;
+    private readonly _onDisposed;
+    readonly onDisposed: Event<ITerminalInstance>;
+    private readonly _onProcessIdReady;
+    readonly onProcessIdReady: Event<ITerminalInstance>;
+    private readonly _onProcessReplayComplete;
+    readonly onProcessReplayComplete: Event<void>;
+    private readonly _onTitleChanged;
+    readonly onTitleChanged: Event<ITerminalInstance>;
+    private readonly _onIconChanged;
+    readonly onIconChanged: Event<{
+        instance: ITerminalInstance;
+        userInitiated: boolean;
+    }>;
+    private readonly _onWillData;
+    readonly onWillData: Event<string>;
+    private readonly _onData;
+    readonly onData: Event<string>;
+    private readonly _onBinary;
+    readonly onBinary: Event<string>;
+    private readonly _onRequestExtHostProcess;
+    readonly onRequestExtHostProcess: Event<ITerminalInstance>;
+    private readonly _onDimensionsChanged;
+    readonly onDimensionsChanged: Event<void>;
+    private readonly _onMaximumDimensionsChanged;
+    readonly onMaximumDimensionsChanged: Event<void>;
+    private readonly _onDidFocus;
+    readonly onDidFocus: Event<ITerminalInstance>;
+    private readonly _onDidRequestFocus;
+    readonly onDidRequestFocus: Event<void>;
+    private readonly _onDidBlur;
+    readonly onDidBlur: Event<ITerminalInstance>;
+    private readonly _onDidInputData;
+    readonly onDidInputData: Event<string>;
+    private readonly _onDidChangeSelection;
+    readonly onDidChangeSelection: Event<ITerminalInstance>;
+    private readonly _onRequestAddInstanceToGroup;
+    readonly onRequestAddInstanceToGroup: Event<IRequestAddInstanceToGroupEvent>;
+    private readonly _onDidChangeHasChildProcesses;
+    readonly onDidChangeHasChildProcesses: Event<boolean>;
+    private readonly _onDidExecuteText;
+    readonly onDidExecuteText: Event<void>;
+    private readonly _onDidChangeTarget;
+    readonly onDidChangeTarget: Event<TerminalLocation | undefined>;
+    private readonly _onDidSendText;
+    readonly onDidSendText: Event<string>;
+    private readonly _onDidChangeShellType;
+    readonly onDidChangeShellType: Event<TerminalShellType>;
+    private readonly _onDidChangeVisibility;
+    readonly onDidChangeVisibility: Event<boolean>;
+    private readonly _onLineData;
+    readonly onLineData: Event<string>;
+    readonly sessionId: string;
+    constructor(_terminalShellTypeContextKey: IContextKey<string>, _shellLaunchConfig: IShellLaunchConfig, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, instantiationService: IInstantiationService, _terminalConfigurationService: ITerminalConfigurationService, _terminalProfileResolverService: ITerminalProfileResolverService, _pathService: IPathService, _fileService: IFileService, _keybindingService: IKeybindingService, _notificationService: INotificationService, _preferencesService: IPreferencesService, _viewsService: IViewsService, _themeService: IThemeService, _configurationService: IConfigurationService, _logService: ITerminalLogService, _storageService: IStorageService, _accessibilityService: IAccessibilityService, _productService: IProductService, _quickInputService: IQuickInputService, _workbenchEnvironmentService: IWorkbenchEnvironmentService, _workspaceContextService: IWorkspaceContextService, _editorService: IEditorService, _workspaceTrustRequestService: IWorkspaceTrustRequestService, _historyService: IHistoryService, _telemetryService: ITelemetryService, _openerService: IOpenerService, _commandService: ICommandService, _accessibilitySignalService: IAccessibilitySignalService, _viewDescriptorService: IViewDescriptorService);
+    getContribution<T extends ITerminalContribution>(id: string): T | null;
+    private _handleOnData;
+    private _getIcon;
+    private _getColor;
+    private _initDimensions;
+    /**
+     * Evaluates and sets the cols and rows of the terminal if possible.
+     * @param width The width of the container.
+     * @param height The height of the container.
+     * @return The terminal's width if it requires a layout.
+     */
+    private _evaluateColsAndRows;
+    private _setLastKnownColsAndRows;
+    private _fireMaximumDimensionsChanged;
+    private _getDimension;
+    get persistentProcessId(): number | undefined;
+    get shouldPersist(): boolean;
+    static getXtermConstructor(keybindingService: IKeybindingService, contextKeyService: IContextKeyService): Promise<typeof XTermTerminal>;
+    /**
+     * Create xterm.js instance and attach data listeners.
+     */
+    protected _createXterm(): Promise<XtermTerminal | undefined>;
+    runCommand(commandLine: string, shouldExecute: boolean, commandId?: string): Promise<void>;
+    detachFromElement(): void;
+    attachToElement(container: HTMLElement): void;
+    /**
+     * Opens the terminal instance inside the parent DOM element previously set with
+     * `attachToElement`, you must ensure the parent DOM element is explicitly visible before
+     * invoking this function as it performs some DOM calculations internally
+     */
+    private _open;
+    private _setFocus;
+    private _setShellIntegrationContextKey;
+    resetFocusContextKey(): void;
+    private _initDragAndDrop;
+    hasSelection(): boolean;
+    get selection(): string | undefined;
+    clearSelection(): void;
+    private _refreshAltBufferContextKey;
+    dispose(reason?: TerminalExitReason): void;
+    detachProcessAndDispose(reason: TerminalExitReason): Promise<void>;
+    focus(force?: boolean): void;
+    focusWhenReady(force?: boolean): Promise<void>;
+    sendText(text: string, shouldExecute: boolean, bracketedPasteMode?: boolean): Promise<void>;
+    sendSignal(signal: string): Promise<void>;
+    sendPath(originalPath: string | URI, shouldExecute: boolean): Promise<void>;
+    preparePathForShell(originalPath: string | URI): Promise<string>;
+    getUriLabelForShell(uri: URI): Promise<string>;
+    setVisible(visible: boolean): void;
+    scrollDownLine(): void;
+    scrollDownPage(): void;
+    scrollToBottom(): void;
+    scrollUpLine(): void;
+    scrollUpPage(): void;
+    scrollToTop(): void;
+    clearBuffer(): void;
+    private _refreshSelectionContextKey;
+    protected _createProcessManager(): TerminalProcessManager;
+    private _createProcess;
+    registerMarker(offset?: number): IMarker | undefined;
+    addBufferMarker(properties: IMarkProperties): void;
+    scrollToMark(startMarkId: string, endMarkId?: string, highlight?: boolean): void;
+    freePortKillProcess(port: string, command: string): Promise<void>;
+    private _onProcessData;
+    private _writeProcessData;
+    /**
+     * Called when either a process tied to a terminal has exited or when a terminal renderer
+     * simulates a process exiting (e.g. custom execution task).
+     * @param exitCode The exit code of the process, this is undefined when the terminal was exited
+     * through user action.
+     */
+    private _onProcessExit;
+    private _relaunchWithShellIntegrationDisabled;
+    /**
+     * Ensure write calls to xterm.js have finished before resolving.
+     */
+    private _flushXtermData;
+    private _attachPressAnyKeyToCloseListener;
+    private _writeInitialText;
+    reuseTerminal(shell: IShellLaunchConfig, reset?: boolean): Promise<void>;
+    relaunch(): void;
+    private _onTitleChange;
+    private _trust;
+    private _updateProcessCwd;
+    updateConfig(): void;
+    private _updateUnicodeVersion;
+    updateAccessibilitySupport(): void;
+    private _setCommandsToSkipShell;
+    layout(dimension: dom.Dimension): void;
+    private _resize;
+    private _updatePtyDimensions;
+    setShellType(shellType: TerminalShellType | undefined): void;
+    private _setAriaLabel;
+    private _updateTitleProperties;
+    setOverrideDimensions(dimensions: ITerminalDimensionsOverride | undefined, immediate?: boolean): void;
+    setFixedDimensions(): Promise<void>;
+    private _parseFixedDimension;
+    toggleSizeToContentWidth(): Promise<void>;
+    private _refreshScrollbar;
+    private _addScrollbar;
+    private _removeScrollbar;
+    private _setResolvedShellLaunchConfig;
+    private _onEnvironmentVariableInfoChanged;
+    private _refreshEnvironmentVariableInfoWidgetState;
+    getInitialCwd(): Promise<string>;
+    getSpeculativeCwd(): Promise<string>;
+    getCwdResource(): Promise<URI | undefined>;
+    private _refreshProperty;
+    private _updateProperty;
+    rename(title?: string, source?: TitleEventSource): Promise<void>;
+    private _setTitle;
+    changeIcon(icon?: TerminalIcon): Promise<TerminalIcon | undefined>;
+    changeColor(color?: string, skipQuickPick?: boolean): Promise<string | undefined>;
+    forceScrollbarVisibility(): void;
+    resetScrollbarVisibility(): void;
+    setParentContextKeyService(parentContextKeyService: IContextKeyService): void;
+    handleMouseEvent(event: MouseEvent, contextMenu: IMenu): Promise<{
+        cancelContextMenu: boolean;
+    } | void>;
+}
+declare enum TerminalLabelType {
+    Title = "title",
+    Description = "description"
+}
+export declare class TerminalLabelComputer extends Disposable {
+    private readonly _fileService;
+    private readonly _terminalConfigurationService;
+    private readonly _workspaceContextService;
+    private _title;
+    private _description;
+    get title(): string | undefined;
+    get description(): string;
+    private readonly _onDidChangeLabel;
+    readonly onDidChangeLabel: Event<{
+        title: string;
+        description: string;
+    }>;
+    constructor(_fileService: IFileService, _terminalConfigurationService: ITerminalConfigurationService, _workspaceContextService: IWorkspaceContextService);
+    refreshLabel(instance: Pick<ITerminalInstance, "shellLaunchConfig" | "shellType" | "cwd" | "fixedCols" | "fixedRows" | "initialCwd" | "processName" | "sequence" | "userHome" | "workspaceFolder" | "staticTitle" | "capabilities" | "title" | "description">, reset?: boolean): void;
+    computeLabel(instance: Pick<ITerminalInstance, "shellLaunchConfig" | "shellType" | "cwd" | "fixedCols" | "fixedRows" | "initialCwd" | "processName" | "sequence" | "userHome" | "workspaceFolder" | "staticTitle" | "capabilities" | "title" | "description" | "progressState">, labelTemplate: string, labelType: TerminalLabelType, reset?: boolean): string;
+    private _getProgressStateString;
+}
+export declare function parseExitResult(exitCodeOrError: ITerminalLaunchError | number | undefined, shellLaunchConfig: IShellLaunchConfig, processState: ProcessState, initialCwd: string | undefined): {
+    code: number | undefined;
+    message: string | undefined;
+} | undefined;
+export declare class TerminalInstanceColorProvider implements IXtermColorProvider {
+    private readonly _target;
+    private readonly _viewDescriptorService;
+    constructor(_target: IReference<TerminalLocation | undefined>, _viewDescriptorService: IViewDescriptorService);
+    getBackgroundColor(theme: IColorTheme): import("@codingame/monaco-vscode-api/vscode/vs/base/common/color").Color | undefined;
+}
+export {};