@codingame/monaco-vscode-api 30.0.1 → 31.0.1

package/vscode/src/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -16,7 +16,7 @@ import { PANEL_BORDER, EDITOR_DRAG_AND_DROP_BACKGROUND, TAB_ACTIVE_BORDER } from
 
 const ansiColorIdentifiers = [];
 const TERMINAL_BACKGROUND_COLOR = registerColor("terminal.background", null, ( localize(
-    13552,
+    13692,
     "The background color of the terminal, this allows coloring the terminal differently to the panel."
 )));
 const TERMINAL_FOREGROUND_COLOR = registerColor("terminal.foreground", {
@@ -24,20 +24,20 @@ const TERMINAL_FOREGROUND_COLOR = registerColor("terminal.foreground", {
     dark: "#CCCCCC",
     hcDark: "#FFFFFF",
     hcLight: "#292929"
-}, ( localize(13553, "The foreground color of the terminal.")));
-const TERMINAL_CURSOR_FOREGROUND_COLOR = registerColor("terminalCursor.foreground", null, ( localize(13554, "The foreground color of the terminal cursor.")));
+}, ( localize(13693, "The foreground color of the terminal.")));
+const TERMINAL_CURSOR_FOREGROUND_COLOR = registerColor("terminalCursor.foreground", null, ( localize(13694, "The foreground color of the terminal cursor.")));
 const TERMINAL_CURSOR_BACKGROUND_COLOR = registerColor("terminalCursor.background", null, ( localize(
-    13555,
+    13695,
     "The background color of the terminal cursor. Allows customizing the color of a character overlapped by a block cursor."
 )));
