@codingame/monaco-vscode-api 27.0.0 → 28.0.1

package/vscode/src/vs/base/common/event.js

@@ -4,8 +4,14 @@ import { onUnexpectedError } from './errors.js';
 import { createSingleCallFunction } from './functional.js';
 import { Disposable, combinedDisposable, toDisposable, DisposableStore, DisposableMap } from './lifecycle.js';
 import { LinkedList } from './linkedList.js';
+import { env } from './process.js';
 import { StopWatch } from './stopwatch.js';
 
+const _bufferLeakWarnCountThreshold = 100;
+const _bufferLeakWarnTimeThreshold = 60_000;
+function _isBufferLeakWarningEnabled() {
+    return !!env["VSCODE_DEV"];
+}
 var Event;
 (function(Event) {
     Event.None = () => Disposable.None;
@@ -254,11 +260,42 @@ var Event;
         ];
     }
     Event.split = split;
-    function buffer(event, flushAfterTimeout = false, _buffer = [], disposable) {
+    function buffer(event, debugName, flushAfterTimeout = false, _buffer = [], disposable) {
         let buffer = _buffer.slice();
+        let bufferLeakWarningData;
+        if (_isBufferLeakWarningEnabled()) {
+            bufferLeakWarningData = {
+                stack: Stacktrace.create(),
+                timerId: setTimeout(() => {
+                    if (buffer && buffer.length > 0 && bufferLeakWarningData && !bufferLeakWarningData.warned) {
+                        bufferLeakWarningData.warned = true;
+                        console.warn(
+                            `[Event.buffer][${debugName}] potential LEAK detected: ${buffer.length} events buffered for ${_bufferLeakWarnTimeThreshold / 1000}s without being consumed. Buffered here:`
+                        );
+                        bufferLeakWarningData.stack.print();
+                    }
+                }, _bufferLeakWarnTimeThreshold),
+                warned: false
+            };
+            if (disposable) {
+                disposable.add(toDisposable(() => clearTimeout(bufferLeakWarningData.timerId)));
+            }
+        }
+        const clearLeakWarningTimer = () => {
+            if (bufferLeakWarningData) {
+                clearTimeout(bufferLeakWarningData.timerId);
+            }
+        };
         let listener = event(e => {
             if (buffer) {
                 buffer.push(e);
+                if (_isBufferLeakWarningEnabled() && bufferLeakWarningData && !bufferLeakWarningData.warned && buffer.length >= _bufferLeakWarnCountThreshold) {
+                    bufferLeakWarningData.warned = true;
+                    console.warn(
+                        `[Event.buffer][${debugName}] potential LEAK detected: ${buffer.length} events buffered without being consumed. Buffered here:`
+                    );
+                    bufferLeakWarningData.stack.print();
+                }
             } else {
                 emitter.fire(e);
             }
@@ -269,6 +306,7 @@ var Event;
         const flush = () => {
             buffer?.forEach(e => emitter.fire(e));
             buffer = null;
+            clearLeakWarningTimer();
         };
         const emitter = ( new Emitter({
             onWillAddFirstListener() {
@@ -293,6 +331,7 @@ var Event;
                     listener.dispose();
                 }
                 listener = null;
+                clearLeakWarningTimer();
             }
         }));
         if (disposable) {

package/vscode/src/vs/base/common/jsonErrorMessages.js

@@ -5,23 +5,23 @@ import { ParseErrorCode } from './json.js';
 function getParseErrorMessage(errorCode) {
     switch (errorCode) {
     case ParseErrorCode.InvalidSymbol:
-        return localize(115, "Invalid symbol");
+        return localize(116, "Invalid symbol");
     case ParseErrorCode.InvalidNumberFormat:
-        return localize(116, "Invalid number format");
+        return localize(117, "Invalid number format");
     case ParseErrorCode.PropertyNameExpected:
-        return localize(117, "Property name expected");
+        return localize(118, "Property name expected");
     case ParseErrorCode.ValueExpected:
-        return localize(118, "Value expected");
+        return localize(119, "Value expected");
     case ParseErrorCode.ColonExpected:
-        return localize(119, "Colon expected");
+        return localize(120, "Colon expected");
     case ParseErrorCode.CommaExpected:
-        return localize(120, "Comma expected");
+        return localize(121, "Comma expected");
     case ParseErrorCode.CloseBraceExpected:
-        return localize(121, "Closing brace expected");
+        return localize(122, "Closing brace expected");
     case ParseErrorCode.CloseBracketExpected:
-        return localize(122, "Closing bracket expected");
+        return localize(123, "Closing bracket expected");
     case ParseErrorCode.EndOfFileExpected:
-        return localize(123, "End of file expected");
+        return localize(124, "End of file expected");
     default:
         return "";
     }

package/vscode/src/vs/base/common/keybindingLabels.js

@@ -32,35 +32,35 @@ const UILabelProvider = ( new ModifierLabelProvider({
     metaKey: "⌘",
     separator: ""
 }, {
-    ctrlKey: ( localize(124, "Ctrl")),
-    shiftKey: ( localize(125, "Shift")),
-    altKey: ( localize(126, "Alt")),
-    metaKey: ( localize(127, "Windows")),
+    ctrlKey: ( localize(125, "Ctrl")),
+    shiftKey: ( localize(126, "Shift")),
+    altKey: ( localize(127, "Alt")),
+    metaKey: ( localize(128, "Windows")),
     separator: "+"
 }, {
-    ctrlKey: ( localize(124, "Ctrl")),
-    shiftKey: ( localize(125, "Shift")),
-    altKey: ( localize(126, "Alt")),
-    metaKey: ( localize(128, "Super")),
+    ctrlKey: ( localize(125, "Ctrl")),
+    shiftKey: ( localize(126, "Shift")),
+    altKey: ( localize(127, "Alt")),
+    metaKey: ( localize(129, "Super")),
     separator: "+"
 }));
 const AriaLabelProvider = ( new ModifierLabelProvider({
-    ctrlKey: ( localize(129, "Control")),
-    shiftKey: ( localize(130, "Shift")),
-    altKey: ( localize(131, "Option")),
-    metaKey: ( localize(132, "Command")),
+    ctrlKey: ( localize(130, "Control")),
+    shiftKey: ( localize(131, "Shift")),
+    altKey: ( localize(132, "Option")),
+    metaKey: ( localize(133, "Command")),
     separator: "+"
 }, {
-    ctrlKey: ( localize(129, "Control")),
-    shiftKey: ( localize(130, "Shift")),
-    altKey: ( localize(133, "Alt")),
-    metaKey: ( localize(134, "Windows")),
+    ctrlKey: ( localize(130, "Control")),
+    shiftKey: ( localize(131, "Shift")),
+    altKey: ( localize(134, "Alt")),
+    metaKey: ( localize(135, "Windows")),
     separator: "+"
 }, {
-    ctrlKey: ( localize(129, "Control")),
-    shiftKey: ( localize(130, "Shift")),
-    altKey: ( localize(133, "Alt")),
-    metaKey: ( localize(135, "Super")),
+    ctrlKey: ( localize(130, "Control")),
+    shiftKey: ( localize(131, "Shift")),
+    altKey: ( localize(134, "Alt")),
+    metaKey: ( localize(136, "Super")),
     separator: "+"
 }));
 const ElectronAcceleratorLabelProvider = ( new ModifierLabelProvider({

package/vscode/src/vs/base/common/parsers.d.ts

@@ -0,0 +1,32 @@
+export declare enum ValidationState {
+    OK = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3,
+    Fatal = 4
+}
+export declare class ValidationStatus {
+    private _state;
+    constructor();
+    get state(): ValidationState;
+    set state(value: ValidationState);
+    isOK(): boolean;
+    isFatal(): boolean;
+}
+export interface IProblemReporter {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    status: ValidationStatus;
+}
+export declare abstract class Parser {
+    private _problemReporter;
+    constructor(problemReporter: IProblemReporter);
+    reset(): void;
+    get problemReporter(): IProblemReporter;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+}

package/vscode/src/vs/base/common/parsers.js

@@ -0,0 +1,54 @@
+
+
+var ValidationState;
+(function (ValidationState) {
+    ValidationState[ValidationState["OK"] = 0] = "OK";
+    ValidationState[ValidationState["Info"] = 1] = "Info";
+    ValidationState[ValidationState["Warning"] = 2] = "Warning";
+    ValidationState[ValidationState["Error"] = 3] = "Error";
+    ValidationState[ValidationState["Fatal"] = 4] = "Fatal";
+})(ValidationState || (ValidationState = {}));
+class ValidationStatus {
+    constructor() {
+        this._state = ValidationState.OK;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        if (value > this._state) {
+            this._state = value;
+        }
+    }
+    isOK() {
+        return this._state === ValidationState.OK;
+    }
+    isFatal() {
+        return this._state === ValidationState.Fatal;
+    }
+}
+class Parser {
+    constructor(problemReporter) {
+        this._problemReporter = problemReporter;
+    }
+    reset() {
+        this._problemReporter.status.state = ValidationState.OK;
+    }
+    get problemReporter() {
+        return this._problemReporter;
+    }
+    info(message) {
+        this._problemReporter.info(message);
+    }
+    warn(message) {
+        this._problemReporter.warn(message);
+    }
+    error(message) {
+        this._problemReporter.error(message);
+    }
+    fatal(message) {
+        this._problemReporter.fatal(message);
+    }
+}
+
+export { Parser, ValidationState, ValidationStatus };

package/vscode/src/vs/base/common/yaml.js

@@ -899,7 +899,7 @@ class YamlParser {
             }
             if (indent !== baseIndent) {
                 if (indent > baseIndent) {
-                    this.emitError(( localize(136, "Unexpected indentation (expected {0}, got {1})", baseIndent, indent)), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-indentation");
+                    this.emitError(( localize(137, "Unexpected indentation (expected {0}, got {1})", baseIndent, indent)), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-indentation");
                 } else {
                     break;
                 }
@@ -912,7 +912,7 @@ class YamlParser {
                 break;
             }
             if (!this.options.allowDuplicateKeys && ( seenKeys.has(entry.key.value))) {
-                this.emitError(( localize(137, "Duplicate key: \"{0}\"", entry.key.value)), entry.key.startOffset, entry.key.endOffset, "duplicate-key");
+                this.emitError(( localize(138, "Duplicate key: \"{0}\"", entry.key.value)), entry.key.startOffset, entry.key.endOffset, "duplicate-key");
             }
             seenKeys.add(entry.key.value);
             properties.push(entry);
@@ -934,7 +934,7 @@ class YamlParser {
         const key = this.scalarFromToken(keyToken);
         const colon = this.expect(TokenType.Colon);
         if (colon.type !== TokenType.Colon) {
-            this.emitError(( localize(138, "Expected \":\"")), colon.startOffset, colon.endOffset, "expected-colon");
+            this.emitError(( localize(139, "Expected \":\"")), colon.startOffset, colon.endOffset, "expected-colon");
             return undefined;
         }
         const value = this.parseMappingValue(baseIndent, colon);
@@ -964,7 +964,7 @@ class YamlParser {
         this.skipNewlinesAndComments();
         const afterNewline = this.currentToken();
         if (afterNewline.type === TokenType.EOF) {
-            this.emitError(( localize(139, "Missing value")), colonToken.startOffset, colonToken.endOffset, "missing-value");
+            this.emitError(( localize(140, "Missing value")), colonToken.startOffset, colonToken.endOffset, "missing-value");
             return this.makeEmptyScalar(colonToken.endOffset);
         }
         const nextIndent = this.currentIndent();
@@ -972,7 +972,7 @@ class YamlParser {
             return this.parseValue(baseIndent) ?? this.makeEmptyScalar(colonToken.endOffset);
         }
         if (nextIndent <= baseIndent) {
-            this.emitError(( localize(139, "Missing value")), colonToken.startOffset, colonToken.endOffset, "missing-value");
+            this.emitError(( localize(140, "Missing value")), colonToken.startOffset, colonToken.endOffset, "missing-value");
             return this.makeEmptyScalar(colonToken.endOffset);
         }
         return this.parseValue(baseIndent) ?? this.makeEmptyScalar(colonToken.endOffset);
@@ -999,7 +999,7 @@ class YamlParser {
             }
             if (indent !== baseIndent) {
                 if (indent > baseIndent) {
-                    this.emitError(( localize(136, "Unexpected indentation (expected {0}, got {1})", baseIndent, indent)), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-indentation");
+                    this.emitError(( localize(137, "Unexpected indentation (expected {0}, got {1})", baseIndent, indent)), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-indentation");
                 } else {
                     break;
                 }
@@ -1048,12 +1048,12 @@ class YamlParser {
         }
         this.skipNewlinesAndComments();
         if (this.currentToken().type === TokenType.EOF) {
-            this.emitError(( localize(140, "Missing sequence item value")), dashToken.startOffset, dashToken.endOffset, "missing-value");
+            this.emitError(( localize(141, "Missing sequence item value")), dashToken.startOffset, dashToken.endOffset, "missing-value");
             return this.makeEmptyScalar(dashToken.endOffset);
         }
         const nextIndent = this.currentIndent();
         if (nextIndent <= baseIndent) {
-            this.emitError(( localize(140, "Missing sequence item value")), dashToken.startOffset, dashToken.endOffset, "missing-value");
+            this.emitError(( localize(141, "Missing sequence item value")), dashToken.startOffset, dashToken.endOffset, "missing-value");
             return this.makeEmptyScalar(dashToken.endOffset);
         }
         return this.parseValue(baseIndent) ?? this.makeEmptyScalar(dashToken.endOffset);
@@ -1074,7 +1074,7 @@ class YamlParser {
             if (this.currentToken().type === TokenType.Scalar) {
                 key = this.parseFlowScalar();
             } else {
-                this.emitError(( localize(141, "Expected mapping key")), this.currentToken().startOffset, this.currentToken().endOffset, "expected-key");
+                this.emitError(( localize(142, "Expected mapping key")), this.currentToken().startOffset, this.currentToken().endOffset, "expected-key");
                 break;
             }
             this.skipFlowWhitespace();
@@ -1100,7 +1100,7 @@ class YamlParser {
         if (endToken.type === TokenType.FlowMapEnd) {
             this.advance();
         } else {
-            this.emitError(( localize(142, "Expected \"}\"")), endToken.startOffset, endToken.endOffset, "expected-flow-map-end");
+            this.emitError(( localize(143, "Expected \"}\"")), endToken.startOffset, endToken.endOffset, "expected-flow-map-end");
         }
         return {
             type: "map",
@@ -1123,7 +1123,7 @@ class YamlParser {
             } else if (this.currentToken().type === TokenType.Scalar) {
                 item = this.parseFlowScalar();
             } else {
-                this.emitError(( localize(143, "Unexpected token in flow sequence")), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-token");
+                this.emitError(( localize(144, "Unexpected token in flow sequence")), this.currentToken().startOffset, this.currentToken().endOffset, "unexpected-token");
                 this.advance();
                 continue;
             }
@@ -1138,7 +1138,7 @@ class YamlParser {
         if (endToken.type === TokenType.FlowSeqEnd) {
             this.advance();
         } else {
-            this.emitError(( localize(144, "Expected \"]\"")), endToken.startOffset, endToken.endOffset, "expected-flow-seq-end");
+            this.emitError(( localize(145, "Expected \"]\"")), endToken.startOffset, endToken.endOffset, "expected-flow-seq-end");
         }
         return {
             type: "sequence",

package/vscode/src/vs/base/parts/ipc/common/ipc.js

@@ -730,7 +730,7 @@ var ProxyChannel;
         const mapEventNameToEvent = ( new Map());
         for (const key in handler) {
             if (propertyIsEvent(key)) {
-                mapEventNameToEvent.set(key, Event.buffer(handler[key], true, undefined, disposables));
+                mapEventNameToEvent.set(key, Event.buffer(handler[key], key, true, undefined, disposables));
             }
         }
         return new (class {
@@ -745,7 +745,7 @@ var ProxyChannel;
                         return target.call(handler, arg);
                     }
                     if (propertyIsEvent(event)) {
-                        mapEventNameToEvent.set(event, Event.buffer(handler[event], true, undefined, disposables));
+                        mapEventNameToEvent.set(event, Event.buffer(handler[event], event, true, undefined, disposables));
                         return mapEventNameToEvent.get(event);
                     }
                 }

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.d.ts

@@ -19,6 +19,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private readonly _editContext;
     private readonly _screenReaderSupport;
     private _previousEditContextSelection;
+    private _previousEditContextText;
     private _editContextPrimarySelection;
     private readonly _parent;
     private _parentBounds;
@@ -42,7 +43,6 @@ export declare class NativeEditContext extends AbstractEditContext {
     onLinesChanged(e: ViewLinesChangedEvent): boolean;
     onLinesDeleted(e: ViewLinesDeletedEvent): boolean;
     onLinesInserted(e: ViewLinesInsertedEvent): boolean;
-    private _updateEditContextOnLineChange;
     onScrollChanged(e: ViewScrollChangedEvent): boolean;
     onZonesChanged(e: ViewZonesChangedEvent): boolean;
     handleWillPaste(): void;

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.js

@@ -49,6 +49,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._visibleRangeProvider = _visibleRangeProvider;
         this.logService = logService;
         this._previousEditContextSelection = ( new OffsetRange(0, 0));
+        this._previousEditContextText = "";
         this._editContextPrimarySelection = ( new Selection(1, 1, 1, 1));
         this._parentBounds = null;
         this._decorations = [];
@@ -228,6 +229,18 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             }
         }));
         this._register(NativeEditContextRegistry.register(ownerID, this));
+        this._register(context.viewModel.model.onDidChangeContent(e => {
+            let doChange = false;
+            for (const change of e.changes) {
+                if (change.range.startLineNumber <= this._editContextPrimarySelection.endLineNumber && change.range.endLineNumber >= this._editContextPrimarySelection.startLineNumber) {
+                    doChange = true;
+                    break;
+                }
+            }
+            if (doChange) {
+                this._updateEditContext();
+            }
+        }));
     }
     dispose() {
         this.domNode.domNode.editContext = undefined;
@@ -271,23 +284,14 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         return true;
     }
     onLinesChanged(e) {
-        this._updateEditContextOnLineChange(e.fromLineNumber, e.fromLineNumber + e.count - 1);
         return true;
     }
     onLinesDeleted(e) {
-        this._updateEditContextOnLineChange(e.fromLineNumber, e.toLineNumber);
         return true;
     }
     onLinesInserted(e) {
-        this._updateEditContextOnLineChange(e.fromLineNumber, e.toLineNumber);
         return true;
     }
-    _updateEditContextOnLineChange(fromLineNumber, toLineNumber) {
-        if (this._editContextPrimarySelection.endLineNumber < fromLineNumber || this._editContextPrimarySelection.startLineNumber > toLineNumber) {
-            return;
-        }
-        this._updateEditContext();
-    }
     onScrollChanged(e) {
         this._scrollLeft = e.scrollLeft;
         this._scrollTop = e.scrollTop;
@@ -352,8 +356,14 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         if (!editContextState) {
             return;
         }
-        this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text ?? " ");
-        this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
+        const newText = editContextState.text ?? " ";
+        if (newText !== this._previousEditContextText) {
+            this._editContext.updateText(0, this._previousEditContextText.length, newText);
+            this._previousEditContextText = newText;
+        }
+        if (editContextState.selectionStartOffset !== this._previousEditContextSelection.start || editContextState.selectionEndOffset !== this._previousEditContextSelection.endExclusive) {
+            this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
+        }
         this._editContextPrimarySelection = editContextState.editContextPrimarySelection;
         this._previousEditContextSelection = ( new OffsetRange(editContextState.selectionStartOffset, editContextState.selectionEndOffset));
     }

package/vscode/src/vs/editor/browser/controller/editContext/native/screenReaderSupport.js

@@ -95,7 +95,7 @@ let ScreenReaderSupport = class ScreenReaderSupport extends Disposable {
         this._domNode.domNode.setAttribute("aria-required", options.get(EditorOption.ariaRequired) ? "true" : "false");
         this._domNode.domNode.setAttribute("aria-multiline", "true");
         this._domNode.domNode.setAttribute("aria-autocomplete", options.get(EditorOption.readOnly) ? "none" : "both");
-        this._domNode.domNode.setAttribute("aria-roledescription", ( localize(145, "editor")));
+        this._domNode.domNode.setAttribute("aria-roledescription", ( localize(146, "editor")));
         this._domNode.domNode.setAttribute(
             "aria-label",
             ariaLabelForScreenReaderContent(options, this._keybindingService)

package/vscode/src/vs/editor/browser/controller/editContext/screenReaderUtils.js

@@ -72,24 +72,24 @@ function ariaLabelForScreenReaderContent(options, keybindingService) {
         const toggleKeybindingLabel = keybindingService.lookupKeybinding("editor.action.toggleScreenReaderAccessibilityMode")?.getAriaLabel();
         const runCommandKeybindingLabel = keybindingService.lookupKeybinding("workbench.action.showCommands")?.getAriaLabel();
         const keybindingEditorKeybindingLabel = keybindingService.lookupKeybinding("workbench.action.openGlobalKeybindings")?.getAriaLabel();
-        const editorNotAccessibleMessage = ( localize(146, "The editor is not accessible at this time."));
+        const editorNotAccessibleMessage = ( localize(147, "The editor is not accessible at this time."));
         if (toggleKeybindingLabel) {
             return localize(
-                147,
+                148,
                 "{0} To enable screen reader optimized mode, use {1}",
                 editorNotAccessibleMessage,
                 toggleKeybindingLabel
             );
         } else if (runCommandKeybindingLabel) {
             return localize(
-                148,
+                149,
                 "{0} To enable screen reader optimized mode, open the quick pick with {1} and run the command Toggle Screen Reader Accessibility Mode, which is currently not triggerable via keyboard.",
                 editorNotAccessibleMessage,
                 runCommandKeybindingLabel
             );
         } else if (keybindingEditorKeybindingLabel) {
             return localize(
-                149,
+                150,
                 "{0} Please assign a keybinding for the command Toggle Screen Reader Accessibility Mode by accessing the keybindings editor with {1} and run it.",
                 editorNotAccessibleMessage,
                 keybindingEditorKeybindingLabel

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.js

@@ -139,7 +139,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this.textArea.setAttribute("aria-required", options.get(EditorOption.ariaRequired) ? "true" : "false");
         this.textArea.setAttribute("tabindex", String(options.get(EditorOption.tabIndex)));
         this.textArea.setAttribute("role", "textbox");
-        this.textArea.setAttribute("aria-roledescription", ( localize(150, "editor")));
+        this.textArea.setAttribute("aria-roledescription", ( localize(151, "editor")));
         this.textArea.setAttribute("aria-multiline", "true");
         this.textArea.setAttribute("aria-autocomplete", options.get(EditorOption.readOnly) ? "none" : "both");
         this._ensureReadOnlyAttribute();

package/vscode/src/vs/editor/browser/coreCommands.js

@@ -972,7 +972,7 @@ var CoreNavigationCommands;
                     type: "object",
                     properties: {
                         "sticky": {
-                            description: ( localize(151, "Stick to the end even when going to longer lines")),
+                            description: ( localize(152, "Stick to the end even when going to longer lines")),
                             type: "boolean",
                             default: false
                         }
@@ -1005,7 +1005,7 @@ var CoreNavigationCommands;
                     type: "object",
                     properties: {
                         "sticky": {
-                            description: ( localize(151, "Stick to the end even when going to longer lines")),
+                            description: ( localize(152, "Stick to the end even when going to longer lines")),
                             type: "boolean",
                             default: false
                         }
@@ -1607,7 +1607,7 @@ var CoreNavigationCommands;
                 [viewModel.getPrimaryCursorState()]
             );
             viewModel.revealAllCursors(args.source, true);
-            status(( localize(152, "Removed secondary cursors")));
+            status(( localize(153, "Removed secondary cursors")));
         }
     })());
     CoreNavigationCommands.RevealLine = registerEditorCommand(new (class extends CoreEditorCommand {

package/vscode/src/vs/editor/browser/editorExtensions.js

@@ -427,17 +427,17 @@ const UndoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
         menuId: MenuId.MenubarEditMenu,
         group: "1_do",
-        title: ( localize(153, "&&Undo")),
+        title: ( localize(154, "&&Undo")),
         order: 1
     }, {
         menuId: MenuId.CommandPalette,
         group: "",
-        title: ( localize(154, "Undo")),
+        title: ( localize(155, "Undo")),
         order: 1
     }, {
         menuId: MenuId.SimpleEditorContext,
         group: "1_do",
-        title: ( localize(154, "Undo")),
+        title: ( localize(155, "Undo")),
         order: 1
     }]
 })));
@@ -459,17 +459,17 @@ const RedoCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
         menuId: MenuId.MenubarEditMenu,
         group: "1_do",
-        title: ( localize(155, "&&Redo")),
+        title: ( localize(156, "&&Redo")),
         order: 2
     }, {
         menuId: MenuId.CommandPalette,
         group: "",
-        title: ( localize(156, "Redo")),
+        title: ( localize(157, "Redo")),
         order: 1
     }, {
         menuId: MenuId.SimpleEditorContext,
         group: "1_do",
-        title: ( localize(156, "Redo")),
+        title: ( localize(157, "Redo")),
         order: 2
     }]
 })));
@@ -488,17 +488,17 @@ const SelectAllCommand = registerCommand(( new MultiCommand({
     menuOpts: [{
         menuId: MenuId.MenubarSelectionMenu,
         group: "1_basic",
-        title: ( localize(157, "&&Select All")),
+        title: ( localize(158, "&&Select All")),
         order: 1
     }, {
         menuId: MenuId.CommandPalette,
         group: "",
-        title: ( localize(158, "Select All")),
+        title: ( localize(159, "Select All")),
         order: 1
     }, {
         menuId: MenuId.SimpleEditorContext,
         group: "9_select",
-        title: ( localize(158, "Select All")),
+        title: ( localize(159, "Select All")),
         order: 1
     }]
 })));

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -79,7 +79,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         if (!ViewGpuContext_1.device) {
             ViewGpuContext_1.device = GPULifecycle.requestDevice(message => {
                 const choices = [{
-                    label: ( localize(159, "Use DOM-based rendering")),
+                    label: ( localize(160, "Use DOM-based rendering")),
                     run: () => this.configurationService.updateValue("editor.experimentalGpuAcceleration", "off")
                 }];
                 this._notificationService.prompt(Severity$1.Warning, message, choices);

package/vscode/src/vs/editor/browser/services/inlineCompletionsService.js

@@ -16,7 +16,7 @@ import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.
 import { IInlineCompletionsService } from './inlineCompletionsService.service.js';
 
 var InlineCompletionsService_1;
-const InlineCompletionsSnoozing = ( new RawContextKey("inlineCompletions.snoozed", false, ( localize(160, "Whether inline completions are currently snoozed"))));
+const InlineCompletionsSnoozing = ( new RawContextKey("inlineCompletions.snoozed", false, ( localize(161, "Whether inline completions are currently snoozed"))));
 let InlineCompletionsService = class InlineCompletionsService extends Disposable {
     static {
         InlineCompletionsService_1 = this;
@@ -110,7 +110,7 @@ class SnoozeInlineCompletion extends Action2 {
     constructor() {
         super({
             id: SnoozeInlineCompletion.ID,
-            title: ( localize2(161, "Snooze Inline Suggestions")),
+            title: ( localize2(162, "Snooze Inline Suggestions")),
             precondition: ContextKeyExpr.true(),
             f1: true
         });
@@ -158,7 +158,7 @@ class SnoozeInlineCompletion extends Action2 {
             value: 3_600_000
         }];
         const picked = await quickInputService.pick(items, {
-            placeHolder: ( localize(162, "Select snooze duration for Inline Suggestions")),
+            placeHolder: ( localize(163, "Select snooze duration for Inline Suggestions")),
             activeItem: items.find(item => item.value === lastSelectedDuration)
         });
         if (picked) {
@@ -180,7 +180,7 @@ class CancelSnoozeInlineCompletion extends Action2 {
     constructor() {
         super({
             id: CancelSnoozeInlineCompletion.ID,
-            title: ( localize2(163, "Cancel Snooze Inline Suggestions")),
+            title: ( localize2(164, "Cancel Snooze Inline Suggestions")),
             precondition: InlineCompletionsSnoozing,
             f1: true
         });