@lvce-editor/static-server 0.70.2 → 0.70.4

package/static/{1b632a9 → 8c1fe09}/packages/settings-view/dist/settingsViewWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$2 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean$2 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$2;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$2;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$2) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -182,8 +225,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -206,14 +249,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -232,8 +275,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -243,8 +286,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -305,8 +348,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -326,8 +369,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -378,7 +421,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -397,7 +440,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -742,10 +785,10 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -781,10 +824,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$1(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -836,6 +879,25 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$3
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
 const toCommandId = key => {
   const dotIndex = key.indexOf('.');
@@ -870,10 +932,11 @@ const create$2 = () => {
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
+          oldState,
           newState
         } = states[uid];
         const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
+        if (oldState === newerState || newState === newerState) {
           return;
         }
         const latest = states[uid];
@@ -942,9 +1005,9 @@ const computeVisibleItems = (items, height, scrollOffset, itemHeight) => {
   const maxLineY = Math.min(totalItems, minLineY + itemsPerViewport);
   const visibleItems = items.slice(minLineY, maxLineY);
   return {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   };
 };
 
@@ -975,16 +1038,16 @@ const validateSettings = (items, modifiedSettings, preferences) => {
     const hasError = errorMessage.length > 0;
     const modified = isItemModified(item, modifiedSettings);
     return {
-      id: item.id,
-      heading: item.heading,
-      description: item.description,
-      type: item.type,
-      value: item.value,
       category: item.category,
-      options: item.options,
-      modified,
+      description: item.description,
       errorMessage,
-      hasError
+      hasError,
+      heading: item.heading,
+      id: item.id,
+      modified,
+      options: item.options,
+      type: item.type,
+      value: item.value
     };
   });
 };
@@ -997,27 +1060,27 @@ const getFilteredItems = (items, tabs, searchValue, modifiedSettings, preference
 };
 
 const User = 1;
-const Script = 2;
+const Script$1 = 2;
 
 const FocusSettingsInput = 2199;
 
 const clear$1 = state => {
   const {
+    height,
+    itemHeight,
     items,
-    tabs,
     modifiedSettings,
     preferences,
-    height,
-    itemHeight,
-    scrollBarMinHeight
+    scrollBarMinHeight,
+    tabs
   } = state;
   const newSearchValue = '';
   const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings, preferences);
   const nextScrollOffset = 0;
   const {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   } = computeVisibleItems(filteredItems, height, nextScrollOffset, itemHeight);
   const {
     thumbHeight,
@@ -1025,18 +1088,18 @@ const clear$1 = state => {
   } = computeScrollBar(height, filteredItems.length, itemHeight, nextScrollOffset, scrollBarMinHeight);
   return {
     ...state,
+    deltaY: 0,
     filteredItems,
-    visibleItems,
-    minLineY,
+    focus: FocusSettingsInput,
+    focusSource: Script$1,
+    inputSource: Script$1,
     maxLineY,
-    deltaY: 0,
+    minLineY,
+    scrollBarThumbHeight: thumbHeight,
+    scrollBarThumbTop: thumbTop,
     scrollOffset: nextScrollOffset,
-    focus: FocusSettingsInput,
-    focusSource: Script,
-    inputSource: Script,
     searchValue: newSearchValue,
-    scrollBarThumbHeight: thumbHeight,
-    scrollBarThumbTop: thumbTop
+    visibleItems
   };
 };
 
