@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

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

@@ -0,0 +1,587 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isSafari } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { MarkNavigationAddon } from './markNavigationAddon.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { PANEL_BACKGROUND } from '../../../../common/theme.js';
+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 } from '../../common/terminalColorRegistry.js';
+import { ShellIntegrationAddon } from '../../../../../platform/terminal/common/xterm/shellIntegrationAddon.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DecorationAddon } from './decorationAddon.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { SuggestAddon } from './suggestAddon.js';
+let CanvasAddon;
+let ImageAddon;
+let SearchAddon;
+let SerializeAddon;
+let Unicode11Addon;
+let WebglAddon;
+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 DisposableStore {
+    *getBufferReverseIterator() {
+        for (let i = this.raw.buffer.active.length; i >= 0; i--) {
+            const { lineData, lineIndex } = getFullBufferLineAsString(i, this.raw.buffer.active);
+            if (lineData) {
+                i = lineIndex;
+                yield lineData;
+            }
+        }
+    }
+    get findResult() { return this._lastFindResult; }
+    get isStdinDisabled() { return !!this.raw.options.disableStdin; }
+    get markTracker() { return this._markNavigationAddon; }
+    get shellIntegration() { return this._shellIntegrationAddon; }
+    get suggestController() { return this._suggestAddon; }
+    get textureAtlas() {
+        const canvas = this._webglAddon?.textureAtlas || this._canvasAddon?.textureAtlas;
+        if (!canvas) {
+            return undefined;
+        }
+        return createImageBitmap(canvas);
+    }
+    constructor(xtermCtor, _configHelper, cols, rows, _backgroundColorProvider, _capabilities, shellIntegrationNonce, _terminalSuggestWidgetVisibleContextKey, disableShellIntegrationReporting, _configurationService, _instantiationService, _logService, _notificationService, _storageService, _themeService, _telemetryService) {
+        super();
+        this._configHelper = _configHelper;
+        this._backgroundColorProvider = _backgroundColorProvider;
+        this._capabilities = _capabilities;
+        this._terminalSuggestWidgetVisibleContextKey = _terminalSuggestWidgetVisibleContextKey;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._notificationService = _notificationService;
+        this._storageService = _storageService;
+        this._themeService = _themeService;
+        this._telemetryService = _telemetryService;
+        this._onDidRequestRunCommand = ( new Emitter());
+        this.onDidRequestRunCommand = this._onDidRequestRunCommand.event;
+        this._onDidRequestFocus = ( new Emitter());
+        this.onDidRequestFocus = this._onDidRequestFocus.event;
+        this._onDidRequestSendText = ( new Emitter());
+        this.onDidRequestSendText = this._onDidRequestSendText.event;
+        this._onDidRequestFreePort = ( new Emitter());
+        this.onDidRequestFreePort = this._onDidRequestFreePort.event;
+        this._onDidChangeFindResults = ( new Emitter());
+        this.onDidChangeFindResults = this._onDidChangeFindResults.event;
+        this._onDidChangeSelection = ( new Emitter());
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        const font = this._configHelper.getFont(undefined, true);
+        const config = this._configHelper.config;
+        const editorOptions = this._configurationService.getValue('editor');
+        this.raw = this.add(( new xtermCtor({
+            allowProposedApi: true,
+            cols,
+            rows,
+            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,
+            minimumContrastRatio: config.minimumContrastRatio,
+            tabStopWidth: config.tabStopWidth,
+            cursorBlink: config.cursorBlinking,
+            cursorStyle: config.cursorStyle === 'line' ? 'bar' : config.cursorStyle,
+            cursorWidth: config.cursorWidth,
+            macOptionIsMeta: config.macOptionIsMeta,
+            macOptionClickForcesSelection: config.macOptionClickForcesSelection,
+            rightClickSelectsWord: config.rightClickBehavior === 'selectWord',
+            fastScrollModifier: 'alt',
+            fastScrollSensitivity: config.fastScrollSensitivity,
+            scrollSensitivity: config.mouseWheelScrollSensitivity,
+            wordSeparator: config.wordSeparators,
+            overviewRulerWidth: 10,
+            smoothScrollDuration: config.smoothScrolling ? 125  : 0
+        })));
+        this._core = this.raw._core;
+        this.add(this._configurationService.onDidChangeConfiguration(async (e) => {
+            if (e.affectsConfiguration("terminal.integrated.gpuAcceleration" )) {
+                XtermTerminal._suggestedRendererType = undefined;
+            }
+            if (e.affectsConfiguration('terminal.integrated') || e.affectsConfiguration('editor.fastScrollSensitivity') || e.affectsConfiguration('editor.mouseWheelScrollSensitivity') || e.affectsConfiguration('editor.multiCursorModifier')) {
+                this.updateConfig();
+            }
+            if (e.affectsConfiguration("terminal.integrated.unicodeVersion" )) {
+                this._updateUnicodeVersion();
+            }
+        }));
+        this.add(this._themeService.onDidColorThemeChange(theme => this._updateTheme(theme)));
+        this.add(this.raw.onSelectionChange(() => this._onDidChangeSelection.fire()));
+        this._updateUnicodeVersion();
+        this._refreshImageAddon();
+        this._markNavigationAddon = this._instantiationService.createInstance(MarkNavigationAddon, _capabilities);
+        this.raw.loadAddon(this._markNavigationAddon);
+        this._decorationAddon = this._instantiationService.createInstance(DecorationAddon, this._capabilities);
+        this._decorationAddon.onDidRequestRunCommand(e => this._onDidRequestRunCommand.fire(e));
+        this.raw.loadAddon(this._decorationAddon);
+        this._shellIntegrationAddon = this._instantiationService.createInstance(ShellIntegrationAddon, shellIntegrationNonce, disableShellIntegrationReporting, this._telemetryService);
+        this.raw.loadAddon(this._shellIntegrationAddon);
+        this._suggestAddon = this._instantiationService.createInstance(SuggestAddon, this._terminalSuggestWidgetVisibleContextKey);
+        this.raw.loadAddon(this._suggestAddon);
+        this._suggestAddon.onAcceptedCompletion(async (text) => {
+            this._onDidRequestFocus.fire();
+            this._onDidRequestSendText.fire(text);
+        });
+    }
+    async getSelectionAsHtml(command) {
+        if (!this._serializeAddon) {
+            const Addon = await this._getSerializeAddonConstructor();
+            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) {
+        if (!this._container) {
+            this.raw.open(container);
+        }
+        if (this._shouldLoadWebgl()) {
+            this._enableWebglRenderer();
+        }
+        else if (this._shouldLoadCanvas()) {
+            this._enableCanvasRenderer();
+        }
+        this._suggestAddon.setContainer(container);
+        this._container = container;
+        return this._container.querySelector('.xterm-screen');
+    }
+    updateConfig() {
+        const config = this._configHelper.config;
+        this.raw.options.altClickMovesCursor = config.altClickMovesCursor;
+        this._setCursorBlink(config.cursorBlinking);
+        this._setCursorStyle(config.cursorStyle);
+        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.smoothScrollDuration = config.smoothScrolling ? 125  : 0;
+        if (this._shouldLoadWebgl()) {
+            this._enableWebglRenderer();
+        }
+        else {
+            this._disposeOfWebglRenderer();
+            if (this._shouldLoadCanvas()) {
+                this._enableCanvasRenderer();
+            }
+            else {
+                this._disposeOfCanvasRenderer();
+            }
+        }
+        this._refreshImageAddon();
+    }
+    _shouldLoadWebgl() {
+        return !isSafari && (this._configHelper.config.gpuAcceleration === 'auto' && XtermTerminal._suggestedRendererType === undefined) || this._configHelper.config.gpuAcceleration === 'on';
+    }
+    _shouldLoadCanvas() {
+        return (this._configHelper.config.gpuAcceleration === 'auto' && (XtermTerminal._suggestedRendererType === undefined || XtermTerminal._suggestedRendererType === 'canvas')) || this._configHelper.config.gpuAcceleration === 'canvas';
+    }
+    forceRedraw() {
+        this.raw.clearTextureAtlas();
+    }
+    clearDecorations() {
+        this._decorationAddon?.clearDecorations();
+    }
+    forceRefresh() {
+        this._core.viewport?._innerRefresh();
+    }
+    forceUnpause() {
+        if (!!this._canvasAddon) {
+            this._core._renderService?._handleIntersectionChange({ intersectionRatio: 1 });
+            this.raw.refresh(0, this.raw.rows - 1);
+        }
+    }
+    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'
+        };
+    }
+    async _getSearchAddon() {
+        if (this._searchAddon) {
+            return this._searchAddon;
+        }
+        const AddonCtor = await this._getSearchAddonConstructor();
+        this._searchAddon = ( new AddonCtor({ highlightLimit: 1000  }));
+        this.raw.loadAddon(this._searchAddon);
+        this._searchAddon.onDidChangeResults((results) => {
+            this._lastFindResult = results;
+            this._onDidChangeFindResults.fire(results);
+        });
+        return this._searchAddon;
+    }
+    clearSearchDecorations() {
+        this._searchAddon?.clearDecorations();
+    }
+    clearActiveSearchDecoration() {
+        this._searchAddon?.clearActiveDecoration();
+    }
+    getFont() {
+        return this._configHelper.getFont(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();
+    }
+    clearBuffer() {
+        this.raw.clear();
+        this._capabilities.get(2 )?.handlePromptStart();
+        this._capabilities.get(2 )?.handleCommandStart();
+    }
+    _setCursorBlink(blink) {
+        if (this.raw.options.cursorBlink !== blink) {
+            this.raw.options.cursorBlink = blink;
+            this.raw.refresh(0, this.raw.rows - 1);
+        }
+    }
+    _setCursorStyle(style) {
+        if (this.raw.options.cursorStyle !== style) {
+            this.raw.options.cursorStyle = (style === 'line') ? 'bar' : style;
+        }
+    }
+    _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._getWebglAddonConstructor();
+        this._webglAddon = ( new Addon());
+        this._disposeOfCanvasRenderer();
+        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();
+            });
+        }
+        catch (e) {
+            this._logService.warn(`Webgl could not be loaded. Falling back to the canvas renderer type.`, e);
+            const neverMeasureRenderTime = this._storageService.getBoolean("terminal.integrated.neverMeasureRenderTime" , -1 , false);
+            if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') {
+                this._measureRenderTime();
+            }
+            XtermTerminal._suggestedRendererType = 'canvas';
+            this._disposeOfWebglRenderer();
+            this._enableCanvasRenderer();
+        }
+    }
+    async _enableCanvasRenderer() {
+        if (!this.raw.element || this._canvasAddon) {
+            return;
+        }
+        const Addon = await this._getCanvasAddonConstructor();
+        this._canvasAddon = ( new Addon());
+        this._disposeOfWebglRenderer();
+        try {
+            this.raw.loadAddon(this._canvasAddon);
+            this._logService.trace('Canvas renderer was loaded');
+        }
+        catch (e) {
+            this._logService.warn(`Canvas renderer could not be loaded, falling back to dom renderer`, e);
+            const neverMeasureRenderTime = this._storageService.getBoolean("terminal.integrated.neverMeasureRenderTime" , -1 , false);
+            if (!neverMeasureRenderTime && this._configHelper.config.gpuAcceleration !== 'off') {
+                this._measureRenderTime();
+            }
+            XtermTerminal._suggestedRendererType = 'dom';
+            this._disposeOfCanvasRenderer();
+        }
+    }
+    async _getCanvasAddonConstructor() {
+        if (!CanvasAddon) {
+            CanvasAddon = (await import('xterm-addon-canvas').then(module => module.default ?? module)).CanvasAddon;
+        }
+        return CanvasAddon;
+    }
+    async _refreshImageAddon() {
+        if (this._configHelper.config.experimentalImageSupport) {
+            if (!this._imageAddon) {
+                const AddonCtor = await this._getImageAddonConstructor();
+                this._imageAddon = ( new AddonCtor());
+                this.raw.loadAddon(this._imageAddon);
+            }
+        }
+        else {
+            try {
+                this._imageAddon?.dispose();
+            }
+            catch {
+            }
+            this._imageAddon = undefined;
+        }
+    }
+    async _getImageAddonConstructor() {
+        if (!ImageAddon) {
+            ImageAddon = (await import('xterm-addon-image').then(module => module.default ?? module)).ImageAddon;
+        }
+        return ImageAddon;
+    }
+    async _getSearchAddonConstructor() {
+        if (!SearchAddon) {
+            SearchAddon = (await import('xterm-addon-search').then(module => module.default ?? module)).SearchAddon;
+        }
+        return SearchAddon;
+    }
+    async _getUnicode11Constructor() {
+        if (!Unicode11Addon) {
+            Unicode11Addon = (await import('xterm-addon-unicode11').then(module => module.default ?? module)).Unicode11Addon;
+        }
+        return Unicode11Addon;
+    }
+    async _getWebglAddonConstructor() {
+        if (!WebglAddon) {
+            WebglAddon = (await import('xterm-addon-webgl').then(module => module.default ?? module)).WebglAddon;
+        }
+        return WebglAddon;
+    }
+    async _getSerializeAddonConstructor() {
+        if (!SerializeAddon) {
+            SerializeAddon = (await import('xterm-addon-serialize').then(module => module.default ?? module)).SerializeAddon;
+        }
+        return SerializeAddon;
+    }
+    _disposeOfCanvasRenderer() {
+        try {
+            this._canvasAddon?.dispose();
+        }
+        catch {
+        }
+        this._canvasAddon = undefined;
+    }
+    _disposeOfWebglRenderer() {
+        try {
+            this._webglAddon?.dispose();
+        }
+        catch {
+        }
+        this._webglAddon = undefined;
+    }
+    async _measureRenderTime() {
+        const frameTimes = [];
+        if (!this._core._renderService?._renderer._renderLayers) {
+            return;
+        }
+        const textRenderLayer = this._core._renderService._renderer._renderLayers[0];
+        const originalOnGridChanged = textRenderLayer?.onGridChanged;
+        const evaluateCanvasRenderer = () => {
+            frameTimes.shift();
+            const medianTime = frameTimes.sort((a, b) => a - b)[Math.floor(frameTimes.length / 2)];
+            if (medianTime > 50 ) {
+                if (this._configHelper.config.gpuAcceleration === 'auto') {
+                    XtermTerminal._suggestedRendererType = 'dom';
+                    this.updateConfig();
+                }
+                else {
+                    const promptChoices = [
+                        {
+                            label: ( localize('yes', "Yes")),
+                            run: () => this._configurationService.updateValue("terminal.integrated.gpuAcceleration" , 'off', 2 )
+                        },
+                        {
+                            label: ( localize('no', "No")),
+                            run: () => { }
+                        },
+                        {
+                            label: ( localize('dontShowAgain', "Don't Show Again")),
+                            isSecondary: true,
+                            run: () => this._storageService.store("terminal.integrated.neverMeasureRenderTime" , true, -1 , 1 )
+                        }
+                    ];
+                    this._notificationService.prompt(Severity.Warning, ( localize(
+                        'terminal.slowRendering',
+                        'Terminal GPU acceleration appears to be slow on your computer. Would you like to switch to disable it which may improve performance? [Read more about terminal settings](https://code.visualstudio.com/docs/editor/integrated-terminal#_changing-how-the-terminal-is-rendered).'
+                    )), promptChoices);
+                }
+            }
+        };
+        textRenderLayer.onGridChanged = (terminal, firstRow, lastRow) => {
+            const startTime = performance.now();
+            originalOnGridChanged.call(textRenderLayer, terminal, firstRow, lastRow);
+            frameTimes.push(performance.now() - startTime);
+            if (frameTimes.length === 20 ) {
+                evaluateCanvasRenderer();
+                textRenderLayer.onGridChanged = originalOnGridChanged;
+            }
+        };
+    }
+    _getXtermTheme(theme) {
+        if (!theme) {
+            theme = this._themeService.getColorTheme();
+        }
+        const foregroundColor = theme.getColor(TERMINAL_FOREGROUND_COLOR);
+        const backgroundColor = this._backgroundColorProvider.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(),
+            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._configHelper.config.unicodeVersion === '11') {
+            const Addon = await this._getUnicode11Constructor();
+            this._unicode11Addon = ( new Addon());
+            this.raw.loadAddon(this._unicode11Addon);
+        }
+        if (this.raw.unicode.activeVersion !== this._configHelper.config.unicodeVersion) {
+            this.raw.unicode.activeVersion = this._configHelper.config.unicodeVersion;
+        }
+    }
+    _writeText(data) {
+        this.raw.write(data);
+    }
+};
+XtermTerminal._suggestedRendererType = undefined;
+XtermTerminal = ( __decorate([
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IInstantiationService)),
+    ( __param(11, ILogService)),
+    ( __param(12, INotificationService)),
+    ( __param(13, IStorageService)),
+    ( __param(14, IThemeService)),
+    ( __param(15, ITelemetryService))
+], XtermTerminal));
+export { XtermTerminal };

