monaco-editor 0.55.0-dev-20251021 → 0.55.0-dev-20251022

package/esm/vs/platform/theme/common/colors/editorColors.js

@@ -9,98 +9,98 @@ import { scrollbarShadow, badgeBackground } from './miscColors.js';
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 // ----- editor
-const editorBackground = registerColor('editor.background', { light: '#ffffff', dark: '#1E1E1E', hcDark: Color.black, hcLight: Color.white }, localize(1785, "Editor background color."));
-const editorForeground = registerColor('editor.foreground', { light: '#333333', dark: '#BBBBBB', hcDark: Color.white, hcLight: foreground }, localize(1786, "Editor default foreground color."));
-registerColor('editorStickyScroll.background', editorBackground, localize(1787, "Background color of sticky scroll in the editor"));
-registerColor('editorStickyScrollGutter.background', editorBackground, localize(1788, "Background color of the gutter part of sticky scroll in the editor"));
-registerColor('editorStickyScrollHover.background', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1789, "Background color of sticky scroll on hover in the editor"));
-registerColor('editorStickyScroll.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1790, "Border color of sticky scroll in the editor"));
-registerColor('editorStickyScroll.shadow', scrollbarShadow, localize(1791, " Shadow color of sticky scroll in the editor"));
-const editorWidgetBackground = registerColor('editorWidget.background', { dark: '#252526', light: '#F3F3F3', hcDark: '#0C141F', hcLight: Color.white }, localize(1792, 'Background color of editor widgets, such as find/replace.'));
-const editorWidgetForeground = registerColor('editorWidget.foreground', foreground, localize(1793, 'Foreground color of editor widgets, such as find/replace.'));
-const editorWidgetBorder = registerColor('editorWidget.border', { dark: '#454545', light: '#C8C8C8', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1794, 'Border color of editor widgets. The color is only used if the widget chooses to have a border and if the color is not overridden by a widget.'));
-registerColor('editorWidget.resizeBorder', null, localize(1795, "Border color of the resize bar of editor widgets. The color is only used if the widget chooses to have a resize border and if the color is not overridden by a widget."));
-registerColor('editorError.background', null, localize(1796, 'Background color of error text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
-const editorErrorForeground = registerColor('editorError.foreground', { dark: '#F14C4C', light: '#E51400', hcDark: '#F48771', hcLight: '#B5200D' }, localize(1797, 'Foreground color of error squigglies in the editor.'));
-const editorErrorBorder = registerColor('editorError.border', { dark: null, light: null, hcDark: Color.fromHex('#E47777').transparent(0.8), hcLight: '#B5200D' }, localize(1798, 'If set, color of double underlines for errors in the editor.'));
-const editorWarningBackground = registerColor('editorWarning.background', null, localize(1799, 'Background color of warning text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
-const editorWarningForeground = registerColor('editorWarning.foreground', { dark: '#CCA700', light: '#BF8803', hcDark: '#FFD370', hcLight: '#895503' }, localize(1800, 'Foreground color of warning squigglies in the editor.'));
-const editorWarningBorder = registerColor('editorWarning.border', { dark: null, light: null, hcDark: Color.fromHex('#FFCC00').transparent(0.8), hcLight: Color.fromHex('#FFCC00').transparent(0.8) }, localize(1801, 'If set, color of double underlines for warnings in the editor.'));
-registerColor('editorInfo.background', null, localize(1802, 'Background color of info text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
-const editorInfoForeground = registerColor('editorInfo.foreground', { dark: '#3794FF', light: '#1a85ff', hcDark: '#3794FF', hcLight: '#1a85ff' }, localize(1803, 'Foreground color of info squigglies in the editor.'));
-const editorInfoBorder = registerColor('editorInfo.border', { dark: null, light: null, hcDark: Color.fromHex('#3794FF').transparent(0.8), hcLight: '#292929' }, localize(1804, 'If set, color of double underlines for infos in the editor.'));
-const editorHintForeground = registerColor('editorHint.foreground', { dark: Color.fromHex('#eeeeee').transparent(0.7), light: '#6c6c6c', hcDark: null, hcLight: null }, localize(1805, 'Foreground color of hint squigglies in the editor.'));
-registerColor('editorHint.border', { dark: null, light: null, hcDark: Color.fromHex('#eeeeee').transparent(0.8), hcLight: '#292929' }, localize(1806, 'If set, color of double underlines for hints in the editor.'));
-const editorActiveLinkForeground = registerColor('editorLink.activeForeground', { dark: '#4E94CE', light: Color.blue, hcDark: Color.cyan, hcLight: '#292929' }, localize(1807, 'Color of active links.'));
+const editorBackground = registerColor('editor.background', { light: '#ffffff', dark: '#1E1E1E', hcDark: Color.black, hcLight: Color.white }, localize(1789, "Editor background color."));
+const editorForeground = registerColor('editor.foreground', { light: '#333333', dark: '#BBBBBB', hcDark: Color.white, hcLight: foreground }, localize(1790, "Editor default foreground color."));
+registerColor('editorStickyScroll.background', editorBackground, localize(1791, "Background color of sticky scroll in the editor"));
+registerColor('editorStickyScrollGutter.background', editorBackground, localize(1792, "Background color of the gutter part of sticky scroll in the editor"));
+registerColor('editorStickyScrollHover.background', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1793, "Background color of sticky scroll on hover in the editor"));
+registerColor('editorStickyScroll.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1794, "Border color of sticky scroll in the editor"));
+registerColor('editorStickyScroll.shadow', scrollbarShadow, localize(1795, " Shadow color of sticky scroll in the editor"));
+const editorWidgetBackground = registerColor('editorWidget.background', { dark: '#252526', light: '#F3F3F3', hcDark: '#0C141F', hcLight: Color.white }, localize(1796, 'Background color of editor widgets, such as find/replace.'));
+const editorWidgetForeground = registerColor('editorWidget.foreground', foreground, localize(1797, 'Foreground color of editor widgets, such as find/replace.'));
+const editorWidgetBorder = registerColor('editorWidget.border', { dark: '#454545', light: '#C8C8C8', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1798, 'Border color of editor widgets. The color is only used if the widget chooses to have a border and if the color is not overridden by a widget.'));
+registerColor('editorWidget.resizeBorder', null, localize(1799, "Border color of the resize bar of editor widgets. The color is only used if the widget chooses to have a resize border and if the color is not overridden by a widget."));
+registerColor('editorError.background', null, localize(1800, 'Background color of error text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
+const editorErrorForeground = registerColor('editorError.foreground', { dark: '#F14C4C', light: '#E51400', hcDark: '#F48771', hcLight: '#B5200D' }, localize(1801, 'Foreground color of error squigglies in the editor.'));
+const editorErrorBorder = registerColor('editorError.border', { dark: null, light: null, hcDark: Color.fromHex('#E47777').transparent(0.8), hcLight: '#B5200D' }, localize(1802, 'If set, color of double underlines for errors in the editor.'));
+const editorWarningBackground = registerColor('editorWarning.background', null, localize(1803, 'Background color of warning text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
+const editorWarningForeground = registerColor('editorWarning.foreground', { dark: '#CCA700', light: '#BF8803', hcDark: '#FFD370', hcLight: '#895503' }, localize(1804, 'Foreground color of warning squigglies in the editor.'));
+const editorWarningBorder = registerColor('editorWarning.border', { dark: null, light: null, hcDark: Color.fromHex('#FFCC00').transparent(0.8), hcLight: Color.fromHex('#FFCC00').transparent(0.8) }, localize(1805, 'If set, color of double underlines for warnings in the editor.'));
+registerColor('editorInfo.background', null, localize(1806, 'Background color of info text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
+const editorInfoForeground = registerColor('editorInfo.foreground', { dark: '#3794FF', light: '#1a85ff', hcDark: '#3794FF', hcLight: '#1a85ff' }, localize(1807, 'Foreground color of info squigglies in the editor.'));
+const editorInfoBorder = registerColor('editorInfo.border', { dark: null, light: null, hcDark: Color.fromHex('#3794FF').transparent(0.8), hcLight: '#292929' }, localize(1808, 'If set, color of double underlines for infos in the editor.'));
+const editorHintForeground = registerColor('editorHint.foreground', { dark: Color.fromHex('#eeeeee').transparent(0.7), light: '#6c6c6c', hcDark: null, hcLight: null }, localize(1809, 'Foreground color of hint squigglies in the editor.'));
+registerColor('editorHint.border', { dark: null, light: null, hcDark: Color.fromHex('#eeeeee').transparent(0.8), hcLight: '#292929' }, localize(1810, 'If set, color of double underlines for hints in the editor.'));
+const editorActiveLinkForeground = registerColor('editorLink.activeForeground', { dark: '#4E94CE', light: Color.blue, hcDark: Color.cyan, hcLight: '#292929' }, localize(1811, 'Color of active links.'));
 // ----- editor selection
-const editorSelectionBackground = registerColor('editor.selectionBackground', { light: '#ADD6FF', dark: '#264F78', hcDark: '#f3f518', hcLight: '#0F4A85' }, localize(1808, "Color of the editor selection."));
-const editorSelectionForeground = registerColor('editor.selectionForeground', { light: null, dark: null, hcDark: '#000000', hcLight: Color.white }, localize(1809, "Color of the selected text for high contrast."));
-const editorInactiveSelection = registerColor('editor.inactiveSelectionBackground', { light: transparent(editorSelectionBackground, 0.5), dark: transparent(editorSelectionBackground, 0.5), hcDark: transparent(editorSelectionBackground, 0.7), hcLight: transparent(editorSelectionBackground, 0.5) }, localize(1810, "Color of the selection in an inactive editor. The color must not be opaque so as not to hide underlying decorations."), true);
-const editorSelectionHighlight = registerColor('editor.selectionHighlightBackground', { light: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), dark: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), hcDark: null, hcLight: null }, localize(1811, 'Color for regions with the same content as the selection. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('editor.selectionHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1812, "Border color for regions with the same content as the selection."));
-registerColor('editor.compositionBorder', { light: '#000000', dark: '#ffffff', hcLight: '#000000', hcDark: '#ffffff' }, localize(1813, "The border color for an IME composition."));
+const editorSelectionBackground = registerColor('editor.selectionBackground', { light: '#ADD6FF', dark: '#264F78', hcDark: '#f3f518', hcLight: '#0F4A85' }, localize(1812, "Color of the editor selection."));
+const editorSelectionForeground = registerColor('editor.selectionForeground', { light: null, dark: null, hcDark: '#000000', hcLight: Color.white }, localize(1813, "Color of the selected text for high contrast."));
+const editorInactiveSelection = registerColor('editor.inactiveSelectionBackground', { light: transparent(editorSelectionBackground, 0.5), dark: transparent(editorSelectionBackground, 0.5), hcDark: transparent(editorSelectionBackground, 0.7), hcLight: transparent(editorSelectionBackground, 0.5) }, localize(1814, "Color of the selection in an inactive editor. The color must not be opaque so as not to hide underlying decorations."), true);
+const editorSelectionHighlight = registerColor('editor.selectionHighlightBackground', { light: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), dark: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), hcDark: null, hcLight: null }, localize(1815, 'Color for regions with the same content as the selection. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('editor.selectionHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1816, "Border color for regions with the same content as the selection."));
+registerColor('editor.compositionBorder', { light: '#000000', dark: '#ffffff', hcLight: '#000000', hcDark: '#ffffff' }, localize(1817, "The border color for an IME composition."));
 // ----- editor find
-registerColor('editor.findMatchBackground', { light: '#A8AC94', dark: '#515C6A', hcDark: null, hcLight: null }, localize(1814, "Color of the current search match."));
-const editorFindMatchForeground = registerColor('editor.findMatchForeground', null, localize(1815, "Text color of the current search match."));
-const editorFindMatchHighlight = registerColor('editor.findMatchHighlightBackground', { light: '#EA5C0055', dark: '#EA5C0055', hcDark: null, hcLight: null }, localize(1816, "Color of the other search matches. The color must not be opaque so as not to hide underlying decorations."), true);
-const editorFindMatchHighlightForeground = registerColor('editor.findMatchHighlightForeground', null, localize(1817, "Foreground color of the other search matches."), true);
-registerColor('editor.findRangeHighlightBackground', { dark: '#3a3d4166', light: '#b4b4b44d', hcDark: null, hcLight: null }, localize(1818, "Color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
-registerColor('editor.findMatchBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1819, "Border color of the current search match."));
-const editorFindMatchHighlightBorder = registerColor('editor.findMatchHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1820, "Border color of the other search matches."));
-const editorFindRangeHighlightBorder = registerColor('editor.findRangeHighlightBorder', { dark: null, light: null, hcDark: transparent(activeContrastBorder, 0.4), hcLight: transparent(activeContrastBorder, 0.4) }, localize(1821, "Border color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
+registerColor('editor.findMatchBackground', { light: '#A8AC94', dark: '#515C6A', hcDark: null, hcLight: null }, localize(1818, "Color of the current search match."));
+const editorFindMatchForeground = registerColor('editor.findMatchForeground', null, localize(1819, "Text color of the current search match."));
+const editorFindMatchHighlight = registerColor('editor.findMatchHighlightBackground', { light: '#EA5C0055', dark: '#EA5C0055', hcDark: null, hcLight: null }, localize(1820, "Color of the other search matches. The color must not be opaque so as not to hide underlying decorations."), true);
+const editorFindMatchHighlightForeground = registerColor('editor.findMatchHighlightForeground', null, localize(1821, "Foreground color of the other search matches."), true);
+registerColor('editor.findRangeHighlightBackground', { dark: '#3a3d4166', light: '#b4b4b44d', hcDark: null, hcLight: null }, localize(1822, "Color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
+registerColor('editor.findMatchBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1823, "Border color of the current search match."));
+const editorFindMatchHighlightBorder = registerColor('editor.findMatchHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1824, "Border color of the other search matches."));
+const editorFindRangeHighlightBorder = registerColor('editor.findRangeHighlightBorder', { dark: null, light: null, hcDark: transparent(activeContrastBorder, 0.4), hcLight: transparent(activeContrastBorder, 0.4) }, localize(1825, "Border color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
 // ----- editor hover
-registerColor('editor.hoverHighlightBackground', { light: '#ADD6FF26', dark: '#264f7840', hcDark: '#ADD6FF26', hcLight: null }, localize(1822, 'Highlight below the word for which a hover is shown. The color must not be opaque so as not to hide underlying decorations.'), true);
-const editorHoverBackground = registerColor('editorHoverWidget.background', editorWidgetBackground, localize(1823, 'Background color of the editor hover.'));
-const editorHoverForeground = registerColor('editorHoverWidget.foreground', editorWidgetForeground, localize(1824, 'Foreground color of the editor hover.'));
-const editorHoverBorder = registerColor('editorHoverWidget.border', editorWidgetBorder, localize(1825, 'Border color of the editor hover.'));
-registerColor('editorHoverWidget.statusBarBackground', { dark: lighten(editorHoverBackground, 0.2), light: darken(editorHoverBackground, 0.05), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, localize(1826, "Background color of the editor hover status bar."));
+registerColor('editor.hoverHighlightBackground', { light: '#ADD6FF26', dark: '#264f7840', hcDark: '#ADD6FF26', hcLight: null }, localize(1826, 'Highlight below the word for which a hover is shown. The color must not be opaque so as not to hide underlying decorations.'), true);
+const editorHoverBackground = registerColor('editorHoverWidget.background', editorWidgetBackground, localize(1827, 'Background color of the editor hover.'));
+const editorHoverForeground = registerColor('editorHoverWidget.foreground', editorWidgetForeground, localize(1828, 'Foreground color of the editor hover.'));
+const editorHoverBorder = registerColor('editorHoverWidget.border', editorWidgetBorder, localize(1829, 'Border color of the editor hover.'));
+registerColor('editorHoverWidget.statusBarBackground', { dark: lighten(editorHoverBackground, 0.2), light: darken(editorHoverBackground, 0.05), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, localize(1830, "Background color of the editor hover status bar."));
 // ----- editor inlay hint
-const editorInlayHintForeground = registerColor('editorInlayHint.foreground', { dark: '#969696', light: '#969696', hcDark: Color.white, hcLight: Color.black }, localize(1827, 'Foreground color of inline hints'));
-const editorInlayHintBackground = registerColor('editorInlayHint.background', { dark: transparent(badgeBackground, .10), light: transparent(badgeBackground, .10), hcDark: transparent(Color.white, .10), hcLight: transparent(badgeBackground, .10) }, localize(1828, 'Background color of inline hints'));
-const editorInlayHintTypeForeground = registerColor('editorInlayHint.typeForeground', editorInlayHintForeground, localize(1829, 'Foreground color of inline hints for types'));
-const editorInlayHintTypeBackground = registerColor('editorInlayHint.typeBackground', editorInlayHintBackground, localize(1830, 'Background color of inline hints for types'));
-const editorInlayHintParameterForeground = registerColor('editorInlayHint.parameterForeground', editorInlayHintForeground, localize(1831, 'Foreground color of inline hints for parameters'));
-const editorInlayHintParameterBackground = registerColor('editorInlayHint.parameterBackground', editorInlayHintBackground, localize(1832, 'Background color of inline hints for parameters'));
+const editorInlayHintForeground = registerColor('editorInlayHint.foreground', { dark: '#969696', light: '#969696', hcDark: Color.white, hcLight: Color.black }, localize(1831, 'Foreground color of inline hints'));
+const editorInlayHintBackground = registerColor('editorInlayHint.background', { dark: transparent(badgeBackground, .10), light: transparent(badgeBackground, .10), hcDark: transparent(Color.white, .10), hcLight: transparent(badgeBackground, .10) }, localize(1832, 'Background color of inline hints'));
+const editorInlayHintTypeForeground = registerColor('editorInlayHint.typeForeground', editorInlayHintForeground, localize(1833, 'Foreground color of inline hints for types'));
+const editorInlayHintTypeBackground = registerColor('editorInlayHint.typeBackground', editorInlayHintBackground, localize(1834, 'Background color of inline hints for types'));
+const editorInlayHintParameterForeground = registerColor('editorInlayHint.parameterForeground', editorInlayHintForeground, localize(1835, 'Foreground color of inline hints for parameters'));
+const editorInlayHintParameterBackground = registerColor('editorInlayHint.parameterBackground', editorInlayHintBackground, localize(1836, 'Background color of inline hints for parameters'));
 // ----- editor lightbulb
-const editorLightBulbForeground = registerColor('editorLightBulb.foreground', { dark: '#FFCC00', light: '#DDB100', hcDark: '#FFCC00', hcLight: '#007ACC' }, localize(1833, "The color used for the lightbulb actions icon."));
-registerColor('editorLightBulbAutoFix.foreground', { dark: '#75BEFF', light: '#007ACC', hcDark: '#75BEFF', hcLight: '#007ACC' }, localize(1834, "The color used for the lightbulb auto fix actions icon."));
-registerColor('editorLightBulbAi.foreground', editorLightBulbForeground, localize(1835, "The color used for the lightbulb AI icon."));
+const editorLightBulbForeground = registerColor('editorLightBulb.foreground', { dark: '#FFCC00', light: '#DDB100', hcDark: '#FFCC00', hcLight: '#007ACC' }, localize(1837, "The color used for the lightbulb actions icon."));
+registerColor('editorLightBulbAutoFix.foreground', { dark: '#75BEFF', light: '#007ACC', hcDark: '#75BEFF', hcLight: '#007ACC' }, localize(1838, "The color used for the lightbulb auto fix actions icon."));
+registerColor('editorLightBulbAi.foreground', editorLightBulbForeground, localize(1839, "The color used for the lightbulb AI icon."));
 // ----- editor snippet
-registerColor('editor.snippetTabstopHighlightBackground', { dark: new Color(new RGBA(124, 124, 124, 0.3)), light: new Color(new RGBA(10, 50, 100, 0.2)), hcDark: new Color(new RGBA(124, 124, 124, 0.3)), hcLight: new Color(new RGBA(10, 50, 100, 0.2)) }, localize(1836, "Highlight background color of a snippet tabstop."));
-registerColor('editor.snippetTabstopHighlightBorder', null, localize(1837, "Highlight border color of a snippet tabstop."));
-registerColor('editor.snippetFinalTabstopHighlightBackground', null, localize(1838, "Highlight background color of the final tabstop of a snippet."));
-registerColor('editor.snippetFinalTabstopHighlightBorder', { dark: '#525252', light: new Color(new RGBA(10, 50, 100, 0.5)), hcDark: '#525252', hcLight: '#292929' }, localize(1839, "Highlight border color of the final tabstop of a snippet."));
+registerColor('editor.snippetTabstopHighlightBackground', { dark: new Color(new RGBA(124, 124, 124, 0.3)), light: new Color(new RGBA(10, 50, 100, 0.2)), hcDark: new Color(new RGBA(124, 124, 124, 0.3)), hcLight: new Color(new RGBA(10, 50, 100, 0.2)) }, localize(1840, "Highlight background color of a snippet tabstop."));
+registerColor('editor.snippetTabstopHighlightBorder', null, localize(1841, "Highlight border color of a snippet tabstop."));
+registerColor('editor.snippetFinalTabstopHighlightBackground', null, localize(1842, "Highlight background color of the final tabstop of a snippet."));
+registerColor('editor.snippetFinalTabstopHighlightBorder', { dark: '#525252', light: new Color(new RGBA(10, 50, 100, 0.5)), hcDark: '#525252', hcLight: '#292929' }, localize(1843, "Highlight border color of the final tabstop of a snippet."));
 // ----- diff editor
 const defaultInsertColor = new Color(new RGBA(155, 185, 85, .2));
 const defaultRemoveColor = new Color(new RGBA(255, 0, 0, .2));
-const diffInserted = registerColor('diffEditor.insertedTextBackground', { dark: '#9ccc2c33', light: '#9ccc2c40', hcDark: null, hcLight: null }, localize(1840, 'Background color for text that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
-const diffRemoved = registerColor('diffEditor.removedTextBackground', { dark: '#ff000033', light: '#ff000033', hcDark: null, hcLight: null }, localize(1841, 'Background color for text that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
-const diffInsertedLine = registerColor('diffEditor.insertedLineBackground', { dark: defaultInsertColor, light: defaultInsertColor, hcDark: null, hcLight: null }, localize(1842, 'Background color for lines that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('diffEditor.removedLineBackground', { dark: defaultRemoveColor, light: defaultRemoveColor, hcDark: null, hcLight: null }, localize(1843, 'Background color for lines that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('diffEditorGutter.insertedLineBackground', null, localize(1844, 'Background color for the margin where lines got inserted.'));
-registerColor('diffEditorGutter.removedLineBackground', null, localize(1845, 'Background color for the margin where lines got removed.'));
-const diffOverviewRulerInserted = registerColor('diffEditorOverview.insertedForeground', null, localize(1846, 'Diff overview ruler foreground for inserted content.'));
-const diffOverviewRulerRemoved = registerColor('diffEditorOverview.removedForeground', null, localize(1847, 'Diff overview ruler foreground for removed content.'));
-registerColor('diffEditor.insertedTextBorder', { dark: null, light: null, hcDark: '#33ff2eff', hcLight: '#374E06' }, localize(1848, 'Outline color for the text that got inserted.'));
-registerColor('diffEditor.removedTextBorder', { dark: null, light: null, hcDark: '#FF008F', hcLight: '#AD0707' }, localize(1849, 'Outline color for text that got removed.'));
-registerColor('diffEditor.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1850, 'Border color between the two text editors.'));
-registerColor('diffEditor.diagonalFill', { dark: '#cccccc33', light: '#22222233', hcDark: null, hcLight: null }, localize(1851, "Color of the diff editor's diagonal fill. The diagonal fill is used in side-by-side diff views."));
-registerColor('diffEditor.unchangedRegionBackground', 'sideBar.background', localize(1852, "The background color of unchanged blocks in the diff editor."));
-registerColor('diffEditor.unchangedRegionForeground', 'foreground', localize(1853, "The foreground color of unchanged blocks in the diff editor."));
-registerColor('diffEditor.unchangedCodeBackground', { dark: '#74747429', light: '#b8b8b829', hcDark: null, hcLight: null }, localize(1854, "The background color of unchanged code in the diff editor."));
+const diffInserted = registerColor('diffEditor.insertedTextBackground', { dark: '#9ccc2c33', light: '#9ccc2c40', hcDark: null, hcLight: null }, localize(1844, 'Background color for text that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
+const diffRemoved = registerColor('diffEditor.removedTextBackground', { dark: '#ff000033', light: '#ff000033', hcDark: null, hcLight: null }, localize(1845, 'Background color for text that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
+const diffInsertedLine = registerColor('diffEditor.insertedLineBackground', { dark: defaultInsertColor, light: defaultInsertColor, hcDark: null, hcLight: null }, localize(1846, 'Background color for lines that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('diffEditor.removedLineBackground', { dark: defaultRemoveColor, light: defaultRemoveColor, hcDark: null, hcLight: null }, localize(1847, 'Background color for lines that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('diffEditorGutter.insertedLineBackground', null, localize(1848, 'Background color for the margin where lines got inserted.'));
+registerColor('diffEditorGutter.removedLineBackground', null, localize(1849, 'Background color for the margin where lines got removed.'));
+const diffOverviewRulerInserted = registerColor('diffEditorOverview.insertedForeground', null, localize(1850, 'Diff overview ruler foreground for inserted content.'));
+const diffOverviewRulerRemoved = registerColor('diffEditorOverview.removedForeground', null, localize(1851, 'Diff overview ruler foreground for removed content.'));
+registerColor('diffEditor.insertedTextBorder', { dark: null, light: null, hcDark: '#33ff2eff', hcLight: '#374E06' }, localize(1852, 'Outline color for the text that got inserted.'));
+registerColor('diffEditor.removedTextBorder', { dark: null, light: null, hcDark: '#FF008F', hcLight: '#AD0707' }, localize(1853, 'Outline color for text that got removed.'));
+registerColor('diffEditor.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1854, 'Border color between the two text editors.'));
+registerColor('diffEditor.diagonalFill', { dark: '#cccccc33', light: '#22222233', hcDark: null, hcLight: null }, localize(1855, "Color of the diff editor's diagonal fill. The diagonal fill is used in side-by-side diff views."));
+registerColor('diffEditor.unchangedRegionBackground', 'sideBar.background', localize(1856, "The background color of unchanged blocks in the diff editor."));
+registerColor('diffEditor.unchangedRegionForeground', 'foreground', localize(1857, "The foreground color of unchanged blocks in the diff editor."));
+registerColor('diffEditor.unchangedCodeBackground', { dark: '#74747429', light: '#b8b8b829', hcDark: null, hcLight: null }, localize(1858, "The background color of unchanged code in the diff editor."));
 // ----- widget
-const widgetShadow = registerColor('widget.shadow', { dark: transparent(Color.black, .36), light: transparent(Color.black, .16), hcDark: null, hcLight: null }, localize(1855, 'Shadow color of widgets such as find/replace inside the editor.'));
-const widgetBorder = registerColor('widget.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1856, 'Border color of widgets such as find/replace inside the editor.'));
+const widgetShadow = registerColor('widget.shadow', { dark: transparent(Color.black, .36), light: transparent(Color.black, .16), hcDark: null, hcLight: null }, localize(1859, 'Shadow color of widgets such as find/replace inside the editor.'));
+const widgetBorder = registerColor('widget.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1860, 'Border color of widgets such as find/replace inside the editor.'));
 // ----- toolbar
-const toolbarHoverBackground = registerColor('toolbar.hoverBackground', { dark: '#5a5d5e50', light: '#b8b8b850', hcDark: null, hcLight: null }, localize(1857, "Toolbar background when hovering over actions using the mouse"));
-registerColor('toolbar.hoverOutline', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1858, "Toolbar outline when hovering over actions using the mouse"));
-registerColor('toolbar.activeBackground', { dark: lighten(toolbarHoverBackground, 0.1), light: darken(toolbarHoverBackground, 0.1), hcDark: null, hcLight: null }, localize(1859, "Toolbar background when holding the mouse over actions"));
+const toolbarHoverBackground = registerColor('toolbar.hoverBackground', { dark: '#5a5d5e50', light: '#b8b8b850', hcDark: null, hcLight: null }, localize(1861, "Toolbar background when hovering over actions using the mouse"));
+registerColor('toolbar.hoverOutline', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1862, "Toolbar outline when hovering over actions using the mouse"));
+registerColor('toolbar.activeBackground', { dark: lighten(toolbarHoverBackground, 0.1), light: darken(toolbarHoverBackground, 0.1), hcDark: null, hcLight: null }, localize(1863, "Toolbar background when holding the mouse over actions"));
 // ----- breadcumbs
-const breadcrumbsForeground = registerColor('breadcrumb.foreground', transparent(foreground, 0.8), localize(1860, "Color of focused breadcrumb items."));
-const breadcrumbsBackground = registerColor('breadcrumb.background', editorBackground, localize(1861, "Background color of breadcrumb items."));
-const breadcrumbsFocusForeground = registerColor('breadcrumb.focusForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, localize(1862, "Color of focused breadcrumb items."));
-const breadcrumbsActiveSelectionForeground = registerColor('breadcrumb.activeSelectionForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, localize(1863, "Color of selected breadcrumb items."));
-registerColor('breadcrumbPicker.background', editorWidgetBackground, localize(1864, "Background color of breadcrumb item picker."));
+const breadcrumbsForeground = registerColor('breadcrumb.foreground', transparent(foreground, 0.8), localize(1864, "Color of focused breadcrumb items."));
+const breadcrumbsBackground = registerColor('breadcrumb.background', editorBackground, localize(1865, "Background color of breadcrumb items."));
+const breadcrumbsFocusForeground = registerColor('breadcrumb.focusForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, localize(1866, "Color of focused breadcrumb items."));
+const breadcrumbsActiveSelectionForeground = registerColor('breadcrumb.activeSelectionForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, localize(1867, "Color of selected breadcrumb items."));
+registerColor('breadcrumbPicker.background', editorWidgetBackground, localize(1868, "Background color of breadcrumb item picker."));
 // ----- merge
 const headerTransparency = 0.5;
 const currentBaseColor = Color.fromHex('#40C8AE').transparent(headerTransparency);
@@ -108,21 +108,21 @@ const incomingBaseColor = Color.fromHex('#40A6FF').transparent(headerTransparenc
 const commonBaseColor = Color.fromHex('#606060').transparent(0.4);
 const contentTransparency = 0.4;
 const rulerTransparency = 1;
-const mergeCurrentHeaderBackground = registerColor('merge.currentHeaderBackground', { dark: currentBaseColor, light: currentBaseColor, hcDark: null, hcLight: null }, localize(1865, 'Current header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('merge.currentContentBackground', transparent(mergeCurrentHeaderBackground, contentTransparency), localize(1866, 'Current content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-const mergeIncomingHeaderBackground = registerColor('merge.incomingHeaderBackground', { dark: incomingBaseColor, light: incomingBaseColor, hcDark: null, hcLight: null }, localize(1867, 'Incoming header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('merge.incomingContentBackground', transparent(mergeIncomingHeaderBackground, contentTransparency), localize(1868, 'Incoming content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-const mergeCommonHeaderBackground = registerColor('merge.commonHeaderBackground', { dark: commonBaseColor, light: commonBaseColor, hcDark: null, hcLight: null }, localize(1869, 'Common ancestor header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('merge.commonContentBackground', transparent(mergeCommonHeaderBackground, contentTransparency), localize(1870, 'Common ancestor content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
-const mergeBorder = registerColor('merge.border', { dark: null, light: null, hcDark: '#C3DF6F', hcLight: '#007ACC' }, localize(1871, 'Border color on headers and the splitter in inline merge-conflicts.'));
-registerColor('editorOverviewRuler.currentContentForeground', { dark: transparent(mergeCurrentHeaderBackground, rulerTransparency), light: transparent(mergeCurrentHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1872, 'Current overview ruler foreground for inline merge-conflicts.'));
-registerColor('editorOverviewRuler.incomingContentForeground', { dark: transparent(mergeIncomingHeaderBackground, rulerTransparency), light: transparent(mergeIncomingHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1873, 'Incoming overview ruler foreground for inline merge-conflicts.'));
-registerColor('editorOverviewRuler.commonContentForeground', { dark: transparent(mergeCommonHeaderBackground, rulerTransparency), light: transparent(mergeCommonHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1874, 'Common ancestor overview ruler foreground for inline merge-conflicts.'));
-const overviewRulerFindMatchForeground = registerColor('editorOverviewRuler.findMatchForeground', { dark: '#d186167e', light: '#d186167e', hcDark: '#AB5A00', hcLight: '#AB5A00' }, localize(1875, 'Overview ruler marker color for find matches. The color must not be opaque so as not to hide underlying decorations.'), true);
-const overviewRulerSelectionHighlightForeground = registerColor('editorOverviewRuler.selectionHighlightForeground', '#A0A0A0CC', localize(1876, 'Overview ruler marker color for selection highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
+const mergeCurrentHeaderBackground = registerColor('merge.currentHeaderBackground', { dark: currentBaseColor, light: currentBaseColor, hcDark: null, hcLight: null }, localize(1869, 'Current header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('merge.currentContentBackground', transparent(mergeCurrentHeaderBackground, contentTransparency), localize(1870, 'Current content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+const mergeIncomingHeaderBackground = registerColor('merge.incomingHeaderBackground', { dark: incomingBaseColor, light: incomingBaseColor, hcDark: null, hcLight: null }, localize(1871, 'Incoming header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('merge.incomingContentBackground', transparent(mergeIncomingHeaderBackground, contentTransparency), localize(1872, 'Incoming content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+const mergeCommonHeaderBackground = registerColor('merge.commonHeaderBackground', { dark: commonBaseColor, light: commonBaseColor, hcDark: null, hcLight: null }, localize(1873, 'Common ancestor header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+registerColor('merge.commonContentBackground', transparent(mergeCommonHeaderBackground, contentTransparency), localize(1874, 'Common ancestor content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
+const mergeBorder = registerColor('merge.border', { dark: null, light: null, hcDark: '#C3DF6F', hcLight: '#007ACC' }, localize(1875, 'Border color on headers and the splitter in inline merge-conflicts.'));
+registerColor('editorOverviewRuler.currentContentForeground', { dark: transparent(mergeCurrentHeaderBackground, rulerTransparency), light: transparent(mergeCurrentHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1876, 'Current overview ruler foreground for inline merge-conflicts.'));
+registerColor('editorOverviewRuler.incomingContentForeground', { dark: transparent(mergeIncomingHeaderBackground, rulerTransparency), light: transparent(mergeIncomingHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1877, 'Incoming overview ruler foreground for inline merge-conflicts.'));
+registerColor('editorOverviewRuler.commonContentForeground', { dark: transparent(mergeCommonHeaderBackground, rulerTransparency), light: transparent(mergeCommonHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, localize(1878, 'Common ancestor overview ruler foreground for inline merge-conflicts.'));
+const overviewRulerFindMatchForeground = registerColor('editorOverviewRuler.findMatchForeground', { dark: '#d186167e', light: '#d186167e', hcDark: '#AB5A00', hcLight: '#AB5A00' }, localize(1879, 'Overview ruler marker color for find matches. The color must not be opaque so as not to hide underlying decorations.'), true);
+const overviewRulerSelectionHighlightForeground = registerColor('editorOverviewRuler.selectionHighlightForeground', '#A0A0A0CC', localize(1880, 'Overview ruler marker color for selection highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
 // ----- problems
-const problemsErrorIconForeground = registerColor('problemsErrorIcon.foreground', editorErrorForeground, localize(1877, "The color used for the problems error icon."));
-const problemsWarningIconForeground = registerColor('problemsWarningIcon.foreground', editorWarningForeground, localize(1878, "The color used for the problems warning icon."));
-const problemsInfoIconForeground = registerColor('problemsInfoIcon.foreground', editorInfoForeground, localize(1879, "The color used for the problems info icon."));
+const problemsErrorIconForeground = registerColor('problemsErrorIcon.foreground', editorErrorForeground, localize(1881, "The color used for the problems error icon."));
+const problemsWarningIconForeground = registerColor('problemsWarningIcon.foreground', editorWarningForeground, localize(1882, "The color used for the problems warning icon."));
+const problemsInfoIconForeground = registerColor('problemsInfoIcon.foreground', editorInfoForeground, localize(1883, "The color used for the problems info icon."));
 
 export { breadcrumbsActiveSelectionForeground, breadcrumbsBackground, breadcrumbsFocusForeground, breadcrumbsForeground, defaultInsertColor, defaultRemoveColor, diffInserted, diffInsertedLine, diffOverviewRulerInserted, diffOverviewRulerRemoved, diffRemoved, editorActiveLinkForeground, editorBackground, editorErrorBorder, editorErrorForeground, editorFindMatchForeground, editorFindMatchHighlight, editorFindMatchHighlightBorder, editorFindMatchHighlightForeground, editorFindRangeHighlightBorder, editorForeground, editorHintForeground, editorHoverBackground, editorHoverBorder, editorHoverForeground, editorInactiveSelection, editorInfoBorder, editorInfoForeground, editorInlayHintBackground, editorInlayHintForeground, editorInlayHintParameterBackground, editorInlayHintParameterForeground, editorInlayHintTypeBackground, editorInlayHintTypeForeground, editorLightBulbForeground, editorSelectionBackground, editorSelectionForeground, editorSelectionHighlight, editorWarningBackground, editorWarningBorder, editorWarningForeground, editorWidgetBackground, editorWidgetBorder, editorWidgetForeground, mergeBorder, mergeCommonHeaderBackground, mergeCurrentHeaderBackground, mergeIncomingHeaderBackground, overviewRulerFindMatchForeground, overviewRulerSelectionHighlightForeground, problemsErrorIconForeground, problemsInfoIconForeground, problemsWarningIconForeground, toolbarHoverBackground, widgetBorder, widgetShadow };

package/esm/vs/platform/theme/common/colors/inputColors.js

@@ -9,58 +9,58 @@ import { editorWidgetBackground } from './editorColors.js';
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 // ----- input
-const inputBackground = registerColor('input.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1880, "Input box background."));
-const inputForeground = registerColor('input.foreground', foreground, localize(1881, "Input box foreground."));
-const inputBorder = registerColor('input.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1882, "Input box border."));
-const inputActiveOptionBorder = registerColor('inputOption.activeBorder', { dark: '#007ACC', light: '#007ACC', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1883, "Border color of activated options in input fields."));
-const inputActiveOptionHoverBackground = registerColor('inputOption.hoverBackground', { dark: '#5a5d5e80', light: '#b8b8b850', hcDark: null, hcLight: null }, localize(1884, "Background color of activated options in input fields."));
-const inputActiveOptionBackground = registerColor('inputOption.activeBackground', { dark: transparent(focusBorder, 0.4), light: transparent(focusBorder, 0.2), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1885, "Background hover color of options in input fields."));
-const inputActiveOptionForeground = registerColor('inputOption.activeForeground', { dark: Color.white, light: Color.black, hcDark: foreground, hcLight: foreground }, localize(1886, "Foreground color of activated options in input fields."));
-registerColor('input.placeholderForeground', { light: transparent(foreground, 0.5), dark: transparent(foreground, 0.5), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, localize(1887, "Input box foreground color for placeholder text."));
+const inputBackground = registerColor('input.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1884, "Input box background."));
+const inputForeground = registerColor('input.foreground', foreground, localize(1885, "Input box foreground."));
+const inputBorder = registerColor('input.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1886, "Input box border."));
+const inputActiveOptionBorder = registerColor('inputOption.activeBorder', { dark: '#007ACC', light: '#007ACC', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1887, "Border color of activated options in input fields."));
+const inputActiveOptionHoverBackground = registerColor('inputOption.hoverBackground', { dark: '#5a5d5e80', light: '#b8b8b850', hcDark: null, hcLight: null }, localize(1888, "Background color of activated options in input fields."));
+const inputActiveOptionBackground = registerColor('inputOption.activeBackground', { dark: transparent(focusBorder, 0.4), light: transparent(focusBorder, 0.2), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1889, "Background hover color of options in input fields."));
+const inputActiveOptionForeground = registerColor('inputOption.activeForeground', { dark: Color.white, light: Color.black, hcDark: foreground, hcLight: foreground }, localize(1890, "Foreground color of activated options in input fields."));
+registerColor('input.placeholderForeground', { light: transparent(foreground, 0.5), dark: transparent(foreground, 0.5), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, localize(1891, "Input box foreground color for placeholder text."));
 // ----- input validation
-const inputValidationInfoBackground = registerColor('inputValidation.infoBackground', { dark: '#063B49', light: '#D6ECF2', hcDark: Color.black, hcLight: Color.white }, localize(1888, "Input validation background color for information severity."));
-const inputValidationInfoForeground = registerColor('inputValidation.infoForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1889, "Input validation foreground color for information severity."));
-const inputValidationInfoBorder = registerColor('inputValidation.infoBorder', { dark: '#007acc', light: '#007acc', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1890, "Input validation border color for information severity."));
-const inputValidationWarningBackground = registerColor('inputValidation.warningBackground', { dark: '#352A05', light: '#F6F5D2', hcDark: Color.black, hcLight: Color.white }, localize(1891, "Input validation background color for warning severity."));
-const inputValidationWarningForeground = registerColor('inputValidation.warningForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1892, "Input validation foreground color for warning severity."));
-const inputValidationWarningBorder = registerColor('inputValidation.warningBorder', { dark: '#B89500', light: '#B89500', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1893, "Input validation border color for warning severity."));
-const inputValidationErrorBackground = registerColor('inputValidation.errorBackground', { dark: '#5A1D1D', light: '#F2DEDE', hcDark: Color.black, hcLight: Color.white }, localize(1894, "Input validation background color for error severity."));
-const inputValidationErrorForeground = registerColor('inputValidation.errorForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1895, "Input validation foreground color for error severity."));
-const inputValidationErrorBorder = registerColor('inputValidation.errorBorder', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1896, "Input validation border color for error severity."));
+const inputValidationInfoBackground = registerColor('inputValidation.infoBackground', { dark: '#063B49', light: '#D6ECF2', hcDark: Color.black, hcLight: Color.white }, localize(1892, "Input validation background color for information severity."));
+const inputValidationInfoForeground = registerColor('inputValidation.infoForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1893, "Input validation foreground color for information severity."));
+const inputValidationInfoBorder = registerColor('inputValidation.infoBorder', { dark: '#007acc', light: '#007acc', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1894, "Input validation border color for information severity."));
+const inputValidationWarningBackground = registerColor('inputValidation.warningBackground', { dark: '#352A05', light: '#F6F5D2', hcDark: Color.black, hcLight: Color.white }, localize(1895, "Input validation background color for warning severity."));
+const inputValidationWarningForeground = registerColor('inputValidation.warningForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1896, "Input validation foreground color for warning severity."));
+const inputValidationWarningBorder = registerColor('inputValidation.warningBorder', { dark: '#B89500', light: '#B89500', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1897, "Input validation border color for warning severity."));
+const inputValidationErrorBackground = registerColor('inputValidation.errorBackground', { dark: '#5A1D1D', light: '#F2DEDE', hcDark: Color.black, hcLight: Color.white }, localize(1898, "Input validation background color for error severity."));
+const inputValidationErrorForeground = registerColor('inputValidation.errorForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, localize(1899, "Input validation foreground color for error severity."));
+const inputValidationErrorBorder = registerColor('inputValidation.errorBorder', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1900, "Input validation border color for error severity."));
 // ----- select
-const selectBackground = registerColor('dropdown.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1897, "Dropdown background."));
-const selectListBackground = registerColor('dropdown.listBackground', { dark: null, light: null, hcDark: Color.black, hcLight: Color.white }, localize(1898, "Dropdown list background."));
-const selectForeground = registerColor('dropdown.foreground', { dark: '#F0F0F0', light: foreground, hcDark: Color.white, hcLight: foreground }, localize(1899, "Dropdown foreground."));
-const selectBorder = registerColor('dropdown.border', { dark: selectBackground, light: '#CECECE', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1900, "Dropdown border."));
+const selectBackground = registerColor('dropdown.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, localize(1901, "Dropdown background."));
+const selectListBackground = registerColor('dropdown.listBackground', { dark: null, light: null, hcDark: Color.black, hcLight: Color.white }, localize(1902, "Dropdown list background."));
+const selectForeground = registerColor('dropdown.foreground', { dark: '#F0F0F0', light: foreground, hcDark: Color.white, hcLight: foreground }, localize(1903, "Dropdown foreground."));
+const selectBorder = registerColor('dropdown.border', { dark: selectBackground, light: '#CECECE', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1904, "Dropdown border."));
 // ------ button
-const buttonForeground = registerColor('button.foreground', Color.white, localize(1901, "Button foreground color."));
-const buttonSeparator = registerColor('button.separator', transparent(buttonForeground, .4), localize(1902, "Button separator color."));
-const buttonBackground = registerColor('button.background', { dark: '#0E639C', light: '#007ACC', hcDark: Color.black, hcLight: '#0F4A85' }, localize(1903, "Button background color."));
-const buttonHoverBackground = registerColor('button.hoverBackground', { dark: lighten(buttonBackground, 0.2), light: darken(buttonBackground, 0.2), hcDark: buttonBackground, hcLight: buttonBackground }, localize(1904, "Button background color when hovering."));
-const buttonBorder = registerColor('button.border', contrastBorder, localize(1905, "Button border color."));
-const buttonSecondaryForeground = registerColor('button.secondaryForeground', { dark: Color.white, light: Color.white, hcDark: Color.white, hcLight: foreground }, localize(1906, "Secondary button foreground color."));
-const buttonSecondaryBackground = registerColor('button.secondaryBackground', { dark: '#3A3D41', light: '#5F6A79', hcDark: null, hcLight: Color.white }, localize(1907, "Secondary button background color."));
-const buttonSecondaryHoverBackground = registerColor('button.secondaryHoverBackground', { dark: lighten(buttonSecondaryBackground, 0.2), light: darken(buttonSecondaryBackground, 0.2), hcDark: null, hcLight: null }, localize(1908, "Secondary button background color when hovering."));
+const buttonForeground = registerColor('button.foreground', Color.white, localize(1905, "Button foreground color."));
+const buttonSeparator = registerColor('button.separator', transparent(buttonForeground, .4), localize(1906, "Button separator color."));
+const buttonBackground = registerColor('button.background', { dark: '#0E639C', light: '#007ACC', hcDark: Color.black, hcLight: '#0F4A85' }, localize(1907, "Button background color."));
+const buttonHoverBackground = registerColor('button.hoverBackground', { dark: lighten(buttonBackground, 0.2), light: darken(buttonBackground, 0.2), hcDark: buttonBackground, hcLight: buttonBackground }, localize(1908, "Button background color when hovering."));
+const buttonBorder = registerColor('button.border', contrastBorder, localize(1909, "Button border color."));
+const buttonSecondaryForeground = registerColor('button.secondaryForeground', { dark: Color.white, light: Color.white, hcDark: Color.white, hcLight: foreground }, localize(1910, "Secondary button foreground color."));
+const buttonSecondaryBackground = registerColor('button.secondaryBackground', { dark: '#3A3D41', light: '#5F6A79', hcDark: null, hcLight: Color.white }, localize(1911, "Secondary button background color."));
+const buttonSecondaryHoverBackground = registerColor('button.secondaryHoverBackground', { dark: lighten(buttonSecondaryBackground, 0.2), light: darken(buttonSecondaryBackground, 0.2), hcDark: null, hcLight: null }, localize(1912, "Secondary button background color when hovering."));
 // ------ radio
-const radioActiveForeground = registerColor('radio.activeForeground', inputActiveOptionForeground, localize(1909, "Foreground color of active radio option."));
-const radioActiveBackground = registerColor('radio.activeBackground', inputActiveOptionBackground, localize(1910, "Background color of active radio option."));
-const radioActiveBorder = registerColor('radio.activeBorder', inputActiveOptionBorder, localize(1911, "Border color of the active radio option."));
-const radioInactiveForeground = registerColor('radio.inactiveForeground', null, localize(1912, "Foreground color of inactive radio option."));
-const radioInactiveBackground = registerColor('radio.inactiveBackground', null, localize(1913, "Background color of inactive radio option."));
-const radioInactiveBorder = registerColor('radio.inactiveBorder', { light: transparent(radioActiveForeground, .2), dark: transparent(radioActiveForeground, .2), hcDark: transparent(radioActiveForeground, .4), hcLight: transparent(radioActiveForeground, .2) }, localize(1914, "Border color of the inactive radio option."));
-const radioInactiveHoverBackground = registerColor('radio.inactiveHoverBackground', inputActiveOptionHoverBackground, localize(1915, "Background color of inactive active radio option when hovering."));
+const radioActiveForeground = registerColor('radio.activeForeground', inputActiveOptionForeground, localize(1913, "Foreground color of active radio option."));
+const radioActiveBackground = registerColor('radio.activeBackground', inputActiveOptionBackground, localize(1914, "Background color of active radio option."));
+const radioActiveBorder = registerColor('radio.activeBorder', inputActiveOptionBorder, localize(1915, "Border color of the active radio option."));
+const radioInactiveForeground = registerColor('radio.inactiveForeground', null, localize(1916, "Foreground color of inactive radio option."));
+const radioInactiveBackground = registerColor('radio.inactiveBackground', null, localize(1917, "Background color of inactive radio option."));
+const radioInactiveBorder = registerColor('radio.inactiveBorder', { light: transparent(radioActiveForeground, .2), dark: transparent(radioActiveForeground, .2), hcDark: transparent(radioActiveForeground, .4), hcLight: transparent(radioActiveForeground, .2) }, localize(1918, "Border color of the inactive radio option."));
+const radioInactiveHoverBackground = registerColor('radio.inactiveHoverBackground', inputActiveOptionHoverBackground, localize(1919, "Background color of inactive active radio option when hovering."));
 // ------ checkbox
-const checkboxBackground = registerColor('checkbox.background', selectBackground, localize(1916, "Background color of checkbox widget."));
-registerColor('checkbox.selectBackground', editorWidgetBackground, localize(1917, "Background color of checkbox widget when the element it's in is selected."));
-const checkboxForeground = registerColor('checkbox.foreground', selectForeground, localize(1918, "Foreground color of checkbox widget."));
-const checkboxBorder = registerColor('checkbox.border', selectBorder, localize(1919, "Border color of checkbox widget."));
-registerColor('checkbox.selectBorder', iconForeground, localize(1920, "Border color of checkbox widget when the element it's in is selected."));
-const checkboxDisabledBackground = registerColor('checkbox.disabled.background', { op: 7 /* ColorTransformType.Mix */, color: checkboxBackground, with: checkboxForeground, ratio: 0.33 }, localize(1921, "Background of a disabled checkbox."));
-const checkboxDisabledForeground = registerColor('checkbox.disabled.foreground', { op: 7 /* ColorTransformType.Mix */, color: checkboxForeground, with: checkboxBackground, ratio: 0.33 }, localize(1922, "Foreground of a disabled checkbox."));
+const checkboxBackground = registerColor('checkbox.background', selectBackground, localize(1920, "Background color of checkbox widget."));
+registerColor('checkbox.selectBackground', editorWidgetBackground, localize(1921, "Background color of checkbox widget when the element it's in is selected."));
+const checkboxForeground = registerColor('checkbox.foreground', selectForeground, localize(1922, "Foreground color of checkbox widget."));
+const checkboxBorder = registerColor('checkbox.border', selectBorder, localize(1923, "Border color of checkbox widget."));
+registerColor('checkbox.selectBorder', iconForeground, localize(1924, "Border color of checkbox widget when the element it's in is selected."));
+const checkboxDisabledBackground = registerColor('checkbox.disabled.background', { op: 7 /* ColorTransformType.Mix */, color: checkboxBackground, with: checkboxForeground, ratio: 0.33 }, localize(1925, "Background of a disabled checkbox."));
+const checkboxDisabledForeground = registerColor('checkbox.disabled.foreground', { op: 7 /* ColorTransformType.Mix */, color: checkboxForeground, with: checkboxBackground, ratio: 0.33 }, localize(1926, "Foreground of a disabled checkbox."));
 // ------ keybinding label
-const keybindingLabelBackground = registerColor('keybindingLabel.background', { dark: new Color(new RGBA(128, 128, 128, 0.17)), light: new Color(new RGBA(221, 221, 221, 0.4)), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1923, "Keybinding label background color. The keybinding label is used to represent a keyboard shortcut."));
-const keybindingLabelForeground = registerColor('keybindingLabel.foreground', { dark: Color.fromHex('#CCCCCC'), light: Color.fromHex('#555555'), hcDark: Color.white, hcLight: foreground }, localize(1924, "Keybinding label foreground color. The keybinding label is used to represent a keyboard shortcut."));
-const keybindingLabelBorder = registerColor('keybindingLabel.border', { dark: new Color(new RGBA(51, 51, 51, 0.6)), light: new Color(new RGBA(204, 204, 204, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: contrastBorder }, localize(1925, "Keybinding label border color. The keybinding label is used to represent a keyboard shortcut."));
-const keybindingLabelBottomBorder = registerColor('keybindingLabel.bottomBorder', { dark: new Color(new RGBA(68, 68, 68, 0.6)), light: new Color(new RGBA(187, 187, 187, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: foreground }, localize(1926, "Keybinding label border bottom color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelBackground = registerColor('keybindingLabel.background', { dark: new Color(new RGBA(128, 128, 128, 0.17)), light: new Color(new RGBA(221, 221, 221, 0.4)), hcDark: Color.transparent, hcLight: Color.transparent }, localize(1927, "Keybinding label background color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelForeground = registerColor('keybindingLabel.foreground', { dark: Color.fromHex('#CCCCCC'), light: Color.fromHex('#555555'), hcDark: Color.white, hcLight: foreground }, localize(1928, "Keybinding label foreground color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelBorder = registerColor('keybindingLabel.border', { dark: new Color(new RGBA(51, 51, 51, 0.6)), light: new Color(new RGBA(204, 204, 204, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: contrastBorder }, localize(1929, "Keybinding label border color. The keybinding label is used to represent a keyboard shortcut."));
+const keybindingLabelBottomBorder = registerColor('keybindingLabel.bottomBorder', { dark: new Color(new RGBA(68, 68, 68, 0.6)), light: new Color(new RGBA(187, 187, 187, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: foreground }, localize(1930, "Keybinding label border bottom color. The keybinding label is used to represent a keyboard shortcut."));
 
 export { buttonBackground, buttonBorder, buttonForeground, buttonHoverBackground, buttonSecondaryBackground, buttonSecondaryForeground, buttonSecondaryHoverBackground, buttonSeparator, checkboxBackground, checkboxBorder, checkboxDisabledBackground, checkboxDisabledForeground, checkboxForeground, inputActiveOptionBackground, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionHoverBackground, inputBackground, inputBorder, inputForeground, inputValidationErrorBackground, inputValidationErrorBorder, inputValidationErrorForeground, inputValidationInfoBackground, inputValidationInfoBorder, inputValidationInfoForeground, inputValidationWarningBackground, inputValidationWarningBorder, inputValidationWarningForeground, keybindingLabelBackground, keybindingLabelBorder, keybindingLabelBottomBorder, keybindingLabelForeground, radioActiveBackground, radioActiveBorder, radioActiveForeground, radioInactiveBackground, radioInactiveBorder, radioInactiveForeground, radioInactiveHoverBackground, selectBackground, selectBorder, selectForeground, selectListBackground };

package/esm/vs/platform/theme/common/colors/listColors.js

@@ -8,44 +8,44 @@ import { editorWidgetBackground, widgetShadow, editorFindMatchHighlight, editorF
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-const listFocusBackground = registerColor('list.focusBackground', null, localize(1927, "List/Tree background color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listFocusForeground = registerColor('list.focusForeground', null, localize(1928, "List/Tree foreground color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listFocusOutline = registerColor('list.focusOutline', { dark: focusBorder, light: focusBorder, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1929, "List/Tree outline color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listFocusAndSelectionOutline = registerColor('list.focusAndSelectionOutline', null, localize(1930, "List/Tree outline color for the focused item when the list/tree is active and selected. An active list/tree has keyboard focus, an inactive does not."));
-const listActiveSelectionBackground = registerColor('list.activeSelectionBackground', { dark: '#04395E', light: '#0060C0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1931, "List/Tree background color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listActiveSelectionForeground = registerColor('list.activeSelectionForeground', { dark: Color.white, light: Color.white, hcDark: null, hcLight: null }, localize(1932, "List/Tree foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listActiveSelectionIconForeground = registerColor('list.activeSelectionIconForeground', null, localize(1933, "List/Tree icon foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
-const listInactiveSelectionBackground = registerColor('list.inactiveSelectionBackground', { dark: '#37373D', light: '#E4E6F1', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1934, "List/Tree background color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
-const listInactiveSelectionForeground = registerColor('list.inactiveSelectionForeground', null, localize(1935, "List/Tree foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
-const listInactiveSelectionIconForeground = registerColor('list.inactiveSelectionIconForeground', null, localize(1936, "List/Tree icon foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
-const listInactiveFocusBackground = registerColor('list.inactiveFocusBackground', null, localize(1937, "List/Tree background color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
-const listInactiveFocusOutline = registerColor('list.inactiveFocusOutline', null, localize(1938, "List/Tree outline color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
-const listHoverBackground = registerColor('list.hoverBackground', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: Color.white.transparent(0.1), hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1939, "List/Tree background when hovering over items using the mouse."));
-const listHoverForeground = registerColor('list.hoverForeground', null, localize(1940, "List/Tree foreground when hovering over items using the mouse."));
-const listDropOverBackground = registerColor('list.dropBackground', { dark: '#062F4A', light: '#D6EBFF', hcDark: null, hcLight: null }, localize(1941, "List/Tree drag and drop background when moving items over other items when using the mouse."));
-const listDropBetweenBackground = registerColor('list.dropBetweenBackground', { dark: iconForeground, light: iconForeground, hcDark: null, hcLight: null }, localize(1942, "List/Tree drag and drop border color when moving items between items when using the mouse."));
-const listHighlightForeground = registerColor('list.highlightForeground', { dark: '#2AAAFF', light: '#0066BF', hcDark: focusBorder, hcLight: focusBorder }, localize(1943, 'List/Tree foreground color of the match highlights when searching inside the list/tree.'));
-const listFocusHighlightForeground = registerColor('list.focusHighlightForeground', { dark: listHighlightForeground, light: ifDefinedThenElse(listActiveSelectionBackground, listHighlightForeground, '#BBE7FF'), hcDark: listHighlightForeground, hcLight: listHighlightForeground }, localize(1944, 'List/Tree foreground color of the match highlights on actively focused items when searching inside the list/tree.'));
-registerColor('list.invalidItemForeground', { dark: '#B89500', light: '#B89500', hcDark: '#B89500', hcLight: '#B5200D' }, localize(1945, 'List/Tree foreground color for invalid items, for example an unresolved root in explorer.'));
-registerColor('list.errorForeground', { dark: '#F88070', light: '#B01011', hcDark: null, hcLight: null }, localize(1946, 'Foreground color of list items containing errors.'));
-registerColor('list.warningForeground', { dark: '#CCA700', light: '#855F00', hcDark: null, hcLight: null }, localize(1947, 'Foreground color of list items containing warnings.'));
-const listFilterWidgetBackground = registerColor('listFilterWidget.background', { light: darken(editorWidgetBackground, 0), dark: lighten(editorWidgetBackground, 0), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, localize(1948, 'Background color of the type filter widget in lists and trees.'));
-const listFilterWidgetOutline = registerColor('listFilterWidget.outline', { dark: Color.transparent, light: Color.transparent, hcDark: '#f38518', hcLight: '#007ACC' }, localize(1949, 'Outline color of the type filter widget in lists and trees.'));
-const listFilterWidgetNoMatchesOutline = registerColor('listFilterWidget.noMatchesOutline', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1950, 'Outline color of the type filter widget in lists and trees, when there are no matches.'));
-const listFilterWidgetShadow = registerColor('listFilterWidget.shadow', widgetShadow, localize(1951, 'Shadow color of the type filter widget in lists and trees.'));
-registerColor('list.filterMatchBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, localize(1952, 'Background color of the filtered match.'));
-registerColor('list.filterMatchBorder', { dark: editorFindMatchHighlightBorder, light: editorFindMatchHighlightBorder, hcDark: contrastBorder, hcLight: activeContrastBorder }, localize(1953, 'Border color of the filtered match.'));
-registerColor('list.deemphasizedForeground', { dark: '#8C8C8C', light: '#8E8E90', hcDark: '#A7A8A9', hcLight: '#666666' }, localize(1954, "List/Tree foreground color for items that are deemphasized."));
+const listFocusBackground = registerColor('list.focusBackground', null, localize(1931, "List/Tree background color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listFocusForeground = registerColor('list.focusForeground', null, localize(1932, "List/Tree foreground color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listFocusOutline = registerColor('list.focusOutline', { dark: focusBorder, light: focusBorder, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1933, "List/Tree outline color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listFocusAndSelectionOutline = registerColor('list.focusAndSelectionOutline', null, localize(1934, "List/Tree outline color for the focused item when the list/tree is active and selected. An active list/tree has keyboard focus, an inactive does not."));
+const listActiveSelectionBackground = registerColor('list.activeSelectionBackground', { dark: '#04395E', light: '#0060C0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1935, "List/Tree background color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listActiveSelectionForeground = registerColor('list.activeSelectionForeground', { dark: Color.white, light: Color.white, hcDark: null, hcLight: null }, localize(1936, "List/Tree foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listActiveSelectionIconForeground = registerColor('list.activeSelectionIconForeground', null, localize(1937, "List/Tree icon foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
+const listInactiveSelectionBackground = registerColor('list.inactiveSelectionBackground', { dark: '#37373D', light: '#E4E6F1', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1938, "List/Tree background color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
+const listInactiveSelectionForeground = registerColor('list.inactiveSelectionForeground', null, localize(1939, "List/Tree foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
+const listInactiveSelectionIconForeground = registerColor('list.inactiveSelectionIconForeground', null, localize(1940, "List/Tree icon foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
+const listInactiveFocusBackground = registerColor('list.inactiveFocusBackground', null, localize(1941, "List/Tree background color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
+const listInactiveFocusOutline = registerColor('list.inactiveFocusOutline', null, localize(1942, "List/Tree outline color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
+const listHoverBackground = registerColor('list.hoverBackground', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: Color.white.transparent(0.1), hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, localize(1943, "List/Tree background when hovering over items using the mouse."));
+const listHoverForeground = registerColor('list.hoverForeground', null, localize(1944, "List/Tree foreground when hovering over items using the mouse."));
+const listDropOverBackground = registerColor('list.dropBackground', { dark: '#062F4A', light: '#D6EBFF', hcDark: null, hcLight: null }, localize(1945, "List/Tree drag and drop background when moving items over other items when using the mouse."));
+const listDropBetweenBackground = registerColor('list.dropBetweenBackground', { dark: iconForeground, light: iconForeground, hcDark: null, hcLight: null }, localize(1946, "List/Tree drag and drop border color when moving items between items when using the mouse."));
+const listHighlightForeground = registerColor('list.highlightForeground', { dark: '#2AAAFF', light: '#0066BF', hcDark: focusBorder, hcLight: focusBorder }, localize(1947, 'List/Tree foreground color of the match highlights when searching inside the list/tree.'));
+const listFocusHighlightForeground = registerColor('list.focusHighlightForeground', { dark: listHighlightForeground, light: ifDefinedThenElse(listActiveSelectionBackground, listHighlightForeground, '#BBE7FF'), hcDark: listHighlightForeground, hcLight: listHighlightForeground }, localize(1948, 'List/Tree foreground color of the match highlights on actively focused items when searching inside the list/tree.'));
+registerColor('list.invalidItemForeground', { dark: '#B89500', light: '#B89500', hcDark: '#B89500', hcLight: '#B5200D' }, localize(1949, 'List/Tree foreground color for invalid items, for example an unresolved root in explorer.'));
+registerColor('list.errorForeground', { dark: '#F88070', light: '#B01011', hcDark: null, hcLight: null }, localize(1950, 'Foreground color of list items containing errors.'));
+registerColor('list.warningForeground', { dark: '#CCA700', light: '#855F00', hcDark: null, hcLight: null }, localize(1951, 'Foreground color of list items containing warnings.'));
+const listFilterWidgetBackground = registerColor('listFilterWidget.background', { light: darken(editorWidgetBackground, 0), dark: lighten(editorWidgetBackground, 0), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, localize(1952, 'Background color of the type filter widget in lists and trees.'));
+const listFilterWidgetOutline = registerColor('listFilterWidget.outline', { dark: Color.transparent, light: Color.transparent, hcDark: '#f38518', hcLight: '#007ACC' }, localize(1953, 'Outline color of the type filter widget in lists and trees.'));
+const listFilterWidgetNoMatchesOutline = registerColor('listFilterWidget.noMatchesOutline', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1954, 'Outline color of the type filter widget in lists and trees, when there are no matches.'));
+const listFilterWidgetShadow = registerColor('listFilterWidget.shadow', widgetShadow, localize(1955, 'Shadow color of the type filter widget in lists and trees.'));
+registerColor('list.filterMatchBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, localize(1956, 'Background color of the filtered match.'));
+registerColor('list.filterMatchBorder', { dark: editorFindMatchHighlightBorder, light: editorFindMatchHighlightBorder, hcDark: contrastBorder, hcLight: activeContrastBorder }, localize(1957, 'Border color of the filtered match.'));
+registerColor('list.deemphasizedForeground', { dark: '#8C8C8C', light: '#8E8E90', hcDark: '#A7A8A9', hcLight: '#666666' }, localize(1958, "List/Tree foreground color for items that are deemphasized."));
 // ------ tree
-const treeIndentGuidesStroke = registerColor('tree.indentGuidesStroke', { dark: '#585858', light: '#a9a9a9', hcDark: '#a9a9a9', hcLight: '#a5a5a5' }, localize(1955, "Tree stroke color for the indentation guides."));
-const treeInactiveIndentGuidesStroke = registerColor('tree.inactiveIndentGuidesStroke', transparent(treeIndentGuidesStroke, 0.4), localize(1956, "Tree stroke color for the indentation guides that are not active."));
+const treeIndentGuidesStroke = registerColor('tree.indentGuidesStroke', { dark: '#585858', light: '#a9a9a9', hcDark: '#a9a9a9', hcLight: '#a5a5a5' }, localize(1959, "Tree stroke color for the indentation guides."));
+const treeInactiveIndentGuidesStroke = registerColor('tree.inactiveIndentGuidesStroke', transparent(treeIndentGuidesStroke, 0.4), localize(1960, "Tree stroke color for the indentation guides that are not active."));
 // ------ table
-const tableColumnsBorder = registerColor('tree.tableColumnsBorder', { dark: '#CCCCCC20', light: '#61616120', hcDark: null, hcLight: null }, localize(1957, "Table border color between columns."));
-const tableOddRowsBackgroundColor = registerColor('tree.tableOddRowsBackground', { dark: transparent(foreground, 0.04), light: transparent(foreground, 0.04), hcDark: null, hcLight: null }, localize(1958, "Background color for odd table rows."));
+const tableColumnsBorder = registerColor('tree.tableColumnsBorder', { dark: '#CCCCCC20', light: '#61616120', hcDark: null, hcLight: null }, localize(1961, "Table border color between columns."));
+const tableOddRowsBackgroundColor = registerColor('tree.tableOddRowsBackground', { dark: transparent(foreground, 0.04), light: transparent(foreground, 0.04), hcDark: null, hcLight: null }, localize(1962, "Background color for odd table rows."));
 // ------ action list
-registerColor('editorActionList.background', editorWidgetBackground, localize(1959, "Action List background color."));
-const editorActionListForeground = registerColor('editorActionList.foreground', editorWidgetForeground, localize(1960, "Action List foreground color."));
-registerColor('editorActionList.focusForeground', listActiveSelectionForeground, localize(1961, "Action List foreground color for the focused item."));
-registerColor('editorActionList.focusBackground', listActiveSelectionBackground, localize(1962, "Action List background color for the focused item."));
+registerColor('editorActionList.background', editorWidgetBackground, localize(1963, "Action List background color."));
+const editorActionListForeground = registerColor('editorActionList.foreground', editorWidgetForeground, localize(1964, "Action List foreground color."));
+registerColor('editorActionList.focusForeground', listActiveSelectionForeground, localize(1965, "Action List foreground color for the focused item."));
+registerColor('editorActionList.focusBackground', listActiveSelectionBackground, localize(1966, "Action List background color for the focused item."));
 
 export { editorActionListForeground, listActiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionIconForeground, listDropBetweenBackground, listDropOverBackground, listFilterWidgetBackground, listFilterWidgetNoMatchesOutline, listFilterWidgetOutline, listFilterWidgetShadow, listFocusAndSelectionOutline, listFocusBackground, listFocusForeground, listFocusHighlightForeground, listFocusOutline, listHighlightForeground, listHoverBackground, listHoverForeground, listInactiveFocusBackground, listInactiveFocusOutline, listInactiveSelectionBackground, listInactiveSelectionForeground, listInactiveSelectionIconForeground, tableColumnsBorder, tableOddRowsBackgroundColor, treeInactiveIndentGuidesStroke, treeIndentGuidesStroke };

package/esm/vs/platform/theme/common/colors/menuColors.js

@@ -8,12 +8,12 @@ import { listActiveSelectionForeground, listActiveSelectionBackground } from './
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-const menuBorder = registerColor('menu.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1963, "Border color of menus."));
-const menuForeground = registerColor('menu.foreground', selectForeground, localize(1964, "Foreground color of menu items."));
-const menuBackground = registerColor('menu.background', selectBackground, localize(1965, "Background color of menu items."));
-const menuSelectionForeground = registerColor('menu.selectionForeground', listActiveSelectionForeground, localize(1966, "Foreground color of the selected menu item in menus."));
-const menuSelectionBackground = registerColor('menu.selectionBackground', listActiveSelectionBackground, localize(1967, "Background color of the selected menu item in menus."));
-const menuSelectionBorder = registerColor('menu.selectionBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1968, "Border color of the selected menu item in menus."));
-const menuSeparatorBackground = registerColor('menu.separatorBackground', { dark: '#606060', light: '#D4D4D4', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1969, "Color of a separator menu item in menus."));
+const menuBorder = registerColor('menu.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, localize(1967, "Border color of menus."));
+const menuForeground = registerColor('menu.foreground', selectForeground, localize(1968, "Foreground color of menu items."));
+const menuBackground = registerColor('menu.background', selectBackground, localize(1969, "Background color of menu items."));
+const menuSelectionForeground = registerColor('menu.selectionForeground', listActiveSelectionForeground, localize(1970, "Foreground color of the selected menu item in menus."));
+const menuSelectionBackground = registerColor('menu.selectionBackground', listActiveSelectionBackground, localize(1971, "Background color of the selected menu item in menus."));
+const menuSelectionBorder = registerColor('menu.selectionBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(1972, "Border color of the selected menu item in menus."));
+const menuSeparatorBackground = registerColor('menu.separatorBackground', { dark: '#606060', light: '#D4D4D4', hcDark: contrastBorder, hcLight: contrastBorder }, localize(1973, "Color of a separator menu item in menus."));
 
 export { menuBackground, menuBorder, menuForeground, menuSelectionBackground, menuSelectionBorder, menuSelectionForeground, menuSeparatorBackground };