@codingame/monaco-vscode-api 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/codeEditor/common/languageConfigurationExtensionPoint.js

@@ -76,7 +76,7 @@ let LanguageConfigurationFileHandler = LanguageConfigurationFileHandler_1 = clas
             let configuration = parse(contents, errors);
             if (errors.length) {
                 console.error(( localize(
-                    9126,
+                    10867,
                     "Errors parsing {0}: {1}",
                     (configFileLocation.toString()),
                     ( errors.map(e => (`[${e.offset}, ${e.length}] ${getParseErrorMessage(e.error)}`))).join("\n")
@@ -84,7 +84,7 @@ let LanguageConfigurationFileHandler = LanguageConfigurationFileHandler_1 = clas
             }
             if (getNodeType(configuration) !== "object") {
                 console.error(( localize(
-                    9127,
+                    10868,
                     "{0}: Invalid format, JSON object expected.",
                     (configFileLocation.toString())
                 )));
@@ -532,11 +532,11 @@ const schema = {
     definitions: {
         openBracket: {
             type: "string",
-            description: ( localize(9128, "The opening bracket character or string sequence."))
+            description: ( localize(10869, "The opening bracket character or string sequence."))
         },
         closeBracket: {
             type: "string",
-            description: ( localize(9129, "The closing bracket character or string sequence."))
+            description: ( localize(10870, "The closing bracket character or string sequence."))
         },
         bracketPair: {
             type: "array",
@@ -556,32 +556,32 @@ const schema = {
                     noIndent: false
                 }
             },
-            description: ( localize(9130, "Defines the comment symbols")),
+            description: ( localize(10871, "Defines the comment symbols")),
             type: "object",
             properties: {
                 blockComment: {
                     type: "array",
-                    description: ( localize(9131, "Defines how block comments are marked.")),
+                    description: ( localize(10872, "Defines how block comments are marked.")),
                     items: [{
                         type: "string",
-                        description: ( localize(9132, "The character sequence that starts a block comment."))
+                        description: ( localize(10873, "The character sequence that starts a block comment."))
                     }, {
                         type: "string",
-                        description: ( localize(9133, "The character sequence that ends a block comment."))
+                        description: ( localize(10874, "The character sequence that ends a block comment."))
                     }]
                 },
                 lineComment: {
                     type: "object",
-                    description: ( localize(9134, "Configuration for line comments.")),
+                    description: ( localize(10875, "Configuration for line comments.")),
                     properties: {
                         comment: {
                             type: "string",
-                            description: ( localize(9135, "The character sequence that starts a line comment."))
+                            description: ( localize(10876, "The character sequence that starts a line comment."))
                         },
                         noIndent: {
                             type: "boolean",
                             description: ( localize(
-                                9136,
+                                10877,
                                 "Whether the comment token should not be indented and placed at the first column. Defaults to false."
                             )),
                             default: false
@@ -595,7 +595,7 @@ const schema = {
         brackets: {
             default: [["(", ")"], ["[", "]"], ["{", "}"]],
             markdownDescription: ( localize(
-                9137,
+                10878,
                 "Defines the bracket symbols that increase or decrease the indentation. When bracket pair colorization is enabled and {0} is not defined, this also defines the bracket pairs that are colorized by their nesting level.",
                 "`colorizedBracketPairs`"
             )),
@@ -607,7 +607,7 @@ const schema = {
         colorizedBracketPairs: {
             default: [["(", ")"], ["[", "]"], ["{", "}"]],
             markdownDescription: ( localize(
-                9138,
+                10879,
                 "Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled. Any brackets included here that are not included in {0} will be automatically included in {0}.",
                 "`brackets`"
             )),
@@ -619,7 +619,7 @@ const schema = {
         autoClosingPairs: {
             default: [["(", ")"], ["[", "]"], ["{", "}"]],
             description: ( localize(
-                9139,
+                10880,
                 "Defines the bracket pairs. When a opening bracket is entered, the closing bracket is inserted automatically."
             )),
             type: "array",
@@ -637,7 +637,7 @@ const schema = {
                         },
                         notIn: {
                             type: "array",
-                            description: ( localize(9140, "Defines a list of scopes where the auto pairs are disabled.")),
+                            description: ( localize(10881, "Defines a list of scopes where the auto pairs are disabled.")),
                             items: {
                                 enum: ["string", "comment"]
                             }
@@ -649,7 +649,7 @@ const schema = {
         autoCloseBefore: {
             default: ";:.,=}])> \n\t",
             description: ( localize(
-                9141,
+                10882,
                 "Defines what characters must be after the cursor in order for bracket or quote autoclosing to occur when using the 'languageDefined' autoclosing setting. This is typically the set of characters which can not start an expression."
             )),
             type: "string"
@@ -657,7 +657,7 @@ const schema = {
         surroundingPairs: {
             default: [["(", ")"], ["[", "]"], ["{", "}"]],
             description: ( localize(
-                9142,
+                10883,
                 "Defines the bracket pairs that can be used to surround a selected string."
             )),
             type: "array",
@@ -680,22 +680,22 @@ const schema = {
         wordPattern: {
             default: "",
             description: ( localize(
-                9143,
+                10884,
                 "Defines what is considered to be a word in the programming language."
             )),
             type: ["string", "object"],
             properties: {
                 pattern: {
                     type: "string",
-                    description: ( localize(9144, "The RegExp pattern used to match words.")),
+                    description: ( localize(10885, "The RegExp pattern used to match words.")),
                     default: ""
                 },
                 flags: {
                     type: "string",
-                    description: ( localize(9145, "The RegExp flags used to match words.")),
+                    description: ( localize(10886, "The RegExp flags used to match words.")),
                     default: "g",
                     pattern: "^([gimuy]+)$",
-                    patternErrorMessage: ( localize(9146, "Must match the pattern `/^([gimuy]+)$/`."))
+                    patternErrorMessage: ( localize(10887, "Must match the pattern `/^([gimuy]+)$/`."))
                 }
             }
         },
@@ -704,90 +704,90 @@ const schema = {
                 increaseIndentPattern: "",
                 decreaseIndentPattern: ""
             },
-            description: ( localize(9147, "The language's indentation settings.")),
+            description: ( localize(10888, "The language's indentation settings.")),
             type: "object",
             properties: {
                 increaseIndentPattern: {
                     type: ["string", "object"],
                     description: ( localize(
-                        9148,
+                        10889,
                         "If a line matches this pattern, then all the lines after it should be indented once (until another rule matches)."
                     )),
                     properties: {
                         pattern: {
                             type: "string",
-                            description: ( localize(9149, "The RegExp pattern for increaseIndentPattern.")),
+                            description: ( localize(10890, "The RegExp pattern for increaseIndentPattern.")),
                             default: ""
                         },
                         flags: {
                             type: "string",
-                            description: ( localize(9150, "The RegExp flags for increaseIndentPattern.")),
+                            description: ( localize(10891, "The RegExp flags for increaseIndentPattern.")),
                             default: "",
                             pattern: "^([gimuy]+)$",
-                            patternErrorMessage: ( localize(9151, "Must match the pattern `/^([gimuy]+)$/`."))
+                            patternErrorMessage: ( localize(10892, "Must match the pattern `/^([gimuy]+)$/`."))
                         }
                     }
                 },
                 decreaseIndentPattern: {
                     type: ["string", "object"],
                     description: ( localize(
-                        9152,
+                        10893,
                         "If a line matches this pattern, then all the lines after it should be unindented once (until another rule matches)."
                     )),
                     properties: {
                         pattern: {
                             type: "string",
-                            description: ( localize(9153, "The RegExp pattern for decreaseIndentPattern.")),
+                            description: ( localize(10894, "The RegExp pattern for decreaseIndentPattern.")),
                             default: ""
                         },
                         flags: {
                             type: "string",
-                            description: ( localize(9154, "The RegExp flags for decreaseIndentPattern.")),
+                            description: ( localize(10895, "The RegExp flags for decreaseIndentPattern.")),
                             default: "",
                             pattern: "^([gimuy]+)$",
-                            patternErrorMessage: ( localize(9155, "Must match the pattern `/^([gimuy]+)$/`."))
+                            patternErrorMessage: ( localize(10896, "Must match the pattern `/^([gimuy]+)$/`."))
                         }
                     }
                 },
                 indentNextLinePattern: {
                     type: ["string", "object"],
                     description: ( localize(
-                        9156,
+                        10897,
                         "If a line matches this pattern, then **only the next line** after it should be indented once."
                     )),
                     properties: {
                         pattern: {
                             type: "string",
-                            description: ( localize(9157, "The RegExp pattern for indentNextLinePattern.")),
+                            description: ( localize(10898, "The RegExp pattern for indentNextLinePattern.")),
                             default: ""
                         },
                         flags: {
                             type: "string",
-                            description: ( localize(9158, "The RegExp flags for indentNextLinePattern.")),
+                            description: ( localize(10899, "The RegExp flags for indentNextLinePattern.")),
                             default: "",
                             pattern: "^([gimuy]+)$",
-                            patternErrorMessage: ( localize(9159, "Must match the pattern `/^([gimuy]+)$/`."))
+                            patternErrorMessage: ( localize(10900, "Must match the pattern `/^([gimuy]+)$/`."))
                         }
                     }
                 },
                 unIndentedLinePattern: {
                     type: ["string", "object"],
                     description: ( localize(
-                        9160,
+                        10901,
                         "If a line matches this pattern, then its indentation should not be changed and it should not be evaluated against the other rules."
                     )),
                     properties: {
                         pattern: {
                             type: "string",
-                            description: ( localize(9161, "The RegExp pattern for unIndentedLinePattern.")),
+                            description: ( localize(10902, "The RegExp pattern for unIndentedLinePattern.")),
                             default: ""
                         },
                         flags: {
                             type: "string",
-                            description: ( localize(9162, "The RegExp flags for unIndentedLinePattern.")),
+                            description: ( localize(10903, "The RegExp flags for unIndentedLinePattern.")),
                             default: "",
                             pattern: "^([gimuy]+)$",
-                            patternErrorMessage: ( localize(9163, "Must match the pattern `/^([gimuy]+)$/`."))
+                            patternErrorMessage: ( localize(10904, "Must match the pattern `/^([gimuy]+)$/`."))
                         }
                     }
                 }
@@ -795,61 +795,61 @@ const schema = {
         },
         folding: {
             type: "object",
-            description: ( localize(9164, "The language's folding settings.")),
+            description: ( localize(10905, "The language's folding settings.")),
             properties: {
                 offSide: {
                     type: "boolean",
                     description: ( localize(
-                        9165,
+                        10906,
                         "A language adheres to the off-side rule if blocks in that language are expressed by their indentation. If set, empty lines belong to the subsequent block."
                     ))
                 },
                 markers: {
                     type: "object",
                     description: ( localize(
-                        9166,
+                        10907,
                         "Language specific folding markers such as '#region' and '#endregion'. The start and end regexes will be tested against the contents of all lines and must be designed efficiently"
                     )),
                     properties: {
                         start: {
                             type: ["string", "object"],
                             description: ( localize(
-                                9167,
+                                10908,
                                 "The RegExp pattern for the start marker. The regexp must start with '^'."
                             )),
                             properties: {
                                 pattern: {
                                     type: "string",
-                                    description: ( localize(9168, "The RegExp pattern for the start marker.")),
+                                    description: ( localize(10909, "The RegExp pattern for the start marker.")),
                                     default: ""
                                 },
                                 flags: {
                                     type: "string",
-                                    description: ( localize(9169, "The RegExp flags for the start marker.")),
+                                    description: ( localize(10910, "The RegExp flags for the start marker.")),
                                     default: "",
                                     pattern: "^([gimuy]+)$",
-                                    patternErrorMessage: ( localize(9170, "Must match the pattern `/^([gimuy]+)$/`."))
+                                    patternErrorMessage: ( localize(10911, "Must match the pattern `/^([gimuy]+)$/`."))
                                 }
                             }
                         },
                         end: {
                             type: ["string", "object"],
                             description: ( localize(
-                                9171,
+                                10912,
                                 "The RegExp pattern for the end marker. The regexp must start with '^'."
                             )),
                             properties: {
                                 pattern: {
                                     type: "string",
-                                    description: ( localize(9172, "The RegExp pattern for the end marker.")),
+                                    description: ( localize(10913, "The RegExp pattern for the end marker.")),
                                     default: ""
                                 },
                                 flags: {
                                     type: "string",
-                                    description: ( localize(9173, "The RegExp flags for the end marker.")),
+                                    description: ( localize(10914, "The RegExp flags for the end marker.")),
                                     default: "",
                                     pattern: "^([gimuy]+)$",
-                                    patternErrorMessage: ( localize(9174, "Must match the pattern `/^([gimuy]+)$/`."))
+                                    patternErrorMessage: ( localize(10915, "Must match the pattern `/^([gimuy]+)$/`."))
                                 }
                             }
                         }
@@ -859,78 +859,78 @@ const schema = {
         },
         onEnterRules: {
             type: "array",
-            description: ( localize(9175, "The language's rules to be evaluated when pressing Enter.")),
+            description: ( localize(10916, "The language's rules to be evaluated when pressing Enter.")),
             items: {
                 type: "object",
-                description: ( localize(9175, "The language's rules to be evaluated when pressing Enter.")),
+                description: ( localize(10916, "The language's rules to be evaluated when pressing Enter.")),
                 required: ["beforeText", "action"],
                 properties: {
                     beforeText: {
                         type: ["string", "object"],
                         description: ( localize(
-                            9176,
+                            10917,
                             "This rule will only execute if the text before the cursor matches this regular expression."
                         )),
                         properties: {
                             pattern: {
                                 type: "string",
-                                description: ( localize(9177, "The RegExp pattern for beforeText.")),
+                                description: ( localize(10918, "The RegExp pattern for beforeText.")),
                                 default: ""
                             },
                             flags: {
                                 type: "string",
-                                description: ( localize(9178, "The RegExp flags for beforeText.")),
+                                description: ( localize(10919, "The RegExp flags for beforeText.")),
                                 default: "",
                                 pattern: "^([gimuy]+)$",
-                                patternErrorMessage: ( localize(9179, "Must match the pattern `/^([gimuy]+)$/`."))
+                                patternErrorMessage: ( localize(10920, "Must match the pattern `/^([gimuy]+)$/`."))
                             }
                         }
                     },
                     afterText: {
                         type: ["string", "object"],
                         description: ( localize(
-                            9180,
+                            10921,
                             "This rule will only execute if the text after the cursor matches this regular expression."
                         )),
                         properties: {
                             pattern: {
                                 type: "string",
-                                description: ( localize(9181, "The RegExp pattern for afterText.")),
+                                description: ( localize(10922, "The RegExp pattern for afterText.")),
                                 default: ""
                             },
                             flags: {
                                 type: "string",
-                                description: ( localize(9182, "The RegExp flags for afterText.")),
+                                description: ( localize(10923, "The RegExp flags for afterText.")),
                                 default: "",
                                 pattern: "^([gimuy]+)$",
-                                patternErrorMessage: ( localize(9183, "Must match the pattern `/^([gimuy]+)$/`."))
+                                patternErrorMessage: ( localize(10924, "Must match the pattern `/^([gimuy]+)$/`."))
                             }
                         }
                     },
                     previousLineText: {
                         type: ["string", "object"],
                         description: ( localize(
-                            9184,
+                            10925,
                             "This rule will only execute if the text above the line matches this regular expression."
                         )),
                         properties: {
                             pattern: {
                                 type: "string",
-                                description: ( localize(9185, "The RegExp pattern for previousLineText.")),
+                                description: ( localize(10926, "The RegExp pattern for previousLineText.")),
                                 default: ""
                             },
                             flags: {
                                 type: "string",
-                                description: ( localize(9186, "The RegExp flags for previousLineText.")),
+                                description: ( localize(10927, "The RegExp flags for previousLineText.")),
                                 default: "",
                                 pattern: "^([gimuy]+)$",
-                                patternErrorMessage: ( localize(9187, "Must match the pattern `/^([gimuy]+)$/`."))
+                                patternErrorMessage: ( localize(10928, "Must match the pattern `/^([gimuy]+)$/`."))
                             }
                         }
                     },
                     action: {
                         type: ["string", "object"],
-                        description: ( localize(9188, "The action to execute.")),
+                        description: ( localize(10929, "The action to execute.")),
                         required: ["indent"],
                         default: {
                             "indent": "indent"
@@ -938,24 +938,24 @@ const schema = {
                         properties: {
                             indent: {
                                 type: "string",
-                                description: ( localize(9189, "Describe what to do with the indentation")),
+                                description: ( localize(10930, "Describe what to do with the indentation")),
                                 default: "indent",
                                 enum: ["none", "indent", "indentOutdent", "outdent"],
-                                markdownEnumDescriptions: [( localize(9190, "Insert new line and copy the previous line's indentation.")), ( localize(
-                                    9191,
+                                markdownEnumDescriptions: [( localize(10931, "Insert new line and copy the previous line's indentation.")), ( localize(
+                                    10932,
                                     "Insert new line and indent once (relative to the previous line's indentation)."
                                 )), ( localize(
-                                    9192,
+                                    10933,
                                     "Insert two new lines:\n - the first one indented which will hold the cursor\n - the second one at the same indentation level"
                                 )), ( localize(
-                                    9193,
+                                    10934,
                                     "Insert new line and outdent once (relative to the previous line's indentation)."
                                 ))]
                             },
                             appendText: {
                                 type: "string",
                                 description: ( localize(
-                                    9194,
+                                    10935,
                                     "Describes text to be appended after the new line and after the indentation."
                                 )),
                                 default: ""
@@ -963,7 +963,7 @@ const schema = {
                             removeText: {
                                 type: "number",
                                 description: ( localize(
-                                    9195,
+                                    10936,
                                     "Describes the number of characters to remove from the new line's indentation."
                                 )),
                                 default: 0

package/vscode/src/vs/workbench/contrib/comments/browser/commentColors.js

@@ -19,33 +19,33 @@ const resolvedCommentViewIcon = registerColor("commentsView.resolvedIcon", {
     light: disabledForeground,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(9201, "Icon color for resolved comments.")));
+}, ( localize(10942, "Icon color for resolved comments.")));
 const unresolvedCommentViewIcon = registerColor("commentsView.unresolvedIcon", {
     dark: listFocusOutline,
     light: listFocusOutline,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(9202, "Icon color for unresolved comments.")));
+}, ( localize(10943, "Icon color for unresolved comments.")));
 registerColor(
     "editorCommentsWidget.replyInputBackground",
     peekViewTitleBackground,
-    ( localize(9203, "Background color for comment reply input box."))
+    ( localize(10944, "Background color for comment reply input box."))
 );
 const resolvedCommentBorder = registerColor("editorCommentsWidget.resolvedBorder", {
     dark: resolvedCommentViewIcon,
     light: resolvedCommentViewIcon,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(9204, "Color of borders and arrow for resolved comments.")));
+}, ( localize(10945, "Color of borders and arrow for resolved comments.")));
 const unresolvedCommentBorder = registerColor("editorCommentsWidget.unresolvedBorder", {
     dark: unresolvedCommentViewIcon,
     light: unresolvedCommentViewIcon,
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(9205, "Color of borders and arrow for unresolved comments.")));
-registerColor("editorCommentsWidget.rangeBackground", ( transparent(unresolvedCommentBorder, .1)), ( localize(9206, "Color of background for comment ranges.")));
+}, ( localize(10946, "Color of borders and arrow for unresolved comments.")));
+registerColor("editorCommentsWidget.rangeBackground", ( transparent(unresolvedCommentBorder, .1)), ( localize(10947, "Color of background for comment ranges.")));
 registerColor("editorCommentsWidget.rangeActiveBackground", ( transparent(unresolvedCommentBorder, .1)), ( localize(
-    9207,
+    10948,
     "Color of background for currently selected or hovered comment range."
 )));
 const commentThreadStateBorderColors = ( new Map([

package/vscode/src/vs/workbench/contrib/comments/browser/commentGlyphWidget.js

@@ -26,14 +26,14 @@ const overviewRulerCommentingRangeForeground = registerColor("editorGutter.comme
     hcDark: Color.white,
     hcLight: Color.black
 }, ( localize(
-    9208,
+    10949,
     "Editor gutter decoration color for commenting ranges. This color should be opaque."
 )));
 const overviewRulerCommentForeground = registerColor(
     "editorOverviewRuler.commentForeground",
     overviewRulerCommentingRangeForeground,
     ( localize(
-    9209,
+    10950,
     "Editor overview ruler decoration color for resolved comments. This color should be opaque."
 ))
 );
@@ -41,7 +41,7 @@ const overviewRulerCommentUnresolvedForeground = registerColor(
     "editorOverviewRuler.commentUnresolvedForeground",
     overviewRulerCommentForeground,
     ( localize(
-    9210,
+    10951,
     "Editor overview ruler decoration color for unresolved comments. This color should be opaque."
 ))
 );
@@ -49,7 +49,7 @@ const overviewRulerCommentDraftForeground = registerColor(
     "editorOverviewRuler.commentDraftForeground",
     overviewRulerCommentUnresolvedForeground,
     ( localize(
-    9211,
+    10952,
     "Editor overview ruler decoration color for comment threads with draft comments. This color should be opaque."
 ))
 );
@@ -58,12 +58,12 @@ const editorGutterCommentGlyphForeground = registerColor("editorGutter.commentGl
     light: editorForeground,
     hcDark: Color.black,
     hcLight: Color.white
-}, ( localize(9212, "Editor gutter decoration color for commenting glyphs.")));
+}, ( localize(10953, "Editor gutter decoration color for commenting glyphs.")));
 registerColor(
     "editorGutter.commentUnresolvedGlyphForeground",
     editorGutterCommentGlyphForeground,
     ( localize(
-    9213,
+    10954,
     "Editor gutter decoration color for commenting glyphs for unresolved comment threads."
 ))
 );
@@ -71,7 +71,7 @@ registerColor(
     "editorGutter.commentDraftGlyphForeground",
     editorGutterCommentGlyphForeground,
     ( localize(
-    9214,
+    10955,
     "Editor gutter decoration color for commenting glyphs for comment threads with draft comments."
 ))
 );

package/vscode/src/vs/workbench/contrib/comments/browser/commentNode.js

@@ -348,7 +348,7 @@ let CommentNode = class CommentNode extends Disposable {
     createReactionPicker(reactionGroup) {
         const toggleReactionAction = this._reactionActions.add(( new ToggleReactionsAction(() => {
             toggleReactionActionViewItem?.show();
-        }, ( localize(9215, "Toggle Reaction")))));
+        }, ( localize(10956, "Toggle Reaction")))));
         let reactionMenuActions = [];
         if (reactionGroup && reactionGroup.length) {
             reactionMenuActions = ( reactionGroup.map(reaction => {
@@ -361,7 +361,7 @@ let CommentNode = class CommentNode extends Disposable {
                         try {
                             await this.commentService.toggleReaction(this.owner, this.resource, this.commentThread, this.comment, reaction);
                         } catch (e) {
-                            const error = e.message ? ( localize(9216, "Toggling the comment reaction failed: {0}.", e.message)) : ( localize(9217, "Toggling the comment reaction failed"));
+                            const error = e.message ? ( localize(10957, "Toggling the comment reaction failed: {0}.", e.message)) : ( localize(10958, "Toggling the comment reaction failed"));
                             this.notificationService.error(error);
                         }
                     }

package/vscode/src/vs/workbench/contrib/comments/browser/commentReply.js

@@ -79,13 +79,9 @@ let CommentReply = class CommentReply extends Disposable {
         this.updateAuthorInfo();
         const hasExistingComments = this._commentThread.comments && this._commentThread.comments.length > 0;
         const modeId = generateUuid() + "-" + (hasExistingComments ? this._commentThread.threadId : ++INMEM_MODEL_ID);
-        const params = JSON.stringify({
-            extensionId: this._commentThread.extensionId,
-            commentThreadId: this._commentThread.threadId
-        });
         let resource = ( URI.from({
             scheme: Schemas.commentsInput,
-            path: `/${this._commentThread.extensionId}/commentinput-${modeId}.md?${params}`
+            path: `/${this._commentThread.extensionId}/commentinput-${modeId}.md`
         }));
         const commentController = this.commentService.getCommentController(this.owner);
         if (commentController) {
@@ -212,7 +208,7 @@ let CommentReply = class CommentReply extends Disposable {
     }
     setCommentEditorDecorations() {
         const hasExistingComments = this._commentThread.comments && this._commentThread.comments.length > 0;
-        const placeholder = hasExistingComments ? (this._commentOptions?.placeHolder || ( localize(9218, "Reply..."))) : (this._commentOptions?.placeHolder || ( localize(9219, "Type a new comment")));
+        const placeholder = hasExistingComments ? (this._commentOptions?.placeHolder || ( localize(10959, "Reply..."))) : (this._commentOptions?.placeHolder || ( localize(10960, "Type a new comment")));
         this.commentEditor.updateOptions({
             placeholder
         });
@@ -349,9 +345,9 @@ let CommentReply = class CommentReply extends Disposable {
         this._register(this.hoverService.setupManagedHover(
             getDefaultHoverDelegate("mouse"),
             this._reviewThreadReplyButton,
-            this._commentOptions?.prompt || ( localize(9218, "Reply..."))
+            this._commentOptions?.prompt || ( localize(10959, "Reply..."))
         ));
-        this._reviewThreadReplyButton.textContent = this._commentOptions?.prompt || ( localize(9218, "Reply..."));
+        this._reviewThreadReplyButton.textContent = this._commentOptions?.prompt || ( localize(10959, "Reply..."));
         this._register(addDisposableListener(
             this._reviewThreadReplyButton,
             "click",

package/vscode/src/vs/workbench/contrib/comments/browser/commentThreadBody.js

@@ -220,7 +220,7 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
         if (this._commentThread.isDocumentCommentThread()) {
             if (this._commentThread.range) {
                 this._commentsElement.ariaLabel = ( localize(
-                    9220,
+                    10961,
                     "Comment thread with {0} comments on lines {1} through {2}. {3}.",
                     this._commentThread.comments?.length,
                     this._commentThread.range.startLineNumber,
@@ -229,7 +229,7 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
                 ));
             } else {
                 this._commentsElement.ariaLabel = ( localize(
-                    9221,
+                    10962,
                     "Comment thread with {0} comments on the entire document. {1}.",
                     this._commentThread.comments?.length,
                     this._commentThread.label
@@ -237,7 +237,7 @@ let CommentThreadBody = class CommentThreadBody extends Disposable {
             }
         } else {
             this._commentsElement.ariaLabel = ( localize(
-                9222,
+                10963,
                 "Comment thread with {0} comments. {1}.",
                 this._commentThread.comments?.length,
                 this._commentThread.label