monaco-editor-core 0.55.0-dev-20251014 → 0.55.0-dev-20251016

package/esm/vs/editor/browser/widget/diffEditor/features/movedBlocksLinesFeature.js

@@ -244,10 +244,10 @@ class MovedBlockOverlayWidget extends ViewZoneOverlayWidget {
         }));
         let text;
         if (_move.changes.length > 0) {
-            text = this._kind === 'original' ? localize(128, 'Code moved with changes to line {0}-{1}', this._move.lineRangeMapping.modified.startLineNumber, this._move.lineRangeMapping.modified.endLineNumberExclusive - 1) : localize(129, 'Code moved with changes from line {0}-{1}', this._move.lineRangeMapping.original.startLineNumber, this._move.lineRangeMapping.original.endLineNumberExclusive - 1);
+            text = this._kind === 'original' ? localize(129, 'Code moved with changes to line {0}-{1}', this._move.lineRangeMapping.modified.startLineNumber, this._move.lineRangeMapping.modified.endLineNumberExclusive - 1) : localize(130, 'Code moved with changes from line {0}-{1}', this._move.lineRangeMapping.original.startLineNumber, this._move.lineRangeMapping.original.endLineNumberExclusive - 1);
         }
         else {
-            text = this._kind === 'original' ? localize(130, 'Code moved to line {0}-{1}', this._move.lineRangeMapping.modified.startLineNumber, this._move.lineRangeMapping.modified.endLineNumberExclusive - 1) : localize(131, 'Code moved from line {0}-{1}', this._move.lineRangeMapping.original.startLineNumber, this._move.lineRangeMapping.original.endLineNumberExclusive - 1);
+            text = this._kind === 'original' ? localize(131, 'Code moved to line {0}-{1}', this._move.lineRangeMapping.modified.startLineNumber, this._move.lineRangeMapping.modified.endLineNumberExclusive - 1) : localize(132, 'Code moved from line {0}-{1}', this._move.lineRangeMapping.original.startLineNumber, this._move.lineRangeMapping.original.endLineNumberExclusive - 1);
         }
         const actionBar = this._register(new ActionBar(this._nodes.actionBar, {
             highlightToggledItems: true,

package/esm/vs/editor/browser/widget/diffEditor/features/revertButtonsFeature.js

@@ -95,8 +95,8 @@ export class RevertButton extends Disposable {
         this._id = `revertButton${RevertButton.counter++}`;
         this._domNode = h('div.revertButton', {
             title: this._revertSelection
-                ? localize(132, 'Revert Selected Changes')
-                : localize(133, 'Revert Change')
+                ? localize(133, 'Revert Selected Changes')
+                : localize(134, 'Revert Change')
         }, [renderIcon(Codicon.arrowRight)]).root;
         this._register(addDisposableListener(this._domNode, EventType.MOUSE_DOWN, e => {
             // don't prevent context menu from showing up

package/esm/vs/editor/browser/widget/diffEditor/registrations.contribution.js

@@ -8,11 +8,11 @@ import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { localize } from '../../../../nls.js';
 import { registerColor } from '../../../../platform/theme/common/colorRegistry.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
-export const diffMoveBorder = registerColor('diffEditor.move.border', '#8b8b8b9c', localize(134, 'The border color for text that got moved in the diff editor.'));
-export const diffMoveBorderActive = registerColor('diffEditor.moveActive.border', '#FFA500', localize(135, 'The active border color for text that got moved in the diff editor.'));
-export const diffEditorUnchangedRegionShadow = registerColor('diffEditor.unchangedRegionShadow', { dark: '#000000', light: '#737373BF', hcDark: '#000000', hcLight: '#737373BF', }, localize(136, 'The color of the shadow around unchanged region widgets.'));
-export const diffInsertIcon = registerIcon('diff-insert', Codicon.add, localize(137, 'Line decoration for inserts in the diff editor.'));
-export const diffRemoveIcon = registerIcon('diff-remove', Codicon.remove, localize(138, 'Line decoration for removals in the diff editor.'));
+export const diffMoveBorder = registerColor('diffEditor.move.border', '#8b8b8b9c', localize(135, 'The border color for text that got moved in the diff editor.'));
+export const diffMoveBorderActive = registerColor('diffEditor.moveActive.border', '#FFA500', localize(136, 'The active border color for text that got moved in the diff editor.'));
+export const diffEditorUnchangedRegionShadow = registerColor('diffEditor.unchangedRegionShadow', { dark: '#000000', light: '#737373BF', hcDark: '#000000', hcLight: '#737373BF', }, localize(137, 'The color of the shadow around unchanged region widgets.'));
+export const diffInsertIcon = registerIcon('diff-insert', Codicon.add, localize(138, 'Line decoration for inserts in the diff editor.'));
+export const diffRemoveIcon = registerIcon('diff-remove', Codicon.remove, localize(139, 'Line decoration for removals in the diff editor.'));
 export const diffLineAddDecorationBackgroundWithIndicator = ModelDecorationOptions.register({
     className: 'line-insert',
     description: 'line-insert',

package/esm/vs/editor/browser/widget/diffEditor/style.css

@@ -426,3 +426,14 @@
 		margin: 0 4px;
 	}
 }
+
+.monaco-editor .line-delete-selectable {
+	user-select: text !important;
+	-webkit-user-select: text !important;
+	z-index: 1 !important;
+}
+
+.line-delete-selectable .view-line {
+	user-select: text !important;
+	-webkit-user-select: text !important;
+}

package/esm/vs/editor/browser/widget/multiDiffEditor/colors.js

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 import { localize } from '../../../../nls.js';
 import { registerColor, editorBackground } from '../../../../platform/theme/common/colorRegistry.js';
-export const multiDiffEditorHeaderBackground = registerColor('multiDiffEditor.headerBackground', { dark: '#262626', light: 'tab.inactiveBackground', hcDark: 'tab.inactiveBackground', hcLight: 'tab.inactiveBackground', }, localize(139, 'The background color of the diff editor\'s header'));
-export const multiDiffEditorBackground = registerColor('multiDiffEditor.background', editorBackground, localize(140, 'The background color of the multi file diff editor'));
-export const multiDiffEditorBorder = registerColor('multiDiffEditor.border', { dark: 'sideBarSectionHeader.border', light: '#cccccc', hcDark: 'sideBarSectionHeader.border', hcLight: '#cccccc', }, localize(141, 'The border color of the multi file diff editor'));
+export const multiDiffEditorHeaderBackground = registerColor('multiDiffEditor.headerBackground', { dark: '#262626', light: 'tab.inactiveBackground', hcDark: 'tab.inactiveBackground', hcLight: 'tab.inactiveBackground', }, localize(140, 'The background color of the diff editor\'s header'));
+export const multiDiffEditorBackground = registerColor('multiDiffEditor.background', editorBackground, localize(141, 'The background color of the multi file diff editor'));
+export const multiDiffEditorBorder = registerColor('multiDiffEditor.border', { dark: 'sideBarSectionHeader.border', light: '#cccccc', hcDark: 'sideBarSectionHeader.border', hcLight: '#cccccc', }, localize(142, 'The border color of the multi file diff editor'));
 //# sourceMappingURL=colors.js.map

package/esm/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidgetImpl.js

@@ -135,8 +135,8 @@ let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposab
             }
             const vm = this._viewModel.read(reader);
             return (!vm || vm.isLoading.read(reader))
-                ? localize(142, 'Loading...')
-                : localize(143, 'No Changed Files');
+                ? localize(143, 'Loading...')
+                : localize(144, 'No Changed Files');
         });
         this._register(autorun((reader) => {
             const message = placeholderMessage.read(reader);

package/esm/vs/editor/common/config/editorConfigurationSchema.js

@@ -8,7 +8,7 @@ export const editorConfigurationBaseNode = Object.freeze({
     id: 'editor',
     order: 5,
     type: 'object',
-    title: nls.localize(144, "Editor"),
+    title: nls.localize(145, "Editor"),
     scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
 });
 const editorConfiguration = {
@@ -19,7 +19,7 @@ const editorConfiguration = {
             default: EDITOR_MODEL_DEFAULTS.tabSize,
             minimum: 1,
             maximum: 100,
-            markdownDescription: nls.localize(145, "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
+            markdownDescription: nls.localize(146, "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
         },
         'editor.indentSize': {
             'anyOf': [
@@ -33,80 +33,80 @@ const editorConfiguration = {
                 }
             ],
             default: 'tabSize',
-            markdownDescription: nls.localize(146, "The number of spaces used for indentation or `\"tabSize\"` to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
+            markdownDescription: nls.localize(147, "The number of spaces used for indentation or `\"tabSize\"` to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
         },
         'editor.insertSpaces': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.insertSpaces,
-            markdownDescription: nls.localize(147, "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
+            markdownDescription: nls.localize(148, "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
         },
         'editor.detectIndentation': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.detectIndentation,
-            markdownDescription: nls.localize(148, "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.", '`#editor.tabSize#`', '`#editor.insertSpaces#`')
+            markdownDescription: nls.localize(149, "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.", '`#editor.tabSize#`', '`#editor.insertSpaces#`')
         },
         'editor.trimAutoWhitespace': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
-            description: nls.localize(149, "Remove trailing auto inserted whitespace.")
+            description: nls.localize(150, "Remove trailing auto inserted whitespace.")
         },
         'editor.largeFileOptimizations': {
             type: 'boolean',
             default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
-            description: nls.localize(150, "Special handling for large files to disable certain memory intensive features.")
+            description: nls.localize(151, "Special handling for large files to disable certain memory intensive features.")
         },
         'editor.wordBasedSuggestions': {
             enum: ['off', 'currentDocument', 'matchingDocuments', 'allDocuments'],
             default: 'matchingDocuments',
             enumDescriptions: [
-                nls.localize(151, 'Turn off Word Based Suggestions.'),
-                nls.localize(152, 'Only suggest words from the active document.'),
-                nls.localize(153, 'Suggest words from all open documents of the same language.'),
-                nls.localize(154, 'Suggest words from all open documents.')
+                nls.localize(152, 'Turn off Word Based Suggestions.'),
+                nls.localize(153, 'Only suggest words from the active document.'),
+                nls.localize(154, 'Suggest words from all open documents of the same language.'),
+                nls.localize(155, 'Suggest words from all open documents.')
             ],
-            description: nls.localize(155, "Controls whether completions should be computed based on words in the document and from which documents they are computed.")
+            description: nls.localize(156, "Controls whether completions should be computed based on words in the document and from which documents they are computed.")
         },
         'editor.semanticHighlighting.enabled': {
             enum: [true, false, 'configuredByTheme'],
             enumDescriptions: [
-                nls.localize(156, 'Semantic highlighting enabled for all color themes.'),
-                nls.localize(157, 'Semantic highlighting disabled for all color themes.'),
-                nls.localize(158, 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
+                nls.localize(157, 'Semantic highlighting enabled for all color themes.'),
+                nls.localize(158, 'Semantic highlighting disabled for all color themes.'),
+                nls.localize(159, 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
             ],
             default: 'configuredByTheme',
-            description: nls.localize(159, "Controls whether the semanticHighlighting is shown for the languages that support it.")
+            description: nls.localize(160, "Controls whether the semanticHighlighting is shown for the languages that support it.")
         },
         'editor.stablePeek': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(160, "Keep peek editors open even when double-clicking their content or when hitting `Escape`.")
+            markdownDescription: nls.localize(161, "Keep peek editors open even when double-clicking their content or when hitting `Escape`.")
         },
         'editor.maxTokenizationLineLength': {
             type: 'integer',
             default: 20_000,
-            description: nls.localize(161, "Lines above this length will not be tokenized for performance reasons")
+            description: nls.localize(162, "Lines above this length will not be tokenized for performance reasons")
         },
         'editor.experimental.asyncTokenization': {
             type: 'boolean',
             default: true,
-            description: nls.localize(162, "Controls whether the tokenization should happen asynchronously on a web worker."),
+            description: nls.localize(163, "Controls whether the tokenization should happen asynchronously on a web worker."),
             tags: ['experimental'],
         },
         'editor.experimental.asyncTokenizationLogging': {
             type: 'boolean',
             default: false,
-            description: nls.localize(163, "Controls whether async tokenization should be logged. For debugging only."),
+            description: nls.localize(164, "Controls whether async tokenization should be logged. For debugging only."),
         },
         'editor.experimental.asyncTokenizationVerification': {
             type: 'boolean',
             default: false,
-            description: nls.localize(164, "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."),
+            description: nls.localize(165, "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."),
             tags: ['experimental'],
         },
         'editor.experimental.treeSitterTelemetry': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(165, "Controls whether tree sitter parsing should be turned on and telemetry collected. Setting `#editor.experimental.preferTreeSitter#` for specific languages will take precedence."),
+            markdownDescription: nls.localize(166, "Controls whether tree sitter parsing should be turned on and telemetry collected. Setting `#editor.experimental.preferTreeSitter#` for specific languages will take precedence."),
             tags: ['experimental'],
             experiment: {
                 mode: 'auto'
@@ -115,7 +115,7 @@ const editorConfiguration = {
         'editor.experimental.preferTreeSitter.css': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(166, "Controls whether tree sitter parsing should be turned on for css. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for css."),
+            markdownDescription: nls.localize(167, "Controls whether tree sitter parsing should be turned on for css. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for css."),
             tags: ['experimental'],
             experiment: {
                 mode: 'auto'
@@ -124,7 +124,7 @@ const editorConfiguration = {
         'editor.experimental.preferTreeSitter.typescript': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(167, "Controls whether tree sitter parsing should be turned on for typescript. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for typescript."),
+            markdownDescription: nls.localize(168, "Controls whether tree sitter parsing should be turned on for typescript. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for typescript."),
             tags: ['experimental'],
             experiment: {
                 mode: 'auto'
@@ -133,7 +133,7 @@ const editorConfiguration = {
         'editor.experimental.preferTreeSitter.ini': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(168, "Controls whether tree sitter parsing should be turned on for ini. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for ini."),
+            markdownDescription: nls.localize(169, "Controls whether tree sitter parsing should be turned on for ini. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for ini."),
             tags: ['experimental'],
             experiment: {
                 mode: 'auto'
@@ -142,7 +142,7 @@ const editorConfiguration = {
         'editor.experimental.preferTreeSitter.regex': {
             type: 'boolean',
             default: false,
-            markdownDescription: nls.localize(169, "Controls whether tree sitter parsing should be turned on for regex. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for regex."),
+            markdownDescription: nls.localize(170, "Controls whether tree sitter parsing should be turned on for regex. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for regex."),
             tags: ['experimental'],
             experiment: {
                 mode: 'auto'
@@ -151,17 +151,17 @@ const editorConfiguration = {
         'editor.language.brackets': {
             type: ['array', 'null'],
             default: null, // We want to distinguish the empty array from not configured.
-            description: nls.localize(170, 'Defines the bracket symbols that increase or decrease the indentation.'),
+            description: nls.localize(171, 'Defines the bracket symbols that increase or decrease the indentation.'),
             items: {
                 type: 'array',
                 items: [
                     {
                         type: 'string',
-                        description: nls.localize(171, 'The opening bracket character or string sequence.')
+                        description: nls.localize(172, 'The opening bracket character or string sequence.')
                     },
                     {
                         type: 'string',
-                        description: nls.localize(172, 'The closing bracket character or string sequence.')
+                        description: nls.localize(173, 'The closing bracket character or string sequence.')
                     }
                 ]
             }
@@ -169,17 +169,17 @@ const editorConfiguration = {
         'editor.language.colorizedBracketPairs': {
             type: ['array', 'null'],
             default: null, // We want to distinguish the empty array from not configured.
-            description: nls.localize(173, 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
+            description: nls.localize(174, 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
             items: {
                 type: 'array',
                 items: [
                     {
                         type: 'string',
-                        description: nls.localize(174, 'The opening bracket character or string sequence.')
+                        description: nls.localize(175, 'The opening bracket character or string sequence.')
                     },
                     {
                         type: 'string',
-                        description: nls.localize(175, 'The closing bracket character or string sequence.')
+                        description: nls.localize(176, 'The closing bracket character or string sequence.')
                     }
                 ]
             }
@@ -187,61 +187,61 @@ const editorConfiguration = {
         'diffEditor.maxComputationTime': {
             type: 'number',
             default: diffEditorDefaultOptions.maxComputationTime,
-            description: nls.localize(176, "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
+            description: nls.localize(177, "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
         },
         'diffEditor.maxFileSize': {
             type: 'number',
             default: diffEditorDefaultOptions.maxFileSize,
-            description: nls.localize(177, "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
+            description: nls.localize(178, "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
         },
         'diffEditor.renderSideBySide': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderSideBySide,
-            description: nls.localize(178, "Controls whether the diff editor shows the diff side by side or inline.")
+            description: nls.localize(179, "Controls whether the diff editor shows the diff side by side or inline.")
         },
         'diffEditor.renderSideBySideInlineBreakpoint': {
             type: 'number',
             default: diffEditorDefaultOptions.renderSideBySideInlineBreakpoint,
-            description: nls.localize(179, "If the diff editor width is smaller than this value, the inline view is used.")
+            description: nls.localize(180, "If the diff editor width is smaller than this value, the inline view is used.")
         },
         'diffEditor.useInlineViewWhenSpaceIsLimited': {
             type: 'boolean',
             default: diffEditorDefaultOptions.useInlineViewWhenSpaceIsLimited,
-            description: nls.localize(180, "If enabled and the editor width is too small, the inline view is used.")
+            description: nls.localize(181, "If enabled and the editor width is too small, the inline view is used.")
         },
         'diffEditor.renderMarginRevertIcon': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderMarginRevertIcon,
-            description: nls.localize(181, "When enabled, the diff editor shows arrows in its glyph margin to revert changes.")
+            description: nls.localize(182, "When enabled, the diff editor shows arrows in its glyph margin to revert changes.")
         },
         'diffEditor.renderGutterMenu': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderGutterMenu,
-            description: nls.localize(182, "When enabled, the diff editor shows a special gutter for revert and stage actions.")
+            description: nls.localize(183, "When enabled, the diff editor shows a special gutter for revert and stage actions.")
         },
         'diffEditor.ignoreTrimWhitespace': {
             type: 'boolean',
             default: diffEditorDefaultOptions.ignoreTrimWhitespace,
-            description: nls.localize(183, "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
+            description: nls.localize(184, "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
         },
         'diffEditor.renderIndicators': {
             type: 'boolean',
             default: diffEditorDefaultOptions.renderIndicators,
-            description: nls.localize(184, "Controls whether the diff editor shows +/- indicators for added/removed changes.")
+            description: nls.localize(185, "Controls whether the diff editor shows +/- indicators for added/removed changes.")
         },
         'diffEditor.codeLens': {
             type: 'boolean',
             default: diffEditorDefaultOptions.diffCodeLens,
-            description: nls.localize(185, "Controls whether the editor shows CodeLens.")
+            description: nls.localize(186, "Controls whether the editor shows CodeLens.")
         },
         'diffEditor.wordWrap': {
             type: 'string',
             enum: ['off', 'on', 'inherit'],
             default: diffEditorDefaultOptions.diffWordWrap,
             markdownEnumDescriptions: [
-                nls.localize(186, "Lines will never wrap."),
-                nls.localize(187, "Lines will wrap at the viewport width."),
-                nls.localize(188, "Lines will wrap according to the {0} setting.", '`#editor.wordWrap#`'),
+                nls.localize(187, "Lines will never wrap."),
+                nls.localize(188, "Lines will wrap at the viewport width."),
+                nls.localize(189, "Lines will wrap according to the {0} setting.", '`#editor.wordWrap#`'),
             ]
         },
         'diffEditor.diffAlgorithm': {
@@ -249,47 +249,47 @@ const editorConfiguration = {
             enum: ['legacy', 'advanced'],
             default: diffEditorDefaultOptions.diffAlgorithm,
             markdownEnumDescriptions: [
-                nls.localize(189, "Uses the legacy diffing algorithm."),
-                nls.localize(190, "Uses the advanced diffing algorithm."),
+                nls.localize(190, "Uses the legacy diffing algorithm."),
+                nls.localize(191, "Uses the advanced diffing algorithm."),
             ]
         },
         'diffEditor.hideUnchangedRegions.enabled': {
             type: 'boolean',
             default: diffEditorDefaultOptions.hideUnchangedRegions.enabled,
-            markdownDescription: nls.localize(191, "Controls whether the diff editor shows unchanged regions."),
+            markdownDescription: nls.localize(192, "Controls whether the diff editor shows unchanged regions."),
         },
         'diffEditor.hideUnchangedRegions.revealLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.revealLineCount,
-            markdownDescription: nls.localize(192, "Controls how many lines are used for unchanged regions."),
+            markdownDescription: nls.localize(193, "Controls how many lines are used for unchanged regions."),
             minimum: 1,
         },
         'diffEditor.hideUnchangedRegions.minimumLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.minimumLineCount,
-            markdownDescription: nls.localize(193, "Controls how many lines are used as a minimum for unchanged regions."),
+            markdownDescription: nls.localize(194, "Controls how many lines are used as a minimum for unchanged regions."),
             minimum: 1,
         },
         'diffEditor.hideUnchangedRegions.contextLineCount': {
             type: 'integer',
             default: diffEditorDefaultOptions.hideUnchangedRegions.contextLineCount,
-            markdownDescription: nls.localize(194, "Controls how many lines are used as context when comparing unchanged regions."),
+            markdownDescription: nls.localize(195, "Controls how many lines are used as context when comparing unchanged regions."),
             minimum: 1,
         },
         'diffEditor.experimental.showMoves': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showMoves,
-            markdownDescription: nls.localize(195, "Controls whether the diff editor should show detected code moves.")
+            markdownDescription: nls.localize(196, "Controls whether the diff editor should show detected code moves.")
         },
         'diffEditor.experimental.showEmptyDecorations': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.showEmptyDecorations,
-            description: nls.localize(196, "Controls whether the diff editor shows empty decorations to see where characters got inserted or deleted."),
+            description: nls.localize(197, "Controls whether the diff editor shows empty decorations to see where characters got inserted or deleted."),
         },
         'diffEditor.experimental.useTrueInlineView': {
             type: 'boolean',
             default: diffEditorDefaultOptions.experimental.useTrueInlineView,
-            description: nls.localize(197, "If enabled and the editor uses the inline view, word changes are rendered inline."),
+            description: nls.localize(198, "If enabled and the editor uses the inline view, word changes are rendered inline."),
         },
     }
 };