@lvce-editor/settings-view 1.5.0 → 1.7.0

package/dist/settingsViewWorkerMain.js

@@ -914,10 +914,34 @@ const terminate = () => {
   globalThis.close();
 };
 
-const clear = state => {
+const getFilteredItems = (items, tabs, searchValue = '') => {
+  const selectedTab = tabs.find(tab => tab.selected);
+  if (!selectedTab) {
+    return items;
+  }
+  const tabFilteredItems = items.filter(item => item.category === selectedTab.id);
+  if (!searchValue.trim()) {
+    return tabFilteredItems;
+  }
+  const normalizedSearchValue = searchValue.toLowerCase().trim();
+  return tabFilteredItems.filter(item => item.heading.toLowerCase().includes(normalizedSearchValue));
+};
+
+const User = 1;
+const Script = 2;
+
+const clear$1 = state => {
+  const {
+    items,
+    tabs
+  } = state;
+  const newSearchValue = '';
+  const filteredItems = getFilteredItems(items, tabs, newSearchValue);
   return {
     ...state,
-    searchValue: ''
+    searchValue: newSearchValue,
+    inputSource: Script,
+    filteredItems
   };
 };
 
@@ -944,24 +968,33 @@ const create$1 = (id, uri, x, y, width, height) => {
     tabs: [],
     items: [],
     searchValue: '',
-    filteredItems: []
+    filteredItems: [],
+    preferences: {},
+    inputSource: 0,
+    scrollOffset: 0,
+    filteredItemsCount: 0
   };
   set$1(id, state, state);
 };
 
