monaco-editor-core 0.54.0-dev-20250910 → 0.54.0-dev-20250912

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

@@ -426,7 +426,7 @@ export function cursorStyleFromString(cursorStyle) {
 //#region editorClassName
 class EditorClassName extends ComputedEditorOption {
     constructor() {
-        super(161 /* EditorOption.editorClassName */);
+        super(162 /* EditorOption.editorClassName */);
     }
     compute(env, options, _) {
         const classNames = ['monaco-editor'];
@@ -442,10 +442,10 @@ class EditorClassName extends ComputedEditorOption {
         else if (options.get(82 /* EditorOption.mouseStyle */) === 'copy') {
             classNames.push('mouse-copy');
         }
-        if (options.get(126 /* EditorOption.showUnused */)) {
+        if (options.get(127 /* EditorOption.showUnused */)) {
             classNames.push('showUnused');
         }
-        if (options.get(156 /* EditorOption.showDeprecated */)) {
+        if (options.get(157 /* EditorOption.showDeprecated */)) {
             classNames.push('showDeprecated');
         }
         return classNames.join(' ');
@@ -674,11 +674,11 @@ class EditorFontInfo extends ComputedEditorOption {
 //#region effectiveCursorStyle
 class EffectiveCursorStyle extends ComputedEditorOption {
     constructor() {
-        super(160 /* EditorOption.effectiveCursorStyle */);
+        super(161 /* EditorOption.effectiveCursorStyle */);
     }
     compute(env, options, _) {
         return env.inputMode === 'overtype' ?
-            options.get(91 /* EditorOption.overtypeCursorStyle */) :
+            options.get(92 /* EditorOption.overtypeCursorStyle */) :
             options.get(34 /* EditorOption.cursorStyle */);
     }
 }
@@ -686,7 +686,7 @@ class EffectiveCursorStyle extends ComputedEditorOption {
 //#region effectiveExperimentalEditContext
 class EffectiveEditContextEnabled extends ComputedEditorOption {
     constructor() {
-        super(169 /* EditorOption.effectiveEditContext */);
+        super(170 /* EditorOption.effectiveEditContext */);
     }
     compute(env, options) {
         return env.editContextSupported && options.get(44 /* EditorOption.editContext */);
@@ -696,7 +696,7 @@ class EffectiveEditContextEnabled extends ComputedEditorOption {
 //#region effectiveAllowVariableFonts
 class EffectiveAllowVariableFonts extends ComputedEditorOption {
     constructor() {
-        super(171 /* EditorOption.effectiveAllowVariableFonts */);
+        super(172 /* EditorOption.effectiveAllowVariableFonts */);
     }
     compute(env, options) {
         const accessibilitySupport = env.accessibilitySupport;
@@ -932,7 +932,7 @@ class EditorHover extends BaseEditorOption {
  */
 export class EditorLayoutInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(164 /* EditorOption.layoutInfo */);
+        super(165 /* EditorOption.layoutInfo */);
     }
     compute(env, options, _) {
         return EditorLayoutInfoComputer.computeLayout(options, {
@@ -1131,24 +1131,24 @@ export class EditorLayoutInfoComputer extends ComputedEditorOption {
         const maxDigitWidth = env.maxDigitWidth;
         const pixelRatio = env.pixelRatio;
         const viewLineCount = env.viewLineCount;
-        const wordWrapOverride2 = options.get(153 /* EditorOption.wordWrapOverride2 */);
-        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(152 /* EditorOption.wordWrapOverride1 */) : wordWrapOverride2);
-        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(148 /* EditorOption.wordWrap */) : wordWrapOverride1);
-        const wordWrapColumn = options.get(151 /* EditorOption.wordWrapColumn */);
+        const wordWrapOverride2 = options.get(154 /* EditorOption.wordWrapOverride2 */);
+        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(153 /* EditorOption.wordWrapOverride1 */) : wordWrapOverride2);
+        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(149 /* EditorOption.wordWrap */) : wordWrapOverride1);
+        const wordWrapColumn = options.get(152 /* EditorOption.wordWrapColumn */);
         const isDominatedByLongLines = env.isDominatedByLongLines;
         const showGlyphMargin = options.get(66 /* EditorOption.glyphMargin */);
         const showLineNumbers = (options.get(76 /* EditorOption.lineNumbers */).renderType !== 0 /* RenderLineNumbersType.Off */);
         const lineNumbersMinChars = options.get(77 /* EditorOption.lineNumbersMinChars */);
-        const scrollBeyondLastLine = options.get(118 /* EditorOption.scrollBeyondLastLine */);
-        const padding = options.get(95 /* EditorOption.padding */);
+        const scrollBeyondLastLine = options.get(119 /* EditorOption.scrollBeyondLastLine */);
+        const padding = options.get(96 /* EditorOption.padding */);
         const minimap = options.get(81 /* EditorOption.minimap */);
-        const scrollbar = options.get(116 /* EditorOption.scrollbar */);
+        const scrollbar = options.get(117 /* EditorOption.scrollbar */);
         const verticalScrollbarWidth = scrollbar.verticalScrollbarSize;
         const verticalScrollbarHasArrows = scrollbar.verticalHasArrows;
         const scrollbarArrowSize = scrollbar.arrowSize;
         const horizontalScrollbarHeight = scrollbar.horizontalScrollbarSize;
         const folding = options.get(52 /* EditorOption.folding */);
-        const showFoldingDecoration = options.get(125 /* EditorOption.showFoldingControls */) !== 'never';
+        const showFoldingDecoration = options.get(126 /* EditorOption.showFoldingControls */) !== 'never';
         let lineDecorationsWidth = options.get(74 /* EditorOption.lineDecorationsWidth */);
         if (folding && showFoldingDecoration) {
             lineDecorationsWidth += 16;
@@ -1246,7 +1246,7 @@ export class EditorLayoutInfoComputer extends ComputedEditorOption {
 //#region WrappingStrategy
 class WrappingStrategy extends BaseEditorOption {
     constructor() {
-        super(155 /* EditorOption.wrappingStrategy */, 'wrappingStrategy', 'simple', {
+        super(156 /* EditorOption.wrappingStrategy */, 'wrappingStrategy', 'simple', {
             'editor.wrappingStrategy': {
                 enumDescriptions: [
                     nls.localize(252, "Assumes that all characters are of the same width. This is a fast algorithm that works correctly for monospace fonts and certain scripts (like Latin characters) where glyphs are of equal width."),
@@ -1310,7 +1310,7 @@ class EditorLightbulb extends BaseEditorOption {
 class EditorStickyScroll extends BaseEditorOption {
     constructor() {
         const defaults = { enabled: true, maxLineCount: 5, defaultModel: 'outlineModel', scrollWithEditor: true };
-        super(130 /* EditorOption.stickyScroll */, 'stickyScroll', defaults, {
+        super(131 /* EditorOption.stickyScroll */, 'stickyScroll', defaults, {
             'editor.stickyScroll.enabled': {
                 type: 'boolean',
                 default: defaults.enabled,
@@ -1352,7 +1352,7 @@ class EditorStickyScroll extends BaseEditorOption {
 class EditorInlayHints extends BaseEditorOption {
     constructor() {
         const defaults = { enabled: 'on', fontSize: 0, fontFamily: '', padding: false, maximumLength: 43 };
-        super(158 /* EditorOption.inlayHints */, 'inlayHints', defaults, {
+        super(159 /* EditorOption.inlayHints */, 'inlayHints', defaults, {
             'editor.inlayHints.enabled': {
                 type: 'string',
                 default: defaults.enabled,
@@ -1586,7 +1586,7 @@ function _multiCursorModifierFromString(multiCursorModifier) {
 }
 class EditorPadding extends BaseEditorOption {
     constructor() {
-        super(95 /* EditorOption.padding */, 'padding', { top: 0, bottom: 0 }, {
+        super(96 /* EditorOption.padding */, 'padding', { top: 0, bottom: 0 }, {
             'editor.padding.top': {
                 type: 'number',
                 default: 0,
@@ -1620,7 +1620,7 @@ class EditorParameterHints extends BaseEditorOption {
             enabled: true,
             cycle: true
         };
-        super(97 /* EditorOption.parameterHints */, 'parameterHints', defaults, {
+        super(98 /* EditorOption.parameterHints */, 'parameterHints', defaults, {
             'editor.parameterHints.enabled': {
                 type: 'boolean',
                 default: defaults.enabled,
@@ -1648,7 +1648,7 @@ class EditorParameterHints extends BaseEditorOption {
 //#region pixelRatio
 class EditorPixelRatio extends ComputedEditorOption {
     constructor() {
-        super(162 /* EditorOption.pixelRatio */);
+        super(163 /* EditorOption.pixelRatio */);
     }
     compute(env, options, _) {
         return env.pixelRatio;
@@ -1658,7 +1658,7 @@ class EditorPixelRatio extends ComputedEditorOption {
 //#region
 class PlaceholderOption extends BaseEditorOption {
     constructor() {
-        super(99 /* EditorOption.placeholder */, 'placeholder', undefined);
+        super(100 /* EditorOption.placeholder */, 'placeholder', undefined);
     }
     validate(input) {
         if (typeof input === 'undefined') {
@@ -1685,7 +1685,7 @@ class EditorQuickSuggestions extends BaseEditorOption {
                 enumDescriptions: [nls.localize(296, "Quick suggestions show inside the suggest widget"), nls.localize(297, "Quick suggestions show as ghost text"), nls.localize(298, "Quick suggestions are disabled")]
             }
         ];
-        super(101 /* EditorOption.quickSuggestions */, 'quickSuggestions', defaults, {
+        super(102 /* EditorOption.quickSuggestions */, 'quickSuggestions', defaults, {
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -1798,9 +1798,9 @@ class EditorRenderLineNumbersOption extends BaseEditorOption {
  * @internal
  */
 export function filterValidationDecorations(options) {
-    const renderValidationDecorations = options.get(111 /* EditorOption.renderValidationDecorations */);
+    const renderValidationDecorations = options.get(112 /* EditorOption.renderValidationDecorations */);
     if (renderValidationDecorations === 'editable') {
-        return options.get(103 /* EditorOption.readOnly */);
+        return options.get(104 /* EditorOption.readOnly */);
     }
     return renderValidationDecorations === 'on' ? false : true;
 }
@@ -1810,13 +1810,13 @@ export function filterValidationDecorations(options) {
  * @internal
  */
 export function filterFontDecorations(options) {
-    return !options.get(171 /* EditorOption.effectiveAllowVariableFonts */);
+    return !options.get(172 /* EditorOption.effectiveAllowVariableFonts */);
 }
 class EditorRulers extends BaseEditorOption {
     constructor() {
         const defaults = [];
         const columnSchema = { type: 'number', description: nls.localize(308, "Number of monospace characters at which this editor ruler will render.") };
-        super(115 /* EditorOption.rulers */, 'rulers', defaults, {
+        super(116 /* EditorOption.rulers */, 'rulers', defaults, {
             type: 'array',
             items: {
                 anyOf: [
@@ -1872,7 +1872,7 @@ class EditorRulers extends BaseEditorOption {
 class ReadonlyMessage extends BaseEditorOption {
     constructor() {
         const defaults = undefined;
-        super(104 /* EditorOption.readOnlyMessage */, 'readOnlyMessage', defaults);
+        super(105 /* EditorOption.readOnlyMessage */, 'readOnlyMessage', defaults);
     }
     validate(_input) {
         if (!_input || typeof _input !== 'object') {
@@ -1909,7 +1909,7 @@ class EditorScrollbar extends BaseEditorOption {
             scrollByPage: false,
             ignoreHorizontalScrollbarInContentHeight: false,
         };
-        super(116 /* EditorOption.scrollbar */, 'scrollbar', defaults, {
+        super(117 /* EditorOption.scrollbar */, 'scrollbar', defaults, {
             'editor.scrollbar.vertical': {
                 type: 'string',
                 enum: ['auto', 'visible', 'hidden'],
@@ -2006,7 +2006,7 @@ class UnicodeHighlight extends BaseEditorOption {
             allowedCharacters: {},
             allowedLocales: { _os: true, _vscode: true },
         };
-        super(141 /* EditorOption.unicodeHighlighting */, 'unicodeHighlight', defaults, {
+        super(142 /* EditorOption.unicodeHighlighting */, 'unicodeHighlight', defaults, {
             [unicodeHighlightConfigKeys.nonBasicASCII]: {
                 restricted: true,
                 type: ['boolean', 'string'],
@@ -2413,7 +2413,7 @@ class EditorSuggest extends BaseEditorOption {
             showUsers: true,
             showIssues: true,
         };
-        super(133 /* EditorOption.suggest */, 'suggest', defaults, {
+        super(134 /* EditorOption.suggest */, 'suggest', defaults, {
             'editor.suggest.insertMode': {
                 type: 'string',
                 enum: ['insert', 'replace'],
@@ -2687,7 +2687,7 @@ class EditorSuggest extends BaseEditorOption {
 }
 class SmartSelect extends BaseEditorOption {
     constructor() {
-        super(128 /* EditorOption.smartSelect */, 'smartSelect', {
+        super(129 /* EditorOption.smartSelect */, 'smartSelect', {
             selectLeadingAndTrailingWhitespace: true,
             selectSubwords: true,
         }, {
@@ -2723,7 +2723,7 @@ class SmartSelect extends BaseEditorOption {
 class WordSegmenterLocales extends BaseEditorOption {
     constructor() {
         const defaults = [];
-        super(146 /* EditorOption.wordSegmenterLocales */, 'wordSegmenterLocales', defaults, {
+        super(147 /* EditorOption.wordSegmenterLocales */, 'wordSegmenterLocales', defaults, {
             anyOf: [
                 {
                     type: 'string',
@@ -2767,7 +2767,7 @@ class WordSegmenterLocales extends BaseEditorOption {
 }
 class WrappingIndentOption extends BaseEditorOption {
     constructor() {
-        super(154 /* EditorOption.wrappingIndent */, 'wrappingIndent', 1 /* WrappingIndent.Same */, {
+        super(155 /* EditorOption.wrappingIndent */, 'wrappingIndent', 1 /* WrappingIndent.Same */, {
             'editor.wrappingIndent': {
                 type: 'string',
                 enum: ['none', 'same', 'indent', 'deepIndent'],
@@ -2803,10 +2803,10 @@ class WrappingIndentOption extends BaseEditorOption {
 }
 class EditorWrappingInfoComputer extends ComputedEditorOption {
     constructor() {
-        super(165 /* EditorOption.wrappingInfo */);
+        super(166 /* EditorOption.wrappingInfo */);
     }
     compute(env, options, _) {
-        const layoutInfo = options.get(164 /* EditorOption.layoutInfo */);
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
         return {
             isDominatedByLongLines: env.isDominatedByLongLines,
             isWordWrapMinified: layoutInfo.isWordWrapMinified,
@@ -2853,7 +2853,7 @@ class EditorDropIntoEditor extends BaseEditorOption {
 class EditorPasteAs extends BaseEditorOption {
     constructor() {
         const defaults = { enabled: true, showPasteSelector: 'afterPaste' };
-        super(96 /* EditorOption.pasteAs */, 'pasteAs', defaults, {
+        super(97 /* EditorOption.pasteAs */, 'pasteAs', defaults, {
             'editor.pasteAs.enabled': {
                 type: 'boolean',
                 default: defaults.enabled,
@@ -3006,7 +3006,7 @@ export const EditorOptions = {
     })),
     bracketPairColorization: register(new BracketPairColorization()),
     bracketPairGuides: register(new GuideOptions()),
-    stickyTabStops: register(new EditorBooleanOption(131 /* EditorOption.stickyTabStops */, 'stickyTabStops', false, { description: nls.localize(461, "Emulate selection behavior of tab characters when using spaces for indentation. Selection will stick to tab stops.") })),
+    stickyTabStops: register(new EditorBooleanOption(132 /* EditorOption.stickyTabStops */, 'stickyTabStops', false, { description: nls.localize(461, "Emulate selection behavior of tab characters when using spaces for indentation. Selection will stick to tab stops.") })),
     codeLens: register(new EditorBooleanOption(23 /* EditorOption.codeLens */, 'codeLens', true, { description: nls.localize(462, "Controls whether the editor shows CodeLens.") })),
     codeLensFontFamily: register(new EditorStringOption(24 /* EditorOption.codeLensFontFamily */, 'codeLensFontFamily', '', { description: nls.localize(463, "Controls the font family for CodeLens.") })),
     codeLensFontSize: register(new EditorIntOption(25 /* EditorOption.codeLensFontSize */, 'codeLensFontSize', 0, 0, 100, {
@@ -3017,7 +3017,7 @@ export const EditorOptions = {
         markdownDescription: nls.localize(464, "Controls the font size in pixels for CodeLens. When set to 0, 90% of `#editor.fontSize#` is used.")
     })),
     colorDecorators: register(new EditorBooleanOption(26 /* EditorOption.colorDecorators */, 'colorDecorators', true, { description: nls.localize(465, "Controls whether the editor should render the inline color decorators and color picker.") })),
-    colorDecoratorActivatedOn: register(new EditorStringEnumOption(167 /* EditorOption.colorDecoratorsActivatedOn */, 'colorDecoratorsActivatedOn', 'clickAndHover', ['clickAndHover', 'hover', 'click'], {
+    colorDecoratorActivatedOn: register(new EditorStringEnumOption(168 /* EditorOption.colorDecoratorsActivatedOn */, 'colorDecoratorsActivatedOn', 'clickAndHover', ['clickAndHover', 'hover', 'click'], {
         enumDescriptions: [
             nls.localize(466, "Make the color picker appear both on click and hover of the color decorator"),
             nls.localize(467, "Make the color picker appear on hover of the color decorator"),
@@ -3042,7 +3042,7 @@ export const EditorOptions = {
         description: nls.localize(477, "Controls whether the smooth caret animation should be enabled.")
     })),
     cursorStyle: register(new EditorEnumOption(34 /* EditorOption.cursorStyle */, 'cursorStyle', TextEditorCursorStyle.Line, 'line', ['line', 'block', 'underline', 'line-thin', 'block-outline', 'underline-thin'], cursorStyleFromString, { description: nls.localize(478, "Controls the cursor style in insert input mode.") })),
-    overtypeCursorStyle: register(new EditorEnumOption(91 /* EditorOption.overtypeCursorStyle */, 'overtypeCursorStyle', TextEditorCursorStyle.Block, 'block', ['line', 'block', 'underline', 'line-thin', 'block-outline', 'underline-thin'], cursorStyleFromString, { description: nls.localize(479, "Controls the cursor style in overtype input mode.") })),
+    overtypeCursorStyle: register(new EditorEnumOption(92 /* EditorOption.overtypeCursorStyle */, 'overtypeCursorStyle', TextEditorCursorStyle.Block, 'block', ['line', 'block', 'underline', 'line-thin', 'block-outline', 'underline-thin'], cursorStyleFromString, { description: nls.localize(479, "Controls the cursor style in overtype input mode.") })),
     cursorSurroundingLines: register(new EditorIntOption(35 /* EditorOption.cursorSurroundingLines */, 'cursorSurroundingLines', 0, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, { description: nls.localize(480, "Controls the minimal number of visible leading lines (minimum 0) and trailing lines (minimum 1) surrounding the cursor. Known as 'scrollOff' or 'scrollOffset' in some other editors.") })),
     cursorSurroundingLinesStyle: register(new EditorStringEnumOption(36 /* EditorOption.cursorSurroundingLinesStyle */, 'cursorSurroundingLinesStyle', 'default', ['default', 'all'], {
         enumDescriptions: [
@@ -3063,7 +3063,7 @@ export const EditorOptions = {
         description: nls.localize(487, "Sets whether the EditContext API should be used instead of the text area to power input in the editor."),
         included: platform.isChrome || platform.isEdge || platform.isNative
     })),
-    renderRichScreenReaderContent: register(new EditorBooleanOption(106 /* EditorOption.renderRichScreenReaderContent */, 'renderRichScreenReaderContent', false, {
+    renderRichScreenReaderContent: register(new EditorBooleanOption(107 /* EditorOption.renderRichScreenReaderContent */, 'renderRichScreenReaderContent', false, {
         markdownDescription: nls.localize(488, "Whether to render rich screen reader content when the `#editor.editContext#` setting is enabled."),
     })),
     stickyScroll: register(new EditorStickyScroll()),
@@ -3113,7 +3113,7 @@ export const EditorOptions = {
     hideCursorInOverviewRuler: register(new EditorBooleanOption(68 /* EditorOption.hideCursorInOverviewRuler */, 'hideCursorInOverviewRuler', false, { description: nls.localize(509, "Controls whether the cursor should be hidden in the overview ruler.") })),
     hover: register(new EditorHover()),
     inDiffEditor: register(new EditorBooleanOption(70 /* EditorOption.inDiffEditor */, 'inDiffEditor', false)),
-    inertialScroll: register(new EditorBooleanOption(157 /* EditorOption.inertialScroll */, 'inertialScroll', false, { description: nls.localize(510, "Make scrolling inertial - mostly useful with touchpad on linux.") })),
+    inertialScroll: register(new EditorBooleanOption(158 /* EditorOption.inertialScroll */, 'inertialScroll', false, { description: nls.localize(510, "Make scrolling inertial - mostly useful with touchpad on linux.") })),
     letterSpacing: register(new EditorFloatOption(72 /* EditorOption.letterSpacing */, 'letterSpacing', EDITOR_FONT_DEFAULTS.letterSpacing, x => EditorFloatOption.clamp(x, -5, 20), { description: nls.localize(511, "Controls the letter spacing in pixels.") })),
     lightbulb: register(new EditorLightbulb()),
     lineDecorationsWidth: register(new EditorLineDecorationsWidth()),
@@ -3145,170 +3145,171 @@ export const EditorOptions = {
 
 
     })),
-    multiCursorPaste: register(new EditorStringEnumOption(87 /* EditorOption.multiCursorPaste */, 'multiCursorPaste', 'spread', ['spread', 'full'], {
+    mouseMiddleClickAction: register(new EditorStringEnumOption(87 /* EditorOption.mouseMiddleClickAction */, 'mouseMiddleClickAction', 'default', ['default', 'openLink', 'ctrlLeftClick'], { description: nls.localize(522, "Controls what happens when middle mouse button is clicked in the editor.") })),
+    multiCursorPaste: register(new EditorStringEnumOption(88 /* EditorOption.multiCursorPaste */, 'multiCursorPaste', 'spread', ['spread', 'full'], {
         markdownEnumDescriptions: [
-            nls.localize(522, "Each cursor pastes a single line of the text."),
-            nls.localize(523, "Each cursor pastes the full text.")
+            nls.localize(523, "Each cursor pastes a single line of the text."),
+            nls.localize(524, "Each cursor pastes the full text.")
         ],
-        markdownDescription: nls.localize(524, "Controls pasting when the line count of the pasted text matches the cursor count.")
+        markdownDescription: nls.localize(525, "Controls pasting when the line count of the pasted text matches the cursor count.")
     })),
-    multiCursorLimit: register(new EditorIntOption(88 /* EditorOption.multiCursorLimit */, 'multiCursorLimit', 10000, 1, 100000, {
-        markdownDescription: nls.localize(525, "Controls the max number of cursors that can be in an active editor at once.")
+    multiCursorLimit: register(new EditorIntOption(89 /* EditorOption.multiCursorLimit */, 'multiCursorLimit', 10000, 1, 100000, {
+        markdownDescription: nls.localize(526, "Controls the max number of cursors that can be in an active editor at once.")
     })),
-    occurrencesHighlight: register(new EditorStringEnumOption(89 /* EditorOption.occurrencesHighlight */, 'occurrencesHighlight', 'singleFile', ['off', 'singleFile', 'multiFile'], {
+    occurrencesHighlight: register(new EditorStringEnumOption(90 /* EditorOption.occurrencesHighlight */, 'occurrencesHighlight', 'singleFile', ['off', 'singleFile', 'multiFile'], {
         markdownEnumDescriptions: [
-            nls.localize(526, "Does not highlight occurrences."),
-            nls.localize(527, "Highlights occurrences only in the current file."),
-            nls.localize(528, "Experimental: Highlights occurrences across all valid open files.")
+            nls.localize(527, "Does not highlight occurrences."),
+            nls.localize(528, "Highlights occurrences only in the current file."),
+            nls.localize(529, "Experimental: Highlights occurrences across all valid open files.")
         ],
-        markdownDescription: nls.localize(529, "Controls whether occurrences should be highlighted across open files.")
+        markdownDescription: nls.localize(530, "Controls whether occurrences should be highlighted across open files.")
     })),
-    occurrencesHighlightDelay: register(new EditorIntOption(90 /* EditorOption.occurrencesHighlightDelay */, 'occurrencesHighlightDelay', 0, 0, 2000, {
-        description: nls.localize(530, "Controls the delay in milliseconds after which occurrences are highlighted."),
+    occurrencesHighlightDelay: register(new EditorIntOption(91 /* EditorOption.occurrencesHighlightDelay */, 'occurrencesHighlightDelay', 0, 0, 2000, {
+        description: nls.localize(531, "Controls the delay in milliseconds after which occurrences are highlighted."),
         tags: ['preview']
     })),
-    overtypeOnPaste: register(new EditorBooleanOption(92 /* EditorOption.overtypeOnPaste */, 'overtypeOnPaste', true, { description: nls.localize(531, "Controls whether pasting should overtype.") })),
-    overviewRulerBorder: register(new EditorBooleanOption(93 /* EditorOption.overviewRulerBorder */, 'overviewRulerBorder', true, { description: nls.localize(532, "Controls whether a border should be drawn around the overview ruler.") })),
-    overviewRulerLanes: register(new EditorIntOption(94 /* EditorOption.overviewRulerLanes */, 'overviewRulerLanes', 3, 0, 3)),
+    overtypeOnPaste: register(new EditorBooleanOption(93 /* EditorOption.overtypeOnPaste */, 'overtypeOnPaste', true, { description: nls.localize(532, "Controls whether pasting should overtype.") })),
+    overviewRulerBorder: register(new EditorBooleanOption(94 /* EditorOption.overviewRulerBorder */, 'overviewRulerBorder', true, { description: nls.localize(533, "Controls whether a border should be drawn around the overview ruler.") })),
+    overviewRulerLanes: register(new EditorIntOption(95 /* EditorOption.overviewRulerLanes */, 'overviewRulerLanes', 3, 0, 3)),
     padding: register(new EditorPadding()),
     pasteAs: register(new EditorPasteAs()),
     parameterHints: register(new EditorParameterHints()),
-    peekWidgetDefaultFocus: register(new EditorStringEnumOption(98 /* EditorOption.peekWidgetDefaultFocus */, 'peekWidgetDefaultFocus', 'tree', ['tree', 'editor'], {
+    peekWidgetDefaultFocus: register(new EditorStringEnumOption(99 /* EditorOption.peekWidgetDefaultFocus */, 'peekWidgetDefaultFocus', 'tree', ['tree', 'editor'], {
         enumDescriptions: [
-            nls.localize(533, "Focus the tree when opening peek"),
-            nls.localize(534, "Focus the editor when opening peek")
+            nls.localize(534, "Focus the tree when opening peek"),
+            nls.localize(535, "Focus the editor when opening peek")
         ],
-        description: nls.localize(535, "Controls whether to focus the inline editor or the tree in the peek widget.")
+        description: nls.localize(536, "Controls whether to focus the inline editor or the tree in the peek widget.")
     })),
     placeholder: register(new PlaceholderOption()),
-    definitionLinkOpensInPeek: register(new EditorBooleanOption(100 /* EditorOption.definitionLinkOpensInPeek */, 'definitionLinkOpensInPeek', false, { description: nls.localize(536, "Controls whether the Go to Definition mouse gesture always opens the peek widget.") })),
+    definitionLinkOpensInPeek: register(new EditorBooleanOption(101 /* EditorOption.definitionLinkOpensInPeek */, 'definitionLinkOpensInPeek', false, { description: nls.localize(537, "Controls whether the Go to Definition mouse gesture always opens the peek widget.") })),
     quickSuggestions: register(new EditorQuickSuggestions()),
-    quickSuggestionsDelay: register(new EditorIntOption(102 /* EditorOption.quickSuggestionsDelay */, 'quickSuggestionsDelay', 10, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, {
-        description: nls.localize(537, "Controls the delay in milliseconds after which quick suggestions will show up."),
+    quickSuggestionsDelay: register(new EditorIntOption(103 /* EditorOption.quickSuggestionsDelay */, 'quickSuggestionsDelay', 10, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, {
+        description: nls.localize(538, "Controls the delay in milliseconds after which quick suggestions will show up."),
         experiment: {
             mode: 'auto'
         }
     })),
-    readOnly: register(new EditorBooleanOption(103 /* EditorOption.readOnly */, 'readOnly', false)),
+    readOnly: register(new EditorBooleanOption(104 /* EditorOption.readOnly */, 'readOnly', false)),
     readOnlyMessage: register(new ReadonlyMessage()),
-    renameOnType: register(new EditorBooleanOption(105 /* EditorOption.renameOnType */, 'renameOnType', false, { description: nls.localize(538, "Controls whether the editor auto renames on type."), markdownDeprecationMessage: nls.localize(539, "Deprecated, use `#editor.linkedEditing#` instead.") })),
-    renderControlCharacters: register(new EditorBooleanOption(107 /* EditorOption.renderControlCharacters */, 'renderControlCharacters', true, { description: nls.localize(540, "Controls whether the editor should render control characters."), restricted: true })),
-    renderFinalNewline: register(new EditorStringEnumOption(108 /* EditorOption.renderFinalNewline */, 'renderFinalNewline', (platform.isLinux ? 'dimmed' : 'on'), ['off', 'on', 'dimmed'], { description: nls.localize(541, "Render last line number when the file ends with a newline.") })),
-    renderLineHighlight: register(new EditorStringEnumOption(109 /* EditorOption.renderLineHighlight */, 'renderLineHighlight', 'line', ['none', 'gutter', 'line', 'all'], {
+    renameOnType: register(new EditorBooleanOption(106 /* EditorOption.renameOnType */, 'renameOnType', false, { description: nls.localize(539, "Controls whether the editor auto renames on type."), markdownDeprecationMessage: nls.localize(540, "Deprecated, use `#editor.linkedEditing#` instead.") })),
+    renderControlCharacters: register(new EditorBooleanOption(108 /* EditorOption.renderControlCharacters */, 'renderControlCharacters', true, { description: nls.localize(541, "Controls whether the editor should render control characters."), restricted: true })),
+    renderFinalNewline: register(new EditorStringEnumOption(109 /* EditorOption.renderFinalNewline */, 'renderFinalNewline', (platform.isLinux ? 'dimmed' : 'on'), ['off', 'on', 'dimmed'], { description: nls.localize(542, "Render last line number when the file ends with a newline.") })),
+    renderLineHighlight: register(new EditorStringEnumOption(110 /* EditorOption.renderLineHighlight */, 'renderLineHighlight', 'line', ['none', 'gutter', 'line', 'all'], {
         enumDescriptions: [
             '',
             '',
             '',
-            nls.localize(542, "Highlights both the gutter and the current line."),
+            nls.localize(543, "Highlights both the gutter and the current line."),
         ],
-        description: nls.localize(543, "Controls how the editor should render the current line highlight.")
+        description: nls.localize(544, "Controls how the editor should render the current line highlight.")
     })),
-    renderLineHighlightOnlyWhenFocus: register(new EditorBooleanOption(110 /* EditorOption.renderLineHighlightOnlyWhenFocus */, 'renderLineHighlightOnlyWhenFocus', false, { description: nls.localize(544, "Controls if the editor should render the current line highlight only when the editor is focused.") })),
-    renderValidationDecorations: register(new EditorStringEnumOption(111 /* EditorOption.renderValidationDecorations */, 'renderValidationDecorations', 'editable', ['editable', 'on', 'off'])),
-    renderWhitespace: register(new EditorStringEnumOption(112 /* EditorOption.renderWhitespace */, 'renderWhitespace', 'selection', ['none', 'boundary', 'selection', 'trailing', 'all'], {
+    renderLineHighlightOnlyWhenFocus: register(new EditorBooleanOption(111 /* EditorOption.renderLineHighlightOnlyWhenFocus */, 'renderLineHighlightOnlyWhenFocus', false, { description: nls.localize(545, "Controls if the editor should render the current line highlight only when the editor is focused.") })),
+    renderValidationDecorations: register(new EditorStringEnumOption(112 /* EditorOption.renderValidationDecorations */, 'renderValidationDecorations', 'editable', ['editable', 'on', 'off'])),
+    renderWhitespace: register(new EditorStringEnumOption(113 /* EditorOption.renderWhitespace */, 'renderWhitespace', 'selection', ['none', 'boundary', 'selection', 'trailing', 'all'], {
         enumDescriptions: [
             '',
-            nls.localize(545, "Render whitespace characters except for single spaces between words."),
-            nls.localize(546, "Render whitespace characters only on selected text."),
-            nls.localize(547, "Render only trailing whitespace characters."),
+            nls.localize(546, "Render whitespace characters except for single spaces between words."),
+            nls.localize(547, "Render whitespace characters only on selected text."),
+            nls.localize(548, "Render only trailing whitespace characters."),
             ''
         ],
-        description: nls.localize(548, "Controls how the editor should render whitespace characters.")
+        description: nls.localize(549, "Controls how the editor should render whitespace characters.")
     })),
-    revealHorizontalRightPadding: register(new EditorIntOption(113 /* EditorOption.revealHorizontalRightPadding */, 'revealHorizontalRightPadding', 15, 0, 1000)),
-    roundedSelection: register(new EditorBooleanOption(114 /* EditorOption.roundedSelection */, 'roundedSelection', true, { description: nls.localize(549, "Controls whether selections should have rounded corners.") })),
+    revealHorizontalRightPadding: register(new EditorIntOption(114 /* EditorOption.revealHorizontalRightPadding */, 'revealHorizontalRightPadding', 15, 0, 1000)),
+    roundedSelection: register(new EditorBooleanOption(115 /* EditorOption.roundedSelection */, 'roundedSelection', true, { description: nls.localize(550, "Controls whether selections should have rounded corners.") })),
     rulers: register(new EditorRulers()),
     scrollbar: register(new EditorScrollbar()),
-    scrollBeyondLastColumn: register(new EditorIntOption(117 /* EditorOption.scrollBeyondLastColumn */, 'scrollBeyondLastColumn', 4, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, { description: nls.localize(550, "Controls the number of extra characters beyond which the editor will scroll horizontally.") })),
-    scrollBeyondLastLine: register(new EditorBooleanOption(118 /* EditorOption.scrollBeyondLastLine */, 'scrollBeyondLastLine', true, { description: nls.localize(551, "Controls whether the editor will scroll beyond the last line.") })),
-    scrollOnMiddleClick: register(new EditorBooleanOption(170 /* EditorOption.scrollOnMiddleClick */, 'scrollOnMiddleClick', false, { description: nls.localize(552, "Controls whether the editor will scroll when the middle button is pressed.") })),
-    scrollPredominantAxis: register(new EditorBooleanOption(119 /* EditorOption.scrollPredominantAxis */, 'scrollPredominantAxis', true, { description: nls.localize(553, "Scroll only along the predominant axis when scrolling both vertically and horizontally at the same time. Prevents horizontal drift when scrolling vertically on a trackpad.") })),
-    selectionClipboard: register(new EditorBooleanOption(120 /* EditorOption.selectionClipboard */, 'selectionClipboard', true, {
-        description: nls.localize(554, "Controls whether the Linux primary clipboard should be supported."),
+    scrollBeyondLastColumn: register(new EditorIntOption(118 /* EditorOption.scrollBeyondLastColumn */, 'scrollBeyondLastColumn', 4, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, { description: nls.localize(551, "Controls the number of extra characters beyond which the editor will scroll horizontally.") })),
+    scrollBeyondLastLine: register(new EditorBooleanOption(119 /* EditorOption.scrollBeyondLastLine */, 'scrollBeyondLastLine', true, { description: nls.localize(552, "Controls whether the editor will scroll beyond the last line.") })),
+    scrollOnMiddleClick: register(new EditorBooleanOption(171 /* EditorOption.scrollOnMiddleClick */, 'scrollOnMiddleClick', false, { description: nls.localize(553, "Controls whether the editor will scroll when the middle button is pressed.") })),
+    scrollPredominantAxis: register(new EditorBooleanOption(120 /* EditorOption.scrollPredominantAxis */, 'scrollPredominantAxis', true, { description: nls.localize(554, "Scroll only along the predominant axis when scrolling both vertically and horizontally at the same time. Prevents horizontal drift when scrolling vertically on a trackpad.") })),
+    selectionClipboard: register(new EditorBooleanOption(121 /* EditorOption.selectionClipboard */, 'selectionClipboard', true, {
+        description: nls.localize(555, "Controls whether the Linux primary clipboard should be supported."),
         included: platform.isLinux
     })),
-    selectionHighlight: register(new EditorBooleanOption(121 /* EditorOption.selectionHighlight */, 'selectionHighlight', true, { description: nls.localize(555, "Controls whether the editor should highlight matches similar to the selection.") })),
-    selectionHighlightMaxLength: register(new EditorIntOption(122 /* EditorOption.selectionHighlightMaxLength */, 'selectionHighlightMaxLength', 200, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, { description: nls.localize(556, "Controls how many characters can be in the selection before similiar matches are not highlighted. Set to zero for unlimited.") })),
-    selectionHighlightMultiline: register(new EditorBooleanOption(123 /* EditorOption.selectionHighlightMultiline */, 'selectionHighlightMultiline', false, { description: nls.localize(557, "Controls whether the editor should highlight selection matches that span multiple lines.") })),
-    selectOnLineNumbers: register(new EditorBooleanOption(124 /* EditorOption.selectOnLineNumbers */, 'selectOnLineNumbers', true)),
-    showFoldingControls: register(new EditorStringEnumOption(125 /* EditorOption.showFoldingControls */, 'showFoldingControls', 'mouseover', ['always', 'never', 'mouseover'], {
+    selectionHighlight: register(new EditorBooleanOption(122 /* EditorOption.selectionHighlight */, 'selectionHighlight', true, { description: nls.localize(556, "Controls whether the editor should highlight matches similar to the selection.") })),
+    selectionHighlightMaxLength: register(new EditorIntOption(123 /* EditorOption.selectionHighlightMaxLength */, 'selectionHighlightMaxLength', 200, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, { description: nls.localize(557, "Controls how many characters can be in the selection before similiar matches are not highlighted. Set to zero for unlimited.") })),
+    selectionHighlightMultiline: register(new EditorBooleanOption(124 /* EditorOption.selectionHighlightMultiline */, 'selectionHighlightMultiline', false, { description: nls.localize(558, "Controls whether the editor should highlight selection matches that span multiple lines.") })),
+    selectOnLineNumbers: register(new EditorBooleanOption(125 /* EditorOption.selectOnLineNumbers */, 'selectOnLineNumbers', true)),
+    showFoldingControls: register(new EditorStringEnumOption(126 /* EditorOption.showFoldingControls */, 'showFoldingControls', 'mouseover', ['always', 'never', 'mouseover'], {
         enumDescriptions: [
-            nls.localize(558, "Always show the folding controls."),
-            nls.localize(559, "Never show the folding controls and reduce the gutter size."),
-            nls.localize(560, "Only show the folding controls when the mouse is over the gutter."),
+            nls.localize(559, "Always show the folding controls."),
+            nls.localize(560, "Never show the folding controls and reduce the gutter size."),
+            nls.localize(561, "Only show the folding controls when the mouse is over the gutter."),
         ],
-        description: nls.localize(561, "Controls when the folding controls on the gutter are shown.")
+        description: nls.localize(562, "Controls when the folding controls on the gutter are shown.")
     })),
-    showUnused: register(new EditorBooleanOption(126 /* EditorOption.showUnused */, 'showUnused', true, { description: nls.localize(562, "Controls fading out of unused code.") })),
-    showDeprecated: register(new EditorBooleanOption(156 /* EditorOption.showDeprecated */, 'showDeprecated', true, { description: nls.localize(563, "Controls strikethrough deprecated variables.") })),
+    showUnused: register(new EditorBooleanOption(127 /* EditorOption.showUnused */, 'showUnused', true, { description: nls.localize(563, "Controls fading out of unused code.") })),
+    showDeprecated: register(new EditorBooleanOption(157 /* EditorOption.showDeprecated */, 'showDeprecated', true, { description: nls.localize(564, "Controls strikethrough deprecated variables.") })),
     inlayHints: register(new EditorInlayHints()),
-    snippetSuggestions: register(new EditorStringEnumOption(127 /* EditorOption.snippetSuggestions */, 'snippetSuggestions', 'inline', ['top', 'bottom', 'inline', 'none'], {
+    snippetSuggestions: register(new EditorStringEnumOption(128 /* EditorOption.snippetSuggestions */, 'snippetSuggestions', 'inline', ['top', 'bottom', 'inline', 'none'], {
         enumDescriptions: [
-            nls.localize(564, "Show snippet suggestions on top of other suggestions."),
-            nls.localize(565, "Show snippet suggestions below other suggestions."),
-            nls.localize(566, "Show snippets suggestions with other suggestions."),
-            nls.localize(567, "Do not show snippet suggestions."),
+            nls.localize(565, "Show snippet suggestions on top of other suggestions."),
+            nls.localize(566, "Show snippet suggestions below other suggestions."),
+            nls.localize(567, "Show snippets suggestions with other suggestions."),
+            nls.localize(568, "Do not show snippet suggestions."),
         ],
-        description: nls.localize(568, "Controls whether snippets are shown with other suggestions and how they are sorted.")
+        description: nls.localize(569, "Controls whether snippets are shown with other suggestions and how they are sorted.")
     })),
     smartSelect: register(new SmartSelect()),
-    smoothScrolling: register(new EditorBooleanOption(129 /* EditorOption.smoothScrolling */, 'smoothScrolling', false, { description: nls.localize(569, "Controls whether the editor will scroll using an animation.") })),
-    stopRenderingLineAfter: register(new EditorIntOption(132 /* EditorOption.stopRenderingLineAfter */, 'stopRenderingLineAfter', 10000, -1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */)),
+    smoothScrolling: register(new EditorBooleanOption(130 /* EditorOption.smoothScrolling */, 'smoothScrolling', false, { description: nls.localize(570, "Controls whether the editor will scroll using an animation.") })),
+    stopRenderingLineAfter: register(new EditorIntOption(133 /* EditorOption.stopRenderingLineAfter */, 'stopRenderingLineAfter', 10000, -1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */)),
     suggest: register(new EditorSuggest()),
     inlineSuggest: register(new InlineEditorSuggest()),
-    inlineCompletionsAccessibilityVerbose: register(new EditorBooleanOption(168 /* EditorOption.inlineCompletionsAccessibilityVerbose */, 'inlineCompletionsAccessibilityVerbose', false, { description: nls.localize(570, "Controls whether the accessibility hint should be provided to screen reader users when an inline completion is shown.") })),
-    suggestFontSize: register(new EditorIntOption(134 /* EditorOption.suggestFontSize */, 'suggestFontSize', 0, 0, 1000, { markdownDescription: nls.localize(571, "Font size for the suggest widget. When set to {0}, the value of {1} is used.", '`0`', '`#editor.fontSize#`') })),
-    suggestLineHeight: register(new EditorIntOption(135 /* EditorOption.suggestLineHeight */, 'suggestLineHeight', 0, 0, 1000, { markdownDescription: nls.localize(572, "Line height for the suggest widget. When set to {0}, the value of {1} is used. The minimum value is 8.", '`0`', '`#editor.lineHeight#`') })),
-    suggestOnTriggerCharacters: register(new EditorBooleanOption(136 /* EditorOption.suggestOnTriggerCharacters */, 'suggestOnTriggerCharacters', true, { description: nls.localize(573, "Controls whether suggestions should automatically show up when typing trigger characters.") })),
-    suggestSelection: register(new EditorStringEnumOption(137 /* EditorOption.suggestSelection */, 'suggestSelection', 'first', ['first', 'recentlyUsed', 'recentlyUsedByPrefix'], {
+    inlineCompletionsAccessibilityVerbose: register(new EditorBooleanOption(169 /* EditorOption.inlineCompletionsAccessibilityVerbose */, 'inlineCompletionsAccessibilityVerbose', false, { description: nls.localize(571, "Controls whether the accessibility hint should be provided to screen reader users when an inline completion is shown.") })),
+    suggestFontSize: register(new EditorIntOption(135 /* EditorOption.suggestFontSize */, 'suggestFontSize', 0, 0, 1000, { markdownDescription: nls.localize(572, "Font size for the suggest widget. When set to {0}, the value of {1} is used.", '`0`', '`#editor.fontSize#`') })),
+    suggestLineHeight: register(new EditorIntOption(136 /* EditorOption.suggestLineHeight */, 'suggestLineHeight', 0, 0, 1000, { markdownDescription: nls.localize(573, "Line height for the suggest widget. When set to {0}, the value of {1} is used. The minimum value is 8.", '`0`', '`#editor.lineHeight#`') })),
+    suggestOnTriggerCharacters: register(new EditorBooleanOption(137 /* EditorOption.suggestOnTriggerCharacters */, 'suggestOnTriggerCharacters', true, { description: nls.localize(574, "Controls whether suggestions should automatically show up when typing trigger characters.") })),
+    suggestSelection: register(new EditorStringEnumOption(138 /* EditorOption.suggestSelection */, 'suggestSelection', 'first', ['first', 'recentlyUsed', 'recentlyUsedByPrefix'], {
         markdownEnumDescriptions: [
-            nls.localize(574, "Always select the first suggestion."),
-            nls.localize(575, "Select recent suggestions unless further typing selects one, e.g. `console.| -> console.log` because `log` has been completed recently."),
-            nls.localize(576, "Select suggestions based on previous prefixes that have completed those suggestions, e.g. `co -> console` and `con -> const`."),
+            nls.localize(575, "Always select the first suggestion."),
+            nls.localize(576, "Select recent suggestions unless further typing selects one, e.g. `console.| -> console.log` because `log` has been completed recently."),
+            nls.localize(577, "Select suggestions based on previous prefixes that have completed those suggestions, e.g. `co -> console` and `con -> const`."),
         ],
-        description: nls.localize(577, "Controls how suggestions are pre-selected when showing the suggest list.")
+        description: nls.localize(578, "Controls how suggestions are pre-selected when showing the suggest list.")
     })),
-    tabCompletion: register(new EditorStringEnumOption(138 /* EditorOption.tabCompletion */, 'tabCompletion', 'off', ['on', 'off', 'onlySnippets'], {
+    tabCompletion: register(new EditorStringEnumOption(139 /* EditorOption.tabCompletion */, 'tabCompletion', 'off', ['on', 'off', 'onlySnippets'], {
         enumDescriptions: [
-            nls.localize(578, "Tab complete will insert the best matching suggestion when pressing tab."),
-            nls.localize(579, "Disable tab completions."),
-            nls.localize(580, "Tab complete snippets when their prefix match. Works best when 'quickSuggestions' aren't enabled."),
+            nls.localize(579, "Tab complete will insert the best matching suggestion when pressing tab."),
+            nls.localize(580, "Disable tab completions."),
+            nls.localize(581, "Tab complete snippets when their prefix match. Works best when 'quickSuggestions' aren't enabled."),
         ],
-        description: nls.localize(581, "Enables tab completions.")
+        description: nls.localize(582, "Enables tab completions.")
     })),
-    tabIndex: register(new EditorIntOption(139 /* EditorOption.tabIndex */, 'tabIndex', 0, -1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */)),
-    trimWhitespaceOnDelete: register(new EditorBooleanOption(140 /* EditorOption.trimWhitespaceOnDelete */, 'trimWhitespaceOnDelete', false, { description: nls.localize(582, "Controls whether the editor will also delete the next line's indentation whitespace when deleting a newline.") })),
+    tabIndex: register(new EditorIntOption(140 /* EditorOption.tabIndex */, 'tabIndex', 0, -1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */)),
+    trimWhitespaceOnDelete: register(new EditorBooleanOption(141 /* EditorOption.trimWhitespaceOnDelete */, 'trimWhitespaceOnDelete', false, { description: nls.localize(583, "Controls whether the editor will also delete the next line's indentation whitespace when deleting a newline.") })),
     unicodeHighlight: register(new UnicodeHighlight()),
-    unusualLineTerminators: register(new EditorStringEnumOption(142 /* EditorOption.unusualLineTerminators */, 'unusualLineTerminators', 'prompt', ['auto', 'off', 'prompt'], {
+    unusualLineTerminators: register(new EditorStringEnumOption(143 /* EditorOption.unusualLineTerminators */, 'unusualLineTerminators', 'prompt', ['auto', 'off', 'prompt'], {
         enumDescriptions: [
-            nls.localize(583, "Unusual line terminators are automatically removed."),
-            nls.localize(584, "Unusual line terminators are ignored."),
-            nls.localize(585, "Unusual line terminators prompt to be removed."),
+            nls.localize(584, "Unusual line terminators are automatically removed."),
+            nls.localize(585, "Unusual line terminators are ignored."),
+            nls.localize(586, "Unusual line terminators prompt to be removed."),
         ],
-        description: nls.localize(586, "Remove unusual line terminators that might cause problems.")
+        description: nls.localize(587, "Remove unusual line terminators that might cause problems.")
     })),
-    useShadowDOM: register(new EditorBooleanOption(143 /* EditorOption.useShadowDOM */, 'useShadowDOM', true)),
-    useTabStops: register(new EditorBooleanOption(144 /* EditorOption.useTabStops */, 'useTabStops', true, { description: nls.localize(587, "Spaces and tabs are inserted and deleted in alignment with tab stops.") })),
-    wordBreak: register(new EditorStringEnumOption(145 /* EditorOption.wordBreak */, 'wordBreak', 'normal', ['normal', 'keepAll'], {
+    useShadowDOM: register(new EditorBooleanOption(144 /* EditorOption.useShadowDOM */, 'useShadowDOM', true)),
+    useTabStops: register(new EditorBooleanOption(145 /* EditorOption.useTabStops */, 'useTabStops', true, { description: nls.localize(588, "Spaces and tabs are inserted and deleted in alignment with tab stops.") })),
+    wordBreak: register(new EditorStringEnumOption(146 /* EditorOption.wordBreak */, 'wordBreak', 'normal', ['normal', 'keepAll'], {
         markdownEnumDescriptions: [
-            nls.localize(588, "Use the default line break rule."),
-            nls.localize(589, "Word breaks should not be used for Chinese/Japanese/Korean (CJK) text. Non-CJK text behavior is the same as for normal."),
+            nls.localize(589, "Use the default line break rule."),
+            nls.localize(590, "Word breaks should not be used for Chinese/Japanese/Korean (CJK) text. Non-CJK text behavior is the same as for normal."),
         ],
-        description: nls.localize(590, "Controls the word break rules used for Chinese/Japanese/Korean (CJK) text.")
+        description: nls.localize(591, "Controls the word break rules used for Chinese/Japanese/Korean (CJK) text.")
     })),
     wordSegmenterLocales: register(new WordSegmenterLocales()),
-    wordSeparators: register(new EditorStringOption(147 /* EditorOption.wordSeparators */, 'wordSeparators', USUAL_WORD_SEPARATORS, { description: nls.localize(591, "Characters that will be used as word separators when doing word related navigations or operations.") })),
-    wordWrap: register(new EditorStringEnumOption(148 /* EditorOption.wordWrap */, 'wordWrap', 'off', ['off', 'on', 'wordWrapColumn', 'bounded'], {
+    wordSeparators: register(new EditorStringOption(148 /* EditorOption.wordSeparators */, 'wordSeparators', USUAL_WORD_SEPARATORS, { description: nls.localize(592, "Characters that will be used as word separators when doing word related navigations or operations.") })),
+    wordWrap: register(new EditorStringEnumOption(149 /* EditorOption.wordWrap */, 'wordWrap', 'off', ['off', 'on', 'wordWrapColumn', 'bounded'], {
         markdownEnumDescriptions: [
-            nls.localize(592, "Lines will never wrap."),
-            nls.localize(593, "Lines will wrap at the viewport width."),
-            nls.localize(594, "Lines will wrap at `#editor.wordWrapColumn#`."),
+            nls.localize(593, "Lines will never wrap."),
+            nls.localize(594, "Lines will wrap at the viewport width."),
+            nls.localize(595, "Lines will wrap at `#editor.wordWrapColumn#`."),
 
 
 
 
 
-            nls.localize(595, "Lines will wrap at the minimum of viewport and `#editor.wordWrapColumn#`."),
+            nls.localize(596, "Lines will wrap at the minimum of viewport and `#editor.wordWrapColumn#`."),
 
 
 
@@ -3316,7 +3317,7 @@ export const EditorOptions = {
 
 
         ],
-        description: nls.localize(596, "Controls how lines should wrap.")
+        description: nls.localize(597, "Controls how lines should wrap.")
 
 
 
@@ -3324,14 +3325,14 @@ export const EditorOptions = {
 
 
     })),
-    wordWrapBreakAfterCharacters: register(new EditorStringOption(149 /* EditorOption.wordWrapBreakAfterCharacters */, 'wordWrapBreakAfterCharacters', 
+    wordWrapBreakAfterCharacters: register(new EditorStringOption(150 /* EditorOption.wordWrapBreakAfterCharacters */, 'wordWrapBreakAfterCharacters', 
     // allow-any-unicode-next-line
     ' \t})]?|/&.,;¢°′″‰℃、。｡､￠，．：；？！％・･ゝゞヽヾーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ々〻ｧｨｩｪｫｬｭｮｯｰ”〉》」』】〕）］｝｣')),
-    wordWrapBreakBeforeCharacters: register(new EditorStringOption(150 /* EditorOption.wordWrapBreakBeforeCharacters */, 'wordWrapBreakBeforeCharacters', 
+    wordWrapBreakBeforeCharacters: register(new EditorStringOption(151 /* EditorOption.wordWrapBreakBeforeCharacters */, 'wordWrapBreakBeforeCharacters', 
     // allow-any-unicode-next-line
     '([{‘“〈《「『【〔（［｛｢£¥＄￡￥+＋')),
-    wordWrapColumn: register(new EditorIntOption(151 /* EditorOption.wordWrapColumn */, 'wordWrapColumn', 80, 1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, {
-        markdownDescription: nls.localize(597, "Controls the wrapping column of the editor when `#editor.wordWrap#` is `wordWrapColumn` or `bounded`.")
+    wordWrapColumn: register(new EditorIntOption(152 /* EditorOption.wordWrapColumn */, 'wordWrapColumn', 80, 1, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, {
+        markdownDescription: nls.localize(598, "Controls the wrapping column of the editor when `#editor.wordWrap#` is `wordWrapColumn` or `bounded`.")
 
 
 
@@ -3339,22 +3340,22 @@ export const EditorOptions = {
 
 
     })),
-    wordWrapOverride1: register(new EditorStringEnumOption(152 /* EditorOption.wordWrapOverride1 */, 'wordWrapOverride1', 'inherit', ['off', 'on', 'inherit'])),
-    wordWrapOverride2: register(new EditorStringEnumOption(153 /* EditorOption.wordWrapOverride2 */, 'wordWrapOverride2', 'inherit', ['off', 'on', 'inherit'])),
-    wrapOnEscapedLineFeeds: register(new EditorBooleanOption(159 /* EditorOption.wrapOnEscapedLineFeeds */, 'wrapOnEscapedLineFeeds', false, { markdownDescription: nls.localize(598, "Controls whether literal `\\n` shall trigger a wordWrap when `#editor.wordWrap#` is enabled.\n\nFor example:\n```c\nchar* str=\"hello\\nworld\"\n```\nwill be displayed as\n```c\nchar* str=\"hello\\n\n           world\"\n```") })),
+    wordWrapOverride1: register(new EditorStringEnumOption(153 /* EditorOption.wordWrapOverride1 */, 'wordWrapOverride1', 'inherit', ['off', 'on', 'inherit'])),
+    wordWrapOverride2: register(new EditorStringEnumOption(154 /* EditorOption.wordWrapOverride2 */, 'wordWrapOverride2', 'inherit', ['off', 'on', 'inherit'])),
+    wrapOnEscapedLineFeeds: register(new EditorBooleanOption(160 /* EditorOption.wrapOnEscapedLineFeeds */, 'wrapOnEscapedLineFeeds', false, { markdownDescription: nls.localize(599, "Controls whether literal `\\n` shall trigger a wordWrap when `#editor.wordWrap#` is enabled.\n\nFor example:\n```c\nchar* str=\"hello\\nworld\"\n```\nwill be displayed as\n```c\nchar* str=\"hello\\n\n           world\"\n```") })),
     // Leave these at the end (because they have dependencies!)
     effectiveCursorStyle: register(new EffectiveCursorStyle()),
     editorClassName: register(new EditorClassName()),
-    defaultColorDecorators: register(new EditorStringEnumOption(166 /* EditorOption.defaultColorDecorators */, 'defaultColorDecorators', 'auto', ['auto', 'always', 'never'], {
+    defaultColorDecorators: register(new EditorStringEnumOption(167 /* EditorOption.defaultColorDecorators */, 'defaultColorDecorators', 'auto', ['auto', 'always', 'never'], {
         enumDescriptions: [
-            nls.localize(599, "Show default color decorators only when no extension provides colors decorators."),
-            nls.localize(600, "Always show default color decorators."),
-            nls.localize(601, "Never show default color decorators."),
+            nls.localize(600, "Show default color decorators only when no extension provides colors decorators."),
+            nls.localize(601, "Always show default color decorators."),
+            nls.localize(602, "Never show default color decorators."),
         ],
-        description: nls.localize(602, "Controls whether inline color decorations should be shown using the default document color provider.")
+        description: nls.localize(603, "Controls whether inline color decorations should be shown using the default document color provider.")
     })),
     pixelRatio: register(new EditorPixelRatio()),
-    tabFocusMode: register(new EditorBooleanOption(163 /* EditorOption.tabFocusMode */, 'tabFocusMode', false, { markdownDescription: nls.localize(603, "Controls whether the editor receives tabs or defers them to the workbench for navigation.") })),
+    tabFocusMode: register(new EditorBooleanOption(164 /* EditorOption.tabFocusMode */, 'tabFocusMode', false, { markdownDescription: nls.localize(604, "Controls whether the editor receives tabs or defers them to the workbench for navigation.") })),
     layoutInfo: register(new EditorLayoutInfoComputer()),
     wrappingInfo: register(new EditorWrappingInfoComputer()),
     wrappingIndent: register(new WrappingIndentOption()),