@codingame/monaco-vscode-api 32.0.2 → 33.0.4

package/vscode/src/vs/workbench/contrib/debug/common/debug.js

@@ -14,19 +14,19 @@ const DEBUG_PANEL_ID = "workbench.panel.repl";
 const REPL_VIEW_ID = "workbench.panel.repl.view";
 const CONTEXT_DEBUG_TYPE = ( new RawContextKey("debugType", undefined, {
     type: "string",
-    description: ( localize(9130, "Debug type of the active debug session. For example 'python'."))
+    description: ( localize(9212, "Debug type of the active debug session. For example 'python'."))
 }));
 const CONTEXT_DEBUG_CONFIGURATION_TYPE = ( new RawContextKey("debugConfigurationType", undefined, {
     type: "string",
     description: ( localize(
-        9131,
+        9213,
         "Debug type of the selected launch configuration. For example 'python'."
     ))
 }));
 const CONTEXT_DEBUG_STATE = ( new RawContextKey("debugState", "inactive", {
     type: "string",
     description: ( localize(
-        9132,
+        9214,
         "State that the focused debug session is in. One of the following: 'inactive', 'initializing', 'stopped' or 'running'."
     ))
 }));
@@ -34,326 +34,326 @@ const CONTEXT_DEBUG_UX_KEY = "debugUx";
 const CONTEXT_DEBUG_UX = ( new RawContextKey(CONTEXT_DEBUG_UX_KEY, "default", {
     type: "string",
     description: ( localize(
-        9133,
+        9215,
         "Debug UX state. When there are no debug configurations it is 'simple', otherwise 'default'. Used to decide when to show welcome views in the debug viewlet."
     ))
 }));
 const CONTEXT_HAS_DEBUGGED = ( new RawContextKey("hasDebugged", false, {
     type: "boolean",
     description: ( localize(
-        9134,
+        9216,
         "True when a debug session has been started at least once, false otherwise."
     ))
 }));
 const CONTEXT_IN_DEBUG_MODE = ( new RawContextKey("inDebugMode", false, {
     type: "boolean",
-    description: ( localize(9135, "True when debugging, false otherwise."))
+    description: ( localize(9217, "True when debugging, false otherwise."))
 }));
 const CONTEXT_IN_DEBUG_REPL = ( new RawContextKey("inDebugRepl", false, {
     type: "boolean",
-    description: ( localize(9136, "True when focus is in the debug console, false otherwise."))
+    description: ( localize(9218, "True when focus is in the debug console, false otherwise."))
 }));
 const CONTEXT_BREAKPOINT_WIDGET_VISIBLE = ( new RawContextKey("breakpointWidgetVisible", false, {
     type: "boolean",
     description: ( localize(
-        9137,
+        9219,
         "True when breakpoint editor zone widget is visible, false otherwise."
     ))
 }));
 const CONTEXT_IN_BREAKPOINT_WIDGET = ( new RawContextKey("inBreakpointWidget", false, {
     type: "boolean",
     description: ( localize(
-        9138,
+        9220,
         "True when focus is in the breakpoint editor zone widget, false otherwise."
     ))
 }));
 const CONTEXT_BREAKPOINTS_FOCUSED = ( new RawContextKey("breakpointsFocused", true, {
     type: "boolean",
-    description: ( localize(9139, "True when the BREAKPOINTS view is focused, false otherwise."))
+    description: ( localize(9221, "True when the BREAKPOINTS view is focused, false otherwise."))
 }));
 const CONTEXT_WATCH_EXPRESSIONS_FOCUSED = ( new RawContextKey("watchExpressionsFocused", true, {
     type: "boolean",
-    description: ( localize(9140, "True when the WATCH view is focused, false otherwise."))
+    description: ( localize(9222, "True when the WATCH view is focused, false otherwise."))
 }));
 const CONTEXT_WATCH_EXPRESSIONS_EXIST = ( new RawContextKey("watchExpressionsExist", false, {
     type: "boolean",
-    description: ( localize(9141, "True when at least one watch expression exists, false otherwise."))
+    description: ( localize(9223, "True when at least one watch expression exists, false otherwise."))
 }));
 const CONTEXT_VARIABLES_FOCUSED = ( new RawContextKey("variablesFocused", true, {
     type: "boolean",
-    description: ( localize(9142, "True when the VARIABLES views is focused, false otherwise"))
+    description: ( localize(9224, "True when the VARIABLES views is focused, false otherwise"))
 }));
 const CONTEXT_EXPRESSION_SELECTED = ( new RawContextKey("expressionSelected", false, {
     type: "boolean",
     description: ( localize(
-        9143,
+        9225,
         "True when an expression input box is open in either the WATCH or the VARIABLES view, false otherwise."
     ))
 }));
 const CONTEXT_BREAKPOINT_INPUT_FOCUSED = ( new RawContextKey("breakpointInputFocused", false, {
     type: "boolean",
-    description: ( localize(9144, "True when the input box has focus in the BREAKPOINTS view."))
+    description: ( localize(9226, "True when the input box has focus in the BREAKPOINTS view."))
 }));
 const CONTEXT_CALLSTACK_ITEM_TYPE = ( new RawContextKey("callStackItemType", undefined, {
     type: "string",
     description: ( localize(
-        9145,
+        9227,
         "Represents the item type of the focused element in the CALL STACK view. For example: 'session', 'thread', 'stackFrame'"
     ))
 }));
 const CONTEXT_CALLSTACK_SESSION_IS_ATTACH = ( new RawContextKey("callStackSessionIsAttach", false, {
     type: "boolean",
     description: ( localize(
-        9146,
+        9228,
         "True when the session in the CALL STACK view is attach, false otherwise. Used internally for inline menus in the CALL STACK view."
     ))
 }));
 const CONTEXT_CALLSTACK_ITEM_STOPPED = ( new RawContextKey("callStackItemStopped", false, {
     type: "boolean",
     description: ( localize(
-        9147,
+        9229,
         "True when the focused item in the CALL STACK is stopped. Used internally for inline menus in the CALL STACK view."
     ))
 }));
 const CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD = ( new RawContextKey("callStackSessionHasOneThread", false, {
     type: "boolean",
     description: ( localize(
-        9148,
+        9230,
         "True when the focused session in the CALL STACK view has exactly one thread. Used internally for inline menus in the CALL STACK view."
     ))
 }));
 const CONTEXT_CALLSTACK_FOCUSED = ( new RawContextKey("callStackFocused", true, {
     type: "boolean",
-    description: ( localize(9149, "True when the CALLSTACK view is focused, false otherwise."))
+    description: ( localize(9231, "True when the CALLSTACK view is focused, false otherwise."))
 }));
 const CONTEXT_WATCH_ITEM_TYPE = ( new RawContextKey("watchItemType", undefined, {
     type: "string",
     description: ( localize(
-        9150,
+        9232,
         "Represents the item type of the focused element in the WATCH view. For example: 'expression', 'variable'"
     ))
 }));
 const CONTEXT_CAN_VIEW_MEMORY = ( new RawContextKey("canViewMemory", undefined, {
     type: "boolean",
     description: ( localize(
-        9151,
+        9233,
         "Indicates whether the item in the view has an associated memory reference."
     ))
 }));
 const CONTEXT_BREAKPOINT_ITEM_TYPE = ( new RawContextKey("breakpointItemType", undefined, {
     type: "string",
     description: ( localize(
-        9152,
+        9234,
         "Represents the item type of the focused element in the BREAKPOINTS view. For example: 'breakpoint', 'exceptionBreakpoint', 'functionBreakpoint', 'dataBreakpoint'"
     ))
 }));
 const CONTEXT_BREAKPOINT_ITEM_IS_DATA_BYTES = ( new RawContextKey("breakpointItemBytes", undefined, {
     type: "boolean",
-    description: ( localize(9153, "Whether the breakpoint item is a data breakpoint on a byte range."))
+    description: ( localize(9235, "Whether the breakpoint item is a data breakpoint on a byte range."))
 }));
 const CONTEXT_BREAKPOINT_HAS_MODES = ( new RawContextKey("breakpointHasModes", false, {
     type: "boolean",
-    description: ( localize(9154, "Whether the breakpoint has multiple modes it can switch to."))
+    description: ( localize(9236, "Whether the breakpoint has multiple modes it can switch to."))
 }));
 const CONTEXT_BREAKPOINT_SUPPORTS_CONDITION = ( new RawContextKey("breakpointSupportsCondition", false, {
     type: "boolean",
-    description: ( localize(9155, "True when the focused breakpoint supports conditions."))
+    description: ( localize(9237, "True when the focused breakpoint supports conditions."))
 }));
 const CONTEXT_LOADED_SCRIPTS_SUPPORTED = ( new RawContextKey("loadedScriptsSupported", false, {
     type: "boolean",
-    description: ( localize(9156, "True when the focused sessions supports the LOADED SCRIPTS view"))
+    description: ( localize(9238, "True when the focused sessions supports the LOADED SCRIPTS view"))
 }));
 const CONTEXT_LOADED_SCRIPTS_ITEM_TYPE = ( new RawContextKey("loadedScriptsItemType", undefined, {
     type: "string",
     description: ( localize(
-        9157,
+        9239,
         "Represents the item type of the focused element in the LOADED SCRIPTS view."
     ))
 }));
 const CONTEXT_FOCUSED_SESSION_IS_ATTACH = ( new RawContextKey("focusedSessionIsAttach", false, {
     type: "boolean",
-    description: ( localize(9158, "True when the focused session is 'attach'."))
+    description: ( localize(9240, "True when the focused session is 'attach'."))
 }));
 const CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG = ( new RawContextKey("focusedSessionIsNoDebug", false, {
     type: "boolean",
-    description: ( localize(9159, "True when the focused session is run without debugging."))
+    description: ( localize(9241, "True when the focused session is run without debugging."))
 }));
 const CONTEXT_STEP_BACK_SUPPORTED = ( new RawContextKey("stepBackSupported", false, {
     type: "boolean",
-    description: ( localize(9160, "True when the focused session supports 'stepBack' requests."))
+    description: ( localize(9242, "True when the focused session supports 'stepBack' requests."))
 }));
 const CONTEXT_RESTART_FRAME_SUPPORTED = ( new RawContextKey("restartFrameSupported", false, {
     type: "boolean",
-    description: ( localize(9161, "True when the focused session supports 'restartFrame' requests."))
+    description: ( localize(9243, "True when the focused session supports 'restartFrame' requests."))
 }));
 const CONTEXT_STACK_FRAME_SUPPORTS_RESTART = ( new RawContextKey("stackFrameSupportsRestart", false, {
     type: "boolean",
-    description: ( localize(9162, "True when the focused stack frame supports 'restartFrame'."))
+    description: ( localize(9244, "True when the focused stack frame supports 'restartFrame'."))
 }));
 const CONTEXT_JUMP_TO_CURSOR_SUPPORTED = ( new RawContextKey("jumpToCursorSupported", false, {
     type: "boolean",
-    description: ( localize(9163, "True when the focused session supports 'jumpToCursor' request."))
+    description: ( localize(9245, "True when the focused session supports 'jumpToCursor' request."))
 }));
 const CONTEXT_STEP_INTO_TARGETS_SUPPORTED = ( new RawContextKey("stepIntoTargetsSupported", false, {
     type: "boolean",
-    description: ( localize(9164, "True when the focused session supports 'stepIntoTargets' request."))
+    description: ( localize(9246, "True when the focused session supports 'stepIntoTargets' request."))
 }));
 const CONTEXT_BREAKPOINTS_EXIST = ( new RawContextKey("breakpointsExist", false, {
     type: "boolean",
-    description: ( localize(9165, "True when at least one breakpoint exists."))
+    description: ( localize(9247, "True when at least one breakpoint exists."))
 }));
 const CONTEXT_DEBUGGERS_AVAILABLE = ( new RawContextKey("debuggersAvailable", false, {
     type: "boolean",
-    description: ( localize(9166, "True when there is at least one debug extensions active."))
+    description: ( localize(9248, "True when there is at least one debug extensions active."))
 }));
 const CONTEXT_DEBUG_EXTENSION_AVAILABLE = ( new RawContextKey("debugExtensionAvailable", true, {
     type: "boolean",
     description: ( localize(
-        9167,
+        9249,
         "True when there is at least one debug extension installed and enabled."
     ))
 }));
 const CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT = ( new RawContextKey("debugProtocolVariableMenuContext", undefined, {
     type: "string",
     description: ( localize(
-        9168,
+        9250,
         "Represents the context the debug adapter sets on the focused variable in the VARIABLES view."
     ))
 }));
 const CONTEXT_SET_VARIABLE_SUPPORTED = ( new RawContextKey("debugSetVariableSupported", false, {
     type: "boolean",
-    description: ( localize(9169, "True when the focused session supports 'setVariable' request."))
+    description: ( localize(9251, "True when the focused session supports 'setVariable' request."))
 }));
 const CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED = ( new RawContextKey("debugSetDataBreakpointAddressSupported", false, {
     type: "boolean",
     description: ( localize(
-        9170,
+        9252,
         "True when the focused session supports 'getBreakpointInfo' request on an address."
     ))
 }));
 const CONTEXT_SET_EXPRESSION_SUPPORTED = ( new RawContextKey("debugSetExpressionSupported", false, {
     type: "boolean",
-    description: ( localize(9171, "True when the focused session supports 'setExpression' request."))
+    description: ( localize(9253, "True when the focused session supports 'setExpression' request."))
 }));
 const CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED = ( new RawContextKey("breakWhenValueChangesSupported", false, {
     type: "boolean",
     description: ( localize(
-        9172,
+        9254,
         "True when the focused session supports to break when value changes."
     ))
 }));
 const CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED = ( new RawContextKey("breakWhenValueIsAccessedSupported", false, {
     type: "boolean",
     description: ( localize(
-        9173,
+        9255,
         "True when the focused breakpoint supports to break when value is accessed."
     ))
 }));
 const CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED = ( new RawContextKey("breakWhenValueIsReadSupported", false, {
     type: "boolean",
     description: ( localize(
-        9174,
+        9256,
         "True when the focused breakpoint supports to break when value is read."
     ))
 }));
 const CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED = ( new RawContextKey("terminateDebuggeeSupported", false, {
     type: "boolean",
     description: ( localize(
-        9175,
+        9257,
         "True when the focused session supports the terminate debuggee capability."
     ))
 }));
 const CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED = ( new RawContextKey("suspendDebuggeeSupported", false, {
     type: "boolean",
     description: ( localize(
-        9176,
+        9258,
         "True when the focused session supports the suspend debuggee capability."
     ))
 }));
 const CONTEXT_TERMINATE_THREADS_SUPPORTED = ( new RawContextKey("terminateThreadsSupported", false, {
     type: "boolean",
     description: ( localize(
-        9177,
+        9259,
         "True when the focused session supports the terminate threads capability."
     ))
 }));
 const CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT = ( new RawContextKey("variableEvaluateNamePresent", false, {
     type: "boolean",
-    description: ( localize(9178, "True when the focused variable has an 'evaluateName' field set."))
+    description: ( localize(9260, "True when the focused variable has an 'evaluateName' field set."))
 }));
 const CONTEXT_VARIABLE_IS_READONLY = ( new RawContextKey("variableIsReadonly", false, {
     type: "boolean",
-    description: ( localize(9179, "True when the focused variable is read-only."))
+    description: ( localize(9261, "True when the focused variable is read-only."))
 }));
 const CONTEXT_VARIABLE_VALUE = ( new RawContextKey("variableValue", false, {
     type: "string",
-    description: ( localize(9180, "Value of the variable, present for debug visualization clauses."))
+    description: ( localize(9262, "Value of the variable, present for debug visualization clauses."))
 }));
 const CONTEXT_VARIABLE_TYPE = ( new RawContextKey("variableType", false, {
     type: "string",
-    description: ( localize(9181, "Type of the variable, present for debug visualization clauses."))
+    description: ( localize(9263, "Type of the variable, present for debug visualization clauses."))
 }));
 const CONTEXT_VARIABLE_INTERFACES = ( new RawContextKey("variableInterfaces", false, {
     type: "array",
     description: ( localize(
-        9182,
+        9264,
         "Any interfaces or contracts that the variable satisfies, present for debug visualization clauses."
     ))
 }));
 const CONTEXT_VARIABLE_NAME = ( new RawContextKey("variableName", false, {
     type: "string",
-    description: ( localize(9183, "Name of the variable, present for debug visualization clauses."))
+    description: ( localize(9265, "Name of the variable, present for debug visualization clauses."))
 }));
 const CONTEXT_VARIABLE_LANGUAGE = ( new RawContextKey("variableLanguage", false, {
     type: "string",
     description: ( localize(
-        9184,
+        9266,
         "Language of the variable source, present for debug visualization clauses."
     ))
 }));
 const CONTEXT_VARIABLE_EXTENSIONID = ( new RawContextKey("variableExtensionId", false, {
     type: "string",
     description: ( localize(
-        9185,
+        9267,
         "Extension ID of the variable source, present for debug visualization clauses."
     ))
 }));
 const CONTEXT_EXCEPTION_WIDGET_VISIBLE = ( new RawContextKey("exceptionWidgetVisible", false, {
     type: "boolean",
-    description: ( localize(9186, "True when the exception widget is visible."))
+    description: ( localize(9268, "True when the exception widget is visible."))
 }));
 const CONTEXT_MULTI_SESSION_REPL = ( new RawContextKey("multiSessionRepl", false, {
     type: "boolean",
-    description: ( localize(9187, "True when there is more than 1 debug console."))
+    description: ( localize(9269, "True when there is more than 1 debug console."))
 }));
 const CONTEXT_MULTI_SESSION_DEBUG = ( new RawContextKey("multiSessionDebug", false, {
     type: "boolean",
-    description: ( localize(9188, "True when there is more than 1 active debug session."))
+    description: ( localize(9270, "True when there is more than 1 active debug session."))
 }));
 const CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED = ( new RawContextKey("disassembleRequestSupported", false, {
     type: "boolean",
-    description: ( localize(9189, "True when the focused sessions supports disassemble request."))
+    description: ( localize(9271, "True when the focused sessions supports disassemble request."))
 }));
 const CONTEXT_DISASSEMBLY_VIEW_FOCUS = ( new RawContextKey("disassemblyViewFocus", false, {
     type: "boolean",
-    description: ( localize(9190, "True when the Disassembly View is focused."))
+    description: ( localize(9272, "True when the Disassembly View is focused."))
 }));
 const CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST = ( new RawContextKey("languageSupportsDisassembleRequest", false, {
     type: "boolean",
     description: ( localize(
-        9191,
+        9273,
         "True when the language in the current editor supports disassemble request."
     ))
 }));
 const CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE = ( new RawContextKey("focusedStackFrameHasInstructionReference", false, {
     type: "boolean",
     description: ( localize(
-        9192,
+        9274,
         "True when the focused stack frame has instruction pointer reference."
     ))
 }));
 const debuggerDisabledMessage = debugType => ( localize(
-    9193,
+    9275,
     "Configured debug type '{0}' is installed but not supported in this environment.",
     debugType
 ));