package/dist/vscode/vs/workbench/contrib/terminal/common/environmentVariable.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IEnvironmentVariableService = ( createDecorator('environmentVariableService'));
+export { IEnvironmentVariableService };

package/dist/vscode/vs/workbench/contrib/terminal/common/environmentVariableService.js

@@ -0,0 +1,94 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { throttle, debounce } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { MergedEnvironmentVariableCollection } from '../../../../platform/terminal/common/environmentVariableCollection.js';
+import { deserializeEnvironmentVariableCollection, deserializeEnvironmentDescriptionMap, serializeEnvironmentVariableCollection, serializeEnvironmentDescriptionMap } from '../../../../platform/terminal/common/environmentVariableShared.js';
+let EnvironmentVariableService = class EnvironmentVariableService {
+    get onDidChangeCollections() { return this._onDidChangeCollections.event; }
+    constructor(_extensionService, _storageService) {
+        this._extensionService = _extensionService;
+        this._storageService = _storageService;
+        this.collections = ( new Map());
+        this._onDidChangeCollections = ( new Emitter());
+        this._storageService.remove("terminal.integrated.environmentVariableCollections" , 1 );
+        const serializedPersistedCollections = this._storageService.get("terminal.integrated.environmentVariableCollectionsV2" , 1 );
+        if (serializedPersistedCollections) {
+            const collectionsJson = JSON.parse(serializedPersistedCollections);
+            collectionsJson.forEach(c => this.collections.set(c.extensionIdentifier, {
+                persistent: true,
+                map: deserializeEnvironmentVariableCollection(c.collection),
+                descriptionMap: deserializeEnvironmentDescriptionMap(c.description)
+            }));
+            this._invalidateExtensionCollections();
+        }
+        this.mergedCollection = this._resolveMergedCollection();
+        this._extensionService.onDidChangeExtensions(() => this._invalidateExtensionCollections());
+    }
+    set(extensionIdentifier, collection) {
+        this.collections.set(extensionIdentifier, collection);
+        this._updateCollections();
+    }
+    delete(extensionIdentifier) {
+        this.collections.delete(extensionIdentifier);
+        this._updateCollections();
+    }
+    _updateCollections() {
+        this._persistCollectionsEventually();
+        this.mergedCollection = this._resolveMergedCollection();
+        this._notifyCollectionUpdatesEventually();
+    }
+    _persistCollectionsEventually() {
+        this._persistCollections();
+    }
+    _persistCollections() {
+        const collectionsJson = [];
+        this.collections.forEach((collection, extensionIdentifier) => {
+            if (collection.persistent) {
+                collectionsJson.push({
+                    extensionIdentifier,
+                    collection: serializeEnvironmentVariableCollection(this.collections.get(extensionIdentifier).map),
+                    description: serializeEnvironmentDescriptionMap(collection.descriptionMap)
+                });
+            }
+        });
+        const stringifiedJson = JSON.stringify(collectionsJson);
+        this._storageService.store("terminal.integrated.environmentVariableCollectionsV2" , stringifiedJson, 1 , 1 );
+    }
+    _notifyCollectionUpdatesEventually() {
+        this._notifyCollectionUpdates();
+    }
+    _notifyCollectionUpdates() {
+        this._onDidChangeCollections.fire(this.mergedCollection);
+    }
+    _resolveMergedCollection() {
+        return ( new MergedEnvironmentVariableCollection(this.collections));
+    }
+    async _invalidateExtensionCollections() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const registeredExtensions = this._extensionService.extensions;
+        let changes = false;
+        this.collections.forEach((_, extensionIdentifier) => {
+            const isExtensionRegistered = ( registeredExtensions.some(r => r.identifier.value === extensionIdentifier));
+            if (!isExtensionRegistered) {
+                this.collections.delete(extensionIdentifier);
+                changes = true;
+            }
+        });
+        if (changes) {
+            this._updateCollections();
+        }
+    }
+};
+EnvironmentVariableService.__decorator = ( __decorate([
+    throttle(1000)
+], EnvironmentVariableService.prototype, "_persistCollectionsEventually", null));
+EnvironmentVariableService.__decorator = ( __decorate([
+    debounce(1000)
+], EnvironmentVariableService.prototype, "_notifyCollectionUpdatesEventually", null));
+EnvironmentVariableService = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IStorageService))
+], EnvironmentVariableService));
+export { EnvironmentVariableService };