-const isEqual$1 = (oldState, newState) => {
+const isEqual$2 = (oldState, newState) => {
   return oldState.focus === newState.focus;
 };
 
-const isEqual = (oldState, newState) => {
+const isEqual$1 = (oldState, newState) => {
   return oldState === newState;
 };
 
 const RenderItems = 1;
 const RenderFocus = 2;
+const RenderValue = 3;
+
+const isEqual = (oldState, newState) => {
+  return newState.inputSource === User || oldState.searchValue === newState.searchValue;
+};
 
-const modules = [isEqual$1, isEqual];
-const numbers = [RenderFocus, RenderItems];
+const modules = [isEqual$2, isEqual$1, isEqual];
+const numbers = [RenderFocus, RenderItems, RenderValue];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -983,14 +1016,6 @@ const diff2 = uid => {
   return diffResult;
 };
 
-const getFilteredItems = (items, tabs) => {
-  const selectedTab = tabs.find(tab => tab.selected);
-  if (!selectedTab) {
-    return items;
-  }
-  return items.filter(item => item.category === selectedTab.id);
-};
-
 const getSelectedTabId = tabs => {
   for (const tab of tabs) {
     if (tab.selected) {
@@ -1016,8 +1041,13 @@ const handleClickTab = (state, name) => {
   if (!name) {
     return state;
   }
-  const updatedTabs = getUpdatedTabs(state.tabs, name);
-  const filteredItems = getFilteredItems(state.items, updatedTabs);
+  const {
+    items,
+    tabs,
+    searchValue
+  } = state;
+  const updatedTabs = getUpdatedTabs(tabs, name);
+  const filteredItems = getFilteredItems(items, updatedTabs, searchValue);
   return {
     ...state,
     tabs: updatedTabs,
@@ -1026,9 +1056,16 @@ const handleClickTab = (state, name) => {
 };
 
 const handleInput = (state, value) => {
+  const {
+    items,
+    tabs
+  } = state;
+  const filteredItems = getFilteredItems(items, tabs, value);
   return {
     ...state,
-    searchValue: value
+    searchValue: value,
+    filteredItems,
+    inputSource: User
   };
 };
 
@@ -1036,8 +1073,12 @@ const initialize = async () => {
   // TODO
 };
 
+const getPreferences = async () => {
+  return {};
+};
+
 const ApplicationsTab = 'applications';
-const Clear = 'Clear';
+const Clear$1 = 'Clear';
 const ExtensionsTab = 'extensions';
 const FeaturesTab = 'features';
 const SecurityTab = 'security';
@@ -1046,106 +1087,1991 @@ const TextEditorTab = 'text-editor';
 const WindowTab = 'window';
 const WorkbenchTab = 'workbench';
 
+const Enum = 1;
 const String = 2;
 const Boolean$1 = 3;
 const Number$1 = 5;
 
-const getSettingItems = async () => {
-  return [{
-    id: 'fontSize',
-    heading: 'Font Size',
-    description: 'The font size of the editor',
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const AutoSave = 'Auto Save';
+const AutoSaveDescription = 'Automatically save files';
+const AutoUpdateExtensions = 'Auto Update Extensions';
+const AutoUpdateExtensionsDescription = 'Automatically update extensions';
+const AutoUpdates = 'Auto Updates';
+const AutoUpdatesDescription = 'Automatically check for updates';
+const Clear = 'Clear';
+const ExtensionRecommendations = 'Extension Recommendations';
+const ExtensionRecommendationsDescription = 'Show extension recommendations';
+const FileEncryption = 'File Encryption';
+const FileEncryptionDescription = 'Encrypt sensitive files';
+const FontFamily = 'Font Family';
+const FontFamilyDescription = 'The font family of the editor';
+const FontSize = 'Font Size';
+const FontSizeDescription = 'The font size of the editor';
+const FormatOnSave = 'Format on Save';
+const FormatOnSaveDescription = 'Format code when saving';
+const NumberValue = 'number value';
+const SearchSettings = 'Search Settings';
+const SettingsContent = 'Settings Content';
+const SidebarPosition = 'Sidebar Position';
+const SidebarPositionDescription = 'The position of the sidebar';
+const Telemetry = 'Telemetry';
+const TelemetryDescription = 'Enable telemetry collection';
+const Theme = 'Theme';
+const ThemeDescription = 'The color theme of the workbench';
+const TwoFactorAuth = 'Two Factor Auth';
+const TwoFactorAuthDescription = 'Enable two factor authentication';
+const WindowSize = 'Window Size';
+const WindowSizeDescription = 'The default window size';
+const WindowTitle = 'Window Title';
+const WindowTitleDescription = 'The title shown in the window';
+const NoSettingsMatching = 'No settings matching "{PH1}" found';
+
+// Text Editor Settings
+const WordWrap = 'Word Wrap';
+const WordWrapDescription = 'Controls how lines should wrap';
+const LineNumbers = 'Line Numbers';
+const LineNumbersDescription = 'Controls the display of line numbers';
+const Minimap = 'Minimap';
+const MinimapDescription = 'Controls whether the minimap is shown';
+const ScrollBeyondLastLine = 'Scroll Beyond Last Line';
+const ScrollBeyondLastLineDescription = 'Controls whether the editor will scroll beyond the last line';
+const SmoothScrolling = 'Smooth Scrolling';
+const SmoothScrollingDescription = 'Controls whether the editor will scroll smoothly';
+const CursorBlinking = 'Cursor Blinking';
+const CursorBlinkingDescription = 'Controls how the cursor should blink';
+const CursorStyle = 'Cursor Style';
+const CursorStyleDescription = 'Controls the cursor style';
+const CursorWidth = 'Cursor Width';
+const CursorWidthDescription = 'Controls the width of the cursor';
+const TabSize = 'Tab Size';
+const TabSizeDescription = 'The number of spaces a tab is equal to';
+const InsertSpaces = 'Insert Spaces';
+const InsertSpacesDescription = 'Insert spaces when pressing Tab';
+const DetectIndentation = 'Detect Indentation';
+const DetectIndentationDescription = 'Controls whether the editor will automatically adjust the indentation';
+const TrimAutoWhitespace = 'Trim Auto Whitespace';
+const TrimAutoWhitespaceDescription = 'Remove trailing auto inserted whitespace';
+const LargeFileOptimizations = 'Large File Optimizations';
+const LargeFileOptimizationsDescription = 'Special handling for large files to disable certain features';
+const RenderWhitespace = 'Render Whitespace';
+const RenderWhitespaceDescription = 'Controls how the editor should render whitespace characters';
+const RenderControlCharacters = 'Render Control Characters';
+const RenderControlCharactersDescription = 'Controls whether the editor should render control characters';
+const RenderLineHighlight = 'Render Line Highlight';
+const RenderLineHighlightDescription = 'Controls how the editor should render the current line highlight';
+const CodeLens = 'Code Lens';
+const CodeLensDescription = 'Controls whether the editor shows CodeLens';
+const Folding = 'Folding';
+const FoldingDescription = 'Controls whether the editor has code folding enabled';
+const ShowFoldingControls = 'Show Folding Controls';
+const ShowFoldingControlsDescription = 'Controls when the folding controls on the gutter are automatically hidden';
+const UnfoldOnClickAfterEnd = 'Unfold On Click After End';
+const UnfoldOnClickAfterEndDescription = 'Controls whether clicking on the empty content after a folded line will unfold the line';
+const Links = 'Links';
+const LinksDescription = 'Controls whether the editor should detect links and make them clickable';
+const ColorDecorators = 'Color Decorators';
+const ColorDecoratorsDescription = 'Controls whether the editor should render the inline color decorators and color picker';
+const Lightbulb = 'Lightbulb';
+const LightbulbDescription = 'Controls whether the editor should show the lightbulb code action';
+const CodeActionsOnSave = 'Code Actions On Save';
+const CodeActionsOnSaveDescription = 'Code actions to be run on save';
+const FormatOnPaste = 'Format On Paste';
+const FormatOnPasteDescription = 'Format a file on paste';
+const FormatOnType = 'Format On Type';
+const FormatOnTypeDescription = 'Format a file on type';
+const AcceptSuggestionOnCommitCharacter = 'Accept Suggestion On Commit Character';
+const AcceptSuggestionOnCommitCharacterDescription = 'Controls if suggestions should be accepted on commit characters';
+const AcceptSuggestionOnEnter = 'Accept Suggestion On Enter';
+const AcceptSuggestionOnEnterDescription = 'Controls if suggestions should be accepted on Enter';
+const TabCompletion = 'Tab Completion';
+const TabCompletionDescription = 'Enables tab completions';
+const WordBasedSuggestions = 'Word Based Suggestions';
+const WordBasedSuggestionsDescription = 'Controls whether completions should be computed based on words in the document';
+const SuggestOnTriggerCharacters = 'Suggest On Trigger Characters';
+const SuggestOnTriggerCharactersDescription = 'Controls whether suggestions should automatically show up when typing trigger characters';
+const QuickSuggestions = 'Quick Suggestions';
+const QuickSuggestionsDescription = 'Controls whether suggestions should automatically show up while typing';
+const ParameterHints = 'Parameter Hints';
+const ParameterHintsDescription = 'Controls whether the editor should show parameter hints';
+const AutoClosingBrackets = 'Auto Closing Brackets';
+const AutoClosingBracketsDescription = 'Controls whether the editor should automatically close brackets after opening them';
+const AutoClosingQuotes = 'Auto Closing Quotes';
+const AutoClosingQuotesDescription = 'Controls whether the editor should automatically close quotes after opening them';
+const AutoClosingOvertype = 'Auto Closing Overtype';
+const AutoClosingOvertypeDescription = 'Controls whether the editor should type over closing quotes or brackets';
+const AutoClosingDelete = 'Auto Closing Delete';
+const AutoClosingDeleteDescription = 'Controls whether the editor should remove adjacent closing quotes or brackets when deleting';
+const AutoSurround = 'Auto Surround';
+const AutoSurroundDescription = 'Controls whether the editor should automatically surround selections';
+const BracketPairColorization = 'Bracket Pair Colorization';
+const BracketPairColorizationDescription = 'Controls whether the editor should enable bracket pair colorization';
+const Guides = 'Guides';
+const GuidesDescription = 'Controls whether the editor should render bracket pair guides';
+const DragAndDrop = 'Drag And Drop';
+const DragAndDropDescription = 'Controls whether the editor allows moving selections via drag and drop';
+const CopyWithSyntaxHighlighting = 'Copy With Syntax Highlighting';
+const CopyWithSyntaxHighlightingDescription = 'Controls whether syntax highlighting should be copied when copying text';
+const MultiCursorModifier = 'Multi Cursor Modifier';
+const MultiCursorModifierDescription = 'The modifier to be used to add multiple cursors with the mouse';
+const MultiCursorPaste = 'Multi Cursor Paste';
+const MultiCursorPasteDescription = 'Controls how the editor should handle multiple cursors when pasting';
+const OccurrencesHighlight = 'Occurrences Highlight';
+const OccurrencesHighlightDescription = 'Controls whether the editor should highlight similar matches to the selection';
+const SelectionHighlight = 'Selection Highlight';
+const SelectionHighlightDescription = 'Controls whether the editor should highlight similar matches to the selection';
+const SemanticHighlighting = 'Semantic Highlighting';
+const SemanticHighlightingDescription = 'Controls whether the editor should enable semantic highlighting';
+const TokenColorCustomizations = 'Token Color Customizations';
+const TokenColorCustomizationsDescription = 'Overrides editor syntax highlighting colors';
+const WorkbenchColorCustomizations = 'Workbench Color Customizations';
+const WorkbenchColorCustomizationsDescription = 'Overrides workbench colors';
+const EditorColorCustomizations = 'Editor Color Customizations';
+const EditorColorCustomizationsDescription = 'Overrides editor colors';
+const DiffEditor = 'Diff Editor';
+const DiffEditorDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffWordWrap = 'Diff Word Wrap';
+const DiffWordWrapDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffCodeLens = 'Diff Code Lens';
+const DiffCodeLensDescription = 'Controls whether the diff editor shows code lens';
+const DiffRenderSideBySide = 'Diff Render Side By Side';
+const DiffRenderSideBySideDescription = 'Controls whether the diff editor shows the diff side by side or inline';
+const DiffIgnoreTrimWhitespace = 'Diff Ignore Trim Whitespace';
+const DiffIgnoreTrimWhitespaceDescription = 'Controls whether the diff editor ignores changes in whitespace';
+const DiffRenderIndicators = 'Diff Render Indicators';
+const DiffRenderIndicatorsDescription = 'Controls whether the diff editor shows indicators';
+const DiffRenderOverviewRuler = 'Diff Render Overview Ruler';
+const DiffRenderOverviewRulerDescription = 'Controls whether the diff editor shows the overview ruler';
+const DiffRenderMarginRevertIcon = 'Diff Render Margin Revert Icon';
+const DiffRenderMarginRevertIconDescription = 'Controls whether the diff editor shows the revert icon in the margin';
+
+// Additional Text Editor Settings
+const InsertMode = 'Insert Mode';
+const InsertModeDescription = 'Controls whether the editor is in insert mode';
+const OverwriteMode = 'Overwrite Mode';
+const OverwriteModeDescription = 'Controls whether the editor is in overwrite mode';
+const ReadOnly = 'Read Only';
+const ReadOnlyDescription = 'Controls whether the editor is read only';
+const AccessibilitySupport = 'Accessibility Support';
+const AccessibilitySupportDescription = 'Controls whether the editor should run in a mode where it is optimized for screen readers';
+const AutoIndent = 'Auto Indent';
+const AutoIndentDescription = 'Controls whether the editor should automatically adjust the indentation';
+const BracketMatching = 'Bracket Matching';
+const BracketMatchingDescription = 'Controls whether the editor should highlight matching brackets';
+const CenteredLayout = 'Centered Layout';
+const CenteredLayoutDescription = 'Controls whether the editor should use centered layout';
+const ColumnSelection = 'Column Selection';
+const ColumnSelectionDescription = 'Controls whether the editor should support column selection';
+const Contextmenu = 'Context Menu';
+const ContextmenuDescription = 'Controls whether the editor should show the context menu';
+const CursorSmoothCaretAnimation = 'Cursor Smooth Caret Animation';
+const CursorSmoothCaretAnimationDescription = 'Controls whether the cursor should be animated';
+const CursorSurroundingLines = 'Cursor Surrounding Lines';
+const CursorSurroundingLinesDescription = 'Controls the number of extra characters beyond which the editor will scroll horizontally';
+const CursorSurroundingLinesStyle = 'Cursor Surrounding Lines Style';
+const CursorSurroundingLinesStyleDescription = 'Controls when the cursor should be hidden';
+const DisableMonospaceOptimizations = 'Disable Monospace Optimizations';
+const DisableMonospaceOptimizationsDescription = 'Controls whether the editor should disable optimizations for monospace fonts';
+const EmptySelectionClipboard = 'Empty Selection Clipboard';
+const EmptySelectionClipboardDescription = 'Controls whether copying without a selection copies the current line';
+const ExtraEditorClassName = 'Extra Editor Class Name';
+const ExtraEditorClassNameDescription = 'An extra class name to add to the editor';
+const FastScrollSensitivity = 'Fast Scroll Sensitivity';
+const FastScrollSensitivityDescription = 'Scrolling speed multiplier when pressing Alt';
+const Find = 'Find';
+const FindDescription = 'Controls whether the editor should add extra space on the bottom';
+const FixedOverflowWidgets = 'Fixed Overflow Widgets';
+const FixedOverflowWidgetsDescription = 'Controls whether the editor should scroll beyond the last line';
+const FoldingStrategy = 'Folding Strategy';
+const FoldingStrategyDescription = 'Controls the folding strategy';
+const FontLigatures = 'Font Ligatures';
+const FontLigaturesDescription = 'Enables/Disables font ligatures';
+const GlyphMargin = 'Glyph Margin';
+const GlyphMarginDescription = 'Controls whether the editor should render the vertical glyph margin';
+const GotoLocation = 'Go To Location';
+const GotoLocationDescription = "Controls the behavior the 'Go to Definition'-mouse gesture";
+const HideCursorInOverviewRuler = 'Hide Cursor In Overview Ruler';
+const HideCursorInOverviewRulerDescription = 'Controls whether the cursor should be hidden in the overview ruler';
+const Hover = 'Hover';
+const HoverDescription = 'Controls whether the editor should show hover';
+const InDiffEditor = 'In Diff Editor';
+const InDiffEditorDescription = 'Controls whether the editor should be in a diff editor';
+const LetterSpacing = 'Letter Spacing';
+const LetterSpacingDescription = 'The letter spacing';
+const LightbulbEnabled = 'Lightbulb Enabled';
+const LightbulbEnabledDescription = 'Controls whether the editor should show the lightbulb code action';
+const LineDecorationsWidth = 'Line Decorations Width';
+const LineDecorationsWidthDescription = 'The width reserved for line decorations (in px)';
+const LineHeight = 'Line Height';
+const LineHeightDescription = 'The line height';
+const MatchBrackets = 'Match Brackets';
+const MatchBracketsDescription = 'Controls whether the editor should highlight matching brackets';
+const MinimapEnabled = 'Minimap Enabled';
+const MinimapEnabledDescription = 'Controls whether the minimap is shown';
+const MouseWheelScrollSensitivity = 'Mouse Wheel Scroll Sensitivity';
+const MouseWheelScrollSensitivityDescription = 'A multiplier to be used on the deltaX and deltaY of mouse wheel scroll events';
+const MouseWheelZoom = 'Mouse Wheel Zoom';
+const MouseWheelZoomDescription = 'Zoom the font of the editor when using mouse wheel and holding Ctrl';
+const MultiCursorMergeOverlapping = 'Multi Cursor Merge Overlapping';
+const MultiCursorMergeOverlappingDescription = 'Merge overlapping selections';
+const OverviewRulerBorder = 'Overview Ruler Border';
+const OverviewRulerBorderDescription = 'Controls whether a border should be drawn around the overview ruler';
+const OverviewRulerLanes = 'Overview Ruler Lanes';
+const OverviewRulerLanesDescription = 'Controls the number of decorations that can show in the overview ruler';
+const PeekWidgetDefaultFocus = 'Peek Widget Default Focus';
+const PeekWidgetDefaultFocusDescription = 'Controls if the peek widget should be focused by default';
+const QuickSuggestionsDelay = 'Quick Suggestions Delay';
+const QuickSuggestionsDelayDescription = 'Controls the delay in milliseconds after which quick suggestions will show up';
+const RenderFinalNewline = 'Render Final Newline';
+const RenderFinalNewlineDescription = 'Controls whether the editor should render the final newline as a space';
+const RenderValidationDecorations = 'Render Validation Decorations';
+const RenderValidationDecorationsDescription = 'Controls whether the editor should render validation decorations';
+const RevealHorizontalRightPadding = 'Reveal Horizontal Right Padding';
+const RevealHorizontalRightPaddingDescription = 'When revealing the cursor, a virtual padding (px) is added to the cursor, turning on a block cursor';
+const RoundedSelection = 'Rounded Selection';
+const RoundedSelectionDescription = 'Controls whether selections should have rounded corners';
+const Rulers = 'Rulers';
+const RulersDescription = 'Render vertical rulers at a certain number of monospace characters';
+const ScrollBeyondLastColumn = 'Scroll Beyond Last Column';
+const ScrollBeyondLastColumnDescription = 'Controls how many characters the editor will scroll horizontally';
+const Scrollbar = 'Scrollbar';
+const ScrollbarDescription = 'Controls the visibility and behavior of the scrollbars';
+const ScrollPredominantAxis = 'Scroll Predominant Axis';
+const ScrollPredominantAxisDescription = 'Scroll only along the predominant axis when scrolling both vertically and horizontally at the same time';
+const SelectionClipboard = 'Selection Clipboard';
+const SelectionClipboardDescription = 'Controls whether the editor should use the CLIPBOARD selection';
+const ShowUnused = 'Show Unused';
+const ShowUnusedDescription = 'Controls fading out of unused code';
+const SnippetSuggestions = 'Snippet Suggestions';
+const SnippetSuggestionsDescription = 'Controls whether snippets are shown with other suggestions and how they are sorted';
+const Suggest = 'Suggest';
+const SuggestDescription = 'Controls whether suggestions should automatically show up while typing';
+const SuggestFontSize = 'Suggest Font Size';
+const SuggestFontSizeDescription = 'Font size for the suggest widget';
+const SuggestLineHeight = 'Suggest Line Height';
+const SuggestLineHeightDescription = 'Line height for the suggest widget';
+const SuggestSelection = 'Suggest Selection';
+const SuggestSelectionDescription = 'Controls how suggestions are selected when showing the suggest widget';
+const UseTabStops = 'Use Tab Stops';
+const UseTabStopsDescription = 'Inserting and deleting whitespace follows tab stops';
+const WordSeparators = 'Word Separators';
+const WordSeparatorsDescription = 'Characters that will be used as word separators when doing word related navigations or operations';
+const WrappingIndent = 'Wrapping Indent';
+const WrappingIndentDescription = 'Controls the indentation of wrapped lines';
+
+const autoSave = () => {
+  return i18nString(AutoSave);
+};
+const autoSaveDescription = () => {
+  return i18nString(AutoSaveDescription);
+};
+const autoUpdateExtensions = () => {
+  return i18nString(AutoUpdateExtensions);
+};
+const autoUpdateExtensionsDescription = () => {
+  return i18nString(AutoUpdateExtensionsDescription);
+};
+const autoUpdates = () => {
+  return i18nString(AutoUpdates);
+};
+const autoUpdatesDescription = () => {
+  return i18nString(AutoUpdatesDescription);
+};
+const clear = () => {
+  return i18nString(Clear);
+};
+const extensionRecommendations = () => {
+  return i18nString(ExtensionRecommendations);
+};
+const extensionRecommendationsDescription = () => {
+  return i18nString(ExtensionRecommendationsDescription);
+};
+const fileEncryption = () => {
+  return i18nString(FileEncryption);
+};
+const fileEncryptionDescription = () => {
+  return i18nString(FileEncryptionDescription);
+};
+const fontFamily = () => {
+  return i18nString(FontFamily);
+};
+const fontFamilyDescription = () => {
+  return i18nString(FontFamilyDescription);
+};
+const fontSize = () => {
+  return i18nString(FontSize);
+};
+const fontSizeDescription = () => {
+  return i18nString(FontSizeDescription);
+};
+const formatOnSave = () => {
+  return i18nString(FormatOnSave);
+};
+const formatOnSaveDescription = () => {
+  return i18nString(FormatOnSaveDescription);
+};
+const numberValue = () => {
+  return i18nString(NumberValue);
+};
+const searchSettings = () => {
+  return i18nString(SearchSettings);
+};
+const settingsContent = () => {
+  return i18nString(SettingsContent);
+};
+const sidebarPosition = () => {
+  return i18nString(SidebarPosition);
+};
+const sidebarPositionDescription = () => {
+  return i18nString(SidebarPositionDescription);
+};
+const telemetry = () => {
+  return i18nString(Telemetry);
+};
+const telemetryDescription = () => {
+  return i18nString(TelemetryDescription);
+};
+const theme = () => {
+  return i18nString(Theme);
+};
+const themeDescription = () => {
+  return i18nString(ThemeDescription);
+};
+const twoFactorAuth = () => {
+  return i18nString(TwoFactorAuth);
+};
+const twoFactorAuthDescription = () => {
+  return i18nString(TwoFactorAuthDescription);
+};
+const windowSize = () => {
+  return i18nString(WindowSize);
+};
+const windowSizeDescription = () => {
+  return i18nString(WindowSizeDescription);
+};
+const windowTitle = () => {
+  return i18nString(WindowTitle);
+};
+const windowTitleDescription = () => {
+  return i18nString(WindowTitleDescription);
+};
+const noSettingsMatching = searchTerm => {
+  return i18nString(NoSettingsMatching, {
+    PH1: searchTerm
+  });
+};
+
+// Text Editor Settings
+const wordWrap = () => {
+  return i18nString(WordWrap);
+};
+const wordWrapDescription = () => {
+  return i18nString(WordWrapDescription);
+};
+const lineNumbers = () => {
+  return i18nString(LineNumbers);
+};
+const lineNumbersDescription = () => {
+  return i18nString(LineNumbersDescription);
+};
+const minimap = () => {
+  return i18nString(Minimap);
+};
+const minimapDescription = () => {
+  return i18nString(MinimapDescription);
+};
+const scrollBeyondLastLine = () => {
+  return i18nString(ScrollBeyondLastLine);
+};
+const scrollBeyondLastLineDescription = () => {
+  return i18nString(ScrollBeyondLastLineDescription);
+};
+const smoothScrolling = () => {
+  return i18nString(SmoothScrolling);
+};
+const smoothScrollingDescription = () => {
+  return i18nString(SmoothScrollingDescription);
+};
+const cursorBlinking = () => {
+  return i18nString(CursorBlinking);
+};
+const cursorBlinkingDescription = () => {
+  return i18nString(CursorBlinkingDescription);
+};
+const cursorStyle = () => {
+  return i18nString(CursorStyle);
+};
+const cursorStyleDescription = () => {
+  return i18nString(CursorStyleDescription);
+};
+const cursorWidth = () => {
+  return i18nString(CursorWidth);
+};
+const cursorWidthDescription = () => {
+  return i18nString(CursorWidthDescription);
+};
+const tabSize = () => {
+  return i18nString(TabSize);
+};
+const tabSizeDescription = () => {
+  return i18nString(TabSizeDescription);
+};
+const insertSpaces = () => {
+  return i18nString(InsertSpaces);
+};
+const insertSpacesDescription = () => {
+  return i18nString(InsertSpacesDescription);
+};
+const detectIndentation = () => {
+  return i18nString(DetectIndentation);
+};
+const detectIndentationDescription = () => {
+  return i18nString(DetectIndentationDescription);
+};
+const trimAutoWhitespace = () => {
+  return i18nString(TrimAutoWhitespace);
+};
+const trimAutoWhitespaceDescription = () => {
+  return i18nString(TrimAutoWhitespaceDescription);
+};
+const largeFileOptimizations = () => {
+  return i18nString(LargeFileOptimizations);
+};
+const largeFileOptimizationsDescription = () => {
+  return i18nString(LargeFileOptimizationsDescription);
+};
+const renderWhitespace = () => {
+  return i18nString(RenderWhitespace);
+};
+const renderWhitespaceDescription = () => {
+  return i18nString(RenderWhitespaceDescription);
+};
+const renderControlCharacters = () => {
+  return i18nString(RenderControlCharacters);
+};
+const renderControlCharactersDescription = () => {
+  return i18nString(RenderControlCharactersDescription);
+};
+const renderLineHighlight = () => {
+  return i18nString(RenderLineHighlight);
+};
+const renderLineHighlightDescription = () => {
+  return i18nString(RenderLineHighlightDescription);
+};
+const codeLens = () => {
+  return i18nString(CodeLens);
+};
+const codeLensDescription = () => {
+  return i18nString(CodeLensDescription);
+};
+const folding = () => {
+  return i18nString(Folding);
+};
+const foldingDescription = () => {
+  return i18nString(FoldingDescription);
+};
+const showFoldingControls = () => {
+  return i18nString(ShowFoldingControls);
+};
+const showFoldingControlsDescription = () => {
+  return i18nString(ShowFoldingControlsDescription);
+};
+const unfoldOnClickAfterEnd = () => {
+  return i18nString(UnfoldOnClickAfterEnd);
+};
+const unfoldOnClickAfterEndDescription = () => {
+  return i18nString(UnfoldOnClickAfterEndDescription);
+};
+const links = () => {
+  return i18nString(Links);
+};
+const linksDescription = () => {
+  return i18nString(LinksDescription);
+};
+const colorDecorators = () => {
+  return i18nString(ColorDecorators);
+};
+const colorDecoratorsDescription = () => {
+  return i18nString(ColorDecoratorsDescription);
+};
+const lightbulb = () => {
+  return i18nString(Lightbulb);
+};
+const lightbulbDescription = () => {
+  return i18nString(LightbulbDescription);
+};
+const codeActionsOnSave = () => {
+  return i18nString(CodeActionsOnSave);
+};
+const codeActionsOnSaveDescription = () => {
+  return i18nString(CodeActionsOnSaveDescription);
+};
+const formatOnPaste = () => {
+  return i18nString(FormatOnPaste);
+};
+const formatOnPasteDescription = () => {
+  return i18nString(FormatOnPasteDescription);
+};
+const formatOnType = () => {
+  return i18nString(FormatOnType);
+};
+const formatOnTypeDescription = () => {
+  return i18nString(FormatOnTypeDescription);
+};
+const acceptSuggestionOnCommitCharacter = () => {
+  return i18nString(AcceptSuggestionOnCommitCharacter);
+};
+const acceptSuggestionOnCommitCharacterDescription = () => {
+  return i18nString(AcceptSuggestionOnCommitCharacterDescription);
+};
+const acceptSuggestionOnEnter = () => {
+  return i18nString(AcceptSuggestionOnEnter);
+};
+const acceptSuggestionOnEnterDescription = () => {
+  return i18nString(AcceptSuggestionOnEnterDescription);
+};
+const tabCompletion = () => {
+  return i18nString(TabCompletion);
+};
+const tabCompletionDescription = () => {
+  return i18nString(TabCompletionDescription);
+};
+const wordBasedSuggestions = () => {
+  return i18nString(WordBasedSuggestions);
+};
+const wordBasedSuggestionsDescription = () => {
+  return i18nString(WordBasedSuggestionsDescription);
+};
+const suggestOnTriggerCharacters = () => {
+  return i18nString(SuggestOnTriggerCharacters);
+};
+const suggestOnTriggerCharactersDescription = () => {
+  return i18nString(SuggestOnTriggerCharactersDescription);
+};
+const quickSuggestions = () => {
+  return i18nString(QuickSuggestions);
+};
+const quickSuggestionsDescription = () => {
+  return i18nString(QuickSuggestionsDescription);
+};
+const parameterHints = () => {
+  return i18nString(ParameterHints);
+};
+const parameterHintsDescription = () => {
+  return i18nString(ParameterHintsDescription);
+};
+const autoClosingBrackets = () => {
+  return i18nString(AutoClosingBrackets);
+};
+const autoClosingBracketsDescription = () => {
+  return i18nString(AutoClosingBracketsDescription);
+};
+const autoClosingQuotes = () => {
+  return i18nString(AutoClosingQuotes);
+};
+const autoClosingQuotesDescription = () => {
+  return i18nString(AutoClosingQuotesDescription);
+};
+const autoClosingOvertype = () => {
+  return i18nString(AutoClosingOvertype);
+};
+const autoClosingOvertypeDescription = () => {
+  return i18nString(AutoClosingOvertypeDescription);
+};
+const autoClosingDelete = () => {
+  return i18nString(AutoClosingDelete);
+};
+const autoClosingDeleteDescription = () => {
+  return i18nString(AutoClosingDeleteDescription);
+};
+const autoSurround = () => {
+  return i18nString(AutoSurround);
+};
+const autoSurroundDescription = () => {
+  return i18nString(AutoSurroundDescription);
+};
+const bracketPairColorization = () => {
+  return i18nString(BracketPairColorization);
+};
+const bracketPairColorizationDescription = () => {
+  return i18nString(BracketPairColorizationDescription);
+};
+const guides = () => {
+  return i18nString(Guides);
+};
+const guidesDescription = () => {
+  return i18nString(GuidesDescription);
+};
+const dragAndDrop = () => {
+  return i18nString(DragAndDrop);
+};
+const dragAndDropDescription = () => {
+  return i18nString(DragAndDropDescription);
+};
+const copyWithSyntaxHighlighting = () => {
+  return i18nString(CopyWithSyntaxHighlighting);
+};
+const copyWithSyntaxHighlightingDescription = () => {
+  return i18nString(CopyWithSyntaxHighlightingDescription);
+};
+const multiCursorModifier = () => {
+  return i18nString(MultiCursorModifier);
+};
+const multiCursorModifierDescription = () => {
+  return i18nString(MultiCursorModifierDescription);
+};
+const multiCursorPaste = () => {
+  return i18nString(MultiCursorPaste);
+};
+const multiCursorPasteDescription = () => {
+  return i18nString(MultiCursorPasteDescription);
+};
+const occurrencesHighlight = () => {
+  return i18nString(OccurrencesHighlight);
+};
+const occurrencesHighlightDescription = () => {
+  return i18nString(OccurrencesHighlightDescription);
+};
+const selectionHighlight = () => {
+  return i18nString(SelectionHighlight);
+};
+const selectionHighlightDescription = () => {
+  return i18nString(SelectionHighlightDescription);
+};
+const semanticHighlighting = () => {
+  return i18nString(SemanticHighlighting);
+};
+const semanticHighlightingDescription = () => {
+  return i18nString(SemanticHighlightingDescription);
+};
+const tokenColorCustomizations = () => {
+  return i18nString(TokenColorCustomizations);
+};
+const tokenColorCustomizationsDescription = () => {
+  return i18nString(TokenColorCustomizationsDescription);
+};
+const workbenchColorCustomizations = () => {
+  return i18nString(WorkbenchColorCustomizations);
+};
+const workbenchColorCustomizationsDescription = () => {
+  return i18nString(WorkbenchColorCustomizationsDescription);
+};
+const editorColorCustomizations = () => {
+  return i18nString(EditorColorCustomizations);
+};
+const editorColorCustomizationsDescription = () => {
+  return i18nString(EditorColorCustomizationsDescription);
+};
+const diffEditor = () => {
+  return i18nString(DiffEditor);
+};
+const diffEditorDescription = () => {
+  return i18nString(DiffEditorDescription);
+};
+const diffWordWrap = () => {
+  return i18nString(DiffWordWrap);
+};
+const diffWordWrapDescription = () => {
+  return i18nString(DiffWordWrapDescription);
+};
+const diffCodeLens = () => {
+  return i18nString(DiffCodeLens);
+};
+const diffCodeLensDescription = () => {
+  return i18nString(DiffCodeLensDescription);
+};
+const diffRenderSideBySide = () => {
+  return i18nString(DiffRenderSideBySide);
+};
+const diffRenderSideBySideDescription = () => {
+  return i18nString(DiffRenderSideBySideDescription);
+};
+const diffIgnoreTrimWhitespace = () => {
+  return i18nString(DiffIgnoreTrimWhitespace);
+};
+const diffIgnoreTrimWhitespaceDescription = () => {
+  return i18nString(DiffIgnoreTrimWhitespaceDescription);
+};
+const diffRenderIndicators = () => {
+  return i18nString(DiffRenderIndicators);
+};
+const diffRenderIndicatorsDescription = () => {
+  return i18nString(DiffRenderIndicatorsDescription);
+};
+const diffRenderOverviewRuler = () => {
+  return i18nString(DiffRenderOverviewRuler);
+};
+const diffRenderOverviewRulerDescription = () => {
+  return i18nString(DiffRenderOverviewRulerDescription);
+};
+const diffRenderMarginRevertIcon = () => {
+  return i18nString(DiffRenderMarginRevertIcon);
+};
+const diffRenderMarginRevertIconDescription = () => {
+  return i18nString(DiffRenderMarginRevertIconDescription);
+};
+
+// Additional Text Editor Settings
+const insertMode = () => {
+  return i18nString(InsertMode);
+};
+const insertModeDescription = () => {
+  return i18nString(InsertModeDescription);
+};
+const overwriteMode = () => {
+  return i18nString(OverwriteMode);
+};
+const overwriteModeDescription = () => {
+  return i18nString(OverwriteModeDescription);
+};
+const readOnly = () => {
+  return i18nString(ReadOnly);
+};
+const readOnlyDescription = () => {
+  return i18nString(ReadOnlyDescription);
+};
+const accessibilitySupport = () => {
+  return i18nString(AccessibilitySupport);
+};
+const accessibilitySupportDescription = () => {
+  return i18nString(AccessibilitySupportDescription);
+};
+const autoIndent = () => {
+  return i18nString(AutoIndent);
+};
+const autoIndentDescription = () => {
+  return i18nString(AutoIndentDescription);
+};
+const bracketMatching = () => {
+  return i18nString(BracketMatching);
+};
+const bracketMatchingDescription = () => {
+  return i18nString(BracketMatchingDescription);
+};
+const centeredLayout = () => {
+  return i18nString(CenteredLayout);
+};
+const centeredLayoutDescription = () => {
+  return i18nString(CenteredLayoutDescription);
+};
+const columnSelection = () => {
+  return i18nString(ColumnSelection);
+};
+const columnSelectionDescription = () => {
+  return i18nString(ColumnSelectionDescription);
+};
+const contextmenu = () => {
+  return i18nString(Contextmenu);
+};
+const contextmenuDescription = () => {
+  return i18nString(ContextmenuDescription);
+};
+const cursorSmoothCaretAnimation = () => {
+  return i18nString(CursorSmoothCaretAnimation);
+};
+const cursorSmoothCaretAnimationDescription = () => {
+  return i18nString(CursorSmoothCaretAnimationDescription);
+};
+const cursorSurroundingLines = () => {
+  return i18nString(CursorSurroundingLines);
+};
+const cursorSurroundingLinesDescription = () => {
+  return i18nString(CursorSurroundingLinesDescription);
+};
+const cursorSurroundingLinesStyle = () => {
+  return i18nString(CursorSurroundingLinesStyle);
+};
+const cursorSurroundingLinesStyleDescription = () => {
+  return i18nString(CursorSurroundingLinesStyleDescription);
+};
+const disableMonospaceOptimizations = () => {
+  return i18nString(DisableMonospaceOptimizations);
+};
+const disableMonospaceOptimizationsDescription = () => {
+  return i18nString(DisableMonospaceOptimizationsDescription);
+};
+const emptySelectionClipboard = () => {
+  return i18nString(EmptySelectionClipboard);
+};
+const emptySelectionClipboardDescription = () => {
+  return i18nString(EmptySelectionClipboardDescription);
+};
+const extraEditorClassName = () => {
+  return i18nString(ExtraEditorClassName);
+};
+const extraEditorClassNameDescription = () => {
+  return i18nString(ExtraEditorClassNameDescription);
+};
+const fastScrollSensitivity = () => {
+  return i18nString(FastScrollSensitivity);
+};
+const fastScrollSensitivityDescription = () => {
+  return i18nString(FastScrollSensitivityDescription);
+};
+const find = () => {
+  return i18nString(Find);
+};
+const findDescription = () => {
+  return i18nString(FindDescription);
+};
+const fixedOverflowWidgets = () => {
+  return i18nString(FixedOverflowWidgets);
+};
+const fixedOverflowWidgetsDescription = () => {
+  return i18nString(FixedOverflowWidgetsDescription);
+};
+const foldingStrategy = () => {
+  return i18nString(FoldingStrategy);
+};
+const foldingStrategyDescription = () => {
+  return i18nString(FoldingStrategyDescription);
+};
+const fontLigatures = () => {
+  return i18nString(FontLigatures);
+};
+const fontLigaturesDescription = () => {
+  return i18nString(FontLigaturesDescription);
+};
+const glyphMargin = () => {
+  return i18nString(GlyphMargin);
+};
+const glyphMarginDescription = () => {
+  return i18nString(GlyphMarginDescription);
+};
+const gotoLocation = () => {
+  return i18nString(GotoLocation);
+};
+const gotoLocationDescription = () => {
+  return i18nString(GotoLocationDescription);
+};
+const hideCursorInOverviewRuler = () => {
+  return i18nString(HideCursorInOverviewRuler);
+};
+const hideCursorInOverviewRulerDescription = () => {
+  return i18nString(HideCursorInOverviewRulerDescription);
+};
+const hover = () => {
+  return i18nString(Hover);
+};
+const hoverDescription = () => {
+  return i18nString(HoverDescription);
+};
+const inDiffEditor = () => {
+  return i18nString(InDiffEditor);
+};
+const inDiffEditorDescription = () => {
+  return i18nString(InDiffEditorDescription);
+};
+const letterSpacing = () => {
+  return i18nString(LetterSpacing);
+};
+const letterSpacingDescription = () => {
+  return i18nString(LetterSpacingDescription);
+};
+const lightbulbEnabled = () => {
+  return i18nString(LightbulbEnabled);
+};
+const lightbulbEnabledDescription = () => {
+  return i18nString(LightbulbEnabledDescription);
+};
+const lineDecorationsWidth = () => {
+  return i18nString(LineDecorationsWidth);
+};
+const lineDecorationsWidthDescription = () => {
+  return i18nString(LineDecorationsWidthDescription);
+};
+const lineHeight = () => {
+  return i18nString(LineHeight);
+};
+const lineHeightDescription = () => {
+  return i18nString(LineHeightDescription);
+};
+const matchBrackets = () => {
+  return i18nString(MatchBrackets);
+};
+const matchBracketsDescription = () => {
+  return i18nString(MatchBracketsDescription);
+};
+const minimapEnabled = () => {
+  return i18nString(MinimapEnabled);
+};
+const minimapEnabledDescription = () => {
+  return i18nString(MinimapEnabledDescription);
+};
+const mouseWheelScrollSensitivity = () => {
+  return i18nString(MouseWheelScrollSensitivity);
+};
+const mouseWheelScrollSensitivityDescription = () => {
+  return i18nString(MouseWheelScrollSensitivityDescription);
+};
+const mouseWheelZoom = () => {
+  return i18nString(MouseWheelZoom);
+};
+const mouseWheelZoomDescription = () => {
+  return i18nString(MouseWheelZoomDescription);
+};
+const multiCursorMergeOverlapping = () => {
+  return i18nString(MultiCursorMergeOverlapping);
+};
+const multiCursorMergeOverlappingDescription = () => {
+  return i18nString(MultiCursorMergeOverlappingDescription);
+};
+const overviewRulerBorder = () => {
+  return i18nString(OverviewRulerBorder);
+};
+const overviewRulerBorderDescription = () => {
+  return i18nString(OverviewRulerBorderDescription);
+};
+const overviewRulerLanes = () => {
+  return i18nString(OverviewRulerLanes);
+};
+const overviewRulerLanesDescription = () => {
+  return i18nString(OverviewRulerLanesDescription);
+};
+const peekWidgetDefaultFocus = () => {
+  return i18nString(PeekWidgetDefaultFocus);
+};
+const peekWidgetDefaultFocusDescription = () => {
+  return i18nString(PeekWidgetDefaultFocusDescription);
+};
+const quickSuggestionsDelay = () => {
+  return i18nString(QuickSuggestionsDelay);
+};
+const quickSuggestionsDelayDescription = () => {
+  return i18nString(QuickSuggestionsDelayDescription);
+};
+const renderFinalNewline = () => {
+  return i18nString(RenderFinalNewline);
+};
+const renderFinalNewlineDescription = () => {
+  return i18nString(RenderFinalNewlineDescription);
+};
+const renderValidationDecorations = () => {
+  return i18nString(RenderValidationDecorations);
+};
+const renderValidationDecorationsDescription = () => {
+  return i18nString(RenderValidationDecorationsDescription);
+};
+const revealHorizontalRightPadding = () => {
+  return i18nString(RevealHorizontalRightPadding);
+};
+const revealHorizontalRightPaddingDescription = () => {
+  return i18nString(RevealHorizontalRightPaddingDescription);
+};
+const roundedSelection = () => {
+  return i18nString(RoundedSelection);
+};
+const roundedSelectionDescription = () => {
+  return i18nString(RoundedSelectionDescription);
+};
+const rulers = () => {
+  return i18nString(Rulers);
+};
+const rulersDescription = () => {
+  return i18nString(RulersDescription);
+};
+const scrollBeyondLastColumn = () => {
+  return i18nString(ScrollBeyondLastColumn);
+};
+const scrollBeyondLastColumnDescription = () => {
+  return i18nString(ScrollBeyondLastColumnDescription);
+};
+const scrollbar = () => {
+  return i18nString(Scrollbar);
+};
+const scrollbarDescription = () => {
+  return i18nString(ScrollbarDescription);
+};
+const scrollPredominantAxis = () => {
+  return i18nString(ScrollPredominantAxis);
+};
+const scrollPredominantAxisDescription = () => {
+  return i18nString(ScrollPredominantAxisDescription);
+};
+const selectionClipboard = () => {
+  return i18nString(SelectionClipboard);
+};
+const selectionClipboardDescription = () => {
+  return i18nString(SelectionClipboardDescription);
+};
+const showUnused = () => {
+  return i18nString(ShowUnused);
+};
+const showUnusedDescription = () => {
+  return i18nString(ShowUnusedDescription);
+};
+const snippetSuggestions = () => {
+  return i18nString(SnippetSuggestions);
+};
+const snippetSuggestionsDescription = () => {
+  return i18nString(SnippetSuggestionsDescription);
+};
+const suggest = () => {
+  return i18nString(Suggest);
+};
+const suggestDescription = () => {
+  return i18nString(SuggestDescription);
+};
+const suggestFontSize = () => {
+  return i18nString(SuggestFontSize);
+};
+const suggestFontSizeDescription = () => {
+  return i18nString(SuggestFontSizeDescription);
+};
+const suggestLineHeight = () => {
+  return i18nString(SuggestLineHeight);
+};
+const suggestLineHeightDescription = () => {
+  return i18nString(SuggestLineHeightDescription);
+};
+const suggestSelection = () => {
+  return i18nString(SuggestSelection);
+};
+const suggestSelectionDescription = () => {
+  return i18nString(SuggestSelectionDescription);
+};
+const useTabStops = () => {
+  return i18nString(UseTabStops);
+};
+const useTabStopsDescription = () => {
+  return i18nString(UseTabStopsDescription);
+};
+const wordSeparators = () => {
+  return i18nString(WordSeparators);
+};
+const wordSeparatorsDescription = () => {
+  return i18nString(WordSeparatorsDescription);
+};
+const wrappingIndent = () => {
+  return i18nString(WrappingIndent);
+};
+const wrappingIndentDescription = () => {
+  return i18nString(WrappingIndentDescription);
+};
+
+const getSettingItems = async () => {
+  return [{
+    id: 'fontSize',
+    heading: fontSize(),
+    description: fontSizeDescription(),
+    type: Number$1,
+    value: '15px',
+    category: TextEditorTab
+  }, {
+    id: 'fontFamily',
+    heading: fontFamily(),
+    description: fontFamilyDescription(),
+    type: String,
+    value: 'Fira Code',
+    category: TextEditorTab
+  },
+  // Text Editor Settings
+  {
+    id: 'wordWrap',
+    heading: wordWrap(),
+    description: wordWrapDescription(),
+    type: Enum,
+    value: 'off',
+    category: TextEditorTab,
+    options: [{
+      id: 'on',
+      label: 'On' // i18n
+    }, {
+      id: 'off',
+      label: 'off' // i18n
+    }]
+  }, {
+    id: 'lineNumbers',
+    heading: lineNumbers(),
+    description: lineNumbersDescription(),
+    type: Enum,
+    value: 'on',
+    category: TextEditorTab,
+    options: [{
+      id: 'on',
+      label: 'On' // i18n
+    }, {
+      id: 'off',
+      label: 'off' // i18n
+    }]
+  }, {
+    id: 'minimap',
+    heading: minimap(),
+    description: minimapDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'scrollBeyondLastLine',
+    heading: scrollBeyondLastLine(),
+    description: scrollBeyondLastLineDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'smoothScrolling',
+    heading: smoothScrolling(),
+    description: smoothScrollingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'cursorBlinking',
+    heading: cursorBlinking(),
+    description: cursorBlinkingDescription(),
+    type: String,
+    value: 'blink',
+    category: TextEditorTab
+  }, {
+    id: 'cursorStyle',
+    heading: cursorStyle(),
+    description: cursorStyleDescription(),
+    type: String,
+    value: 'line',
+    category: TextEditorTab
+  }, {
+    id: 'cursorWidth',
+    heading: cursorWidth(),
+    description: cursorWidthDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'tabSize',
+    heading: tabSize(),
+    description: tabSizeDescription(),
+    type: Number$1,
+    value: '4',
+    category: TextEditorTab
+  }, {
+    id: 'insertSpaces',
+    heading: insertSpaces(),
+    description: insertSpacesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'detectIndentation',
+    heading: detectIndentation(),
+    description: detectIndentationDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'trimAutoWhitespace',
+    heading: trimAutoWhitespace(),
+    description: trimAutoWhitespaceDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'largeFileOptimizations',
+    heading: largeFileOptimizations(),
+    description: largeFileOptimizationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'renderWhitespace',
+    heading: renderWhitespace(),
+    description: renderWhitespaceDescription(),
+    type: String,
+    value: 'selection',
+    category: TextEditorTab
+  }, {
+    id: 'renderControlCharacters',
+    heading: renderControlCharacters(),
+    description: renderControlCharactersDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'renderLineHighlight',
+    heading: renderLineHighlight(),
+    description: renderLineHighlightDescription(),
+    type: String,
+    value: 'line',
+    category: TextEditorTab
+  }, {
+    id: 'codeLens',
+    heading: codeLens(),
+    description: codeLensDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'folding',
+    heading: folding(),
+    description: foldingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'showFoldingControls',
+    heading: showFoldingControls(),
+    description: showFoldingControlsDescription(),
+    type: String,
+    value: 'mouseover',
+    category: TextEditorTab
+  }, {
+    id: 'unfoldOnClickAfterEnd',
+    heading: unfoldOnClickAfterEnd(),
+    description: unfoldOnClickAfterEndDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'links',
+    heading: links(),
+    description: linksDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'colorDecorators',
+    heading: colorDecorators(),
+    description: colorDecoratorsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'lightbulb',
+    heading: lightbulb(),
+    description: lightbulbDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'codeActionsOnSave',
+    heading: codeActionsOnSave(),
+    description: codeActionsOnSaveDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'formatOnPaste',
+    heading: formatOnPaste(),
+    description: formatOnPasteDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'formatOnType',
+    heading: formatOnType(),
+    description: formatOnTypeDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'acceptSuggestionOnCommitCharacter',
+    heading: acceptSuggestionOnCommitCharacter(),
+    description: acceptSuggestionOnCommitCharacterDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'acceptSuggestionOnEnter',
+    heading: acceptSuggestionOnEnter(),
+    description: acceptSuggestionOnEnterDescription(),
+    type: String,
+    value: 'on',
+    category: TextEditorTab
+  }, {
+    id: 'tabCompletion',
+    heading: tabCompletion(),
+    description: tabCompletionDescription(),
+    type: String,
+    value: 'on',
+    category: TextEditorTab
+  }, {
+    id: 'wordBasedSuggestions',
+    heading: wordBasedSuggestions(),
+    description: wordBasedSuggestionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'suggestOnTriggerCharacters',
+    heading: suggestOnTriggerCharacters(),
+    description: suggestOnTriggerCharactersDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'quickSuggestions',
+    heading: quickSuggestions(),
+    description: quickSuggestionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'parameterHints',
+    heading: parameterHints(),
+    description: parameterHintsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingBrackets',
+    heading: autoClosingBrackets(),
+    description: autoClosingBracketsDescription(),
+    type: String,
+    value: 'always',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingQuotes',
+    heading: autoClosingQuotes(),
+    description: autoClosingQuotesDescription(),
+    type: String,
+    value: 'always',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingOvertype',
+    heading: autoClosingOvertype(),
+    description: autoClosingOvertypeDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoClosingDelete',
+    heading: autoClosingDelete(),
+    description: autoClosingDeleteDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoSurround',
+    heading: autoSurround(),
+    description: autoSurroundDescription(),
+    type: String,
+    value: 'quotes',
+    category: TextEditorTab
+  }, {
+    id: 'bracketPairColorization',
+    heading: bracketPairColorization(),
+    description: bracketPairColorizationDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'guides',
+    heading: guides(),
+    description: guidesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'dragAndDrop',
+    heading: dragAndDrop(),
+    description: dragAndDropDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'copyWithSyntaxHighlighting',
+    heading: copyWithSyntaxHighlighting(),
+    description: copyWithSyntaxHighlightingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorModifier',
+    heading: multiCursorModifier(),
+    description: multiCursorModifierDescription(),
+    type: String,
+    value: 'alt',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorPaste',
+    heading: multiCursorPaste(),
+    description: multiCursorPasteDescription(),
+    type: String,
+    value: 'full',
+    category: TextEditorTab
+  }, {
+    id: 'occurrencesHighlight',
+    heading: occurrencesHighlight(),
+    description: occurrencesHighlightDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'selectionHighlight',
+    heading: selectionHighlight(),
+    description: selectionHighlightDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'semanticHighlighting',
+    heading: semanticHighlighting(),
+    description: semanticHighlightingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'tokenColorCustomizations',
+    heading: tokenColorCustomizations(),
+    description: tokenColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'workbenchColorCustomizations',
+    heading: workbenchColorCustomizations(),
+    description: workbenchColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'editorColorCustomizations',
+    heading: editorColorCustomizations(),
+    description: editorColorCustomizationsDescription(),
+    type: String,
+    value: '{}',
+    category: TextEditorTab
+  }, {
+    id: 'diffEditor',
+    heading: diffEditor(),
+    description: diffEditorDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffWordWrap',
+    heading: diffWordWrap(),
+    description: diffWordWrapDescription(),
+    type: String,
+    value: 'inherit',
+    category: TextEditorTab
+  }, {
+    id: 'diffCodeLens',
+    heading: diffCodeLens(),
+    description: diffCodeLensDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderSideBySide',
+    heading: diffRenderSideBySide(),
+    description: diffRenderSideBySideDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffIgnoreTrimWhitespace',
+    heading: diffIgnoreTrimWhitespace(),
+    description: diffIgnoreTrimWhitespaceDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderIndicators',
+    heading: diffRenderIndicators(),
+    description: diffRenderIndicatorsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderOverviewRuler',
+    heading: diffRenderOverviewRuler(),
+    description: diffRenderOverviewRulerDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'diffRenderMarginRevertIcon',
+    heading: diffRenderMarginRevertIcon(),
+    description: diffRenderMarginRevertIconDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  },
+  // Additional Text Editor Settings
+  {
+    id: 'insertMode',
+    heading: insertMode(),
+    description: insertModeDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overwriteMode',
+    heading: overwriteMode(),
+    description: overwriteModeDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'readOnly',
+    heading: readOnly(),
+    description: readOnlyDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'accessibilitySupport',
+    heading: accessibilitySupport(),
+    description: accessibilitySupportDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'autoIndent',
+    heading: autoIndent(),
+    description: autoIndentDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'bracketMatching',
+    heading: bracketMatching(),
+    description: bracketMatchingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'centeredLayout',
+    heading: centeredLayout(),
+    description: centeredLayoutDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'columnSelection',
+    heading: columnSelection(),
+    description: columnSelectionDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'contextmenu',
+    heading: contextmenu(),
+    description: contextmenuDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSmoothCaretAnimation',
+    heading: cursorSmoothCaretAnimation(),
+    description: cursorSmoothCaretAnimationDescription(),
+    type: String,
+    value: 'off',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSurroundingLines',
+    heading: cursorSurroundingLines(),
+    description: cursorSurroundingLinesDescription(),
+    type: Number$1,
+    value: '3',
+    category: TextEditorTab
+  }, {
+    id: 'cursorSurroundingLinesStyle',
+    heading: cursorSurroundingLinesStyle(),
+    description: cursorSurroundingLinesStyleDescription(),
+    type: String,
+    value: 'all',
+    category: TextEditorTab
+  }, {
+    id: 'disableMonospaceOptimizations',
+    heading: disableMonospaceOptimizations(),
+    description: disableMonospaceOptimizationsDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'emptySelectionClipboard',
+    heading: emptySelectionClipboard(),
+    description: emptySelectionClipboardDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'extraEditorClassName',
+    heading: extraEditorClassName(),
+    description: extraEditorClassNameDescription(),
+    type: String,
+    value: '',
+    category: TextEditorTab
+  }, {
+    id: 'fastScrollSensitivity',
+    heading: fastScrollSensitivity(),
+    description: fastScrollSensitivityDescription(),
+    type: Number$1,
+    value: '5',
+    category: TextEditorTab
+  }, {
+    id: 'find',
+    heading: find(),
+    description: findDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'fixedOverflowWidgets',
+    heading: fixedOverflowWidgets(),
+    description: fixedOverflowWidgetsDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'foldingStrategy',
+    heading: foldingStrategy(),
+    description: foldingStrategyDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'fontLigatures',
+    heading: fontLigatures(),
+    description: fontLigaturesDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'glyphMargin',
+    heading: glyphMargin(),
+    description: glyphMarginDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'gotoLocation',
+    heading: gotoLocation(),
+    description: gotoLocationDescription(),
+    type: String,
+    value: 'mouse',
+    category: TextEditorTab
+  }, {
+    id: 'hideCursorInOverviewRuler',
+    heading: hideCursorInOverviewRuler(),
+    description: hideCursorInOverviewRulerDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'hover',
+    heading: hover(),
+    description: hoverDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'inDiffEditor',
+    heading: inDiffEditor(),
+    description: inDiffEditorDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'letterSpacing',
+    heading: letterSpacing(),
+    description: letterSpacingDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'lightbulbEnabled',
+    heading: lightbulbEnabled(),
+    description: lightbulbEnabledDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'lineDecorationsWidth',
+    heading: lineDecorationsWidth(),
+    description: lineDecorationsWidthDescription(),
+    type: Number$1,
+    value: '10',
+    category: TextEditorTab
+  }, {
+    id: 'lineHeight',
+    heading: lineHeight(),
+    description: lineHeightDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'matchBrackets',
+    heading: matchBrackets(),
+    description: matchBracketsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'minimapEnabled',
+    heading: minimapEnabled(),
+    description: minimapEnabledDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'mouseWheelScrollSensitivity',
+    heading: mouseWheelScrollSensitivity(),
+    description: mouseWheelScrollSensitivityDescription(),
+    type: Number$1,
+    value: '1',
+    category: TextEditorTab
+  }, {
+    id: 'mouseWheelZoom',
+    heading: mouseWheelZoom(),
+    description: mouseWheelZoomDescription(),
+    type: Boolean$1,
+    value: 'false',
+    category: TextEditorTab
+  }, {
+    id: 'multiCursorMergeOverlapping',
+    heading: multiCursorMergeOverlapping(),
+    description: multiCursorMergeOverlappingDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overviewRulerBorder',
+    heading: overviewRulerBorder(),
+    description: overviewRulerBorderDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'overviewRulerLanes',
+    heading: overviewRulerLanes(),
+    description: overviewRulerLanesDescription(),
     type: Number$1,
-    value: '15px',
+    value: '3',
     category: TextEditorTab
   }, {
-    id: 'fontFamily',
-    heading: 'Font Family',
-    description: 'The font family of the editor',
+    id: 'peekWidgetDefaultFocus',
+    heading: peekWidgetDefaultFocus(),
+    description: peekWidgetDefaultFocusDescription(),
     type: String,
-    value: 'Fira Code',
+    value: 'editor',
+    category: TextEditorTab
+  }, {
+    id: 'quickSuggestionsDelay',
+    heading: quickSuggestionsDelay(),
+    description: quickSuggestionsDelayDescription(),
+    type: Number$1,
+    value: '10',
+    category: TextEditorTab
+  }, {
+    id: 'renderFinalNewline',
+    heading: renderFinalNewline(),
+    description: renderFinalNewlineDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'renderValidationDecorations',
+    heading: renderValidationDecorations(),
+    description: renderValidationDecorationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'revealHorizontalRightPadding',
+    heading: revealHorizontalRightPadding(),
+    description: revealHorizontalRightPaddingDescription(),
+    type: Number$1,
+    value: '30',
+    category: TextEditorTab
+  }, {
+    id: 'roundedSelection',
+    heading: roundedSelection(),
+    description: roundedSelectionDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'rulers',
+    heading: rulers(),
+    description: rulersDescription(),
+    type: String,
+    value: '[]',
+    category: TextEditorTab
+  }, {
+    id: 'scrollBeyondLastColumn',
+    heading: scrollBeyondLastColumn(),
+    description: scrollBeyondLastColumnDescription(),
+    type: Number$1,
+    value: '5',
+    category: TextEditorTab
+  }, {
+    id: 'scrollbar',
+    heading: scrollbar(),
+    description: scrollbarDescription(),
+    type: String,
+    value: 'auto',
+    category: TextEditorTab
+  }, {
+    id: 'scrollPredominantAxis',
+    heading: scrollPredominantAxis(),
+    description: scrollPredominantAxisDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'selectionClipboard',
+    heading: selectionClipboard(),
+    description: selectionClipboardDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'showUnused',
+    heading: showUnused(),
+    description: showUnusedDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'snippetSuggestions',
+    heading: snippetSuggestions(),
+    description: snippetSuggestionsDescription(),
+    type: String,
+    value: 'bottom',
+    category: TextEditorTab
+  }, {
+    id: 'suggest',
+    heading: suggest(),
+    description: suggestDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'suggestFontSize',
+    heading: suggestFontSize(),
+    description: suggestFontSizeDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'suggestLineHeight',
+    heading: suggestLineHeight(),
+    description: suggestLineHeightDescription(),
+    type: Number$1,
+    value: '0',
+    category: TextEditorTab
+  }, {
+    id: 'suggestSelection',
+    heading: suggestSelection(),
+    description: suggestSelectionDescription(),
+    type: String,
+    value: 'recentlyUsed',
+    category: TextEditorTab
+  }, {
+    id: 'useTabStops',
+    heading: useTabStops(),
+    description: useTabStopsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: TextEditorTab
+  }, {
+    id: 'wordSeparators',
+    heading: wordSeparators(),
+    description: wordSeparatorsDescription(),
+    type: String,
+    value: '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?',
+    category: TextEditorTab
+  }, {
+    id: 'wrappingIndent',
+    heading: wrappingIndent(),
+    description: wrappingIndentDescription(),
+    type: String,
+    value: 'same',
     category: TextEditorTab
   }, {
     id: 'theme',
-    heading: 'Theme',
-    description: 'The color theme of the workbench',
+    heading: theme(),
+    description: themeDescription(),
     type: String,
     value: 'Dark',
     category: WorkbenchTab
   }, {
     id: 'sidebarPosition',
-    heading: 'Sidebar Position',
-    description: 'The position of the sidebar',
+    heading: sidebarPosition(),
+    description: sidebarPositionDescription(),
     type: String,
     value: 'Left',
     category: WorkbenchTab
   }, {
     id: 'windowTitle',
-    heading: 'Window Title',
-    description: 'The title shown in the window',
+    heading: windowTitle(),
+    description: windowTitleDescription(),
     type: String,
     value: 'Settings View',
     category: WindowTab
   }, {
     id: 'windowSize',
-    heading: 'Window Size',
-    description: 'The default window size',
+    heading: windowSize(),
+    description: windowSizeDescription(),
     type: String,
     value: '1024x768',
     category: WindowTab
   }, {
     id: 'autoSave',
-    heading: 'Auto Save',
-    description: 'Automatically save files',
+    heading: autoSave(),
+    description: autoSaveDescription(),
     type: Boolean$1,
     value: 'true',
     category: FeaturesTab
   }, {
     id: 'formatOnSave',
-    heading: 'Format on Save',
-    description: 'Format code when saving',
+    heading: formatOnSave(),
+    description: formatOnSaveDescription(),
     type: Boolean$1,
     value: 'false',
     category: FeaturesTab
   }, {
     id: 'telemetry',
-    heading: 'Telemetry',
-    description: 'Enable telemetry collection',
+    heading: telemetry(),
+    description: telemetryDescription(),
     type: Boolean$1,
     value: 'true',
     category: ApplicationsTab
   }, {
     id: 'updates',
-    heading: 'Auto Updates',
-    description: 'Automatically check for updates',
+    heading: autoUpdates(),
+    description: autoUpdatesDescription(),
     type: Boolean$1,
     value: 'true',
     category: ApplicationsTab
   }, {
     id: 'encryption',
-    heading: 'File Encryption',
-    description: 'Encrypt sensitive files',
+    heading: fileEncryption(),
+    description: fileEncryptionDescription(),
     type: Boolean$1,
     value: 'false',
     category: SecurityTab
   }, {
     id: 'twoFactor',
-    heading: 'Two Factor Auth',
-    description: 'Enable two factor authentication',
+    heading: twoFactorAuth(),
+    description: twoFactorAuthDescription(),
     type: Boolean$1,
     value: 'false',
     category: SecurityTab
   }, {
     id: 'extensionsAutoUpdate',
-    heading: 'Auto Update Extensions',
-    description: 'Automatically update extensions',
+    heading: autoUpdateExtensions(),
+    description: autoUpdateExtensionsDescription(),
     type: Boolean$1,
     value: 'true',
     category: ExtensionsTab
   }, {
     id: 'extensionRecommendations',
-    heading: 'Extension Recommendations',
-    description: 'Show extension recommendations',
+    heading: extensionRecommendations(),
+    description: extensionRecommendationsDescription(),
     type: Boolean$1,
     value: 'true',
     category: ExtensionsTab
@@ -1185,15 +3111,78 @@ const getTabs = () => {
   return tabs;
 };
 
+const getSavedMinLineY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'minLineY' in savedState && typeof savedState.minLineY === 'number') {
+    return savedState.minLineY;
+  }
+  return 0;
+};
+const getSavedSearchValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'searchValue' in savedState && typeof savedState.searchValue === 'string') {
+    return savedState.searchValue;
+  }
+  return '';
+};
+const getSavedDeltaY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
+    return savedState.deltaY;
+  }
+  return 0;
+};
+const getSavedWorkspacePath = savedState => {
+  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
+    return savedState.workspacePath;
+  }
+  return '';
+};
+const getSavedTabId = savedState => {
+  if (savedState && typeof savedState === 'object' && 'selectedTab' in savedState && typeof savedState.selectedTab === 'string') {
+    return savedState.selectedTab;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  if (!savedState) {
+    return {
+      root: '',
+      minLineY: 0,
+      deltaY: 0,
+      tabId: '',
+      searchValue: ''
+    };
+  }
+  const root = getSavedWorkspacePath(savedState);
+  const minLineY = getSavedMinLineY(savedState);
+  const deltaY = getSavedDeltaY(savedState);
+  const tabId = getSavedTabId(savedState);
+  const searchValue = getSavedSearchValue(savedState);
+  return {
+    root,
+    minLineY,
+    deltaY,
+    tabId,
+    searchValue
+  };
+};
+
 const loadContent = async (state, savedState) => {
+  const {
+    searchValue,
+    tabId
+  } = restoreState(savedState);
   const tabs = getTabs();
+  const newTabs = getUpdatedTabs(tabs, tabId);
   const items = await getSettingItems();
-  const filteredItems = getFilteredItems(items, tabs);
+  const filteredItems = getFilteredItems(items, newTabs, searchValue);
+  const preferences = await getPreferences();
   return {
     ...state,
-    tabs,
+    tabs: newTabs,
     items,
-    filteredItems
+    filteredItems,
+    preferences,
+    inputSource: Script,
+    searchValue
   };
 };
 
@@ -1215,21 +3204,25 @@ const Div = 4;
 const H1 = 5;
 const Input = 6;
 const Text = 12;
-const H2 = 22;
 const H3 = 23;
 const Aside = 28;
 const P = 50;
 const Ul = 60;
+const Select = 63;
+const Option = 64;
+const Label = 66;
 const VirtualDomElements = {
   __proto__: null,
   Aside,
   Button,
   Div,
   H1,
-  H2,
   H3,
   Input,
+  Label,
+  Option,
   P,
+  Select,
   Ul};
 const text = data => {
   return {
@@ -1240,11 +3233,17 @@ const text = data => {
 };
 
 const {
-  Viewlet} = ClassNames;
+  Viewlet
+} = ClassNames;
 const Settings = 'Settings';
 
+// TODo use numeric ids
+const HandleClickClear = 'handleClickClear';
+const HandleClickTab = 'handleClickTab';
+const HandleInput = 'handleInput';
+
 const getSettingsInputDom = () => {
-  const placeholder = 'Search Settings';
+  const placeholder = searchSettings();
   return [{
     type: VirtualDomElements.Div,
     className: 'SettingsInputWrapper',
@@ -1254,16 +3253,21 @@ const getSettingsInputDom = () => {
     className: 'InputBox SettingsSearchInput',
     placeholder,
     childCount: 0,
-    name: SettingsSearch // TODO add input event listener
+    name: SettingsSearch,
+    onInput: HandleInput
   }, {
     type: VirtualDomElements.Button,
-    className: 'Button InputButton',
+    className: 'Button InputButton SearchFieldButton',
     childCount: 1,
-    ariaLabel: 'Clear',
-    // TODO i18n string
-    name: Clear // TODO add click event listener
-  }, text('Clear') // TODO use icon
-  ];
+    ariaLabel: clear(),
+    name: Clear$1,
+    // TODO add click event listener
+    onClick: HandleClickClear
+  }, {
+    type: VirtualDomElements.Div,
+    className: 'MaskIcon MaskIconClearAll',
+    childCount: 0
+  }];
 };
 
 const getSettingsHeaderDom = () => {
@@ -1274,6 +3278,33 @@ const getSettingsHeaderDom = () => {
   }, ...getSettingsInputDom()];
 };
 
+const getItemCheckBoxVirtualDom = item => {
+  const {
+    heading,
+    description
+  } = item;
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItem',
+    childCount: 3
+  }, {
+    type: VirtualDomElements.H3,
+    childCount: 1
+  }, text(heading), {
+    type: VirtualDomElements.Div,
+    className: 'SettingsItemCheckBox',
+    childCount: 2
+  }, {
+    type: VirtualDomElements.Input,
+    className: 'CheckBox',
+    inputType: 'checkbox',
+    childCount: 0
+  }, {
+    type: VirtualDomElements.Label,
+    childCount: 1
+  }, text(description)];
+};
+
 const getItemNumberVirtualDom = item => {
   const {
     heading,
@@ -1293,37 +3324,124 @@ const getItemNumberVirtualDom = item => {
     type: VirtualDomElements.Input,
     className: 'InputBox',
     inputType: 'number',
-    placeholder: 'number value',
+    placeholder: numberValue(),
+    childCount: 0
+  }];
+};
+
+const getOptionDom = option => {
+  const {
+    id,
+    label
+  } = option;
+  return [{
+    type: VirtualDomElements.Option,
+    childCount: 1,
+    value: id
+  }, text(label)];
+};
+
+const getItemSelectVirtualDom = item => {
+  const {
+    heading,
+    description
+  } = item;
+  const options = item.options || [];
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItem',
+    childCount: 3
+  }, {
+    type: VirtualDomElements.H3,
+    childCount: 1
+  }, text(heading), {
+    type: VirtualDomElements.P,
+    childCount: 1
+  }, text(description), {
+    type: VirtualDomElements.Select,
+    className: 'Select',
+    childCount: options.length
+  }, ...options.flatMap(getOptionDom)];
+};
+
+const getItemStringVirtualDom = item => {
+  const {
+    heading,
+    description
+  } = item;
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItem',
+    childCount: 3
+  }, {
+    type: VirtualDomElements.H3,
+    childCount: 1
+  }, text(heading), {
+    type: VirtualDomElements.P,
+    childCount: 1
+  }, text(description), {
+    type: VirtualDomElements.Input,
+    className: 'InputBox',
+    inputType: 'text',
+    placeholder: numberValue(),
     childCount: 0
   }];
 };
 
