@lvce-editor/server 0.0.19 → 0.0.22

package/static/{8db9fb4 → 09bf9c7}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -60,8 +60,9 @@ const MODULE_LISTENER = 73;
 const MODULE_VIEWLET_SEARCH = 74;
 const MODULE_VIEWLET_EDITOR_COMPLETION = 75;
 const MODULE_VIEWLET_Locations = 76;
+const MODULE_VIEWLET_PROBLEMS = 77;
 
-const state$F = {
+const state$C = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
 };
@@ -186,6 +187,8 @@ const loadModule = (moduleId) => {
       return Promise.resolve().then(function () { return ViewletEditorCompletion_ipc; })
     case MODULE_VIEWLET_Locations:
       return Promise.resolve().then(function () { return ViewletLocations_ipc; })
+    case MODULE_VIEWLET_PROBLEMS:
+      return Promise.resolve().then(function () { return ViewletProblems_ipc; })
     default:
       throw new Error(`unknown module "${moduleId}"`)
   }
@@ -196,11 +199,11 @@ const initializeModule = (module) => {
 };
 
 const getOrLoadModule = (moduleId) => {
-  if (!state$F.pendingModules[moduleId]) {
+  if (!state$C.pendingModules[moduleId]) {
     const importPromise = loadModule(moduleId);
-    state$F.pendingModules[moduleId] = importPromise.then(initializeModule);
+    state$C.pendingModules[moduleId] = importPromise.then(initializeModule);
   }
-  return state$F.pendingModules[moduleId]
+  return state$C.pendingModules[moduleId]
 };
 
 const getModuleId = (commandId) => {
@@ -739,6 +742,17 @@ const getModuleId = (commandId) => {
     case 7409:
     case 7410:
       return MODULE_MENU
+    case 7550:
+    case 7551:
+    case 7552:
+    case 7553:
+    case 7554:
+    case 7555:
+    case 7556:
+    case 7557:
+    case 7558:
+    case 7559:
+      return MODULE_VIEWLET_PROBLEMS
     case 7633:
     case 7634:
     case 7635:
@@ -880,20 +894,20 @@ const getModuleId = (commandId) => {
 const loadCommand = (command) => getOrLoadModule(getModuleId(command));
 
 const register$2 = (commandId, listener) => {
-  state$F.commands[commandId] = listener;
+  state$C.commands[commandId] = listener;
 };
 
 const hasThrown = new Set();
 
 const execute$1 = (command, ...args) => {
-  if (command in state$F.commands) {
-    return state$F.commands[command](...args)
+  if (command in state$C.commands) {
+    return state$C.commands[command](...args)
   }
   return (
     loadCommand(command)
       // TODO can skip then block in prod (only to prevent endless loop in dev)
       .then(() => {
-        if (!(command in state$F.commands)) {
+        if (!(command in state$C.commands)) {
           if (hasThrown.has(command)) {
             return
           }
@@ -905,37 +919,37 @@ const execute$1 = (command, ...args) => {
   )
 };
 
-const state$E = {
+const state$B = {
   callbacks: Object.create(null),
   onceListeners: new Set(),
   id: 2,
 };
 
 const register$1 = (resolve, reject) => {
-  state$E.callbacks[++state$E.id] = {
+  state$B.callbacks[++state$B.id] = {
     resolve,
     reject,
   };
-  return state$E.id
+  return state$B.id
 };
 
 // TODO merge resolve and resolveEmpty
 const resolve = (id, args) => {
-  if (!(id in state$E.callbacks)) {
+  if (!(id in state$B.callbacks)) {
     console.log(args);
     console.warn(`callback ${id} may already be disposed`);
     return
   }
-  state$E.callbacks[id].resolve(args);
-  delete state$E.callbacks[id];
+  state$B.callbacks[id].resolve(args);
+  delete state$B.callbacks[id];
 };
 
 const reject = (id, error) => {
-  if (!(id in state$E.callbacks)) {
+  if (!(id in state$B.callbacks)) {
     console.warn(`callback ${id} may already be disposed`);
     return
   }
-  state$E.callbacks[id].reject(error);
+  state$B.callbacks[id].reject(error);
 };
 
 const create$u = (url, baton) => {
@@ -1025,16 +1039,16 @@ const preparePrettyError = (rawError) => {
 };
 
 // TODO state is actually not needed here, only for testing because jest doesn't support mocking esm
-const state$D = {
+const state$A = {
   pendingMessages: [],
   send(message) {
-    state$D.pendingMessages.push(message);
+    state$A.pendingMessages.push(message);
   },
   async receive(message) {
     if (message.method) {
       const result = await execute$1(message.method, ...message.params);
       if (message.id) {
-        state$D.send({
+        state$A.send({
           jsonrpc: '2.0',
           id: message.id,
           result,
@@ -1051,21 +1065,21 @@ const state$D = {
 };
 
 const listen$1 = () => {
-  console.assert(state$D.pendingMessages.length === 0);
+  console.assert(state$A.pendingMessages.length === 0);
   {
     // TODO replace this during build
     const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
     const wsUrl = `${wsProtocol}//${location.host}`;
-    create$u(wsUrl, state$D);
+    create$u(wsUrl, state$A);
   }
 };
 
 const send$2 = (method, ...params) => {
-  send$3(state$D, method, ...params);
+  send$3(state$A, method, ...params);
 };
 
 const invoke$2 = async (method, ...params) => {
-  const responseMessage = await invoke$3(state$D, method, ...params);
+  const responseMessage = await invoke$3(state$A, method, ...params);
   if (responseMessage.error) {
     const prettyError = preparePrettyError(responseMessage.error);
     throw prettyError
@@ -1081,7 +1095,7 @@ const invoke$2 = async (method, ...params) => {
 
 // TODO treeshake this function out when targeting electron
 
-const state$C = {
+const state$z = {
   cachedIsMobileOrTablet: undefined,
   getPlatform() {
     // @ts-ignore
@@ -1094,7 +1108,7 @@ const state$C = {
     // @ts-ignore
     {
       // @ts-ignore
-      return '/8db9fb4'
+      return '/09bf9c7'
     }
   },
   isMobileOrTablet() {
@@ -1182,53 +1196,53 @@ const state$C = {
 };
 
 const isMobileOrTablet = () => {
-  if (state$C.cachedIsMobileOrTablet === undefined) {
-    state$C.cachedIsMobileOrTablet = state$C.isMobileOrTablet();
+  if (state$z.cachedIsMobileOrTablet === undefined) {
+    state$z.cachedIsMobileOrTablet = state$z.isMobileOrTablet();
   }
-  return state$C.cachedIsMobileOrTablet
+  return state$z.cachedIsMobileOrTablet
 };
 
 const getExtensionsPath = () => {
-  return state$C.getExtensionsPath()
+  return state$z.getExtensionsPath()
 };
 
 const getCachedExtensionsPath = () => {
-  return state$C.getCachedExtensionsPath()
+  return state$z.getCachedExtensionsPath()
 };
 
 const getMarketPlaceUrl = () => {
-  return state$C.getMarketPlaceUrl()
+  return state$z.getMarketPlaceUrl()
 };
 
 const getLogsDir = () => {
-  return state$C.getLogsDir()
+  return state$z.getLogsDir()
 };
 
 const getUserSettingsPath = () => {
-  return state$C.getUserSettingsPath()
+  return state$z.getUserSettingsPath()
 };
 
 /**
  * @returns {'electron'|'remote'|'web'|'test'}
  */
 const getPlatform = () => {
-  return state$C.getPlatform()
+  return state$z.getPlatform()
 };
 
 const getAssetDir = () => {
-  return state$C.getAssetDir()
+  return state$z.getAssetDir()
 };
 
 const getRecentlyOpenedPath = () => {
-  return state$C.getRecentlyOpenedPath()
+  return state$z.getRecentlyOpenedPath()
 };
 
 const getConfigPath = () => {
-  return state$C.getConfigPath()
+  return state$z.getConfigPath()
 };
 
 const getCachePath = () => {
-  return state$C.getCachePath()
+  return state$z.getCachePath()
 };
 
 const copy$2 = (protocol, source, target) => {
@@ -1320,27 +1334,27 @@ var FileSystemDisk = {
 // pros
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
-const state$B = {
+const state$y = {
   listenerMap: Object.create(null),
 };
 
 const emitEvent = async (event, ...args) => {
-  const listeners = state$B.listenerMap[event] || [];
+  const listeners = state$y.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 
 const addListener = (event, fn) => {
-  state$B.listenerMap[event] ||= [];
-  if (state$B.listenerMap[event].includes(fn)) {
+  state$y.listenerMap[event] ||= [];
+  if (state$y.listenerMap[event].includes(fn)) {
     return
   }
-  state$B.listenerMap[event].push(fn);
+  state$y.listenerMap[event].push(fn);
 };
 
 const removeListener$1 = (event, fn) => {
-  const listeners = state$B.listenerMap[event];
+  const listeners = state$y.listenerMap[event];
   if (!listeners) {
     console.info(
       `[info] listener for event ${event} is not registered and cannot be unregistered`
@@ -1350,101 +1364,105 @@ const removeListener$1 = (event, fn) => {
   const index = listeners.indexOf(fn);
   listeners.splice(index, 1);
   if (listeners.length === 0) {
-    delete state$B.listenerMap[event];
+    delete state$y.listenerMap[event];
   }
 };
 
 /* istanbul ignore file */
 
-const state$A = {
+const state$x = {
   pendingMessages: [],
   /**
-   *
-   * @param {any} message
-   * @returns {void}
+   * @type {any}
    */
-  send(message) {
-    throw new Error('not implemented')
-  },
-  // TODO renderer process should only be able send events
-  // should not be able to invoke callbacks
-  handleMessage(message) {
-    switch (message[0]) {
-      case 67330:
-      case 67331:
-        resolve(message[1], message[2]);
-        break
-      default:
-        execute$1(...message);
-        break
-    }
-  },
-  sendAndTransfer(message, transferables) {},
+  ipc: undefined,
 };
 
 const handleMessageFromRendererProcess = (event) => {
-  state$A.handleMessage(event.data);
+  const message = event.data;
+  switch (message[0]) {
+    case 67330:
+    case 67331:
+      resolve(message[1], message[2]);
+      break
+    default:
+      execute$1(...message);
+      break
+  }
 };
 
 const listenModuleWorker = () => {
   onmessage = handleMessageFromRendererProcess;
-  state$A.send = (message) => postMessage(message);
-  state$A.sendAndTransfer = (message, transferables) => {
-    postMessage(message, transferables);
-  };
+  return {
+    send(message) {
+      postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      postMessage(message, transferables);
+    },
+  }
 };
 
 const listenMessagePort = () => {
   const messageChannel = new MessageChannel();
   messageChannel.port1.onmessage = handleMessageFromRendererProcess;
-  state$A.send = (message) => {
-    messageChannel.port1.postMessage(message);
-  };
-  state$A.sendAndTransfer = (message, transferables) => {
-    messageChannel.port1.postMessage(message, transferables);
-  };
   globalThis.acceptPort(messageChannel.port2);
+  return {
+    send(message) {
+      messageChannel.port1.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      messageChannel.port1.postMessage(message, transferables);
+    },
+  }
 };
 
 const listenReferencePort = () => {
   const referencePort = {
     onmessage(message, transferables) {},
-    postMessage: state$A.handleMessage,
+    postMessage: state$x.handleMessage,
   };
   // TODO get rid of extra data wrapper
-  state$A.send = (message) => {
-    referencePort.onmessage({ data: message });
-  };
-  state$A.sendAndTransfer = ({ data: message }, transferables) => {
-    referencePort.onmessage(message, transferables);
-  };
   globalThis.acceptReferencePort(referencePort);
+  return {
+    send(message) {
+      referencePort.onmessage({ data: message });
+    },
+    sendAndTransfer({ data: message }, transferables) {
+      referencePort.onmessage(message, transferables);
+    },
+  }
 };
 
-const listen = () => {
-  console.assert(state$A.pendingMessages.length === 0);
+const getIpc = () => {
   // TODO tree-shake out if/else in prod
   if (globalThis.acceptPort) {
-    listenMessagePort();
+    return listenMessagePort()
   } else if (globalThis.acceptReferencePort) {
-    listenReferencePort();
+    return listenReferencePort()
   } else {
-    listenModuleWorker();
+    return listenModuleWorker()
   }
 };
 
+const listen = () => {
+  console.assert(state$x.pendingMessages.length === 0);
+  const ipc = getIpc();
+  state$x.ipc = ipc;
+};
+
 /**
  * @deprecated use invoke instead
  * @param {*} message
  */
 const send$1 = (message) => {
-  state$A.send(message);
+  state$x.ipc.send(message);
 };
 
 const invoke$1 = async (method, ...params) => {
   const responseMessage = await new Promise((resolve, reject) => {
     const callbackId = register$1(resolve, reject);
-    state$A.send([
+    state$x.ipc.send([
       /* RendererWorker.invoke */ 909090,
       /* callbackId */ callbackId,
       /* method */ method,
@@ -1479,38 +1497,44 @@ const reload = async () => {
   }
   if (getPlatform() === 'electron') {
     // TODO should use invoke here
-    send$2(/* Electron.windowReload */ 'Electron.windowReload');
+    await invoke$2(
+      /* Electron.windowReload */ 'Electron.windowReload'
+    );
   }
 };
 
-const minimize = () => {
+const minimize = async () => {
   if (getPlatform() === 'web') {
     return
   }
-  send$2(/* Electron.windowMinimize */ 'Electron.windowMinimize');
+  await invoke$2(
+    /* Electron.windowMinimize */ 'Electron.windowMinimize'
+  );
 };
 
-const maximize = () => {
+const maximize = async () => {
   if (getPlatform() === 'web') {
     return
   }
-  send$2(/* Electron.windowMaximize */ 'Electron.windowMaximize');
+  await invoke$2(
+    /* Electron.windowMaximize */ 'Electron.windowMaximize'
+  );
 };
 
-const unmaximize = () => {
+const unmaximize = async () => {
   if (getPlatform() === 'web') {
     return
   }
-  send$2(
+  await invoke$2(
     /* Electron.windowUnmaximize */ 'Electron.windowUnMaximize'
   );
 };
 
-const close$4 = () => {
+const close$4 = async () => {
   if (getPlatform() === 'web') {
     return
   }
-  send$2(/* Electron.windowClose */ 'Electron.windowClose');
+  await invoke$2(/* Electron.windowClose */ 'Electron.windowClose');
 };
 
 const exit = async () => {
@@ -1530,7 +1554,7 @@ const openNew = async () => {
   );
 };
 
-const state$z = {
+const state$w = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -1543,14 +1567,14 @@ const state$z = {
  */
 const setPath = async (path) => {
   // TODO not in electron
-  state$z.workspacePath = path;
+  state$w.workspacePath = path;
   await onWorkspaceChange();
 };
 
 const setUri = async (uri) => {
   const path = uri.slice('file://'.length);
-  state$z.workspacePath = path;
-  state$z.workspaceUri = uri;
+  state$w.workspacePath = path;
+  state$w.workspaceUri = uri;
   await onWorkspaceChange();
 };
 
@@ -1624,7 +1648,7 @@ const getResolvedRoot = async () => {
 };
 
 const getTitle = (workspacePath) => {
-  const pathSeparator = state$z.pathSeparator;
+  const pathSeparator = state$w.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1)
 };
 
@@ -1636,28 +1660,28 @@ const getPathName = (workspacePath) => {
 };
 
 const onWorkspaceChange = async () => {
-  const title = getTitle(state$z.workspacePath);
+  const title = getTitle(state$w.workspacePath);
   await setTitle(title);
   if (getPlatform() === 'web' || getPlatform() === 'remote') {
-    const pathName = getPathName(state$z.workspacePath);
+    const pathName = getPathName(state$w.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$z.workspacePath);
+  await emitEvent('workspace.change', state$w.workspacePath);
 };
 
 const hydrate$b = async () => {
   const resolvedRoot = await getResolvedRoot();
   // TODO why is this if statement here?
-  if (state$z.homeDir !== resolvedRoot.homeDir) {
-    state$z.homeDir = resolvedRoot.homeDir;
+  if (state$w.homeDir !== resolvedRoot.homeDir) {
+    state$w.homeDir = resolvedRoot.homeDir;
   }
   // TODO how to check that path from renderer process is valid?
   // TODO also need to check whether it is a folder or file
-  state$z.workspacePath = resolvedRoot.path;
-  state$z.homeDir = resolvedRoot.homeDir;
-  state$z.pathSeparator = resolvedRoot.pathSeparator;
-  state$z.workspaceUri = resolvedRoot.uri;
-  state$z.source = resolvedRoot.source;
+  state$w.workspacePath = resolvedRoot.path;
+  state$w.homeDir = resolvedRoot.homeDir;
+  state$w.pathSeparator = resolvedRoot.pathSeparator;
+  state$w.workspaceUri = resolvedRoot.uri;
+  state$w.source = resolvedRoot.source;
   await onWorkspaceChange();
 };
 
@@ -1666,30 +1690,30 @@ const hydrate$b = async () => {
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$z.workspacePath
+  return state$w.workspacePath
 };
 
 const getHomeDir = () => {
-  return state$z.homeDir
+  return state$w.homeDir
 };
 
 // TODO this should be in FileSystem module
 const pathBaseName = (path) => {
-  const pathSeparator = state$z.pathSeparator;
+  const pathSeparator = state$w.pathSeparator;
   return path.slice(path.lastIndexOf(pathSeparator) + 1)
 };
 
 // TODO this should be in FileSystem module
 const pathDirName = (path) => {
-  const pathSeparator = state$z.pathSeparator;
+  const pathSeparator = state$w.pathSeparator;
   return path.slice(0, path.lastIndexOf(pathSeparator))
 };
 
 const getAbsolutePath = (relativePath) => {
   if (relativePath.startsWith('./')) {
-    return `${state$z.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
+    return `${state$w.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
   }
-  return `${state$z.workspacePath}/${relativePath}` // TODO support windows paths
+  return `${state$w.workspacePath}/${relativePath}` // TODO support windows paths
 };
 
 // TODO treeshake out this whole module in production
@@ -1906,7 +1930,7 @@ const readGitHubDirectory = (owner, repo, ref, path) => {
 
 // based on https://github.com/conwnet/github1s/blob/master/extensions/github1s/src/interfaces/github-api-rest.ts
 
-const state$y = {
+const state$v = {
   cache: Object.create(null),
 };
 
@@ -1965,7 +1989,7 @@ const readDirWithFileTypes$4 = async (protocol, path) => {
     'HEAD',
     relativePath
   );
-  state$y.cache[relativeUri] = githubDirents;
+  state$v.cache[relativeUri] = githubDirents;
   const dirents = toDirents(githubDirents);
   return dirents
 };
@@ -1981,7 +2005,7 @@ const getPathSeparator$5 = () => {
 
 var FileSystemGitHub = {
   __proto__: null,
-  state: state$y,
+  state: state$v,
   readFile: readFile$4,
   readDirWithFileTypes: readDirWithFileTypes$4,
   getBlobUrl: getBlobUrl$2,
@@ -1993,7 +2017,7 @@ const STATUS_LOADING = 1;
 const STATUS_RUNNING = 2;
 const STATUS_ERROR = 3;
 
-const state$x = {
+const state$u = {
   status: STATUS_OFF, // TODO should be an enum state
   /**
    * @type {any[]}
@@ -2008,18 +2032,18 @@ const state$x = {
 };
 
 const startExtensionHost = async () => {
-  switch (state$x.status) {
+  switch (state$u.status) {
     case STATUS_LOADING:
     case STATUS_RUNNING:
       throw new Error('extension host is already starting')
   }
-  state$x.status = STATUS_LOADING;
+  state$u.status = STATUS_LOADING;
   await invoke$2(/* ExtensionHost.start */ 'ExtensionHost.start');
-  state$x.status = STATUS_RUNNING;
-  for (const readyCallback of state$x.readyCallbacks) {
+  state$u.status = STATUS_RUNNING;
+  for (const readyCallback of state$u.readyCallbacks) {
     readyCallback();
   }
-  state$x.readyCallbacks = [];
+  state$u.readyCallbacks = [];
   // TODO handle error
   await invoke$2(
     /* ExtensionHost.setWorkspaceRoot */ 'ExtensionHost.setWorkspaceRoot',
@@ -2038,7 +2062,7 @@ var ExtensionHostCore = {
   STATUS_LOADING: STATUS_LOADING,
   STATUS_RUNNING: STATUS_RUNNING,
   STATUS_ERROR: STATUS_ERROR,
-  state: state$x,
+  state: state$u,
   startExtensionHost: startExtensionHost,
   invoke: invoke
 };
@@ -2089,7 +2113,7 @@ const getLanguageConfiguration$1 = async (languageId) => {
 
 // TODO merge all of this with extension host languages module
 
-const state$w = {
+const state$t = {
   languages: [],
   loadState: false,
   isHydrating: false,
@@ -2098,7 +2122,7 @@ const state$w = {
 const getLanguageId = (path) => {
   string(path);
   const extension = path.slice(path.lastIndexOf('.'));
-  for (const language of state$w.languages) {
+  for (const language of state$t.languages) {
     if (language.extensions && language.extensions.includes(extension)) {
       return language.id
     }
@@ -2113,20 +2137,20 @@ const getLanguages = () => {
 };
 
 const hydrate$a = async () => {
-  state$w.isHydrating = true;
+  state$t.isHydrating = true;
   // TODO handle error
   // TODO main parts should have nothing todo with shared process -> only sub components
-  state$w.languages = await getLanguages();
+  state$t.languages = await getLanguages();
   await emitEvent('languages.changed');
-  state$w.loaded = true;
+  state$t.loaded = true;
 };
 
 const hasLoaded = () => {
-  return state$w.loaded
+  return state$t.loaded
 };
 
 const waitForLoad = async () => {
-  if (state$w.isHydrating) {
+  if (state$t.isHydrating) {
     await new Promise((resolve) => {
       const handleLanguageChange = (editor, languageId) => {
         resolve();
@@ -2153,7 +2177,7 @@ const getLanguageConfiguration = async (editor) => {
   return languageConfiguration
 };
 
-const state$v = {
+const state$s = {
   extensionPromiseCache: Object.create(null),
 };
 
@@ -2169,27 +2193,27 @@ const activateExtension = async (extension) => {
   if (!extension.main) {
     return
   }
-  if (!state$v.extensionPromiseCache[extension.id]) {
+  if (!state$s.extensionPromiseCache[extension.id]) {
     const activatableExtension = toActivatableExtension(extension);
-    state$v.extensionPromiseCache[extension.id] = invoke$2(
+    state$s.extensionPromiseCache[extension.id] = invoke$2(
       /* ExtensionHost.enableExtension */ 'ExtensionHost.enableExtension',
       /* activatableExtension */ activatableExtension
     );
   }
   // TODO what if activation fails or extension is restarted ot extension host is restarted?
-  return state$v.extensionPromiseCache[extension.id]
+  return state$s.extensionPromiseCache[extension.id]
 };
 
 const ensureExtensionHostIsStarted = async () => {
-  switch (state$x.status) {
+  switch (state$u.status) {
     case STATUS_OFF:
-      state$x.extensionHostPromise =
+      state$u.extensionHostPromise =
         startExtensionHost();
-      await state$x.extensionHostPromise;
+      await state$u.extensionHostPromise;
       await activateByEvent('onStartupFinished');
       break
     case STATUS_LOADING:
-      await state$x.extensionHostPromise;
+      await state$u.extensionHostPromise;
       break
     case STATUS_RUNNING:
       break
@@ -2544,7 +2568,7 @@ files['/sample-folder/a.txt'] = '';
 files['/sample-folder/b.txt'] = '';
 files['/sample-folder/c.txt'] = '';
 
-const state$u = {
+const state$r = {
   watchers: Object.create(null),
   saveListeners: [],
 };
@@ -2636,7 +2660,7 @@ const getPathSeparator$3 = () => {
 
 var FileSystemWeb = {
   __proto__: null,
-  state: state$u,
+  state: state$r,
   readFile: readFile$2,
   remove: remove$2,
   rename: rename$3,
@@ -2721,19 +2745,19 @@ const getProtocol = (uri) => {
   return 'file'
 };
 
-const state$t = {
+const state$q = {
   fileSystems: Object.create(null),
 };
 
 // TODO extension host should be able to register arbitrary protocols (except app, http, https, file, )
-state$t.fileSystems['memfs'] = FileSystemExtensionHost;
-state$t.fileSystems['app'] = FileSystemApp;
-state$t.fileSystems['github'] = FileSystemGitHub;
-state$t.fileSystems['web'] = FileSystemWeb;
-state$t.fileSystems['data'] = FileSystemData;
+state$q.fileSystems['memfs'] = FileSystemExtensionHost;
+state$q.fileSystems['app'] = FileSystemApp;
+state$q.fileSystems['github'] = FileSystemGitHub;
+state$q.fileSystems['web'] = FileSystemWeb;
+state$q.fileSystems['data'] = FileSystemData;
 
 const getFileSystem = (protocol) => {
-  return state$t.fileSystems[protocol] || FileSystemDisk
+  return state$q.fileSystems[protocol] || FileSystemDisk
 };
 
 const readFile = (uri) => {
@@ -2804,7 +2828,7 @@ const parse = (content) => {
   }
 };
 
-const state$s = Object.create(null);
+const state$p = Object.create(null);
 
 const openSettingsJson = async () => {
   await execute$1(/* Main.openUri */ 97, /* uri */ 'app://settings.json');
@@ -2845,7 +2869,7 @@ const hydrate$9 = async () => {
   // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
   // TODO probably not all preferences need to be kept in memory
   const preferences = await getPreferences();
-  Object.assign(state$s, preferences);
+  Object.assign(state$p, preferences);
 
   const styles = [];
   const fontSize = preferences['editor.fontSize'];
@@ -2875,13 +2899,13 @@ ${styles.join('\n')}
 };
 
 const get = (key) => {
-  return state$s[key]
+  return state$p[key]
 };
 
 const set = async (key, value) => {
-  state$s[key] = value;
+  state$p[key] = value;
   if (getPlatform() === 'web') {
-    const preferences = { ...state$s, [key]: value };
+    const preferences = { ...state$p, [key]: value };
     await execute$1(
       /* LocalStorage.setJson */ 6901,
       /* key */ 'preferences',
@@ -2889,7 +2913,7 @@ const set = async (key, value) => {
     );
     return
   }
-  const content = stringify(state$s);
+  const content = stringify(state$p);
   await writeFile(`app://settings.json`, content);
 };
 
@@ -2996,7 +3020,7 @@ const hydrate$8 = async () => {
   }
 };
 
-const state$r = {
+const state$o = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -3023,7 +3047,7 @@ const getExtension = (file) => {
 };
 
 const getFileIcon = (file) => {
-  const iconTheme = state$r.iconTheme;
+  const iconTheme = state$o.iconTheme;
   if (!iconTheme) {
     return ''
   }
@@ -3045,7 +3069,7 @@ const getFileIcon = (file) => {
 };
 
 const getFolderIcon = (folder) => {
-  const iconTheme = state$r.iconTheme;
+  const iconTheme = state$o.iconTheme;
   if (!iconTheme || !iconTheme.folderNames) {
     return ''
   }
@@ -3057,7 +3081,7 @@ const getFolderIcon = (folder) => {
 };
 
 const getFolderIconExpanded = (folder) => {
-  const iconTheme = state$r.iconTheme;
+  const iconTheme = state$o.iconTheme;
   if (!iconTheme) {
     return ''
   }
@@ -3129,8 +3153,8 @@ const hydrate$7 = async () => {
 
     const iconThemeId = get('icon-theme') || 'vscode-icons';
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$r.iconTheme = iconTheme.json;
-    state$r.extensionPath = iconTheme.extensionPath;
+    state$o.iconTheme = iconTheme.json;
+    state$o.extensionPath = iconTheme.extensionPath;
 
     const iconThemeCss = getIconThemeCss2(iconTheme);
     await invoke$1(
@@ -3202,7 +3226,7 @@ const printError = (error) => {
 };
 
 // TODO state is not needed here but because jest doesn't support mocking for esm yet this is a workaround
-const state$q = {
+const state$n = {
   async handleError(error) {
     printError(error);
     const enhancedErrorMessage = enhanceErrorMessage(error);
@@ -3223,19 +3247,19 @@ const state$q = {
 };
 
 const handleError$1 = async (error) => {
-  await state$q.handleError(error);
+  await state$n.handleError(error);
 };
 
 const showErrorDialog = async (error) => {
-  await state$q.showErrorDialog(error);
+  await state$n.showErrorDialog(error);
 };
 
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$q.seenWarnings.includes(stringified)) {
+  if (state$n.seenWarnings.includes(stringified)) {
     return
   }
-  state$q.seenWarnings.push(stringified);
+  state$n.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
@@ -3277,7 +3301,7 @@ const handleKeyBinding = async (keyBinding) => {
   }
 };
 
-const state$p = {
+const state$m = {
   instances: Object.create(null),
   modules: Object.create(null),
 };
@@ -3286,10 +3310,10 @@ const state$p = {
  * @deprecated
  */
 const send = (id, method, ...args) => {
-  const instance = state$p.instances[id];
+  const instance = state$m.instances[id];
   if (!instance) {
     console.info('instance disposed', { id, method, args });
-    console.info(state$p.instances);
+    console.info(state$m.instances);
     return
   }
   const fn$1 = instance.factory[method];
@@ -3305,7 +3329,7 @@ const dispose$p = async (id) => {
     console.warn('no instance to dispose');
     return
   }
-  const instance = state$p.instances[id];
+  const instance = state$m.instances[id];
   if (!instance) {
     console.info('instance may already be disposed');
     return
@@ -3324,8 +3348,8 @@ const dispose$p = async (id) => {
     throw new Error(`Failed to dispose viewlet ${id}: ${error}`)
   }
   instance.status = 'disposed';
-  delete state$p.instances[id];
-  delete state$p.modules[id];
+  delete state$m.instances[id];
+  delete state$m.modules[id];
   await emitEvent(`Viewlet.dispose.${id}`);
 };
 
@@ -3335,7 +3359,7 @@ const dispose$p = async (id) => {
 const wrapViewletCommand = (id, fn) => {
   const wrappedViewletCommand = async (...args) => {
     // TODO get actual focused instance
-    const activeInstance = state$p.instances[id];
+    const activeInstance = state$m.instances[id];
     if (!activeInstance) {
       console.info(`no active instance for ${id}`);
       return
@@ -3361,7 +3385,7 @@ const wrapViewletCommand = (id, fn) => {
         /* Viewlet.sendMultiple */ 3032,
         /* commands */ commands,
       ]);
-      state$p.instances[id].state = newState;
+      state$m.instances[id].state = newState;
     } else {
       return fn(activeInstance.state, ...args)
     }
@@ -3370,7 +3394,7 @@ const wrapViewletCommand = (id, fn) => {
 };
 
 const resize$c = (id, dimensions) => {
-  const instance = state$p.instances[id];
+  const instance = state$m.instances[id];
   if (!instance || !instance.factory || !instance.factory.resize) {
     console.warn('cannot resize', id);
     return []
@@ -3379,7 +3403,7 @@ const resize$c = (id, dimensions) => {
   const { newState, commands } = instance.factory.resize(oldState, dimensions);
   object(newState);
   array(commands);
-  state$p.instances[id].state = newState;
+  state$m.instances[id].state = newState;
   if (instance.factory.hasFunctionalRender) {
     return instance.factory.render(oldState, newState)
   }
@@ -3387,12 +3411,12 @@ const resize$c = (id, dimensions) => {
 };
 
 const getState = (id) => {
-  const instance = state$p.instances[id];
+  const instance = state$m.instances[id];
   return instance.state
 };
 
 const setState = (id, newState) => {
-  const instance = state$p.instances[id];
+  const instance = state$m.instances[id];
   if (instance && instance.factory && instance.factory.hasFunctionalRender) {
     const oldState = instance.state;
     const commands = instance.factory.render(oldState, newState);
@@ -3482,14 +3506,14 @@ const create$t = (
   width,
   height
 ) => {
-  console.assert(typeof getModule === 'function');
-  console.assert(typeof id === 'string');
-  console.assert(typeof parentId === 'string');
-  console.assert(typeof uri === 'string');
-  console.assert(typeof left === 'number');
-  console.assert(typeof top === 'number');
-  console.assert(typeof width === 'number');
-  console.assert(typeof height === 'number');
+  fn(getModule);
+  string(id);
+  string(parentId);
+  string(uri);
+  number(left);
+  number(top);
+  number(width);
+  number(height);
   return {
     type: 0,
     getModule,
@@ -3550,7 +3574,7 @@ const load = async (viewlet, focus = false) => {
     }
     state = VIEWLET_STATE_CONTENT_LOADED;
 
-    state$p.instances[viewlet.id] = { state: newState, factory: module };
+    state$m.instances[viewlet.id] = { state: newState, factory: module };
 
     await invoke$1(/* Viewlet.load */ 3030, /* id */ viewlet.id);
     if (viewlet.disposed) {
@@ -3626,7 +3650,7 @@ const load = async (viewlet, focus = false) => {
 
 // TODO where to force rendering of contents (need to call sidebar.openViewlet somewhere)
 
-const state$o = {
+const state$l = {
   activityBarLeft: 0,
   activityBarTop: 0,
   activityBarWidth: 48,
@@ -3659,6 +3683,7 @@ const state$o = {
   titleBarVisible: true,
   windowWidth: 0,
   windowHeight: 0,
+  sashId: '',
 };
 
 const SIDE_BAR_MIN_WIDTH = 170;
@@ -3759,13 +3784,13 @@ const getPoints = (layout, bounds) => {
 };
 
 const updateLayout = async (layout) => {
-  const points = getPoints(layout, state$o);
-  Object.assign(state$o, points);
+  const points = getPoints(layout, state$l);
+  Object.assign(state$l, points);
   invoke$1(/* Layout.update */ 1100, /* points */ points);
   await execute$1(
     /* LocalStorage.setJson */ 6901,
     /* key */ 'layout',
-    /* value */ state$o
+    /* value */ state$l
   );
 };
 
@@ -3820,10 +3845,10 @@ const getDimensions = (state, id) => {
 
 const show$5 = async (key, id) => {
   updateLayout({
-    ...state$o,
+    ...state$l,
     [key]: true,
   });
-  const dimensions = getDimensions(state$o, id);
+  const dimensions = getDimensions(state$l, id);
   const instance = create$t(
     getModule$1,
     id,
@@ -3839,14 +3864,14 @@ const show$5 = async (key, id) => {
 
 const hide$2 = async (key, id) => {
   updateLayout({
-    ...state$o,
+    ...state$l,
     [key]: false,
   });
   await dispose$p(id);
 };
 
 const toggle = async (key, id) => {
-  if (state$o[key]) {
+  if (state$l[key]) {
     await hide$2(key, id);
   } else {
     await show$5(key, id);
@@ -3885,7 +3910,7 @@ const showMain = async () => {
 };
 
 const isSideBarVisible = () => {
-  return state$o.sideBarVisible
+  return state$l.sideBarVisible
 };
 
 // TODO replace with one method in renderer process: setActivityBarVisible(true|false)
@@ -3923,47 +3948,72 @@ const getInitialLayout = async () => {
   if (cachedLayout) {
     return cachedLayout
   }
-  return state$o
+  return state$l
 };
 
 const hydrate$5 = async () => {
   const windowBounds = await getBounds();
   const initialLayout = await getInitialLayout();
   const points = getPoints(initialLayout, windowBounds);
-  Object.assign(state$o, points);
+  Object.assign(state$l, points);
   await invoke$1(/* Layout.show */ 1109, /* points */ points);
 };
 
+const handleSashPointerDown = (id) => {
+  state$l.sashId = id;
+  console.log({ id });
+};
+
 // TODO make this functional
-const handleSashSideBarMove = async (x) => {
-  const newSideBarWidth = state$o.windowWidth - state$o.activityBarWidth - x;
-  if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH / 2) {
-    state$o.sideBarVisible = false;
-    state$o.mainWidth = state$o.windowWidth - state$o.activityBarWidth;
-  } else if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH) {
-    state$o.sideBarVisible = true;
-    state$o.sideBarWidth = SIDE_BAR_MIN_WIDTH;
-    state$o.mainWidth =
-      state$o.windowWidth - state$o.activityBarWidth - SIDE_BAR_MIN_WIDTH;
-    state$o.sideBarLeft =
-      state$o.windowWidth - state$o.activityBarWidth - SIDE_BAR_MIN_WIDTH;
-  } else {
-    state$o.sideBarVisible = true;
-    state$o.mainWidth = x;
-    state$o.sideBarLeft = x;
-    state$o.sideBarWidth = newSideBarWidth;
+const handleSashPointerMove = async (x, y) => {
+  if (state$l.sashId === 'SideBar') {
+    const newSideBarWidth = state$l.windowWidth - state$l.activityBarWidth - x;
+    if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH / 2) {
+      state$l.sideBarVisible = false;
+      state$l.mainWidth = state$l.windowWidth - state$l.activityBarWidth;
+    } else if (newSideBarWidth <= SIDE_BAR_MIN_WIDTH) {
+      state$l.sideBarVisible = true;
+      state$l.sideBarWidth = SIDE_BAR_MIN_WIDTH;
+      state$l.mainWidth =
+        state$l.windowWidth - state$l.activityBarWidth - SIDE_BAR_MIN_WIDTH;
+      state$l.sideBarLeft =
+        state$l.windowWidth - state$l.activityBarWidth - SIDE_BAR_MIN_WIDTH;
+    } else {
+      state$l.sideBarVisible = true;
+      state$l.mainWidth = x;
+      state$l.sideBarLeft = x;
+      state$l.sideBarWidth = newSideBarWidth;
+    }
+  } else if (state$l.sashId === 'Panel') {
+    const newPanelHeight = state$l.windowHeight - state$l.statusBarHeight - y;
+    if (newPanelHeight < PANEL_MIN_HEIGHT / 2) {
+      state$l.panelVisible = false;
+      state$l.mainHeight =
+        state$l.windowHeight - state$l.statusBarHeight - state$l.titleBarHeight;
+    } else if (newPanelHeight <= PANEL_MIN_HEIGHT) {
+      state$l.panelVisible = true;
+      state$l.panelHeight = PANEL_MIN_HEIGHT;
+      state$l.mainHeight =
+        state$l.windowHeight - state$l.activityBarHeight - PANEL_MIN_HEIGHT;
+    } else {
+      state$l.panelVisible = true;
+      state$l.mainHeight = y - state$l.titleBarHeight;
+      state$l.panelTop = y;
+      state$l.panelHeight = state$l.windowHeight - state$l.statusBarHeight - y;
+    }
   }
-  await updateLayout(state$o);
+
+  await updateLayout(state$l);
 };
 
 // TODO a bit unnecessary to send the same layout very often, but it avoids keeping state in renderer process
 const handleResize = async (bounds) => {
-  const points = getPoints(state$o, bounds);
-  Object.assign(state$o, points);
+  const points = getPoints(state$l, bounds);
+  Object.assign(state$l, points);
   await invoke$1(/* Layout.update */ 1100, /* points */ points);
   const ids = ['Main', 'ActivityBar', 'SideBar', 'TitleBar', 'StatusBar'];
   const resizeInstance = (id) => {
-    const dimensions = getDimensions(state$o, id);
+    const dimensions = getDimensions(state$l, id);
     return resize$c(id, dimensions)
   };
   const commands = ids.flatMap(resizeInstance);
@@ -3972,11 +4022,11 @@ const handleResize = async (bounds) => {
   }
   // TODO send the whole batch at once
   for (const command of commands) {
-    send$1(command);
+    invoke$1(command);
   }
 };
 
-const state$n = {
+const state$k = {
   listenerMap: Object.create(null),
   phase: 0,
 };
@@ -4000,23 +4050,23 @@ const PHASE_FIFTEEN = 15;
 const PHASE_SIXTEEN = 16;
 
 const once = (event, listener) => {
-  if (state$n.phase >= event) {
+  if (state$k.phase >= event) {
     listener();
   } else {
     // TODO could also statically allocate listenermap at start as array[13]
-    state$n.listenerMap[event] ||= [];
-    state$n.listenerMap[event].push(listener);
+    state$k.listenerMap[event] ||= [];
+    state$k.listenerMap[event].push(listener);
   }
 };
 
 const mark$1 = (event) => {
-  const listeners = state$n.listenerMap[event] || [];
+  const listeners = state$k.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$n.phase = event;
+  state$k.phase = event;
   if (event === PHASE_TWELVE) {
-    state$n.listenerMap = Object.create(null);
+    state$k.listenerMap = Object.create(null);
   }
 };
 
@@ -4029,16 +4079,16 @@ const measure = (measureName, start, end) => {
 };
 
 const getStateToSave = () => {
-  const instances = state$p.instances;
+  const instances = state$m.instances;
   // const mainEditors = Main.state.editors
   return {
     instances,
     mainEditors: [],
     workspace: {
-      path: state$z.workspacePath,
-      homeDir: state$z.homeDir,
-      pathSeparator: state$z.pathSeparator,
-      uri: state$z.workspaceUri,
+      path: state$w.workspacePath,
+      homeDir: state$w.homeDir,
+      pathSeparator: state$w.pathSeparator,
+      uri: state$w.workspaceUri,
     },
   }
 };
@@ -4214,7 +4264,7 @@ const startup = async (config) => {
   mark$1(PHASE_SEVEN);
 
   mark('code/willLoadSideBar');
-  if (state$o.sideBarVisible) {
+  if (state$l.sideBarVisible) {
     await showSideBar();
   }
   mark('code/didLoadSideBar');
@@ -4222,7 +4272,7 @@ const startup = async (config) => {
   mark$1(PHASE_EIGHT);
 
   mark('code/willLoadPanel');
-  if (state$o.panelVisible) {
+  if (state$l.panelVisible) {
     await showPanel();
   }
   mark('code/didLoadPanel');
@@ -4230,7 +4280,7 @@ const startup = async (config) => {
   mark$1(PHASE_NINE);
 
   mark('code/willLoadActivityBar');
-  if (state$o.activityBarVisible) {
+  if (state$l.activityBarVisible) {
     await showActivityBar();
   }
   mark('code/didLoadActivityBar');
@@ -4238,7 +4288,7 @@ const startup = async (config) => {
   mark$1(PHASE_TEN);
 
   mark('code/willLoadStatusBar');
-  if (state$o.statusBarVisible) {
+  if (state$l.statusBarVisible) {
     await showStatusBar();
   }
   mark('code/didLoadStatusBar');
@@ -4257,7 +4307,7 @@ const startup = async (config) => {
   mark$1(PHASE_FOURTEEN);
 
   mark('code/willLoadTitleBar');
-  if (state$o.titleBarVisible) {
+  if (state$l.titleBarVisible) {
     await showTitleBar();
   }
   mark('code/didLoadTitleBar');
@@ -4343,12 +4393,12 @@ const main = async () => {
 
 main();
 
-const state$m = {
+const state$j = {
   notifications: [],
 };
 
 const create$s = async (type, text) => {
-  state$m.notifications.push({ type, text });
+  state$j.notifications.push({ type, text });
   await invoke$1(
     /* Notification.create */ 991,
     /* type */ type,
@@ -4357,7 +4407,7 @@ const create$s = async (type, text) => {
 };
 
 const showWithOptions = async (type, text, options) => {
-  state$m.notifications.push({ type, text, options });
+  state$j.notifications.push({ type, text, options });
   console.log({ type, text, options });
   await invoke$1(
     /* Notification.createWithOptions */ 993,
@@ -4369,7 +4419,7 @@ const showWithOptions = async (type, text, options) => {
 
 const handleClick$7 = (index) => {
   console.log('handle click');
-  const notification = state$m.notifications[0];
+  const notification = state$j.notifications[0];
   if (!notification.options) {
     throw new Error('notification has no options that can be clicked')
   }
@@ -4381,7 +4431,7 @@ const dispose$o = async (id) => {
   await invoke$1(/* Notification.dispose */ 992, /* id */ id);
 };
 
-const __initialize__$W = () => {
+const __initialize__$X = () => {
   register$2(900, create$s);
   register$2(901, dispose$o);
   register$2(902, showWithOptions);
@@ -4390,7 +4440,7 @@ const __initialize__$W = () => {
 
 var Notification_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$W
+  __initialize__: __initialize__$X
 };
 
 const ACTIVITY_BAR_ITEM_HEIGHT = 48;
@@ -4514,7 +4564,7 @@ const getActivityBarItems = () => {
 
 const loadContent$n = async (state) => {
   const activityBarItems = getActivityBarItems();
-  const sideBar = state$p.instances.SideBar;
+  const sideBar = state$m.instances.SideBar;
   const viewletId =
     sideBar && sideBar.state ? sideBar.state.currentViewletId : '';
   const selectedIndex = findIndex(activityBarItems, viewletId);
@@ -4673,7 +4723,7 @@ const handleContextMenu$2 = async (state, x, y) => {
   return state
 };
 
-const focusIndex$8 = (state, index) => {
+const focusIndex$9 = (state, index) => {
   return {
     ...state,
     focusedIndex: index,
@@ -4682,7 +4732,7 @@ const focusIndex$8 = (state, index) => {
 
 const focus$2 = (state) => {
   const indexToFocus = state.focusedIndex === -1 ? 0 : state.focusedIndex;
-  return focusIndex$8(state, indexToFocus)
+  return focusIndex$9(state, indexToFocus)
 };
 
 const focusNext$8 = (state) => {
@@ -4690,22 +4740,22 @@ const focusNext$8 = (state) => {
   if (state.focusedIndex === state.activityBarItems.length - 1) {
     return state
   }
-  return focusIndex$8(state, state.focusedIndex + 1)
+  return focusIndex$9(state, state.focusedIndex + 1)
 };
 
 const focusPrevious$8 = (state) => {
   if (state.focusedIndex === 0) {
     return state
   }
-  return focusIndex$8(state, state.focusedIndex - 1)
+  return focusIndex$9(state, state.focusedIndex - 1)
 };
 
 const focusFirst$8 = (state) => {
-  return focusIndex$8(state, 0)
+  return focusIndex$9(state, 0)
 };
 
 const focusLast$8 = (state) => {
-  return focusIndex$8(state, state.activityBarItems.length - 1)
+  return focusIndex$9(state, state.activityBarItems.length - 1)
 };
 
 const getPosition$2 = (state, index) => {
@@ -4803,7 +4853,7 @@ var ViewletActivityBar = {
   toggleItem: toggleItem,
   toggleActivityBarItem: toggleActivityBarItem,
   handleContextMenu: handleContextMenu$2,
-  focusIndex: focusIndex$8,
+  focusIndex: focusIndex$9,
   focus: focus$2,
   focusNext: focusNext$8,
   focusPrevious: focusPrevious$8,
@@ -4815,7 +4865,7 @@ var ViewletActivityBar = {
   hasFunctionalRender: hasFunctionalRender$c
 };
 
-const __initialize__$V = () => {
+const __initialize__$W = () => {
   register$2(8000, wrapViewletCommand('ActivityBar', toggleItem));
   register$2(8001, wrapViewletCommand('ActivityBar', handleClick$6));
   register$2(8002, wrapViewletCommand('ActivityBar', handleContextMenu$2));
@@ -4834,10 +4884,10 @@ const __initialize__$V = () => {
 
 var ViewletActivityBar_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$V
+  __initialize__: __initialize__$W
 };
 
-const __initialize__$U = () => {
+const __initialize__$V = () => {
   register$2(8080, reload);
   register$2(8081, minimize);
   register$2(8082, maximize);
@@ -4850,7 +4900,7 @@ const __initialize__$U = () => {
 
 var Window_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$U
+  __initialize__: __initialize__$V
 };
 
 // interface Editor {
@@ -5050,15 +5100,15 @@ const openUri$1 = async (state, uri) => {
   state.activeIndex = state.editors.length - 1;
   const tabLabel = pathBaseName(uri);
   const tabTitle = getTabTitle(uri);
-  send$1([
+  await invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'Main',
     /* method */ 'openViewlet',
     /* id */ id,
     /* tabLabel */ tabLabel,
     /* tabTitle */ tabTitle,
-    /* oldActiveIndex */ oldActiveIndex,
-  ]);
+    /* oldActiveIndex */ oldActiveIndex
+  );
   return load(instance)
 };
 
@@ -5113,7 +5163,7 @@ const closeAllEditors = (state) => {
   state.focusedIndex = -1;
   state.selectedIndex = -1;
   // TODO should call dispose method, but only in renderer-worker
-  delete state$p.instances.EditorText;
+  delete state$m.instances.EditorText;
 };
 
 const dispose$m = () => {};
@@ -5142,19 +5192,19 @@ const closeEditor = async (state, index) => {
     //   height: instance.state.height,
     //   columnWidth: COLUMN_WIDTH,
     // })
-    send$1([
+    await invoke$1(
       /* Main.closeOneTab */ 2164,
       /* closeIndex */ oldActiveIndex,
-      /* focusIndex */ newActiveIndex,
-    ]);
+      /* focusIndex */ newActiveIndex
+    );
     return
   }
-  send$1([
+  await invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'Main',
     /* method */ 'closeOneTabOnly',
-    /* closeIndex */ index,
-  ]);
+    /* closeIndex */ index
+  );
   state.editors.splice(index, 1);
   if (index < state.activeIndex) {
     state.activeIndex--;
@@ -5178,7 +5228,7 @@ const handleTabContextMenu = async (state, index, x, y) => {
   );
 };
 
-const focusIndex$7 = (state, index) => {
+const focusIndex$8 = (state, index) => {
   if (index === state.activeIndex) {
     console.log('index', index, ' is already active index');
     return
@@ -5215,49 +5265,49 @@ const focusIndex$7 = (state, index) => {
 };
 
 const focusFirst$7 = (state) => {
-  return focusIndex$7(state, 0)
+  return focusIndex$8(state, 0)
 };
 
 const focusLast$7 = (state) => {
-  return focusIndex$7(state, state.editors.length - 1)
+  return focusIndex$8(state, state.editors.length - 1)
 };
 
 const focusPrevious$7 = (state) => {
   const previousIndex =
     state.activeIndex === 0 ? state.editors.length - 1 : state.activeIndex - 1;
-  return focusIndex$7(state, previousIndex)
+  return focusIndex$8(state, previousIndex)
 };
 
 const focusNext$7 = (state) => {
   const nextIndex =
     state.activeIndex === state.editors.length - 1 ? 0 : state.activeIndex + 1;
-  return focusIndex$7(state, nextIndex)
+  return focusIndex$8(state, nextIndex)
 };
 
 const handleTabClick = (state, index) => {
   console.log('focus index', index);
-  return focusIndex$7(state, index)
+  return focusIndex$8(state, index)
 };
 
 const closeOthers = async (state) => {
   if (state.focusedIndex === state.activeIndex) {
     // view is kept the same, only tabs are closed
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeOthers',
       /* keepIndex */ state.focusedIndex,
-      /* focusIndex */ state.focusedIndex,
-    ]);
+      /* focusIndex */ state.focusedIndex
+    );
   } else {
     // view needs to be switched to focused index
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeOthers',
       /* keepIndex */ state.focusedIndex,
-      /* focusIndex */ state.focusedIndex,
-    ]);
+      /* focusIndex */ state.focusedIndex
+    );
   }
   state.editors = [state.editors[state.focusedIndex]];
   state.activeIndex = 0;
@@ -5267,20 +5317,20 @@ const closeOthers = async (state) => {
 const closeTabsRight = async (state) => {
   if (state.focusedIndex >= state.activeIndex) {
     // view is kept the same, only tabs are closed
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeTabsRight',
-      /* index */ state.focusedIndex,
-    ]);
+      /* index */ state.focusedIndex
+    );
   } else {
     // view needs to be switched to focused index
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeTabsRight',
-      /* index */ state.focusedIndex,
-    ]);
+      /* index */ state.focusedIndex
+    );
   }
   state.editors = state.editors.slice(0, state.focusedIndex + 1);
   state.activeIndex = state.focusedIndex;
@@ -5289,20 +5339,20 @@ const closeTabsRight = async (state) => {
 const closeTabsLeft = async (state) => {
   if (state.focusedIndex <= state.activeIndex) {
     // view is kept the same, only tabs are closed
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeTabsLeft',
-      /* index */ state.focusedIndex,
-    ]);
+      /* index */ state.focusedIndex
+    );
   } else {
     // view needs to be switched to focused index
-    send$1([
+    await invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'Main',
       /* method */ 'closeTabsLeft',
-      /* index */ state.focusedIndex,
-    ]);
+      /* index */ state.focusedIndex
+    );
   }
   state.editors = state.editors.slice(state.focusedIndex);
   state.activeIndex = state.focusedIndex;
@@ -5346,7 +5396,7 @@ var ViewletMain = {
   closeEditor: closeEditor,
   closeFocusedTab: closeFocusedTab,
   handleTabContextMenu: handleTabContextMenu,
-  focusIndex: focusIndex$7,
+  focusIndex: focusIndex$8,
   focusFirst: focusFirst$7,
   focusLast: focusLast$7,
   focusPrevious: focusPrevious$7,
@@ -5358,7 +5408,7 @@ var ViewletMain = {
   resize: resize$a
 };
 
-const __initialize__$T = () => {
+const __initialize__$U = () => {
   register$2(89, wrapViewletCommand('Main', save));
   register$2(92, wrapViewletCommand('Main', handleDrop));
   register$2(93, wrapViewletCommand('Main', closeActiveEditor));
@@ -5380,7 +5430,7 @@ const __initialize__$T = () => {
 
 var ViewletMain_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$T
+  __initialize__: __initialize__$U
 };
 
 const getModule = (id) => {
@@ -5429,7 +5479,10 @@ const getMenuEntries$h = async (id) => {
   return module.getMenuEntries()
 };
 
-const state$l = {
+const state$i = {
+  /**
+   * @type {any[]}
+   */
   menus: [],
   latestTimeStamp: 0,
   enterTimeout: -1,
@@ -5462,17 +5515,17 @@ const getMenuHeight = (items) => {
 };
 
 const getCurrentMenu = () => {
-  if (state$l.menus.length === 0) {
+  if (state$i.menus.length === 0) {
     console.warn('menu not available');
   }
-  return state$l.menus.at(-1)
+  return state$i.menus.at(-1)
 };
 
 const addMenuInternal = (menu) => {
-  if (state$l.menus.length > 5) {
+  if (state$i.menus.length > 5) {
     throw new Error('too many menus')
   }
-  state$l.menus.push(menu);
+  state$i.menus.push(menu);
   return menu
 };
 
@@ -5480,8 +5533,8 @@ const getMenuBounds = (x, y, items) => {
   const menuWidth = CONTEXT_MENU_WIDTH;
   const menuHeight = getMenuHeight(items);
 
-  const windowWidth = state$o.windowWidth;
-  const windowHeight = state$o.windowHeight;
+  const windowWidth = state$l.windowWidth;
+  const windowHeight = state$l.windowHeight;
   // TODO maybe only send labels and keybindings to ui (id not needed on ui)
   // TODO what about separators?
 
@@ -5507,7 +5560,7 @@ const show$4 = async (x, y, id, mouseBlocking = false) => {
     id,
     items,
     focusedIndex: -1,
-    level: state$l.menus.length,
+    level: state$i.menus.length,
     x: bounds.x,
     y: bounds.y,
   });
@@ -5526,15 +5579,15 @@ const show$4 = async (x, y, id, mouseBlocking = false) => {
 
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
-  state$l.menus = state$l.menus.slice(0, level + 1);
-  const parentMenu = state$l.menus[level];
+  state$i.menus = state$i.menus.slice(0, level + 1);
+  const parentMenu = state$i.menus[level];
   const item = parentMenu.items[index];
   const subMenuItems = await getMenuEntries$h(item.id);
   const subMenu = addMenuInternal({
     id: item.id,
     items: subMenuItems,
     focusedIndex: -1,
-    level: state$l.menus.length,
+    level: state$i.menus.length,
     y: parentMenu.y + index * 25,
     x: parentMenu.x + MENU_WIDTH,
     enterX,
@@ -5559,7 +5612,7 @@ const showSubMenu = async (level, index) => {
 };
 
 const selectIndex$3 = async (level, index) => {
-  const menu = state$l.menus[level];
+  const menu = state$i.menus[level];
   menu.focusedIndex = index;
   const item = menu.items[menu.focusedIndex];
   switch (item.flags) {
@@ -5581,15 +5634,15 @@ const selectIndex$3 = async (level, index) => {
 };
 
 const selectCurrent$1 = async (level) => {
-  const menu = state$l.menus[level];
+  const menu = state$i.menus[level];
   await selectIndex$3(level, menu.focusedIndex);
 };
 
 const hide$1 = async () => {
-  if (state$l.menus.length === 0) {
+  if (state$i.menus.length === 0) {
     return
   }
-  state$l.menus = [];
+  state$i.menus = [];
   await invoke$1(/* Menu.hide */ 7901);
 };
 
@@ -5598,8 +5651,8 @@ const hide$1 = async () => {
 // with keyboard -> don't open submenu, only focus
 
 const hideSubMenus = async (level) => {
-  if (level < state$l.menus.length) {
-    state$l.menus = state$l.menus.slice(0, level + 1);
+  if (level < state$i.menus.length) {
+    state$i.menus = state$i.menus.slice(0, level + 1);
     await invoke$1(
       /* Menu.hideSubMenu */ 7904,
       /* level */ level + 1
@@ -5620,27 +5673,27 @@ const handleMouseEnter$1 = async (
   enterY,
   enterTimeStamp
 ) => {
-  state$l.latestTimeStamp = enterTimeStamp;
-  if (level >= state$l.menus.length) {
+  state$i.latestTimeStamp = enterTimeStamp;
+  if (level >= state$i.menus.length) {
     return
   }
-  const menu = state$l.menus[level];
+  const menu = state$i.menus[level];
   if (menu.focusedIndex === index) {
     return
   }
-  if (level < state$l.menus.length - 1) {
-    const subMenu = state$l.menus[level + 1];
+  if (level < state$i.menus.length - 1) {
+    const subMenu = state$i.menus[level + 1];
     const subMenuEnterX = subMenu.enterX;
     // TODO should check for triangle position here
     if (enterX >= subMenuEnterX) {
       await new Promise(resolveAfterTimeout);
-      if (state$l.latestTimeStamp !== enterTimeStamp) {
+      if (state$i.latestTimeStamp !== enterTimeStamp) {
         return
       }
     }
   }
   const item = menu.items[index];
-  await focusIndex$6(menu, index);
+  await focusIndex$7(menu, index);
   switch (item.flags) {
     case /* SubMenu */ 4:
       await showSubMenuAtEnter(menu.level, index, enterX, enterY);
@@ -5651,7 +5704,7 @@ const handleMouseEnter$1 = async (
   }
 };
 
-const focusIndex$6 = async (menu, index) => {
+const focusIndex$7 = async (menu, index) => {
   if (menu.items.length === 0) {
     return
   }
@@ -5684,7 +5737,7 @@ const focusFirst$6 = async () => {
   }
   const indexToFocus = getIndexToFocusNextStartingAt$1(menu.items, 0);
   console.log({ first: indexToFocus });
-  await focusIndex$6(menu, indexToFocus);
+  await focusIndex$7(menu, indexToFocus);
 };
 
 const focusLast$6 = async () => {
@@ -5693,7 +5746,7 @@ const focusLast$6 = async () => {
     menu.items,
     menu.items.length - 1
   );
-  await focusIndex$6(menu, indexToFocus);
+  await focusIndex$7(menu, indexToFocus);
 };
 
 // TODO this code seems a bit too complicated, maybe it can be simplified
@@ -5720,7 +5773,7 @@ const focusPrevious$6 = async () => {
     return
   }
   const indexToFocus = getIndexToFocusPrevious(menu);
-  await focusIndex$6(menu, indexToFocus);
+  await focusIndex$7(menu, indexToFocus);
 };
 
 const canBeFocused = (item) => {
@@ -5738,7 +5791,7 @@ const focusNext$6 = async () => {
     return
   }
   const indexToFocus = getIndexToFocusNext(menu);
-  await focusIndex$6(menu, indexToFocus);
+  await focusIndex$7(menu, indexToFocus);
 };
 
 // TODO handle printable letter and focus item that starts with that letter
@@ -5760,7 +5813,7 @@ const show$3 = async (x, y, id) => {
   // TODO what about separators?
 };
 
-const __initialize__$S = () => {
+const __initialize__$T = () => {
   register$2(950, undefined);
   register$2(951, show$3);
   register$2(952, undefined);
@@ -5774,10 +5827,10 @@ const __initialize__$S = () => {
 
 var ContextMenu_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$S
+  __initialize__: __initialize__$T
 };
 
-const __initialize__$R = () => {
+const __initialize__$S = () => {
   register$2(1100, showSideBar);
   register$2(1101, hideSideBar);
   register$2(1102, toggleSideBar);
@@ -5790,30 +5843,31 @@ const __initialize__$R = () => {
   register$2(1109, hydrate$5);
   register$2(1110, undefined);
   register$2(1111, handleResize);
-  register$2(1112, handleSashSideBarMove);
+  register$2(1112, handleSashPointerMove);
+  register$2(1113, handleSashPointerDown);
 };
 
 var Layout_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$R
+  __initialize__: __initialize__$S
 };
 
-const __initialize__$Q = () => {
+const __initialize__$R = () => {
   register$2(2133, send);
 };
 
 var Viewlet_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$Q
+  __initialize__: __initialize__$R
 };
 
-const __initialize__$P = () => {
+const __initialize__$Q = () => {
   register$2(47110, undefined);
 };
 
 var Workbench_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$P
+  __initialize__: __initialize__$Q
 };
 
 // based on https://github.com/bevacqua/fuzzysearch/blob/master/index.js
@@ -5889,7 +5943,7 @@ const STATE_DEFAULT = 0;
 const STATE_CREATING = 1;
 const STATE_FINISHED = 2;
 
-const state$k = {
+const state$h = {
   state: STATE_DEFAULT,
   picks: [],
   filteredPicks: [],
@@ -5913,9 +5967,9 @@ const filterPicks = (picks, exclude, value) => {
     if (exclude.has(pick.id)) {
       return false
     }
-    if (!pick.label && !state$k.warned.includes(JSON.stringify(pick))) {
+    if (!pick.label && !state$h.warned.includes(JSON.stringify(pick))) {
       console.warn('[QuickPick] item has missing label', pick);
-      state$k.warned.push(JSON.stringify(pick));
+      state$h.warned.push(JSON.stringify(pick));
       return false
     }
     const labelMatch = fuzzySearch(value, pick.label || pick.id);
@@ -5956,75 +6010,75 @@ const toDisplayPicks = (picks) => {
 };
 
 const getVisiblePicks = (picks, filterValue) => {
-  const filteredPicks = filterPicks(picks, state$k.recentPickIds, filterValue);
-  state$k.filteredPicks = filteredPicks;
-  state$k.state = STATE_FINISHED;
+  const filteredPicks = filterPicks(picks, state$h.recentPickIds, filterValue);
+  state$h.filteredPicks = filteredPicks;
+  state$h.state = STATE_FINISHED;
   const slicedPicks = slicePicks(filteredPicks);
   return toDisplayPicks(slicedPicks)
 };
 
 // TODO have lazy loadable provider as argument
 const show$2 = async (value, provider) => {
-  state$k.provider = provider;
-  if (state$k.state === STATE_FINISHED) {
-    const version = ++state$k.versionId;
+  state$h.provider = provider;
+  if (state$h.state === STATE_FINISHED) {
+    const version = ++state$h.versionId;
     // TODO if provider is immutable, don't necessarily need to get new picks
     const newPicks = await provider.getPicks(value);
     array(newPicks);
-    if (version !== state$k.versionId) {
+    if (version !== state$h.versionId) {
       return
     }
     const filterValue = provider.getFilterValue(value);
     const visiblePicks = getVisiblePicks(newPicks, filterValue);
     const placeholder = provider.getPlaceholder();
     const label = provider.getLabel();
-    send$1([
+    invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicksAndPlaceholder',
       /* value */ value,
       /* picks */ visiblePicks,
       /* focusIndex */ 0,
-      /* unFocusIndex */ state$k.focusedIndex,
+      /* unFocusIndex */ state$h.focusedIndex,
       /* placeholder */ placeholder,
-      /* label */ label,
-    ]);
-    state$k.picks = newPicks;
-    state$k.visiblePicks = visiblePicks;
-    state$k.focusedIndex = 0;
-    state$k.state = STATE_FINISHED;
-    state$k.minLineY = 0;
-    state$k.maxLineY = Math.min(
-      state$k.minLineY + state$k.maxVisibleItems,
+      /* label */ label
+    );
+    state$h.picks = newPicks;
+    state$h.visiblePicks = visiblePicks;
+    state$h.focusedIndex = 0;
+    state$h.state = STATE_FINISHED;
+    state$h.minLineY = 0;
+    state$h.maxLineY = Math.min(
+      state$h.minLineY + state$h.maxVisibleItems,
       newPicks.length - 1
     );
     return
   }
-  state$k.state = STATE_CREATING;
-  const version = ++state$k.versionId;
+  state$h.state = STATE_CREATING;
+  const version = ++state$h.versionId;
   // TODO also pass initial value here
   await invoke$1(/* Viewlet.load */ 3030, /* id */ 'QuickPick');
   const newPicks = await provider.getPicks(value);
   array(newPicks);
-  if (version !== state$k.versionId) {
+  if (version !== state$h.versionId) {
     return
   }
   if (newPicks.length === 0) {
     const noResults = await provider.getNoResults();
-    send$1([
+    invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'showNoResults',
       /* noResults */ noResults,
-      /* unfocusIndex */ state$k.focusedIndex,
-    ]);
+      /* unfocusIndex */ state$h.focusedIndex
+    );
     return
   }
   const filterValue = provider.getFilterValue(value);
   const visiblePicks = getVisiblePicks(newPicks, filterValue);
   const placeholder = provider.getPlaceholder();
   const label = provider.getLabel();
-  send$1([
+  invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'QuickPick',
     /* method */ 'updateValueAndPicksAndPlaceholder',
@@ -6033,33 +6087,33 @@ const show$2 = async (value, provider) => {
     /* focusIndex */ 0,
     /* unFocusIndex */ -1,
     /* placeholder */ placeholder,
-    /* label */ label,
-  ]);
-  state$k.picks = newPicks;
-  state$k.visiblePicks = visiblePicks;
-  state$k.focusedIndex = 0;
-  state$k.state = STATE_FINISHED;
-  state$k.minLineY = 0;
-  state$k.maxLineY = Math.min(
-    state$k.minLineY + state$k.maxVisibleItems,
+    /* label */ label
+  );
+  state$h.picks = newPicks;
+  state$h.visiblePicks = visiblePicks;
+  state$h.focusedIndex = 0;
+  state$h.state = STATE_FINISHED;
+  state$h.minLineY = 0;
+  state$h.maxLineY = Math.min(
+    state$h.minLineY + state$h.maxVisibleItems,
     newPicks.length - 1
   );
 };
 
 const dispose$l = () => {
-  switch (state$k.state) {
+  switch (state$h.state) {
     case STATE_DEFAULT:
     case STATE_CREATING:
       break
     case STATE_FINISHED:
-      state$k.state = STATE_DEFAULT;
-      send$1([/* Viewlet.dispose */ 3026, /* id */ 'QuickPick']);
+      state$h.state = STATE_DEFAULT;
+      invoke$1(/* Viewlet.dispose */ 3026, /* id */ 'QuickPick');
       break
   }
 };
 
 const handleBlur$1 = async () => {
-  switch (state$k.state) {
+  switch (state$h.state) {
     case STATE_DEFAULT:
     case STATE_CREATING:
       break
@@ -6081,13 +6135,13 @@ const getPick = (state, index) => {
 };
 
 const selectIndex$2 = async (index, button = /* left */ 0) => {
-  const pick = getPick(state$k, index);
-  const versionBefore = state$k.versionId;
-  const selectPickResult = await state$k.provider.selectPick(pick, index, button);
+  const pick = getPick(state$h, index);
+  const versionBefore = state$h.versionId;
+  const selectPickResult = await state$h.provider.selectPick(pick, index, button);
   object(selectPickResult);
   string(selectPickResult.command);
   const { command } = selectPickResult;
-  const versionAfter = state$k.versionId;
+  const versionAfter = state$h.versionId;
   if (versionBefore !== versionAfter) {
     // selecting a pick might have opened another quick pick
     // so there is no need to hide the quick pick
@@ -6111,22 +6165,22 @@ const selectIndex$2 = async (index, button = /* left */ 0) => {
 };
 
 const selectCurrentIndex = async () => {
-  await selectIndex$2(state$k.focusedIndex);
+  await selectIndex$2(state$h.focusedIndex);
 };
 
 // TODO when user types letters -> no need to query provider again -> just filter existing results
 const handleInput$2 = async (value) => {
-  if (state$k.state === STATE_DEFAULT) {
+  if (state$h.state === STATE_DEFAULT) {
     return
   }
-  state$k.state = STATE_CREATING;
-  const version = ++state$k.versionId;
+  state$h.state = STATE_CREATING;
+  const version = ++state$h.versionId;
   // TODO if provider is immutable, don't necessarily need to get new picks
-  const newPicks = await state$k.provider.getPicks(value);
-  if (version !== state$k.versionId) {
+  const newPicks = await state$h.provider.getPicks(value);
+  if (version !== state$h.versionId) {
     return
   }
-  const filterValue = state$k.provider.getFilterValue(value);
+  const filterValue = state$h.provider.getFilterValue(value);
   const visiblePicks = getVisiblePicks(newPicks, filterValue);
 
   send$1([
@@ -6134,12 +6188,12 @@ const handleInput$2 = async (value) => {
     /* id */ 'QuickPick',
     /* method */ 'updatePicks',
     /* picks */ visiblePicks,
-    /* unFocusIndex */ state$k.focusedIndex,
+    /* unFocusIndex */ state$h.focusedIndex,
   ]);
-  state$k.picks = newPicks;
-  state$k.visiblePicks = visiblePicks;
-  state$k.focusedIndex = 0;
-  state$k.state = STATE_FINISHED;
+  state$h.picks = newPicks;
+  state$h.visiblePicks = visiblePicks;
+  state$h.focusedIndex = 0;
+  state$h.state = STATE_FINISHED;
 };
 
 // TODO use reactive Programming
@@ -6156,103 +6210,103 @@ const handleInput$2 = async (value) => {
 //
 // })
 
-const focusIndex$5 = async (index) => {
-  console.log({ index, maxLineY: state$k.maxLineY });
-  if (index < state$k.minLineY) {
-    state$k.minLineY = index;
-    state$k.maxLineY = Math.min(
-      index + state$k.maxVisibleItems,
-      state$k.filteredPicks.length - 1
+const focusIndex$6 = async (index) => {
+  console.log({ index, maxLineY: state$h.maxLineY });
+  if (index < state$h.minLineY) {
+    state$h.minLineY = index;
+    state$h.maxLineY = Math.min(
+      index + state$h.maxVisibleItems,
+      state$h.filteredPicks.length - 1
     );
-    const slicedPicks = state$k.filteredPicks.slice(
-      state$k.minLineY,
-      state$k.maxLineY
+    const slicedPicks = state$h.filteredPicks.slice(
+      state$h.minLineY,
+      state$h.maxLineY
     );
     const displayPicks = toDisplayPicks(slicedPicks);
-    const relativeFocusIndex = index - state$k.minLineY;
-    const relativeUnFocusIndex = state$k.focusedIndex - state$k.minLineY;
-    send$1([
+    const relativeFocusIndex = index - state$h.minLineY;
+    const relativeUnFocusIndex = state$h.focusedIndex - state$h.minLineY;
+    invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
-      /* value */ state$k.value,
+      /* value */ state$h.value,
       /* visiblePicks */ displayPicks,
       /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex,
-    ]);
+      /* unFocusIndex */ relativeUnFocusIndex
+    );
     // TODO need to scroll up
-  } else if (index > state$k.maxLineY) {
+  } else if (index > state$h.maxLineY) {
     // TODO need to scroll down
-    state$k.minLineY = Math.max(0, index - state$k.maxVisibleItems);
-    state$k.maxLineY = Math.min(
-      index + state$k.maxVisibleItems - 1,
-      state$k.filteredPicks.length - 1
+    state$h.minLineY = Math.max(0, index - state$h.maxVisibleItems);
+    state$h.maxLineY = Math.min(
+      index + state$h.maxVisibleItems - 1,
+      state$h.filteredPicks.length - 1
     );
-    const slicedPicks = state$k.filteredPicks.slice(
-      state$k.minLineY,
-      state$k.maxLineY
+    const slicedPicks = state$h.filteredPicks.slice(
+      state$h.minLineY,
+      state$h.maxLineY
     );
     console.log(
       'scroll down',
       index,
-      state$k.minLineY,
-      state$k.maxLineY,
+      state$h.minLineY,
+      state$h.maxLineY,
       slicedPicks
     );
     const displayPicks = toDisplayPicks(slicedPicks);
-    const relativeFocusIndex = index - state$k.minLineY;
-    const relativeUnFocusIndex = state$k.focusedIndex - state$k.minLineY;
+    const relativeFocusIndex = index - state$h.minLineY;
+    const relativeUnFocusIndex = state$h.focusedIndex - state$h.minLineY;
     console.log({
       relativeFocusIndex,
       relativeUnFocusIndex,
     });
-    send$1([
+    invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
-      /* value */ state$k.value,
+      /* value */ state$h.value,
       /* visiblePicks */ displayPicks,
       /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex,
-    ]);
+      /* unFocusIndex */ relativeUnFocusIndex
+    );
   } else {
-    send$1([
+    invoke$1(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'focusIndex',
-      /* unFocusIndex */ state$k.focusedIndex,
-      /* index */ index,
-    ]);
+      /* unFocusIndex */ state$h.focusedIndex,
+      /* index */ index
+    );
   }
 
-  state$k.focusedIndex = index;
+  state$h.focusedIndex = index;
   // TODO get types working
   // @ts-ignore
-  if (state$k.provider.focusPick) {
+  if (state$h.provider.focusPick) {
     // @ts-ignore
-    await state$k.provider.focusPick(state$k.filteredPicks[index]);
+    await state$h.provider.focusPick(state$h.filteredPicks[index]);
   }
 };
 
 const focusFirst$5 = async () => {
-  await focusIndex$5(0);
+  await focusIndex$6(0);
 };
 
 const focusLast$5 = async () => {
-  await focusIndex$5(state$k.filteredPicks.length - 1);
+  await focusIndex$6(state$h.filteredPicks.length - 1);
 };
 
 const focusPrevious$5 = async () => {
   const previousIndex =
-    state$k.focusedIndex === 0
-      ? state$k.filteredPicks.length - 1
-      : state$k.focusedIndex - 1;
-  await focusIndex$5(previousIndex);
+    state$h.focusedIndex === 0
+      ? state$h.filteredPicks.length - 1
+      : state$h.focusedIndex - 1;
+  await focusIndex$6(previousIndex);
 };
 
 const focusNext$5 = async () => {
-  const nextIndex = (state$k.focusedIndex + 1) % state$k.filteredPicks.length;
-  await focusIndex$5(nextIndex);
+  const nextIndex = (state$h.focusedIndex + 1) % state$h.filteredPicks.length;
+  await focusIndex$6(nextIndex);
 };
 
 // TODO not sure these should be in this file
@@ -6315,7 +6369,7 @@ const showExtensionsQuickPick = async (items) => {
   await show$2('', provider);
 };
 
-const __initialize__$O = () => {
+const __initialize__$P = () => {
   register$2(71179, openEverythingQuickPick);
   register$2(71178, dispose$l);
   register$2(71180, selectCurrentIndex);
@@ -6337,7 +6391,7 @@ const __initialize__$O = () => {
 
 var QuickPick_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$O
+  __initialize__: __initialize__$P
 };
 
 const name$m = 'Panel';
@@ -6437,7 +6491,7 @@ var ViewletPanel = {
   tabsHandleClick: tabsHandleClick
 };
 
-const __initialize__$N = () => {
+const __initialize__$O = () => {
   register$2(711, wrapViewletCommand('Panel', tabsHandleClick));
   register$2(712, wrapViewletCommand('Panel', openViewlet$1));
   register$2(713, create$p);
@@ -6445,23 +6499,23 @@ const __initialize__$N = () => {
 
 var Panel_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$N
+  __initialize__: __initialize__$O
 };
 
-const state$j = {
+const state$g = {
   id: 0,
 };
 
 const create$o = () => {
-  return ++state$j.id
+  return ++state$g.id
 };
 
-const state$i = {
+const state$f = {
   activeWidget: undefined,
 };
 
 const create$n = ({ getText }) => {
-  state$i.activeWidget = {
+  state$f.activeWidget = {
     id: create$o(),
     searchValue: '',
     // TODO how does find widget get text from editor? Both are complete separated
@@ -6470,7 +6524,7 @@ const create$n = ({ getText }) => {
   };
   send$1([
     /* FindWidget.create */ 4100,
-    /* id */ state$i.activeWidget.id,
+    /* id */ state$f.activeWidget.id,
   ]);
 };
 
@@ -6490,8 +6544,8 @@ const update = async (widget) => {
 };
 
 const setValue$1 = async (value) => {
-  state$i.activeWidget.value = value;
-  update(state$i.activeWidget);
+  state$f.activeWidget.value = value;
+  update(state$f.activeWidget);
 };
 
 const previousMatch = () => {};
@@ -6499,19 +6553,19 @@ const previousMatch = () => {};
 const nextMatch = () => {};
 
 const dispose$j = () => {
-  if (!state$i.activeWidget) {
+  if (!state$f.activeWidget) {
     return
   }
   send$1([
     /* FindWidget.dispose */ 4102,
-    /* id */ state$i.activeWidget.id,
+    /* id */ state$f.activeWidget.id,
   ]);
-  state$i.activeWidget = undefined;
+  state$f.activeWidget = undefined;
 };
 
 var FindWidget = {
   __proto__: null,
-  state: state$i,
+  state: state$f,
   create: create$n,
   setValue: setValue$1,
   previousMatch: previousMatch,
@@ -6519,7 +6573,7 @@ var FindWidget = {
   dispose: dispose$j
 };
 
-const __initialize__$M = () => {
+const __initialize__$N = () => {
   register$2(212333, create$n);
   register$2(212334, dispose$j);
   register$2(4101, setValue$1);
@@ -6528,10 +6582,10 @@ const __initialize__$M = () => {
 
 var FindWidget_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$M
+  __initialize__: __initialize__$N
 };
 
-const __initialize__$L = () => {
+const __initialize__$M = () => {
   register$2(1200, openSettingsJson);
   register$2(1201, openSettingsJson);
   // TODO rename to openKeyBindingsJson -> similar to openSettingsJson
@@ -6542,7 +6596,7 @@ const __initialize__$L = () => {
 
 var Preferences_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$L
+  __initialize__: __initialize__$M
 };
 
 const BYTE_UNITS = [
@@ -6995,8 +7049,8 @@ const getMemoryUsageContent = async () => {
     extensionHostMemoryUsage
   );
   const rendererWorkerMemoryUsage = await getRendererWorkerMemoryUsage();
-  const totalSent = state$D.totalSent;
-  const totalReceived = state$D.totalReceived;
+  const totalSent = state$A.totalSent;
+  const totalReceived = state$A.totalReceived;
   const formattedRendererWorkerMemoryUsage = formatRendererWorkerData({
     memory: rendererWorkerMemoryUsage.memory,
     userAgentSpecificMemory: rendererWorkerMemoryUsage.userAgentSpecificMemory,
@@ -7054,14 +7108,14 @@ const allocateMemoryInSharedProcess = async () => {
   );
 };
 
-const crashSharedProcess = () => {
-  send$2(
+const crashSharedProcess = async () => {
+  await invoke$2(
     /* Developer.crashSharedProcess */ 'Developer.crashSharedProcess'
   );
 };
 
-const crashMainProcess = () => {
-  send$2(
+const crashMainProcess = async () => {
+  await invoke$2(
     /* Electron.crashMainProcess */ 'Electron.crashMainProcess'
   );
 };
@@ -7075,8 +7129,10 @@ const openLogsFolder = async () => {
   await execute$1(/* Open.openNativeFolder */ 1370, /* path */ logsFolder);
 };
 
-const toggleDeveloperTools = () => {
-  send$2(/* Electron.toggleDevtools */ 'Electron.toggleDevtools');
+const toggleDeveloperTools = async () => {
+  await invoke$2(
+    /* Electron.toggleDevtools */ 'Electron.toggleDevtools'
+  );
 };
 
 const showIconThemeCss = async () => {
@@ -7144,7 +7200,7 @@ const openProcessExplorer = async () => {
   );
 };
 
-const __initialize__$K = () => {
+const __initialize__$L = () => {
   register$2(820, getStartupPerformanceContent);
   register$2(821, getMemoryUsageContent);
   register$2(822, allocateMemoryInSharedProcess);
@@ -7170,15 +7226,15 @@ const __initialize__$K = () => {
 
 var Developer_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$K
+  __initialize__: __initialize__$L
 };
 
-const state$h = {
+const state$e = {
   blurListeners: [],
 };
 
 const editorBlur = (editor) => {
-  for (const listener of state$h.blurListeners) {
+  for (const listener of state$e.blurListeners) {
     listener(editor);
   }
   // TODO save on blur
@@ -7187,7 +7243,7 @@ const editorBlur = (editor) => {
 };
 
 const removeListener = (fn) => {
-  state$h.blurListeners.splice(state$h.blurListeners.indexOf(fn), 1);
+  state$e.blurListeners.splice(state$e.blurListeners.indexOf(fn), 1);
 };
 
 // based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
@@ -7430,7 +7486,7 @@ var TokenizePlainText = {
   tokenizeLine: tokenizeLine
 };
 
-const state$g = {
+const state$d = {
   tokenizers: Object.create(null),
   tokenizePaths: Object.create(null),
   listeners: [],
@@ -7439,7 +7495,7 @@ const state$g = {
 
 // TODO more dynamic: should come from extensions anywhere on file system
 const getTokenizePath = (languageId) => {
-  for (const language of state$w.languages) {
+  for (const language of state$t.languages) {
     if (language.id === languageId && language.tokenize) {
       return language.tokenize
     }
@@ -7449,7 +7505,7 @@ const getTokenizePath = (languageId) => {
 
 // TODO loadTokenizer should be invoked from renderer worker
 const loadTokenizer = async (languageId) => {
-  if (languageId in state$g.tokenizers) {
+  if (languageId in state$d.tokenizers) {
     return
   }
   const tokenizePath = getTokenizePath(languageId);
@@ -7477,9 +7533,9 @@ const loadTokenizer = async (languageId) => {
       );
       return
     }
-    state$g.tokenizers[languageId] = tokenizer;
+    state$d.tokenizers[languageId] = tokenizer;
   } catch (error) {
-    state$g.tokenizers[languageId] = TokenizePlainText;
+    state$d.tokenizers[languageId] = TokenizePlainText;
     // TODO better error handling
     console.error(error);
     return
@@ -7488,10 +7544,10 @@ const loadTokenizer = async (languageId) => {
 };
 
 const getTokenizer = (languageId) => {
-  if (languageId in state$g.tokenizers) {
-    return state$g.tokenizers[languageId]
+  if (languageId in state$d.tokenizers) {
+    return state$d.tokenizers[languageId]
   }
-  if (languageId in state$g.pending) {
+  if (languageId in state$d.pending) {
     return TokenizePlainText
   }
   return TokenizePlainText
@@ -7865,8 +7921,8 @@ const getDecorationClassName = (type) => {
   switch (type) {
     case 2816:
     case 2817:
-    case 2825:
     case 2824:
+    case 2825:
     case 2856:
     case 2857:
     case 3072:
@@ -7897,8 +7953,8 @@ const getDecorationClassName = (type) => {
     case 2089:
     case 2313:
     case 2560:
-    case 2569:
     case 2561:
+    case 2569:
     case 2584:
       return 'VariableName'
     case 256:
@@ -7911,6 +7967,7 @@ const getDecorationClassName = (type) => {
 };
 
 const getLineInfo = (line, tokens, decorations, TokenMap, lineOffset) => {
+  console.log({ decorations });
   let start = 0;
   let end = 0;
   const lineInfo = [];
@@ -8548,7 +8605,7 @@ const openFromType = async (editor, text) => {
   // } else if (state.isOpened) {
   //   await close()
   // }
-  return state$p.instances['EditorText'].state
+  return state$m.instances['EditorText'].state
 };
 
 const close$3 = async (editor) => {
@@ -8559,13 +8616,13 @@ const close$3 = async (editor) => {
   return editor
 };
 
-const state$f = {
+const state$c = {
   isComposing: false,
   compositionText: '',
 };
 
 const editorCompositionStart = (editor, event) => {
-  state$f.isComposing = true;
+  state$c.isComposing = true;
   console.log({ event });
   console.log('composition start');
   return editor
@@ -8576,7 +8633,7 @@ const getCompositionChanges = (editor, data) => {
   for (const selection of editor.selections) {
     const startRowIndex = selection.start.rowIndex;
     const startColumnIndex =
-      selection.start.columnIndex - state$f.compositionText.length;
+      selection.start.columnIndex - state$c.compositionText.length;
     changes.push({
       start: {
         rowIndex: startRowIndex,
@@ -8584,7 +8641,7 @@ const getCompositionChanges = (editor, data) => {
       },
       end: selection.end,
       inserted: [data],
-      deleted: [state$f.compositionText],
+      deleted: [state$c.compositionText],
       origin: 'compositionUpdate',
     });
   }
@@ -8594,15 +8651,15 @@ const getCompositionChanges = (editor, data) => {
 const editorCompositionUpdate = (editor, data) => {
   const changes = getCompositionChanges(editor, data);
   console.log('composition update', { changes });
-  state$f.compositionText = data;
+  state$c.compositionText = data;
   return scheduleDocumentAndCursorsSelections(editor, changes)
 };
 
 const editorCompositionEnd = (editor, data) => {
   const changes = getCompositionChanges(editor, data);
   console.log('composition end', { changes });
-  state$f.isComposing = false;
-  state$f.compositionText = '';
+  state$c.isComposing = false;
+  state$c.compositionText = '';
   return scheduleDocumentAndCursorsSelections(editor, changes)
 };
 
@@ -9305,7 +9362,7 @@ const executeDefinitionProvider = async (editor, offset) => {
   )
 };
 
-const state$e = {
+const state$b = {
   timeout: -1,
 };
 
@@ -9328,14 +9385,16 @@ const editorShowMessage = async (editor, position, message) => {
     console.log('ran timeout fn');
     editorHideMessage(editor);
   };
+
+  // TODO use wrapper timing module instead of this
   // @ts-ignore
-  state$e.timeout = setTimeout(handleTimeout, 3_000);
+  state$b.timeout = setTimeout(handleTimeout, 3_000);
   return editor
 };
 
 const editorHideMessage = async (editor) => {
-  clearTimeout(state$e.timeout);
-  state$e.timeout = -1;
+  clearTimeout(state$b.timeout);
+  state$b.timeout = -1;
   await invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'EditorText',
@@ -9551,7 +9610,7 @@ const editorHandleNativeSelectionChange = (editor, range) => {
   return scheduleSelections(editor, selections)
 };
 
-const state$d = {
+const state$a = {
   /**
    * Offset at which scrollbar thumb has been clicked
    */
@@ -9589,14 +9648,14 @@ const editorHandleScrollBarClick = (editor, y) => {
   const diff = relativeY - currentScrollBarY;
   console.log({ diff });
   if (diff >= 0 && diff < editor.scrollBarHeight) {
-    state$d.handleOffset = diff;
+    state$a.handleOffset = diff;
     console.log({ handleOffset: diff });
     return editor
   }
   const newPercent = getNewDeltaPercent$1(editor, relativeY);
   console.log({ newPercent });
   // TODO
-  state$d.handleOffset = editor.scrollBarHeight / 2;
+  state$a.handleOffset = editor.scrollBarHeight / 2;
   // TODO when diff is greater, position scrollbar in the middle around cursor
   const newDeltaY = newPercent * editor.finalDeltaY;
   return setDeltaYFixedValue(editor, newDeltaY)
@@ -9619,8 +9678,8 @@ const getNewPercent$1 = (editor, relativeY) => {
 
 const editorHandleScrollBarMove = (editor, y) => {
   const relativeY =
-    y - editor.top - state$d.handleOffset;
-  console.log('handle offset', state$d.handleOffset);
+    y - editor.top - state$a.handleOffset;
+  console.log('handle offset', state$a.handleOffset);
   const newPercent = getNewPercent$1(editor, relativeY);
   const newDeltaY = newPercent * editor.finalDeltaY;
   return setDeltaYFixedValue(editor, newDeltaY)
@@ -9628,7 +9687,7 @@ const editorHandleScrollBarMove = (editor, y) => {
 
 // TODO not sure where this state should be
 // TODO maybe rename to selection anchor
-const state$c = {
+const state$9 = {
   position: {
     rowIndex: 0,
     columnIndex: 0,
@@ -9683,7 +9742,7 @@ const editorMoveSelectionForwards = (editor, anchor, position) => {
 };
 
 const editorMoveSelection = (editor, position) => {
-  const anchor = state$c.position;
+  const anchor = state$9.position;
   // TODO if selection equals previous selection -> do nothing
   switch (compare(position, anchor)) {
     case -1:
@@ -9721,10 +9780,10 @@ const editorHandleSingleClick = async (
       return newEditor
     }
   }
-  state$c.position = position;
+  state$9.position = position;
   return editorCursorSet(
     editor,
-    state$c.position
+    state$9.position
   )
 };
 
@@ -9868,7 +9927,7 @@ const isSlash = (text) => {
 };
 
 const editorTypeWithBraceCompletion = async (editor, text) => {
-  if (!state$w.loaded) {
+  if (!state$t.loaded) {
     await waitForLoad();
   }
   editor.languageId = getLanguageId(editor.uri); // TODO avoid side effect here
@@ -9891,7 +9950,7 @@ const editorTypeWithBraceCompletion = async (editor, text) => {
 };
 
 const editorTypeWithSlashCompletion = async (editor, text) => {
-  if (!state$w.loaded) {
+  if (!state$t.loaded) {
     await waitForLoad();
   }
   editor.languageId = getLanguageId(editor.uri); // TODO avoid side effect here
@@ -9999,7 +10058,7 @@ const editorHandleTab = async (editor) => {
 
 // main()
 
-const state$b = {
+const state$8 = {
   touchOffsetY: 0,
   deltaY: 0,
 };
@@ -10010,8 +10069,8 @@ const editorHandleTouchStart = (editor, touchEvent) => {
   }
   console.log('touch start');
   const firstTouch = touchEvent.touches[0];
-  state$b.touchOffsetY = firstTouch.y;
-  state$b.deltaY = editor.deltaY;
+  state$8.touchOffsetY = firstTouch.y;
+  state$8.deltaY = editor.deltaY;
   // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
   // EditorMoveSelection.state.position = position
   // state.date = Date.now()
@@ -10026,10 +10085,10 @@ const editorHandleTouchEnd = (editor, touchEvent) => {
   const firstTouch = touchEvent.changedTouches[0];
   const position = at(editor, firstTouch.x, firstTouch.y);
   if (
-    state$c.position.rowIndex === position.rowIndex &&
-    state$c.position.columnIndex === position.columnIndex
+    state$9.position.rowIndex === position.rowIndex &&
+    state$9.position.columnIndex === position.columnIndex
   ) {
-    if (Date.now() - state$b.date > LONG_TOUCH_THRESHOLD) {
+    if (Date.now() - state$8.date > LONG_TOUCH_THRESHOLD) {
       editorSelectWord(
         editor,
         position.rowIndex,
@@ -10197,7 +10256,7 @@ const editorMoveLineUp = (editor) => {
 };
 
 const editorMoveRectangleSelection = (editor, position) => {
-  const anchor = state$c.position;
+  const anchor = state$9.position;
   const startRowIndex = anchor.rowIndex;
   const startColumnIndex = anchor.columnIndex;
   const endRowIndex = position.rowIndex;
@@ -10259,7 +10318,7 @@ const editorSave = async (editor) => {
     const betterError = new Error(`Failed to save file "${uri}"`, {
       cause: error,
     });
-    await showErrorDialog(betterError);
+    await handleError$1(betterError);
     return
   }
   await emitEvent('editor.save', editor);
@@ -11206,12 +11265,12 @@ const setLanguageId = async (editor, languageId) => {
   await loadTokenizer(languageId);
   const tokenizer = getTokenizer(languageId);
   if (tokenizer === editor.tokenizer) {
-    return state$p.instances['EditorText'].state
+    return state$m.instances['EditorText'].state
   }
   // TODO update syntax highlighting
   // TODO get edits
 
-  const latestEditor = state$p.instances['EditorText'].state;
+  const latestEditor = state$m.instances['EditorText'].state;
 
   return {
     ...latestEditor,
@@ -11440,7 +11499,7 @@ const setDecorations = (editor, decorations) => {
   }
 };
 
-const __initialize__$J = () => {
+const __initialize__$K = () => {
   register$2(341, wrapViewletCommand('EditorText', editorCursorsDown));
   register$2(342, wrapViewletCommand('EditorText', editorCursorCharacterLeft));
   register$2(343, wrapViewletCommand('EditorText', editorCursorsCharacterRight));
@@ -11529,17 +11588,17 @@ const __initialize__$J = () => {
 
 var EditorCommand_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$J
+  __initialize__: __initialize__$K
 };
 
-const __initialize__$I = () => {
+const __initialize__$J = () => {
   register$2(1422, handleKeyBinding);
   register$2(1423, hydrate$6);
 };
 
 var KeyBindings_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$I
+  __initialize__: __initialize__$J
 };
 
 const openNativeFolder = async (absolutePath) => {
@@ -11559,14 +11618,14 @@ const openCachedExtensionsFolder = async () => {
   await openNativeFolder(cachedExtensionsFolder);
 };
 
-const __initialize__$H = () => {
+const __initialize__$I = () => {
   register$2(7650, openExtensionsFolder);
   register$2(7651, openCachedExtensionsFolder);
 };
 
 var Extensions_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$H
+  __initialize__: __initialize__$I
 };
 
 // TODO viewlet should only have create and refresh functions
@@ -11662,7 +11721,7 @@ const create$k = (id, uri, left, top, width, height) => {
   return {
     root: '',
     dirents: [],
-    focusedIndex: -1,
+    focusedIndex: -2,
     hoverIndex: -1,
     top,
     left,
@@ -11681,7 +11740,7 @@ const getPathSeparator = (root) => {
 };
 
 const loadContent$k = async (state) => {
-  const root = state$z.workspacePath;
+  const root = state$w.workspacePath;
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const dirents = await getTopLevelDirents({ root, pathSeparator });
   return {
@@ -11734,9 +11793,9 @@ const contentLoadedEffects$3 = (state) => {
 
   // TODO hoist function
   addListener('workspace.change', async () => {
-    state.root = state$z.workspacePath;
+    state.root = state$w.workspacePath;
     const newState = await loadContent$k(state);
-    state$p.instances['Explorer'].state = newState;
+    state$m.instances['Explorer'].state = newState;
     await contentLoaded$k(newState);
     // TODO
   });
@@ -11845,7 +11904,7 @@ const removeDirent = async (state) => {
 
   // TODO removing of file and setting focus should happen at the same time
   await scheduleDirents(state);
-  await focusIndex$4(state, indexToFocus);
+  await focusIndex$5(state, indexToFocus);
 };
 
 const renameDirent = async (state) => {
@@ -12023,7 +12082,7 @@ const acceptRename = async (state) => {
   //  TODO move focused index
   state.dirents = newDirents;
   await contentLoaded$k(state);
-  await focusIndex$4(state, focusedIndex);
+  await focusIndex$5(state, focusedIndex);
 
   // await updateDirents(state)
 };
@@ -12057,7 +12116,7 @@ const newDirent = async (state) => {
   // TODO do it like vscode, select position between folders and files
   const focusedIndex = state.focusedIndex;
   const index = state.focusedIndex + 1;
-  if (focusedIndex !== -1) {
+  if (focusedIndex >= 0) {
     const dirent = state.dirents[state.focusedIndex];
     console.log({ dirent, dirents: state.dirents, fi: state.focusedIndex });
     if (dirent.type === 'directory') {
@@ -12250,7 +12309,7 @@ const handleClickDirectoryExpanded = async (state, dirent, index) => {
 
 const handleClick$5 = async (state, index) => {
   if (index === -1) {
-    state.focusedIndex = -1;
+    await focusIndex$5(state, -1);
     return
   }
   const actualIndex = index + state.minLineY;
@@ -12279,13 +12338,15 @@ const handleClickCurrent = async (state) => {
   await handleClick$5(state, state.focusedIndex);
 };
 
-const focusIndex$4 = async (state, index) => {
+const focusIndex$5 = async (state, index) => {
+  const oldFocusedIndex = state.focusedIndex;
   state.focusedIndex = index;
   await invoke$1(
     /* viewSend */ 3024,
     /* id */ 'Explorer',
-    /* method */ 'focusIndex',
-    /* focusedIndex */ state.focusedIndex
+    /* method */ 'setFocusedIndex',
+    /* oldIndex */ oldFocusedIndex,
+    /* newIndex */ state.focusedIndex
   );
 };
 
@@ -12293,7 +12354,7 @@ const focusNext$4 = async (state) => {
   if (state.focusedIndex === state.dirents.length - 1) {
     return
   }
-  await focusIndex$4(state, state.focusedIndex + 1);
+  await focusIndex$5(state, state.focusedIndex + 1);
 };
 
 const focusPrevious$4 = async (state) => {
@@ -12302,12 +12363,12 @@ const focusPrevious$4 = async (state) => {
       if (state.dirents.length === 0) {
         break
       }
-      await focusIndex$4(state, state.dirents.length - 1);
+      await focusIndex$5(state, state.dirents.length - 1);
       break
     case 0:
       break
     default:
-      await focusIndex$4(state, state.focusedIndex - 1);
+      await focusIndex$5(state, state.focusedIndex - 1);
       break
   }
 };
@@ -12316,7 +12377,7 @@ const focusFirst$4 = async (state) => {
   if (state.dirents.length === 0 || state.focusedIndex === 0) {
     return
   }
-  await focusIndex$4(state, 0);
+  await focusIndex$5(state, 0);
 };
 
 const focusLast$4 = async (state) => {
@@ -12326,7 +12387,7 @@ const focusLast$4 = async (state) => {
   ) {
     return
   }
-  await focusIndex$4(state, state.dirents.length - 1);
+  await focusIndex$5(state, state.dirents.length - 1);
 };
 
 const scrollUp = () => {};
@@ -12351,7 +12412,7 @@ const handleArrowRight = async (state) => {
       }
       const nextDirent = state.dirents[state.focusedIndex + 1];
       if (nextDirent.depth === dirent.depth + 1) {
-        await focusIndex$4(state, state.focusedIndex + 1);
+        await focusIndex$5(state, state.focusedIndex + 1);
       }
       break
   }
@@ -12365,7 +12426,7 @@ const focusParentFolder = async (state) => {
   if (parentStartIndex === -1) {
     return
   }
-  await focusIndex$4(state, parentStartIndex);
+  await focusIndex$5(state, parentStartIndex);
 };
 
 const handleArrowLeft = async (state) => {
@@ -12623,7 +12684,7 @@ var ViewletExplorer = {
   newFolder: newFolder,
   handleClick: handleClick$5,
   handleClickCurrent: handleClickCurrent,
-  focusIndex: focusIndex$4,
+  focusIndex: focusIndex$5,
   focusNext: focusNext$4,
   focusPrevious: focusPrevious$4,
   focusFirst: focusFirst$4,
@@ -12643,7 +12704,7 @@ var ViewletExplorer = {
   collapseAll: collapseAll
 };
 
-const __initialize__$G = () => {
+const __initialize__$H = () => {
   register$2(142, wrapViewletCommand('Explorer', focusNext$4));
   register$2(143, wrapViewletCommand('Explorer', focusPrevious$4));
   register$2(144, wrapViewletCommand('Explorer', scrollUp));
@@ -12679,28 +12740,28 @@ const __initialize__$G = () => {
 
 var ViewletExplorer_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$G
+  __initialize__: __initialize__$H
 };
 
-const state$a = {
+const state$7 = {
   count: 0,
   decorations: [],
   listeners: [],
 };
 
 const updateDecorations = () => {
-  for (const listener of state$a.listeners) {
+  for (const listener of state$7.listeners) {
     listener();
   }
 };
 
-const __initialize__$F = () => {
+const __initialize__$G = () => {
   register$2(1300, updateDecorations);
 };
 
 var SourceControl_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$F
+  __initialize__: __initialize__$G
 };
 
 const name$k = 'Terminal';
@@ -12729,17 +12790,17 @@ const contentLoadedEffects$2 = async (state) => {
   send$2(
     /* createTerminal */ 'Terminal.create',
     /* id */ state.id,
-    /* cwd */ state$z.workspacePath
+    /* cwd */ state$w.workspacePath
   );
 };
 
-const handleData$1 = (state, data) => {
+const handleData$1 = async (state, data) => {
   // Terminal.handleData(state, data)
   const parsedData = new Uint8Array(data.data);
-  send$1([
+  await invoke$1(
     /* ViewletTerminal.write */ 9922,
-    /* data */ parsedData,
-  ]);
+    /* data */ parsedData
+  );
 };
 
 const write = async (state, input) => {
@@ -12772,11 +12833,11 @@ const resize$8 = async (state, width, height) => {
   // Terminal.resize(state, width, height)
 };
 
-const clear$2 = (state) => {
-  send$1([
+const clear$2 = async (state) => {
+  await invoke$1(
     /* ViewletTerminal.write */ 9922,
-    /* data */ new TextEncoder().encode('TODO clear terminal'),
-  ]);
+    /* data */ new TextEncoder().encode('TODO clear terminal')
+  );
 };
 
 var ViewletTerminal = {
@@ -12793,14 +12854,14 @@ var ViewletTerminal = {
   clear: clear$2
 };
 
-const __initialize__$E = () => {
+const __initialize__$F = () => {
   register$2(4870, wrapViewletCommand('Terminal', write));
   register$2(4871 , wrapViewletCommand('Terminal', clear$2));
 };
 
 var ViewletTerminal_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$E
+  __initialize__: __initialize__$F
 };
 
 const open$1 = () => {
@@ -12811,7 +12872,7 @@ const close$2 = () => {
   console.log('TODO close color picker');
 };
 
-const __initialize__$D = () => {
+const __initialize__$E = () => {
   register$2(1400, open$1);
   register$2(1401, close$2);
 
@@ -12819,7 +12880,7 @@ const __initialize__$D = () => {
 
 var ColorPicker_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$D
+  __initialize__: __initialize__$E
 };
 
 const install = (id) => {
@@ -13190,7 +13251,7 @@ const handleInput$1 = async (state, value) => {
   }
 };
 
-const focusIndex$3 = (state, index) => {
+const focusIndex$4 = (state, index) => {
   if (index === -1) {
     return {
       ...state,
@@ -13233,14 +13294,14 @@ const focusIndex$3 = (state, index) => {
 
 // TODO lazyload this
 const handleClick$4 = (state, index) => {
-  return focusIndex$3(state, index)
+  return focusIndex$4(state, index)
 };
 
 const focusNext$3 = (state) => {
   if (state.focusedIndex === state.filteredExtensions.length - 1) {
     return state
   }
-  return focusIndex$3(state, state.focusedIndex + 1)
+  return focusIndex$4(state, state.focusedIndex + 1)
 };
 
 const focusNextPage = (state) => {
@@ -13251,14 +13312,14 @@ const focusNextPage = (state) => {
     state.maxLineY + (state.maxLineY - state.minLineY) - 2,
     state.filteredExtensions.length - 1
   );
-  return focusIndex$3(state, indexNextPage)
+  return focusIndex$4(state, indexNextPage)
 };
 
 const focusPrevious$3 = (state) => {
   if (state.focusedIndex === 0 || state.focusedIndex === -1) {
     return state
   }
-  return focusIndex$3(state, state.focusedIndex - 1)
+  return focusIndex$4(state, state.focusedIndex - 1)
 };
 
 const focusPreviousPage = (state) => {
@@ -13270,21 +13331,21 @@ const focusPreviousPage = (state) => {
     state.minLineY - (state.maxLineY - state.minLineY) + 1,
     0
   );
-  return focusIndex$3(state, indexPreviousPage)
+  return focusIndex$4(state, indexPreviousPage)
 };
 
 const focusFirst$3 = (state) => {
   if (state.filteredExtensions.length === 0) {
     return state
   }
-  return focusIndex$3(state, 0)
+  return focusIndex$4(state, 0)
 };
 
 const focusLast$3 = (state) => {
   if (state.filteredExtensions.length === 0) {
     return state
   }
-  return focusIndex$3(state, state.filteredExtensions.length - 1)
+  return focusIndex$4(state, state.filteredExtensions.length - 1)
 };
 
 // TODO show error / warning  when installment fails / times out
@@ -13621,7 +13682,7 @@ var ViewletExtensions = {
   contentLoaded: contentLoaded$i,
   dispose: dispose$g,
   handleInput: handleInput$1,
-  focusIndex: focusIndex$3,
+  focusIndex: focusIndex$4,
   handleClick: handleClick$4,
   focusNext: focusNext$3,
   focusNextPage: focusNextPage,
@@ -13646,7 +13707,7 @@ var ViewletExtensions = {
   render: render$b
 };
 
-const __initialize__$C = () => {
+const __initialize__$D = () => {
   register$2(860, wrapViewletCommand('Extensions', openSuggest));
   register$2(861, wrapViewletCommand('Extensions', closeSuggest));
   register$2(862, wrapViewletCommand('Extensions', toggleSuggest));
@@ -13655,7 +13716,7 @@ const __initialize__$C = () => {
   register$2(865, wrapViewletCommand('Extensions', handleInstall));
   register$2(866, wrapViewletCommand('Extensions', handleUninstall));
   register$2(867, wrapViewletCommand('Extensions', handleClick$4));
-  register$2(868, wrapViewletCommand('Extensions', focusIndex$3));
+  register$2(868, wrapViewletCommand('Extensions', focusIndex$4));
   register$2(869, wrapViewletCommand('Extensions', focusFirst$3));
   register$2(870, wrapViewletCommand('Extensions', focusLast$3));
   register$2(871, wrapViewletCommand('Extensions', focusPrevious$3));
@@ -13670,49 +13731,42 @@ const __initialize__$C = () => {
 
 var ViewletExtensions_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$C
+  __initialize__: __initialize__$D
 };
 
-const state$9 = {
-  async readText() {
-    let text;
-    try {
-      // @ts-ignore
-      text = await navigator.clipboard.readText();
-    } catch (error) {
-      if (error.message === 'Read permission denied.') {
-        console.warn(
-          'Failed to paste text: The Browser disallowed reading from clipboard'
-        );
-      } else if (
-        error.message === 'navigator.clipboard.readText is not a function'
-      ) {
-        console.warn(
-          'Failed to paste text: The Clipboard Api is not available in Firefox'
-        );
-      } else {
-        console.warn(error);
-      }
-      return
-    }
-    return text
-  },
-  async writeText(path) {
-    try {
+const readText = async () => {
+  let text;
+  try {
+    // @ts-ignore
+    text = await navigator.clipboard.readText();
+  } catch (error) {
+    // @ts-ignore
+    if (error.message === 'Read permission denied.') {
+      console.warn(
+        'Failed to paste text: The Browser disallowed reading from clipboard'
+      );
+    } else if (
       // @ts-ignore
-      await navigator.clipboard.writeText(path);
-    } catch (error) {
+      error.message === 'navigator.clipboard.readText is not a function'
+    ) {
+      console.warn(
+        'Failed to paste text: The Clipboard Api is not available in Firefox'
+      );
+    } else {
       console.warn(error);
     }
-  },
-};
-
-const readText = () => {
-  return state$9.readText()
+    return
+  }
+  return text
 };
 
 const writeText = async (path) => {
-  await state$9.writeText(path);
+  try {
+    // @ts-ignore
+    await navigator.clipboard.writeText(path);
+  } catch (error) {
+    console.warn(error);
+  }
 };
 
 const writeNativeFiles = (type, files) => {
@@ -13727,7 +13781,7 @@ const readNativeFiles = () => {
   return invoke$2(/* command */ 'ClipBoard.readFiles')
 };
 
-const __initialize__$B = () => {
+const __initialize__$C = () => {
   register$2(240, readText);
   register$2(241, writeText);
   register$2(243, writeNativeFiles);
@@ -13736,7 +13790,7 @@ const __initialize__$B = () => {
 
 var ClipBoard_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$B
+  __initialize__: __initialize__$C
 };
 
 class HTTPError extends Error {
@@ -14083,26 +14137,13 @@ const createInstance = (defaults) => {
 };
 const ky = createInstance();
 
-const state$8 = {
-  async getJson(url, options) {
+const getJson$3 = async (url, options = {}) => {
+  try {
     // cannot use ky(url).json() because it sets "accept: application/json"
     // which doesn't work with preload, see
     // https://stackoverflow.com/questions/41655955/why-are-preload-link-not-working-for-json-requests#answer-48645748
     const response = await ky(url, options);
     return response.json()
-  },
-  async getText(url, options) {
-    return ky(url, options).text()
-  },
-};
-
-/**
- * @throws
- */
-const getJson$3 = async (url, options = {}) => {
-  try {
-    const result = await state$8.getJson(url, options);
-    return result
   } catch (error) {
     if (
       error &&
@@ -14127,6 +14168,7 @@ const getJson$3 = async (url, options = {}) => {
         throw new Error(`Failed to request json from "${url}": ${json.message}`)
       }
     }
+    // @ts-ignore
     error.message = `Failed to request json from "${url}": ${error.message}`;
     throw error
   }
@@ -14134,8 +14176,7 @@ const getJson$3 = async (url, options = {}) => {
 
 const getText$1 = async (url, options = {}) => {
   try {
-    const result = await state$8.getText(url, options);
-    return result
+    return ky(url, options).text()
   } catch (error) {
     if (
       error &&
@@ -14149,19 +14190,22 @@ const getText$1 = async (url, options = {}) => {
         }
       )
     }
-    throw new Error(`Failed to request text from "${url}"`, { cause: error })
+    throw new Error(`Failed to request text from "${url}"`, {
+      // @ts-ignore
+      cause: error,
+    })
   }
 };
 
 // TODO only use Ajax module via ipc -> that way is is always lazyloaded
-const __initialize__$A = () => {
+const __initialize__$B = () => {
   register$2(270, getJson$3);
   register$2(271, getText$1);
 };
 
 var Ajax_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$A
+  __initialize__: __initialize__$B
 };
 
 const hydrate$1 = async () => {
@@ -14169,26 +14213,26 @@ const hydrate$1 = async () => {
   // EditorSave.onDidSave(onDidSaveEditor)
 };
 
-const __initialize__$z = () => {
+const __initialize__$A = () => {
   register$2(3380, hydrate$1);
 };
 
 var Format_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$z
+  __initialize__: __initialize__$A
 };
 
-const __initialize__$y = () => {
+const __initialize__$z = () => {
   register$2(5610, hydrate$8);
   register$2(5611, setColorTheme$1);
 };
 
 var ColorTheme_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$y
+  __initialize__: __initialize__$z
 };
 
-const __initialize__$x = () => {
+const __initialize__$y = () => {
   // TODO command necessary?
   register$2(3030, undefined);
   // TODO hydrate should be an alias for reload/load
@@ -14198,10 +14242,10 @@ const __initialize__$x = () => {
 
 var IconTheme_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$x
+  __initialize__: __initialize__$y
 };
 
-const __initialize__$w = () => {
+const __initialize__$x = () => {
   register$2(7400, show$4);
   register$2(7401, hide$1);
   register$2(7403, selectIndex$3);
@@ -14209,18 +14253,21 @@ const __initialize__$w = () => {
   register$2(7405, focusPrevious$6);
   register$2(7406, focusFirst$6);
   register$2(7407, focusLast$6);
-  register$2(7408, focusIndex$6);
+  register$2(7408, focusIndex$7);
   register$2(7409, handleMouseEnter$1);
 };
 
 var Menu_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$w
+  __initialize__: __initialize__$x
 };
 
 // TODO menu should not be needed initially, only when item is selected and menu is opened
 
-const state$7 = {
+const state$6 = {
+  /**
+   * @type{any[]}
+   */
   titleBarEntries: [],
   focusedIndex: 0,
   isMenuOpen: false,
@@ -14230,8 +14277,8 @@ const state$7 = {
 // TODO only compute once if is electron and filter out during build process
 
 const getEntries = async () => {
-  state$7.titleBarEntries = await getMenuEntries$h('titleBar');
-  return state$7.titleBarEntries
+  state$6.titleBarEntries = await getMenuEntries$h('titleBar');
+  return state$6.titleBarEntries
 };
 
 /**
@@ -14243,9 +14290,9 @@ const openMenuAtIndex = async (index, shouldBeFocused) => {
   // TODO send renderer process
   // 1. open menu, items to show
   // 2. focus menu
-  const id = state$7.titleBarEntries[index].id;
+  const id = state$6.titleBarEntries[index].id;
   const items = await getMenuEntries$h(id);
-  state$l.menus = [];
+  state$i.menus = [];
   const bounds = await invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'TitleBar',
@@ -14263,7 +14310,7 @@ const openMenuAtIndex = async (index, shouldBeFocused) => {
     id,
     items,
     focusedIndex: menuFocusedIndex,
-    level: state$l.menus.length,
+    level: state$i.menus.length,
     x,
     y,
   });
@@ -14271,7 +14318,7 @@ const openMenuAtIndex = async (index, shouldBeFocused) => {
     /* Viewlet.send */ 3024,
     /* id */ 'TitleBar',
     /* method */ 'menuOpen',
-    /* unFocusIndex */ state$7.focusedIndex,
+    /* unFocusIndex */ state$6.focusedIndex,
     /* index */ index,
     /* level */ menu.level,
     /* menuItems */ menu.items,
@@ -14282,55 +14329,55 @@ const openMenuAtIndex = async (index, shouldBeFocused) => {
     /* width */ width,
     /* height */ height,
   ]);
-  state$7.isMenuOpen = true;
+  state$6.isMenuOpen = true;
 };
 
 /**
  * @param {boolean} focus
  */
 const openMenu = async (focus) => {
-  if (state$7.focusedIndex === -1) {
+  if (state$6.focusedIndex === -1) {
     return
   }
-  await openMenuAtIndex(state$7.focusedIndex, focus);
+  await openMenuAtIndex(state$6.focusedIndex, focus);
 };
 
-const closeMenu = (keepFocus) => {
+const closeMenu = async (keepFocus) => {
   // TODO send to renderer process
   // 1. close menu
   // 2. focus top level entry
-  const focusIndex = keepFocus ? state$7.focusedIndex : -1;
+  const focusIndex = keepFocus ? state$6.focusedIndex : -1;
   // TODO use Viewlet.dispose instead
-  send$1([
+  state$6.isMenuOpen = false;
+  await invoke$1(
     /* Viewlet.send */ 3024,
     /* id */ 'TitleBar',
     /* method */ 'menuClose',
-    /* unFocusIndex */ state$7.focusedIndex,
-    /* focusIndex */ focusIndex,
-  ]);
-  state$7.isMenuOpen = false;
+    /* unFocusIndex */ state$6.focusedIndex,
+    /* focusIndex */ focusIndex
+  );
 };
 
-const focusIndex$2 = async (index) => {
-  if (state$7.isMenuOpen) {
+const focusIndex$3 = async (index) => {
+  if (state$6.isMenuOpen) {
     await openMenuAtIndex(index, /* focus */ false);
   } else {
-    send$1([
+    await invoke$1(
       /* TitleBarMenuBar.focusIndex */ 1371,
-      /* unFocusIndex */ state$7.focusedIndex,
-      /* index */ index,
-    ]);
+      /* unFocusIndex */ state$6.focusedIndex,
+      /* index */ index
+    );
   }
-  state$7.focusedIndex = index;
+  state$6.focusedIndex = index;
 };
 
 const toggleIndex = async (index) => {
-  if (state$7.isMenuOpen && state$7.focusedIndex === index) {
+  if (state$6.isMenuOpen && state$6.focusedIndex === index) {
     closeMenu(/* keepFocus */ true);
   } else {
     await openMenuAtIndex(index, /* focus */ false);
   }
-  state$7.focusedIndex = index;
+  state$6.focusedIndex = index;
 };
 
 const focus$1 = async () => {
@@ -14343,10 +14390,10 @@ const getIndexToFocusPreviousStartingAt = (items, index) => {
 
 const focusPrevious$2 = async () => {
   const indexToFocus = getIndexToFocusPreviousStartingAt(
-    state$7.titleBarEntries,
-    state$7.focusedIndex - 1
+    state$6.titleBarEntries,
+    state$6.focusedIndex - 1
   );
-  await focusIndex$2(indexToFocus);
+  await focusIndex$3(indexToFocus);
 };
 
 const getIndexToFocusNextStartingAt = (items, index) => {
@@ -14354,29 +14401,28 @@ const getIndexToFocusNextStartingAt = (items, index) => {
 };
 
 const focusNext$2 = async () => {
-  console.log('ff next');
   const indexToFocus = getIndexToFocusNextStartingAt(
-    state$7.titleBarEntries,
-    state$7.focusedIndex + 1
+    state$6.titleBarEntries,
+    state$6.focusedIndex + 1
   );
-  await focusIndex$2(indexToFocus);
+  await focusIndex$3(indexToFocus);
 };
 
 const focusFirst$2 = async () => {
-  const indexToFocus = getIndexToFocusNextStartingAt(state$7.titleBarEntries, 0);
-  await focusIndex$2(indexToFocus);
+  const indexToFocus = getIndexToFocusNextStartingAt(state$6.titleBarEntries, 0);
+  await focusIndex$3(indexToFocus);
 };
 
 const focusLast$2 = async () => {
   const indexToFocus = getIndexToFocusPreviousStartingAt(
-    state$7.titleBarEntries,
-    state$7.titleBarEntries.length - 1
+    state$6.titleBarEntries,
+    state$6.titleBarEntries.length - 1
   );
-  await focusIndex$2(indexToFocus);
+  await focusIndex$3(indexToFocus);
 };
 
 const handleKeyArrowLeft = async () => {
-  if (state$7.isMenuOpen && state$l.menus.length > 1) {
+  if (state$6.isMenuOpen && state$i.menus.length > 1) {
     return
   }
   // TODO menu collapse
@@ -14384,7 +14430,7 @@ const handleKeyArrowLeft = async () => {
 };
 
 const handleKeyArrowUp = () => {
-  if (!state$7.isMenuOpen) {
+  if (!state$6.isMenuOpen) {
     return
   }
   focusPrevious$6();
@@ -14392,12 +14438,12 @@ const handleKeyArrowUp = () => {
 
 const handleKeyArrowRight = async () => {
   console.log('arrow right');
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     // if menu can open sub menu to the right -> do that
-    const menu = state$l.menus.at(-1);
+    const menu = state$i.menus.at(-1);
     const item = menu.items[menu.focusedIndex];
     if (item.flags === /* SubMenu */ 4) {
-      await showSubMenu(state$l.menus.length - 1, menu.focusedIndex);
+      await showSubMenu(state$i.menus.length - 1, menu.focusedIndex);
       return
     }
   }
@@ -14405,7 +14451,7 @@ const handleKeyArrowRight = async () => {
 };
 
 const handleKeyHome = async () => {
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     focusFirst$6();
   } else {
     await focusFirst$2();
@@ -14414,7 +14460,7 @@ const handleKeyHome = async () => {
 
 // TODO this is also use for pagedown -> maybe find a better name for this function
 const handleKeyEnd = async () => {
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     focusLast$6();
   } else {
     await focusLast$2();
@@ -14423,7 +14469,7 @@ const handleKeyEnd = async () => {
 
 // TODO this is same as handle key enter -> merge the functions
 const handleKeySpace = async () => {
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     await selectCurrent$1();
   } else {
     openMenu(/* focus */ true);
@@ -14431,7 +14477,7 @@ const handleKeySpace = async () => {
 };
 
 const handleKeyEnter = async () => {
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     await selectCurrent$1();
   } else {
     openMenu(/* focus */ true);
@@ -14439,25 +14485,25 @@ const handleKeyEnter = async () => {
 };
 
 const handleKeyEscape = () => {
-  if (!state$7.isMenuOpen) {
+  if (!state$6.isMenuOpen) {
     return
   }
   closeMenu(/* keepFocus */ true);
 };
 
 const handleKeyArrowDown = async () => {
-  if (state$7.isMenuOpen) {
+  if (state$6.isMenuOpen) {
     focusNext$6();
   } else {
     await openMenu(/* focus */ true);
   }
 };
 
-const __initialize__$v = () => {
+const __initialize__$w = () => {
   register$2(4610, toggleIndex);
   register$2(4611, undefined);
   register$2(4612, focus$1);
-  register$2(4613, focusIndex$2);
+  register$2(4613, focusIndex$3);
   register$2(4614, focusPrevious$2);
   register$2(4615, focusNext$2);
   register$2(4616, closeMenu);
@@ -14475,16 +14521,16 @@ const __initialize__$v = () => {
 
 var TitleBarMenuBar_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$v
+  __initialize__: __initialize__$w
 };
 
-const __initialize__$u = () => {
+const __initialize__$v = () => {
   register$2(440, handleError$1);
 };
 
 var ErrorHandling_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$u
+  __initialize__: __initialize__$v
 };
 
 // TODO maybe rename this module to Focus
@@ -14496,55 +14542,49 @@ const PART_STATUS_BAR = 4;
 const PART_SIDE_BAR = 5;
 const PART_ACTIVITY_BAR = 6;
 
-const state$6 = {
+const state$5 = {
   focusedPart: PART_TITLE_BAR,
 };
 
-const focusActivityBar = () => {
-  send$1([/* ActivityBar.focus */ 717115]);
+const focusActivityBar = async () => {
+  await invoke$1(/* ActivityBar.focus */ 717115);
 };
 
-const focusStatusBar = () => {
-  send$1([/* StatusBar.focus */ 8882]);
+const focusStatusBar = async () => {
+  await invoke$1(/* StatusBar.focus */ 8882);
 };
 
-const focusPanel = () => {
-  send$1([/* Panel.focus */ 6664]);
+const focusPanel = async () => {
+  await invoke$1(/* Panel.focus */ 6664);
 };
 
-const focusSideBar = () => {
-  send$1([/* SideBar.focus */ 5554]);
+const focusSideBar = async () => {
+  await invoke$1(/* SideBar.focus */ 5554);
 };
 
-const focusTitleBar = () => {
-  send$1([/* TitleBar.focus */ 1331]);
+const focusTitleBar = async () => {
+  await invoke$1(/* TitleBar.focus */ 1331);
 };
 
-const focusMain = () => {
-  send$1([/* Main.focus */ 2145]);
+const focusMain = async () => {
+  await invoke$1(/* Main.focus */ 2145);
 };
 
 const focusPart = (part) => {
-  state$6.focusedPart = part;
-  switch (state$6.focusedPart) {
+  state$5.focusedPart = part;
+  switch (state$5.focusedPart) {
     case PART_TITLE_BAR:
-      focusTitleBar();
-      break
+      return focusTitleBar()
     case PART_MAIN:
-      focusMain();
-      break
+      return focusMain()
     case PART_PANEL:
-      focusPanel();
-      break
+      return focusPanel()
     case PART_STATUS_BAR:
-      focusStatusBar();
-      break
+      return focusStatusBar()
     case PART_SIDE_BAR:
-      focusSideBar();
-      break
+      return focusSideBar()
     case PART_ACTIVITY_BAR:
-      focusActivityBar();
-      break
+      return focusActivityBar()
     default:
       throw console.warn(`unknown part ${part}`)
   }
@@ -14605,22 +14645,22 @@ const getVisiblePartPrevious = (part) => {
 
 const getCurrentPart = () => {
   // TODO ask renderer process
-  return state$6.focusedPart
+  return state$5.focusedPart
 };
 
-const focusNextPart = () => {
+const focusNextPart = async () => {
   const currentPart = getCurrentPart();
   const nextPart = getVisiblePartNext(currentPart);
-  focusPart(nextPart);
+  await focusPart(nextPart);
 };
 
-const focusPreviousPart = () => {
+const focusPreviousPart = async () => {
   const currentPart = getCurrentPart();
   const previousPart = getVisiblePartPrevious(currentPart);
-  focusPart(previousPart);
+  await focusPart(previousPart);
 };
 
-const __initialize__$t = () => {
+const __initialize__$u = () => {
   register$2(5740, focusPreviousPart);
   register$2(5741, focusNextPart);
   register$2(5742, focusActivityBar);
@@ -14633,10 +14673,10 @@ const __initialize__$t = () => {
 
 var Navigation_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$t
+  __initialize__: __initialize__$u
 };
 
-const CACHE_NAME = 'lvce-runtime-8db9fb4';
+const CACHE_NAME = 'lvce-runtime-09bf9c7';
 
 const shouldIgnoreError = (error) => {
   // Firefox throws dom exception in private mode
@@ -14647,37 +14687,6 @@ const shouldIgnoreError = (error) => {
   )
 };
 
-const state$5 = {
-  async getJson(key) {
-    try {
-      const response = await getResponse(key);
-      if (!response) {
-        return undefined
-      }
-      const json = await response.json();
-      return json
-    } catch (error) {
-      if (shouldIgnoreError(error)) {
-        return undefined
-      }
-      throw new Error(`Failed to get json from cache "${key}"`, {
-        cause: error,
-      })
-    }
-  },
-  async setJson(key, value) {
-    try {
-      await setResponse(key, JSON.stringify(value), 'application/json');
-    } catch (error) {
-      if (shouldIgnoreError(error)) {
-        return
-      }
-      throw new Error(`Failed to put json into cache "${key}"`, {
-        cause: error,
-      })
-    }
-  },
-};
 // TODO when caches is not defined -> should return undefined
 
 const getCache = async () => {
@@ -14697,11 +14706,23 @@ const getResponse = async (key) => {
   return response
 };
 
-/**
- * @throws
- */
-const getJson$2 = (key) => {
-  return state$5.getJson(key)
+const getJson$2 = async (key) => {
+  try {
+    const response = await getResponse(key);
+    if (!response) {
+      return undefined
+    }
+    const json = await response.json();
+    return json
+  } catch (error) {
+    if (shouldIgnoreError(error)) {
+      return undefined
+    }
+    throw new Error(`Failed to get json from cache "${key}"`, {
+      // @ts-ignore
+      cause: error,
+    })
+  }
 };
 
 const setResponse = async (key, value, contentType) => {
@@ -14732,12 +14753,19 @@ const setResponse = async (key, value, contentType) => {
 };
 
 const setJson$1 = async (key, value) => {
-  return state$5.setJson(key, value)
+  try {
+    await setResponse(key, JSON.stringify(value), 'application/json');
+  } catch (error) {
+    if (shouldIgnoreError(error)) {
+      return
+    }
+    throw new Error(`Failed to put json into cache "${key}"`, {
+      // @ts-ignore
+      cause: error,
+    })
+  }
 };
 
-/**
- * @throws
- */
 const clearCache = async () => {
   if (typeof caches === 'undefined') {
     return
@@ -14749,6 +14777,7 @@ const clearCache = async () => {
       return
     }
     throw new Error('Failed to clear cache', {
+      // @ts-ignore
       cause: error,
     })
   }
@@ -14756,7 +14785,7 @@ const clearCache = async () => {
 
 // TODO only use CacheStorage module via ipc -> that way is is always lazyloaded
 
-const __initialize__$s = () => {
+const __initialize__$t = () => {
   register$2(6800, clearCache);
   register$2(6801, setJson$1);
   register$2(6802, getJson$2);
@@ -14764,7 +14793,7 @@ const __initialize__$s = () => {
 
 var CacheStorage_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$s
+  __initialize__: __initialize__$t
 };
 
 const clear$1 = async () => {
@@ -14806,7 +14835,7 @@ const setJson = async (key, value) => {
 
 // TODO only use LocalStorage module via ipc -> that way is is always lazyloaded
 
-const __initialize__$r = () => {
+const __initialize__$s = () => {
   register$2(6900, clear$1);
   register$2(6901, setJson);
   register$2(6902, getJson$1);
@@ -14816,7 +14845,7 @@ const __initialize__$r = () => {
 
 var LocalStorage_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$r
+  __initialize__: __initialize__$s
 };
 
 const clear = async () => {
@@ -14840,24 +14869,24 @@ const getJson = async (key) => {
 
 // TODO only use SessionStorage module via ipc -> that way is is always lazyloaded
 
-const __initialize__$q = () => {
+const __initialize__$r = () => {
   register$2(6755, clear);
   register$2(6756, getJson);
 };
 
 var SessionStorage_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$q
+  __initialize__: __initialize__$r
 };
 
-const __initialize__$p = () => {
+const __initialize__$q = () => {
   register$2(67330, resolve);
   register$2(67331, reject);
 };
 
 var Callback_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$p
+  __initialize__: __initialize__$q
 };
 
 /**
@@ -15317,13 +15346,13 @@ const getCommandInfo = (id) => {
   }
 };
 
-const __initialize__$o = () => {
+const __initialize__$p = () => {
   register$2(1592, getCommandInfo);
 };
 
 var CommandInfo_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$o
+  __initialize__: __initialize__$p
 };
 
 const state$4 = {
@@ -15427,7 +15456,7 @@ const handleClick$3 = async (index) => {
   }
 };
 
-const __initialize__$n = () => {
+const __initialize__$o = () => {
   register$2(1492, openFolder);
   register$2(1493, showAbout);
   register$2(1494, showMessage);
@@ -15437,10 +15466,10 @@ const __initialize__$n = () => {
 
 var Dialog_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$n
+  __initialize__: __initialize__$o
 };
 
-const __initialize__$m = () => {
+const __initialize__$n = () => {
   register$2(7633, setPath);
   register$2(7634, hydrate$b);
   register$2(7635, setUri);
@@ -15448,7 +15477,7 @@ const __initialize__$m = () => {
 
 var Workspace_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$m
+  __initialize__: __initialize__$n
 };
 
 const transparent = (color, factor) => {
@@ -15554,16 +15583,16 @@ const createColorThemeFromJson = (colorThemeId, colorThemeJson) => {
 //   }) //?.
 // }
 
-const __initialize__$l = () => {
+const __initialize__$m = () => {
   register$2(232, createColorThemeFromJson);
 };
 
 var ColorThemeFromJson_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$l
+  __initialize__: __initialize__$m
 };
 
-const __initialize__$k = () => {
+const __initialize__$l = () => {
   register$2(5430, getRecentlyOpened$2);
   register$2(5432, clearRecentlyOpened);
   register$2(5433, addToRecentlyOpened);
@@ -15572,13 +15601,13 @@ const __initialize__$k = () => {
 
 var RecentlyOpened_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$k
+  __initialize__: __initialize__$l
 };
 
 // TODO who calls this?
 // TODO how to return value?
 
-const __initialize__$j = () => {
+const __initialize__$k = () => {
   register$2(501, readFile);
   register$2(502, remove);
   register$2(503, readDirWithFileTypes);
@@ -15588,12 +15617,12 @@ const __initialize__$j = () => {
 
 var FileSystem_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$j
+  __initialize__: __initialize__$k
 };
 
 const findInWorkspace = async (searchTerm) => {
   // TODO ask shared process
-  const root = state$z.workspacePath;
+  const root = state$w.workspacePath;
   const result = await invoke$2(
     /* Search.search */ 'Search.search',
     /* folder */ root,
@@ -15602,15 +15631,15 @@ const findInWorkspace = async (searchTerm) => {
   return result
 };
 
-const __initialize__$i = () => {
+const __initialize__$j = () => {
   register$2(5200, findInWorkspace);
   console.log('register command');
-  console.log(state$F.commands);
+  console.log(state$C.commands);
 };
 
 var FindInWorkspace_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$i
+  __initialize__: __initialize__$j
 };
 
 const executeDiagnosticProvider = async (editor) => {
@@ -15646,13 +15675,13 @@ const hydrate = () => {
 
 // see also https://tink.uk/using-the-web-speech-api-to-simulate-css-speech-support/
 
-const __initialize__$h = () => {
+const __initialize__$i = () => {
   register$2(8786, hydrate);
 };
 
 var EditorDiagnostics_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$h
+  __initialize__: __initialize__$i
 };
 
 const executePrepareRenameProvider = async (editor, offset) => {
@@ -15695,11 +15724,11 @@ const open = async (editor) => {
     const y$1 = y(editor, editor.cursor);
     // const prepareRenameResult = await prepareRename(editor)
     // console.log({ prepareRenameResult })
-    send$1([
+    await invoke$1(
       /* EditorRename.openWidget */ 4512,
       /* x */ x$1,
-      /* y */ y$1,
-    ]);
+      /* y */ y$1
+    );
   } else {
     // TODO also show error when promise rejects
     await execute$1(
@@ -15754,11 +15783,11 @@ const finish = async (editor) => {
   // console.log({ workspaceEdits })
 };
 
-const abort = () => {
-  send$1([/* EditorRename.closeWidget */ 4514]);
+const abort = async () => {
+  await invoke$1(/* EditorRename.closeWidget */ 4514);
 };
 
-const __initialize__$g = () => {
+const __initialize__$h = () => {
   register$2(3300, open);
   register$2(3301, finish);
   register$2(3302, abort);
@@ -15766,27 +15795,27 @@ const __initialize__$g = () => {
 
 var EditorRename_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$g
+  __initialize__: __initialize__$h
 };
 
-const show$1 = (editor, message, position) => {
+const show$1 = async (editor, message, position) => {
   const x$1 = x(editor, position);
   const y$1 = y(editor, position);
-  send$1([
+  await invoke$1(
     /* EditorError.show */ 3700,
     /* message */ message,
     /* x */ x$1,
-    /* y */ y$1,
-  ]);
+    /* y */ y$1
+  );
 };
 
-const __initialize__$f = () => {
+const __initialize__$g = () => {
   register$2(3900, show$1);
 };
 
 var EditorError_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$f
+  __initialize__: __initialize__$g
 };
 
 // TODO should avoid many promises somehow
@@ -15816,22 +15845,22 @@ const getKeyBindings = async () => {
   return keyBindings
 };
 
-const __initialize__$e = () => {
+const __initialize__$f = () => {
   register$2(8961, getKeyBindings);
 };
 
 var KeyBindingsInitial_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$e
+  __initialize__: __initialize__$f
 };
 
-const __initialize__$d = () => {
+const __initialize__$e = () => {
   register$2(6661, hydrate$4);
 };
 
 var SaveState_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$d
+  __initialize__: __initialize__$e
 };
 
 const acceptInput$1 = async (text) => {
@@ -15974,23 +16003,23 @@ var ViewletSourceControl = {
   render: render$a
 };
 
-const __initialize__$c = () => {
+const __initialize__$d = () => {
   register$2(6532, wrapViewletCommand('Source Control',acceptInput));
 };
 
 var ViewletSourceControl_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$c
+  __initialize__: __initialize__$d
 };
 
-const __initialize__$b = () => {
+const __initialize__$c = () => {
   register$2(5783, hydrate$3);
   register$2(5784, uninstall$1);
 };
 
 var ServiceWorker_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$b
+  __initialize__: __initialize__$c
 };
 
 const state$3 = {
@@ -16043,14 +16072,14 @@ const hide = async () => {
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
 
-const __initialize__$a = () => {
+const __initialize__$b = () => {
   register$2(9081, show);
   register$2(9082, hide);
 };
 
 var ImagePreview_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$a
+  __initialize__: __initialize__$b
 };
 
 /**
@@ -16161,13 +16190,13 @@ const decode = (encoded) => {
   return decoded
 };
 
-const __initialize__$9 = () => {
+const __initialize__$a = () => {
   register$2(7890, decode);
 };
 
 var Base64_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$9
+  __initialize__: __initialize__$a
 };
 
 function createBlob(parts, properties) {
@@ -16209,22 +16238,22 @@ const base64StringToBlob = (base64String) => {
   return base64StringToBlob$1(base64String)
 };
 
-const __initialize__$8 = () => {
+const __initialize__$9 = () => {
   register$2(4356, base64StringToBlob);
 };
 
 var Blob_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$8
+  __initialize__: __initialize__$9
 };
 
-const __initialize__$7 = () => {
+const __initialize__$8 = () => {
   register$2(1370, openNativeFolder);
 };
 
 var Open_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$7
+  __initialize__: __initialize__$8
 };
 
 const playBell = async () => {
@@ -16232,13 +16261,13 @@ const playBell = async () => {
   await invoke$1(/* Audio.play */ 3211, /* src */ src);
 };
 
-const __initialize__$6 = () => {
+const __initialize__$7 = () => {
   register$2(4444, playBell);
 };
 
 var Audio_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$6
+  __initialize__: __initialize__$7
 };
 
 const create$g = (id, uri, left, top, width, height) => {
@@ -16408,14 +16437,14 @@ var ViewletSideBar = {
   resize: resize$5
 };
 
-const __initialize__$5 = () => {
+const __initialize__$6 = () => {
   register$2(553, wrapViewletCommand('SideBar', showOrHideViewlet));
   register$2(554, wrapViewletCommand('SideBar', openViewlet));
 };
 
 var ViewletSideBar_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$5
+  __initialize__: __initialize__$6
 };
 
 const state$2 = Object.create(null);
@@ -16616,22 +16645,22 @@ var ViewletStatusBar = {
   render: render$9
 };
 
-const __initialize__$4 = () => {
+const __initialize__$5 = () => {
   register$2(2260, wrapViewletCommand('StatusBar', updateStatusBarItems));
 };
 
 var ViewletStatusBar_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$4
+  __initialize__: __initialize__$5
 };
 
-const __initialize__$3 = () => {
+const __initialize__$4 = () => {
   register$2(3444, execute);
 };
 
 var Listener_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$3
+  __initialize__: __initialize__$4
 };
 
 const name$g = 'Search';
@@ -16792,14 +16821,14 @@ var ViewletSearch = {
   render: render$8
 };
 
-const __initialize__$2 = () => {
+const __initialize__$3 = () => {
   register$2(9444, wrapViewletCommand('Search', handleInput));
   register$2(9445, wrapViewletCommand('Search', handleClick));
 };
 
 var ViewletSearch_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$2
+  __initialize__: __initialize__$3
 };
 
 const executeCompletionProvider = async (editor, offset) => {
@@ -16967,7 +16996,7 @@ const selectIndex$1 = (state, index) => {
   return select(state, completionItem)
 };
 
-const focusIndex$1 = (state, index) => {
+const focusIndex$2 = (state, index) => {
   return {
     ...state,
     focusedIndex: index,
@@ -16975,25 +17004,25 @@ const focusIndex$1 = (state, index) => {
 };
 
 const focusFirst$1 = (state) => {
-  return focusIndex$1(state, 0)
+  return focusIndex$2(state, 0)
 };
 
 const focusLast$1 = (state) => {
-  return focusIndex$1(state, state.completionItems.length - 1)
+  return focusIndex$2(state, state.completionItems.length - 1)
 };
 
 const focusPrevious$1 = (state) => {
   if (state.focusedIndex === 0) {
     return focusLast$1(state)
   }
-  return focusIndex$1(state, state.focusedIndex - 1)
+  return focusIndex$2(state, state.focusedIndex - 1)
 };
 
 const focusNext$1 = (state) => {
   if (state.focusedIndex === state.completionItems.length - 1) {
     return focusFirst$1(state)
   }
-  return focusIndex$1(state, state.focusedIndex + 1)
+  return focusIndex$2(state, state.focusedIndex + 1)
 };
 
 const hasFunctionalRender$7 = true;
@@ -17038,7 +17067,7 @@ var ViewletEditorCompletion = {
   handleSelectionChange: handleSelectionChange,
   advance: advance,
   selectIndex: selectIndex$1,
-  focusIndex: focusIndex$1,
+  focusIndex: focusIndex$2,
   focusFirst: focusFirst$1,
   focusLast: focusLast$1,
   focusPrevious: focusPrevious$1,
@@ -17048,7 +17077,7 @@ var ViewletEditorCompletion = {
   dispose: dispose$c
 };
 
-const __initialize__$1 = () => {
+const __initialize__$2 = () => {
   register$2(981, wrapViewletCommand('EditorCompletion', dispose$c));
   register$2(982, wrapViewletCommand('EditorCompletion', selectIndex$1));
   register$2(983, wrapViewletCommand('EditorCompletion', focusFirst$1));
@@ -17060,7 +17089,7 @@ const __initialize__$1 = () => {
 
 var ViewletEditorCompletion_ipc = {
   __proto__: null,
-  __initialize__: __initialize__$1
+  __initialize__: __initialize__$2
 };
 
 const name$f = 'Locations';
@@ -17256,7 +17285,7 @@ const render$6 = (oldState, newState) => {
   return changes
 };
 
-const focusIndex = (state, index) => {
+const focusIndex$1 = (state, index) => {
   return {
     ...state,
     focusedIndex: index,
@@ -17267,28 +17296,28 @@ const focusFirst = (state) => {
   if (state.displayReferences.length === 0) {
     return state
   }
-  return focusIndex(state, 0)
+  return focusIndex$1(state, 0)
 };
 
 const focusPrevious = (state) => {
   if (state.focusedIndex === 0 || state.focusedIndex === -1) {
     return state
   }
-  return focusIndex(state, state.focusedIndex - 1)
+  return focusIndex$1(state, state.focusedIndex - 1)
 };
 
 const focusNext = (state) => {
   if (state.focusedIndex === state.displayReferences.length - 1) {
     return state
   }
-  return focusIndex(state, state.focusedIndex + 1)
+  return focusIndex$1(state, state.focusedIndex + 1)
 };
 
 const focusLast = (state) => {
   if (state.focusedIndex === state.displayReferences.length - 1) {
     return state
   }
-  return focusIndex(state, state.displayReferences.length - 1)
+  return focusIndex$1(state, state.displayReferences.length - 1)
 };
 
 const selectCurrent = (state) => {
@@ -17308,7 +17337,7 @@ var ViewletLocations = {
   selectIndex: selectIndex,
   hasFunctionalRender: hasFunctionalRender$6,
   render: render$6,
-  focusIndex: focusIndex,
+  focusIndex: focusIndex$1,
   focusFirst: focusFirst,
   focusPrevious: focusPrevious,
   focusNext: focusNext,
@@ -17316,37 +17345,61 @@ var ViewletLocations = {
   selectCurrent: selectCurrent
 };
 
-const __initialize__ = () => {
+const __initialize__$1 = () => {
   register$2(7100, wrapViewletCommand('Locations', selectIndex));
   register$2(7101, wrapViewletCommand('Locations', focusFirst));
   register$2(7102, wrapViewletCommand('Locations', focusLast));
   register$2(7103, wrapViewletCommand('Locations', focusNext));
   register$2(7104, wrapViewletCommand('Locations', focusPrevious));
   register$2(7105, wrapViewletCommand('Locations', selectCurrent));
-  register$2(7106, wrapViewletCommand('Locations', focusIndex));
+  register$2(7106, wrapViewletCommand('Locations', focusIndex$1));
 };
 
 var ViewletLocations_ipc = {
   __proto__: null,
-  __initialize__: __initialize__
+  __initialize__: __initialize__$1
 };
 
-const name$e = 'RunAndDebug';
+const name$e = 'Problems';
 
-const create$b = (id) => {
+const create$b = () => {
   return {
-    id,
+    problems: [],
     disposed: false,
+    focusedIndex: -2,
   }
 };
 
+const toProblem = (diagnostic) => {
+  return diagnostic.message
+};
+
 const loadContent$b = async (state) => {
-  return state
+  const instance = state$m.instances['EditorText'];
+  if (!instance) {
+    return state
+  }
+  const editor = instance.state;
+  const diagnostics = await executeDiagnosticProvider(
+    editor
+  );
+  const problems = diagnostics.map(toProblem);
+  return {
+    ...state,
+    problems,
+  }
 };
 
 const contentLoaded$b = async (state) => {};
 
-// TODO make sure dispose is actually called
+const focusIndex = (state, index) => {
+  console.log({ index });
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+};
+
 const dispose$a = (state) => {
   return {
     ...state,
@@ -17354,30 +17407,58 @@ const dispose$a = (state) => {
   }
 };
 
-const resize$2 = (state, dimensions) => {
-  return {
-    newState: {
-      ...state,
-      ...dimensions,
-    },
-    commands: [],
+const hasFunctionalRender$5 = true;
+
+const render$5 = (oldState, newState) => {
+  console.log('render', oldState, newState);
+  const changes = [];
+  if (oldState.problems !== newState.problems) {
+    changes.push([
+      /* Viewlet.invoke */ 3024,
+      /* id */ 'Problems',
+      /* method */ 'setProblems',
+      /* problems */ newState.problems,
+    ]);
   }
+  if (oldState.focusedIndex !== newState.focusedIndex) {
+    console.log('focused idnex changed');
+    changes.push([
+      /* Viewlet.invoke */ 3024,
+      /* id */ 'Problems',
+      /* method */ 'setFocusedIndex',
+      /* focusedIndex */ newState.focusedIndex,
+    ]);
+  }
+  return changes
 };
 
-var ViewletRunAndDebug = {
+var ViewletProblems = {
   __proto__: null,
   name: name$e,
   create: create$b,
   loadContent: loadContent$b,
   contentLoaded: contentLoaded$b,
+  focusIndex: focusIndex,
   dispose: dispose$a,
-  resize: resize$2
+  hasFunctionalRender: hasFunctionalRender$5,
+  render: render$5
+};
+
+// prettier-ignore
+const __initialize__ = () => {
+  register$2(7550, wrapViewletCommand('Problems', focusIndex));
+};
+
+var ViewletProblems_ipc = {
+  __proto__: null,
+  __initialize__: __initialize__
 };
 
-const name$d = 'Debug Console';
+const name$d = 'RunAndDebug';
 
-const create$a = () => {
+const create$a = (id) => {
   return {
+    id,
     disposed: false,
   }
 };
@@ -17388,6 +17469,7 @@ const loadContent$a = async (state) => {
 
 const contentLoaded$a = async (state) => {};
 
+// TODO make sure dispose is actually called
 const dispose$9 = (state) => {
   return {
     ...state,
@@ -17395,13 +17477,54 @@ const dispose$9 = (state) => {
   }
 };
 
-var ViewletDebugConsole = {
+const resize$2 = (state, dimensions) => {
+  return {
+    newState: {
+      ...state,
+      ...dimensions,
+    },
+    commands: [],
+  }
+};
+
+var ViewletRunAndDebug = {
   __proto__: null,
   name: name$d,
   create: create$a,
   loadContent: loadContent$a,
   contentLoaded: contentLoaded$a,
-  dispose: dispose$9
+  dispose: dispose$9,
+  resize: resize$2
+};
+
+const name$c = 'Debug Console';
+
+const create$9 = () => {
+  return {
+    disposed: false,
+  }
+};
+
+const loadContent$9 = async (state) => {
+  return state
+};
+
+const contentLoaded$9 = async (state) => {};
+
+const dispose$8 = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+};
+
+var ViewletDebugConsole = {
+  __proto__: null,
+  name: name$c,
+  create: create$9,
+  loadContent: loadContent$9,
+  contentLoaded: contentLoaded$9,
+  dispose: dispose$8
 };
 
 const getOutputChannels = () => {
@@ -17413,9 +17536,9 @@ const getOutputChannels = () => {
   )
 };
 
-const name$c = 'Output';
+const name$b = 'Output';
 
-const create$9 = () => {
+const create$8 = () => {
   return {
     selectedIndex: -1,
     // TODO get list of outputChannels from extension host
@@ -17431,7 +17554,7 @@ const toExtensionHostOption = (outputChannel) => {
   }
 };
 
-const loadContent$9 = async (state) => {
+const loadContent$8 = async (state) => {
   // TODO get list of outputChannels from extension host
 
   const channels = await getOutputChannels();
@@ -17456,7 +17579,7 @@ const loadContent$9 = async (state) => {
   }
 };
 
-const contentLoaded$9 = async (state) => {
+const contentLoaded$8 = async (state) => {
   await invoke$1(
     /* Viewlet.invoke */ 3024,
     /* id */ 'Output',
@@ -17493,7 +17616,7 @@ const handleData = async (state, data) => {
   );
 };
 
-const dispose$8 = async (state) => {
+const dispose$7 = async (state) => {
   state.disposed = true;
   // TODO close output channel in shared process
   await invoke$2(
@@ -17522,81 +17645,17 @@ const handleError = (state, error) => {
 };
 
 var ViewletOutput = {
-  __proto__: null,
-  name: name$c,
-  create: create$9,
-  loadContent: loadContent$9,
-  contentLoaded: contentLoaded$9,
-  setOutputChannel: setOutputChannel,
-  handleData: handleData,
-  dispose: dispose$8,
-  openFindWidget: openFindWidget,
-  closeFindWidget: closeFindWidget,
-  handleError: handleError
-};
-
-const name$b = 'Problems';
-
-const create$8 = () => {
-  return {
-    problems: [],
-    disposed: false,
-  }
-};
-
-const toProblem = (diagnostic) => {
-  return diagnostic.message
-};
-
-const loadContent$8 = async (state) => {
-  const instance = state$p.instances['EditorText'];
-  if (!instance) {
-    return state
-  }
-  const editor = instance.state;
-  const diagnostics = await executeDiagnosticProvider(
-    editor
-  );
-  const problems = diagnostics.map(toProblem);
-  return {
-    ...state,
-    problems,
-  }
-};
-
-const contentLoaded$8 = async (state) => {};
-
-const dispose$7 = (state) => {
-  return {
-    ...state,
-    disposed: true,
-  }
-};
-
-const hasFunctionalRender$5 = true;
-
-const render$5 = (oldState, newState) => {
-  const changes = [];
-  if (oldState.problems !== newState.problems) {
-    changes.push([
-      /* Viewlet.invoke */ 3024,
-      /* id */ 'Problems',
-      /* method */ 'setProblems',
-      /* problems */ newState.problems,
-    ]);
-  }
-  return changes
-};
-
-var ViewletProblems = {
   __proto__: null,
   name: name$b,
   create: create$8,
   loadContent: loadContent$8,
   contentLoaded: contentLoaded$8,
+  setOutputChannel: setOutputChannel,
+  handleData: handleData,
   dispose: dispose$7,
-  hasFunctionalRender: hasFunctionalRender$5,
-  render: render$5
+  openFindWidget: openFindWidget,
+  closeFindWidget: closeFindWidget,
+  handleError: handleError
 };
 
 const create$7 = (id) => {
@@ -17685,7 +17744,7 @@ const getContent = async (uri) => {
 
 // TODO how to connect this function with tokenizer?
 const handleTokenizeChange = () => {
-  const instances = state$p.instances;
+  const instances = state$m.instances;
   const instance = instances.EditorText;
   if (!instance) {
     console.log('no text editor');
@@ -17781,7 +17840,7 @@ const contentLoadedEffects = async (state) => {
 };
 
 const handleLanguagesChanged = async () => {
-  const instances = state$p.instances;
+  const instances = state$m.instances;
   const instance = instances.EditorText;
   if (!instance) {
     console.log('no text editor');
@@ -18059,7 +18118,7 @@ const executeReferenceProvider = async (editor, offset) => {
 };
 
 const getReferences = async () => {
-  const editor = state$p.instances['EditorText'].state;
+  const editor = state$m.instances['EditorText'].state;
   const offset = offsetAt(editor, editor.cursor);
   const references = await executeReferenceProvider(
     editor,
@@ -18080,7 +18139,7 @@ const loadContent$1 = async (state) => {
 
 // TODO side effect is not good here, find a way to call ViewletLocations
 const contentLoaded$1 = (state) => {
-  state$p.instances['Locations'] = {
+  state$m.instances['Locations'] = {
     factory: ViewletLocations,
     state,
   };
@@ -18119,7 +18178,7 @@ const name$5 = 'Implementations';
 // TODO speed up this function by 130% by not running activation event (onReferences) again and again
 // e.g. (21ms activation event, 11ms getReferences) => (11ms getReferences)
 const getImplementations = async () => {
-  const editor = state$p.instances['EditorText'].state;
+  const editor = state$m.instances['EditorText'].state;
   const offset = offsetAt(editor, editor.cursor);
   const implementations =
     await executeImplementationProvider(
@@ -18137,7 +18196,7 @@ const loadContent = async (state) => {
 };
 
 const contentLoaded = (state) => {
-  state$p.instances['Locations'] = {
+  state$m.instances['Locations'] = {
     factory: ViewletLocations,
     state,
   };
@@ -18170,7 +18229,7 @@ const toContextMenuItem$1 = (activityBarItem) => {
 
 const getMenuEntries$g = async () => {
   const activityBarItems =
-    state$p.instances['ActivityBar'].state.activityBarItems;
+    state$m.instances['ActivityBar'].state.activityBarItems;
   return [
     ...activityBarItems.map(toContextMenuItem$1),
     {
@@ -19451,7 +19510,7 @@ const getNoResults = () => {
 };
 
 const getPicks = async (searchValue) => {
-  const workspace = state$z.workspacePath;
+  const workspace = state$w.workspacePath;
   if (!workspace) {
     return []
   }
@@ -19461,7 +19520,7 @@ const getPicks = async (searchValue) => {
 };
 
 const selectPick = async (item) => {
-  const workspace = state$z.workspacePath;
+  const workspace = state$w.workspacePath;
   const absolutePath = `${workspace}/${item.label}`;
   await openUri(absolutePath);
   return {