@codingame/monaco-vscode-xterm-common 24.1.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@codingame/monaco-vscode-xterm-common",
+  "version": "24.1.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package depending on xterm",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "24.1.0",
+    "@codingame/monaco-vscode-xterm-addons-common": "24.1.0",
+    "@xterm/xterm": "5.6.0-beta.137"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/platform/terminal/common/capabilities/naiveCwdDetectionCapability.d.ts

@@ -0,0 +1,11 @@
+import { ITerminalChildProcess } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { TerminalCapability, INaiveCwdDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+export declare class NaiveCwdDetectionCapability implements INaiveCwdDetectionCapability {
+    private readonly _process;
+    constructor(_process: ITerminalChildProcess);
+    readonly type = TerminalCapability.NaiveCwdDetection;
+    private _cwd;
+    private readonly _onDidChangeCwd;
+    readonly onDidChangeCwd: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<string>;
+    getCwd(): Promise<string>;
+}

package/vscode/src/vs/platform/terminal/common/capabilities/naiveCwdDetectionCapability.js

@@ -0,0 +1,26 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+
+class NaiveCwdDetectionCapability {
+    constructor(_process) {
+        this._process = _process;
+        this.type = TerminalCapability.NaiveCwdDetection;
+        this._cwd = '';
+        this._onDidChangeCwd = ( new Emitter());
+        this.onDidChangeCwd = this._onDidChangeCwd.event;
+    }
+    async getCwd() {
+        if (!this._process) {
+            return Promise.resolve('');
+        }
+        const newCwd = await this._process.getCwd();
+        if (newCwd !== this._cwd) {
+            this._onDidChangeCwd.fire(newCwd);
+        }
+        this._cwd = newCwd;
+        return this._cwd;
+    }
+}
+
+export { NaiveCwdDetectionCapability };

package/vscode/src/vs/platform/terminal/common/environmentVariable.d.ts

@@ -0,0 +1,86 @@
+import { IProcessEnvironment } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { IWorkspaceFolderData } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+export declare enum EnvironmentVariableMutatorType {
+    Replace = 1,
+    Append = 2,
+    Prepend = 3
+}
+export interface IEnvironmentVariableMutator {
+    readonly variable: string;
+    readonly value: string;
+    readonly type: EnvironmentVariableMutatorType;
+    readonly scope?: EnvironmentVariableScope;
+    readonly options?: IEnvironmentVariableMutatorOptions;
+}
+export interface IEnvironmentVariableCollectionDescription {
+    readonly description: string | undefined;
+    readonly scope?: EnvironmentVariableScope;
+}
+export interface IEnvironmentVariableMutatorOptions {
+    applyAtProcessCreation?: boolean;
+    applyAtShellIntegration?: boolean;
+}
+export type EnvironmentVariableScope = {
+    workspaceFolder?: IWorkspaceFolderData;
+};
+export interface IEnvironmentVariableCollection {
+    readonly map: ReadonlyMap<string, IEnvironmentVariableMutator>;
+    readonly descriptionMap?: ReadonlyMap<string, IEnvironmentVariableCollectionDescription>;
+}
+/** [variable, mutator] */
+export type ISerializableEnvironmentVariableCollection = [
+    string,
+    IEnvironmentVariableMutator
+][];
+export type ISerializableEnvironmentDescriptionMap = [
+    string,
+    IEnvironmentVariableCollectionDescription
+][];
+export interface IExtensionOwnedEnvironmentDescriptionMutator extends IEnvironmentVariableCollectionDescription {
+    readonly extensionIdentifier: string;
+}
+/** [extension, collection, description] */
+export type ISerializableEnvironmentVariableCollections = [
+    string,
+    ISerializableEnvironmentVariableCollection,
+    ISerializableEnvironmentDescriptionMap
+][];
+export interface IExtensionOwnedEnvironmentVariableMutator extends IEnvironmentVariableMutator {
+    readonly extensionIdentifier: string;
+}
+export interface IMergedEnvironmentVariableCollectionDiff {
+    added: ReadonlyMap<string, IExtensionOwnedEnvironmentVariableMutator[]>;
+    changed: ReadonlyMap<string, IExtensionOwnedEnvironmentVariableMutator[]>;
+    removed: ReadonlyMap<string, IExtensionOwnedEnvironmentVariableMutator[]>;
+}
+type VariableResolver = (str: string) => Promise<string>;
+/**
+ * Represents an environment variable collection that results from merging several collections
+ * together.
+ */
+export interface IMergedEnvironmentVariableCollection {
+    readonly collections: ReadonlyMap<string, IEnvironmentVariableCollection>;
+    /**
+     * Gets the variable map for a given scope.
+     * @param scope The scope to get the variable map for. If undefined, the global scope is used.
+     */
+    getVariableMap(scope: EnvironmentVariableScope | undefined): Map<string, IExtensionOwnedEnvironmentVariableMutator[]>;
+    /**
+     * Gets the description map for a given scope.
+     * @param scope The scope to get the description map for. If undefined, description map for the
+     * global scope is returned.
+     */
+    getDescriptionMap(scope: EnvironmentVariableScope | undefined): Map<string, string | undefined>;
+    /**
+     * Applies this collection to a process environment.
+     * @param variableResolver An optional function to use to resolve variables within the
+     * environment values.
+     */
+    applyToProcessEnvironment(env: IProcessEnvironment, scope: EnvironmentVariableScope | undefined, variableResolver?: VariableResolver): Promise<void>;
+    /**
+     * Generates a diff of this collection against another. Returns undefined if the collections are
+     * the same.
+     */
+    diff(other: IMergedEnvironmentVariableCollection, scope: EnvironmentVariableScope | undefined): IMergedEnvironmentVariableCollectionDiff | undefined;
+}
+export {};

package/vscode/src/vs/platform/terminal/common/environmentVariable.js

@@ -0,0 +1,10 @@
+
+
+var EnvironmentVariableMutatorType;
+(function (EnvironmentVariableMutatorType) {
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Replace"] = 1] = "Replace";
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Append"] = 2] = "Append";
+    EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
+})(EnvironmentVariableMutatorType || (EnvironmentVariableMutatorType = {}));
+
+export { EnvironmentVariableMutatorType };

package/vscode/src/vs/platform/terminal/common/environmentVariableCollection.d.ts

@@ -0,0 +1,17 @@
+import { IProcessEnvironment } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { EnvironmentVariableScope, IEnvironmentVariableCollection, IExtensionOwnedEnvironmentVariableMutator, IMergedEnvironmentVariableCollection, IMergedEnvironmentVariableCollectionDiff } from "./environmentVariable.js";
+type VariableResolver = (str: string) => Promise<string>;
+export declare class MergedEnvironmentVariableCollection implements IMergedEnvironmentVariableCollection {
+    readonly collections: ReadonlyMap<string, IEnvironmentVariableCollection>;
+    private readonly map;
+    private readonly descriptionMap;
+    constructor(collections: ReadonlyMap<string, IEnvironmentVariableCollection>);
+    applyToProcessEnvironment(env: IProcessEnvironment, scope: EnvironmentVariableScope | undefined, variableResolver?: VariableResolver): Promise<void>;
+    private _encodeColons;
+    private blockPythonActivationVar;
+    diff(other: IMergedEnvironmentVariableCollection, scope: EnvironmentVariableScope | undefined): IMergedEnvironmentVariableCollectionDiff | undefined;
+    getVariableMap(scope: EnvironmentVariableScope | undefined): Map<string, IExtensionOwnedEnvironmentVariableMutator[]>;
+    getDescriptionMap(scope: EnvironmentVariableScope | undefined): Map<string, string | undefined>;
+    private populateDescriptionMap;
+}
+export {};

package/vscode/src/vs/platform/terminal/common/environmentVariableCollection.js

@@ -0,0 +1,214 @@
+
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { EnvironmentVariableMutatorType } from './environmentVariable.js';
+
+const mutatorTypeToLabelMap = ( new Map([
+    [EnvironmentVariableMutatorType.Append, 'APPEND'],
+    [EnvironmentVariableMutatorType.Prepend, 'PREPEND'],
+    [EnvironmentVariableMutatorType.Replace, 'REPLACE']
+]));
+const PYTHON_ACTIVATION_VARS_PATTERN = /^VSCODE_PYTHON_(PWSH|ZSH|BASH|FISH)_ACTIVATE/;
+const PYTHON_ENV_EXTENSION_ID = 'ms-python.vscode-python-envs';
+class MergedEnvironmentVariableCollection {
+    constructor(collections) {
+        this.collections = collections;
+        this.map = ( new Map());
+        this.descriptionMap = ( new Map());
+        collections.forEach((collection, extensionIdentifier) => {
+            this.populateDescriptionMap(collection, extensionIdentifier);
+            const it = collection.map.entries();
+            let next = it.next();
+            while (!next.done) {
+                const mutator = next.value[1];
+                const key = next.value[0];
+                if (this.blockPythonActivationVar(key, extensionIdentifier)) {
+                    next = it.next();
+                    continue;
+                }
+                let entry = this.map.get(key);
+                if (!entry) {
+                    entry = [];
+                    this.map.set(key, entry);
+                }
+                if (entry.length > 0 && entry[0].type === EnvironmentVariableMutatorType.Replace) {
+                    next = it.next();
+                    continue;
+                }
+                const extensionMutator = {
+                    extensionIdentifier,
+                    value: mutator.value,
+                    type: mutator.type,
+                    scope: mutator.scope,
+                    variable: mutator.variable,
+                    options: mutator.options
+                };
+                if (!extensionMutator.scope) {
+                    delete extensionMutator.scope;
+                }
+                entry.unshift(extensionMutator);
+                next = it.next();
+            }
+        });
+    }
+    async applyToProcessEnvironment(env, scope, variableResolver) {
+        let lowerToActualVariableNames;
+        if (isWindows) {
+            lowerToActualVariableNames = {};
+            ( Object.keys(env)).forEach(e => lowerToActualVariableNames[e.toLowerCase()] = e);
+        }
+        for (const [variable, mutators] of this.getVariableMap(scope)) {
+            const actualVariable = isWindows ? lowerToActualVariableNames[variable.toLowerCase()] || variable : variable;
+            for (const mutator of mutators) {
+                const value = variableResolver ? await variableResolver(mutator.value) : mutator.value;
+                if (this.blockPythonActivationVar(mutator.variable, mutator.extensionIdentifier)) {
+                    continue;
+                }
+                if (mutator.options?.applyAtProcessCreation ?? true) {
+                    switch (mutator.type) {
+                        case EnvironmentVariableMutatorType.Append:
+                            env[actualVariable] = (env[actualVariable] || '') + value;
+                            break;
+                        case EnvironmentVariableMutatorType.Prepend:
+                            env[actualVariable] = value + (env[actualVariable] || '');
+                            break;
+                        case EnvironmentVariableMutatorType.Replace:
+                            env[actualVariable] = value;
+                            break;
+                    }
+                }
+                if (mutator.options?.applyAtShellIntegration ?? false) {
+                    const key = `VSCODE_ENV_${mutatorTypeToLabelMap.get(mutator.type)}`;
+                    env[key] = (env[key] ? env[key] + ':' : '') + variable + '=' + this._encodeColons(value);
+                }
+            }
+        }
+    }
+    _encodeColons(value) {
+        return value.replaceAll(':', '\\x3a');
+    }
+    blockPythonActivationVar(variable, extensionIdentifier) {
+        if (PYTHON_ACTIVATION_VARS_PATTERN.test(variable) && PYTHON_ENV_EXTENSION_ID !== extensionIdentifier) {
+            return true;
+        }
+        return false;
+    }
+    diff(other, scope) {
+        const added = ( new Map());
+        const changed = ( new Map());
+        const removed = ( new Map());
+        other.getVariableMap(scope).forEach((otherMutators, variable) => {
+            const currentMutators = this.getVariableMap(scope).get(variable);
+            const result = getMissingMutatorsFromArray(otherMutators, currentMutators);
+            if (result) {
+                added.set(variable, result);
+            }
+        });
+        this.getVariableMap(scope).forEach((currentMutators, variable) => {
+            const otherMutators = other.getVariableMap(scope).get(variable);
+            const result = getMissingMutatorsFromArray(currentMutators, otherMutators);
+            if (result) {
+                removed.set(variable, result);
+            }
+        });
+        this.getVariableMap(scope).forEach((currentMutators, variable) => {
+            const otherMutators = other.getVariableMap(scope).get(variable);
+            const result = getChangedMutatorsFromArray(currentMutators, otherMutators);
+            if (result) {
+                changed.set(variable, result);
+            }
+        });
+        if (added.size === 0 && changed.size === 0 && removed.size === 0) {
+            return undefined;
+        }
+        return { added, changed, removed };
+    }
+    getVariableMap(scope) {
+        const result = ( new Map());
+        for (const mutators of ( this.map.values())) {
+            const filteredMutators = mutators.filter(m => filterScope(m, scope));
+            if (filteredMutators.length > 0) {
+                result.set(filteredMutators[0].variable, filteredMutators);
+            }
+        }
+        return result;
+    }
+    getDescriptionMap(scope) {
+        const result = ( new Map());
+        for (const mutators of ( this.descriptionMap.values())) {
+            const filteredMutators = mutators.filter(m => filterScope(m, scope, true));
+            for (const mutator of filteredMutators) {
+                result.set(mutator.extensionIdentifier, mutator.description);
+            }
+        }
+        return result;
+    }
+    populateDescriptionMap(collection, extensionIdentifier) {
+        if (!collection.descriptionMap) {
+            return;
+        }
+        const it = collection.descriptionMap.entries();
+        let next = it.next();
+        while (!next.done) {
+            const mutator = next.value[1];
+            const key = next.value[0];
+            let entry = this.descriptionMap.get(key);
+            if (!entry) {
+                entry = [];
+                this.descriptionMap.set(key, entry);
+            }
+            const extensionMutator = {
+                extensionIdentifier,
+                scope: mutator.scope,
+                description: mutator.description
+            };
+            if (!extensionMutator.scope) {
+                delete extensionMutator.scope;
+            }
+            entry.push(extensionMutator);
+            next = it.next();
+        }
+    }
+}
+function filterScope(mutator, scope, strictFilter = false) {
+    if (!mutator.scope) {
+        if (strictFilter) {
+            return scope === mutator.scope;
+        }
+        return true;
+    }
+    if (mutator.scope.workspaceFolder && scope?.workspaceFolder && mutator.scope.workspaceFolder.index === scope.workspaceFolder.index) {
+        return true;
+    }
+    return false;
+}
+function getMissingMutatorsFromArray(current, other) {
+    if (!other) {
+        return current;
+    }
+    const otherMutatorExtensions = ( new Set());
+    other.forEach(m => otherMutatorExtensions.add(m.extensionIdentifier));
+    const result = [];
+    current.forEach(mutator => {
+        if (!( otherMutatorExtensions.has(mutator.extensionIdentifier))) {
+            result.push(mutator);
+        }
+    });
+    return result.length === 0 ? undefined : result;
+}
+function getChangedMutatorsFromArray(current, other) {
+    if (!other) {
+        return undefined;
+    }
+    const otherMutatorExtensions = ( new Map());
+    other.forEach(m => otherMutatorExtensions.set(m.extensionIdentifier, m));
+    const result = [];
+    current.forEach(mutator => {
+        const otherMutator = otherMutatorExtensions.get(mutator.extensionIdentifier);
+        if (otherMutator && (mutator.type !== otherMutator.type || mutator.value !== otherMutator.value || mutator.scope?.workspaceFolder?.index !== otherMutator.scope?.workspaceFolder?.index)) {
+            result.push(otherMutator);
+        }
+    });
+    return result.length === 0 ? undefined : result;
+}
+
+export { MergedEnvironmentVariableCollection };

package/vscode/src/vs/platform/terminal/common/terminalRecorder.d.ts

@@ -0,0 +1,14 @@
+import { IPtyHostProcessReplayEvent } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { ReplayEntry } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminalProcess";
+export interface IRemoteTerminalProcessReplayEvent {
+    events: ReplayEntry[];
+}
+export declare class TerminalRecorder {
+    private _entries;
+    private _totalDataLength;
+    constructor(cols: number, rows: number);
+    handleResize(cols: number, rows: number): void;
+    handleData(data: string): void;
+    generateReplayEventSync(): IPtyHostProcessReplayEvent;
+    generateReplayEvent(): Promise<IPtyHostProcessReplayEvent>;
+}

package/vscode/src/vs/platform/terminal/common/terminalRecorder.js

@@ -0,0 +1,75 @@
+
+
+var Constants;
+(function (Constants) {
+    Constants[Constants["MaxRecorderDataSize"] = 10485760] = "MaxRecorderDataSize";
+})(Constants || (Constants = {}));
+class TerminalRecorder {
+    constructor(cols, rows) {
+        this._totalDataLength = 0;
+        this._entries = [{ cols, rows, data: [] }];
+    }
+    handleResize(cols, rows) {
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.data.length === 0) {
+                this._entries.pop();
+            }
+        }
+        if (this._entries.length > 0) {
+            const lastEntry = this._entries[this._entries.length - 1];
+            if (lastEntry.cols === cols && lastEntry.rows === rows) {
+                return;
+            }
+            if (lastEntry.cols === 0 && lastEntry.rows === 0) {
+                lastEntry.cols = cols;
+                lastEntry.rows = rows;
+                return;
+            }
+        }
+        this._entries.push({ cols, rows, data: [] });
+    }
+    handleData(data) {
+        const lastEntry = this._entries[this._entries.length - 1];
+        lastEntry.data.push(data);
+        this._totalDataLength += data.length;
+        while (this._totalDataLength > Constants.MaxRecorderDataSize) {
+            const firstEntry = this._entries[0];
+            const remainingToDelete = this._totalDataLength - Constants.MaxRecorderDataSize;
+            if (remainingToDelete >= firstEntry.data[0].length) {
+                this._totalDataLength -= firstEntry.data[0].length;
+                firstEntry.data.shift();
+                if (firstEntry.data.length === 0) {
+                    this._entries.shift();
+                }
+            }
+            else {
+                firstEntry.data[0] = firstEntry.data[0].substr(remainingToDelete);
+                this._totalDataLength -= remainingToDelete;
+            }
+        }
+    }
+    generateReplayEventSync() {
+        this._entries.forEach((entry) => {
+            if (entry.data.length > 0) {
+                entry.data = [entry.data.join('')];
+            }
+        });
+        return {
+            events: ( this._entries.map(
+                entry => ({ cols: entry.cols, rows: entry.rows, data: entry.data[0] ?? '' })
+            )),
+            commands: {
+                isWindowsPty: false,
+                hasRichCommandDetection: false,
+                commands: [],
+                promptInputModel: undefined,
+            }
+        };
+    }
+    async generateReplayEvent() {
+        return this.generateReplayEventSync();
+    }
+}
+
+export { TerminalRecorder };

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