-const getSettingsItemsDom = items => {
+const getItemVirtualDom = item => {
+  if (item.type === Number$1) {
+    return getItemNumberVirtualDom(item);
+  }
+  if (item.type === Boolean$1) {
+    return getItemCheckBoxVirtualDom(item);
+  }
+  if (item.type === String) {
+    return getItemStringVirtualDom(item);
+  }
+  if (item.type === Enum) {
+    return getItemSelectVirtualDom(item);
+  }
+  // TODO
+  return [text('unknown setting type')];
+};
+
+const getSettingsNoResultsDom = searchValue => {
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'SettingsItems',
+    childCount: 1
+  }, {
+    type: VirtualDomElements.Div,
+    className: 'SettingsNoResults',
+    childCount: 1
+  }, text(noSettingsMatching(searchValue))];
+};
+
+const getSettingsItemsDom = (items, searchValue) => {
+  if (items.length === 0 && searchValue.trim()) {
+    return getSettingsNoResultsDom(searchValue);
+  }
   return [{
     type: VirtualDomElements.Div,
     className: 'SettingsItems',
     childCount: items.length
-  }, ...items.flatMap(getItemNumberVirtualDom)];
+  }, ...items.flatMap(getItemVirtualDom)];
 };
 
-const getSettingsContentDom = (items, tabs) => {
+const getSettingsContentDom = (items, tabs, searchValue) => {
   const selectedTab = tabs.find(tab => tab.selected);
-  const headerText = selectedTab ? selectedTab.label : 'Settings Content';
+  const headerText = selectedTab ? selectedTab.label : settingsContent();
   return [{
     type: VirtualDomElements.Div,
     className: 'SettingsContent',
     childCount: 2
   }, {
     type: VirtualDomElements.H1,
+    className: 'SettingsContentHeading',
     childCount: 1
-  }, text(headerText), ...getSettingsItemsDom(items)];
+  }, text(headerText), ...getSettingsItemsDom(items, searchValue)];
 };
 