-const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor("terminal.selectionBackground", editorSelectionBackground, ( localize(13556, "The selection background color of the terminal.")));
+const TERMINAL_SELECTION_BACKGROUND_COLOR = registerColor("terminal.selectionBackground", editorSelectionBackground, ( localize(13696, "The selection background color of the terminal.")));
 const TERMINAL_INACTIVE_SELECTION_BACKGROUND_COLOR = registerColor("terminal.inactiveSelectionBackground", {
     light: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5)),
     dark: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5)),
     hcDark: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.7)),
     hcLight: ( transparent(TERMINAL_SELECTION_BACKGROUND_COLOR, 0.5))
 }, ( localize(
-    13557,
+    13697,
     "The selection background color of the terminal when it does not have focus."
 )));
 const TERMINAL_SELECTION_FOREGROUND_COLOR = registerColor("terminal.selectionForeground", {
@@ -46,7 +46,7 @@ const TERMINAL_SELECTION_FOREGROUND_COLOR = registerColor("terminal.selectionFor
     hcDark: "#000000",
     hcLight: "#ffffff"
 }, ( localize(
-    13558,
+    13698,
     "The selection foreground color of the terminal. When this is null the selection foreground will be retained and have the minimum contrast ratio feature applied."
 )));
 const TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR = registerColor("terminalCommandDecoration.defaultBackground", {
@@ -54,14 +54,14 @@ const TERMINAL_COMMAND_DECORATION_DEFAULT_BACKGROUND_COLOR = registerColor("term
     dark: "#ffffff40",
     hcDark: "#ffffff80",
     hcLight: "#00000040"
-}, ( localize(13559, "The default terminal command decoration background color.")));
+}, ( localize(13699, "The default terminal command decoration background color.")));
 const TERMINAL_COMMAND_DECORATION_SUCCESS_BACKGROUND_COLOR = registerColor("terminalCommandDecoration.successBackground", {
     dark: "#1B81A8",
     light: "#2090D3",
     hcDark: "#1B81A8",
     hcLight: "#007100"
 }, ( localize(
-    13560,
+    13700,
     "The terminal command decoration background color for successful commands."
 )));
 const TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR = registerColor("terminalCommandDecoration.errorBackground", {
@@ -70,26 +70,26 @@ const TERMINAL_COMMAND_DECORATION_ERROR_BACKGROUND_COLOR = registerColor("termin
     hcDark: "#F14C4C",
     hcLight: "#B5200D"
 }, ( localize(
-    13561,
+    13701,
     "The terminal command decoration background color for error commands."
 )));
-const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor("terminalOverviewRuler.cursorForeground", "#A0A0A0CC", ( localize(13562, "The overview ruler cursor color.")));
+const TERMINAL_OVERVIEW_RULER_CURSOR_FOREGROUND_COLOR = registerColor("terminalOverviewRuler.cursorForeground", "#A0A0A0CC", ( localize(13702, "The overview ruler cursor color.")));
 registerColor("terminal.border", PANEL_BORDER, ( localize(
-    13563,
+    13703,
     "The color of the border that separates split panes within the terminal. This defaults to panel.border."
 )));
-const TERMINAL_OVERVIEW_RULER_BORDER_COLOR = registerColor("terminalOverviewRuler.border", editorOverviewRulerBorder, ( localize(13564, "The overview ruler left-side border color.")));
+const TERMINAL_OVERVIEW_RULER_BORDER_COLOR = registerColor("terminalOverviewRuler.border", editorOverviewRulerBorder, ( localize(13704, "The overview ruler left-side border color.")));
 const TERMINAL_FIND_MATCH_BACKGROUND_COLOR = registerColor("terminal.findMatchBackground", {
     dark: editorFindMatch,
     light: editorFindMatch,
     hcDark: null,
     hcLight: "#0F4A85"
 }, ( localize(
-    13565,
+    13705,
     "Color of the current search match in the terminal. The color must not be opaque so as not to hide underlying terminal content."
 )), true);
 registerColor("terminal.hoverHighlightBackground", ( transparent(editorHoverHighlight, 0.5)), ( localize(
-    13566,
+    13706,
     "Highlight below the word for which a hover is shown. The color must not be opaque so as not to hide underlying decorations."
 )));
 const TERMINAL_FIND_MATCH_BORDER_COLOR = registerColor("terminal.findMatchBorder", {
@@ -97,14 +97,14 @@ const TERMINAL_FIND_MATCH_BORDER_COLOR = registerColor("terminal.findMatchBorder
     light: null,
     hcDark: "#f38518",
     hcLight: "#0F4A85"
-}, ( localize(13567, "Border color of the current search match in the terminal.")));
+}, ( localize(13707, "Border color of the current search match in the terminal.")));
 const TERMINAL_FIND_MATCH_HIGHLIGHT_BACKGROUND_COLOR = registerColor("terminal.findMatchHighlightBackground", {
     dark: editorFindMatchHighlight,
     light: editorFindMatchHighlight,
     hcDark: null,
     hcLight: null
 }, ( localize(
-    13568,
+    13708,
     "Color of the other search matches in the terminal. The color must not be opaque so as not to hide underlying terminal content."
 )), true);
 const TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR = registerColor("terminal.findMatchHighlightBorder", {
@@ -112,19 +112,19 @@ const TERMINAL_FIND_MATCH_HIGHLIGHT_BORDER_COLOR = registerColor("terminal.findM
     light: null,
     hcDark: "#f38518",
     hcLight: "#0F4A85"
-}, ( localize(13569, "Border color of the other search matches in the terminal.")));
+}, ( localize(13709, "Border color of the other search matches in the terminal.")));
 const TERMINAL_OVERVIEW_RULER_FIND_MATCH_FOREGROUND_COLOR = registerColor("terminalOverviewRuler.findMatchForeground", {
     dark: overviewRulerFindMatchForeground,
     light: overviewRulerFindMatchForeground,
     hcDark: "#f38518",
     hcLight: "#0F4A85"
-}, ( localize(13570, "Overview ruler marker color for find matches in the terminal.")));
+}, ( localize(13710, "Overview ruler marker color for find matches in the terminal.")));
 registerColor("terminal.dropBackground", EDITOR_DRAG_AND_DROP_BACKGROUND, ( localize(
-    13571,
+    13711,
     "Background color when dragging on top of terminals. The color should have transparency so that the terminal contents can still shine through."
 )), true);
 registerColor("terminal.tab.activeBorder", TAB_ACTIVE_BORDER, ( localize(
-    13572,
+    13712,
     "Border on the side of the terminal tab in the panel. This defaults to tab.activeBorder."
 )));
 registerColor("terminal.initialHintForeground", {
@@ -132,7 +132,7 @@ registerColor("terminal.initialHintForeground", {
     light: "#0007",
     hcDark: null,
     hcLight: null
-}, ( localize(13573, "Foreground color of the terminal initial hint.")));
+}, ( localize(13713, "Foreground color of the terminal initial hint.")));
 const ansiColorMap = {
     "terminal.ansiBlack": {
         index: 0,
@@ -283,7 +283,7 @@ function registerColors() {
     for (const id in ansiColorMap) {
         const entry = ansiColorMap[id];
         const colorName = id.substring(13);
-        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localize(13574, "'{0}' ANSI color in the terminal.", colorName)));
+        ansiColorIdentifiers[entry.index] = registerColor(id, entry.defaults, ( localize(13714, "'{0}' ANSI color in the terminal.", colorName)));
     }
 }
 

package/vscode/src/vs/workbench/contrib/terminal/common/terminalContextKey.js

