@codingame/monaco-vscode-api 9.0.2 → 10.0.0

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

@@ -0,0 +1,29 @@
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+class CwdDetectionCapability extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 0 ;
+        this._cwd = '';
+        this._cwds = ( new Map());
+        this._onDidChangeCwd = this._register(( new Emitter()));
+        this.onDidChangeCwd = this._onDidChangeCwd.event;
+    }
+    get cwds() {
+        return Array.from(( this._cwds.keys()));
+    }
+    getCwd() {
+        return this._cwd;
+    }
+    updateCwd(cwd) {
+        const didChange = this._cwd !== cwd;
+        this._cwd = cwd;
+        const count = this._cwds.get(this._cwd) || 0;
+        this._cwds.delete(this._cwd);
+        this._cwds.set(this._cwd, count + 1);
+        if (didChange) {
+            this._onDidChangeCwd.fire(cwd);
+        }
+    }
+}
+export { CwdDetectionCapability };

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

@@ -0,0 +1,22 @@
+import { Emitter } from '../../../../base/common/event.js';
+class NaiveCwdDetectionCapability {
+    constructor(_process) {
+        this._process = _process;
+        this.type = 1 ;
+        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/capabilities/partialCommandDetectionCapability.js

@@ -0,0 +1,48 @@
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+class PartialCommandDetectionCapability extends DisposableStore {
+    get commands() { return this._commands; }
+    constructor(_terminal) {
+        super();
+        this._terminal = _terminal;
+        this.type = 3 ;
+        this._commands = [];
+        this._onCommandFinished = this.add(( new Emitter()));
+        this.onCommandFinished = this._onCommandFinished.event;
+        this.add(this._terminal.onData(e => this._onData(e)));
+        this.add(this._terminal.parser.registerCsiHandler({ final: 'J' }, params => {
+            if (params.length >= 1 && (params[0] === 2 || params[0] === 3)) {
+                this._clearCommandsInViewport();
+            }
+            return false;
+        }));
+    }
+    _onData(data) {
+        if (data === '\x0d') {
+            this._onEnter();
+        }
+    }
+    _onEnter() {
+        if (!this._terminal) {
+            return;
+        }
+        if (this._terminal.buffer.active.cursorX >= 2 ) {
+            const marker = this._terminal.registerMarker(0);
+            if (marker) {
+                this._commands.push(marker);
+                this._onCommandFinished.fire(marker);
+            }
+        }
+    }
+    _clearCommandsInViewport() {
+        let count = 0;
+        for (let i = this._commands.length - 1; i >= 0; i--) {
+            if (this._commands[i].line < this._terminal.buffer.active.baseY) {
+                break;
+            }
+            count++;
+        }
+        this._commands.splice(this._commands.length - count, count);
+    }
+}
+export { PartialCommandDetectionCapability };

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

@@ -0,0 +1,94 @@
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+class TerminalCapabilityStore extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._map = ( new Map());
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return ( this._map.keys());
+    }
+    add(capability, impl) {
+        this._map.set(capability, impl);
+        this._onDidAddCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    get(capability) {
+        return this._map.get(capability);
+    }
+    remove(capability) {
+        const impl = this._map.get(capability);
+        if (!impl) {
+            return;
+        }
+        this._map.delete(capability);
+        this._onDidRemoveCapabilityType.fire(capability);
+        this._onDidAddCapability.fire({ id: capability, capability: impl });
+    }
+    has(capability) {
+        return ( this._map.has(capability));
+    }
+}
+class TerminalCapabilityStoreMultiplexer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._stores = [];
+        this._onDidRemoveCapabilityType = this._register(( new Emitter()));
+        this.onDidRemoveCapabilityType = this._onDidRemoveCapabilityType.event;
+        this._onDidAddCapabilityType = this._register(( new Emitter()));
+        this.onDidAddCapabilityType = this._onDidAddCapabilityType.event;
+        this._onDidRemoveCapability = this._register(( new Emitter()));
+        this.onDidRemoveCapability = this._onDidRemoveCapability.event;
+        this._onDidAddCapability = this._register(( new Emitter()));
+        this.onDidAddCapability = this._onDidAddCapability.event;
+    }
+    get items() {
+        return this._items();
+    }
+    *_items() {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                yield c;
+            }
+        }
+    }
+    has(capability) {
+        for (const store of this._stores) {
+            for (const c of store.items) {
+                if (c === capability) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get(capability) {
+        for (const store of this._stores) {
+            const c = store.get(capability);
+            if (c) {
+                return c;
+            }
+        }
+        return undefined;
+    }
+    add(store) {
+        this._stores.push(store);
+        for (const capability of store.items) {
+            this._onDidAddCapabilityType.fire(capability);
+            this._onDidAddCapability.fire({ id: capability, capability: store.get(capability) });
+        }
+        this._register(store.onDidAddCapabilityType(e => this._onDidAddCapabilityType.fire(e)));
+        this._register(store.onDidAddCapability(e => this._onDidAddCapability.fire(e)));
+        this._register(store.onDidRemoveCapabilityType(e => this._onDidRemoveCapabilityType.fire(e)));
+        this._register(store.onDidRemoveCapability(e => this._onDidRemoveCapability.fire(e)));
+    }
+}
+export { TerminalCapabilityStore, TerminalCapabilityStoreMultiplexer };

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

@@ -0,0 +1,7 @@
+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.js

@@ -0,0 +1,196 @@
+import { isWindows } from '../../../base/common/platform.js';
+import { EnvironmentVariableMutatorType } from './environmentVariable.js';
+const mutatorTypeToLabelMap = ( new Map([
+    [EnvironmentVariableMutatorType.Append, 'APPEND'],
+    [EnvironmentVariableMutatorType.Prepend, 'PREPEND'],
+    [EnvironmentVariableMutatorType.Replace, 'REPLACE']
+]));
+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];
+                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 (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');
+    }
+    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/terminal.js

@@ -1,130 +1,6 @@
 import { Emitter } from '../../../base/common/event.js';
 import '../../contextkey/common/contextkey.js';
 import { Registry } from '../../registry/common/platform.js';
-var TerminalSettingPrefix;
-( (function(TerminalSettingPrefix) {
-    TerminalSettingPrefix["AutomationProfile"] = "terminal.integrated.automationProfile.";
-    TerminalSettingPrefix["DefaultProfile"] = "terminal.integrated.defaultProfile.";
-    TerminalSettingPrefix["Profiles"] = "terminal.integrated.profiles.";
-})(TerminalSettingPrefix || (TerminalSettingPrefix = {})));
-var TerminalSettingId;
-( (function(TerminalSettingId) {
-    TerminalSettingId["SendKeybindingsToShell"] = "terminal.integrated.sendKeybindingsToShell";
-    TerminalSettingId["AutomationProfileLinux"] = "terminal.integrated.automationProfile.linux";
-    TerminalSettingId["AutomationProfileMacOs"] = "terminal.integrated.automationProfile.osx";
-    TerminalSettingId["AutomationProfileWindows"] = "terminal.integrated.automationProfile.windows";
-    TerminalSettingId["ProfilesWindows"] = "terminal.integrated.profiles.windows";
-    TerminalSettingId["ProfilesMacOs"] = "terminal.integrated.profiles.osx";
-    TerminalSettingId["ProfilesLinux"] = "terminal.integrated.profiles.linux";
-    TerminalSettingId["DefaultProfileLinux"] = "terminal.integrated.defaultProfile.linux";
-    TerminalSettingId["DefaultProfileMacOs"] = "terminal.integrated.defaultProfile.osx";
-    TerminalSettingId["DefaultProfileWindows"] = "terminal.integrated.defaultProfile.windows";
-    TerminalSettingId["UseWslProfiles"] = "terminal.integrated.useWslProfiles";
-    TerminalSettingId["TabsDefaultColor"] = "terminal.integrated.tabs.defaultColor";
-    TerminalSettingId["TabsDefaultIcon"] = "terminal.integrated.tabs.defaultIcon";
-    TerminalSettingId["TabsEnabled"] = "terminal.integrated.tabs.enabled";
-    TerminalSettingId["TabsEnableAnimation"] = "terminal.integrated.tabs.enableAnimation";
-    TerminalSettingId["TabsHideCondition"] = "terminal.integrated.tabs.hideCondition";
-    TerminalSettingId["TabsShowActiveTerminal"] = "terminal.integrated.tabs.showActiveTerminal";
-    TerminalSettingId["TabsShowActions"] = "terminal.integrated.tabs.showActions";
-    TerminalSettingId["TabsLocation"] = "terminal.integrated.tabs.location";
-    TerminalSettingId["TabsFocusMode"] = "terminal.integrated.tabs.focusMode";
-    TerminalSettingId["MacOptionIsMeta"] = "terminal.integrated.macOptionIsMeta";
-    TerminalSettingId["MacOptionClickForcesSelection"] = "terminal.integrated.macOptionClickForcesSelection";
-    TerminalSettingId["AltClickMovesCursor"] = "terminal.integrated.altClickMovesCursor";
-    TerminalSettingId["CopyOnSelection"] = "terminal.integrated.copyOnSelection";
-    TerminalSettingId["EnableMultiLinePasteWarning"] = "terminal.integrated.enableMultiLinePasteWarning";
-    TerminalSettingId["DrawBoldTextInBrightColors"] = "terminal.integrated.drawBoldTextInBrightColors";
-    TerminalSettingId["FontFamily"] = "terminal.integrated.fontFamily";
-    TerminalSettingId["FontSize"] = "terminal.integrated.fontSize";
-    TerminalSettingId["LetterSpacing"] = "terminal.integrated.letterSpacing";
-    TerminalSettingId["LineHeight"] = "terminal.integrated.lineHeight";
-    TerminalSettingId["MinimumContrastRatio"] = "terminal.integrated.minimumContrastRatio";
-    TerminalSettingId["TabStopWidth"] = "terminal.integrated.tabStopWidth";
-    TerminalSettingId["FastScrollSensitivity"] = "terminal.integrated.fastScrollSensitivity";
-    TerminalSettingId["MouseWheelScrollSensitivity"] = "terminal.integrated.mouseWheelScrollSensitivity";
-    TerminalSettingId["BellDuration"] = "terminal.integrated.bellDuration";
-    TerminalSettingId["FontWeight"] = "terminal.integrated.fontWeight";
-    TerminalSettingId["FontWeightBold"] = "terminal.integrated.fontWeightBold";
-    TerminalSettingId["CursorBlinking"] = "terminal.integrated.cursorBlinking";
-    TerminalSettingId["CursorStyle"] = "terminal.integrated.cursorStyle";
-    TerminalSettingId["CursorStyleInactive"] = "terminal.integrated.cursorStyleInactive";
-    TerminalSettingId["CursorWidth"] = "terminal.integrated.cursorWidth";
-    TerminalSettingId["Scrollback"] = "terminal.integrated.scrollback";
-    TerminalSettingId["DetectLocale"] = "terminal.integrated.detectLocale";
-    TerminalSettingId["DefaultLocation"] = "terminal.integrated.defaultLocation";
-    TerminalSettingId["GpuAcceleration"] = "terminal.integrated.gpuAcceleration";
-    TerminalSettingId["TerminalTitleSeparator"] = "terminal.integrated.tabs.separator";
-    TerminalSettingId["TerminalTitle"] = "terminal.integrated.tabs.title";
-    TerminalSettingId["TerminalDescription"] = "terminal.integrated.tabs.description";
-    TerminalSettingId["RightClickBehavior"] = "terminal.integrated.rightClickBehavior";
-    TerminalSettingId["MiddleClickBehavior"] = "terminal.integrated.middleClickBehavior";
-    TerminalSettingId["Cwd"] = "terminal.integrated.cwd";
-    TerminalSettingId["ConfirmOnExit"] = "terminal.integrated.confirmOnExit";
-    TerminalSettingId["ConfirmOnKill"] = "terminal.integrated.confirmOnKill";
-    TerminalSettingId["EnableBell"] = "terminal.integrated.enableBell";
-    TerminalSettingId["EnableVisualBell"] = "terminal.integrated.enableVisualBell";
-    TerminalSettingId["CommandsToSkipShell"] = "terminal.integrated.commandsToSkipShell";
-    TerminalSettingId["AllowChords"] = "terminal.integrated.allowChords";
-    TerminalSettingId["AllowMnemonics"] = "terminal.integrated.allowMnemonics";
-    TerminalSettingId["TabFocusMode"] = "terminal.integrated.tabFocusMode";
-    TerminalSettingId["EnvMacOs"] = "terminal.integrated.env.osx";
-    TerminalSettingId["EnvLinux"] = "terminal.integrated.env.linux";
-    TerminalSettingId["EnvWindows"] = "terminal.integrated.env.windows";
-    TerminalSettingId["EnvironmentChangesIndicator"] = "terminal.integrated.environmentChangesIndicator";
-    TerminalSettingId["EnvironmentChangesRelaunch"] = "terminal.integrated.environmentChangesRelaunch";
-    TerminalSettingId["ExperimentalWindowsUseConptyDll"] = "terminal.integrated.experimental.windowsUseConptyDll";
-    TerminalSettingId["ShowExitAlert"] = "terminal.integrated.showExitAlert";
-    TerminalSettingId["SplitCwd"] = "terminal.integrated.splitCwd";
-    TerminalSettingId["WindowsEnableConpty"] = "terminal.integrated.windowsEnableConpty";
-    TerminalSettingId["WordSeparators"] = "terminal.integrated.wordSeparators";
-    TerminalSettingId["EnableFileLinks"] = "terminal.integrated.enableFileLinks";
-    TerminalSettingId["AllowedLinkSchemes"] = "terminal.integrated.allowedLinkSchemes";
-    TerminalSettingId["UnicodeVersion"] = "terminal.integrated.unicodeVersion";
-    TerminalSettingId["EnablePersistentSessions"] = "terminal.integrated.enablePersistentSessions";
-    TerminalSettingId["PersistentSessionReviveProcess"] = "terminal.integrated.persistentSessionReviveProcess";
-    TerminalSettingId["HideOnStartup"] = "terminal.integrated.hideOnStartup";
-    TerminalSettingId["CustomGlyphs"] = "terminal.integrated.customGlyphs";
-    TerminalSettingId["RescaleOverlappingGlyphs"] = "terminal.integrated.rescaleOverlappingGlyphs";
-    TerminalSettingId["PersistentSessionScrollback"] = "terminal.integrated.persistentSessionScrollback";
-    TerminalSettingId["InheritEnv"] = "terminal.integrated.inheritEnv";
-    TerminalSettingId["ShowLinkHover"] = "terminal.integrated.showLinkHover";
-    TerminalSettingId["IgnoreProcessNames"] = "terminal.integrated.ignoreProcessNames";
-    TerminalSettingId["AutoReplies"] = "terminal.integrated.autoReplies";
-    TerminalSettingId["ShellIntegrationEnabled"] = "terminal.integrated.shellIntegration.enabled";
-    TerminalSettingId["ShellIntegrationShowWelcome"] = "terminal.integrated.shellIntegration.showWelcome";
-    TerminalSettingId["ShellIntegrationDecorationsEnabled"] = "terminal.integrated.shellIntegration.decorationsEnabled";
-    TerminalSettingId["ShellIntegrationCommandHistory"] = "terminal.integrated.shellIntegration.history";
-    TerminalSettingId["EnableImages"] = "terminal.integrated.enableImages";
-    TerminalSettingId["SmoothScrolling"] = "terminal.integrated.smoothScrolling";
-    TerminalSettingId["IgnoreBracketedPasteMode"] = "terminal.integrated.ignoreBracketedPasteMode";
-    TerminalSettingId["FocusAfterRun"] = "terminal.integrated.focusAfterRun";
-    TerminalSettingId["DeveloperPtyHostLatency"] = "terminal.integrated.developer.ptyHost.latency";
-    TerminalSettingId["DeveloperPtyHostStartupDelay"] = "terminal.integrated.developer.ptyHost.startupDelay";
-    TerminalSettingId["DevMode"] = "terminal.integrated.developer.devMode";
-})(TerminalSettingId || (TerminalSettingId = {})));
-var PosixShellType;
-( (function(PosixShellType) {
-    PosixShellType["Bash"] = "bash";
-    PosixShellType["Fish"] = "fish";
-    PosixShellType["Sh"] = "sh";
-    PosixShellType["Csh"] = "csh";
-    PosixShellType["Ksh"] = "ksh";
-    PosixShellType["Zsh"] = "zsh";
-})(PosixShellType || (PosixShellType = {})));
-var WindowsShellType;
-( (function(WindowsShellType) {
-    WindowsShellType["CommandPrompt"] = "cmd";
-    WindowsShellType["Wsl"] = "wsl";
-    WindowsShellType["GitBash"] = "gitbash";
-})(WindowsShellType || (WindowsShellType = {})));
-var GeneralShellType;
-( (function(GeneralShellType) {
-    GeneralShellType["PowerShell"] = "pwsh";
-    GeneralShellType["Python"] = "python";
-    GeneralShellType["Julia"] = "julia";
-    GeneralShellType["NuShell"] = "nu";
-})(GeneralShellType || (GeneralShellType = {})));
 var TitleEventSource;
 ( (function(TitleEventSource) {
     TitleEventSource[TitleEventSource["Api"] = 0] = "Api";
@@ -132,41 +8,11 @@ var TitleEventSource;
     TitleEventSource[TitleEventSource["Sequence"] = 2] = "Sequence";
     TitleEventSource[TitleEventSource["Config"] = 3] = "Config";
 })(TitleEventSource || (TitleEventSource = {})));
-var ProcessPropertyType;
-( (function(ProcessPropertyType) {
-    ProcessPropertyType["Cwd"] = "cwd";
-    ProcessPropertyType["InitialCwd"] = "initialCwd";
-    ProcessPropertyType["FixedDimensions"] = "fixedDimensions";
-    ProcessPropertyType["Title"] = "title";
-    ProcessPropertyType["ShellType"] = "shellType";
-    ProcessPropertyType["HasChildProcesses"] = "hasChildProcesses";
-    ProcessPropertyType["ResolvedShellLaunchConfig"] = "resolvedShellLaunchConfig";
-    ProcessPropertyType["OverrideDimensions"] = "overrideDimensions";
-    ProcessPropertyType["FailedShellIntegrationActivation"] = "failedShellIntegrationActivation";
-    ProcessPropertyType["UsedShellIntegrationInjection"] = "usedShellIntegrationInjection";
-})(ProcessPropertyType || (ProcessPropertyType = {})));
 var TerminalLocation;
 ( (function(TerminalLocation) {
     TerminalLocation[TerminalLocation["Panel"] = 1] = "Panel";
     TerminalLocation[TerminalLocation["Editor"] = 2] = "Editor";
 })(TerminalLocation || (TerminalLocation = {})));
-var TerminalLocationString;
-( (function(TerminalLocationString) {
-    TerminalLocationString["TerminalView"] = "view";
-    TerminalLocationString["Editor"] = "editor";
-})(TerminalLocationString || (TerminalLocationString = {})));
-var FlowControlConstants;
-( (function(FlowControlConstants) {
-    FlowControlConstants[FlowControlConstants["HighWatermarkChars"] = 100000] = "HighWatermarkChars";
-    FlowControlConstants[FlowControlConstants["LowWatermarkChars"] = 5000] = "LowWatermarkChars";
-    FlowControlConstants[FlowControlConstants["CharCountAckSize"] = 5000] = "CharCountAckSize";
-})(FlowControlConstants || (FlowControlConstants = {})));
-var ShellIntegrationStatus;
-( (function(ShellIntegrationStatus) {
-    ShellIntegrationStatus[ShellIntegrationStatus["Off"] = 0] = "Off";
-    ShellIntegrationStatus[ShellIntegrationStatus["FinalTerm"] = 1] = "FinalTerm";
-    ShellIntegrationStatus[ShellIntegrationStatus["VSCode"] = 2] = "VSCode";
-})(ShellIntegrationStatus || (ShellIntegrationStatus = {})));
 var TerminalExitReason;
 ( (function(TerminalExitReason) {
     TerminalExitReason[TerminalExitReason["Unknown"] = 0] = "Unknown";
@@ -211,4 +57,4 @@ class TerminalBackendRegistry {
     }
 }
 Registry.add(TerminalExtensions.Backend, ( new TerminalBackendRegistry()));
-export { FlowControlConstants, GeneralShellType, PosixShellType, ProcessPropertyType, ShellIntegrationStatus, TerminalBackendChangeEvent, TerminalExitReason, TerminalExtensions, TerminalLocation, TerminalLocationString, TerminalSettingId, TerminalSettingPrefix, TitleEventSource, WindowsShellType };
+export { TerminalBackendChangeEvent, TerminalExitReason, TerminalExtensions, TerminalLocation, TitleEventSource };

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

@@ -0,0 +1,40 @@
+import { OS } from '../../../base/common/platform.js';
+function escapeNonWindowsPath(path) {
+    let newPath = path;
+    if (newPath.includes('\\')) {
+        newPath = newPath.replace(/\\/g, '\\\\');
+    }
+    const bannedChars = /[\`\$\|\&\>\~\#\!\^\*\;\<\"\']/g;
+    newPath = newPath.replace(bannedChars, '');
+    return `'${newPath}'`;
+}
+function collapseTildePath(path, userHome, separator) {
+    if (!path) {
+        return '';
+    }
+    if (!userHome) {
+        return path;
+    }
+    if (userHome.match(/[\/\\]$/)) {
+        userHome = userHome.slice(0, userHome.length - 1);
+    }
+    const normalizedPath = path.replace(/\\/g, '/').toLowerCase();
+    const normalizedUserHome = userHome.replace(/\\/g, '/').toLowerCase();
+    if (!normalizedPath.includes(normalizedUserHome)) {
+        return path;
+    }
+    return `~${separator}${path.slice(userHome.length + 1)}`;
+}
+function sanitizeCwd(cwd) {
+    if (cwd.match(/^['"].*['"]$/)) {
+        cwd = cwd.substring(1, cwd.length - 1);
+    }
+    if (OS === 1  && cwd && cwd[1] === ':') {
+        return cwd[0].toUpperCase() + cwd.substring(1);
+    }
+    return cwd;
+}
+function shouldUseEnvironmentVariableCollection(slc) {
+    return !slc.strictEnv;
+}
+export { collapseTildePath, escapeNonWindowsPath, sanitizeCwd, shouldUseEnvironmentVariableCollection };