@lvce-editor/settings-view 1.16.0 → 1.18.0

package/dist/settingsViewWorkerMain.js

@@ -937,7 +937,7 @@ const filterBySearch = (items, searchValue) => {
   const normalizedSearchValue = searchValue.toLowerCase().trim();
   return items.filter(item => item.heading.toLowerCase().includes(normalizedSearchValue));
 };
-const getFilteredItems = (items, tabs, searchValue = '', preferences = {}) => {
+const getFilteredItems = (items, tabs, searchValue = '', preferences) => {
   const tabFilteredItems = filterByTab(items, tabs);
   const itemsWithModifiedProperty = addModifiedProperty(tabFilteredItems, preferences);
   return filterBySearch(itemsWithModifiedProperty, searchValue);
@@ -952,10 +952,10 @@ const clear$1 = state => {
   const {
     items,
     tabs,
-    preferences
+    modifiedSettings
   } = state;
   const newSearchValue = '';
-  const filteredItems = getFilteredItems(items, tabs, newSearchValue, preferences);
+  const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings);
   return {
     ...state,
     filteredItems,
@@ -1037,8 +1037,8 @@ const isEqual = (oldState, newState) => {
   return newState.inputSource === User || oldState.searchValue === newState.searchValue;
 };
 
-const modules = [isEqual$4, isEqual$3, isEqual, isEqual$1, isEqual$2];
-const numbers = [RenderFocus, RenderItems, RenderValue, RenderSettingValues, RenderScrollOffset];
+const modules = [isEqual$3, isEqual, isEqual$1, isEqual$2, isEqual$4, isEqual$4];
+const numbers = [RenderItems, RenderValue, RenderSettingValues, RenderScrollOffset, RenderFocus, RenderFocusContext];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1065,8 +1065,69 @@ const diff2 = uid => {
   return diffResult;
 };
 
-const getKeyBindings = () => {
-  return [];
+const Tab$1 = 'tab';
+const TabList = 'tablist';
+const AriaRoles = {
+  __proto__: null,
+  Tab: Tab$1,
+  TabList};
+const Viewlet$1 = 'Viewlet';
+const ClassNames = {
+  __proto__: null,
+  Viewlet: Viewlet$1};
+const UpArrow = 14;
+const DownArrow = 16;
+const KeyCode = {
+  __proto__: null,
+  DownArrow,
+  UpArrow
+};
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+const Button$1 = 1;
+const Div = 4;
+const H1 = 5;
+const Input = 6;
+const Text = 12;
+const H3 = 23;
+const Aside = 28;
+const P = 50;
+const Ul = 60;
+const Select$1 = 63;
+const Option = 64;
+const Label = 66;
+const VirtualDomElements = {
+  __proto__: null,
+  Aside,
+  Button: Button$1,
+  Div,
+  H1,
+  H3,
+  Input,
+  Label,
+  Option,
+  P,
+  Select: Select$1,
+  Ul};
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getKeyBindings$1 = () => {
+  return [{
+    key: KeyCode.UpArrow,
+    command: 'Settings.usePreviousSearchValue',
+    when: FocusSettingsInput
+  }, {
+    key: KeyCode.DownArrow,
+    command: 'Settings.useNextSearchValue',
+    when: FocusSettingsInput
+  }];
 };
 
 const getName = () => {
@@ -1103,10 +1164,10 @@ const handleClickTab = (state, name) => {
     items,
     tabs,
     searchValue,
-    preferences
+    modifiedSettings
   } = state;
   const updatedTabs = getUpdatedTabs(tabs, name);
-  const filteredItems = getFilteredItems(items, updatedTabs, searchValue, preferences);
+  const filteredItems = getFilteredItems(items, updatedTabs, searchValue, modifiedSettings);
   return {
     ...state,
     tabs: updatedTabs,
@@ -1117,12 +1178,57 @@ const handleClickTab = (state, name) => {
 const addToHistory = (history, value) => {
   let newHistory = history;
   let newHistoryIndex = -1;
-  if (value && value.trim() && !history.includes(value)) {
-    newHistory = [...history, value];
+  if (!value || !value.trim()) {
+    return {
+      newHistory,
+      newHistoryIndex
+    };
+  }
+  const trimmedValue = value.trim();
+
+  // Check if this value is already in history
+  const existingIndex = history.indexOf(trimmedValue);
+  if (existingIndex !== -1) {
+    newHistoryIndex = existingIndex;
+    return {
+      newHistory,
+      newHistoryIndex
+    };
+  }
+
+  // Check if this value is a prefix of any existing history item
+  // If it is, don't add it to history yet (it's still being typed)
+  const isPrefixOfExisting = history.some(historyItem => historyItem.startsWith(trimmedValue) && historyItem !== trimmedValue);
+  if (isPrefixOfExisting) {
+    // Don't add to history, but find the closest match for index
+    const closestMatch = history.find(historyItem => historyItem.startsWith(trimmedValue));
+    if (closestMatch) {
+      newHistoryIndex = history.indexOf(closestMatch);
+    }
+    return {
+      newHistory,
+      newHistoryIndex
+    };
+  }
+
+  // Check if any existing history items are prefixes of this value
+  // If so, remove all prefix items and add the complete value at the first prefix position
+  const prefixItems = history.filter(historyItem => trimmedValue.startsWith(historyItem) && historyItem !== trimmedValue);
+  if (prefixItems.length > 0) {
+    // Find the position of the first prefix item
+    const firstPrefixIndex = history.findIndex(historyItem => trimmedValue.startsWith(historyItem) && historyItem !== trimmedValue);
+
+    // Remove all prefix items and add the complete value at the first prefix position
+
+    // Insert the new value at the position where the first prefix was
+    const beforePrefix = history.slice(0, firstPrefixIndex);
+    const afterPrefix = history.slice(firstPrefixIndex).filter(historyItem => !trimmedValue.startsWith(historyItem) || historyItem === trimmedValue);
+    newHistory = [...beforePrefix, trimmedValue, ...afterPrefix];
+    newHistoryIndex = firstPrefixIndex;
+  } else {
+    // Add as new item
+    newHistory = [...history, trimmedValue];
     newHistoryIndex = newHistory.length - 1;
-  } else if (value && value.trim()) {
-    // If value already exists in history, find its index
-    newHistoryIndex = history.indexOf(value);
   }
   return {
     newHistory,
@@ -1134,10 +1240,10 @@ const handleInput = (state, value, inputSource = User) => {
   const {
     items,
     tabs,
-    preferences,
-    history
+    history,
+    modifiedSettings
   } = state;
-  const filteredItems = getFilteredItems(items, tabs, value, preferences);
+  const filteredItems = getFilteredItems(items, tabs, value, modifiedSettings);
   const {
     newHistory,
     newHistoryIndex
@@ -1152,8 +1258,16 @@ const handleInput = (state, value, inputSource = User) => {
   };
 };
 
+const None = 0;
 const SearchInput = 1;
 
+const handleInputBlur = state => {
+  return {
+    ...state,
+    focus: None
+  };
+};
+
 const handleInputFocus = state => {
   return {
     ...state,
@@ -1225,8 +1339,378 @@ const initialize = async () => {
   // TODO
 };
 
+const getModifiedSettings = preferences => {
+  const modifiedSettings = Object.create(null);
+  for (const key of Object.keys(preferences)) {
+    modifiedSettings[key] = true;
+  }
+  return modifiedSettings;
+};
+
+const rpcs = Object.create(null);
+const set$g = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+
+const create = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$g(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+const DebugWorker$1 = 55;
+const RendererWorker$1 = 1;
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$3,
+  dispose: dispose$3
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$3('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$3('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$3('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$3('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$3('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$3('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$3('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer$3('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$3('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke$3('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$3('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer$3('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$3('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$3('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$3('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  return invoke$3('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$3('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$3('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$3('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer$3('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$3('Confirmprompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$3('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$3('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$3('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$3('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$3('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$3('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$3('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$3('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$3('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$3('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker$1);
+};
+const getPreference = async key => {
+  return await invoke$3('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$3('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$3('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$3('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$3('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer$3(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$3('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$3('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$3('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$3('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$3('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$3('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$3('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$3('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$3('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$3('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$3('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$3('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$3('Preferences.getAll');
+};
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose: dispose$3,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$3,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
+
 const getPreferences = async () => {
-  return {};
+  try {
+    return await RendererWorker.getAllPreferences();
+  } catch {
+    return {};
+  }
 };
 
 const ApplicationsTab = 'applications';
@@ -2332,375 +2816,391 @@ const unknownSettingType = () => {
   return i18nString(UnknownSettingType);
 };
 
-const getSettingItems = async () => {
+const getSettingItemsApplications = () => {
+  return [{
+    id: 'telemetry',
+    heading: telemetry(),
+    description: telemetryDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ApplicationsTab
+  }, {
+    id: 'updates',
+    heading: autoUpdates(),
+    description: autoUpdatesDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ApplicationsTab
+  }];
+};
+
+const getSettingItemsEditor = () => {
   return [{
-    id: 'Editor.fontSize',
+    id: 'editor.fontSize',
     heading: fontSize(),
     description: fontSizeDescription(),
     type: Number$1,
     value: 15,
     category: TextEditorTab
   }, {
-    id: 'Editor.fontFamily',
+    id: 'editor.fontFamily',
     heading: fontFamily(),
     description: fontFamilyDescription(),
     type: String,
     value: 'Fira Code',
     category: TextEditorTab
-  },
-  // Text Editor Settings
-  {
-    id: 'Editor.wordWrap',
+  }, {
+    id: 'editor.wordWrap',
     heading: wordWrap(),
     description: wordWrapDescription(),
     type: Enum,
     value: 'off',
     category: TextEditorTab,
     options: [{
-      id: 'on',
+      id: 'editor.on',
       label: 'On' // i18n
     }, {
-      id: 'off',
+      id: 'editor.off',
       label: 'off' // i18n
     }]
   }, {
-    id: 'Editor.lineNumbers',
+    id: 'editor.lineNumbers',
     heading: lineNumbers(),
     description: lineNumbersDescription(),
     type: Enum,
     value: 'on',
     category: TextEditorTab,
     options: [{
-      id: 'on',
+      id: 'editor.on',
       label: 'On' // i18n
     }, {
-      id: 'off',
+      id: 'editor.off',
       label: 'off' // i18n
     }]
   }, {
-    id: 'Editor.minimap',
+    id: 'editor.minimap',
     heading: minimap(),
     description: minimapDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.scrollBeyondLastLine',
+    id: 'editor.scrollBeyondLastLine',
     heading: scrollBeyondLastLine(),
     description: scrollBeyondLastLineDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'Editor.smoothScrolling',
+    id: 'editor.smoothScrolling',
     heading: smoothScrolling(),
     description: smoothScrollingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.cursorBlinking',
+    id: 'editor.cursorBlinking',
     heading: cursorBlinking(),
     description: cursorBlinkingDescription(),
     type: String,
     value: 'blink',
     category: TextEditorTab
   }, {
-    id: 'Editor.cursorStyle',
+    id: 'editor.cursorStyle',
     heading: cursorStyle(),
     description: cursorStyleDescription(),
     type: String,
     value: 'line',
     category: TextEditorTab
   }, {
-    id: 'Editor.cursorWidth',
+    id: 'editor.cursorWidth',
     heading: cursorWidth(),
     description: cursorWidthDescription(),
     type: Number$1,
     value: '0',
     category: TextEditorTab
   }, {
-    id: 'Editor.tabSize',
+    id: 'editor.tabSize',
     heading: tabSize(),
     description: tabSizeDescription(),
     type: Number$1,
     value: '4',
     category: TextEditorTab
   }, {
-    id: 'Editor.insertSpaces',
+    id: 'editor.insertSpaces',
     heading: insertSpaces(),
     description: insertSpacesDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.detectIndentation',
+    id: 'editor.detectIndentation',
     heading: detectIndentation(),
     description: detectIndentationDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.trimAutoWhitespace',
+    id: 'editor.trimAutoWhitespace',
     heading: trimAutoWhitespace(),
     description: trimAutoWhitespaceDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.largeFileOptimizations',
+    id: 'editor.largeFileOptimizations',
     heading: largeFileOptimizations(),
     description: largeFileOptimizationsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.renderWhitespace',
+    id: 'editor.renderWhitespace',
     heading: renderWhitespace(),
     description: renderWhitespaceDescription(),
     type: String,
     value: 'selection',
     category: TextEditorTab
   }, {
-    id: 'Editor.renderControlCharacters',
+    id: 'editor.renderControlCharacters',
     heading: renderControlCharacters(),
     description: renderControlCharactersDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'Editor.renderLineHighlight',
+    id: 'editor.renderLineHighlight',
     heading: renderLineHighlight(),
     description: renderLineHighlightDescription(),
     type: String,
     value: 'line',
     category: TextEditorTab
   }, {
-    id: 'Editor.codeLens',
+    id: 'editor.codeLens',
     heading: codeLens(),
     description: codeLensDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.folding',
+    id: 'editor.folding',
     heading: folding(),
     description: foldingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.showFoldingControls',
+    id: 'editor.showFoldingControls',
     heading: showFoldingControls(),
     description: showFoldingControlsDescription(),
     type: String,
     value: 'mouseover',
     category: TextEditorTab
   }, {
-    id: 'Editor.unfoldOnClickAfterEnd',
+    id: 'editor.unfoldOnClickAfterEnd',
     heading: unfoldOnClickAfterEnd(),
     description: unfoldOnClickAfterEndDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'Editor.links',
+    id: 'editor.links',
     heading: links(),
     description: linksDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'colorDecorators',
+    id: 'editor.colorDecorators',
     heading: colorDecorators(),
     description: colorDecoratorsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'lightbulb',
+    id: 'editor.lightbulb',
     heading: lightbulb(),
     description: lightbulbDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'codeActionsOnSave',
+    id: 'editor.codeActionsOnSave',
     heading: codeActionsOnSave(),
     description: codeActionsOnSaveDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'formatOnPaste',
+    id: 'editor.formatOnPaste',
     heading: formatOnPaste(),
     description: formatOnPasteDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'formatOnType',
+    id: 'editor.formatOnType',
     heading: formatOnType(),
     description: formatOnTypeDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'acceptSuggestionOnCommitCharacter',
+    id: 'editor.acceptSuggestionOnCommitCharacter',
     heading: acceptSuggestionOnCommitCharacter(),
     description: acceptSuggestionOnCommitCharacterDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'acceptSuggestionOnEnter',
+    id: 'editor.acceptSuggestionOnEnter',
     heading: acceptSuggestionOnEnter(),
     description: acceptSuggestionOnEnterDescription(),
     type: String,
     value: 'on',
     category: TextEditorTab
   }, {
-    id: 'tabCompletion',
+    id: 'editor.tabCompletion',
     heading: tabCompletion(),
     description: tabCompletionDescription(),
     type: String,
     value: 'on',
     category: TextEditorTab
   }, {
-    id: 'wordBasedSuggestions',
+    id: 'editor.wordBasedSuggestions',
     heading: wordBasedSuggestions(),
     description: wordBasedSuggestionsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'suggestOnTriggerCharacters',
+    id: 'editor.suggestOnTriggerCharacters',
     heading: suggestOnTriggerCharacters(),
     description: suggestOnTriggerCharactersDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'quickSuggestions',
+    id: 'editor.quickSuggestions',
     heading: quickSuggestions(),
     description: quickSuggestionsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'parameterHints',
+    id: 'editor.parameterHints',
     heading: parameterHints(),
     description: parameterHintsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'autoClosingBrackets',
+    id: 'editor.autoClosingBrackets',
     heading: autoClosingBrackets(),
     description: autoClosingBracketsDescription(),
     type: String,
     value: 'always',
     category: TextEditorTab
   }, {
-    id: 'autoClosingQuotes',
+    id: 'editor.autoClosingQuotes',
     heading: autoClosingQuotes(),
     description: autoClosingQuotesDescription(),
     type: String,
     value: 'always',
     category: TextEditorTab
   }, {
-    id: 'autoClosingOvertype',
+    id: 'editor.autoClosingOvertype',
     heading: autoClosingOvertype(),
     description: autoClosingOvertypeDescription(),
     type: String,
     value: 'auto',
     category: TextEditorTab
   }, {
-    id: 'autoClosingDelete',
+    id: 'editor.autoClosingDelete',
     heading: autoClosingDelete(),
     description: autoClosingDeleteDescription(),
     type: String,
     value: 'auto',
     category: TextEditorTab
   }, {
-    id: 'autoSurround',
+    id: 'editor.autoSurround',
     heading: autoSurround(),
     description: autoSurroundDescription(),
     type: String,
     value: 'quotes',
     category: TextEditorTab
   }, {
-    id: 'bracketPairColorization',
+    id: 'editor.bracketPairColorization',
     heading: bracketPairColorization(),
     description: bracketPairColorizationDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'guides',
+    id: 'editor.guides',
     heading: guides(),
     description: guidesDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'dragAndDrop',
+    id: 'editor.dragAndDrop',
     heading: dragAndDrop(),
     description: dragAndDropDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'copyWithSyntaxHighlighting',
+    id: 'editor.copyWithSyntaxHighlighting',
     heading: copyWithSyntaxHighlighting(),
     description: copyWithSyntaxHighlightingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'multiCursorModifier',
+    id: 'editor.multiCursorModifier',
     heading: multiCursorModifier(),
     description: multiCursorModifierDescription(),
     type: String,
     value: 'alt',
     category: TextEditorTab
   }, {
-    id: 'multiCursorPaste',
+    id: 'editor.multiCursorPaste',
     heading: multiCursorPaste(),
     description: multiCursorPasteDescription(),
     type: String,
     value: 'full',
     category: TextEditorTab
   }, {
-    id: 'occurrencesHighlight',
+    id: 'editor.occurrencesHighlight',
     heading: occurrencesHighlight(),
     description: occurrencesHighlightDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'selectionHighlight',
+    id: 'editor.selectionHighlight',
     heading: selectionHighlight(),
     description: selectionHighlightDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'semanticHighlighting',
+    id: 'editor.semanticHighlighting',
     heading: semanticHighlighting(),
     description: semanticHighlightingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'tokenColorCustomizations',
+    id: 'editor.tokenColorCustomizations',
     heading: tokenColorCustomizations(),
     description: tokenColorCustomizationsDescription(),
     type: String,
     value: '{}',
     category: TextEditorTab
   }, {
-    id: 'workbenchColorCustomizations',
+    id: 'editor.workbenchColorCustomizations',
     heading: workbenchColorCustomizations(),
     description: workbenchColorCustomizationsDescription(),
     type: String,
@@ -2714,491 +3214,483 @@ const getSettingItems = async () => {
     value: '{}',
     category: TextEditorTab
   }, {
-    id: 'diffEditor',
+    id: 'editor.diffEditor',
     heading: diffEditor(),
     description: diffEditorDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'diffWordWrap',
+    id: 'editor.diffWordWrap',
     heading: diffWordWrap(),
     description: diffWordWrapDescription(),
     type: String,
     value: 'inherit',
     category: TextEditorTab
   }, {
-    id: 'diffCodeLens',
+    id: 'editor.diffCodeLens',
     heading: diffCodeLens(),
     description: diffCodeLensDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'diffRenderSideBySide',
+    id: 'editor.diffRenderSideBySide',
     heading: diffRenderSideBySide(),
     description: diffRenderSideBySideDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'diffIgnoreTrimWhitespace',
+    id: 'editor.diffIgnoreTrimWhitespace',
     heading: diffIgnoreTrimWhitespace(),
     description: diffIgnoreTrimWhitespaceDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'diffRenderIndicators',
+    id: 'editor.diffRenderIndicators',
     heading: diffRenderIndicators(),
     description: diffRenderIndicatorsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'diffRenderOverviewRuler',
+    id: 'editor.diffRenderOverviewRuler',
     heading: diffRenderOverviewRuler(),
     description: diffRenderOverviewRulerDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'diffRenderMarginRevertIcon',
+    id: 'editor.diffRenderMarginRevertIcon',
     heading: diffRenderMarginRevertIcon(),
     description: diffRenderMarginRevertIconDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
-  },
-  // Additional Text Editor Settings
-  {
-    id: 'insertMode',
+  }, {
+    id: 'editor.insertMode',
     heading: insertMode(),
     description: insertModeDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'overwriteMode',
+    id: 'editor.overwriteMode',
     heading: overwriteMode(),
     description: overwriteModeDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'readOnly',
+    id: 'editor.readOnly',
     heading: readOnly(),
     description: readOnlyDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'accessibilitySupport',
+    id: 'editor.accessibilitySupport',
     heading: accessibilitySupport(),
     description: accessibilitySupportDescription(),
     type: String,
     value: 'auto',
     category: TextEditorTab
   }, {
-    id: 'autoIndent',
+    id: 'editor.autoIndent',
     heading: autoIndent(),
     description: autoIndentDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'bracketMatching',
+    id: 'editor.bracketMatching',
     heading: bracketMatching(),
     description: bracketMatchingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'centeredLayout',
+    id: 'editor.centeredLayout',
     heading: centeredLayout(),
     description: centeredLayoutDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'columnSelection',
+    id: 'editor.columnSelection',
     heading: columnSelection(),
     description: columnSelectionDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'contextmenu',
+    id: 'editor.contextmenu',
     heading: contextmenu(),
     description: contextmenuDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'cursorSmoothCaretAnimation',
+    id: 'editor.cursorSmoothCaretAnimation',
     heading: cursorSmoothCaretAnimation(),
     description: cursorSmoothCaretAnimationDescription(),
     type: String,
     value: 'off',
     category: TextEditorTab
   }, {
-    id: 'cursorSurroundingLines',
+    id: 'editor.cursorSurroundingLines',
     heading: cursorSurroundingLines(),
     description: cursorSurroundingLinesDescription(),
     type: Number$1,
     value: '3',
     category: TextEditorTab
   }, {
-    id: 'cursorSurroundingLinesStyle',
+    id: 'editor.cursorSurroundingLinesStyle',
     heading: cursorSurroundingLinesStyle(),
     description: cursorSurroundingLinesStyleDescription(),
     type: String,
     value: 'all',
     category: TextEditorTab
   }, {
-    id: 'disableMonospaceOptimizations',
+    id: 'editor.disableMonospaceOptimizations',
     heading: disableMonospaceOptimizations(),
     description: disableMonospaceOptimizationsDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'emptySelectionClipboard',
+    id: 'editor.emptySelectionClipboard',
     heading: emptySelectionClipboard(),
     description: emptySelectionClipboardDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'extraEditorClassName',
+    id: 'editor.extraEditorClassName',
     heading: extraEditorClassName(),
     description: extraEditorClassNameDescription(),
     type: String,
     value: '',
     category: TextEditorTab
   }, {
-    id: 'fastScrollSensitivity',
+    id: 'editor.fastScrollSensitivity',
     heading: fastScrollSensitivity(),
     description: fastScrollSensitivityDescription(),
     type: Number$1,
     value: '5',
     category: TextEditorTab
   }, {
-    id: 'find',
+    id: 'editor.find',
     heading: find(),
     description: findDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'fixedOverflowWidgets',
+    id: 'editor.fixedOverflowWidgets',
     heading: fixedOverflowWidgets(),
     description: fixedOverflowWidgetsDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'foldingStrategy',
+    id: 'editor.foldingStrategy',
     heading: foldingStrategy(),
     description: foldingStrategyDescription(),
     type: String,
     value: 'auto',
     category: TextEditorTab
   }, {
-    id: 'fontLigatures',
+    id: 'editor.fontLigatures',
     heading: fontLigatures(),
     description: fontLigaturesDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'glyphMargin',
+    id: 'editor.glyphMargin',
     heading: glyphMargin(),
     description: glyphMarginDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'gotoLocation',
+    id: 'editor.gotoLocation',
     heading: gotoLocation(),
     description: gotoLocationDescription(),
     type: String,
     value: 'mouse',
     category: TextEditorTab
   }, {
-    id: 'hideCursorInOverviewRuler',
+    id: 'editor.hideCursorInOverviewRuler',
     heading: hideCursorInOverviewRuler(),
     description: hideCursorInOverviewRulerDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'hover',
+    id: 'editor.hover',
     heading: hover(),
     description: hoverDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'inDiffEditor',
+    id: 'editor.inDiffEditor',
     heading: inDiffEditor(),
     description: inDiffEditorDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'letterSpacing',
+    id: 'editor.letterSpacing',
     heading: letterSpacing(),
     description: letterSpacingDescription(),
     type: Number$1,
     value: '0',
     category: TextEditorTab
   }, {
-    id: 'lightbulbEnabled',
+    id: 'editor.lightbulbEnabled',
     heading: lightbulbEnabled(),
     description: lightbulbEnabledDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'lineDecorationsWidth',
+    id: 'editor.lineDecorationsWidth',
     heading: lineDecorationsWidth(),
     description: lineDecorationsWidthDescription(),
     type: Number$1,
     value: '10',
     category: TextEditorTab
   }, {
-    id: 'lineHeight',
+    id: 'editor.lineHeight',
     heading: lineHeight(),
     description: lineHeightDescription(),
     type: Number$1,
     value: '0',
     category: TextEditorTab
   }, {
-    id: 'matchBrackets',
+    id: 'editor.matchBrackets',
     heading: matchBrackets(),
     description: matchBracketsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'minimapEnabled',
+    id: 'editor.minimapEnabled',
     heading: minimapEnabled(),
     description: minimapEnabledDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'mouseWheelScrollSensitivity',
+    id: 'editor.mouseWheelScrollSensitivity',
     heading: mouseWheelScrollSensitivity(),
     description: mouseWheelScrollSensitivityDescription(),
     type: Number$1,
     value: '1',
     category: TextEditorTab
   }, {
-    id: 'mouseWheelZoom',
+    id: 'editor.mouseWheelZoom',
     heading: mouseWheelZoom(),
     description: mouseWheelZoomDescription(),
     type: Boolean$1,
     value: 'false',
     category: TextEditorTab
   }, {
-    id: 'multiCursorMergeOverlapping',
+    id: 'editor.multiCursorMergeOverlapping',
     heading: multiCursorMergeOverlapping(),
     description: multiCursorMergeOverlappingDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'overviewRulerBorder',
+    id: 'editor.overviewRulerBorder',
     heading: overviewRulerBorder(),
     description: overviewRulerBorderDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'overviewRulerLanes',
+    id: 'editor.overviewRulerLanes',
     heading: overviewRulerLanes(),
     description: overviewRulerLanesDescription(),
     type: Number$1,
     value: '3',
     category: TextEditorTab
   }, {
-    id: 'peekWidgetDefaultFocus',
+    id: 'editor.peekWidgetDefaultFocus',
     heading: peekWidgetDefaultFocus(),
     description: peekWidgetDefaultFocusDescription(),
     type: String,
     value: 'editor',
     category: TextEditorTab
   }, {
-    id: 'quickSuggestionsDelay',
+    id: 'editor.quickSuggestionsDelay',
     heading: quickSuggestionsDelay(),
     description: quickSuggestionsDelayDescription(),
     type: Number$1,
     value: '10',
     category: TextEditorTab
   }, {
-    id: 'renderFinalNewline',
+    id: 'editor.renderFinalNewline',
     heading: renderFinalNewline(),
     description: renderFinalNewlineDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'renderValidationDecorations',
+    id: 'editor.renderValidationDecorations',
     heading: renderValidationDecorations(),
     description: renderValidationDecorationsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'revealHorizontalRightPadding',
+    id: 'editor.revealHorizontalRightPadding',
     heading: revealHorizontalRightPadding(),
     description: revealHorizontalRightPaddingDescription(),
     type: Number$1,
     value: '30',
     category: TextEditorTab
   }, {
-    id: 'roundedSelection',
+    id: 'editor.roundedSelection',
     heading: roundedSelection(),
     description: roundedSelectionDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'rulers',
+    id: 'editor.rulers',
     heading: rulers(),
     description: rulersDescription(),
     type: String,
     value: '[]',
     category: TextEditorTab
   }, {
-    id: 'scrollBeyondLastColumn',
+    id: 'editor.scrollBeyondLastColumn',
     heading: scrollBeyondLastColumn(),
     description: scrollBeyondLastColumnDescription(),
     type: Number$1,
     value: '5',
     category: TextEditorTab
   }, {
-    id: 'scrollbar',
+    id: 'editor.scrollbar',
     heading: scrollbar(),
     description: scrollbarDescription(),
     type: String,
     value: 'auto',
     category: TextEditorTab
   }, {
-    id: 'scrollPredominantAxis',
+    id: 'editor.scrollPredominantAxis',
     heading: scrollPredominantAxis(),
     description: scrollPredominantAxisDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'selectionClipboard',
+    id: 'editor.selectionClipboard',
     heading: selectionClipboard(),
     description: selectionClipboardDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'Editor.background',
+    id: 'editor.background',
     heading: 'Editor background',
     description: 'Editor background color',
     type: Color,
     value: '#567567',
     category: TextEditorTab
   }, {
-    id: 'showUnused',
+    id: 'editor.showUnused',
     heading: showUnused(),
     description: showUnusedDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'snippetSuggestions',
+    id: 'editor.snippetSuggestions',
     heading: snippetSuggestions(),
     description: snippetSuggestionsDescription(),
     type: String,
     value: 'bottom',
     category: TextEditorTab
   }, {
-    id: 'suggest',
+    id: 'editor.suggest',
     heading: suggest(),
     description: suggestDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'suggestFontSize',
+    id: 'editor.suggestFontSize',
     heading: suggestFontSize(),
     description: suggestFontSizeDescription(),
     type: Number$1,
     value: '0',
     category: TextEditorTab
   }, {
-    id: 'suggestLineHeight',
+    id: 'editor.suggestLineHeight',
     heading: suggestLineHeight(),
     description: suggestLineHeightDescription(),
     type: Number$1,
     value: '0',
     category: TextEditorTab
   }, {
-    id: 'suggestSelection',
+    id: 'editor.suggestSelection',
     heading: suggestSelection(),
     description: suggestSelectionDescription(),
     type: String,
     value: 'recentlyUsed',
     category: TextEditorTab
   }, {
-    id: 'useTabStops',
+    id: 'editor.useTabStops',
     heading: useTabStops(),
     description: useTabStopsDescription(),
     type: Boolean$1,
     value: 'true',
     category: TextEditorTab
   }, {
-    id: 'wordSeparators',
+    id: 'editor.wordSeparators',
     heading: wordSeparators(),
     description: wordSeparatorsDescription(),
     type: String,
     value: '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?',
     category: TextEditorTab
   }, {
-    id: 'wrappingIndent',
+    id: 'editor.wrappingIndent',
     heading: wrappingIndent(),
     description: wrappingIndentDescription(),
     type: String,
     value: 'same',
     category: TextEditorTab
+  }];
+};
+
+const getSettingItemsExtensions = () => {
+  return [{
+    id: 'extensionsAutoUpdate',
+    heading: autoUpdateExtensions(),
+    description: autoUpdateExtensionsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ExtensionsTab
   }, {
-    id: 'theme',
-    heading: theme(),
-    description: themeDescription(),
-    type: String,
-    value: 'Dark',
-    category: WorkbenchTab
-  }, {
-    id: 'sidebarPosition',
-    heading: sidebarPosition(),
-    description: sidebarPositionDescription(),
-    type: String,
-    value: 'Left',
-    category: WorkbenchTab
-  }, {
-    id: 'windowTitle',
-    heading: windowTitle(),
-    description: windowTitleDescription(),
-    type: String,
-    value: 'Settings View',
-    category: WindowTab
-  }, {
-    id: 'windowSize',
-    heading: windowSize(),
-    description: windowSizeDescription(),
-    type: String,
-    value: '1024x768',
-    category: WindowTab
-  }, {
+    id: 'extensionRecommendations',
+    heading: extensionRecommendations(),
+    description: extensionRecommendationsDescription(),
+    type: Boolean$1,
+    value: 'true',
+    category: ExtensionsTab
+  }];
+};
+
+const getSettingItemsFeatures = () => {
+  return [{
     id: 'autoSave',
     heading: autoSave(),
     description: autoSaveDescription(),
@@ -3212,21 +3704,11 @@ const getSettingItems = async () => {
     type: Boolean$1,
     value: 'false',
     category: FeaturesTab
-  }, {
-    id: 'telemetry',
-    heading: telemetry(),
-    description: telemetryDescription(),
-    type: Boolean$1,
-    value: 'true',
-    category: ApplicationsTab
-  }, {
-    id: 'updates',
-    heading: autoUpdates(),
-    description: autoUpdatesDescription(),
-    type: Boolean$1,
-    value: 'true',
-    category: ApplicationsTab
-  }, {
+  }];
+};
+
+const getSettingItemsSecurity = () => {
+  return [{
     id: 'encryption',
     heading: fileEncryption(),
     description: fileEncryptionDescription(),
@@ -3240,23 +3722,49 @@ const getSettingItems = async () => {
     type: Boolean$1,
     value: 'false',
     category: SecurityTab
+  }];
+};
+
+const getSettingItemsWindow = () => {
+  return [{
+    id: 'windowTitle',
+    heading: windowTitle(),
+    description: windowTitleDescription(),
+    type: String,
+    value: 'Settings View',
+    category: WindowTab
   }, {
-    id: 'extensionsAutoUpdate',
-    heading: autoUpdateExtensions(),
-    description: autoUpdateExtensionsDescription(),
-    type: Boolean$1,
-    value: 'true',
-    category: ExtensionsTab
+    id: 'windowSize',
+    heading: windowSize(),
+    description: windowSizeDescription(),
+    type: String,
+    value: '1024x768',
+    category: WindowTab
+  }];
+};
+
+const getSettingItemsWorkbench = () => {
+  return [{
+    id: 'theme',
+    heading: theme(),
+    description: themeDescription(),
+    type: String,
+    value: 'Dark',
+    category: WorkbenchTab
   }, {
-    id: 'extensionRecommendations',
-    heading: extensionRecommendations(),
-    description: extensionRecommendationsDescription(),
-    type: Boolean$1,
-    value: 'true',
-    category: ExtensionsTab
+    id: 'sidebarPosition',
+    heading: sidebarPosition(),
+    description: sidebarPositionDescription(),
+    type: String,
+    value: 'Left',
+    category: WorkbenchTab
   }];
 };
 
+const getSettingItems = async () => {
+  return [...getSettingItemsEditor(), ...getSettingItemsWorkbench(), ...getSettingItemsWindow(), ...getSettingItemsFeatures(), ...getSettingItemsApplications(), ...getSettingItemsSecurity(), ...getSettingItemsExtensions()];
+};
+
 const getTabs = () => {
   const tabs = [{
     id: TextEditorTab,
@@ -3290,88 +3798,107 @@ const getTabs = () => {
   return tabs;
 };
 
+const getSavedDeltaY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
+    return savedState.deltaY;
+  }
+  return 0;
+};
+
+const getSavedHistory = savedState => {
+  if (savedState && typeof savedState === 'object' && 'history' in savedState && Array.isArray(savedState.history)) {
+    // Validate that all items are strings and limit to last 10 items
+    const validHistory = savedState.history.filter(item => typeof item === 'string').slice(-10); // Keep only the last 10 items
+    return validHistory;
+  }
+  return [];
+};
+
+const getSavedHistoryIndex = (savedState, history) => {
+  if (savedState && typeof savedState === 'object' && 'historyIndex' in savedState && typeof savedState.historyIndex === 'number') {
+    const {
+      historyIndex
+    } = savedState;
+    // Ensure historyIndex is within valid bounds
+    if (historyIndex >= 0 && historyIndex < history.length) {
+      return historyIndex;
+    }
+  }
+  return -1;
+};
+
 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;
+
+const getSavedScrollOffset = savedState => {
+  if (savedState && typeof savedState === 'object' && 'scrollOffset' in savedState && typeof savedState.scrollOffset === 'number') {
+    return savedState.scrollOffset;
   }
   return 0;
 };
-const getSavedWorkspacePath = savedState => {
-  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
-    return savedState.workspacePath;
+
+const getSavedSearchValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'searchValue' in savedState && typeof savedState.searchValue === 'string') {
+    return savedState.searchValue;
   }
   return '';
 };
+
 const getSavedTabId = savedState => {
   if (savedState && typeof savedState === 'object' && 'selectedTab' in savedState && typeof savedState.selectedTab === 'string') {
     return savedState.selectedTab;
   }
   return '';
 };
-const getSavedScrollOffset = savedState => {
-  if (savedState && typeof savedState === 'object' && 'scrollOffset' in savedState && typeof savedState.scrollOffset === 'number') {
-    return savedState.scrollOffset;
-  }
-  return 0;
-};
+
 const restoreState = savedState => {
   if (!savedState) {
     return {
-      root: '',
       minLineY: 0,
       deltaY: 0,
       tabId: '',
       searchValue: '',
-      scrollOffset: 0
+      scrollOffset: 0,
+      history: [],
+      historyIndex: -1
     };
   }
-  const root = getSavedWorkspacePath(savedState);
   const minLineY = getSavedMinLineY(savedState);
   const deltaY = getSavedDeltaY(savedState);
   const tabId = getSavedTabId(savedState);
   const searchValue = getSavedSearchValue(savedState);
   const scrollOffset = getSavedScrollOffset(savedState);
+  const history = getSavedHistory(savedState);
+  const historyIndex = getSavedHistoryIndex(savedState, history);
   return {
-    root,
     minLineY,
     deltaY,
     tabId,
     searchValue,
-    scrollOffset
+    scrollOffset,
+    history,
+    historyIndex
   };
 };
 
-const getModifiedSettings = preferences => {
-  const modifiedSettings = Object.create(null);
-  for (const key of Object.keys(preferences)) {
-    modifiedSettings[key] = true;
-  }
-  return modifiedSettings;
-};
 const loadContent = async (state, savedState) => {
   const {
     searchValue,
     tabId,
-    scrollOffset
+    scrollOffset,
+    history,
+    historyIndex
   } = restoreState(savedState);
   const tabs = getTabs();
   const newTabs = getUpdatedTabs(tabs, tabId);
   const items = await getSettingItems();
   const preferences = await getPreferences();
   const modifiedSettings = getModifiedSettings(preferences);
-  const filteredItems = getFilteredItems(items, newTabs, searchValue, preferences);
+  const filteredItems = getFilteredItems(items, newTabs, searchValue, modifiedSettings);
   return {
     ...state,
     filteredItems,
@@ -3381,7 +3908,9 @@ const loadContent = async (state, savedState) => {
     preferences,
     scrollOffset,
     searchValue,
-    tabs: newTabs
+    tabs: newTabs,
+    history,
+    historyIndex
   };
 };
 
@@ -3398,52 +3927,6 @@ const renderFocusContext = (oldState, newState) => {
   return ['Viewlet.setFocusContext', focusKey];
 };
 
-const Tab$1 = 'tab';
-const TabList = 'tablist';
-const AriaRoles = {
-  __proto__: null,
-  Tab: Tab$1,
-  TabList};
-const Viewlet$1 = 'Viewlet';
-const ClassNames = {
-  __proto__: null,
-  Viewlet: Viewlet$1};
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-const Button$1 = 1;
-const Div = 4;
-const H1 = 5;
-const Input = 6;
-const Text = 12;
-const H3 = 23;
-const Aside = 28;
-const P = 50;
-const Ul = 60;
-const Select$1 = 63;
-const Option = 64;
-const Label = 66;
-const VirtualDomElements = {
-  __proto__: null,
-  Aside,
-  Button: Button$1,
-  Div,
-  H1,
-  H3,
-  Input,
-  Label,
-  Option,
-  P,
-  Select: Select$1,
-  Ul};
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
 const {
   Viewlet
 } = ClassNames;
@@ -3455,6 +3938,7 @@ const InputBox = 'InputBox';
 const InputButton = 'InputButton';
 const MaskIcon = 'MaskIcon';
 const MaskIconClearAll = 'MaskIconClearAll';
+const ModifiedIndicator = 'ModifiedIndicator';
 const SearchFieldButton = 'SearchFieldButton';
 const Select = 'Select';
 const Settings = 'Settings';
@@ -3495,16 +3979,19 @@ const HandleScroll = 'handleScroll';
 const HandleSettingSelect = 'handleSettingSelect';
 const HandleInputFocus = 'handleInputFocus';
 
-const getButtonClassName = hasSearchValue => {
+const enabledClass = mergeClassNames(Button, InputButton, SearchFieldButton);
+const disabledClass = mergeClassNames(enabledClass, Disabled);
+const getClearButtonClassName = hasSearchValue => {
   if (hasSearchValue) {
-    return mergeClassNames(Button, InputButton, SearchFieldButton);
+    return disabledClass;
   }
-  return mergeClassNames(Button, InputButton, SearchFieldButton, Disabled);
+  return enabledClass;
 };
+
 const getSettingsInputButtonsDom = hasSearchValue => {
   return [{
     type: VirtualDomElements.Button,
-    className: getButtonClassName(hasSearchValue),
+    className: getClearButtonClassName(hasSearchValue),
     childCount: 1,
     ariaLabel: clear(),
     name: Clear$1,
@@ -3588,11 +4075,12 @@ const getItemCheckBoxVirtualDom = item => {
   }, text(description)];
 };
 
+const parent = {
+  type: VirtualDomElements.H3,
+  childCount: 1
+};
 const getItemHeadingDom = heading => {
-  return [{
-    type: VirtualDomElements.H3,
-    childCount: 1
-  }, text(heading)];
+  return [parent, text(heading)];
 };
 
 const getItemLabelDom = (domId, label) => {
@@ -3635,6 +4123,17 @@ const getItemColorVirtualDom = item => {
   }, ...getItemLabelDom(domId, description)];
 };
 
+const getSettingsModifiedIndicatorDom = isModified => {
+  if (!isModified) {
+    return [];
+  }
+  return [{
+    type: VirtualDomElements.Div,
+    className: ModifiedIndicator,
+    childCount: 0
+  }];
+};
+
 const getItemNumberVirtualDom = item => {
   const {
     heading,
@@ -3644,13 +4143,14 @@ const getItemNumberVirtualDom = item => {
   } = item;
   const domId = getInputId(id);
   const isModified = modified || false;
+  const modifiedChildCount = isModified ? 1 : 0;
   return [{
     type: VirtualDomElements.Div,
     className: SettingsItem,
-    childCount: 3,
+    childCount: 3 + modifiedChildCount,
     role: 'group',
     'data-modified': isModified
-  }, ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
+  }, ...getSettingsModifiedIndicatorDom(isModified), ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
     type: VirtualDomElements.Input,
     className: InputBox,
     inputType: 'number',
@@ -3868,10 +4368,10 @@ const getSettingsDom = state => {
   const {
     tabs,
     filteredItems,
-    searchValue,
-    filteredItemsCount
+    searchValue
   } = state;
   const hasSearchValue = searchValue.trim().length > 0;
+  const filteredItemsCount = filteredItems.length;
   return [{
     type: VirtualDomElements.Div,
     childCount: 2,
@@ -3992,19 +4492,21 @@ const saveState = state => {
     tabs,
     searchValue,
     scrollOffset,
-    focus
+    focus,
+    history,
+    historyIndex
   } = state;
   const selectedTab = getSelectedTabId(tabs);
   return {
-    expandedPaths: [],
-    root: '',
     minLineY: 0,
     maxLineY: 0,
     deltaY: 0,
     searchValue,
     selectedTab,
     scrollOffset,
-    focus
+    focus,
+    history,
+    historyIndex
   };
 };
 
@@ -4014,14 +4516,14 @@ const useNextSearchValue = state => {
     historyIndex,
     items,
     tabs,
-    preferences
+    modifiedSettings
   } = state;
   if (history.length === 0 || historyIndex >= history.length - 1) {
     return state;
   }
   const newHistoryIndex = historyIndex + 1;
   const newSearchValue = history[newHistoryIndex];
-  const filteredItems = getFilteredItems(items, tabs, newSearchValue, preferences);
+  const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings);
   return {
     ...state,
     searchValue: newSearchValue,
@@ -4037,14 +4539,14 @@ const usePreviousSearchValue = state => {
     historyIndex,
     items,
     tabs,
-    preferences
+    modifiedSettings
   } = state;
   if (history.length === 0 || historyIndex <= 0) {
     return state;
   }
   const newHistoryIndex = historyIndex - 1;
   const newSearchValue = history[newHistoryIndex];
-  const filteredItems = getFilteredItems(items, tabs, newSearchValue, preferences);
+  const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings);
   return {
     ...state,
     searchValue: newSearchValue,
@@ -4063,6 +4565,7 @@ const commandMap = {
   'Settings.getName': getName,
   'Settings.getCommandIds': getCommandIds,
   'Settings.handleClickTab': wrapCommand(handleClickTab),
+  'Settings.handleInputBlur': wrapCommand(handleInputBlur),
   'Settings.handleInput': wrapCommand(handleInput),
   'Settings.handleScroll': wrapCommand(handleScroll),
   'Settings.handleSettingChecked': wrapCommand(handleSettingChecked),
@@ -4078,48 +4581,8 @@ const commandMap = {
   'Settings.terminate': terminate,
   'Settings.useNextSearchValue': wrapCommand(useNextSearchValue),
   'Settings.usePreviousSearchValue': wrapCommand(usePreviousSearchValue),
-  'Settings.getKeyBindings': getKeyBindings
-};
-
-const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
-  rpcs[id] = rpc;
+  'Settings.getKeyBindings': getKeyBindings$1
 };
-const get = id => {
-  return rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$g(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-const RendererWorker$1 = 1;
-const {
-  set: set$3} = create(RendererWorker$1);
-const RendererWorker = {
-  __proto__: null,
-  set: set$3};
 
 const {
   set