@@ -363,7 +363,7 @@ const DEBUG_SCHEME = "debug";
 const INTERNAL_CONSOLE_OPTIONS_SCHEMA = {
     enum: ["neverOpen", "openOnSessionStart", "openOnFirstSessionStart"],
     default: "openOnFirstSessionStart",
-    description: ( localize(9194, "Controls when the internal Debug Console should open."))
+    description: ( localize(9276, "Controls when the internal Debug Console should open."))
 };
 var State;
 (function(State) {

package/vscode/src/vs/workbench/contrib/debug/common/debugModel.js

@@ -181,7 +181,7 @@ class ExpressionContainer {
                     0,
                     "",
                     undefined,
-                    localize(9201, "Invalid variable attributes"),
+                    localize(9283, "Invalid variable attributes"),
                     0,
                     0,
                     undefined,
@@ -231,7 +231,7 @@ class ExpressionContainer {
     }
     async evaluateExpression(expression, session, stackFrame, context, keepLazyVars = false, location) {
         if (!session || (!stackFrame && context !== "repl")) {
-            this.value = context === "repl" ? ( localize(9202, "Please start a debug session to evaluate expressions")) : Expression.DEFAULT_VALUE;
+            this.value = context === "repl" ? ( localize(9284, "Please start a debug session to evaluate expressions")) : Expression.DEFAULT_VALUE;
             this.reference = 0;
             return false;
         }
@@ -314,7 +314,7 @@ class VisualizedExpression {
 }
 class Expression extends ExpressionContainer {
     static {
-        this.DEFAULT_VALUE = ( localize(9203, "not available"));
+        this.DEFAULT_VALUE = ( localize(9285, "not available"));
     }
     constructor(name, id = generateUuid()) {
         super(undefined, undefined, 0, id);
@@ -631,9 +631,9 @@ class Thread {
     }
     get stateLabel() {
         if (this.stoppedDetails) {
-            return this.stoppedDetails.description || (this.stoppedDetails.reason ? ( localize(9204, "Paused on {0}", this.stoppedDetails.reason)) : ( localize(9205, "Paused")));
+            return this.stoppedDetails.description || (this.stoppedDetails.reason ? ( localize(9286, "Paused on {0}", this.stoppedDetails.reason)) : ( localize(9287, "Paused")));
         }
-        return localize(9206, "Running");
+        return localize(9288, "Running");
     }
     async fetchCallStack(levels = 20) {
         if (this.stopped) {
@@ -948,7 +948,7 @@ class Breakpoint extends BaseBreakpoint {
     get message() {
         if (this.textFileService.isDirty(this.uri)) {
             return localize(
-                9207,
+                9289,
                 "Unverified breakpoint. File is modified, please restart debug session."
             );
         }

package/vscode/src/vs/workbench/contrib/debug/common/debugSource.js

@@ -9,7 +9,7 @@ import { Schemas } from '../../../../base/common/network.js';
 import { isUriString } from './debugUtils.js';
 import { TextEditorSelectionRevealType } from '../../../../platform/editor/common/editor.js';
 
-const UNKNOWN_SOURCE_LABEL = ( localize(9251, "Unknown Source"));
+const UNKNOWN_SOURCE_LABEL = ( localize(9333, "Unknown Source"));
 class Source {
     constructor(raw_, sessionId, uriIdentityService, logService) {
         let path;

package/vscode/src/vs/workbench/contrib/debug/common/disassemblyViewInput.js

@@ -4,7 +4,7 @@ import { localize } from '../../../../nls.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 
-const DisassemblyEditorIcon = registerIcon("disassembly-editor-label-icon", Codicon.debug, ( localize(9263, "Icon of the disassembly editor label.")));
+const DisassemblyEditorIcon = registerIcon("disassembly-editor-label-icon", Codicon.debug, ( localize(9345, "Icon of the disassembly editor label.")));
 class DisassemblyViewInput extends EditorInput {
     constructor() {
         super(...arguments);
@@ -23,7 +23,7 @@ class DisassemblyViewInput extends EditorInput {
         return DisassemblyViewInput._instance;
     }
     getName() {
-        return localize(9264, "Disassembly");
+        return localize(9346, "Disassembly");
     }
     getIcon() {
         return DisassemblyEditorIcon;

package/vscode/src/vs/workbench/contrib/debug/common/loadedScriptsPicker.js

@@ -25,7 +25,7 @@ async function showLoadedScriptMenu(accessor) {
     });
     localDisposableStore.add(quickPick);
     quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( localize(9265, "Search loaded scripts by name"));
+    quickPick.placeholder = ( localize(9347, "Search loaded scripts by name"));
     quickPick.items = await _getPicks(
         quickPick.value,
         sessions,

package/vscode/src/vs/workbench/contrib/debug/common/replModel.js

@@ -232,7 +232,7 @@ class ReplModel {
         if (clearAnsiIndex !== -1) {
             this.removeReplExpressions();
             this.appendToRepl(session, {
-                output: ( localize(9266, "Console was cleared")),
+                output: ( localize(9348, "Console was cleared")),
                 sev: Severity$1.Ignore
             });
             output = output.substring(clearAnsiIndex + clearAnsiSequence.length);

package/vscode/src/vs/workbench/contrib/dropOrPasteInto/browser/commands.js

@@ -14,12 +14,12 @@ let DropOrPasteIntoCommands = class DropOrPasteIntoCommands {
         this._preferencesService = _preferencesService;
         CopyPasteController.setConfigureDefaultAction(toAction({
             id: "workbench.action.configurePreferredPasteAction",
-            label: ( localize(9267, "Configure preferred paste action...")),
+            label: ( localize(9349, "Configure preferred paste action...")),
             run: () => this.configurePreferredPasteAction()
         }));
         DropIntoEditorController.setConfigureDefaultAction(toAction({
             id: "workbench.action.configurePreferredDropAction",
-            label: ( localize(9268, "Configure preferred drop action...")),
+            label: ( localize(9350, "Configure preferred drop action...")),
             run: () => this.configurePreferredDropAction()
         }));
     }

package/vscode/src/vs/workbench/contrib/dropOrPasteInto/browser/configurationSchema.js

@@ -17,12 +17,12 @@ const dropAsPreferenceSchema = {
     type: "array",
     scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
     description: ( localize(
-        9269,
+        9351,
         "Configures the preferred type of edit to use when dropping content.\n\nThis is an ordered list of edit kinds. The first available edit of a preferred kind will be used."
     )),
     default: [],
     items: {
-        description: ( localize(9270, "The kind identifier of the drop edit.")),
+        description: ( localize(9352, "The kind identifier of the drop edit.")),
         anyOf: [{
             type: "string"
         }, {
@@ -35,12 +35,12 @@ const pasteAsPreferenceSchema = {
     type: "array",
     scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
     description: ( localize(
-        9271,
+        9353,
         "Configures the preferred type of edit to use when pasting content.\n\nThis is an ordered list of edit kinds. The first available edit of a preferred kind will be used."
     )),
     default: [],
     items: {
-        description: ( localize(9272, "The kind identifier of the paste edit.")),
+        description: ( localize(9354, "The kind identifier of the paste edit.")),
         anyOf: [{
             type: "string"
         }, {

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryServiceImpl.d.ts

@@ -0,0 +1,15 @@
+import { EditSuggestionId } from "../../../../../../editor/common/textModelEditSource.js";
+import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
+import { IEditTelemetryCodeAcceptedData, IEditTelemetryCodeRejectedData, IEditTelemetryCodeSuggestedData } from "./aiEditTelemetryService.js";
+import { IAiEditTelemetryService } from "./aiEditTelemetryService.service.js";
+import { IRandomService } from "../../randomService.service.js";
+export declare class AiEditTelemetryServiceImpl implements IAiEditTelemetryService {
+    private readonly instantiationService;
+    private readonly _randomService;
+    readonly _serviceBrand: undefined;
+    private readonly _telemetryService;
+    constructor(instantiationService: IInstantiationService, _randomService: IRandomService);
+    createSuggestionId(data: Omit<IEditTelemetryCodeSuggestedData, "suggestionId">): EditSuggestionId;
+    handleCodeAccepted(data: IEditTelemetryCodeAcceptedData): void;
+    handleCodeRejected(data: IEditTelemetryCodeRejectedData): void;
+}