@@ -0,0 +1,28 @@
+import { IEnvironmentVariableInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable";
+import { ITerminalStatus } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { EnvironmentVariableScope, IMergedEnvironmentVariableCollection, IMergedEnvironmentVariableCollectionDiff } from "../../../../platform/terminal/common/environmentVariable.js";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+export declare class EnvironmentVariableInfoStale implements IEnvironmentVariableInfo {
+    private readonly _diff;
+    private readonly _terminalId;
+    private readonly _collection;
+    private readonly _terminalService;
+    private readonly _extensionService;
+    readonly requiresAction = true;
+    constructor(_diff: IMergedEnvironmentVariableCollectionDiff, _terminalId: number, _collection: IMergedEnvironmentVariableCollection, _terminalService: ITerminalService, _extensionService: IExtensionService);
+    private _getInfo;
+    private _getActions;
+    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
+}
+export declare class EnvironmentVariableInfoChangesActive implements IEnvironmentVariableInfo {
+    private readonly _collection;
+    private readonly _commandService;
+    private readonly _extensionService;
+    readonly requiresAction = false;
+    constructor(_collection: IMergedEnvironmentVariableCollection, _commandService: ICommandService, _extensionService: IExtensionService);
+    private _getInfo;
+    private _getActions;
+    getStatus(scope: EnvironmentVariableScope | undefined): ITerminalStatus;
+}

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

@@ -0,0 +1,125 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { TerminalCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { TerminalStatus } from './terminalStatusList.js';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+
+let EnvironmentVariableInfoStale = class EnvironmentVariableInfoStale {
+    constructor(_diff, _terminalId, _collection, _terminalService, _extensionService) {
+        this._diff = _diff;
+        this._terminalId = _terminalId;
+        this._collection = _collection;
+        this._terminalService = _terminalService;
+        this._extensionService = _extensionService;
+        this.requiresAction = true;
+    }
+    _getInfo(scope) {
+        const extSet = ( new Set());
+        addExtensionIdentifiers(extSet, ( this._diff.added.values()));
+        addExtensionIdentifiers(extSet, ( this._diff.removed.values()));
+        addExtensionIdentifiers(extSet, ( this._diff.changed.values()));
+        let message = ( localize(
+            11464,
+            "The following extensions want to relaunch the terminal to contribute to its environment:"
+        ));
+        message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
+        return message;
+    }
+    _getActions() {
+        return [{
+                label: ( localize(11465, "Relaunch Terminal")),
+                run: () => this._terminalService.getInstanceFromId(this._terminalId)?.relaunch(),
+                commandId: TerminalCommandId.Relaunch
+            }];
+    }
+    getStatus(scope) {
+        return {
+            id: TerminalStatus.RelaunchNeeded,
+            severity: Severity.Warning,
+            icon: Codicon.warning,
+            tooltip: this._getInfo(scope),
+            hoverActions: this._getActions()
+        };
+    }
+};
+EnvironmentVariableInfoStale = ( __decorate([
+    ( __param(3, ITerminalService)),
+    ( __param(4, IExtensionService))
+], EnvironmentVariableInfoStale));
+let EnvironmentVariableInfoChangesActive = class EnvironmentVariableInfoChangesActive {
+    constructor(_collection, _commandService, _extensionService) {
+        this._collection = _collection;
+        this._commandService = _commandService;
+        this._extensionService = _extensionService;
+        this.requiresAction = false;
+    }
+    _getInfo(scope) {
+        const extSet = ( new Set());
+        addExtensionIdentifiers(extSet, ( this._collection.getVariableMap(scope).values()));
+        let message = ( localize(
+            11466,
+            "The following extensions have contributed to this terminal's environment:"
+        ));
+        message += getMergedDescription(this._collection, scope, this._extensionService, extSet);
+        return message;
+    }
+    _getActions(scope) {
+        return [{
+                label: ( localize(11467, "Show Environment Contributions")),
+                run: () => this._commandService.executeCommand(TerminalCommandId.ShowEnvironmentContributions, scope),
+                commandId: TerminalCommandId.ShowEnvironmentContributions
+            }];
+    }
+    getStatus(scope) {
+        return {
+            id: TerminalStatus.EnvironmentVariableInfoChangesActive,
+            severity: Severity.Info,
+            tooltip: undefined,
+            detailedTooltip: this._getInfo(scope),
+            hoverActions: this._getActions(scope)
+        };
+    }
+};
+EnvironmentVariableInfoChangesActive = ( __decorate([
+    ( __param(1, ICommandService)),
+    ( __param(2, IExtensionService))
+], EnvironmentVariableInfoChangesActive));
+function getMergedDescription(collection, scope, extensionService, extSet) {
+    const message = ['\n'];
+    const globalDescriptions = collection.getDescriptionMap(undefined);
+    const workspaceDescriptions = collection.getDescriptionMap(scope);
+    for (const ext of extSet) {
+        const globalDescription = globalDescriptions.get(ext);
+        if (globalDescription) {
+            message.push(`\n- \`${getExtensionName(ext, extensionService)}\``);
+            message.push(`: ${globalDescription}`);
+        }
+        const workspaceDescription = workspaceDescriptions.get(ext);
+        if (workspaceDescription) {
+            const workspaceSuffix = globalDescription ? ` (${( localize(11468, 'workspace'))})` : '';
+            message.push(`\n- \`${getExtensionName(ext, extensionService)}${workspaceSuffix}\``);
+            message.push(`: ${workspaceDescription}`);
+        }
+        if (!globalDescription && !workspaceDescription) {
+            message.push(`\n- \`${getExtensionName(ext, extensionService)}\``);
+        }
+    }
+    return message.join('');
+}
+function addExtensionIdentifiers(extSet, diff) {
+    for (const mutators of diff) {
+        for (const mutator of mutators) {
+            extSet.add(mutator.extensionIdentifier);
+        }
+    }
+}
+function getExtensionName(id, extensionService) {
+    return extensionService.extensions.find(e => e.id === id)?.displayName || id;
+}
+
+export { EnvironmentVariableInfoChangesActive, EnvironmentVariableInfoStale };