@@ -43,17 +43,17 @@ var TerminalContextKeyStrings;
 var TerminalContextKeys;
 (function(TerminalContextKeys) {
     TerminalContextKeys.isOpen = ( new RawContextKey(TerminalContextKeyStrings.IsOpen, false, true));
-    TerminalContextKeys.focus = ( new RawContextKey(TerminalContextKeyStrings.Focus, false, ( localize(13738, "Whether the terminal is focused."))));
+    TerminalContextKeys.focus = ( new RawContextKey(TerminalContextKeyStrings.Focus, false, ( localize(13879, "Whether the terminal is focused."))));
     TerminalContextKeys.focusInAny = ( new RawContextKey(TerminalContextKeyStrings.FocusInAny, false, ( localize(
-        13739,
+        13880,
         "Whether any terminal is focused, including detached terminals used in other UI."
     ))));
-    TerminalContextKeys.editorFocus = ( new RawContextKey(TerminalContextKeyStrings.EditorFocus, false, ( localize(13740, "Whether a terminal in the editor area is focused."))));
-    TerminalContextKeys.count = ( new RawContextKey(TerminalContextKeyStrings.Count, 0, ( localize(13741, "The current number of terminals."))));
+    TerminalContextKeys.editorFocus = ( new RawContextKey(TerminalContextKeyStrings.EditorFocus, false, ( localize(13881, "Whether a terminal in the editor area is focused."))));
+    TerminalContextKeys.count = ( new RawContextKey(TerminalContextKeyStrings.Count, 0, ( localize(13882, "The current number of terminals."))));
     TerminalContextKeys.groupCount = ( new RawContextKey(TerminalContextKeyStrings.GroupCount, 0, true));
     TerminalContextKeys.tabsNarrow = ( new RawContextKey(TerminalContextKeyStrings.TabsNarrow, false, true));
     TerminalContextKeys.terminalHasFixedWidth = ( new RawContextKey(TerminalContextKeyStrings.HasFixedWidth, false, true));
-    TerminalContextKeys.tabsFocus = ( new RawContextKey(TerminalContextKeyStrings.TabsFocus, false, ( localize(13742, "Whether the terminal tabs widget is focused."))));
+    TerminalContextKeys.tabsFocus = ( new RawContextKey(TerminalContextKeyStrings.TabsFocus, false, ( localize(13883, "Whether the terminal tabs widget is focused."))));
     TerminalContextKeys.webExtensionContributedProfile = ( new RawContextKey(TerminalContextKeyStrings.WebExtensionContributedProfile, false, true));
     TerminalContextKeys.terminalHasBeenCreated = ( new RawContextKey(TerminalContextKeyStrings.TerminalHasBeenCreated, false, true));
     TerminalContextKeys.terminalEditorActive = ( new RawContextKey(TerminalContextKeyStrings.TerminalEditorActive, false, true));
@@ -61,16 +61,16 @@ var TerminalContextKeys;
     TerminalContextKeys.shellType = ( new RawContextKey(TerminalContextKeyStrings.ShellType, undefined, {
         type: "string",
         description: ( localize(
-            13743,
+            13884,
             "The shell type of the active terminal, this is set if the type can be detected."
         ))
     }));
-    TerminalContextKeys.altBufferActive = ( new RawContextKey(TerminalContextKeyStrings.AltBufferActive, false, ( localize(13744, "Whether the terminal's alt buffer is active."))));
-    TerminalContextKeys.suggestWidgetVisible = ( new RawContextKey(TerminalContextKeyStrings.SuggestWidgetVisible, false, ( localize(13745, "Whether the terminal's suggest widget is visible."))));
+    TerminalContextKeys.altBufferActive = ( new RawContextKey(TerminalContextKeyStrings.AltBufferActive, false, ( localize(13885, "Whether the terminal's alt buffer is active."))));
+    TerminalContextKeys.suggestWidgetVisible = ( new RawContextKey(TerminalContextKeyStrings.SuggestWidgetVisible, false, ( localize(13886, "Whether the terminal's suggest widget is visible."))));
     TerminalContextKeys.notFocus = ( TerminalContextKeys.focus.toNegated());
-    TerminalContextKeys.viewShowing = ( new RawContextKey(TerminalContextKeyStrings.ViewShowing, false, ( localize(13746, "Whether the terminal view is showing"))));
-    TerminalContextKeys.textSelected = ( new RawContextKey(TerminalContextKeyStrings.TextSelected, false, ( localize(13747, "Whether text is selected in the active terminal."))));
-    TerminalContextKeys.textSelectedInFocused = ( new RawContextKey(TerminalContextKeyStrings.TextSelectedInFocused, false, ( localize(13748, "Whether text is selected in a focused terminal."))));
+    TerminalContextKeys.viewShowing = ( new RawContextKey(TerminalContextKeyStrings.ViewShowing, false, ( localize(13887, "Whether the terminal view is showing"))));
+    TerminalContextKeys.textSelected = ( new RawContextKey(TerminalContextKeyStrings.TextSelected, false, ( localize(13888, "Whether text is selected in the active terminal."))));
+    TerminalContextKeys.textSelectedInFocused = ( new RawContextKey(TerminalContextKeyStrings.TextSelectedInFocused, false, ( localize(13889, "Whether text is selected in a focused terminal."))));
     TerminalContextKeys.notTextSelected = ( TerminalContextKeys.textSelected.toNegated());
     TerminalContextKeys.findVisible = ( new RawContextKey(TerminalContextKeyStrings.FindVisible, false, true));
     TerminalContextKeys.notFindVisible = ( TerminalContextKeys.findVisible.toNegated());
@@ -78,21 +78,21 @@ var TerminalContextKeys;
     TerminalContextKeys.findFocus = ( new RawContextKey(TerminalContextKeyStrings.FindFocused, false, true));
     TerminalContextKeys.notFindFocus = ( TerminalContextKeys.findInputFocus.toNegated());
     TerminalContextKeys.processSupported = ( new RawContextKey(TerminalContextKeyStrings.ProcessSupported, false, ( localize(
-        13749,
+        13890,
         "Whether terminal processes can be launched in the current workspace."
     ))));
-    TerminalContextKeys.tabsSingularSelection = ( new RawContextKey(TerminalContextKeyStrings.TabsSingularSelection, false, ( localize(13750, "Whether one terminal is selected in the terminal tabs list."))));
-    TerminalContextKeys.splitTerminalTabFocused = ( new RawContextKey(TerminalContextKeyStrings.SplitTerminal, false, ( localize(13751, "Whether the focused tab's terminal is a split terminal."))));
-    TerminalContextKeys.splitTerminalActive = ( new RawContextKey(TerminalContextKeyStrings.SplitPaneActive, false, ( localize(13752, "Whether the active terminal is a split pane."))));
+    TerminalContextKeys.tabsSingularSelection = ( new RawContextKey(TerminalContextKeyStrings.TabsSingularSelection, false, ( localize(13891, "Whether one terminal is selected in the terminal tabs list."))));
+    TerminalContextKeys.splitTerminalTabFocused = ( new RawContextKey(TerminalContextKeyStrings.SplitTerminal, false, ( localize(13892, "Whether the focused tab's terminal is a split terminal."))));
+    TerminalContextKeys.splitTerminalActive = ( new RawContextKey(TerminalContextKeyStrings.SplitPaneActive, false, ( localize(13893, "Whether the active terminal is a split pane."))));
     TerminalContextKeys.inTerminalRunCommandPicker = ( new RawContextKey(
         TerminalContextKeyStrings.InTerminalRunCommandPicker,
         false,
-        ( localize(13753, "Whether the terminal run command picker is currently open."))
+        ( localize(13894, "Whether the terminal run command picker is currently open."))
     ));
     TerminalContextKeys.terminalShellIntegrationEnabled = ( new RawContextKey(
         TerminalContextKeyStrings.TerminalShellIntegrationEnabled,
         false,
-        ( localize(13754, "Whether shell integration is enabled in the active terminal"))
+        ( localize(13895, "Whether shell integration is enabled in the active terminal"))
     ));
     TerminalContextKeys.terminalDictationInProgress = ( new RawContextKey(TerminalContextKeyStrings.DictationInProgress, false));
     TerminalContextKeys.shouldShowViewInlineActions = ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", TERMINAL_VIEW_ID)), ( ContextKeyExpr.notEquals(`config.${TerminalSettingId.TabsHideCondition}`, "never")), ContextKeyExpr.not(TerminalContribContextKeyStrings.ChatHasHiddenTerminals), ( ContextKeyExpr.or(

package/vscode/src/vs/workbench/contrib/terminal/common/terminalEnvironment.d.ts

@@ -0,0 +1,38 @@
+import { URI } from "../../../../base/common/uri.js";
+import { IWorkspaceFolder } from "../../../../platform/workspace/common/workspace.js";
+import { IWorkspaceContextService } from "../../../../platform/workspace/common/workspace.service.js";
+import { IConfigurationResolverService } from "../../../services/configurationResolver/common/configurationResolver.service.js";
+import { IShellLaunchConfig, ITerminalBackend, ITerminalEnvironment, TerminalShellType } from "../../../../platform/terminal/common/terminal.js";
+import { IProcessEnvironment, OperatingSystem } from "../../../../base/common/platform.js";
+import { IHistoryService } from "../../../services/history/common/history.service.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+export declare function mergeEnvironments(parent: IProcessEnvironment, other: ITerminalEnvironment | undefined): void;
+export declare function addTerminalEnvironmentKeys(env: IProcessEnvironment, version: string | undefined, locale: string | undefined, detectLocale: "auto" | "off" | "on"): void;
+export declare function shouldSetLangEnvVariable(env: IProcessEnvironment, detectLocale: "auto" | "off" | "on"): boolean;
+export declare function getLangEnvVariable(locale?: string): string;
+export declare function getCwd(shell: IShellLaunchConfig, userHome: string | undefined, variableResolver: VariableResolver | undefined, root: URI | undefined, customCwd: string | undefined, logService?: ILogService): Promise<string>;
+export type VariableResolver = (str: string) => Promise<string>;
+export declare function createVariableResolver(lastActiveWorkspace: IWorkspaceFolder | undefined, env: IProcessEnvironment, configurationResolverService: IConfigurationResolverService | undefined): VariableResolver | undefined;
+export declare function createTerminalEnvironment(shellLaunchConfig: IShellLaunchConfig, envFromConfig: ITerminalEnvironment | undefined, variableResolver: VariableResolver | undefined, version: string | undefined, detectLocale: "auto" | "off" | "on", baseEnv: IProcessEnvironment): Promise<IProcessEnvironment>;
+/**
+ * Takes a path and returns the properly escaped path to send to a given shell. On Windows, this
+ * included trying to prepare the path for WSL if needed.
+ *
+ * @param originalPath The path to be escaped and formatted.
+ * @param executable The executable off the shellLaunchConfig.
+ * @param title The terminal's title.
+ * @param shellType The type of shell the path is being sent to.
+ * @param backend The backend for the terminal.
+ * @param isWindowsFrontend Whether the frontend is Windows, this is only exposed for injection via
+ * tests.
+ * @returns An escaped version of the path to be executed in the terminal.
+ */
+export declare function preparePathForShell(resource: string | URI, executable: string | undefined, title: string, shellType: TerminalShellType | undefined, backend: Pick<ITerminalBackend, "getWslPath"> | undefined, os: OperatingSystem | undefined, isWindowsFrontend?: boolean): Promise<string>;
+export declare function getWorkspaceForTerminal(cwd: URI | string | undefined, workspaceContextService: IWorkspaceContextService, historyService: IHistoryService): IWorkspaceFolder | undefined;
+export declare function getUriLabelForShell(uri: URI | string, backend: Pick<ITerminalBackend, "getWslPath">, shellType?: TerminalShellType, os?: OperatingSystem, isWindowsFrontend?: boolean): Promise<string>;
+/**
+ * Gets the unified duration to wait for shell integration after the terminal launches before
+ * declaring the terminal lacks shell integration.
+ */
+export declare function getShellIntegrationTimeout(configurationService: IConfigurationService, siInjectionEnabled: boolean, isRemote: boolean, processReadyTimestamp?: number): number;

package/vscode/src/vs/workbench/contrib/terminal/common/terminalEnvironment.js

@@ -0,0 +1,321 @@
+
+import { isAbsolute, join, basename } from '../../../../base/common/path.js';
+import { URI, uriToFsPath } from '../../../../base/common/uri.js';
+import { sanitizeProcessEnvironment } from '../../../../base/common/processes.js';
+import { WindowsShellType, TerminalSettingId, ShellIntegrationTimeoutOverride } from '../../../../platform/terminal/common/terminal.js';
+import { isWindows, isMacintosh, language, OperatingSystem } from '../../../../base/common/platform.js';
+import { sanitizeCwd, escapeNonWindowsPath } from '../../../../platform/terminal/common/terminalEnvironment.js';
+import { isString, isNumber } from '../../../../base/common/types.js';
+
+function mergeEnvironments(parent, other) {
+    if (!other) {
+        return;
+    }
+    if (isWindows) {
+        for (const configKey in other) {
+            let actualKey = configKey;
+            for (const envKey in parent) {
+                if (configKey.toLowerCase() === envKey.toLowerCase()) {
+                    actualKey = envKey;
+                    break;
+                }
+            }
+            const value = other[configKey];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, actualKey, value);
+            }
+        }
+    } else {
+        ( Object.keys(other)).forEach(key => {
+            const value = other[key];
+            if (value !== undefined) {
+                _mergeEnvironmentValue(parent, key, value);
+            }
+        });
+    }
+}
+function _mergeEnvironmentValue(env, key, value) {
+    if (isString(value)) {
+        env[key] = value;
+    } else {
+        delete env[key];
+    }
+}
+function addTerminalEnvironmentKeys(env, version, locale, detectLocale) {
+    env["TERM_PROGRAM"] = "vscode";
+    if (version) {
+        env["TERM_PROGRAM_VERSION"] = version;
+    }
+    if (shouldSetLangEnvVariable(env, detectLocale)) {
+        env["LANG"] = getLangEnvVariable(locale);
+    }
+    env["COLORTERM"] = "truecolor";
+}
+function mergeNonNullKeys(env, other) {
+    if (!other) {
+        return;
+    }
+    for (const key of ( Object.keys(other))) {
+        const value = other[key];
+        if (value !== undefined && value !== null) {
+            env[key] = value;
+        }
+    }
+}
+async function resolveConfigurationVariables(variableResolver, env) {
+    await Promise.all(( Object.entries(env).map(async ([key, value]) => {
+        if (isString(value)) {
+            try {
+                env[key] = await variableResolver(value);
+            } catch (e) {
+                env[key] = value;
+            }
+        }
+    })));
+    return env;
+}
+function shouldSetLangEnvVariable(env, detectLocale) {
+    if (detectLocale === "on") {
+        return true;
+    }
+    if (detectLocale === "auto") {
+        const lang = env["LANG"];
+        return !lang || (lang.search(/\.UTF\-8$/) === -1 && lang.search(/\.utf8$/) === -1 && lang.search(/\.euc.+/) === -1);
+    }
+    return false;
+}
+function getLangEnvVariable(locale) {
+    const parts = locale ? locale.split("-") : [];
+    const n = parts.length;
+    if (n === 0) {
+        return "en_US.UTF-8";
+    }
+    if (n === 1) {
+        const languageVariants = {
+            af: "ZA",
+            am: "ET",
+            be: "BY",
+            bg: "BG",
+            ca: "ES",
+            cs: "CZ",
+            da: "DK",
+            de: "DE",
+            el: "GR",
+            en: "US",
+            es: "ES",
+            et: "EE",
+            eu: "ES",
+            fi: "FI",
+            fr: "FR",
+            he: "IL",
+            hr: "HR",
+            hu: "HU",
+            hy: "AM",
+            is: "IS",
+            it: "IT",
+            ja: "JP",
+            kk: "KZ",
+            ko: "KR",
+            lt: "LT",
+            nl: "NL",
+            no: "NO",
+            pl: "PL",
+            pt: "BR",
+            ro: "RO",
+            ru: "RU",
+            sk: "SK",
+            sl: "SI",
+            sr: "YU",
+            sv: "SE",
+            tr: "TR",
+            uk: "UA",
+            zh: "CN"
+        };
+        if (Object.prototype.hasOwnProperty.call(languageVariants, parts[0])) {
+            parts.push(languageVariants[parts[0]]);
+        }
+    } else {
+        parts[1] = parts[1].toUpperCase();
+    }
+    return parts.join("_") + ".UTF-8";
+}
+async function getCwd(shell, userHome, variableResolver, root, customCwd, logService) {
+    if (shell.cwd) {
+        const unresolved = (typeof shell.cwd === "object") ? shell.cwd.fsPath : shell.cwd;
+        const resolved = await _resolveCwd(unresolved, variableResolver);
+        return sanitizeCwd(resolved || unresolved);
+    }
+    let cwd;
+    if (!shell.ignoreConfigurationCwd && customCwd) {
+        if (variableResolver) {
+            customCwd = await _resolveCwd(customCwd, variableResolver, logService);
+        }
+        if (customCwd) {
+            if (isAbsolute(customCwd)) {
+                cwd = customCwd;
+            } else if (root) {
+                cwd = join(root.fsPath, customCwd);
+            }
+        }
+    }
+    if (!cwd) {
+        cwd = root ? root.fsPath : userHome || "";
+    }
+    return sanitizeCwd(cwd);
+}
+async function _resolveCwd(cwd, variableResolver, logService) {
+    if (variableResolver) {
+        try {
+            return await variableResolver(cwd);
+        } catch (e) {
+            logService?.error("Could not resolve terminal cwd", e);
+            return undefined;
+        }
+    }
+    return cwd;
+}
+function createVariableResolver(lastActiveWorkspace, env, configurationResolverService) {
+    if (!configurationResolverService) {
+        return undefined;
+    }
+    return str => configurationResolverService.resolveWithEnvironment(env, lastActiveWorkspace, str);
+}
+async function createTerminalEnvironment(
+    shellLaunchConfig,
+    envFromConfig,
+    variableResolver,
+    version,
+    detectLocale,
+    baseEnv
+) {
+    const env = {};
+    if (shellLaunchConfig.strictEnv) {
+        mergeNonNullKeys(env, shellLaunchConfig.env);
+    } else {
+        mergeNonNullKeys(env, baseEnv);
+        const allowedEnvFromConfig = {
+            ...envFromConfig
+        };
+        if (variableResolver) {
+            if (allowedEnvFromConfig) {
+                await resolveConfigurationVariables(variableResolver, allowedEnvFromConfig);
+            }
+            if (shellLaunchConfig.env) {
+                await resolveConfigurationVariables(variableResolver, shellLaunchConfig.env);
+            }
+        }
+        if (isMacintosh) {
+            if (env["VSCODE_NODE_OPTIONS"]) {
+                env["NODE_OPTIONS"] = env["VSCODE_NODE_OPTIONS"];
+                delete env["VSCODE_NODE_OPTIONS"];
+            }
+            if (env["VSCODE_NODE_REPL_EXTERNAL_MODULE"]) {
+                env["NODE_REPL_EXTERNAL_MODULE"] = env["VSCODE_NODE_REPL_EXTERNAL_MODULE"];
+                delete env["VSCODE_NODE_REPL_EXTERNAL_MODULE"];
+            }
+        }
+        sanitizeProcessEnvironment(env, "VSCODE_IPC_HOOK_CLI");
+        mergeEnvironments(env, allowedEnvFromConfig);
+        mergeEnvironments(env, shellLaunchConfig.env);
+        addTerminalEnvironmentKeys(env, version, language, detectLocale);
+    }
+    return env;
+}
+async function preparePathForShell(
+    resource,
+    executable,
+    title,
+    shellType,
+    backend,
+    os,
+    isWindowsFrontend = isWindows
+) {
+    let originalPath;
+    if (isString(resource)) {
+        originalPath = resource;
+    } else {
+        originalPath = resource.fsPath;
+        if (isWindowsFrontend && os !== OperatingSystem.Windows) {
+            originalPath = originalPath.replace(/\\/g, "/");
+        } else if (!isWindowsFrontend && os === OperatingSystem.Windows) {
+            originalPath = originalPath.replace(/\//g, "\\");
+        }
+    }
+    if (!executable) {
+        return originalPath;
+    }
+    const hasSpace = originalPath.includes(" ");
+    const hasParens = originalPath.includes("(") || originalPath.includes(")");
+    const pathBasename = basename(executable, ".exe");
+    const isPowerShell = pathBasename === "pwsh" || title === "pwsh" || pathBasename === "powershell" || title === "powershell";
+    if (isPowerShell && (hasSpace || originalPath.includes("'"))) {
+        return `& '${originalPath.replace(/'/g, "''")}'`;
+    }
+    if (hasParens && isPowerShell) {
+        return `& '${originalPath}'`;
+    }
+    if (os === OperatingSystem.Windows) {
+        if (shellType !== undefined) {
+            if (shellType === WindowsShellType.GitBash) {
+                return escapeNonWindowsPath(originalPath.replace(/\\/g, "/"), shellType);
+            } else if (shellType === WindowsShellType.Wsl) {
+                return backend?.getWslPath(originalPath, "win-to-unix") || originalPath;
+            } else if (hasSpace) {
+                return `"${originalPath}"`;
+            }
+            return originalPath;
+        }
+        const lowerExecutable = executable.toLowerCase();
+        if (lowerExecutable.includes("wsl") || (lowerExecutable.includes("bash.exe") && !lowerExecutable.toLowerCase().includes("git"))) {
+            return backend?.getWslPath(originalPath, "win-to-unix") || originalPath;
+        } else if (hasSpace) {
+            return `"${originalPath}"`;
+        }
+        return originalPath;
+    }
+    return escapeNonWindowsPath(originalPath, shellType);
+}
+function getWorkspaceForTerminal(cwd, workspaceContextService, historyService) {
+    const cwdUri = isString(cwd) ? ( URI.parse(cwd)) : cwd;
+    let workspaceFolder = cwdUri ? workspaceContextService.getWorkspaceFolder(cwdUri) ?? undefined : undefined;
+    if (!workspaceFolder) {
+        const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot();
+        workspaceFolder = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
+    }
+    return workspaceFolder;
+}
+async function getUriLabelForShell(uri, backend, shellType, os, isWindowsFrontend = isWindows) {
+    let path = isString(uri) ? uri : uri.fsPath;
+    if (os === OperatingSystem.Windows) {
+        if (shellType === WindowsShellType.Wsl) {
+            return backend.getWslPath(path.replaceAll("/", "\\"), "win-to-unix");
+        } else if (shellType === WindowsShellType.GitBash) {
+            return path.replaceAll("\\", "/").replace(/^([a-zA-Z]):\//, "/$1/");
+        } else {
+            path = isString(uri) ? path : uriToFsPath(uri, true);
+            return !isWindowsFrontend ? path.replaceAll("/", "\\") : path;
+        }
+    } else {
+        return isWindowsFrontend ? path.replaceAll("\\", "/") : path;
+    }
+}
+function getShellIntegrationTimeout(configurationService, siInjectionEnabled, isRemote, processReadyTimestamp) {
+    const timeoutValue = configurationService.getValue(TerminalSettingId.ShellIntegrationTimeout);
+    let timeoutMs;
+    if (isNumber(timeoutValue) && timeoutValue === ShellIntegrationTimeoutOverride.DisableForTests) {
+        timeoutMs = 0;
+    } else if (!isNumber(timeoutValue) || timeoutValue < 0) {
+        timeoutMs = siInjectionEnabled ? 5000 : (isRemote ? 3000 : 2000);
+    } else if (timeoutValue === 0) {
+        timeoutMs = 0;
+    } else {
+        timeoutMs = Math.max(timeoutValue, 500);
+    }
+    if (processReadyTimestamp !== undefined) {
+        const elapsed = Date.now() - processReadyTimestamp;
+        timeoutMs = Math.max(0, timeoutMs - elapsed);
+    }
+    return timeoutMs;
+}
+
+export { addTerminalEnvironmentKeys, createTerminalEnvironment, createVariableResolver, getCwd, getLangEnvVariable, getShellIntegrationTimeout, getUriLabelForShell, getWorkspaceForTerminal, mergeEnvironments, preparePathForShell, shouldSetLangEnvVariable };

package/vscode/src/vs/workbench/contrib/terminal/common/terminalStrings.js

@@ -2,35 +2,35 @@
 import { localize2, localize } from '../../../../nls.js';
 
 const terminalStrings = {
-    terminal: ( localize(13755, "Terminal")),
-    new: ( localize(13756, "New Terminal")),
-    currentSessionCategory: ( localize(13757, "current session")),
-    previousSessionCategory: ( localize(13758, "previous session")),
-    typeTask: ( localize(13759, "Task")),
-    typeLocal: ( localize(13760, "Local")),
-    actionCategory: ( localize2(13761, "Terminal")),
-    focus: ( localize2(13762, "Focus Terminal")),
+    terminal: ( localize(13896, "Terminal")),
+    new: ( localize(13897, "New Terminal")),
+    currentSessionCategory: ( localize(13898, "current session")),
+    previousSessionCategory: ( localize(13899, "previous session")),
+    typeTask: ( localize(13900, "Task")),
+    typeLocal: ( localize(13901, "Local")),
+    actionCategory: ( localize2(13902, "Terminal")),
+    focus: ( localize2(13903, "Focus Terminal")),
     kill: {
-        ...( localize2(13763, "Kill Terminal")),
-        short: ( localize(13764, "Kill"))
+        ...( localize2(13904, "Kill Terminal")),
+        short: ( localize(13905, "Kill"))
     },
-    moveToEditor: ( localize2(13765, "Move Terminal into Editor Area")),
-    moveIntoNewWindow: ( localize2(13766, "Move Terminal into New Window")),
-    newInNewWindow: ( localize2(13767, "New Terminal Window")),
-    moveToTerminalPanel: ( localize2(13768, "Move Terminal into Panel")),
-    changeIcon: ( localize2(13769, "Change Icon...")),
-    changeColor: ( localize2(13770, "Change Color...")),
+    moveToEditor: ( localize2(13906, "Move Terminal into Editor Area")),
+    moveIntoNewWindow: ( localize2(13907, "Move Terminal into New Window")),
+    newInNewWindow: ( localize2(13908, "New Terminal Window")),
+    moveToTerminalPanel: ( localize2(13909, "Move Terminal into Panel")),
+    changeIcon: ( localize2(13910, "Change Icon...")),
+    changeColor: ( localize2(13911, "Change Color...")),
     split: {
-        ...( localize2(13771, "Split Terminal")),
-        short: ( localize(13772, "Split"))
+        ...( localize2(13912, "Split Terminal")),
+        short: ( localize(13913, "Split"))
     },
-    unsplit: ( localize2(13773, "Unsplit Terminal")),
-    rename: ( localize2(13774, "Rename...")),
-    toggleSizeToContentWidth: ( localize2(13775, "Toggle Size to Content Width")),
-    focusHover: ( localize2(13776, "Focus Hover")),
-    newWithCwd: ( localize2(13777, "Create New Terminal Starting in a Custom Working Directory")),
-    renameWithArgs: ( localize2(13778, "Rename the Currently Active Terminal")),
-    scrollToPreviousCommand: ( localize2(13779, "Scroll to Previous Command")),
-    scrollToNextCommand: ( localize2(13780, "Scroll to Next Command"))};
+    unsplit: ( localize2(13914, "Unsplit Terminal")),
+    rename: ( localize2(13915, "Rename...")),
+    toggleSizeToContentWidth: ( localize2(13916, "Toggle Size to Content Width")),
+    focusHover: ( localize2(13917, "Focus Hover")),
+    newWithCwd: ( localize2(13918, "Create New Terminal Starting in a Custom Working Directory")),
+    renameWithArgs: ( localize2(13919, "Rename the Currently Active Terminal")),
+    scrollToPreviousCommand: ( localize2(13920, "Scroll to Previous Command")),
+    scrollToNextCommand: ( localize2(13921, "Scroll to Next Command"))};
 
 export { terminalStrings };