@lvce-editor/problems-view 1.12.0 → 1.14.0

package/dist/problemsViewWorkerMain.js

@@ -527,7 +527,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$6 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -546,7 +546,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$6(id, resolve);
   return {
     id,
     promise
@@ -626,7 +626,8 @@ const splitLines = lines => {
   return lines.split(NewLine);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -890,13 +891,19 @@ const send$1 = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -907,7 +914,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -923,10 +930,10 @@ const createRpc = ipc => {
       send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1012,9 +1019,33 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$4
 };
+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$1 = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
 const create$2 = () => {
   const states = Object.create(null);
+  const commandMapRef = {};
   return {
     get(uid) {
       return states[uid];
@@ -1041,10 +1072,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];
@@ -1055,6 +1087,15 @@ const create$2 = () => {
       };
       return wrapped;
     },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -1068,6 +1109,14 @@ const create$2 = () => {
         }
       }
       return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId$1);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
     }
   };
 };
@@ -1075,16 +1124,43 @@ const terminate = () => {
   globalThis.close();
 };
 
+const None$1 = 'none';
+const ToolBar = 'toolbar';
+const Tree = 'tree';
+const TreeItem = 'treeitem';
+
+const Button$1 = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const A = 53;
+
+const Space = 9;
+const PageUp = 10;
+const PageDown = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+
+const Script$1 = 2;
+
+const DebugWorker = 55;
+const EditorWorker$1 = 99;
+const RendererWorker$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create$1 = rpcId => {
   return {
     // @ts-ignore
@@ -1100,7 +1176,7 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$5(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1108,42 +1184,511 @@ const create$1 = rpcId => {
     }
   };
 };
-const EditorWorker$1 = 99;
-const RendererWorker$1 = 1;
+
 const {
-  invoke: invoke$c,
-  set: set$c} = create$1(EditorWorker$1);
+  invoke: invoke$1,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$4,
+  dispose: dispose$1
+} = create$1(EditorWorker$1);
+const sendMessagePortToExtensionHostWorker$1 = async port => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$1(
+  // @ts-ignore
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
+};
+// TODO add tests for this
+const activateByEvent$1 = async event => {
+  // @ts-ignore
+  await invoke$1('ActivateByEvent.activateByEvent', event);
+};
+const applyEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$1('Editor.applyEdit2', editorUid, changes);
+};
+const applyWorkspaceEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$1('Editor.applyWorkspaceEdit', editorUid, changes);
+};
+const closeWidget$1 = async (editorUid, widgetId, widgetName, focusId) => {
+  // @ts-ignore
+  await invoke$1('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
+};
+const getWordAt = async (uid, rowIndex, columnIndex) => {
+  // @ts-ignore
+  const word = await invoke$1('Editor.getWordAt2', uid, rowIndex, columnIndex);
+  return word;
+};
+const getLines = async editorUid => {
+  const lines = await invoke$1('Editor.getLines2', editorUid);
+  return lines;
+};
+const getPositionAtCursor = async parentUid => {
+  const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
+  return position;
+};
+const getOffsetAtCursor = async editorId => {
+  // @ts-ignore
+  return await invoke$1('Editor.getOffsetAtCursor', editorId);
+};
+const getSelections = async editorUid => {
+  const selections = await invoke$1('Editor.getSelections2', editorUid);
+  return selections;
+};
+const getWordAtOffset2 = async editorUid => {
+  return invoke$1('Editor.getWordAtOffset2', editorUid);
+};
+const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
+  return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+};
+const updateDebugInfo = async info => {
+  await invoke$1('Editor.updateDebugInfo', info);
+};
+const getUri = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getUri', editorUid);
+};
+const getLanguageId = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getLanguageId', editorUid);
+};
 const getProblems$2 = async () => {
   // @ts-ignore
-  return invoke$c('Editor.getProblems');
+  return invoke$1('Editor.getProblems');
 };
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$4(mockRpc);
+  return mockRpc;
+};
+
 const EditorWorker = {
   __proto__: null,
+  activateByEvent: activateByEvent$1,
+  applyEdit,
+  applyWorkspaceEdit,
+  closeWidget: closeWidget$1,
+  dispose: dispose$1,
+  getLanguageId,
+  getLines,
+  getOffsetAtCursor,
+  getPositionAtCursor,
   getProblems: getProblems$2,
-  set: set$c};
+  getSelections,
+  getUri,
+  getWordAt,
+  getWordAtOffset2,
+  getWordBefore,
+  invoke: invoke$1,
+  invokeAndTransfer: invokeAndTransfer$1,
+  registerMockRpc: registerMockRpc$1,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  set: set$4,
+  updateDebugInfo
+};
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3} = create$1(RendererWorker$1);
+  invoke,
+  invokeAndTransfer,
+  set: set$3,
+  dispose
+} = create$1(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke('FileSystemHandle.getFilePathElectron', file);
+};
+/**
+ * @deprecated
+ */
+const showContextMenu = async (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('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke('WebView.unregisterInterceptor', id);
+};
 const sendMessagePortToEditorWorker$1 = 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('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  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('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke('Layout.handleWorkspaceRefresh');
+};
+const closeWidget = async widgetId => {
+  return invoke('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings$1 = async () => {
+  return invoke('KeyBindingsInitial.getKeyBindings');
 };
 const writeClipBoardText$1 = 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('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  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 sendMessagePortToFileSystemProcess = async (port, rpcId) => {
+  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const getPreference = async key => {
+  return await invoke('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke('Extensions.handleInput', searchValue, Script$1);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  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$3(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
   __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings: getKeyBindings$1,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  handleWorkspaceRefresh,
+  installExtension,
+  invoke,
+  invokeAndTransfer,
+  measureTextBlockHeight,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readClipBoardText,
+  readFile,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
   sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$1,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemProcess,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
+  sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
   set: set$3,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showContextMenu2,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
   writeClipBoardText: writeClipBoardText$1
 };
 
 const {
+  sendMessagePortToEditorWorker,
   set: set$2,
-  writeClipBoardText,
-  sendMessagePortToEditorWorker
+  writeClipBoardText
 } = RendererWorker;
 
 const writeText = async text => {
@@ -1152,8 +1697,8 @@ const writeText = async text => {
 
 const copyMessage = async state => {
   const {
-    problems,
-    focusedIndex
+    focusedIndex,
+    problems
   } = state;
   const problem = problems[focusedIndex];
   await writeText(problem.message);
@@ -1169,31 +1714,31 @@ const {
   wrapCommand
 } = create$2();
 
-const None$1 = 0;
+const None = 0;
 const Table = 1;
 const List = 2;
 
 const create = (id, uri, x, y, width, height, workspaceUri) => {
   const state = {
-    uid: id,
-    problems: [],
+    collapsedUris: [],
+    filteredProblems: [],
+    filterValue: '',
     focusedIndex: -2,
-    message: '',
-    itemHeight: 22,
-    x,
-    y,
-    width,
     height,
-    filterValue: '',
-    viewMode: None$1,
     inputSource: User,
-    minLineY: 0,
-    maxLineY: 0,
+    itemHeight: 22,
     listItems: [],
-    collapsedUris: [],
+    maxLineY: 0,
+    message: '',
+    minLineY: 0,
+    problems: [],
     smallWidthBreakPoint: 650,
-    filteredProblems: [],
-    workspaceUri
+    uid: id,
+    viewMode: None,
+    width,
+    workspaceUri,
+    x,
+    y
   };
   set$1(id, state, state);
 };
@@ -1225,8 +1770,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -1251,56 +1796,10 @@ const getCommandIds = () => {
   return ids;
 };
 
-const None = 'none';
-const ToolBar = 'toolbar';
-const Tree$1 = 'tree';
-const TreeItem$1 = 'treeitem';
-const AriaRoles = {
-  __proto__: null,
-  None,
-  ToolBar,
-  Tree: Tree$1,
-  TreeItem: TreeItem$1
-};
-const Space = 9;
-const PageUp = 10;
-const PageDown = 11;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const KeyCode = {
-  __proto__: null,
-  DownArrow,
-  End,
-  Home,
-  LeftArrow,
-  PageDown,
-  PageUp,
-  RightArrow,
-  Space,
-  UpArrow
-};
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
-const Button$1 = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const A = 53;
-const VirtualDomElements = {
-  __proto__: null,
-  A,
-  Button: Button$1,
-  Div,
-  Img,
-  Input,
-  Span};
+
 const text = data => {
   return {
     type: Text,
@@ -1313,48 +1812,48 @@ const FocusProblems = 19;
 
 const getKeyBindings = () => {
   return [{
-    key: KeyCode.DownArrow,
     command: 'Problems.focusNext',
+    key: DownArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.UpArrow,
     command: 'Problems.focusPrevious',
+    key: UpArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: KeyCode.PageUp,
     command: 'Problems.focusFirst',
+    key: PageUp,
     when: FocusProblems
   }, {
-    key: KeyCode.PageDown,
     command: 'Problems.focusLast',
+    key: PageDown,
     when: FocusProblems
   }, {
-    key: KeyCode.End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: KeyCode.Space,
     command: 'Problems.selectCurrent',
+    key: Space,
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: KeyCode.End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: KeyCode.LeftArrow,
     command: 'Problems.handleArrowLeft',
+    key: LeftArrow,
     when: FocusProblems
   }, {
-    key: KeyCode.RightArrow,
     command: 'Problems.handleArrowRight',
+    key: RightArrow,
     when: FocusProblems
   }];
 };
@@ -1380,9 +1879,9 @@ const getArrowLeftNewFocusedIndex = (problems, collapsedUris, focusedIndex) => {
 };
 const handleArrowLeft = state => {
   const {
-    problems,
+    collapsedUris,
     focusedIndex,
-    collapsedUris
+    problems
   } = state;
   const {
     index,
@@ -1390,8 +1889,8 @@ const handleArrowLeft = state => {
   } = getArrowLeftNewFocusedIndex(problems, collapsedUris, focusedIndex);
   return {
     ...state,
-    focusedIndex: index,
-    collapsedUris: newCollapsedUris
+    collapsedUris: newCollapsedUris,
+    focusedIndex: index
   };
 };
 
@@ -1413,9 +1912,9 @@ const getArrowRightNewFocusedIndex = (problems, collapsedUris, focusedIndex) =>
 };
 const handleArrowRight = state => {
   const {
-    problems,
+    collapsedUris,
     focusedIndex,
-    collapsedUris
+    problems
   } = state;
   const {
     index,
@@ -1423,8 +1922,8 @@ const handleArrowRight = state => {
   } = getArrowRightNewFocusedIndex(problems, collapsedUris, focusedIndex);
   return {
     ...state,
-    focusedIndex: index,
-    collapsedUris: newCollapsedUris
+    collapsedUris: newCollapsedUris,
+    focusedIndex: index
   };
 };
 
@@ -1436,10 +1935,10 @@ const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
 
 const handleClickAt = (state, eventX, eventY) => {
   const {
+    itemHeight,
     problems,
     x,
-    y,
-    itemHeight
+    y
   } = state;
 
   // TODO use functional focus rendering
@@ -1462,8 +1961,6 @@ const handleClickButton = async (state, name) => {
 };
 
 const handleContextMenu = async (state, eventX, eventY) => {
-  // @ts-ignore
-  // await ContextMenu.show(eventX, eventY, MenuEntryId.Problems)
   return state;
 };
 
@@ -1498,8 +1995,8 @@ const createEditorWorkerRpc = async () => {
 };
 
 const {
-  set,
-  getProblems: getProblems$1
+  getProblems: getProblems$1,
+  set
 } = EditorWorker;
 
 const initialize = async () => {
@@ -1509,29 +2006,29 @@ const initialize = async () => {
 
 const toProblem = (diagnostic, index) => {
   const {
+    code,
+    columnIndex,
     message,
     rowIndex,
-    columnIndex,
     source,
-    code,
     type,
     uri
   } = diagnostic;
   return {
-    message: message || '',
-    rowIndex: rowIndex || 0,
+    code: code || '',
     columnIndex: columnIndex || 0,
-    uri,
-    relativePath: '',
     count: 0,
-    source: source || '',
-    code: code || '',
-    type: type || 'error',
+    fileName: '',
+    level: 2,
     listItemType: Item,
+    message: message || '',
     posInSet: index,
+    relativePath: '',
+    rowIndex: rowIndex || 0,
     setSize: 1,
-    level: 2,
-    fileName: ''
+    source: source || '',
+    type: type || 'error',
+    uri
   };
 };
 const getRelativeParentUri = (uri, workspaceUri) => {
@@ -1545,20 +2042,20 @@ const getFileName = uri => {
 const toProblems = (diagnostics, workspaceUri = '') => {
   const problems = [];
   let problem = {
-    message: '',
-    rowIndex: 0,
+    code: '',
     columnIndex: 0,
-    uri: '',
-    relativePath: '',
     count: 0,
-    source: '',
-    code: '',
+    fileName: '',
     level: 0,
     listItemType: 0,
+    message: '',
     posInSet: 0,
+    relativePath: '',
+    rowIndex: 0,
     setSize: 0,
+    source: '',
     type: '',
-    fileName: ''
+    uri: ''
   };
   let relativeIndex = 0;
   for (const diagnostic of diagnostics) {
@@ -1568,20 +2065,20 @@ const toProblems = (diagnostics, workspaceUri = '') => {
     } else {
       relativeIndex = 1;
       problem = {
-        message: '',
-        rowIndex: 0,
+        code: '',
         columnIndex: 0,
-        uri: diagnostic.uri,
-        relativePath: '',
         count: 1,
-        source: '',
-        type: '',
+        fileName: '',
+        level: 1,
         listItemType: Expanded,
+        message: '',
         posInSet: relativeIndex,
+        relativePath: '',
+        rowIndex: 0,
         setSize: 123,
-        level: 1,
-        code: '',
-        fileName: ''
+        source: '',
+        type: '',
+        uri: diagnostic.uri
       };
       problems.push(problem);
     }
@@ -1606,13 +2103,13 @@ const getProblems = async workspaceUri => {
     // @ts-ignore
     const problems = toProblems(diagnostics, workspaceUri);
     return {
-      problems,
-      error: ''
+      error: '',
+      problems
     };
   } catch (error) {
     return {
-      problems: [],
-      error: `${error}`
+      error: `${error}`,
+      problems: []
     };
   }
 };
@@ -1719,8 +2216,8 @@ const getSavedCollapsedUris = savedState => {
 };
 const loadContent = async (state, savedState) => {
   const {
-    problems,
-    error
+    error,
+    problems
   } = await getProblems(state.workspaceUri);
   if (error) {
     return {
@@ -1734,14 +2231,14 @@ const loadContent = async (state, savedState) => {
   const collapsedUris = getSavedCollapsedUris(savedState);
   return {
     ...state,
-    problems,
-    message,
-    viewMode,
+    collapsedUris,
+    filteredProblems: problems,
     filterValue,
     inputSource: Script,
-    filteredProblems: problems,
     listItems: [],
-    collapsedUris
+    message,
+    problems,
+    viewMode
   };
 };
 
@@ -1789,40 +2286,40 @@ const HandleContextMenu = 'handleContextMenu';
 const HandleFilterInput = 'handleFilterInput';
 const HandlePointerDown = 'handlePointerDown';
 
-const getIconVirtualDom = (icon, type = VirtualDomElements.Div) => {
+const getIconVirtualDom = (icon, type = Div) => {
   return {
-    type,
+    childCount: 0,
     className: mergeClassNames('MaskIcon', `MaskIcon${icon}`),
-    role: AriaRoles.None,
-    childCount: 0
+    role: None$1,
+    type
   };
 };
 
 const getActionButtonVirtualDom = action => {
   const {
-    id,
+    command,
     icon,
-    command
+    id
   } = action;
   return [{
-    type: VirtualDomElements.Button,
+    childCount: 1,
     className: IconButton,
-    title: id,
     'data-command': command,
-    childCount: 1
+    title: id,
+    type: Button$1
   }, getIconVirtualDom(icon)];
 };
 
 const getInputBoxVirtualDom = (name, onInput, placeholder) => {
   return {
-    type: VirtualDomElements.Input,
-    className: InputBox,
     autocapitalize: 'off',
     autocorrect: 'off',
+    className: InputBox,
     name,
     onInput: onInput,
     placeholder: placeholder,
-    spellcheck: false
+    spellcheck: false,
+    type: Input
   };
 };
 
@@ -1845,70 +2342,69 @@ const getBadgeDom = badgeText => {
     return [];
   }
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: FilterBadge,
-    childCount: 1
+    type: Div
   }, text(badgeText)];
 };
 const getProblemsFilterVirtualDom = action => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: getChildCount(action.badgeText),
     className: Filter$1,
-    childCount: getChildCount(action.badgeText)
+    type: Div
   }, getInputBoxVirtualDom(Filter$2, action.command, action.placeholder || ''), ...getBadgeDom(action.badgeText), ...getActionButtonVirtualDom({
-    id: 'more filters',
-    // TODO use i18n string
+    command: 'more filters',
     icon: Filter,
-    command: 'more filters'
+    id: 'more filters' // TODO use i18n string
   })];
 };
 
 const getNoResultsWithFilterVirtualDom = () => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 3,
     className: Message,
-    childCount: 3
+    type: Div
   }, {
-    type: VirtualDomElements.Span,
-    childCount: 1
+    childCount: 1,
+    type: Span
   }, text(noResultsFoundWithProvidedFilterCriteria()), {
-    type: VirtualDomElements.A,
-    className: MessageAction,
     childCount: 1,
-    onClick: HandleClearFilterClick
+    className: MessageAction,
+    onClick: HandleClearFilterClick,
+    type: A
   }, text(clearFilter()), text('.')];
 };
 
 const getBadgeVirtualDom = (className, count) => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: mergeClassNames('Badge', className) + (''),
-    childCount: 1
+    type: Div
   }, text(`${count}`)];
 };
 
 const getChevronDownVirtualDom = (extraClassName = '') => {
   return {
-    type: VirtualDomElements.Div,
+    childCount: 0,
     className: mergeClassNames(Chevron, 'MaskIconChevronDown', extraClassName) + (extraClassName === '' ? ' ' : ''),
-    childCount: 0
+    type: Div
   };
 };
 const getChevronRightVirtualDom = (extraClassName = '') => {
   return {
-    type: VirtualDomElements.Div,
+    childCount: 0,
     className: mergeClassNames(Chevron, 'MaskIconChevronRight', extraClassName) + (extraClassName === '' ? ' ' : ''),
-    childCount: 0
+    type: Div
   };
 };
 
 const getFileIconVirtualDom = icon => {
   return {
-    type: VirtualDomElements.Img,
+    childCount: 0,
     className: FileIcon,
+    role: None$1,
     src: icon,
-    role: AriaRoles.None,
-    childCount: 0
+    type: Img
   };
 };
 
@@ -1917,15 +2413,15 @@ const Warning = 'warning';
 const getProblemsIconVirtualDom = type => {
   if (type === Warning) {
     return {
-      type: VirtualDomElements.Div,
+      childCount: 0,
       className: mergeClassNames(ProblemsIcon, ProblemsWarningIcon),
-      childCount: 0
+      type: Div
     };
   }
   return {
-    type: VirtualDomElements.Div,
+    childCount: 0,
     className: mergeClassNames(ProblemsIcon, ProblemsErrorIcon),
-    childCount: 0
+    type: Div
   };
 };
 
@@ -1951,6 +2447,7 @@ const getProblemVirtualDom = problem => {
   const {
     code,
     columnIndex,
+    fileName,
     filterValueLength,
     icon,
     isActive,
@@ -1964,8 +2461,7 @@ const getProblemVirtualDom = problem => {
     rowIndex,
     setSize,
     source,
-    type,
-    fileName
+    type
   } = problem;
   let className = Problem;
   if (isActive) {
@@ -1973,41 +2469,41 @@ const getProblemVirtualDom = problem => {
   }
   if (listItemType === Expanded || listItemType === Collapsed) {
     return [{
-      type: VirtualDomElements.Div,
-      className,
-      childCount: 5,
-      paddingLeft: getTreeItemIndent(1),
-      ariaPosInSet: posInSet,
-      ariaSetSize: setSize,
-      ariaLevel: level,
       ariaExpanded: !isCollapsed,
+      ariaLevel: level,
+      ariaPosInSet: posInSet,
       ariaSelected: isActive,
-      role: AriaRoles.TreeItem
+      ariaSetSize: setSize,
+      childCount: 5,
+      className,
+      paddingLeft: getTreeItemIndent(1),
+      role: TreeItem,
+      type: Div
     }, listItemType === Collapsed ? getChevronRightVirtualDom() : getChevronDownVirtualDom(), getFileIconVirtualDom(icon), text(fileName), {
-      type: VirtualDomElements.Div,
+      childCount: 1,
       className: LabelDetail,
-      childCount: 1
+      type: Div
     }, text(relativePath), ...getBadgeVirtualDom(ProblemBadge, problem.count)];
   }
   const lineColumn = atLineColumn(rowIndex, columnIndex);
   const label = {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: Label,
-    childCount: 1
+    type: Div
   };
   /**
    * @type {any}
    */
   const dom = [{
-    type: VirtualDomElements.Div,
-    className,
-    childCount: 3,
-    paddingLeft: getTreeItemIndent(2),
-    ariaPosInSet: posInSet,
-    ariaSetSize: setSize,
     ariaLevel: level,
+    ariaPosInSet: posInSet,
     ariaSelected: isActive,
-    role: AriaRoles.TreeItem
+    ariaSetSize: setSize,
+    childCount: 3,
+    className,
+    paddingLeft: getTreeItemIndent(2),
+    role: TreeItem,
+    type: Div
   }, getProblemsIconVirtualDom(type), label];
   if (filterValueLength) {
     const before = message.slice(0, messageMatchIndex);
@@ -2015,37 +2511,38 @@ const getProblemVirtualDom = problem => {
     const after = message.slice(messageMatchIndex + filterValueLength);
     label.childCount += 2;
     dom.push(text(before), {
-      type: VirtualDomElements.Div,
+      childCount: 1,
       className: Highlight,
-      childCount: 1
+      type: Div
     }, text(middle), text(after));
   } else {
     dom.push(text(message));
   }
   dom.push({
-    type: VirtualDomElements.Span,
+    childCount: 2,
     className: ProblemAt,
-    childCount: 2
+    type: Span
   }, text(getProblemSourceDetail(source, code)), text(lineColumn));
   return dom;
 };
 
 const getProblemsListVirtualDom = problems => {
   const dom = [{
-    type: VirtualDomElements.Div,
-    className: ProblemsList,
+    ariaLabel: 'Problems Tree',
+    // TODO use i18n string
     childCount: problems.length,
-    role: AriaRoles.Tree,
-    ariaLabel: 'Problems Tree' // TODO use i18n string
+    className: ProblemsList,
+    role: Tree,
+    type: Div
   }, ...problems.flatMap(getProblemVirtualDom)];
   return dom;
 };
 
 const getProblemsNoProblemsFoundVirtualDom = () => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: Message,
-    childCount: 1
+    type: Div
   }, text(noProblemsDetected())];
 };
 
@@ -2058,11 +2555,11 @@ const getClassName = isEven => {
 const getProblemsTableRowVirtualDom = problem => {
   const {
     code,
-    source,
-    uri,
-    message,
     isEven,
-    type
+    message,
+    source,
+    type,
+    uri
   } = problem;
   // TODO problems are grouped by uri, depending
   // on which renderer is used the data needs to look different
@@ -2070,38 +2567,38 @@ const getProblemsTableRowVirtualDom = problem => {
     return [];
   }
   const dom = [{
-    type: VirtualDomElements.Div,
+    childCount: 5,
     className: getClassName(isEven),
-    childCount: 5
+    type: Div
   }, {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, getProblemsIconVirtualDom(type), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(getProblemSourceDetail(source, code)), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(message), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(uri), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(source)];
   return dom;
 };
 
 const getProblemsTableBodyVirtualDom = problems => {
   const dom = [{
-    type: VirtualDomElements.Div,
+    childCount: problems.length,
     className: ProblemsTableBody,
-    childCount: problems.length
+    type: Div
   }, ...problems.flatMap(getProblemsTableRowVirtualDom)];
   return dom;
 };
@@ -2112,42 +2609,42 @@ const getProblemsTableHeaderVirtualDom = () => {
   const textMessage = message();
   const textFile = file();
   const dom = [{
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableHeader,
-    childCount: 1
+    type: Div
   }, {
-    type: VirtualDomElements.Div,
+    childCount: 5,
     className: ProblemsTableRow,
-    childCount: 5
+    type: Div
   }, {
-    type: VirtualDomElements.Div,
+    childCount: 0,
     className: ProblemsTableRowItem,
-    childCount: 0
+    type: Div
   }, {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(textCode), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(textMessage), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(textFile), {
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: ProblemsTableRowItem,
-    childCount: 1
+    type: Div
   }, text(textSource)];
   return dom;
 };
 
 const getProblemsTableVirtualDom = problems => {
   const dom = [{
-    type: VirtualDomElements.Div,
+    childCount: 2,
     className: ProblemsTable,
-    childCount: 2
+    type: Div
   }, ...getProblemsTableHeaderVirtualDom(), ...getProblemsTableBodyVirtualDom(problems)];
   return dom;
 };
@@ -2155,9 +2652,9 @@ const getProblemsTableVirtualDom = problems => {
 const getProblemsVirtualDom$1 = (viewMode, problems, filterValue, message) => {
   if (problems.length === 0 && message) {
     return [{
-      type: VirtualDomElements.Div,
+      childCount: 1,
       className: Message,
-      childCount: 1
+      type: Div
     }, text(message)];
   }
   if (problems.length === 0 && filterValue) {
@@ -2176,19 +2673,19 @@ const getProblemsVirtualDom = (viewMode, problems, filterValue, isSmall, message
   // TODO avoid mutation
   const dom = [];
   dom.push({
-    type: VirtualDomElements.Div,
+    childCount: 1,
     className: mergeClassNames(Viewlet, Problems),
-    tabIndex: 0,
-    onPointerDown: HandlePointerDown,
-    onContextMenu: HandleContextMenu,
     onBlur: HandleBlur,
-    childCount: 1
+    onContextMenu: HandleContextMenu,
+    onPointerDown: HandlePointerDown,
+    tabIndex: 0,
+    type: Div
   });
   if (isSmall) {
     dom[0].childCount++;
     dom.push(...getProblemsFilterVirtualDom({
-      command: HandleFilterInput,
       badgeText: '',
+      command: HandleFilterInput,
       placeholder: filter()}));
   }
   dom.push(...getProblemsVirtualDom$1(viewMode, problems, filterValue, message));
@@ -2226,11 +2723,11 @@ const filterProblems = (problems, collapsedUris, filterValue) => {
     }
     filtered.push({
       ...problem,
-      uriMatchIndex,
-      sourceMatchIndex,
-      messageMatchIndex,
+      isCollapsed,
       listItemType: getListItemType(problem.listItemType, isCollapsed),
-      isCollapsed
+      messageMatchIndex,
+      sourceMatchIndex,
+      uriMatchIndex
     });
   }
   return filtered;
@@ -2258,10 +2755,10 @@ const getVisibleProblems = (problems, collapsedUris, focusedIndex, filterValue)
     const problem = filtered[i];
     visibleItems.push({
       ...problem,
-      isEven: i % 2 === 0,
-      isActive: i === focusedIndex,
+      filterValueLength,
       icon: getIcon(problem.uri),
-      filterValueLength
+      isActive: i === focusedIndex,
+      isEven: i % 2 === 0
     });
   }
   return visibleItems;
@@ -2269,14 +2766,14 @@ const getVisibleProblems = (problems, collapsedUris, focusedIndex, filterValue)
 
 const renderItems = (oldState, newState) => {
   const {
-    problems,
-    width,
-    smallWidthBreakPoint,
     collapsedUris,
+    filterValue,
     focusedIndex,
+    message,
+    problems,
+    smallWidthBreakPoint,
     viewMode,
-    filterValue,
-    message
+    width
   } = newState;
   const visible = getVisibleProblems(problems, collapsedUris, focusedIndex, filterValue);
   const isSmall = width <= smallWidthBreakPoint;
@@ -2286,10 +2783,10 @@ const renderItems = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderItems:
-      return renderItems;
     case RenderFilterValue:
       return renderFilterValue;
+    case RenderItems:
+      return renderItems;
     default:
       throw new Error('unknown renderer');
   }
@@ -2306,8 +2803,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   set$1(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
@@ -2327,23 +2824,23 @@ const getActionVirtualDom = action => {
 
 const getActionsVirtualDom = actions => {
   return [{
-    type: VirtualDomElements.Div,
+    childCount: actions.length,
     className: Actions,
-    role: AriaRoles.ToolBar,
-    childCount: actions.length
+    role: ToolBar,
+    type: Div
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
 const getActions = state => {
   const {
-    problems,
-    width,
     collapsedUris,
-    focusedIndex,
-    smallWidthBreakPoint,
     filterValue,
+    focusedIndex,
     inputSource,
-    viewMode
+    problems,
+    smallWidthBreakPoint,
+    viewMode,
+    width
   } = state;
   const visibleCount = getVisibleProblems(problems, collapsedUris, focusedIndex, filterValue).length;
   const problemsCount = problems.length;
@@ -2351,32 +2848,32 @@ const getActions = state => {
   const actions = [];
   if (!isSmall) {
     actions.push({
-      type: ProblemsFilter,
-      id: 'Filter',
-      command: HandleFilterInput,
       badgeText: visibleCount === problemsCount ? '' : showingOf(visibleCount, problemsCount),
+      command: HandleFilterInput,
+      id: 'Filter',
       placeholder: filter(),
+      type: ProblemsFilter,
       value: inputSource === Script ? filterValue : ''
     });
   }
   if (viewMode === Table) {
     actions.push({
-      type: Button,
-      id: viewAsList$1(),
       command: 'viewAsList',
-      icon: ListTree
+      icon: ListTree,
+      id: viewAsList$1(),
+      type: Button
     });
   } else {
     actions.push({
-      type: Button,
-      id: collapseAll(),
       command: 'collapseAll',
-      icon: CollapseAll
+      icon: CollapseAll,
+      id: collapseAll(),
+      type: Button
     }, {
-      type: Button,
-      id: viewAsTable$1(),
       command: 'viewAsTable',
-      icon: ListFlat
+      icon: ListFlat,
+      id: viewAsTable$1(),
+      type: Button
     });
   }
   return actions;
@@ -2421,14 +2918,14 @@ const resize = (state, dimensions) => {
 
 const saveState = state => {
   const {
-    viewMode,
+    collapsedUris,
     filterValue,
-    collapsedUris
+    viewMode
   } = state;
   return {
-    viewMode,
+    collapsedUris,
     filterValue,
-    collapsedUris
+    viewMode
   };
 };
 
@@ -2456,8 +2953,8 @@ const commandMap = {
   'Problems.handleArrowLeft': wrapCommand(handleArrowLeft),
   'Problems.handleArrowRight': wrapCommand(handleArrowRight),
   'Problems.handleClickAt': wrapCommand(handleClickAt),
-  'Problems.handleContextMenu': wrapCommand(handleContextMenu),
   'Problems.handleClickButton': wrapCommand(handleClickButton),
+  'Problems.handleContextMenu': wrapCommand(handleContextMenu),
   'Problems.handleFilterInput': wrapCommand(handleFilterInput),
   'Problems.handleIconThemeChange': wrapCommand(handleIconThemeChange),
   'Problems.initialize': initialize,