@@ -1050,10 +1113,10 @@ const clearHistory = state => {
 
 const {
   get: get$1,
-  set: set$1,
-  wrapCommand,
   getCommandIds,
   registerCommands,
+  set: set$3,
+  wrapCommand,
   wrapGetter
 } = create$2();
 
@@ -1061,36 +1124,36 @@ const create$1 = (id, uri, x, y, width, height) => {
   const state = {
     breakPointsExpanded: false,
     breakPointsVisible: false,
-    focus: 0,
-    id,
-    uri,
-    x,
-    y,
-    width,
-    height,
     deltaY: 0,
-    itemHeight: 100,
-    tabs: [],
-    items: [],
-    searchValue: '',
     filteredItems: [],
-    preferences: {},
-    inputSource: 0,
-    scrollOffset: 0,
-    minLineY: 0,
-    maxLineY: 0,
-    visibleItems: [],
     filteredItemsCount: 0,
+    focus: 0,
+    focusSource: 0,
+    height,
+    highlightsEnabled: false,
     history: [],
     historyIndex: -1,
+    id,
+    inputSource: 0,
+    itemHeight: 100,
+    items: [],
+    maxLineY: 0,
+    minLineY: 0,
     modifiedSettings: {},
-    focusSource: 0,
+    preferences: {},
     scrollBarMinHeight: 0,
     scrollBarThumbHeight: 0,
     scrollBarThumbTop: 0,
-    highlightsEnabled: false
+    scrollOffset: 0,
+    searchValue: '',
+    tabs: [],
+    uri,
+    visibleItems: [],
+    width,
+    x,
+    y
   };
-  set$1(id, state, state);
+  set$3(id, state, state);
 };
 
 const isEqual$4 = (oldState, newState) => {
@@ -1141,8 +1204,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -1151,25 +1214,478 @@ const diff2 = uid => {
 const Group = 'group';
 const Tab$1 = 'tab';
 const TabList = 'tablist';
-const AriaRoles = {
-  __proto__: null,
-  Group,
-  Tab: Tab$1,
-  TabList};
+
+const Actions = 'Actions';
+const AdditionalDetails = 'AdditionalDetails';
+const AdditionalDetailsEntry = 'AdditionalDetailsEntry';
+const AdditionalDetailsTitle = 'AdditionalDetailsTitle';
+const Aside$1 = 'Aside';
+const Badge = 'Badge';
+const Button$1 = 'Button';
+const ButtonPrimary = 'ButtonPrimary';
+const CallStackArrow = 'CallStackArrow';
+const CallStackDescription = 'CallStackDescription';
+const CallStackLabel = 'CallStackLabel';
+const Categories = 'Categories';
+const Category = 'Category';
+const Changelog = 'Changelog';
+const Chevron = 'Chevron';
+const CloseMaskIcon = 'MaskIcon MaskIconClose';
+const CodeGeneratorInput = 'CodeGeneratorInput';
+const CodeGeneratorMessage = 'CodeGeneratorMessage';
+const CodeGeneratorWidget = 'CodeGeneratorWidget';
+const ColoredMaskIcon = 'ColoredMaskIcon';
+const ColorPicker = 'ColorPicker';
+const ColorPickerBackgroundColor = 'ColorPickerBackgroundColor';
+const ColorPickerDark = 'ColorPickerDark';
+const ColorPickerLight = 'ColorPickerLight';
+const ColorPickerRectangle = 'ColorPickerRectangle';
+const ColorPickerSlider = 'ColorPickerSlider';
+const ColorPickerSliderThumb = 'ColorPickerSliderThumb';
+const CompletionDetailCloseButton = 'CompletionDetailCloseButton';
+const CompletionDetailContent = 'CompletionDetailContent';
+const DebugButton = 'DebugButton';
+const DebugButtons = 'DebugButtons';
+const DebugPausedMessage = 'DebugPausedMessage';
+const DebugPropertyChevron = 'DebugPropertyChevron';
+const DebugPropertyKey = 'DebugPropertyKey';
+const DebugRow = 'DebugRow';
+const DebugRowCallStack = 'DebugRowCallStack';
+const DebugRowCheckBox = 'DebugRowCheckBox';
+const DebugRowInputField = 'DebugRowInputField';
+const DebugSectionAction = 'DebugSectionAction';
+const DebugSectionActions = 'DebugSectionActions';
+const DebugSectionHeader = 'DebugSectionHeader';
+const DebugValue = 'DebugValue';
+const DebugValueBoolean = 'DebugValueBoolean';
+const DebugValueFunction = 'DebugValueFunction';
+const DebugValueGetter = 'DebugValueGetter';
+const DebugValueNumber = 'DebugValueNumber';
+const DebugValueObject = 'DebugValueObject';
+const DebugValueScopeName = 'DebugValueScopeName';
+const DebugValueString = 'DebugValueString';
+const DebugValueSymbol = 'DebugValueSymbol';
+const DebugValueUndefined = 'DebugValueUndefined';
+const DefaultMarkdown = 'DefaultMarkdown';
+const DefinitionListItem = 'DefinitionListItem';
+const DefinitionListItemHeading = 'DefinitionListItemHeading';
+const DefinitionListItemValue = 'DefinitionListItemValue';
+const DeleteWatchExpression = 'DeleteWatchExpression';
+const Diagnostic = 'Diagnostic';
+const DiagnosticError = 'DiagnosticError';
+const DiagnosticWarning = 'DiagnosticWarning';
+const EditorCompletionItem = 'EditorCompletionItem';
+const EditorCompletionItemDeprecated = 'EditorCompletionItemDeprecated';
+const EditorCompletionItemFocused = 'EditorCompletionItemFocused';
+const EditorCompletionItemHighlight = 'EditorCompletionItemHighlight';
+const EditorCursor = 'EditorCursor';
+const EditorRow = 'EditorRow';
+const EditorSelection = 'EditorSelection';
+const EditorSourceActions = 'EditorSourceActions';
+const EditorSourceActionsList = 'EditorSourceActionsList';
+const Empty = '';
+const ExtensionActions = 'ExtensionActions';
+const ExtensionActive = 'ExtensionActive';
+const ExtensionDetail = 'ExtensionDetail';
+const ExtensionDetailDescription = 'ExtensionDetailDescription';
+const ExtensionDetailHeader = 'ExtensionDetailHeader';
+const ExtensionDetailHeaderActions = 'ExtensionDetailHeaderActions';
+const ExtensionDetailHeaderDetails = 'ExtensionDetailHeaderDetails';
+const ExtensionDetailIcon = 'ExtensionDetailIcon';
+const ExtensionDetailName = 'ExtensionDetailName';
+const ExtensionDetailNameBadge = 'ExtensionDetailNameBadge';
+const ExtensionDetailPanel = 'ExtensionDetailPanel';
+const ExtensionDetailTab = 'ExtensionDetailTab';
+const ExtensionDetailTabs = 'ExtensionDetailTabs';
+const ExtensionDetailTabSelected = 'ExtensionDetailTabSelected';
+const ExtensionHeader = 'ExtensionHeader';
+const ExtensionListItem = 'ExtensionListItem';
+const ExtensionListItemAuthorName = 'ExtensionListItemAuthorName';
+const ExtensionListItemDescription = 'ExtensionListItemDescription';
+const ExtensionListItemDetail = 'ExtensionListItemDetail';
+const ExtensionListItemFooter = 'ExtensionListItemFooter';
+const ExtensionListItemIcon = 'ExtensionListItemIcon';
+const ExtensionListItemName = 'ExtensionListItemName';
+const Extensions = 'Extensions';
+const Feature = 'Feature';
+const FeatureContent = 'FeatureContent';
+const Features = 'Features';
+const FeaturesList = 'FeaturesList';
+const FeatureWebView = 'FeatureWebView';
+const FileIcon = 'FileIcon';
+const Filter = 'Filter';
+const FilterBadge = 'FilterBadge';
+const FindWidget = 'FindWidget';
+const FindWidgetFind = 'FindWidgetFind';
+const FindWidgetMatchCount = 'FindWidgetMatchCount';
+const FindWidgetMatchCountEmpty = 'FindWidgetMatchCountEmpty';
+const FindWidgetReplace = 'FindWidgetReplace';
+const FindWidgetRight = 'FindWidgetRight';
+const FocusOutline = 'FocusOutline';
+const Grow = 'Grow';
+const Highlight = 'Highlight';
+const HighlightDeleted = 'HighlightDeleted';
+const HighlightInserted = 'HighlightInserted';
+const HoverDisplayString = 'HoverDisplayString';
+const HoverDocumentation = 'HoverDocumentation';
+const HoverEditorRow = 'HoverEditorRow';
+const HoverProblem = 'HoverProblem';
+const HoverProblemDetail = 'HoverProblemDetail';
+const HoverProblemMessage = 'HoverProblemMessage';
+const IconButton = 'IconButton';
+const IconButtonDisabled = 'IconButtonDisabled';
+const IconClose = 'IconClose';
+const InputBox$1 = 'InputBox';
+const InputLabel = 'InputLabel';
+const InputValidationError = 'InputValidationError';
+const Label$2 = 'Label';
+const LabelCut = 'LabelCut';
+const LabelDetail = 'LabelDetail';
+const Large = 'Large';
+const List = 'List';
+const ListItems = 'ListItems';
+const Markdown = 'Markdown';
+const MaskIcon$1 = 'MaskIcon';
+const MaskIconBook = 'MaskIconBook';
+const MaskIconCaseSensitive = 'MaskIconCaseSensitive';
+const MaskIconChevronDown = 'MaskIconChevronDown';
+const MaskIconChevronRight = 'MaskIconChevronRight';
+const MaskIconEllipsis = 'MaskIconEllipsis';
+const MaskIconExclude = 'MaskIconExclude';
+const MaskIconPreserveCase = 'MaskIconPreserveCase';
+const MaskIconRegex = 'MaskIconRegex';
+const MaskIconReplaceAll = 'MaskIconReplaceAll';
+const MaskIconSymbolFile = 'MaskIconSymbolFile';
+const MaskIconWholeWord = 'MaskIconWholeWord';
+const Message = 'Message';
+const MessageAction = 'MessageAction';
+const MoreInfo = 'MoreInfo';
+const MoreInfoEntry = 'MoreInfoEntry';
+const MoreInfoEntryKey = 'MoreInfoEntryKey';
+const MoreInfoEntryOdd = 'MoreInfoEntryOdd';
+const MoreInfoEntryValue = 'MoreInfoEntryValue';
+const MultilineInputBox = 'MultilineInputBox';
+const Normal = 'Normal';
+const Problem = 'Problem';
+const ProblemAt = 'ProblemAt';
+const ProblemBadge = 'ProblemBadge';
+const Problems = 'Problems';
+const ProblemSelected = 'ProblemSelected';
+const ProblemsErrorIcon = 'ProblemsErrorIcon';
+const ProblemsIcon = 'ProblemsIcon';
+const ProblemsList = 'ProblemsList';
+const ProblemsTable = 'ProblemsTable';
+const ProblemsTableBody = 'ProblemsTableBody';
+const ProblemsTableHeader = 'ProblemsTableHeader';
+const ProblemsTableRow = 'ProblemsTableRow';
+const ProblemsTableRowItem = 'ProblemsTableRowItem';
+const ProblemsTableRowOdd = 'ProblemsTableRowOdd';
+const ProblemsWarningIcon = 'ProblemsWarningIcon';
+const QuickPick = 'QuickPick';
+const QuickPickHeader = 'QuickPickHeader';
+const QuickPickHighlight = 'QuickPickHighlight';
+const QuickPickItem = 'QuickPickItem';
+const QuickPickItemActive = 'QuickPickItemActive';
+const QuickPickItemDescription = 'QuickPickItemDescription';
+const QuickPickItemLabel = 'QuickPickItemLabel';
+const QuickPickItems = 'QuickPickItems';
+const QuickPickMaskIcon = 'QuickPickMaskIcon';
+const QuickPickScrollbar = 'QuickPickScrollbar';
+const QuickPickScrollbarSlider = 'QuickPickScrollbarSlider';
+const QuickPickStatus = 'QuickPickStatus';
+const Resource = 'Resource';
+const Resources = 'Resources';
+const Sash = 'Sash';
+const SashVertical = 'SashVertical';
+const Scrollbar$1 = 'Scrollbar';
+const ScrollBar = 'ScrollBar';
+const ScrollBarSmall = 'ScrollBarSmall';
+const ScrollbarThumb = 'ScrollbarThumb';
+const ScrollBarThumb = 'ScrollBarThumb';
+const ScrollBarThumbActive = 'ScrollBarThumbActive';
+const ScrollbarTrack = 'ScrollbarTrack';
+const ScrollBarVertical = 'ScrollBarVertical';
+const Search = 'Search';
+const SearchField = 'SearchField';
+const SearchFieldButton$1 = 'SearchFieldButton';
+const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
+const SearchFieldButtonDisabled = 'SearchFieldButtonDisabled';
+const SearchFieldButtons = 'SearchFieldButtons';
+const SearchFieldContainer = 'SearchFieldContainer';
+const SearchFieldDisabled = 'SearchFieldDisabled';
+const SearchFieldError = 'SearchFieldError';
+const SearchHeader = 'SearchHeader';
+const SearchHeaderDetails = 'SearchHeaderDetails';
+const SearchHeaderDetailsExpanded = 'SearchHeaderDetailsExpanded';
+const SearchHeaderDetailsExpandedTop = 'SearchHeaderDetailsExpandedTop';
+const SearchHeaderDetailsHeading = 'SearchHeaderDetailsHeading';
+const SearchHeaderTop = 'SearchHeaderTop';
+const SearchHeaderTopRight = 'SearchHeaderTopRight';
+const SearchInputError = 'SearchInputError';
+const SearchRemove = 'SearchRemove';
+const SearchToggleButton = 'SearchToggleButton';
+const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
+const SettingsButton = 'SettingsButton';
+const SettingsIcon = 'SettingsIcon';
+const Small = 'Small';
+const SourceActionHeading = 'SourceActionHeading';
+const SourceActionIcon = 'SourceActionIcon';
+const SourceActionItem = 'SourceActionItem';
+const SourceActionItemFocused = 'SourceActionItemFocused';
+const SourceControlBadge = 'SourceControlBadge';
+const Table = 'Table';
+const TableCell = 'TableCell';
+const TableHeading = 'TableHeading';
+const ToggleDetails = 'ToggleDetails';
+const Tree = 'Tree';
+const TreeItem = 'TreeItem';
+const TreeItemActive = 'TreeItemActive';
+const TreeItems = 'TreeItems';
 const Viewlet$1 = 'Viewlet';
+const ViewletFind = 'ViewletFind';
+const ViewletFindWidget = 'ViewletFindWidget';
+const ViewletSearchMessage = 'ViewletSearchMessage';
+const ViewletSearchMessageIndented = 'ViewletSearchMessageIndented';
+const Welcome = 'Welcome';
+const WelcomeMessage = 'WelcomeMessage';
+
 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(' ');
+  Actions,
+  AdditionalDetails,
+  AdditionalDetailsEntry,
+  AdditionalDetailsTitle,
+  Aside: Aside$1,
+  Badge,
+  Button: Button$1,
+  ButtonPrimary,
+  CallStackArrow,
+  CallStackDescription,
+  CallStackLabel,
+  Categories,
+  Category,
+  Changelog,
+  Chevron,
+  CloseMaskIcon,
+  CodeGeneratorInput,
+  CodeGeneratorMessage,
+  CodeGeneratorWidget,
+  ColorPicker,
+  ColorPickerBackgroundColor,
+  ColorPickerDark,
+  ColorPickerLight,
+  ColorPickerRectangle,
+  ColorPickerSlider,
+  ColorPickerSliderThumb,
+  ColoredMaskIcon,
+  CompletionDetailCloseButton,
+  CompletionDetailContent,
+  DebugButton,
+  DebugButtons,
+  DebugPausedMessage,
+  DebugPropertyChevron,
+  DebugPropertyKey,
+  DebugRow,
+  DebugRowCallStack,
+  DebugRowCheckBox,
+  DebugRowInputField,
+  DebugSectionAction,
+  DebugSectionActions,
+  DebugSectionHeader,
+  DebugValue,
+  DebugValueBoolean,
+  DebugValueFunction,
+  DebugValueGetter,
+  DebugValueNumber,
+  DebugValueObject,
+  DebugValueScopeName,
+  DebugValueString,
+  DebugValueSymbol,
+  DebugValueUndefined,
+  DefaultMarkdown,
+  DefinitionListItem,
+  DefinitionListItemHeading,
+  DefinitionListItemValue,
+  DeleteWatchExpression,
+  Diagnostic,
+  DiagnosticError,
+  DiagnosticWarning,
+  EditorCompletionItem,
+  EditorCompletionItemDeprecated,
+  EditorCompletionItemFocused,
+  EditorCompletionItemHighlight,
+  EditorCursor,
+  EditorRow,
+  EditorSelection,
+  EditorSourceActions,
+  EditorSourceActionsList,
+  Empty,
+  ExtensionActions,
+  ExtensionActive,
+  ExtensionDetail,
+  ExtensionDetailDescription,
+  ExtensionDetailHeader,
+  ExtensionDetailHeaderActions,
+  ExtensionDetailHeaderDetails,
+  ExtensionDetailIcon,
+  ExtensionDetailName,
+  ExtensionDetailNameBadge,
+  ExtensionDetailPanel,
+  ExtensionDetailTab,
+  ExtensionDetailTabSelected,
+  ExtensionDetailTabs,
+  ExtensionHeader,
+  ExtensionListItem,
+  ExtensionListItemAuthorName,
+  ExtensionListItemDescription,
+  ExtensionListItemDetail,
+  ExtensionListItemFooter,
+  ExtensionListItemIcon,
+  ExtensionListItemName,
+  Extensions,
+  Feature,
+  FeatureContent,
+  FeatureWebView,
+  Features,
+  FeaturesList,
+  FileIcon,
+  Filter,
+  FilterBadge,
+  FindWidget,
+  FindWidgetFind,
+  FindWidgetMatchCount,
+  FindWidgetMatchCountEmpty,
+  FindWidgetReplace,
+  FindWidgetRight,
+  FocusOutline,
+  Grow,
+  Highlight,
+  HighlightDeleted,
+  HighlightInserted,
+  HoverDisplayString,
+  HoverDocumentation,
+  HoverEditorRow,
+  HoverProblem,
+  HoverProblemDetail,
+  HoverProblemMessage,
+  IconButton,
+  IconButtonDisabled,
+  IconClose,
+  InputBox: InputBox$1,
+  InputLabel,
+  InputValidationError,
+  Label: Label$2,
+  LabelCut,
+  LabelDetail,
+  Large,
+  List,
+  ListItems,
+  Markdown,
+  MaskIcon: MaskIcon$1,
+  MaskIconBook,
+  MaskIconCaseSensitive,
+  MaskIconChevronDown,
+  MaskIconChevronRight,
+  MaskIconEllipsis,
+  MaskIconExclude,
+  MaskIconPreserveCase,
+  MaskIconRegex,
+  MaskIconReplaceAll,
+  MaskIconSymbolFile,
+  MaskIconWholeWord,
+  Message,
+  MessageAction,
+  MoreInfo,
+  MoreInfoEntry,
+  MoreInfoEntryKey,
+  MoreInfoEntryOdd,
+  MoreInfoEntryValue,
+  MultilineInputBox,
+  Normal,
+  Problem,
+  ProblemAt,
+  ProblemBadge,
+  ProblemSelected,
+  Problems,
+  ProblemsErrorIcon,
+  ProblemsIcon,
+  ProblemsList,
+  ProblemsTable,
+  ProblemsTableBody,
+  ProblemsTableHeader,
+  ProblemsTableRow,
+  ProblemsTableRowItem,
+  ProblemsTableRowOdd,
+  ProblemsWarningIcon,
+  QuickPick,
+  QuickPickHeader,
+  QuickPickHighlight,
+  QuickPickItem,
+  QuickPickItemActive,
+  QuickPickItemDescription,
+  QuickPickItemLabel,
+  QuickPickItems,
+  QuickPickMaskIcon,
+  QuickPickScrollbar,
+  QuickPickScrollbarSlider,
+  QuickPickStatus,
+  Resource,
+  Resources,
+  Sash,
+  SashVertical,
+  ScrollBar,
+  ScrollBarSmall,
+  ScrollBarThumb,
+  ScrollBarThumbActive,
+  ScrollBarVertical,
+  Scrollbar: Scrollbar$1,
+  ScrollbarThumb,
+  ScrollbarTrack,
+  Search,
+  SearchField,
+  SearchFieldButton: SearchFieldButton$1,
+  SearchFieldButtonChecked,
+  SearchFieldButtonDisabled,
+  SearchFieldButtons,
+  SearchFieldContainer,
+  SearchFieldDisabled,
+  SearchFieldError,
+  SearchHeader,
+  SearchHeaderDetails,
+  SearchHeaderDetailsExpanded,
+  SearchHeaderDetailsExpandedTop,
+  SearchHeaderDetailsHeading,
+  SearchHeaderTop,
+  SearchHeaderTopRight,
+  SearchInputError,
+  SearchRemove,
+  SearchToggleButton,
+  SearchToggleButtonExpanded,
+  SettingsButton,
+  SettingsIcon,
+  Small,
+  SourceActionHeading,
+  SourceActionIcon,
+  SourceActionItem,
+  SourceActionItemFocused,
+  SourceControlBadge,
+  Table,
+  TableCell,
+  TableHeading,
+  ToggleDetails,
+  Tree,
+  TreeItem,
+  TreeItemActive,
+  TreeItems,
+  Viewlet: Viewlet$1,
+  ViewletFind,
+  ViewletFindWidget,
+  ViewletSearchMessage,
+  ViewletSearchMessageIndented,
+  Welcome,
+  WelcomeMessage
 };
+
 const Button = 1;
 const Div = 4;
 const H1 = 5;
@@ -1182,19 +1698,14 @@ const Ul = 60;
 const Select$1 = 63;
 const Option = 64;
 const Label$1 = 66;
-const VirtualDomElements = {
-  __proto__: null,
-  Aside,
-  Button,
-  Div,
-  H1,
-  H3,
-  Input,
-  Label: Label$1,
-  Option,
-  P,
-  Select: Select$1,
-  Ul};
+
+const UpArrow = 14;
+const DownArrow = 16;
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
 const text = data => {
   return {
     type: Text,
@@ -1205,12 +1716,12 @@ const text = data => {
 
 const getKeyBindings$1 = () => {
   return [{
-    key: KeyCode.UpArrow,
     command: 'Settings.usePreviousSearchValue',
+    key: UpArrow,
     when: FocusSettingsInput
   }, {
-    key: KeyCode.DownArrow,
     command: 'Settings.useNextSearchValue',
+    key: DownArrow,
     when: FocusSettingsInput
   }];
 };
@@ -1246,21 +1757,21 @@ const handleClickTab = (state, name) => {
     return state;
   }
   const {
+    height,
+    itemHeight,
     items,
-    tabs,
-    searchValue,
     modifiedSettings,
     preferences,
-    height,
-    itemHeight,
-    scrollOffset
+    scrollOffset,
+    searchValue,
+    tabs
   } = state;
   const updatedTabs = getUpdatedTabs(tabs, name);
   const filteredItems = getFilteredItems(items, updatedTabs, searchValue, modifiedSettings, preferences);
   const {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   } = computeVisibleItems(filteredItems, height, scrollOffset, itemHeight);
   const {
     scrollBarMinHeight
@@ -1271,13 +1782,13 @@ const handleClickTab = (state, name) => {
   } = computeScrollBar(height, filteredItems.length, itemHeight, scrollOffset, scrollBarMinHeight);
   return {
     ...state,
-    tabs: updatedTabs,
     filteredItems,
-    visibleItems,
-    minLineY,
     maxLineY,
+    minLineY,
     scrollBarThumbHeight: thumbHeight,
-    scrollBarThumbTop: thumbTop
+    scrollBarThumbTop: thumbTop,
+    tabs: updatedTabs,
+    visibleItems
   };
 };
 
@@ -1344,21 +1855,21 @@ const addToHistory = (history, value) => {
 
 const handleInput = (state, value, inputSource = User) => {
   const {
-    items,
-    tabs,
+    height,
     history,
+    itemHeight,
+    items,
     modifiedSettings,
     preferences,
-    height,
-    itemHeight
+    tabs
   } = state;
   const filteredItems = getFilteredItems(items, tabs, value, modifiedSettings, preferences);
   // Reset scroll when filter value changes so the user sees results from the top
   const nextScrollOffset = 0;
   const {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   } = computeVisibleItems(filteredItems, height, nextScrollOffset, itemHeight);
   const {
     scrollBarMinHeight
@@ -1373,18 +1884,18 @@ const handleInput = (state, value, inputSource = User) => {
   } = addToHistory(history, value);
   return {
     ...state,
-    searchValue: value,
-    filteredItems,
-    visibleItems,
-    minLineY,
-    maxLineY,
     deltaY: 0,
-    scrollOffset: nextScrollOffset,
+    filteredItems,
     history: newHistory,
     historyIndex: newHistoryIndex,
     inputSource,
+    maxLineY,
+    minLineY,
     scrollBarThumbHeight: thumbHeight,
-    scrollBarThumbTop: thumbTop
+    scrollBarThumbTop: thumbTop,
+    scrollOffset: nextScrollOffset,
+    searchValue: value,
+    visibleItems
   };
 };
 
@@ -1408,8 +1919,8 @@ const handleInputFocus = state => {
 const handleScroll = (state, scrollTop, inputSource = User) => {
   return {
     ...state,
-    scrollOffset: scrollTop,
-    inputSource
+    inputSource,
+    scrollOffset: scrollTop
   };
 };
 
@@ -1432,12 +1943,12 @@ const getNewModifiedSettings = (modifiedSettings, name) => {
 
 const handleSettingUpdate = (state, name, value, inputSource) => {
   const {
-    modifiedSettings,
+    filteredItems,
     items,
-    tabs,
-    searchValue,
+    modifiedSettings,
     preferences,
-    filteredItems
+    searchValue,
+    tabs
   } = state;
   const newModifiedSettings = getNewModifiedSettings(modifiedSettings, name);
   const newPreferences = {
@@ -1447,8 +1958,8 @@ const handleSettingUpdate = (state, name, value, inputSource) => {
   const newFilteredItems = getNewFilteredItems(modifiedSettings, newModifiedSettings, items, tabs, searchValue, filteredItems, preferences, newPreferences);
   return {
     ...state,
-    inputSource,
     filteredItems: newFilteredItems,
+    inputSource,
     preferences: newPreferences
   };
 };
@@ -1516,9 +2027,9 @@ const handleWheel = (state, eventDeltaY, inputSource = User) => {
   const clampedDeltaY = clamp(total, 0, maxScrollable);
   const scrollOffset = clampedDeltaY;
   const {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   } = computeVisibleItems(filteredItems, height, scrollOffset, itemHeight);
   const {
     scrollBarMinHeight
@@ -1530,13 +2041,13 @@ const handleWheel = (state, eventDeltaY, inputSource = User) => {
   return {
     ...state,
     deltaY: clampedDeltaY,
-    scrollOffset,
-    visibleItems,
-    minLineY,
-    maxLineY,
     inputSource,
+    maxLineY,
+    minLineY,
     scrollBarThumbHeight: thumbHeight,
-    scrollBarThumbTop: thumbTop
+    scrollBarThumbTop: thumbTop,
+    scrollOffset,
+    visibleItems
   };
 };
 
@@ -1552,18 +2063,25 @@ const getModifiedSettings = preferences => {
   return modifiedSettings;
 };
 
+const Script = 2;
+
+const DebugWorker = 55;
+const RendererWorker$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get(rpcId);
@@ -1577,284 +2095,357 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
+      set$2(rpcId, rpc);
     }
   };
 };
-const DebugWorker$1 = 55;
-const RendererWorker$1 = 1;
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3,
-  dispose: dispose$3
+  dispose,
+  invoke,
+  invokeAndTransfer,
+  set: set$1
 } = create(RendererWorker$1);
 const searchFileHtml = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
+  return invoke('ExtensionHost.searchFileWithHtml', uri);
 };
 const getFilePathElectron = async file => {
-  return invoke$3('FileSystemHandle.getFilePathElectron', file);
+  return invoke('FileSystemHandle.getFilePathElectron', file);
 };
+/**
+ * @deprecated
+ */
 const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$3('ContextMenu.show', x, y, id, ...args);
+  return invoke('ContextMenu.show', x, y, id, ...args);
+};
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  // @ts-ignore
+  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const getElectronVersion = async () => {
-  return invoke$3('Process.getElectronVersion');
+  return invoke('Process.getElectronVersion');
 };
 const applyBulkReplacement = async bulkEdits => {
-  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
+  await invoke('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 const setColorTheme = async id => {
   // @ts-ignore
-  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+  return invoke(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
 };
 const getNodeVersion = async () => {
-  return invoke$3('Process.getNodeVersion');
+  return invoke('Process.getNodeVersion');
 };
 const getChromeVersion = async () => {
-  return invoke$3('Process.getChromeVersion');
+  return invoke('Process.getChromeVersion');
 };
 const getV8Version = async () => {
-  return invoke$3('Process.getV8Version');
+  return invoke('Process.getV8Version');
 };
 const getFileHandles = async fileIds => {
-  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
+  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
   return files;
 };
 const setWorkspacePath = async path => {
-  await invoke$3('Workspace.setPath', path);
+  await invoke('Workspace.setPath', path);
 };
 const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$3('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
 };
 const unregisterWebViewInterceptor = async id => {
-  await invoke$3('WebView.unregisterInterceptor', id);
+  await invoke('WebView.unregisterInterceptor', id);
 };
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
 };
 const sendMessagePortToErrorWorker = async (port, rpcId) => {
   const command = 'Errors.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
   const command = 'Markdown.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
+  return invoke('FileSystem.readFile', uri);
 };
 const getWebViewSecret = async key => {
   // @ts-ignore
-  return invoke$3('WebView.getSecret', key);
+  return invoke('WebView.getSecret', key);
 };
 const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$3('WebView.setPort', uid, port, origin, portType);
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
 };
 const setFocus = key => {
-  return invoke$3('Focus.setFocus', key);
+  return invoke('Focus.setFocus', key);
 };
 const getFileIcon = async options => {
-  return invoke$3('IconTheme.getFileIcon', options);
+  return invoke('IconTheme.getFileIcon', options);
 };
 const getColorThemeNames = async () => {
-  return invoke$3('ColorTheme.getColorThemeNames');
+  return invoke('ColorTheme.getColorThemeNames');
 };
 const disableExtension = async id => {
-  return invoke$3('ExtensionManagement.disable', id);
+  // @ts-ignore
+  return invoke('ExtensionManagement.disable', id);
 };
 const enableExtension = async id => {
   // @ts-ignore
-  return invoke$3('ExtensionManagement.enable', id);
+  return invoke('ExtensionManagement.enable', id);
 };
 const handleDebugChange = async params => {
   // @ts-ignore
-  return invoke$3('Run And Debug.handleChange', params);
+  return invoke('Run And Debug.handleChange', params);
 };
 const getFolderIcon = async options => {
-  return invoke$3('IconTheme.getFolderIcon', options);
+  return invoke('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke('Layout.handleWorkspaceRefresh');
 };
 const closeWidget = async widgetId => {
-  return invoke$3('Viewlet.closeWidget', widgetId);
+  return invoke('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$3('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
 };
 const confirm = async (message, options) => {
   // @ts-ignore
-  const result = await invoke$3('Confirmprompt.prompt', message, options);
+  const result = await invoke('ConfirmPrompt.prompt', message, options);
   return result;
 };
 const getRecentlyOpened = async () => {
-  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 const getKeyBindings = async () => {
-  return invoke$3('KeyBindingsInitial.getKeyBindings');
+  return invoke('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText = async text => {
-  await invoke$3('ClipBoard.writeText', /* text */text);
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+const readClipBoardText = async () => {
+  return invoke('ClipBoard.readText');
 };
 const writeClipBoardImage = async blob => {
   // @ts-ignore
-  await invoke$3('ClipBoard.writeImage', /* text */blob);
+  await invoke('ClipBoard.writeImage', /* text */blob);
 };
 const searchFileMemory = async uri => {
   // @ts-ignore
-  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
+  return invoke('ExtensionHost.searchFileWithMemory', uri);
 };
 const searchFileFetch = async uri => {
-  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
+  return invoke('ExtensionHost.searchFileWithFetch', uri);
 };
 const showMessageBox = async options => {
-  return invoke$3('ElectronDialog.showMessageBox', options);
+  return invoke('ElectronDialog.showMessageBox', options);
 };
 const handleDebugResumed = async params => {
-  await invoke$3('Run And Debug.handleResumed', params);
+  await invoke('Run And Debug.handleResumed', params);
 };
 const openWidget = async name => {
-  await invoke$3('Viewlet.openWidget', name);
+  await invoke('Viewlet.openWidget', name);
 };
 const getIcons = async requests => {
-  const icons = await invoke$3('IconTheme.getIcons', requests);
+  const icons = await invoke('IconTheme.getIcons', requests);
   return icons;
 };
-const activateByEvent = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+const activateByEvent = (event, assetDir, platform) => {
+  return invoke('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
-  return invoke$3('Focus.setAdditionalFocus', focusKey);
+  return invoke('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$3('GetActiveEditor.getActiveEditorId');
+  return invoke('GetActiveEditor.getActiveEditorId');
 };
 const getWorkspacePath = () => {
-  return invoke$3('Workspace.getPath');
+  return invoke('Workspace.getPath');
 };
 const sendMessagePortToRendererProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker$1);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
+const sendMessagePortToSharedProcess = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
+const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = 'Iframes.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const getPreference = async key => {
-  return await invoke$3('Preferences.get', key);
+  return await invoke('Preferences.get', key);
 };
 const getAllExtensions = async () => {
-  return invoke$3('ExtensionManagement.getAllExtensions');
+  return invoke('ExtensionManagement.getAllExtensions');
 };
 const rerenderEditor = async key => {
   // @ts-ignore
-  return invoke$3('Editor.rerender', key);
+  return invoke('Editor.rerender', key);
 };
 const handleDebugPaused = async params => {
-  await invoke$3('Run And Debug.handlePaused', params);
+  await invoke('Run And Debug.handlePaused', params);
 };
 const openUri = async (uri, focus, options) => {
-  await invoke$3('Main.openUri', uri, focus, options);
+  await invoke('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer$3(
+  await invokeAndTransfer(
   // @ts-ignore
   'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
 };
 const handleDebugScriptParsed = async script => {
-  await invoke$3('Run And Debug.handleScriptParsed', script);
+  await invoke('Run And Debug.handleScriptParsed', script);
 };
 const getWindowId = async () => {
-  return invoke$3('GetWindowId.getWindowId');
+  return invoke('GetWindowId.getWindowId');
 };
 const getBlob = async uri => {
   // @ts-ignore
-  return invoke$3('FileSystem.getBlob', uri);
+  return invoke('FileSystem.getBlob', uri);
 };
 const getExtensionCommands = async () => {
-  return invoke$3('ExtensionHost.getCommands');
+  return invoke('ExtensionHost.getCommands');
 };
 const showErrorDialog = async errorInfo => {
   // @ts-ignore
-  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
+  await invoke('ErrorHandling.showErrorDialog', errorInfo);
 };
 const getFolderSize = async uri => {
   // @ts-ignore
-  return await invoke$3('FileSystem.getFolderSize', uri);
+  return await invoke('FileSystem.getFolderSize', uri);
 };
 const getExtension = async id => {
   // @ts-ignore
-  return invoke$3('ExtensionManagement.getExtension', id);
+  return invoke('ExtensionManagement.getExtension', id);
 };
 const getMarkdownDom = async html => {
   // @ts-ignore
-  return invoke$3('Markdown.getVirtualDom', html);
+  return invoke('Markdown.getVirtualDom', html);
 };
 const renderMarkdown = async (markdown, options) => {
   // @ts-ignore
-  return invoke$3('Markdown.renderMarkdown', markdown, options);
+  return invoke('Markdown.renderMarkdown', markdown, options);
 };
 const openNativeFolder = async uri => {
   // @ts-ignore
-  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
+  await invoke('OpenNativeFolder.openNativeFolder', uri);
 };
 const uninstallExtension = async id => {
-  return invoke$3('ExtensionManagement.uninstall', id);
+  return invoke('ExtensionManagement.uninstall', id);
 };
 const installExtension = async id => {
   // @ts-ignore
-  return invoke$3('ExtensionManagement.install', id);
+  return invoke('ExtensionManagement.install', id);
+};
+const minimizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.minimize');
+};
+const unmaximizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.unmaximize');
+};
+const maximizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.maximize');
+};
+const closeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.close');
 };
 const openExtensionSearch = async () => {
   // @ts-ignore
-  return invoke$3('SideBar.openViewlet', 'Extensions');
+  return invoke('SideBar.openViewlet', 'Extensions');
 };
 const setExtensionsSearchValue = async searchValue => {
   // @ts-ignore
-  return invoke$3('Extensions.handleInput', searchValue);
+  return invoke('Extensions.handleInput', searchValue, Script);
 };
 const openExternal = async uri => {
   // @ts-ignore
-  await invoke$3('Open.openExternal', uri);
+  await invoke('Open.openExternal', uri);
 };
 const openUrl = async uri => {
   // @ts-ignore
-  await invoke$3('Open.openUrl', uri);
+  await invoke('Open.openUrl', uri);
 };
 const getAllPreferences = async () => {
   // @ts-ignore
-  return invoke$3('Preferences.getAll');
+  return invoke('Preferences.getAll');
 };
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  return invoke$3('FilePicker.showSaveFilePicker');
+  return invoke('FilePicker.showSaveFilePicker');
 };
 const getLogsDir = async () => {
   // @ts-ignore
-  return invoke$3('PlatformPaths.getLogsDir');
+  return invoke('PlatformPaths.getLogsDir');
+};
+const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
+  return invoke(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$1(mockRpc);
+  return mockRpc;
 };
+
 const RendererWorker = {
   __proto__: null,
   activateByEvent,
   applyBulkReplacement,
   closeWidget,
+  closeWindow,
   confirm,
   disableExtension,
-  dispose: dispose$3,
+  dispose,
   enableExtension,
   getActiveEditorId,
   getAllExtensions,
@@ -1885,16 +2476,22 @@ const RendererWorker = {
   handleDebugPaused,
   handleDebugResumed,
   handleDebugScriptParsed,
+  handleWorkspaceRefresh,
   installExtension,
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
+  invoke,
+  invokeAndTransfer,
+  maximizeWindow,
+  measureTextBlockHeight,
+  minimizeWindow,
   openExtensionSearch,
   openExternal,
   openNativeFolder,
   openUri,
   openUrl,
   openWidget,
+  readClipBoardText,
   readFile,
+  registerMockRpc,
   registerWebViewInterceptor,
   renderMarkdown,
   rerenderEditor,
@@ -1904,12 +2501,19 @@ const RendererWorker = {
   sendMessagePortToEditorWorker,
   sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToFileSystemProcess,
   sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToIframeWorker,
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSharedProcess,
+  sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
-  set: set$3,
+  sendMessagePortToTextMeasurementWorker,
+  set: set$1,
   setAdditionalFocus,
   setColorTheme,
   setExtensionsSearchValue,
@@ -1917,10 +2521,12 @@ const RendererWorker = {
   setWebViewPort,
   setWorkspacePath,
   showContextMenu,
+  showContextMenu2,
   showErrorDialog,
   showMessageBox,
   showSaveFilePicker,
   uninstallExtension,
+  unmaximizeWindow,
   unregisterWebViewInterceptor,
   writeClipBoardImage,
   writeClipBoardText
@@ -1928,7 +2534,7 @@ const RendererWorker = {
 
 const getPreferences = async () => {
   try {
-    return await RendererWorker.getAllPreferences();
+    return await getAllPreferences();
   } catch {
     return {};
   }
@@ -3032,30 +3638,29 @@ const unknownSettingType = () => {
 
 const getSettingItemsApplications = () => {
   return [{
-    id: 'telemetry',
-    heading: telemetry(),
+    category: ApplicationsTab,
     description: telemetryDescription(),
+    heading: telemetry(),
+    id: 'telemetry',
     type: Boolean$1,
-    value: 'true',
-    category: ApplicationsTab
+    value: 'true'
   }, {
-    id: 'updates',
-    heading: autoUpdates(),
+    category: ApplicationsTab,
     description: autoUpdatesDescription(),
+    heading: autoUpdates(),
+    id: 'updates',
     type: Boolean$1,
-    value: 'true',
-    category: ApplicationsTab
+    value: 'true'
   }];
 };
 
 const getSettingItemsEditor = () => {
   return [{
-    id: 'editor.fontSize',
-    heading: fontSize(),
+    category: TextEditorTab,
     description: fontSizeDescription(),
+    heading: fontSize(),
+    id: 'editor.fontSize',
     type: Number$1,
-    value: 15,
-    category: TextEditorTab,
     validate(value) {
       if (typeof value !== 'number') {
         return 'font size must be of type number';
@@ -3069,91 +3674,91 @@ const getSettingItemsEditor = () => {
         return 'font size must not be greater than 100';
       }
       return '';
-    }
+    },
+    value: 15
   }, {
-    id: 'editor.fontFamily',
-    heading: fontFamily(),
+    category: TextEditorTab,
     description: fontFamilyDescription(),
+    heading: fontFamily(),
+    id: 'editor.fontFamily',
     type: String,
-    value: 'Fira Code',
-    category: TextEditorTab
+    value: 'Fira Code'
   }, {
-    id: 'editor.wordWrap',
-    heading: wordWrap(),
-    description: wordWrapDescription(),
-    type: Enum,
-    value: 'off',
     category: TextEditorTab,
+    description: wordWrapDescription(),
+    heading: wordWrap(),
+    id: 'editor.wordWrap',
     options: [{
       id: 'editor.on',
       label: 'On' // i18n
     }, {
       id: 'editor.off',
       label: 'off' // i18n
-    }]
-  }, {
-    id: 'editor.lineNumbers',
-    heading: lineNumbers(),
-    description: lineNumbersDescription(),
+    }],
     type: Enum,
-    value: 'on',
+    value: 'off'
+  }, {
     category: TextEditorTab,
+    description: lineNumbersDescription(),
+    heading: lineNumbers(),
+    id: 'editor.lineNumbers',
     options: [{
       id: 'editor.on',
       label: 'On' // i18n
     }, {
       id: 'editor.off',
       label: 'off' // i18n
-    }]
+    }],
+    type: Enum,
+    value: 'on'
   }, {
-    id: 'editor.minimap',
-    heading: minimap(),
+    category: TextEditorTab,
     description: minimapDescription(),
+    heading: minimap(),
+    id: 'editor.minimap',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.scrollBeyondLastLine',
-    heading: scrollBeyondLastLine(),
+    category: TextEditorTab,
     description: scrollBeyondLastLineDescription(),
+    heading: scrollBeyondLastLine(),
+    id: 'editor.scrollBeyondLastLine',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.smoothScrolling',
-    heading: smoothScrolling(),
+    category: TextEditorTab,
     description: smoothScrollingDescription(),
+    heading: smoothScrolling(),
+    id: 'editor.smoothScrolling',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.cursorBlinking',
-    heading: cursorBlinking(),
+    category: TextEditorTab,
     description: cursorBlinkingDescription(),
+    heading: cursorBlinking(),
+    id: 'editor.cursorBlinking',
     type: String,
-    value: 'blink',
-    category: TextEditorTab
+    value: 'blink'
   }, {
-    id: 'editor.cursorStyle',
-    heading: cursorStyle(),
+    category: TextEditorTab,
     description: cursorStyleDescription(),
+    heading: cursorStyle(),
+    id: 'editor.cursorStyle',
     type: String,
-    value: 'line',
-    category: TextEditorTab
+    value: 'line'
   }, {
-    id: 'editor.cursorWidth',
-    heading: cursorWidth(),
+    category: TextEditorTab,
     description: cursorWidthDescription(),
+    heading: cursorWidth(),
+    id: 'editor.cursorWidth',
     type: Number$1,
-    value: '0',
-    category: TextEditorTab
+    value: '0'
   }, {
-    id: 'editor.tabSize',
-    heading: tabSize(),
+    category: TextEditorTab,
     description: tabSizeDescription(),
+    heading: tabSize(),
+    id: 'editor.tabSize',
     type: Number$1,
-    value: '4',
-    category: TextEditorTab,
     validate(value) {
       if (typeof value !== 'number') {
         return 'font size must be of type number';
@@ -3167,839 +3772,840 @@ const getSettingItemsEditor = () => {
         return `tab size must not be greater than ${maxTabSize}`;
       }
       return '';
-    }
+    },
+    value: '4'
   }, {
-    id: 'editor.insertSpaces',
-    heading: insertSpaces(),
+    category: TextEditorTab,
     description: insertSpacesDescription(),
+    heading: insertSpaces(),
+    id: 'editor.insertSpaces',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.detectIndentation',
-    heading: detectIndentation(),
+    category: TextEditorTab,
     description: detectIndentationDescription(),
+    heading: detectIndentation(),
+    id: 'editor.detectIndentation',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.trimAutoWhitespace',
-    heading: trimAutoWhitespace(),
+    category: TextEditorTab,
     description: trimAutoWhitespaceDescription(),
+    heading: trimAutoWhitespace(),
+    id: 'editor.trimAutoWhitespace',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.largeFileOptimizations',
-    heading: largeFileOptimizations(),
+    category: TextEditorTab,
     description: largeFileOptimizationsDescription(),
+    heading: largeFileOptimizations(),
+    id: 'editor.largeFileOptimizations',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.renderWhitespace',
-    heading: renderWhitespace(),
+    category: TextEditorTab,
     description: renderWhitespaceDescription(),
+    heading: renderWhitespace(),
+    id: 'editor.renderWhitespace',
     type: String,
-    value: 'selection',
-    category: TextEditorTab
+    value: 'selection'
   }, {
-    id: 'editor.renderControlCharacters',
-    heading: renderControlCharacters(),
+    category: TextEditorTab,
     description: renderControlCharactersDescription(),
+    heading: renderControlCharacters(),
+    id: 'editor.renderControlCharacters',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.renderLineHighlight',
-    heading: renderLineHighlight(),
+    category: TextEditorTab,
     description: renderLineHighlightDescription(),
+    heading: renderLineHighlight(),
+    id: 'editor.renderLineHighlight',
     type: String,
-    value: 'line',
-    category: TextEditorTab
+    value: 'line'
   }, {
-    id: 'editor.codeLens',
-    heading: codeLens(),
+    category: TextEditorTab,
     description: codeLensDescription(),
+    heading: codeLens(),
+    id: 'editor.codeLens',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.folding',
-    heading: folding(),
+    category: TextEditorTab,
     description: foldingDescription(),
+    heading: folding(),
+    id: 'editor.folding',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.showFoldingControls',
-    heading: showFoldingControls(),
+    category: TextEditorTab,
     description: showFoldingControlsDescription(),
+    heading: showFoldingControls(),
+    id: 'editor.showFoldingControls',
     type: String,
-    value: 'mouseover',
-    category: TextEditorTab
+    value: 'mouseover'
   }, {
-    id: 'editor.unfoldOnClickAfterEnd',
-    heading: unfoldOnClickAfterEnd(),
+    category: TextEditorTab,
     description: unfoldOnClickAfterEndDescription(),
+    heading: unfoldOnClickAfterEnd(),
+    id: 'editor.unfoldOnClickAfterEnd',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.links',
-    heading: links(),
+    category: TextEditorTab,
     description: linksDescription(),
+    heading: links(),
+    id: 'editor.links',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.colorDecorators',
-    heading: colorDecorators(),
+    category: TextEditorTab,
     description: colorDecoratorsDescription(),
+    heading: colorDecorators(),
+    id: 'editor.colorDecorators',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.lightbulb',
-    heading: lightbulb(),
+    category: TextEditorTab,
     description: lightbulbDescription(),
+    heading: lightbulb(),
+    id: 'editor.lightbulb',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.codeActionsOnSave',
-    heading: codeActionsOnSave(),
+    category: TextEditorTab,
     description: codeActionsOnSaveDescription(),
+    heading: codeActionsOnSave(),
+    id: 'editor.codeActionsOnSave',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.formatOnPaste',
-    heading: formatOnPaste(),
+    category: TextEditorTab,
     description: formatOnPasteDescription(),
+    heading: formatOnPaste(),
+    id: 'editor.formatOnPaste',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.formatOnType',
-    heading: formatOnType(),
+    category: TextEditorTab,
     description: formatOnTypeDescription(),
+    heading: formatOnType(),
+    id: 'editor.formatOnType',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.acceptSuggestionOnCommitCharacter',
-    heading: acceptSuggestionOnCommitCharacter(),
+    category: TextEditorTab,
     description: acceptSuggestionOnCommitCharacterDescription(),
+    heading: acceptSuggestionOnCommitCharacter(),
+    id: 'editor.acceptSuggestionOnCommitCharacter',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.acceptSuggestionOnEnter',
-    heading: acceptSuggestionOnEnter(),
+    category: TextEditorTab,
     description: acceptSuggestionOnEnterDescription(),
+    heading: acceptSuggestionOnEnter(),
+    id: 'editor.acceptSuggestionOnEnter',
     type: String,
-    value: 'on',
-    category: TextEditorTab
+    value: 'on'
   }, {
-    id: 'editor.tabCompletion',
-    heading: tabCompletion(),
+    category: TextEditorTab,
     description: tabCompletionDescription(),
+    heading: tabCompletion(),
+    id: 'editor.tabCompletion',
     type: String,
-    value: 'on',
-    category: TextEditorTab
+    value: 'on'
   }, {
-    id: 'editor.wordBasedSuggestions',
-    heading: wordBasedSuggestions(),
+    category: TextEditorTab,
     description: wordBasedSuggestionsDescription(),
+    heading: wordBasedSuggestions(),
+    id: 'editor.wordBasedSuggestions',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.suggestOnTriggerCharacters',
-    heading: suggestOnTriggerCharacters(),
+    category: TextEditorTab,
     description: suggestOnTriggerCharactersDescription(),
+    heading: suggestOnTriggerCharacters(),
+    id: 'editor.suggestOnTriggerCharacters',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.quickSuggestions',
-    heading: quickSuggestions(),
+    category: TextEditorTab,
     description: quickSuggestionsDescription(),
+    heading: quickSuggestions(),
+    id: 'editor.quickSuggestions',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.parameterHints',
-    heading: parameterHints(),
+    category: TextEditorTab,
     description: parameterHintsDescription(),
+    heading: parameterHints(),
+    id: 'editor.parameterHints',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.autoClosingBrackets',
-    heading: autoClosingBrackets(),
+    category: TextEditorTab,
     description: autoClosingBracketsDescription(),
+    heading: autoClosingBrackets(),
+    id: 'editor.autoClosingBrackets',
     type: String,
-    value: 'always',
-    category: TextEditorTab
+    value: 'always'
   }, {
-    id: 'editor.autoClosingQuotes',
-    heading: autoClosingQuotes(),
+    category: TextEditorTab,
     description: autoClosingQuotesDescription(),
+    heading: autoClosingQuotes(),
+    id: 'editor.autoClosingQuotes',
     type: String,
-    value: 'always',
-    category: TextEditorTab
+    value: 'always'
   }, {
-    id: 'editor.autoClosingOvertype',
-    heading: autoClosingOvertype(),
+    category: TextEditorTab,
     description: autoClosingOvertypeDescription(),
+    heading: autoClosingOvertype(),
+    id: 'editor.autoClosingOvertype',
     type: String,
-    value: 'auto',
-    category: TextEditorTab
+    value: 'auto'
   }, {
-    id: 'editor.autoClosingDelete',
-    heading: autoClosingDelete(),
+    category: TextEditorTab,
     description: autoClosingDeleteDescription(),
+    heading: autoClosingDelete(),
+    id: 'editor.autoClosingDelete',
     type: String,
-    value: 'auto',
-    category: TextEditorTab
+    value: 'auto'
   }, {
-    id: 'editor.autoSurround',
-    heading: autoSurround(),
+    category: TextEditorTab,
     description: autoSurroundDescription(),
+    heading: autoSurround(),
+    id: 'editor.autoSurround',
     type: String,
-    value: 'quotes',
-    category: TextEditorTab
+    value: 'quotes'
   }, {
-    id: 'editor.bracketPairColorization',
-    heading: bracketPairColorization(),
+    category: TextEditorTab,
     description: bracketPairColorizationDescription(),
+    heading: bracketPairColorization(),
+    id: 'editor.bracketPairColorization',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.guides',
-    heading: guides(),
+    category: TextEditorTab,
     description: guidesDescription(),
+    heading: guides(),
+    id: 'editor.guides',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.dragAndDrop',
-    heading: dragAndDrop(),
+    category: TextEditorTab,
     description: dragAndDropDescription(),
+    heading: dragAndDrop(),
+    id: 'editor.dragAndDrop',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.copyWithSyntaxHighlighting',
-    heading: copyWithSyntaxHighlighting(),
+    category: TextEditorTab,
     description: copyWithSyntaxHighlightingDescription(),
+    heading: copyWithSyntaxHighlighting(),
+    id: 'editor.copyWithSyntaxHighlighting',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.multiCursorModifier',
-    heading: multiCursorModifier(),
+    category: TextEditorTab,
     description: multiCursorModifierDescription(),
+    heading: multiCursorModifier(),
+    id: 'editor.multiCursorModifier',
     type: String,
-    value: 'alt',
-    category: TextEditorTab
+    value: 'alt'
   }, {
-    id: 'editor.multiCursorPaste',
-    heading: multiCursorPaste(),
+    category: TextEditorTab,
     description: multiCursorPasteDescription(),
+    heading: multiCursorPaste(),
+    id: 'editor.multiCursorPaste',
     type: String,
-    value: 'full',
-    category: TextEditorTab
+    value: 'full'
   }, {
-    id: 'editor.occurrencesHighlight',
-    heading: occurrencesHighlight(),
+    category: TextEditorTab,
     description: occurrencesHighlightDescription(),
+    heading: occurrencesHighlight(),
+    id: 'editor.occurrencesHighlight',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.selectionHighlight',
-    heading: selectionHighlight(),
+    category: TextEditorTab,
     description: selectionHighlightDescription(),
+    heading: selectionHighlight(),
+    id: 'editor.selectionHighlight',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.semanticHighlighting',
-    heading: semanticHighlighting(),
+    category: TextEditorTab,
     description: semanticHighlightingDescription(),
+    heading: semanticHighlighting(),
+    id: 'editor.semanticHighlighting',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.tokenColorCustomizations',
-    heading: tokenColorCustomizations(),
+    category: TextEditorTab,
     description: tokenColorCustomizationsDescription(),
+    heading: tokenColorCustomizations(),
+    id: 'editor.tokenColorCustomizations',
     type: String,
-    value: '{}',
-    category: TextEditorTab
+    value: '{}'
   }, {
-    id: 'editor.workbenchColorCustomizations',
-    heading: workbenchColorCustomizations(),
+    category: TextEditorTab,
     description: workbenchColorCustomizationsDescription(),
+    heading: workbenchColorCustomizations(),
+    id: 'editor.workbenchColorCustomizations',
     type: String,
-    value: '{}',
-    category: TextEditorTab
+    value: '{}'
   }, {
-    id: 'editorColorCustomizations',
-    heading: editorColorCustomizations(),
+    category: TextEditorTab,
     description: editorColorCustomizationsDescription(),
+    heading: editorColorCustomizations(),
+    id: 'editorColorCustomizations',
     type: String,
-    value: '{}',
-    category: TextEditorTab
+    value: '{}'
   }, {
-    id: 'editor.diffEditor',
-    heading: diffEditor(),
+    category: TextEditorTab,
     description: diffEditorDescription(),
+    heading: diffEditor(),
+    id: 'editor.diffEditor',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.diffWordWrap',
-    heading: diffWordWrap(),
+    category: TextEditorTab,
     description: diffWordWrapDescription(),
+    heading: diffWordWrap(),
+    id: 'editor.diffWordWrap',
     type: String,
-    value: 'inherit',
-    category: TextEditorTab
+    value: 'inherit'
   }, {
-    id: 'editor.diffCodeLens',
-    heading: diffCodeLens(),
+    category: TextEditorTab,
     description: diffCodeLensDescription(),
+    heading: diffCodeLens(),
+    id: 'editor.diffCodeLens',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.diffRenderSideBySide',
-    heading: diffRenderSideBySide(),
+    category: TextEditorTab,
     description: diffRenderSideBySideDescription(),
+    heading: diffRenderSideBySide(),
+    id: 'editor.diffRenderSideBySide',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.diffIgnoreTrimWhitespace',
-    heading: diffIgnoreTrimWhitespace(),
+    category: TextEditorTab,
     description: diffIgnoreTrimWhitespaceDescription(),
-    type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    heading: diffIgnoreTrimWhitespace(),
+    id: 'editor.diffIgnoreTrimWhitespace',
+    type: Boolean$1,
+    value: 'false'
   }, {
-    id: 'editor.diffRenderIndicators',
-    heading: diffRenderIndicators(),
+    category: TextEditorTab,
     description: diffRenderIndicatorsDescription(),
+    heading: diffRenderIndicators(),
+    id: 'editor.diffRenderIndicators',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.diffRenderOverviewRuler',
-    heading: diffRenderOverviewRuler(),
+    category: TextEditorTab,
     description: diffRenderOverviewRulerDescription(),
+    heading: diffRenderOverviewRuler(),
+    id: 'editor.diffRenderOverviewRuler',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.diffRenderMarginRevertIcon',
-    heading: diffRenderMarginRevertIcon(),
+    category: TextEditorTab,
     description: diffRenderMarginRevertIconDescription(),
+    heading: diffRenderMarginRevertIcon(),
+    id: 'editor.diffRenderMarginRevertIcon',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.insertMode',
-    heading: insertMode(),
+    category: TextEditorTab,
     description: insertModeDescription(),
+    heading: insertMode(),
+    id: 'editor.insertMode',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.overwriteMode',
-    heading: overwriteMode(),
+    category: TextEditorTab,
     description: overwriteModeDescription(),
+    heading: overwriteMode(),
+    id: 'editor.overwriteMode',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.readOnly',
-    heading: readOnly(),
+    category: TextEditorTab,
     description: readOnlyDescription(),
+    heading: readOnly(),
+    id: 'editor.readOnly',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.accessibilitySupport',
-    heading: accessibilitySupport(),
+    category: TextEditorTab,
     description: accessibilitySupportDescription(),
+    heading: accessibilitySupport(),
+    id: 'editor.accessibilitySupport',
     type: String,
-    value: 'auto',
-    category: TextEditorTab
+    value: 'auto'
   }, {
-    id: 'editor.autoIndent',
-    heading: autoIndent(),
+    category: TextEditorTab,
     description: autoIndentDescription(),
+    heading: autoIndent(),
+    id: 'editor.autoIndent',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.bracketMatching',
-    heading: bracketMatching(),
+    category: TextEditorTab,
     description: bracketMatchingDescription(),
+    heading: bracketMatching(),
+    id: 'editor.bracketMatching',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.centeredLayout',
-    heading: centeredLayout(),
+    category: TextEditorTab,
     description: centeredLayoutDescription(),
+    heading: centeredLayout(),
+    id: 'editor.centeredLayout',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.columnSelection',
-    heading: columnSelection(),
+    category: TextEditorTab,
     description: columnSelectionDescription(),
+    heading: columnSelection(),
+    id: 'editor.columnSelection',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.contextmenu',
-    heading: contextmenu(),
+    category: TextEditorTab,
     description: contextmenuDescription(),
+    heading: contextmenu(),
+    id: 'editor.contextmenu',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.cursorSmoothCaretAnimation',
-    heading: cursorSmoothCaretAnimation(),
+    category: TextEditorTab,
     description: cursorSmoothCaretAnimationDescription(),
+    heading: cursorSmoothCaretAnimation(),
+    id: 'editor.cursorSmoothCaretAnimation',
     type: String,
-    value: 'off',
-    category: TextEditorTab
+    value: 'off'
   }, {
-    id: 'editor.cursorSurroundingLines',
-    heading: cursorSurroundingLines(),
+    category: TextEditorTab,
     description: cursorSurroundingLinesDescription(),
+    heading: cursorSurroundingLines(),
+    id: 'editor.cursorSurroundingLines',
     type: Number$1,
-    value: '3',
-    category: TextEditorTab
+    value: '3'
   }, {
-    id: 'editor.cursorSurroundingLinesStyle',
-    heading: cursorSurroundingLinesStyle(),
+    category: TextEditorTab,
     description: cursorSurroundingLinesStyleDescription(),
+    heading: cursorSurroundingLinesStyle(),
+    id: 'editor.cursorSurroundingLinesStyle',
     type: String,
-    value: 'all',
-    category: TextEditorTab
+    value: 'all'
   }, {
-    id: 'editor.disableMonospaceOptimizations',
-    heading: disableMonospaceOptimizations(),
+    category: TextEditorTab,
     description: disableMonospaceOptimizationsDescription(),
+    heading: disableMonospaceOptimizations(),
+    id: 'editor.disableMonospaceOptimizations',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.emptySelectionClipboard',
-    heading: emptySelectionClipboard(),
+    category: TextEditorTab,
     description: emptySelectionClipboardDescription(),
+    heading: emptySelectionClipboard(),
+    id: 'editor.emptySelectionClipboard',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.extraEditorClassName',
-    heading: extraEditorClassName(),
+    category: TextEditorTab,
     description: extraEditorClassNameDescription(),
+    heading: extraEditorClassName(),
+    id: 'editor.extraEditorClassName',
     type: String,
-    value: '',
-    category: TextEditorTab
+    value: ''
   }, {
-    id: 'editor.fastScrollSensitivity',
-    heading: fastScrollSensitivity(),
+    category: TextEditorTab,
     description: fastScrollSensitivityDescription(),
+    heading: fastScrollSensitivity(),
+    id: 'editor.fastScrollSensitivity',
     type: Number$1,
-    value: '5',
-    category: TextEditorTab
+    value: '5'
   }, {
-    id: 'editor.find',
-    heading: find(),
+    category: TextEditorTab,
     description: findDescription(),
+    heading: find(),
+    id: 'editor.find',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.fixedOverflowWidgets',
-    heading: fixedOverflowWidgets(),
+    category: TextEditorTab,
     description: fixedOverflowWidgetsDescription(),
+    heading: fixedOverflowWidgets(),
+    id: 'editor.fixedOverflowWidgets',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.foldingStrategy',
-    heading: foldingStrategy(),
+    category: TextEditorTab,
     description: foldingStrategyDescription(),
+    heading: foldingStrategy(),
+    id: 'editor.foldingStrategy',
     type: String,
-    value: 'auto',
-    category: TextEditorTab
+    value: 'auto'
   }, {
-    id: 'editor.fontLigatures',
-    heading: fontLigatures(),
+    category: TextEditorTab,
     description: fontLigaturesDescription(),
+    heading: fontLigatures(),
+    id: 'editor.fontLigatures',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.glyphMargin',
-    heading: glyphMargin(),
+    category: TextEditorTab,
     description: glyphMarginDescription(),
+    heading: glyphMargin(),
+    id: 'editor.glyphMargin',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.gotoLocation',
-    heading: gotoLocation(),
+    category: TextEditorTab,
     description: gotoLocationDescription(),
+    heading: gotoLocation(),
+    id: 'editor.gotoLocation',
     type: String,
-    value: 'mouse',
-    category: TextEditorTab
+    value: 'mouse'
   }, {
-    id: 'editor.hideCursorInOverviewRuler',
-    heading: hideCursorInOverviewRuler(),
+    category: TextEditorTab,
     description: hideCursorInOverviewRulerDescription(),
+    heading: hideCursorInOverviewRuler(),
+    id: 'editor.hideCursorInOverviewRuler',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.hover',
-    heading: hover(),
+    category: TextEditorTab,
     description: hoverDescription(),
+    heading: hover(),
+    id: 'editor.hover',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.inDiffEditor',
-    heading: inDiffEditor(),
+    category: TextEditorTab,
     description: inDiffEditorDescription(),
+    heading: inDiffEditor(),
+    id: 'editor.inDiffEditor',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.letterSpacing',
-    heading: letterSpacing(),
+    category: TextEditorTab,
     description: letterSpacingDescription(),
+    heading: letterSpacing(),
+    id: 'editor.letterSpacing',
     type: Number$1,
-    value: '0',
-    category: TextEditorTab
+    value: '0'
   }, {
-    id: 'editor.lightbulbEnabled',
-    heading: lightbulbEnabled(),
+    category: TextEditorTab,
     description: lightbulbEnabledDescription(),
+    heading: lightbulbEnabled(),
+    id: 'editor.lightbulbEnabled',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.lineDecorationsWidth',
-    heading: lineDecorationsWidth(),
+    category: TextEditorTab,
     description: lineDecorationsWidthDescription(),
+    heading: lineDecorationsWidth(),
+    id: 'editor.lineDecorationsWidth',
     type: Number$1,
-    value: '10',
-    category: TextEditorTab
+    value: '10'
   }, {
-    id: 'editor.lineHeight',
-    heading: lineHeight(),
+    category: TextEditorTab,
     description: lineHeightDescription(),
+    heading: lineHeight(),
+    id: 'editor.lineHeight',
     type: Number$1,
-    value: '0',
-    category: TextEditorTab
+    value: '0'
   }, {
-    id: 'editor.matchBrackets',
-    heading: matchBrackets(),
+    category: TextEditorTab,
     description: matchBracketsDescription(),
+    heading: matchBrackets(),
+    id: 'editor.matchBrackets',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.minimapEnabled',
-    heading: minimapEnabled(),
+    category: TextEditorTab,
     description: minimapEnabledDescription(),
+    heading: minimapEnabled(),
+    id: 'editor.minimapEnabled',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.mouseWheelScrollSensitivity',
-    heading: mouseWheelScrollSensitivity(),
+    category: TextEditorTab,
     description: mouseWheelScrollSensitivityDescription(),
+    heading: mouseWheelScrollSensitivity(),
+    id: 'editor.mouseWheelScrollSensitivity',
     type: Number$1,
-    value: '1',
-    category: TextEditorTab
+    value: '1'
   }, {
-    id: 'editor.mouseWheelZoom',
-    heading: mouseWheelZoom(),
+    category: TextEditorTab,
     description: mouseWheelZoomDescription(),
+    heading: mouseWheelZoom(),
+    id: 'editor.mouseWheelZoom',
     type: Boolean$1,
-    value: 'false',
-    category: TextEditorTab
+    value: 'false'
   }, {
-    id: 'editor.multiCursorMergeOverlapping',
-    heading: multiCursorMergeOverlapping(),
+    category: TextEditorTab,
     description: multiCursorMergeOverlappingDescription(),
+    heading: multiCursorMergeOverlapping(),
+    id: 'editor.multiCursorMergeOverlapping',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.overviewRulerBorder',
-    heading: overviewRulerBorder(),
+    category: TextEditorTab,
     description: overviewRulerBorderDescription(),
+    heading: overviewRulerBorder(),
+    id: 'editor.overviewRulerBorder',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.overviewRulerLanes',
-    heading: overviewRulerLanes(),
+    category: TextEditorTab,
     description: overviewRulerLanesDescription(),
+    heading: overviewRulerLanes(),
+    id: 'editor.overviewRulerLanes',
     type: Number$1,
-    value: '3',
-    category: TextEditorTab
+    value: '3'
   }, {
-    id: 'editor.peekWidgetDefaultFocus',
-    heading: peekWidgetDefaultFocus(),
+    category: TextEditorTab,
     description: peekWidgetDefaultFocusDescription(),
+    heading: peekWidgetDefaultFocus(),
+    id: 'editor.peekWidgetDefaultFocus',
     type: String,
-    value: 'editor',
-    category: TextEditorTab
+    value: 'editor'
   }, {
-    id: 'editor.quickSuggestionsDelay',
-    heading: quickSuggestionsDelay(),
+    category: TextEditorTab,
     description: quickSuggestionsDelayDescription(),
+    heading: quickSuggestionsDelay(),
+    id: 'editor.quickSuggestionsDelay',
     type: Number$1,
-    value: '10',
-    category: TextEditorTab
+    value: '10'
   }, {
-    id: 'editor.renderFinalNewline',
-    heading: renderFinalNewline(),
+    category: TextEditorTab,
     description: renderFinalNewlineDescription(),
+    heading: renderFinalNewline(),
+    id: 'editor.renderFinalNewline',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.renderValidationDecorations',
-    heading: renderValidationDecorations(),
+    category: TextEditorTab,
     description: renderValidationDecorationsDescription(),
+    heading: renderValidationDecorations(),
+    id: 'editor.renderValidationDecorations',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.revealHorizontalRightPadding',
-    heading: revealHorizontalRightPadding(),
+    category: TextEditorTab,
     description: revealHorizontalRightPaddingDescription(),
+    heading: revealHorizontalRightPadding(),
+    id: 'editor.revealHorizontalRightPadding',
     type: Number$1,
-    value: '30',
-    category: TextEditorTab
+    value: '30'
   }, {
-    id: 'editor.roundedSelection',
-    heading: roundedSelection(),
+    category: TextEditorTab,
     description: roundedSelectionDescription(),
+    heading: roundedSelection(),
+    id: 'editor.roundedSelection',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.rulers',
-    heading: rulers(),
+    category: TextEditorTab,
     description: rulersDescription(),
+    heading: rulers(),
+    id: 'editor.rulers',
     type: String,
-    value: '[]',
-    category: TextEditorTab
+    value: '[]'
   }, {
-    id: 'editor.scrollBeyondLastColumn',
-    heading: scrollBeyondLastColumn(),
+    category: TextEditorTab,
     description: scrollBeyondLastColumnDescription(),
+    heading: scrollBeyondLastColumn(),
+    id: 'editor.scrollBeyondLastColumn',
     type: Number$1,
-    value: '5',
-    category: TextEditorTab
+    value: '5'
   }, {
-    id: 'editor.scrollbar',
-    heading: scrollbar(),
+    category: TextEditorTab,
     description: scrollbarDescription(),
+    heading: scrollbar(),
+    id: 'editor.scrollbar',
     type: String,
-    value: 'auto',
-    category: TextEditorTab
+    value: 'auto'
   }, {
-    id: 'editor.scrollPredominantAxis',
-    heading: scrollPredominantAxis(),
+    category: TextEditorTab,
     description: scrollPredominantAxisDescription(),
+    heading: scrollPredominantAxis(),
+    id: 'editor.scrollPredominantAxis',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.selectionClipboard',
-    heading: selectionClipboard(),
+    category: TextEditorTab,
     description: selectionClipboardDescription(),
+    heading: selectionClipboard(),
+    id: 'editor.selectionClipboard',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.background',
-    heading: 'Editor background',
+    category: TextEditorTab,
     description: 'Editor background color',
+    heading: 'Editor background',
+    id: 'editor.background',
     type: Color,
-    value: '#567567',
-    category: TextEditorTab
+    value: '#567567'
   }, {
-    id: 'editor.showUnused',
-    heading: showUnused(),
+    category: TextEditorTab,
     description: showUnusedDescription(),
+    heading: showUnused(),
+    id: 'editor.showUnused',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.snippetSuggestions',
-    heading: snippetSuggestions(),
+    category: TextEditorTab,
     description: snippetSuggestionsDescription(),
+    heading: snippetSuggestions(),
+    id: 'editor.snippetSuggestions',
     type: String,
-    value: 'bottom',
-    category: TextEditorTab
+    value: 'bottom'
   }, {
-    id: 'editor.suggest',
-    heading: suggest(),
+    category: TextEditorTab,
     description: suggestDescription(),
+    heading: suggest(),
+    id: 'editor.suggest',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.suggestFontSize',
-    heading: suggestFontSize(),
+    category: TextEditorTab,
     description: suggestFontSizeDescription(),
+    heading: suggestFontSize(),
+    id: 'editor.suggestFontSize',
     type: Number$1,
-    value: '0',
-    category: TextEditorTab
+    value: '0'
   }, {
-    id: 'editor.suggestLineHeight',
-    heading: suggestLineHeight(),
+    category: TextEditorTab,
     description: suggestLineHeightDescription(),
+    heading: suggestLineHeight(),
+    id: 'editor.suggestLineHeight',
     type: Number$1,
-    value: '0',
-    category: TextEditorTab
+    value: '0'
   }, {
-    id: 'editor.suggestSelection',
-    heading: suggestSelection(),
+    category: TextEditorTab,
     description: suggestSelectionDescription(),
+    heading: suggestSelection(),
+    id: 'editor.suggestSelection',
     type: String,
-    value: 'recentlyUsed',
-    category: TextEditorTab
+    value: 'recentlyUsed'
   }, {
-    id: 'editor.useTabStops',
-    heading: useTabStops(),
+    category: TextEditorTab,
     description: useTabStopsDescription(),
+    heading: useTabStops(),
+    id: 'editor.useTabStops',
     type: Boolean$1,
-    value: 'true',
-    category: TextEditorTab
+    value: 'true'
   }, {
-    id: 'editor.wordSeparators',
-    heading: wordSeparators(),
+    category: TextEditorTab,
     description: wordSeparatorsDescription(),
+    heading: wordSeparators(),
+    id: 'editor.wordSeparators',
     type: String,
-    value: '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?',
-    category: TextEditorTab
+    value: '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?'
   }, {
-    id: 'editor.wrappingIndent',
-    heading: wrappingIndent(),
+    category: TextEditorTab,
     description: wrappingIndentDescription(),
+    heading: wrappingIndent(),
+    id: 'editor.wrappingIndent',
     type: String,
-    value: 'same',
-    category: TextEditorTab
+    value: 'same'
   }];
 };
 
 const getSettingItemsExtensions = () => {
   return [{
-    id: 'extensionsAutoUpdate',
-    heading: autoUpdateExtensions(),
+    category: ExtensionsTab,
     description: autoUpdateExtensionsDescription(),
+    heading: autoUpdateExtensions(),
+    id: 'extensionsAutoUpdate',
     type: Boolean$1,
-    value: 'true',
-    category: ExtensionsTab
+    value: 'true'
   }, {
-    id: 'extensionRecommendations',
-    heading: extensionRecommendations(),
+    category: ExtensionsTab,
     description: extensionRecommendationsDescription(),
+    heading: extensionRecommendations(),
+    id: 'extensionRecommendations',
     type: Boolean$1,
-    value: 'true',
-    category: ExtensionsTab
+    value: 'true'
   }];
 };
 
 const getSettingItemsFeatures = () => {
   return [{
-    id: 'autoSave',
-    heading: autoSave(),
+    category: FeaturesTab,
     description: autoSaveDescription(),
+    heading: autoSave(),
+    id: 'autoSave',
     type: Boolean$1,
-    value: 'true',
-    category: FeaturesTab
+    value: 'true'
   }, {
-    id: 'formatOnSave',
-    heading: formatOnSave(),
+    category: FeaturesTab,
     description: formatOnSaveDescription(),
+    heading: formatOnSave(),
+    id: 'formatOnSave',
     type: Boolean$1,
-    value: 'false',
-    category: FeaturesTab
+    value: 'false'
   }];
 };
 
 const getSettingItemsSecurity = () => {
   return [{
-    id: 'encryption',
-    heading: fileEncryption(),
+    category: SecurityTab,
     description: fileEncryptionDescription(),
+    heading: fileEncryption(),
+    id: 'encryption',
     type: Boolean$1,
-    value: 'false',
-    category: SecurityTab
+    value: 'false'
   }, {
-    id: 'twoFactor',
-    heading: twoFactorAuth(),
+    category: SecurityTab,
     description: twoFactorAuthDescription(),
+    heading: twoFactorAuth(),
+    id: 'twoFactor',
     type: Boolean$1,
-    value: 'false',
-    category: SecurityTab
+    value: 'false'
   }];
 };
 
 const getSettingItemsWindow = () => {
   return [{
-    id: 'windowTitle',
-    heading: windowTitle(),
+    category: WindowTab,
     description: windowTitleDescription(),
+    heading: windowTitle(),
+    id: 'windowTitle',
     type: String,
-    value: 'Settings View',
-    category: WindowTab
+    value: 'Settings View'
   }, {
-    id: 'windowSize',
-    heading: windowSize(),
+    category: WindowTab,
     description: windowSizeDescription(),
+    heading: windowSize(),
+    id: 'windowSize',
     type: String,
-    value: '1024x768',
-    category: WindowTab
+    value: '1024x768'
   }];
 };
 
 const getSettingItemsWorkbench = () => {
   return [{
-    id: 'theme',
-    heading: theme(),
+    category: WorkbenchTab,
     description: themeDescription(),
+    heading: theme(),
+    id: 'theme',
     type: String,
-    value: 'Dark',
-    category: WorkbenchTab
+    value: 'Dark'
   }, {
-    id: 'sidebarPosition',
-    heading: sidebarPosition(),
+    category: WorkbenchTab,
     description: sidebarPositionDescription(),
+    heading: sidebarPosition(),
+    id: 'sidebarPosition',
     type: String,
-    value: 'Left',
-    category: WorkbenchTab
+    value: 'Left'
   }];
 };
 
@@ -4100,13 +4706,13 @@ const getSavedTabId = savedState => {
 const restoreState = savedState => {
   if (!savedState) {
     return {
-      minLineY: 0,
       deltaY: 0,
-      tabId: '',
-      searchValue: '',
-      scrollOffset: 0,
       history: [],
-      historyIndex: -1
+      historyIndex: -1,
+      minLineY: 0,
+      scrollOffset: 0,
+      searchValue: '',
+      tabId: ''
     };
   }
   const minLineY = getSavedMinLineY(savedState);
@@ -4117,23 +4723,23 @@ const restoreState = savedState => {
   const history = getSavedHistory(savedState);
   const historyIndex = getSavedHistoryIndex(savedState, history);
   return {
-    minLineY,
     deltaY,
-    tabId,
-    searchValue,
-    scrollOffset,
     history,
-    historyIndex
+    historyIndex,
+    minLineY,
+    scrollOffset,
+    searchValue,
+    tabId
   };
 };
 
 const loadContent = async (state, savedState) => {
   const {
-    searchValue,
-    tabId,
-    scrollOffset,
     history,
-    historyIndex
+    historyIndex,
+    scrollOffset,
+    searchValue,
+    tabId
   } = restoreState(savedState);
   const tabs = getTabs();
   const newTabs = getUpdatedTabs(tabs, tabId);
@@ -4146,9 +4752,9 @@ const loadContent = async (state, savedState) => {
     itemHeight
   } = state;
   const {
-    visibleItems,
+    maxLineY,
     minLineY,
-    maxLineY
+    visibleItems
   } = computeVisibleItems(filteredItems, height, scrollOffset, itemHeight);
   const {
     scrollBarMinHeight
@@ -4160,20 +4766,20 @@ const loadContent = async (state, savedState) => {
   return {
     ...state,
     filteredItems,
-    visibleItems,
-    minLineY,
-    maxLineY,
-    inputSource: Script,
+    history,
+    historyIndex,
+    inputSource: Script$1,
     items,
+    maxLineY,
+    minLineY,
     modifiedSettings,
     preferences,
+    scrollBarThumbHeight: thumbHeight,
+    scrollBarThumbTop: thumbTop,
     scrollOffset,
     searchValue,
     tabs: newTabs,
-    history,
-    historyIndex,
-    scrollBarThumbHeight: thumbHeight,
-    scrollBarThumbTop: thumbTop
+    visibleItems
   };
 };
 
@@ -4193,11 +4799,11 @@ const renderFocusContext = (oldState, newState) => {
 const {
   Viewlet
 } = ClassNames;
-const Badge = 'Badge';
 const CheckBox = 'CheckBox';
 const ErrorMessage = 'ErrorMessage';
 const InputBox = 'InputBox';
 const InputBoxError = 'InputBoxError';
+const InputBadge = 'InputBadge';
 const Label = 'Label';
 const MaskIcon = 'MaskIcon';
 const MaskIconClearAll = 'MaskIconClearAll';
@@ -4231,9 +4837,9 @@ const getSettingsInputBadgeDom = (filteredSettingsCount, hasSearchValue) => {
   }
   const badgeText = matchingSettings(filteredSettingsCount);
   return [{
-    type: VirtualDomElements.Div,
-    className: Badge,
-    childCount: 1
+    childCount: 1,
+    className: InputBadge,
+    type: Div
   }, text(badgeText)];
 };
 
@@ -4257,36 +4863,36 @@ const getClearButtonClassName = hasSearchValue => {
 };
 
 const icon = {
-  type: VirtualDomElements.Div,
+  childCount: 0,
   className: mergeClassNames(MaskIcon, MaskIconClearAll),
-  childCount: 0
+  type: Div
 };
 const getSettingsInputButtonsDom = hasSearchValue => {
   return [{
-    type: VirtualDomElements.Button,
-    className: getClearButtonClassName(hasSearchValue),
-    childCount: 1,
     ariaLabel: clear(),
-    name: Clear$1,
+    childCount: 1,
+    className: getClearButtonClassName(hasSearchValue),
     disabled: !hasSearchValue,
-    onClick: HandleClickClear
+    name: Clear$1,
+    onClick: HandleClickClear,
+    type: Button
   }, icon];
 };
 
 const getSettingsInputDom = () => {
   const placeholder = searchSettings();
   return [{
-    type: VirtualDomElements.Input,
-    className: mergeClassNames(InputBox, SettingsSearchInput, 'MultilineInputBox'),
-    placeholder,
+    autocapitalize: 'off',
     autocomplete: 'off',
     autocorrect: 'off',
-    autocapitalize: 'off',
-    spellcheck: false,
     childCount: 0,
+    className: mergeClassNames(InputBox, SettingsSearchInput, 'MultilineInputBox'),
     name: SettingsSearch,
+    onFocus: HandleInputFocus,
     onInput: HandleInput,
-    onFocus: HandleInputFocus
+    placeholder,
+    spellcheck: false,
+    type: Input
   }];
 };
 
@@ -4296,36 +4902,36 @@ const getChildCount$1 = hasSearchValue => {
 const getSettingsHeaderDom = (filteredSettingsCount, hasSearchValue) => {
   const childCount = getChildCount$1(hasSearchValue);
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: SettingsHeader,
-    childCount: 1
+    type: Div
   }, {
-    type: VirtualDomElements.Div,
+    childCount,
     className: mergeClassNames(SettingsInputWrapper, 'SearchField'),
-    childCount
+    type: Div
   }, ...getSettingsInputDom(), ...getSettingsInputBadgeDom(filteredSettingsCount, hasSearchValue), ...getSettingsInputButtonsDom(hasSearchValue)];
 };
 
 const getContentHeadingDom = headerText => {
   return [{
-    type: VirtualDomElements.H1,
+    childCount: 1,
     className: SettingsContentHeading,
-    childCount: 1
+    type: H1
   }, text(headerText)];
 };
 
 const parentNode$1 = {
-  type: VirtualDomElements.Div,
+  childCount: 1,
   className: mergeClassNames(SettingsScrollBar, SettingsScrollBarSmall),
-  childCount: 1
+  type: Div
 };
 const getScrollBarDom = (thumbHeight, thumbTop) => {
   return [parentNode$1, {
-    type: VirtualDomElements.Div,
-    className: SettingsScrollBarThumb,
     childCount: 0,
+    className: SettingsScrollBarThumb,
     height: `${thumbHeight}px`,
-    top: `${thumbTop}px`
+    top: `${thumbTop}px`,
+    type: Div
   }];
 };
 
@@ -4334,9 +4940,9 @@ const getErrorMessageDom = errorMessage => {
     return [];
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ErrorMessage,
-    childCount: 1
+    type: Div
   }, text(errorMessage)];
 };
 
@@ -4345,9 +4951,9 @@ const getInputId = id => {
 };
 
 const parent = {
-  type: VirtualDomElements.H3,
+  childCount: 1,
   className: SettingsItemHeading,
-  childCount: 1
+  type: H3
 };
 const getItemHeadingDom = heading => {
   return [parent, text(heading)];
@@ -4355,77 +4961,77 @@ const getItemHeadingDom = heading => {
 
 const getItemLabelDom = (domId, label) => {
   return [{
-    type: VirtualDomElements.Label,
-    htmlFor: domId,
     childCount: 1,
-    className: Label
+    className: Label,
+    htmlFor: domId,
+    type: Label$1
   }, text(label)];
 };
 
 const getItemCheckBoxVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
-    modified,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id,
+    modified
   } = item;
   const domId = getInputId(id);
   const checkBoxClassName = hasError ? `${CheckBox} ${InputBoxError}` : CheckBox;
   const errorChildCount = hasError ? 1 : 0;
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 2 + errorChildCount,
-    role: AriaRoles.Group,
-    'data-modified': modified
+    className: SettingsItem,
+    'data-modified': modified,
+    role: Group,
+    type: Div
   }, ...getItemHeadingDom(heading), {
-    type: VirtualDomElements.Div,
+    childCount: 2,
     className: SettingsItemCheckBox,
-    childCount: 2
+    type: Div
   }, {
-    type: VirtualDomElements.Input,
-    className: checkBoxClassName,
     childCount: 0,
+    className: checkBoxClassName,
     id: domId,
     inputType: 'checkbox',
     name: id,
-    onChange: HandleSettingChecked
+    onChange: HandleSettingChecked,
+    type: Input
   }, ...getItemLabelDom(domId, description), ...getErrorMessageDom(errorMessage)];
 };
 
 const getItemColorVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
-    modified,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id,
+    modified
   } = item;
   const domId = getInputId(id);
   const colorInputClassName = hasError ? mergeClassNames('ColorInput', InputBoxError) : mergeClassNames('ColorInput');
   const errorChildCount = hasError ? 1 : 0;
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 3 + errorChildCount,
-    role: AriaRoles.Group,
-    'data-modified': modified
+    className: SettingsItem,
+    'data-modified': modified,
+    role: Group,
+    type: Div
   }, ...getItemHeadingDom(heading), {
-    type: VirtualDomElements.Div,
+    childCount: 2,
     className: SettingsItemCheckBox,
-    childCount: 2
+    type: Div
   }, {
-    type: VirtualDomElements.Input,
-    className: colorInputClassName,
-    inputType: 'color',
-    placeholder: colorValue(),
     childCount: 0,
+    className: colorInputClassName,
     id: domId,
+    inputType: 'color',
     name: id,
-    onInput: HandleSettingInput
+    onInput: HandleSettingInput,
+    placeholder: colorValue(),
+    type: Input
   }, ...getItemLabelDom(domId, description), ...getErrorMessageDom(errorMessage)];
 };
 
@@ -4434,9 +5040,9 @@ const getSettingsModifiedIndicatorDom = isModified => {
     return [];
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 0,
     className: ModifiedIndicator,
-    childCount: 0
+    type: Div
   }];
 };
 
@@ -4454,31 +5060,31 @@ const getInputClassName = hasError => {
 };
 const getItemNumberVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
-    modified,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id,
+    modified
   } = item;
   const domId = getInputId(id);
   const inputClassName = getInputClassName(hasError);
   const childCount = getChildCount(modified, hasError);
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount,
-    role: AriaRoles.Group,
-    'data-modified': modified
+    className: SettingsItem,
+    'data-modified': modified,
+    role: Group,
+    type: Div
   }, ...getSettingsModifiedIndicatorDom(modified), ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
-    type: VirtualDomElements.Input,
-    className: inputClassName,
-    inputType: 'number',
-    placeholder: numberValue(),
     childCount: 0,
+    className: inputClassName,
     id: domId,
+    inputType: 'number',
     name: id,
-    onInput: HandleSettingInput
+    onInput: HandleSettingInput,
+    placeholder: numberValue(),
+    type: Input
   }, ...getErrorMessageDom(errorMessage)];
 };
 