-// TODo use numeric ids
-const HandleClickClear = 'handleClickClear';
-const HandleClickTab = 'handleClickTab';
-const HandleInput = 'handleInput';
-
 const getTabClassName = tab => {
   return tab.selected ? mergeClassNames('Tab', 'TabSelected') : 'Tab';
 };
@@ -1352,36 +3470,32 @@ const getSettingsTabsDom = tabs => {
 };
 
 const getSettingsSideBarDom = tabs => {
-  const sideBarHeading = 'Settings SideBar';
   return [{
     type: VirtualDomElements.Aside,
     className: 'SettingsSideBar',
-    childCount: 2
-  }, {
-    type: VirtualDomElements.H2,
-    className: 'SettingsSideBarHeading',
     childCount: 1
-  }, text(sideBarHeading), ...getSettingsTabsDom(tabs)];
+  }, ...getSettingsTabsDom(tabs)];
 };
 
-const getSettingsMainDom = (tabs, items) => {
+const getSettingsMainDom = (tabs, items, searchValue) => {
   return [{
     type: VirtualDomElements.Div,
     className: 'SettingsMain',
     childCount: 2
-  }, ...getSettingsSideBarDom(tabs), ...getSettingsContentDom(items, tabs)];
+  }, ...getSettingsSideBarDom(tabs), ...getSettingsContentDom(items, tabs, searchValue)];
 };
 
 const getSettingsDom = state => {
   const {
     tabs,
-    filteredItems
+    filteredItems,
+    searchValue
   } = state;
   return [{
     type: VirtualDomElements.Div,
     childCount: 2,
     className: mergeClassNames(Viewlet, Settings)
-  }, ...getSettingsHeaderDom(), ...getSettingsMainDom(tabs, filteredItems)];
+  }, ...getSettingsHeaderDom(), ...getSettingsMainDom(tabs, filteredItems, searchValue)];
 };
 
 const renderItems = (oldState, newState) => {
@@ -1389,10 +3503,20 @@ const renderItems = (oldState, newState) => {
   return ['Viewlet.setDom2', newState.id, dom];
 };
 
+const renderValue = (oldState, newState) => {
+  const {
+    id,
+    searchValue
+  } = newState;
+  return ['Viewlet.setValueByName', id, SettingsSearch, searchValue];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderItems:
       return renderItems;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -1434,42 +3558,6 @@ const renderEventListeners = () => {
   }];
 };
 
