@codingame/monaco-vscode-xterm-addons-common 24.1.0

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/xtermTerminal.js

@@ -0,0 +1,867 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isAncestorOfActiveElement, getActiveWindow, addDisposableListener, EventType, getWindow, getDocument } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { TerminalSettingId } 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 { XtermTerminalConstants } 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 { LogLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { MarkNavigationAddon, ScrollPosition } from './markNavigationAddon.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { PANEL_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
+import { TERMINAL_BACKGROUND_COLOR, TERMINAL_FIND_MATCH_BACKGROUND_COLOR, TERMINAL_FIND_MATCH_BORDER_COLOR, TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR, TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR, TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR, TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR, TERMINAL_FOREGROUND_COLOR, TERMINAL_CURSOR_FOREGROUND_COLOR, TERMINAL_CURSOR_BACKGROUND_COLOR, TERMINAL_SELECTION_BACKGROUND_COLOR, TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR, TERMINAL_SELECTION_FOREGROUND_COLOR, ansiColorIdentifiers, TERMINAL_OVERVIEW_RULER_BORDER_COLOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
+import { ShellIntegrationAddon } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/xterm/shellIntegrationAddon';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { DecorationAddon } from './decorationAddon.js';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { TerminalContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { debounce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/decorators';
+import { MouseWheelClassifier } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { StandardWheelEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import { scrollbarSliderHoverBackground, scrollbarSliderBackground, scrollbarSliderActiveBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { XtermAddonImporter } from './xtermAddonImporter.js';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+
+var XtermTerminal_1;
+var RenderConstants;
+(function (RenderConstants) {
+    RenderConstants[RenderConstants["SmoothScrollDuration"] = 125] = "SmoothScrollDuration";
+})(RenderConstants || (RenderConstants = {}));
+function getFullBufferLineAsString(lineIndex, buffer) {
+    let line = buffer.getLine(lineIndex);
+    if (!line) {
+        return { lineData: undefined, lineIndex };
+    }
+    let lineData = line.translateToString(true);
+    while (lineIndex > 0 && line.isWrapped) {
+        line = buffer.getLine(--lineIndex);
+        if (!line) {
+            break;
+        }
+        lineData = line.translateToString(false) + lineData;
+    }
+    return { lineData, lineIndex };
+}
+let XtermTerminal = class XtermTerminal extends Disposable {
+    static { XtermTerminal_1 = this; }
+    static { this._suggestedRendererType = undefined; }
+    get lastInputEvent() { return this._lastInputEvent; }
+    get progressState() { return this._progressState; }
+    get findResult() { return this._lastFindResult; }
+    get isStdinDisabled() { return !!this.raw.options.disableStdin; }
+    get isGpuAccelerated() { return !!this._webglAddon; }
+    get markTracker() { return this._markNavigationAddon; }
+    get shellIntegration() { return this._shellIntegrationAddon; }
+    get decorationAddon() { return this._decorationAddon; }
+    get textureAtlas() {
+        const canvas = this._webglAddon?.textureAtlas;
+        if (!canvas) {
+            return undefined;
+        }
+        return createImageBitmap(canvas);
+    }
+    get isFocused() {
+        if (!this.raw.element) {
+            return false;
+        }
+        return isAncestorOfActiveElement(this.raw.element);
+    }
+    constructor(resource, xtermCtor, options, _onDidExecuteText, _configurationService, _instantiationService, _logService, _notificationService, _themeService, _telemetryService, _terminalConfigurationService, _clipboardService, contextKeyService, _accessibilitySignalService, layoutService) {
+        super();
+        this._onDidExecuteText = _onDidExecuteText;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._notificationService = _notificationService;
+        this._themeService = _themeService;
+        this._telemetryService = _telemetryService;
+        this._terminalConfigurationService = _terminalConfigurationService;
+        this._clipboardService = _clipboardService;
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._isPhysicalMouseWheel = MouseWheelClassifier.INSTANCE.isPhysicalMouseWheel();
+        this._progressState = { state: 0, value: 0 };
+        this._ligaturesAddon = this._register(( new MutableDisposable()));
+        this._attachedDisposables = this._register(( new DisposableStore()));
+        this._onDidRequestRunCommand = this._register(( new Emitter()));
+        this.onDidRequestRunCommand = this._onDidRequestRunCommand.event;
+        this._onDidRequestCopyAsHtml = this._register(( new Emitter()));
+        this.onDidRequestCopyAsHtml = this._onDidRequestCopyAsHtml.event;
+        this._onDidRequestRefreshDimensions = this._register(( new Emitter()));
+        this.onDidRequestRefreshDimensions = this._onDidRequestRefreshDimensions.event;
+        this._onDidChangeFindResults = this._register(( new Emitter()));
+        this.onDidChangeFindResults = this._onDidChangeFindResults.event;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this._onDidChangeFocus = this._register(( new Emitter()));
+        this.onDidChangeFocus = this._onDidChangeFocus.event;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._onDidChangeProgress = this._register(( new Emitter()));
+        this.onDidChangeProgress = this._onDidChangeProgress.event;
+        this._xtermAddonLoader = options.xtermAddonImporter ?? ( new XtermAddonImporter());
+        this._xtermColorProvider = options.xtermColorProvider;
+        this._capabilities = options.capabilities;
+        const font = this._terminalConfigurationService.getFont(getActiveWindow(), undefined, true);
+        const config = this._terminalConfigurationService.config;
+        const editorOptions = this._configurationService.getValue('editor');
+        this.raw = this._register(( new xtermCtor({
+            allowProposedApi: true,
+            cols: options.cols,
+            rows: options.rows,
+            documentOverride: layoutService.mainContainer.ownerDocument,
+            altClickMovesCursor: config.altClickMovesCursor && editorOptions.multiCursorModifier === 'alt',
+            scrollback: config.scrollback,
+            theme: this.getXtermTheme(),
+            drawBoldTextInBrightColors: config.drawBoldTextInBrightColors,
+            fontFamily: font.fontFamily,
+            fontWeight: config.fontWeight,
+            fontWeightBold: config.fontWeightBold,
+            fontSize: font.fontSize,
+            letterSpacing: font.letterSpacing,
+            lineHeight: font.lineHeight,
+            logLevel: vscodeToXtermLogLevel(this._logService.getLevel()),
+            logger: this._logService,
+            minimumContrastRatio: config.minimumContrastRatio,
+            tabStopWidth: config.tabStopWidth,
+            cursorBlink: config.cursorBlinking,
+            cursorStyle: vscodeToXtermCursorStyle(config.cursorStyle),
+            cursorInactiveStyle: vscodeToXtermCursorStyle(config.cursorStyleInactive),
+            cursorWidth: config.cursorWidth,
+            macOptionIsMeta: config.macOptionIsMeta,
+            macOptionClickForcesSelection: config.macOptionClickForcesSelection,
+            rightClickSelectsWord: config.rightClickBehavior === 'selectWord',
+            fastScrollModifier: 'alt',
+            fastScrollSensitivity: config.fastScrollSensitivity,
+            scrollSensitivity: config.mouseWheelScrollSensitivity,
+            scrollOnEraseInDisplay: true,
+            wordSeparator: config.wordSeparators,
+            overviewRuler: options.disableOverviewRuler ? { width: 0 } : {
+                width: 14,
+                showTopBorder: true,
+            },
+            ignoreBracketedPasteMode: config.ignoreBracketedPasteMode,
+            rescaleOverlappingGlyphs: config.rescaleOverlappingGlyphs,
+            windowOptions: {
+                getWinSizePixels: true,
+                getCellSizePixels: true,
+                getWinSizeChars: true,
+            },
+        })));
+        this._updateSmoothScrolling();
+        this._core = this.raw._core;
+        this._register(this._configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration(TerminalSettingId.GpuAcceleration)) {
+                XtermTerminal_1._suggestedRendererType = undefined;
+            }
+            if (e.affectsConfiguration('terminal.integrated') || e.affectsConfiguration('editor.fastScrollSensitivity') || e.affectsConfiguration('editor.mouseWheelScrollSensitivity') || e.affectsConfiguration('editor.multiCursorModifier')) {
+                this.updateConfig();
+            }
+            if (e.affectsConfiguration(TerminalSettingId.UnicodeVersion)) {
+                this._updateUnicodeVersion();
+            }
+            if (e.affectsConfiguration(TerminalSettingId.ShellIntegrationDecorationsEnabled)) {
+                this._updateTheme();
+            }
+        }));
+        this._register(this._themeService.onDidColorThemeChange(theme => this._updateTheme(theme)));
+        this._register(this._logService.onDidChangeLogLevel(e => this.raw.options.logLevel = vscodeToXtermLogLevel(e)));
+        this._register(this.raw.onSelectionChange(() => {
+            this._onDidChangeSelection.fire();
+            if (this.isFocused) {
+                this._anyFocusedTerminalHasSelection.set(this.raw.hasSelection());
+            }
+        }));
+        this._register(this.raw.onData(e => this._lastInputEvent = e));
+        this._updateUnicodeVersion();
+        this._markNavigationAddon = this._instantiationService.createInstance(MarkNavigationAddon, options.capabilities);
+        this.raw.loadAddon(this._markNavigationAddon);
+        this._decorationAddon = this._instantiationService.createInstance(DecorationAddon, resource, this._capabilities);
+        this._register(this._decorationAddon.onDidRequestRunCommand(e => this._onDidRequestRunCommand.fire(e)));
+        this._register(this._decorationAddon.onDidRequestCopyAsHtml(e => this._onDidRequestCopyAsHtml.fire(e)));
+        this.raw.loadAddon(this._decorationAddon);
+        this._shellIntegrationAddon = ( new ShellIntegrationAddon(
+            options.shellIntegrationNonce ?? '',
+            options.disableShellIntegrationReporting,
+            this._onDidExecuteText,
+            this._telemetryService,
+            this._logService
+        ));
+        this.raw.loadAddon(this._shellIntegrationAddon);
+        this._xtermAddonLoader.importAddon('clipboard').then(ClipboardAddon => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._clipboardAddon = this._instantiationService.createInstance(ClipboardAddon, undefined, {
+                async readText(type) {
+                    return _clipboardService.readText(type === 'p' ? 'selection' : 'clipboard');
+                },
+                async writeText(type, text) {
+                    return _clipboardService.writeText(text, type === 'p' ? 'selection' : 'clipboard');
+                }
+            });
+            this.raw.loadAddon(this._clipboardAddon);
+        });
+        this._xtermAddonLoader.importAddon('progress').then(ProgressAddon => {
+            if (this._store.isDisposed) {
+                return;
+            }
+            const progressAddon = this._instantiationService.createInstance(ProgressAddon);
+            this.raw.loadAddon(progressAddon);
+            const updateProgress = () => {
+                if (!equals(this._progressState, progressAddon.progress)) {
+                    this._progressState = progressAddon.progress;
+                    this._onDidChangeProgress.fire(this._progressState);
+                }
+            };
+            this._register(progressAddon.onChange(() => updateProgress()));
+            updateProgress();
+            const commandDetection = this._capabilities.get(TerminalCapability.CommandDetection);
+            if (commandDetection) {
+                this._register(commandDetection.onCommandFinished(() => progressAddon.progress = { state: 0, value: 0 }));
+            }
+            else {
+                const disposable = this._capabilities.onDidAddCapability(e => {
+                    if (e.id === TerminalCapability.CommandDetection) {
+                        this._register(e.capability.onCommandFinished(() => progressAddon.progress = { state: 0, value: 0 }));
+                        this._store.delete(disposable);
+                    }
+                });
+                this._store.add(disposable);
+            }
+        });
+        this._anyTerminalFocusContextKey = TerminalContextKeys.focusInAny.bindTo(contextKeyService);
+        this._anyFocusedTerminalHasSelection = TerminalContextKeys.textSelectedInFocused.bindTo(contextKeyService);
+    }
+    *getBufferReverseIterator() {
+        for (let i = this.raw.buffer.active.length - 1; i >= 0; i--) {
+            const { lineData, lineIndex } = getFullBufferLineAsString(i, this.raw.buffer.active);
+            if (lineData) {
+                i = lineIndex;
+                yield lineData;
+            }
+        }
+    }
+    getContentsAsText(startMarker, endMarker) {
+        const lines = [];
+        const buffer = this.raw.buffer.active;
+        if (startMarker?.line === -1) {
+            throw ( new Error('Cannot get contents of a disposed startMarker'));
+        }
+        if (endMarker?.line === -1) {
+            throw ( new Error('Cannot get contents of a disposed endMarker'));
+        }
+        const startLine = startMarker?.line ?? 0;
+        const endLine = endMarker?.line ?? buffer.length - 1;
+        for (let y = startLine; y <= endLine; y++) {
+            lines.push(buffer.getLine(y)?.translateToString(true) ?? '');
+        }
+        return lines.join('\n');
+    }
+    async getContentsAsHtml() {
+        if (!this._serializeAddon) {
+            const Addon = await this._xtermAddonLoader.importAddon('serialize');
+            this._serializeAddon = ( new Addon());
+            this.raw.loadAddon(this._serializeAddon);
+        }
+        return this._serializeAddon.serializeAsHTML();
+    }
+    async getCommandOutputAsHtml(command, maxLines) {
+        if (!this._serializeAddon) {
+            const Addon = await this._xtermAddonLoader.importAddon('serialize');
+            this._serializeAddon = ( new Addon());
+            this.raw.loadAddon(this._serializeAddon);
+        }
+        let startLine;
+        let startCol;
+        if (command.executedMarker && command.executedMarker.line >= 0) {
+            startLine = command.executedMarker.line;
+            startCol = Math.max(command.executedX ?? 0, 0);
+        }
+        else {
+            startLine = command.marker?.line !== undefined ? command.marker.line + 1 : 1;
+            startCol = Math.max(command.startX ?? 0, 0);
+        }
+        let endLine = command.endMarker?.line !== undefined ? command.endMarker.line - 1 : this.raw.buffer.active.length - 1;
+        if (endLine < startLine) {
+            return { text: '', truncated: false };
+        }
+        let emptyLinesFromEnd = 0;
+        for (let i = endLine; i >= startLine; i--) {
+            const line = this.raw.buffer.active.getLine(i);
+            if (line && line.translateToString(true).trim() === '') {
+                emptyLinesFromEnd++;
+            }
+            else {
+                break;
+            }
+        }
+        endLine = endLine - emptyLinesFromEnd;
+        let emptyLinesFromStart = 0;
+        for (let i = startLine; i <= endLine; i++) {
+            const line = this.raw.buffer.active.getLine(i);
+            if (line && line.translateToString(true, i === startLine ? startCol : undefined).trim() === '') {
+                if (i === startLine) {
+                    startCol = 0;
+                }
+                emptyLinesFromStart++;
+            }
+            else {
+                break;
+            }
+        }
+        startLine = startLine + emptyLinesFromStart;
+        if (maxLines && endLine - startLine > maxLines) {
+            startLine = endLine - maxLines;
+            startCol = 0;
+        }
+        const bufferLine = this.raw.buffer.active.getLine(startLine);
+        if (bufferLine) {
+            startCol = Math.min(startCol, bufferLine.length);
+        }
+        const range = { startLine, endLine, startCol };
+        const result = this._serializeAddon.serializeAsHTML({ range });
+        return { text: result, truncated: (endLine - startLine) >= maxLines };
+    }
+    async getSelectionAsHtml(command) {
+        if (!this._serializeAddon) {
+            const Addon = await this._xtermAddonLoader.importAddon('serialize');
+            this._serializeAddon = ( new Addon());
+            this.raw.loadAddon(this._serializeAddon);
+        }
+        if (command) {
+            const length = command.getOutput()?.length;
+            const row = command.marker?.line;
+            if (!length || !row) {
+                throw ( new Error(`No row ${row} or output length ${length} for command ${command}`));
+            }
+            this.raw.select(0, row + 1, length - Math.floor(length / this.raw.cols));
+        }
+        const result = this._serializeAddon.serializeAsHTML({ onlySelection: true });
+        if (command) {
+            this.raw.clearSelection();
+        }
+        return result;
+    }
+    attachToElement(container, partialOptions) {
+        const options = { enableGpu: true, ...partialOptions };
+        if (!this._attached) {
+            this.raw.open(container);
+        }
+        if (options.enableGpu) {
+            if (this._shouldLoadWebgl()) {
+                this._enableWebglRenderer();
+            }
+        }
+        if (!this.raw.element || !this.raw.textarea) {
+            throw ( new Error('xterm elements not set after open'));
+        }
+        const ad = this._attachedDisposables;
+        ad.clear();
+        ad.add(addDisposableListener(this.raw.textarea, 'focus', () => this._setFocused(true)));
+        ad.add(addDisposableListener(this.raw.textarea, 'blur', () => this._setFocused(false)));
+        ad.add(addDisposableListener(this.raw.textarea, 'focusout', () => this._setFocused(false)));
+        ad.add(addDisposableListener(this.raw.element, EventType.MOUSE_WHEEL, (e) => {
+            const classifier = MouseWheelClassifier.INSTANCE;
+            classifier.acceptStandardWheelEvent(( new StandardWheelEvent(e)));
+            const value = classifier.isPhysicalMouseWheel();
+            if (value !== this._isPhysicalMouseWheel) {
+                this._isPhysicalMouseWheel = value;
+                this._updateSmoothScrolling();
+            }
+        }, { passive: true }));
+        this._refreshLigaturesAddon();
+        this._attached = { container, options };
+        return this._attached?.container.querySelector('.xterm-screen');
+    }
+    _setFocused(isFocused) {
+        this._onDidChangeFocus.fire(isFocused);
+        this._anyTerminalFocusContextKey.set(isFocused);
+        this._anyFocusedTerminalHasSelection.set(isFocused && this.raw.hasSelection());
+    }
+    write(data, callback) {
+        this.raw.write(data, callback);
+    }
+    resize(columns, rows) {
+        this._logService.debug('resizing', columns, rows);
+        this.raw.resize(columns, rows);
+    }
+    updateConfig() {
+        const config = this._terminalConfigurationService.config;
+        this.raw.options.altClickMovesCursor = config.altClickMovesCursor;
+        this._setCursorBlink(config.cursorBlinking);
+        this._setCursorStyle(config.cursorStyle);
+        this._setCursorStyleInactive(config.cursorStyleInactive);
+        this._setCursorWidth(config.cursorWidth);
+        this.raw.options.scrollback = config.scrollback;
+        this.raw.options.drawBoldTextInBrightColors = config.drawBoldTextInBrightColors;
+        this.raw.options.minimumContrastRatio = config.minimumContrastRatio;
+        this.raw.options.tabStopWidth = config.tabStopWidth;
+        this.raw.options.fastScrollSensitivity = config.fastScrollSensitivity;
+        this.raw.options.scrollSensitivity = config.mouseWheelScrollSensitivity;
+        this.raw.options.macOptionIsMeta = config.macOptionIsMeta;
+        const editorOptions = this._configurationService.getValue('editor');
+        this.raw.options.altClickMovesCursor = config.altClickMovesCursor && editorOptions.multiCursorModifier === 'alt';
+        this.raw.options.macOptionClickForcesSelection = config.macOptionClickForcesSelection;
+        this.raw.options.rightClickSelectsWord = config.rightClickBehavior === 'selectWord';
+        this.raw.options.wordSeparator = config.wordSeparators;
+        this.raw.options.customGlyphs = config.customGlyphs;
+        this.raw.options.ignoreBracketedPasteMode = config.ignoreBracketedPasteMode;
+        this.raw.options.rescaleOverlappingGlyphs = config.rescaleOverlappingGlyphs;
+        this._updateSmoothScrolling();
+        if (this._attached) {
+            if (this._attached.options.enableGpu) {
+                if (this._shouldLoadWebgl()) {
+                    this._enableWebglRenderer();
+                }
+                else {
+                    this._disposeOfWebglRenderer();
+                }
+            }
+            this._refreshLigaturesAddon();
+        }
+    }
+    _updateSmoothScrolling() {
+        this.raw.options.smoothScrollDuration = this._terminalConfigurationService.config.smoothScrolling && this._isPhysicalMouseWheel ? RenderConstants.SmoothScrollDuration : 0;
+    }
+    _shouldLoadWebgl() {
+        return (this._terminalConfigurationService.config.gpuAcceleration === 'auto' && XtermTerminal_1._suggestedRendererType === undefined) || this._terminalConfigurationService.config.gpuAcceleration === 'on';
+    }
+    forceRedraw() {
+        this.raw.clearTextureAtlas();
+    }
+    clearDecorations() {
+        this._decorationAddon?.clearDecorations();
+    }
+    forceRefresh() {
+        this._core.viewport?._innerRefresh();
+    }
+    async findNext(term, searchOptions) {
+        this._updateFindColors(searchOptions);
+        return (await this._getSearchAddon()).findNext(term, searchOptions);
+    }
+    async findPrevious(term, searchOptions) {
+        this._updateFindColors(searchOptions);
+        return (await this._getSearchAddon()).findPrevious(term, searchOptions);
+    }
+    _updateFindColors(searchOptions) {
+        const theme = this._themeService.getColorTheme();
+        const terminalBackground = theme.getColor(TERMINAL_BACKGROUND_COLOR) || theme.getColor(PANEL_BACKGROUND);
+        const findMatchBackground = theme.getColor(TERMINAL_FIND_MATCH_BACKGROUND_COLOR);
+        const findMatchBorder = theme.getColor(TERMINAL_FIND_MATCH_BORDER_COLOR);
+        const findMatchOverviewRuler = theme.getColor(TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR);
+        const findMatchHighlightBackground = theme.getColor(TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR);
+        const findMatchHighlightBorder = theme.getColor(TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR);
+        const findMatchHighlightOverviewRuler = theme.getColor(TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR);
+        searchOptions.decorations = {
+            activeMatchBackground: findMatchBackground?.toString(),
+            activeMatchBorder: findMatchBorder?.toString() || 'transparent',
+            activeMatchColorOverviewRuler: findMatchOverviewRuler?.toString() || 'transparent',
+            matchBackground: terminalBackground ? findMatchHighlightBackground?.blend(terminalBackground).toString() : undefined,
+            matchBorder: findMatchHighlightBorder?.toString() || 'transparent',
+            matchOverviewRuler: findMatchHighlightOverviewRuler?.toString() || 'transparent'
+        };
+    }
+    _getSearchAddon() {
+        if (!this._searchAddonPromise) {
+            this._searchAddonPromise = this._xtermAddonLoader.importAddon('search').then((AddonCtor) => {
+                if (this._store.isDisposed) {
+                    return Promise.reject('Could not create search addon, terminal is disposed');
+                }
+                this._searchAddon = ( new AddonCtor({ highlightLimit: XtermTerminalConstants.SearchHighlightLimit }));
+                this.raw.loadAddon(this._searchAddon);
+                this._searchAddon.onDidChangeResults((results) => {
+                    this._lastFindResult = results;
+                    this._onDidChangeFindResults.fire(results);
+                });
+                return this._searchAddon;
+            });
+        }
+        return this._searchAddonPromise;
+    }
+    clearSearchDecorations() {
+        this._searchAddon?.clearDecorations();
+    }
+    clearActiveSearchDecoration() {
+        this._searchAddon?.clearActiveDecoration();
+    }
+    getFont() {
+        return this._terminalConfigurationService.getFont(getWindow(this.raw.element), this._core);
+    }
+    getLongestViewportWrappedLineLength() {
+        let maxLineLength = 0;
+        for (let i = this.raw.buffer.active.length - 1; i >= this.raw.buffer.active.viewportY; i--) {
+            const lineInfo = this._getWrappedLineCount(i, this.raw.buffer.active);
+            maxLineLength = Math.max(maxLineLength, ((lineInfo.lineCount * this.raw.cols) - lineInfo.endSpaces) || 0);
+            i = lineInfo.currentIndex;
+        }
+        return maxLineLength;
+    }
+    _getWrappedLineCount(index, buffer) {
+        let line = buffer.getLine(index);
+        if (!line) {
+            throw ( new Error('Could not get line'));
+        }
+        let currentIndex = index;
+        let endSpaces = 0;
+        for (let i = Math.min(line.length, this.raw.cols) - 1; i >= 0; i--) {
+            if (!line?.getCell(i)?.getChars()) {
+                endSpaces++;
+            }
+            else {
+                break;
+            }
+        }
+        while (line?.isWrapped && currentIndex > 0) {
+            currentIndex--;
+            line = buffer.getLine(currentIndex);
+        }
+        return { lineCount: index - currentIndex + 1, currentIndex, endSpaces };
+    }
+    scrollDownLine() {
+        this.raw.scrollLines(1);
+    }
+    scrollDownPage() {
+        this.raw.scrollPages(1);
+    }
+    scrollToBottom() {
+        this.raw.scrollToBottom();
+    }
+    scrollUpLine() {
+        this.raw.scrollLines(-1);
+    }
+    scrollUpPage() {
+        this.raw.scrollPages(-1);
+    }
+    scrollToTop() {
+        this.raw.scrollToTop();
+    }
+    scrollToLine(line, position = ScrollPosition.Top) {
+        this.markTracker.scrollToLine(line, position);
+    }
+    clearBuffer() {
+        this.raw.clear();
+        this._capabilities.get(TerminalCapability.CommandDetection)?.handlePromptStart();
+        this._capabilities.get(TerminalCapability.CommandDetection)?.handleCommandStart();
+        this._accessibilitySignalService.playSignal(AccessibilitySignal.clear);
+    }
+    hasSelection() {
+        return this.raw.hasSelection();
+    }
+    clearSelection() {
+        this.raw.clearSelection();
+    }
+    selectMarkedRange(fromMarkerId, toMarkerId, scrollIntoView = false) {
+        const detectionCapability = this.shellIntegration.capabilities.get(TerminalCapability.BufferMarkDetection);
+        if (!detectionCapability) {
+            return;
+        }
+        const start = detectionCapability.getMark(fromMarkerId);
+        const end = detectionCapability.getMark(toMarkerId);
+        if (start === undefined || end === undefined) {
+            return;
+        }
+        this.raw.selectLines(start.line, end.line);
+        if (scrollIntoView) {
+            this.raw.scrollToLine(start.line);
+        }
+    }
+    selectAll() {
+        this.raw.focus();
+        this.raw.selectAll();
+    }
+    focus() {
+        this.raw.focus();
+    }
+    async copySelection(asHtml, command) {
+        if (this.hasSelection() || (asHtml && command)) {
+            if (asHtml) {
+                const textAsHtml = await this.getSelectionAsHtml(command);
+                function listener(e) {
+                    if (e.clipboardData) {
+                        if (!e.clipboardData.types.includes('text/plain')) {
+                            e.clipboardData.setData('text/plain', command?.getOutput() ?? '');
+                        }
+                        e.clipboardData.setData('text/html', textAsHtml);
+                    }
+                    e.preventDefault();
+                }
+                const doc = getDocument(this.raw.element);
+                doc.addEventListener('copy', listener);
+                doc.execCommand('copy');
+                doc.removeEventListener('copy', listener);
+            }
+            else {
+                await this._clipboardService.writeText(this.raw.getSelection());
+            }
+        }
+        else {
+            this._notificationService.warn(( localize(11673, 'The terminal has no selection to copy')));
+        }
+    }
+    _setCursorBlink(blink) {
+        if (this.raw.options.cursorBlink !== blink) {
+            this.raw.options.cursorBlink = blink;
+            this.raw.refresh(0, this.raw.rows - 1);
+        }
+    }
+    _setCursorStyle(style) {
+        const mapped = vscodeToXtermCursorStyle(style);
+        if (this.raw.options.cursorStyle !== mapped) {
+            this.raw.options.cursorStyle = mapped;
+        }
+    }
+    _setCursorStyleInactive(style) {
+        const mapped = vscodeToXtermCursorStyle(style);
+        if (this.raw.options.cursorInactiveStyle !== mapped) {
+            this.raw.options.cursorInactiveStyle = mapped;
+        }
+    }
+    _setCursorWidth(width) {
+        if (this.raw.options.cursorWidth !== width) {
+            this.raw.options.cursorWidth = width;
+        }
+    }
+    async _enableWebglRenderer() {
+        if (!this.raw.element || this._webglAddon) {
+            return;
+        }
+        const Addon = await this._xtermAddonLoader.importAddon('webgl');
+        this._webglAddon = ( new Addon());
+        try {
+            this.raw.loadAddon(this._webglAddon);
+            this._logService.trace('Webgl was loaded');
+            this._webglAddon.onContextLoss(() => {
+                this._logService.info(`Webgl lost context, disposing of webgl renderer`);
+                this._disposeOfWebglRenderer();
+            });
+            this._refreshImageAddon();
+            this._onDidRequestRefreshDimensions.fire();
+        }
+        catch (e) {
+            this._logService.warn(`Webgl could not be loaded. Falling back to the DOM renderer`, e);
+            XtermTerminal_1._suggestedRendererType = 'dom';
+            this._disposeOfWebglRenderer();
+        }
+    }
+    async _refreshLigaturesAddon() {
+        if (!this.raw.element) {
+            return;
+        }
+        const ligaturesConfig = this._terminalConfigurationService.config.fontLigatures;
+        let shouldRecreateWebglRenderer = false;
+        if (ligaturesConfig?.enabled) {
+            if (this._ligaturesAddon.value && !equals(ligaturesConfig, this._ligaturesAddonConfig)) {
+                this._ligaturesAddon.clear();
+            }
+            if (!this._ligaturesAddon.value) {
+                const LigaturesAddon = await this._xtermAddonLoader.importAddon('ligatures');
+                if (this._store.isDisposed) {
+                    return;
+                }
+                this._ligaturesAddon.value = this._instantiationService.createInstance(LigaturesAddon, {
+                    fontFeatureSettings: ligaturesConfig.featureSettings,
+                    fallbackLigatures: ligaturesConfig.fallbackLigatures,
+                });
+                this.raw.loadAddon(this._ligaturesAddon.value);
+                shouldRecreateWebglRenderer = true;
+            }
+        }
+        else {
+            if (!this._ligaturesAddon.value) {
+                return;
+            }
+            this._ligaturesAddon.clear();
+            shouldRecreateWebglRenderer = true;
+        }
+        if (shouldRecreateWebglRenderer && this._webglAddon) {
+            this._disposeOfWebglRenderer();
+            await this._enableWebglRenderer();
+        }
+    }
+    async _refreshImageAddon() {
+        if (this._terminalConfigurationService.config.enableImages && this._webglAddon) {
+            if (!this._imageAddon) {
+                const AddonCtor = await this._xtermAddonLoader.importAddon('image');
+                this._imageAddon = ( new AddonCtor());
+                this.raw.loadAddon(this._imageAddon);
+            }
+        }
+        else {
+            try {
+                this._imageAddon?.dispose();
+            }
+            catch {
+            }
+            this._imageAddon = undefined;
+        }
+    }
+    _disposeOfWebglRenderer() {
+        try {
+            this._webglAddon?.dispose();
+        }
+        catch {
+        }
+        this._webglAddon = undefined;
+        this._refreshImageAddon();
+        this._onDidRequestRefreshDimensions.fire();
+    }
+    async getRangeAsVT(startMarker, endMarker, skipLastLine) {
+        if (!this._serializeAddon) {
+            const Addon = await this._xtermAddonLoader.importAddon('serialize');
+            this._serializeAddon = ( new Addon());
+            this.raw.loadAddon(this._serializeAddon);
+        }
+        assert(startMarker.line !== -1);
+        let end = endMarker?.line ?? this.raw.buffer.active.length - 1;
+        if (skipLastLine) {
+            end = end - 1;
+        }
+        return this._serializeAddon.serialize({
+            range: {
+                start: startMarker.line,
+                end: end
+            }
+        });
+    }
+    getXtermTheme(theme) {
+        if (!theme) {
+            theme = this._themeService.getColorTheme();
+        }
+        const config = this._terminalConfigurationService.config;
+        const hideOverviewRuler = ['never', 'gutter'].includes(config.shellIntegration?.decorationsEnabled ?? '');
+        const foregroundColor = theme.getColor(TERMINAL_FOREGROUND_COLOR);
+        const backgroundColor = this._xtermColorProvider.getBackgroundColor(theme);
+        const cursorColor = theme.getColor(TERMINAL_CURSOR_FOREGROUND_COLOR) || foregroundColor;
+        const cursorAccentColor = theme.getColor(TERMINAL_CURSOR_BACKGROUND_COLOR) || backgroundColor;
+        const selectionBackgroundColor = theme.getColor(TERMINAL_SELECTION_BACKGROUND_COLOR);
+        const selectionInactiveBackgroundColor = theme.getColor(TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR);
+        const selectionForegroundColor = theme.getColor(TERMINAL_SELECTION_FOREGROUND_COLOR) || undefined;
+        return {
+            background: backgroundColor?.toString(),
+            foreground: foregroundColor?.toString(),
+            cursor: cursorColor?.toString(),
+            cursorAccent: cursorAccentColor?.toString(),
+            selectionBackground: selectionBackgroundColor?.toString(),
+            selectionInactiveBackground: selectionInactiveBackgroundColor?.toString(),
+            selectionForeground: selectionForegroundColor?.toString(),
+            overviewRulerBorder: hideOverviewRuler ? '#0000' : theme.getColor(TERMINAL_OVERVIEW_RULER_BORDER_COLOR)?.toString(),
+            scrollbarSliderActiveBackground: theme.getColor(scrollbarSliderActiveBackground)?.toString(),
+            scrollbarSliderBackground: theme.getColor(scrollbarSliderBackground)?.toString(),
+            scrollbarSliderHoverBackground: theme.getColor(scrollbarSliderHoverBackground)?.toString(),
+            black: theme.getColor(ansiColorIdentifiers[0])?.toString(),
+            red: theme.getColor(ansiColorIdentifiers[1])?.toString(),
+            green: theme.getColor(ansiColorIdentifiers[2])?.toString(),
+            yellow: theme.getColor(ansiColorIdentifiers[3])?.toString(),
+            blue: theme.getColor(ansiColorIdentifiers[4])?.toString(),
+            magenta: theme.getColor(ansiColorIdentifiers[5])?.toString(),
+            cyan: theme.getColor(ansiColorIdentifiers[6])?.toString(),
+            white: theme.getColor(ansiColorIdentifiers[7])?.toString(),
+            brightBlack: theme.getColor(ansiColorIdentifiers[8])?.toString(),
+            brightRed: theme.getColor(ansiColorIdentifiers[9])?.toString(),
+            brightGreen: theme.getColor(ansiColorIdentifiers[10])?.toString(),
+            brightYellow: theme.getColor(ansiColorIdentifiers[11])?.toString(),
+            brightBlue: theme.getColor(ansiColorIdentifiers[12])?.toString(),
+            brightMagenta: theme.getColor(ansiColorIdentifiers[13])?.toString(),
+            brightCyan: theme.getColor(ansiColorIdentifiers[14])?.toString(),
+            brightWhite: theme.getColor(ansiColorIdentifiers[15])?.toString()
+        };
+    }
+    _updateTheme(theme) {
+        this.raw.options.theme = this.getXtermTheme(theme);
+    }
+    refresh() {
+        this._updateTheme();
+        this._decorationAddon.refreshLayouts();
+    }
+    async _updateUnicodeVersion() {
+        if (!this._unicode11Addon && this._terminalConfigurationService.config.unicodeVersion === '11') {
+            const Addon = await this._xtermAddonLoader.importAddon('unicode11');
+            this._unicode11Addon = ( new Addon());
+            this.raw.loadAddon(this._unicode11Addon);
+        }
+        if (this.raw.unicode.activeVersion !== this._terminalConfigurationService.config.unicodeVersion) {
+            this.raw.unicode.activeVersion = this._terminalConfigurationService.config.unicodeVersion;
+        }
+    }
+    _writeText(data) {
+        this.raw.write(data);
+    }
+    dispose() {
+        this._anyTerminalFocusContextKey.reset();
+        this._anyFocusedTerminalHasSelection.reset();
+        this._onDidDispose.fire();
+        super.dispose();
+    }
+};
+XtermTerminal.__decorator = ( __decorate([
+    debounce(100)
+], XtermTerminal.prototype, "_refreshLigaturesAddon", null));
+XtermTerminal.__decorator = ( __decorate([
+    debounce(100)
+], XtermTerminal.prototype, "_refreshImageAddon", null));
+XtermTerminal = XtermTerminal_1 = ( __decorate([
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, ITerminalLogService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, ITerminalConfigurationService)),
+    ( __param(11, IClipboardService)),
+    ( __param(12, IContextKeyService)),
+    ( __param(13, IAccessibilitySignalService)),
+    ( __param(14, ILayoutService))
+], XtermTerminal));
+function getXtermScaledDimensions(w, font, width, height) {
+    if (!font.charWidth || !font.charHeight) {
+        return null;
+    }
+    const scaledWidthAvailable = width * w.devicePixelRatio;
+    const scaledCharWidth = font.charWidth * w.devicePixelRatio + font.letterSpacing;
+    const cols = Math.max(Math.floor(scaledWidthAvailable / scaledCharWidth), 1);
+    const scaledHeightAvailable = height * w.devicePixelRatio;
+    const scaledCharHeight = Math.ceil(font.charHeight * w.devicePixelRatio);
+    const scaledLineHeight = Math.floor(scaledCharHeight * font.lineHeight);
+    const rows = Math.max(Math.floor(scaledHeightAvailable / scaledLineHeight), 1);
+    return { rows, cols };
+}
+function vscodeToXtermLogLevel(logLevel) {
+    switch (logLevel) {
+        case LogLevel.Trace: return 'trace';
+        case LogLevel.Debug: return 'debug';
+        case LogLevel.Info: return 'info';
+        case LogLevel.Warning: return 'warn';
+        case LogLevel.Error: return 'error';
+        default: return 'off';
+    }
+}
+function vscodeToXtermCursorStyle(style) {
+    if (style === 'line') {
+        return 'bar';
+    }
+    return style;
+}
+
+export { XtermTerminal, getXtermScaledDimensions };