@@ -4488,118 +5094,118 @@ const getOptionDom = option => {
     label
   } = option;
   return [{
-    type: VirtualDomElements.Option,
     childCount: 1,
+    type: Option,
     value: id
   }, text(label)];
 };
 
 const getItemSelectVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
-    options,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id,
+    options
   } = item;
   const domId = getInputId(id);
   const selectClassName = hasError ? `${Select} ${InputBoxError}` : Select;
   const errorChildCount = hasError ? 1 : 0;
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 3 + errorChildCount,
-    role: AriaRoles.Group
+    className: SettingsItem,
+    role: Group,
+    type: Div
   }, ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
-    type: VirtualDomElements.Select,
-    className: selectClassName,
     childCount: options?.length || 0,
+    className: selectClassName,
     id: domId,
     name: id,
-    onChange: HandleSettingSelect
+    onChange: HandleSettingSelect,
+    type: Select$1
   }, ...(options?.flatMap(getOptionDom) || []), ...getErrorMessageDom(errorMessage)];
 };
 
 const getItemStringVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id
   } = item;
   const domId = getInputId(id);
   const inputClassName = hasError ? `${InputBox} ${InputBoxError}` : InputBox;
   const errorChildCount = hasError ? 1 : 0;
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 3 + errorChildCount,
-    role: AriaRoles.Group
+    className: SettingsItem,
+    role: Group,
+    type: Div
   }, ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
