@codingame/monaco-vscode-api 29.1.1 → 30.0.0

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/textModelDiffs.js

@@ -89,22 +89,33 @@ class TextModelDiffs extends Disposable {
         this.ensureUpToDate();
         diffToRemoves.sort(compareBy(d => d.inputRange.startLineNumber, numberComparator));
         diffToRemoves.reverse();
-        let diffs = this._diffs.get();
-        for (const diffToRemove of diffToRemoves) {
-            const len = diffs.length;
-            diffs = diffs.filter(d => d !== diffToRemove);
-            if (len === diffs.length) {
+        const diffs = this._diffs.get();
+        const toRemoveSet = ( new Set(diffToRemoves));
+        if (toRemoveSet.size !== diffToRemoves.length) {
+            throw ( new BugIndicatingError());
+        }
+        const diffsSet = ( new Set(diffs));
+        for (const d of diffToRemoves) {
+            if (!( diffsSet.has(d))) {
                 throw ( new BugIndicatingError());
             }
+        }
+        for (const diffToRemove of diffToRemoves) {
             this._barrier.runExclusivelyOrThrow(() => {
                 const edits = diffToRemove.getReverseLineEdit().toEdits(this.textModel.getLineCount());
                 this.textModel.pushEditOperations(null, edits, () => null, group);
             });
-            diffs = ( diffs.map(
-                d => d.outputRange.isAfter(diffToRemove.outputRange) ? d.addOutputLineDelta(diffToRemove.inputRange.length - diffToRemove.outputRange.length) : d
-            ));
         }
-        this._diffs.set(diffs, transaction, TextModelDiffChangeReason.other);
+        let cumulativeDelta = 0;
+        const newDiffs = [];
+        for (const d of diffs) {
+            if (( toRemoveSet.has(d))) {
+                cumulativeDelta += d.inputRange.length - d.outputRange.length;
+            } else {
+                newDiffs.push(cumulativeDelta !== 0 ? d.addOutputLineDelta(cumulativeDelta) : d);
+            }
+        }
+        this._diffs.set(newDiffs, transaction, TextModelDiffChangeReason.other);
     }
     applyEditRelativeToOriginal(edit, transaction, group) {
         this.ensureUpToDate();

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

@@ -4,35 +4,35 @@ import { RawContextKey } from '../../../../platform/contextkey/common/contextkey
 
 const ctxIsMergeEditor = ( new RawContextKey("isMergeEditor", false, {
     type: "boolean",
-    description: ( localize(10858, "The editor is a merge editor"))
+    description: ( localize(10923, "The editor is a merge editor"))
 }));
 const ctxIsMergeResultEditor = ( new RawContextKey("isMergeResultEditor", false, {
     type: "boolean",
-    description: ( localize(10859, "The editor is a the result editor of a merge editor."))
+    description: ( localize(10924, "The editor is a the result editor of a merge editor."))
 }));
 const ctxMergeEditorLayout = ( new RawContextKey("mergeEditorLayout", "mixed", {
     type: "string",
-    description: ( localize(10860, "The layout mode of a merge editor"))
+    description: ( localize(10925, "The layout mode of a merge editor"))
 }));
 const ctxMergeEditorShowBase = ( new RawContextKey("mergeEditorShowBase", false, {
     type: "boolean",
-    description: ( localize(10861, "If the merge editor shows the base version"))
+    description: ( localize(10926, "If the merge editor shows the base version"))
 }));
 const ctxMergeEditorShowBaseAtTop = ( new RawContextKey("mergeEditorShowBaseAtTop", false, {
     type: "boolean",
-    description: ( localize(10862, "If base should be shown at the top"))
+    description: ( localize(10927, "If base should be shown at the top"))
 }));
 const ctxMergeEditorShowNonConflictingChanges = ( new RawContextKey("mergeEditorShowNonConflictingChanges", false, {
     type: "boolean",
-    description: ( localize(10863, "If the merge editor shows non-conflicting changes"))
+    description: ( localize(10928, "If the merge editor shows non-conflicting changes"))
 }));
 const ctxMergeBaseUri = ( new RawContextKey("mergeEditorBaseUri", "", {
     type: "string",
-    description: ( localize(10864, "The uri of the baser of a merge editor"))
+    description: ( localize(10929, "The uri of the baser of a merge editor"))
 }));
 const ctxMergeResultUri = ( new RawContextKey("mergeEditorResultUri", "", {
     type: "string",
-    description: ( localize(10865, "The uri of the result of a merge editor"))
+    description: ( localize(10930, "The uri of the result of a merge editor"))
 }));
 const StorageCloseWithConflicts = "mergeEditorCloseWithConflicts";
 

package/vscode/src/vs/workbench/contrib/meteredConnection/browser/meteredConnection.contribution.js

@@ -20,7 +20,7 @@ registerAction2(class ConfigureMeteredConnectionAction extends Action2 {
     constructor() {
         super({
             id: ConfigureMeteredConnectionAction.ID,
-            title: ( localize2(10866, "Configure Metered Connection")),
+            title: ( localize2(10931, "Configure Metered Connection")),
             f1: true
         });
     }
@@ -30,22 +30,22 @@ registerAction2(class ConfigureMeteredConnectionAction extends Action2 {
         const currentValue = configurationService.getValue(METERED_CONNECTION_SETTING_KEY);
         const picks = [{
             value: "auto",
-            label: ( localize(10867, "Auto")),
-            description: ( localize(10868, "Detect metered connections automatically")),
+            label: ( localize(10932, "Auto")),
+            description: ( localize(10933, "Detect metered connections automatically")),
             picked: currentValue === "auto"
         }, {
             value: "on",
-            label: ( localize(10869, "On")),
-            description: ( localize(10870, "Always treat the connection as metered")),
+            label: ( localize(10934, "On")),
+            description: ( localize(10935, "Always treat the connection as metered")),
             picked: currentValue === "on"
         }, {
             value: "off",
-            label: ( localize(10871, "Off")),
-            description: ( localize(10872, "Never treat the connection as metered")),
+            label: ( localize(10936, "Off")),
+            description: ( localize(10937, "Never treat the connection as metered")),
             picked: currentValue === "off"
         }];
         const pick = await quickInputService.pick(picks, {
-            placeHolder: ( localize(10873, "Select Metered Connection Mode")),
+            placeHolder: ( localize(10938, "Select Metered Connection Mode")),
             activeItem: picks.find(p => p.picked)
         });
         if (pick) {

package/vscode/src/vs/workbench/contrib/meteredConnection/browser/meteredConnectionStatus.js

@@ -42,16 +42,16 @@ let MeteredConnectionStatusContribution = class MeteredConnectionStatusContribut
     }
     getStatusBarEntry() {
         return {
-            name: ( localize(10874, "Metered Connection")),
+            name: ( localize(10939, "Metered Connection")),
             text: "$(radio-tower)",
-            ariaLabel: ( localize(10875, "Metered Connection Enabled")),
+            ariaLabel: ( localize(10940, "Metered Connection Enabled")),
             tooltip: ( localize(
-                10876,
+                10941,
                 "Metered connection enabled. Some automatic features like extension updates, Settings Sync, and automatic Git operations are paused to reduce data usage."
             )),
             command: {
                 id: "workbench.action.configureMeteredConnection",
-                title: ( localize(10877, "Configure"))
+                title: ( localize(10942, "Configure"))
             },
             showInAllWindows: true
         };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/icons.contribution.js

@@ -3,6 +3,6 @@ import { Codicon } from '../../../../base/common/codicons.js';
 import { localize } from '../../../../nls.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 
-const MultiDiffEditorIcon = registerIcon("multi-diff-editor-label-icon", Codicon.diffMultiple, ( localize(10883, "Icon of the multi diff editor label.")));
+const MultiDiffEditorIcon = registerIcon("multi-diff-editor-label-icon", Codicon.diffMultiple, ( localize(10948, "Icon of the multi diff editor label.")));
 
 export { MultiDiffEditorIcon };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput.js

@@ -145,11 +145,11 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
         };
         this._register(autorun(reader => {
             const resources = this.resources.read(reader);
-            const label = this.label ?? ( localize(10885, "Multi Diff Editor"));
+            const label = this.label ?? ( localize(10950, "Multi Diff Editor"));
             if (resources && resources.length === 1) {
-                this._name = ( localize(10886, "{0} (1 file)", label));
+                this._name = ( localize(10951, "{0} (1 file)", label));
             } else if (resources) {
-                this._name = ( localize(10887, "{0} ({1} files)", label, resources.length));
+                this._name = ( localize(10952, "{0} ({1} files)", label, resources.length));
             } else {
                 this._name = label;
             }

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/scmMultiDiffSourceResolver.js

@@ -213,7 +213,7 @@ class OpenScmGroupAction extends Action2 {
     constructor() {
         super({
             id: "_workbench.openScmMultiDiffEditor",
-            title: ( localize2(10888, "Open Changes")),
+            title: ( localize2(10953, "Open Changes")),
             f1: false
         });
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget.js

@@ -50,23 +50,23 @@ import { NotebookSetting, NotebookFindScopeType } from '../../../common/notebook
 import { AnchorAlignment } from '../../../../../../base/common/layout.js';
 
 registerCss(notebookFindReplaceWidget);
-const NLS_FIND_INPUT_LABEL = ( localize(10944, "Find"));
-const NLS_FIND_INPUT_PLACEHOLDER = ( localize(10945, "Find"));
-const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(10946, "Previous Match"));
-const NLS_NEXT_MATCH_BTN_LABEL = ( localize(10947, "Next Match"));
-const NLS_TOGGLE_SELECTION_FIND_TITLE = ( localize(10948, "Find in Selection"));
-const NLS_CLOSE_BTN_LABEL = ( localize(10949, "Close"));
-const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( localize(10950, "Toggle Replace"));
-const NLS_REPLACE_INPUT_LABEL = ( localize(10951, "Replace"));
-const NLS_REPLACE_INPUT_PLACEHOLDER = ( localize(10952, "Replace"));
-const NLS_REPLACE_BTN_LABEL = ( localize(10953, "Replace"));
-const NLS_REPLACE_ALL_BTN_LABEL = ( localize(10954, "Replace All"));
-registerIcon("find-filter", Codicon.filter, ( localize(10955, "Icon for Find Filter in find widget.")));
-const NOTEBOOK_FIND_FILTERS = ( localize(10956, "Find Filters"));
-const NOTEBOOK_FIND_IN_MARKUP_INPUT = ( localize(10957, "Markdown Source"));
-const NOTEBOOK_FIND_IN_MARKUP_PREVIEW = ( localize(10958, "Rendered Markdown"));
-const NOTEBOOK_FIND_IN_CODE_INPUT = ( localize(10959, "Code Cell Source"));
-const NOTEBOOK_FIND_IN_CODE_OUTPUT = ( localize(10960, "Code Cell Output"));
+const NLS_FIND_INPUT_LABEL = ( localize(11009, "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( localize(11010, "Find"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(11011, "Previous Match"));
+const NLS_NEXT_MATCH_BTN_LABEL = ( localize(11012, "Next Match"));
+const NLS_TOGGLE_SELECTION_FIND_TITLE = ( localize(11013, "Find in Selection"));
+const NLS_CLOSE_BTN_LABEL = ( localize(11014, "Close"));
+const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( localize(11015, "Toggle Replace"));
+const NLS_REPLACE_INPUT_LABEL = ( localize(11016, "Replace"));
+const NLS_REPLACE_INPUT_PLACEHOLDER = ( localize(11017, "Replace"));
+const NLS_REPLACE_BTN_LABEL = ( localize(11018, "Replace"));
+const NLS_REPLACE_ALL_BTN_LABEL = ( localize(11019, "Replace All"));
+registerIcon("find-filter", Codicon.filter, ( localize(11020, "Icon for Find Filter in find widget.")));
+const NOTEBOOK_FIND_FILTERS = ( localize(11021, "Find Filters"));
+const NOTEBOOK_FIND_IN_MARKUP_INPUT = ( localize(11022, "Markdown Source"));
+const NOTEBOOK_FIND_IN_MARKUP_PREVIEW = ( localize(11023, "Rendered Markdown"));
+const NOTEBOOK_FIND_IN_CODE_INPUT = ( localize(11024, "Code Cell Source"));
+const NOTEBOOK_FIND_IN_CODE_OUTPUT = ( localize(11025, "Code Cell Output"));
 const NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH = 419;
 const NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING = 4;
 let NotebookFindFilterActionViewItem = class NotebookFindFilterActionViewItem extends DropdownMenuActionViewItem {

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOutputActions.js

@@ -22,7 +22,7 @@ registerAction2(class ShowAllOutputsAction extends Action2 {
     constructor() {
         super({
             id: "notebook.cellOuput.showEmptyOutputs",
-            title: ( localize(11021, "Show Empty Outputs")),
+            title: ( localize(11086, "Show Empty Outputs")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_HAS_HIDDEN_OUTPUTS))
@@ -47,7 +47,7 @@ registerAction2(class CopyCellOutputAction extends Action2 {
     constructor() {
         super({
             id: COPY_OUTPUT_COMMAND_ID,
-            title: ( localize(11022, "Copy Cell Output")),
+            title: ( localize(11087, "Copy Cell Output")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: NOTEBOOK_CELL_HAS_OUTPUTS
@@ -130,7 +130,7 @@ registerAction2(class OpenCellOutputInEditorAction extends Action2 {
     constructor() {
         super({
             id: OPEN_OUTPUT_COMMAND_ID,
-            title: ( localize(11023, "Open Cell Output in Text Editor")),
+            title: ( localize(11088, "Open Cell Output in Text Editor")),
             f1: false,
             category: NOTEBOOK_ACTIONS_CATEGORY,
             icon: copyIcon
@@ -159,7 +159,7 @@ registerAction2(class SaveCellOutputImageAction extends Action2 {
     constructor() {
         super({
             id: SAVE_OUTPUT_IMAGE_COMMAND_ID,
-            title: ( localize(11024, "Save Image")),
+            title: ( localize(11089, "Save Image")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.regex(NOTEBOOK_CELL_OUTPUT_MIMETYPE.key, /^image\//))
@@ -207,7 +207,7 @@ registerAction2(class SaveCellOutputImageAction extends Action2 {
         const uri = await fileDialogService.showSaveDialog({
             defaultUri,
             filters: [{
-                name: ( localize(11025, "Image Files")),
+                name: ( localize(11090, "Image Files")),
                 extensions: [extension]
             }]
         });
@@ -228,7 +228,7 @@ registerAction2(class OpenCellOutputInNotebookOutputEditorAction extends Action2
     constructor() {
         super({
             id: OPEN_OUTPUT_IN_OUTPUT_PREVIEW_COMMAND_ID,
-            title: ( localize(11026, "Open in Output Preview")),
+            title: ( localize(11091, "Open in Output Preview")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, ( ContextKeyExpr.equals("config.notebook.output.openInPreviewEditor.enabled", true))))

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/coreActions.js

@@ -15,7 +15,7 @@ import { MarshalledId } from '../../../../../base/common/marshallingIds.js';
 import { isEqual } from '../../../../../base/common/resources.js';
 
 const SELECT_KERNEL_ID = "_notebook.selectKernel";
-const NOTEBOOK_ACTIONS_CATEGORY = ( localize2(11041, "Notebook"));
+const NOTEBOOK_ACTIONS_CATEGORY = ( localize2(11106, "Notebook"));
 const CELL_TITLE_CELL_GROUP_ID = "inline/cell";
 const CELL_TITLE_OUTPUT_GROUP_ID = "inline/output";
 const NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT = KeybindingWeight.EditorContrib;
@@ -321,18 +321,18 @@ const cellExecutionArgs = [{
 }];
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
     submenu: MenuId.NotebookCellInsert,
-    title: ( localize(11042, "Insert Cell")),
+    title: ( localize(11107, "Insert Cell")),
     group: CellOverflowToolbarGroups.Insert,
     when: ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true))
 });
 MenuRegistry.appendMenuItem(MenuId.EditorContext, {
     submenu: MenuId.NotebookCellTitle,
-    title: ( localize(11043, "Notebook Cell")),
+    title: ( localize(11108, "Notebook Cell")),
     group: CellOverflowToolbarGroups.Insert,
     when: NOTEBOOK_EDITOR_FOCUSED
 });
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
-    title: ( localize(11044, "Share")),
+    title: ( localize(11109, "Share")),
     submenu: MenuId.EditorContextShare,
     group: CellOverflowToolbarGroups.Share
 });

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/foldingController.js

@@ -128,8 +128,8 @@ class FoldingController extends Disposable {
     }
 }
 registerNotebookContribution(FoldingController.id, FoldingController);
-const NOTEBOOK_FOLD_COMMAND_LABEL = ( localize(11084, "Fold Cell"));
-const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2(11085, "Unfold Cell"));
+const NOTEBOOK_FOLD_COMMAND_LABEL = ( localize(11149, "Fold Cell"));
+const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2(11150, "Unfold Cell"));
 const FOLDING_COMMAND_ARGS = {
     args: [{
         isOptional: true,
@@ -159,7 +159,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "notebook.fold",
-            title: ( localize2(11084, "Fold Cell")),
+            title: ( localize2(11149, "Fold Cell")),
             category: NOTEBOOK_ACTIONS_CATEGORY,
             keybinding: {
                 when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookAccessibilityProvider.js

@@ -92,18 +92,18 @@ let NotebookAccessibilityProvider = class NotebookAccessibilityProvider extends
         return this.createItemLabel(executionLabel, element.cellKind);
     }
     get widgetAriaLabelName() {
-        return this.isReplHistory ? ( localize(11256, "REPL Editor History")) : ( localize(11257, "Notebook"));
+        return this.isReplHistory ? ( localize(11321, "REPL Editor History")) : ( localize(11322, "Notebook"));
     }
     getWidgetAriaLabel() {
         const keybinding = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
         if (this.configurationService.getValue(this.verbositySettingId)) {
             return keybinding ? ( localize(
-                11258,
+                11323,
                 "{0}\nUse {1} for accessibility help",
                 this.widgetAriaLabelName,
                 keybinding
             )) : ( localize(
-                11259,
+                11324,
                 "{0}\nRun the Open Accessibility Help command for more information",
                 this.widgetAriaLabelName
             ));

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookEditor.js

@@ -244,7 +244,7 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
                 const knownProvider = this._notebookService.getViewTypeProvider(input.viewType);
                 if (!knownProvider) {
                     throw ( new Error(( localize(
-                        11260,
+                        11325,
                         "Cannot open resource with notebook editor type '{0}', please check if you have the right extension installed and enabled.",
                         input.viewType
                     ))));
@@ -252,12 +252,12 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
                 await this._extensionsWorkbenchService.whenInitialized;
                 const extensionInfo = this._extensionsWorkbenchService.local.find(e => e.identifier.id === knownProvider);
                 throw createEditorOpenError(( new Error(( localize(
-                    11261,
+                    11326,
                     "Cannot open resource with notebook editor type '{0}', please check if you have the right extension installed and enabled.",
                     input.viewType
                 )))), [toAction({
                     id: "workbench.notebook.action.installOrEnableMissing",
-                    label: extensionInfo ? ( localize(11262, "Enable extension for '{0}'", input.viewType)) : ( localize(11263, "Install extension for '{0}'", input.viewType)),
+                    label: extensionInfo ? ( localize(11327, "Enable extension for '{0}'", input.viewType)) : ( localize(11328, "Install extension for '{0}'", input.viewType)),
                     run: async () => {
                         const d = this._notebookService.onAddViewType(viewType => {
                             if (viewType === input.viewType) {
@@ -284,7 +284,7 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
                     }
                 }), toAction({
                     id: "workbench.notebook.action.openAsText",
-                    label: ( localize(11264, "Open As Text")),
+                    label: ( localize(11329, "Open As Text")),
                     run: async () => {
                         const backup = await this._workingCopyBackupService.resolve({
                             resource: input.resource,
@@ -348,13 +348,13 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
                 let message;
                 if (e instanceof TooLargeFileOperationError) {
                     message = ( localize(
-                        11265,
+                        11330,
                         "The notebook is not displayed in the notebook editor because it is very large ({0}).",
                         ByteSize.formatSize(e.size)
                     ));
                 } else {
                     message = ( localize(
-                        11266,
+                        11331,
                         "The notebook is not displayed in the notebook editor because it is very large."
                     ));
                 }
@@ -362,7 +362,7 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
             }
             const error = createEditorOpenError(e instanceof Error ? e : ( new Error((e ? e.message : ""))), [toAction({
                 id: "workbench.notebook.action.openInTextEditor",
-                label: ( localize(11267, "Open in Text Editor")),
+                label: ( localize(11332, "Open in Text Editor")),
                 run: async () => {
                     const activeEditorPane = this._editorService.activeEditorPane;
                     if (!activeEditorPane) {

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookEditorWidget.js

@@ -2657,16 +2657,16 @@ let NotebookEditorWidget = class NotebookEditorWidget extends Disposable {
             if (!cell || !(cell instanceof CodeCellViewModel)) {
                 return;
             }
-            this.viewModel?.viewCells.find(cell => cell.handle === value.cellInfo.cellHandle);
             const viewIndex = this._list.getViewIndex(cell);
             if (viewIndex === undefined) {
                 return;
             }
-            if (cell.outputsViewModels.indexOf(key) < 0) {
+            const outputIndex = cell.outputsViewModels.indexOf(key);
+            if (outputIndex < 0) {
                 removedItems.push(key);
+                return;
             }
             const cellTop = this._list.getCellViewScrollTop(cell);
-            const outputIndex = cell.outputsViewModels.indexOf(key);
             const outputOffset = cell.getOutputOffset(outputIndex);
             updateItems.push({
                 cell,
@@ -2858,51 +2858,51 @@ const notebookCellBorder = registerColor("notebook.cellBorderColor", {
     light: ( transparent(listInactiveSelectionBackground, 1)),
     hcDark: PANEL_BORDER,
     hcLight: PANEL_BORDER
-}, ( localize(11268, "The border color for notebook cells.")));
-registerColor("notebook.focusedEditorBorder", focusBorder, ( localize(11269, "The color of the notebook cell editor border.")));
+}, ( localize(11333, "The border color for notebook cells.")));
+registerColor("notebook.focusedEditorBorder", focusBorder, ( localize(11334, "The color of the notebook cell editor border.")));
 const cellStatusIconSuccess = registerColor(
     "notebookStatusSuccessIcon.foreground",
     debugIconStartForeground,
-    ( localize(11270, "The error icon color of notebook cells in the cell status bar."))
+    ( localize(11335, "The error icon color of notebook cells in the cell status bar."))
 );
 const runningCellRulerDecorationColor = registerColor(
     "notebookEditorOverviewRuler.runningCellForeground",
     debugIconStartForeground,
     ( localize(
-    11271,
+    11336,
     "The color of the running cell decoration in the notebook editor overview ruler."
 ))
 );
-const cellStatusIconError = registerColor("notebookStatusErrorIcon.foreground", errorForeground, ( localize(11272, "The error icon color of notebook cells in the cell status bar.")));
-registerColor("notebookStatusRunningIcon.foreground", foreground, ( localize(11273, "The running icon color of notebook cells in the cell status bar.")));
-registerColor("notebook.outputContainerBorderColor", null, ( localize(11274, "The border color of the notebook output container.")));
-registerColor("notebook.outputContainerBackgroundColor", null, ( localize(11275, "The color of the notebook output container background.")));
+const cellStatusIconError = registerColor("notebookStatusErrorIcon.foreground", errorForeground, ( localize(11337, "The error icon color of notebook cells in the cell status bar.")));
+registerColor("notebookStatusRunningIcon.foreground", foreground, ( localize(11338, "The running icon color of notebook cells in the cell status bar.")));
+registerColor("notebook.outputContainerBorderColor", null, ( localize(11339, "The border color of the notebook output container.")));
+registerColor("notebook.outputContainerBackgroundColor", null, ( localize(11340, "The color of the notebook output container background.")));
 registerColor("notebook.cellToolbarSeparator", {
     dark: ( ( Color.fromHex("#808080")).transparent(0.35)),
     light: ( ( Color.fromHex("#808080")).transparent(0.35)),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(11276, "The color of the separator in the cell bottom toolbar")));
-const focusedCellBackground = registerColor("notebook.focusedCellBackground", null, ( localize(11277, "The background color of a cell when the cell is focused.")));
+}, ( localize(11341, "The color of the separator in the cell bottom toolbar")));
+const focusedCellBackground = registerColor("notebook.focusedCellBackground", null, ( localize(11342, "The background color of a cell when the cell is focused.")));
 registerColor("notebook.selectedCellBackground", {
     dark: listInactiveSelectionBackground,
     light: listInactiveSelectionBackground,
     hcDark: null,
     hcLight: null
-}, ( localize(11278, "The background color of a cell when the cell is selected.")));
+}, ( localize(11343, "The background color of a cell when the cell is selected.")));
 registerColor("notebook.cellHoverBackground", {
     dark: ( transparent(focusedCellBackground, .5)),
     light: ( transparent(focusedCellBackground, .7)),
     hcDark: null,
     hcLight: null
-}, ( localize(11279, "The background color of a cell when the cell is hovered.")));
+}, ( localize(11344, "The background color of a cell when the cell is hovered.")));
 registerColor("notebook.selectedCellBorder", {
     dark: notebookCellBorder,
     light: notebookCellBorder,
     hcDark: contrastBorder,
     hcLight: contrastBorder
 }, ( localize(
-    11280,
+    11345,
     "The color of the cell's top and bottom border when the cell is selected but not focused."
 )));
 registerColor("notebook.inactiveSelectedCellBorder", {
@@ -2910,13 +2910,13 @@ registerColor("notebook.inactiveSelectedCellBorder", {
     light: null,
     hcDark: focusBorder,
     hcLight: focusBorder
-}, ( localize(11281, "The color of the cell's borders when multiple cells are selected.")));
+}, ( localize(11346, "The color of the cell's borders when multiple cells are selected.")));
 registerColor("notebook.focusedCellBorder", focusBorder, ( localize(
-    11282,
+    11347,
     "The color of the cell's focus indicator borders when the cell is focused."
 )));
 registerColor("notebook.inactiveFocusedCellBorder", notebookCellBorder, ( localize(
-    11283,
+    11348,
     "The color of the cell's top and bottom border when a cell is focused while the primary focus is outside of the editor."
 )));
 registerColor("notebook.cellStatusBarItemHoverBackground", {
@@ -2924,40 +2924,40 @@ registerColor("notebook.cellStatusBarItemHoverBackground", {
     dark: ( new Color(( new RGBA(255, 255, 255, 0.15)))),
     hcDark: ( new Color(( new RGBA(255, 255, 255, 0.15)))),
     hcLight: ( new Color(( new RGBA(0, 0, 0, 0.08))))
-}, ( localize(11284, "The background color of notebook cell status bar items.")));
-registerColor("notebook.cellInsertionIndicator", focusBorder, ( localize(11285, "The color of the notebook cell insertion indicator.")));
+}, ( localize(11349, "The background color of notebook cell status bar items.")));
+registerColor("notebook.cellInsertionIndicator", focusBorder, ( localize(11350, "The color of the notebook cell insertion indicator.")));
 registerColor(
     "notebookScrollbarSlider.background",
     scrollbarSliderBackground,
-    ( localize(11286, "Notebook scrollbar slider background color."))
+    ( localize(11351, "Notebook scrollbar slider background color."))
 );
 registerColor(
     "notebookScrollbarSlider.hoverBackground",
     scrollbarSliderHoverBackground,
-    ( localize(11287, "Notebook scrollbar slider background color when hovering."))
+    ( localize(11352, "Notebook scrollbar slider background color when hovering."))
 );
 registerColor(
     "notebookScrollbarSlider.activeBackground",
     scrollbarSliderActiveBackground,
-    ( localize(11288, "Notebook scrollbar slider background color when clicked on."))
+    ( localize(11353, "Notebook scrollbar slider background color when clicked on."))
 );
 registerColor("notebook.symbolHighlightBackground", {
     dark: ( Color.fromHex("#ffffff0b")),
     light: ( Color.fromHex("#fdff0033")),
     hcDark: null,
     hcLight: null
-}, ( localize(11289, "Background color of highlighted cell")));
+}, ( localize(11354, "Background color of highlighted cell")));
 registerColor("notebook.cellEditorBackground", {
     light: SIDE_BAR_BACKGROUND,
     dark: SIDE_BAR_BACKGROUND,
     hcDark: null,
     hcLight: null
-}, ( localize(11290, "Cell editor background color.")));
+}, ( localize(11355, "Cell editor background color.")));
 const notebookEditorBackground = registerColor("notebook.editorBackground", {
     light: EDITOR_PANE_BACKGROUND,
     dark: EDITOR_PANE_BACKGROUND,
     hcDark: null,
     hcLight: null
-}, ( localize(11291, "Notebook background color.")));
+}, ( localize(11356, "Notebook background color.")));
 
 export { NotebookEditorWidget, cellStatusIconError, cellStatusIconSuccess, focusedCellBackground, getDefaultNotebookCreationOptions, notebookCellBorder, runningCellRulerDecorationColor };