-const getSavedMinLineY = savedState => {
-  if (savedState && typeof savedState === 'object' && 'minLineY' in savedState && typeof savedState.minLineY === 'number') {
-    return savedState.minLineY;
-  }
-  return 0;
-};
-const getSavedDeltaY = savedState => {
-  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
-    return savedState.deltaY;
-  }
-  return 0;
-};
-const getSavedWorkspacePath = savedState => {
-  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
-    return savedState.workspacePath;
-  }
-  return '';
-};
-const restoreState = savedState => {
-  if (!savedState) {
-    return {
-      root: '',
-      minLineY: 0,
-      deltaY: 0
-    };
-  }
-  const root = getSavedWorkspacePath(savedState);
-  const minLineY = getSavedMinLineY(savedState);
-  const deltaY = getSavedDeltaY(savedState);
-  return {
-    root,
-    minLineY,
-    deltaY
-  };
-};
-
 const saveState = state => {
   const {
     tabs,
@@ -1500,7 +3588,7 @@ const commandMap = {
   'Settings.saveState': wrapGetter(saveState),
   'Settings.terminate': terminate,
   'Settings.handleClickTab': wrapCommand(handleClickTab),
-  'Settings.clear': wrapCommand(clear),
+  'Settings.clear': wrapCommand(clear$1),
   'Settings.handleInput': wrapCommand(handleInput)
 };