-    type: VirtualDomElements.Input,
-    className: inputClassName,
-    inputType: 'text',
-    placeholder: stringValue(),
     childCount: 0,
+    className: inputClassName,
     id: domId,
+    inputType: 'text',
     name: id,
-    onInput: HandleSettingInput
+    onInput: HandleSettingInput,
+    placeholder: stringValue(),
+    type: Input
   }, ...getErrorMessageDom(errorMessage)];
 };
 
 const getItemUnknownVirtualDom = () => {
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 1,
-    role: AriaRoles.Group
+    className: SettingsItem,
+    role: Group,
+    type: Div
   }, text(unknownSettingType())];
 };
 
 const getItemUrlVirtualDom = item => {
   const {
-    heading,
     description,
-    id,
-    modified,
+    errorMessage,
     hasError,
-    errorMessage
+    heading,
+    id,
+    modified
   } = item;
   const domId = getInputId(id);
   const inputClassName = hasError ? `${InputBox} ${InputBoxError}` : InputBox;
   const errorChildCount = hasError ? 1 : 0;
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsItem,
     childCount: 3 + errorChildCount,
-    role: AriaRoles.Group,
-    'data-modified': modified
+    className: SettingsItem,
+    'data-modified': modified,
+    role: Group,
+    type: Div
   }, ...getItemHeadingDom(heading), ...getItemLabelDom(domId, description), {
-    type: VirtualDomElements.Input,
-    className: inputClassName,
-    inputType: 'url',
-    placeholder: numberValue(),
     childCount: 0,
+    className: inputClassName,
     id: domId,
+    inputType: 'url',
     name: id,
-    onInput: HandleSettingInput
+    onInput: HandleSettingInput,
+    placeholder: numberValue(),
+    type: Input
   }, ...getErrorMessageDom(errorMessage)];
 };
 
 const getItemRender = type => {
   switch (type) {
-    case Number$1:
-      return getItemNumberVirtualDom;
     case Boolean$1:
       return getItemCheckBoxVirtualDom;
-    case String:
-      return getItemStringVirtualDom;
-    case Enum:
-      return getItemSelectVirtualDom;
     case Color:
       return getItemColorVirtualDom;
+    case Enum:
+      return getItemSelectVirtualDom;
+    case Number$1:
+      return getItemNumberVirtualDom;
+    case String:
+      return getItemStringVirtualDom;
     case Url:
       return getItemUrlVirtualDom;
     default:
@@ -4614,13 +5220,13 @@ const getItemVirtualDom = item => {
 
 const getSettingsNoResultsDom = searchValue => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: SettingsItems,
-    childCount: 1
+    type: Div
   }, {
-    type: VirtualDomElements.P,
+    childCount: 1,
     className: SettingsNoResults,
-    childCount: 1
+    type: P
   }, text(noSettingsMatching(searchValue))];
 };
 
@@ -4629,9 +5235,9 @@ const getSettingsItemsDom = (items, searchValue) => {
     return getSettingsNoResultsDom(searchValue);
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: items.length,
     className: SettingsItems,
-    childCount: items.length
+    type: Div
   }, ...items.flatMap(getItemVirtualDom)];
 };
 
@@ -4639,14 +5245,14 @@ const getSettingsContentDom = (visibleItems, tabs, searchValue, thumbHeight, thu
   const selectedTab = tabs.find(tab => tab.selected);
   const headerText = selectedTab ? selectedTab.label : settingsContent();
   return [{
-    type: VirtualDomElements.Div,
-    className: SettingsContent,
     childCount: 2,
-    onWheel: HandleWheel
+    className: SettingsContent,
+    onWheel: HandleWheel,
+    type: Div
   }, ...getContentHeadingDom(headerText), {
-    type: VirtualDomElements.Div,
+    childCount: 2,
     className: SettingsItemWrapper,
-    childCount: 2
+    type: Div
   }, ...getSettingsItemsDom(visibleItems, searchValue), ...getScrollBarDom(thumbHeight, thumbTop)];
 };
 
@@ -4657,55 +5263,55 @@ const getTabClassName = tab => {
 const getTabVirtualDom = tab => {
   const className = getTabClassName(tab);
   return [{
-    type: VirtualDomElements.Button,
-    className,
+    ariaSelected: tab.selected,
     childCount: 1,
-    role: AriaRoles.Tab,
-    name: tab.id,
+    className,
     id: tab.id,
-    ariaSelected: tab.selected
+    name: tab.id,
+    role: Tab$1,
+    type: Button
   }, text(tab.label)];
 };
 
 const getSettingsTabsDom = tabs => {
   return [{
-    type: VirtualDomElements.Ul,
-    className: SettingsTabs,
-    role: AriaRoles.TabList,
     childCount: tabs.length,
-    onClick: HandleClickTab
+    className: SettingsTabs,
+    onClick: HandleClickTab,
+    role: TabList,
+    type: Ul
   }, ...tabs.flatMap(getTabVirtualDom)];
 };
 
 const getSettingsSideBarDom = tabs => {
   return [{
-    type: VirtualDomElements.Aside,
+    childCount: 1,
     className: SettingsSideBar,
-    childCount: 1
+    type: Aside
   }, ...getSettingsTabsDom(tabs)];
 };
 
 const getSettingsMainDom = (tabs, visibleItems, totalItemCount, searchValue, thumbHeight, thumbTop) => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 2,
     className: SettingsMain,
-    childCount: 2
+    type: Div
   }, ...getSettingsSideBarDom(tabs), ...getSettingsContentDom(visibleItems, tabs, searchValue, thumbHeight, thumbTop)];
 };
 
 const parentNode = {
-  type: VirtualDomElements.Div,
   childCount: 2,
-  className: mergeClassNames(Viewlet, Settings)
+  className: mergeClassNames(Viewlet, Settings),
+  type: Div
 };
 const getSettingsDom = state => {
   const {
-    tabs,
     filteredItems,
-    visibleItems,
-    searchValue,
     scrollBarThumbHeight,
-    scrollBarThumbTop
+    scrollBarThumbTop,
+    searchValue,
+    tabs,
+    visibleItems
   } = state;
   const hasSearchValue = searchValue.trim().length > 0;
   const filteredItemsCount = filteredItems.length;
@@ -4755,18 +5361,18 @@ const renderValue = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderFocus:
+      return renderFocus;
+    case RenderFocusContext:
+      return renderFocusContext;
     case RenderItems:
       return renderItems;
-    case RenderValue:
-      return renderValue;
-    case RenderSettingValues:
-      return renderSettingValues;
     case RenderScrollOffset:
       return renderScrollOffset;
-    case RenderFocusContext:
-      return renderFocusContext;
-    case RenderFocus:
-      return renderFocus;
+    case RenderSettingValues:
+      return renderSettingValues;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -4783,10 +5389,10 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
-  set$1(uid, newState, newState);
+  set$3(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -4832,24 +5438,24 @@ const renderEventListeners = () => {
 
 const saveState = state => {
   const {
-    tabs,
-    searchValue,
-    scrollOffset,
     focus,
     history,
-    historyIndex
+    historyIndex,
+    scrollOffset,
+    searchValue,
+    tabs
   } = state;
   const selectedTab = getSelectedTabId(tabs);
   return {
-    minLineY: 0,
-    maxLineY: 0,
     deltaY: 0,
-    searchValue,
-    selectedTab,
-    scrollOffset,
     focus,
     history,
-    historyIndex
+    historyIndex,
+    maxLineY: 0,
+    minLineY: 0,
+    scrollOffset,
+    searchValue,
+    selectedTab
   };
 };
 
@@ -4858,9 +5464,9 @@ const useNextSearchValue = state => {
     history,
     historyIndex,
     items,
-    tabs,
     modifiedSettings,
-    preferences
+    preferences,
+    tabs
   } = state;
   if (history.length === 0 || historyIndex >= history.length - 1) {
     return state;
@@ -4870,10 +5476,10 @@ const useNextSearchValue = state => {
   const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings, preferences);
   return {
     ...state,
-    searchValue: newSearchValue,
-    historyIndex: newHistoryIndex,
     filteredItems,
-    inputSource: Script
+    historyIndex: newHistoryIndex,
+    inputSource: Script$1,
+    searchValue: newSearchValue
   };
 };
 
@@ -4882,9 +5488,9 @@ const usePreviousSearchValue = state => {
     history,
     historyIndex,
     items,
-    tabs,
     modifiedSettings,
-    preferences
+    preferences,
+    tabs
   } = state;
   if (history.length === 0 || historyIndex <= 0) {
     return state;
@@ -4894,10 +5500,10 @@ const usePreviousSearchValue = state => {
   const filteredItems = getFilteredItems(items, tabs, newSearchValue, modifiedSettings, preferences);
   return {
     ...state,
-    searchValue: newSearchValue,
-    historyIndex: newHistoryIndex,
     filteredItems,
-    inputSource: Script
+    historyIndex: newHistoryIndex,
+    inputSource: Script$1,
+    searchValue: newSearchValue
   };
 };
 
@@ -4907,17 +5513,18 @@ const commandMap = {
   'Settings.clearHistory': wrapCommand(clearHistory),
   'Settings.create': create$1,
   'Settings.diff2': diff2,
-  'Settings.getName': getName,
   'Settings.getCommandIds': getCommandIds,
+  'Settings.getKeyBindings': getKeyBindings$1,
+  'Settings.getName': getName,
   'Settings.handleClickTab': wrapCommand(handleClickTab),
-  'Settings.handleInputBlur': wrapCommand(handleInputBlur),
   'Settings.handleInput': wrapCommand(handleInput),
+  'Settings.handleInputBlur': wrapCommand(handleInputBlur),
+  'Settings.handleInputFocus': wrapCommand(handleInputFocus),
   'Settings.handleScroll': wrapCommand(handleScroll),
-  'Settings.handleWheel': wrapCommand(handleWheel),
   'Settings.handleSettingChecked': wrapCommand(handleSettingChecked),
   'Settings.handleSettingInput': wrapCommand(handleSettingInput),
-  'Settings.handleInputFocus': wrapCommand(handleInputFocus),
   'Settings.handleSettingSelect': wrapCommand(handleSettingSelect),
+  'Settings.handleWheel': wrapCommand(handleWheel),
   'Settings.loadContent': wrapCommand(loadContent),
   'Settings.render2': render2,
   'Settings.renderActions': renderActions,
@@ -4926,8 +5533,7 @@ const commandMap = {
   'Settings.saveState': wrapGetter(saveState),
   'Settings.terminate': terminate,
   'Settings.useNextSearchValue': wrapCommand(useNextSearchValue),
-  'Settings.usePreviousSearchValue': wrapCommand(usePreviousSearchValue),
-  'Settings.getKeyBindings': getKeyBindings$1
+  'Settings.usePreviousSearchValue': wrapCommand(usePreviousSearchValue)
 };
 
 const {