@lvce-editor/static-server 0.59.5 → 0.60.0

package/static/{2c9ff1f → bb5da46}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -72,17 +72,17 @@ const fn = value => {
   }
 };
 
-const state$L = {
+const state$K = {
   pending: Object.create(null)
 };
 const get$j = id => {
-  return state$L.pending[id];
+  return state$K.pending[id];
 };
 const has$2 = id => {
-  return id in state$L.pending;
+  return id in state$K.pending;
 };
 const set$j = (id, value) => {
-  state$L.pending[id] = value;
+  state$K.pending[id] = value;
 };
 
 const Web$1 = 1;
@@ -96,7 +96,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/2c9ff1f';
+    return '/bb5da46';
   }
 };
 const assetDir = getAssetDir();
@@ -420,10 +420,10 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const invoke$r = (ipc, method, ...params) => {
+const invoke$s = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$9 = (ipc, method, ...params) => {
+const invokeAndTransfer$a = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -792,7 +792,7 @@ const getModuleId$1 = commandId => {
   }
 };
 
-const state$K = {
+const state$J = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -815,29 +815,29 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$K.load(moduleId);
+    const module = await state$J.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$K.pendingModules[moduleId]) {
-    state$K.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$J.pendingModules[moduleId]) {
+    state$J.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$K.pendingModules[moduleId];
+  return state$J.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$2 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$K.commands[commandId] = listener;
+  state$J.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$K.commands) {
-    const fn = state$K.commands[command];
+  if (command in state$J.commands) {
+    const fn = state$J.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -846,7 +846,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$K.commands)) {
+    if (!(command in state$J.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -857,7 +857,7 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$K.load = load;
+  state$J.load = load;
 };
 
 const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
@@ -1059,7 +1059,7 @@ const listen$2 = async ({
 };
 
 /* istanbul ignore file */
-const state$J = {
+const state$I = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1072,16 +1072,16 @@ const getIpc = () => {
   });
 };
 const listen$1 = async () => {
-  console.assert(state$J.pendingMessages.length === 0);
+  console.assert(state$I.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc);
-  state$J.ipc = ipc;
+  state$I.ipc = ipc;
 };
-const invoke$q = (method, ...params) => {
-  return invoke$r(state$J.ipc, method, ...params);
+const invoke$r = (method, ...params) => {
+  return invoke$s(state$I.ipc, method, ...params);
 };
-const invokeAndTransfer$8 = (method, ...params) => {
-  return invokeAndTransfer$9(state$J.ipc, method, ...params);
+const invokeAndTransfer$9 = (method, ...params) => {
+  return invokeAndTransfer$a(state$I.ipc, method, ...params);
 };
 
 const actuallyLoadCssStyleSheet = async css => {
@@ -1099,7 +1099,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$q('Css.addCssStyleSheet', id, css);
+  return invoke$r('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1123,11 +1123,11 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$r(ipc, method, ...params);
+      return invoke$s(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invokeAndTransfer$9(ipc, method, ...params);
+      return invokeAndTransfer$a(ipc, method, ...params);
     },
     async dispose() {
       const promise = workers.get(fn);
@@ -1201,21 +1201,21 @@ const create$14 = async ({
   return ipc;
 };
 
-const state$I = Object.create(null);
+const state$H = Object.create(null);
 const setAll = async preferences => {
-  Object.assign(state$I, preferences);
+  Object.assign(state$H, preferences);
 };
 const get$h = key => {
-  return state$I[key];
+  return state$H[key];
 };
 const getAll$3 = () => {
-  return state$I;
+  return state$H;
 };
 const set$h = async (key, value) => {
-  state$I[key] = value;
+  state$H[key] = value;
 };
 
-const getConfiguredWorkerUrl$l = () => {
+const getConfiguredWorkerUrl$m = () => {
   let configuredWorkerUrl = get$h('develop.errorWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -1231,15 +1231,15 @@ const launchErrorWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$l()
+    url: getConfiguredWorkerUrl$m()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$p,
-  invokeAndTransfer: invokeAndTransfer$7
+  invoke: invoke$q,
+  invokeAndTransfer: invokeAndTransfer$8
 } = getOrCreateWorker(launchErrorWorker);
 
 const serializeError = error => {
@@ -1260,14 +1260,14 @@ const serializeError = error => {
 const prepare = async error => {
   try {
     const serialized = serializeError(error);
-    const prepared = await invoke$p('Errors.prepare', serialized);
+    const prepared = await invoke$q('Errors.prepare', serialized);
     return prepared;
   } catch {
     return error;
   }
 };
 const print = async (error, prefix = '') => {
-  await invoke$p('Errors.print', error, prefix);
+  await invoke$q('Errors.print', error, prefix);
 };
 const getMessage$3 = error => {
   if (error && error.type && error.message) {
@@ -1279,7 +1279,7 @@ const getMessage$3 = error => {
   return `Error: ${error}`;
 };
 
-const state$H = {
+const state$G = {
   /**
    * @type {string[]}
    */
@@ -1315,10 +1315,10 @@ const showErrorDialog = async error => {
 };
 const warn$1 = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$H.seenWarnings.includes(stringified)) {
+  if (state$G.seenWarnings.includes(stringified)) {
     return;
   }
-  state$H.seenWarnings.push(stringified);
+  state$G.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
@@ -1333,32 +1333,32 @@ const extensionHostWorkerUrl = `${assetDir}/packages/renderer-worker/node_module
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$G = {
+const state$F = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$G.listenerMap[event] || [];
+  const listeners = state$F.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$G.listenerMap[event] ||= [];
-  if (state$G.listenerMap[event].includes(fn)) {
+  state$F.listenerMap[event] ||= [];
+  if (state$F.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$G.listenerMap[event].unshift(fn);
+    state$F.listenerMap[event].unshift(fn);
   } else {
-    state$G.listenerMap[event].push(fn);
+    state$F.listenerMap[event].push(fn);
   }
 };
 
-const state$F = {
+const state$E = {
   id: 0
 };
 const create$13 = () => {
-  return ++state$F.id;
+  return ++state$E.id;
 };
 
 const ModuleWorkerWithMessagePort = 4;
@@ -1438,7 +1438,7 @@ const create$12 = async ({
     port1,
     port2
   } = getPortTuple(port);
-  await invokeAndTransfer$8('IpcParent.create', {
+  await invokeAndTransfer$9('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
@@ -1502,19 +1502,19 @@ const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   wrap: wrap$7
 };
 
-const state$E = {
+const state$D = {
   shouldLaunchMultipleWorkers: false
 };
 const setConfig = shouldLaunchMultipleWorkers => {
-  state$E.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+  state$D.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
 const getConfig = () => {
-  return state$E.shouldLaunchMultipleWorkers;
+  return state$D.shouldLaunchMultipleWorkers;
 };
 
 const objects = Object.create(null);
 const transferToRendererProcess = async (objectId, transferable) => {
-  await invokeAndTransfer$8('Transferrable.transfer', transferable, objectId);
+  await invokeAndTransfer$9('Transferrable.transfer', transferable, objectId);
 };
 const transfer = (objectId, transferable) => {
   number(objectId);
@@ -1753,7 +1753,7 @@ const parse$1 = content => {
   }
 };
 
-const state$D = {
+const state$C = {
   /**
    * @type {any}
    */
@@ -1761,18 +1761,18 @@ const state$D = {
 };
 
 /* istanbul ignore file */
-const invoke$o = async (method, ...params) => {
+const invoke$p = async (method, ...params) => {
   const {
     ipc
-  } = state$D;
-  const result = await invoke$r(ipc, method, ...params);
+  } = state$C;
+  const result = await invoke$s(ipc, method, ...params);
   return result;
 };
-const invokeAndTransfer$6 = async (method, ...params) => {
+const invokeAndTransfer$7 = async (method, ...params) => {
   const {
     ipc
-  } = state$D;
-  const result = await invokeAndTransfer$9(ipc, method, ...params);
+  } = state$C;
+  const result = await invokeAndTransfer$a(ipc, method, ...params);
   return result;
 };
 
@@ -1810,7 +1810,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$o(PreferencesGetAll);
+  return invoke$p(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -1850,7 +1850,7 @@ const set$g = async (key, value) => {
   await writeFile$f('app://settings.json', content);
 };
 
-const state$C = {
+const state$B = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -1860,7 +1860,7 @@ const state$C = {
 };
 
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$o(/* Workspace.resolveRoot */WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$p(/* Workspace.resolveRoot */WorkspaceResolveRoot);
   return resolvedRoot;
 };
 const isValid$1 = resolvedRoot => {
@@ -1876,7 +1876,7 @@ const getResolveRootFromSessionStorage = async () => {
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$C.isTest = true;
+    state$B.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -1926,13 +1926,13 @@ const getResolvedRoot = async href => {
 };
 
 const getHref = () => {
-  return invoke$q(/* Location.getHref */'Location.getHref');
+  return invoke$r(/* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$q(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$r(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$a = () => {
-  return invoke$q(/* Location.hydrate */'Location.hydrate');
+  return invoke$r(/* Location.hydrate */'Location.hydrate');
 };
 const getOrigin = () => {
   return location.origin;
@@ -1942,7 +1942,7 @@ const getHost = () => {
 };
 
 const set$f = title => {
-  return invoke$q('WindowTitle.set', title);
+  return invoke$r('WindowTitle.set', title);
 };
 
 /**
@@ -1953,35 +1953,35 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$C.workspacePath = path;
+  state$B.workspacePath = path;
   // @ts-ignore
-  state$C.workspaceUri = path;
-  state$C.pathSeparator = pathSeparator;
+  state$B.workspaceUri = path;
+  state$B.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async uri => {
   const path = uri.slice('file://'.length);
-  state$C.workspacePath = path;
-  state$C.workspaceUri = uri;
+  state$B.workspacePath = path;
+  state$B.workspaceUri = uri;
   await onWorkspaceChange();
 };
 const getPath = () => {
-  return state$C.workspacePath;
+  return state$B.workspacePath;
 };
 const getUri$1 = () => {
-  return state$C.workspaceUri;
+  return state$B.workspaceUri;
 };
 const close$5 = () => {
   return setPath('');
 };
 const isTest = () => {
-  return state$C.isTest;
+  return state$B.isTest;
 };
 const getTitle$1 = workspacePath => {
   if (!workspacePath) {
     return '';
   }
-  const pathSeparator = state$C.pathSeparator;
+  const pathSeparator = state$B.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
 };
 const getPathName = workspacePath => {
@@ -1994,51 +1994,51 @@ const getPathName = workspacePath => {
   return '';
 };
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$C.workspacePath);
+  const title = getTitle$1(state$B.workspacePath);
   await set$f(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$C.workspacePath);
+    const pathName = getPathName(state$B.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$C.workspacePath);
+  await emitEvent('workspace.change', state$B.workspacePath);
 };
 const hydrate$9 = async ({
   href
 }) => {
-  if (state$C.workspacePath) {
+  if (state$B.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$C.isTest) {
+  if (state$B.isTest) {
     return;
   }
-  if (state$C.workspacePath) {
+  if (state$B.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$C.homeDir !== resolvedRoot.homeDir) {
-    state$C.homeDir = resolvedRoot.homeDir;
+  if (state$B.homeDir !== resolvedRoot.homeDir) {
+    state$B.homeDir = resolvedRoot.homeDir;
   }
   if (!canBeRestored$6(resolvedRoot.path)) {
     return;
   }
   // TODO how to check that path from renderer process is valid?
   // TODO also need to check whether it is a folder or file
-  state$C.workspacePath = resolvedRoot.path;
-  state$C.homeDir = resolvedRoot.homeDir;
-  state$C.pathSeparator = resolvedRoot.pathSeparator;
-  state$C.workspaceUri = resolvedRoot.uri;
-  state$C.source = resolvedRoot.source;
-  if (state$C.workspaceUri && state$C.workspaceUri.startsWith('/')) {
-    state$C.workspaceUri = `file://${state$C.workspaceUri}`;
+  state$B.workspacePath = resolvedRoot.path;
+  state$B.homeDir = resolvedRoot.homeDir;
+  state$B.pathSeparator = resolvedRoot.pathSeparator;
+  state$B.workspaceUri = resolvedRoot.uri;
+  state$B.source = resolvedRoot.source;
+  if (state$B.workspaceUri && state$B.workspaceUri.startsWith('/')) {
+    state$B.workspaceUri = `file://${state$B.workspaceUri}`;
   }
   await onWorkspaceChange();
 };
 const getWorkspaceUri = () => {
-  return state$C.workspaceUri;
+  return state$B.workspaceUri;
 };
 const getHomeDir = () => {
-  return state$C.homeDir;
+  return state$B.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -2051,7 +2051,7 @@ const pathBaseName = path => {
 
 // TODO this should be in FileSystem module
 const pathDirName = path => {
-  const pathSeparator = state$C.pathSeparator || '/';
+  const pathSeparator = state$B.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString;
@@ -2074,16 +2074,16 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$r(ipc, 'Workspace.setWorkspacePath', state$C.workspacePath);
+  await invoke$s(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$r(ipc, 'Workspace.setWorkspacePath', state$C.workspacePath);
+    await invoke$s(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   });
   return ipc;
 };
 
 const {
-  invoke: invoke$n,
-  invokeAndTransfer: invokeAndTransfer$5
+  invoke: invoke$o,
+  invokeAndTransfer: invokeAndTransfer$6
 } = getOrCreateWorker(launchExtensionHostWorker);
 
 // TODO make storage configurable via settings as localstorage or indexeddb
@@ -2112,11 +2112,11 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
 };
 
 const getColorThemeJson = colorThemeId => {
-  return invoke$n('ColorTheme.getColorThemeJson', colorThemeId);
+  return invoke$o('ColorTheme.getColorThemeJson', colorThemeId);
 };
 
 const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
-  return invoke$n('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
+  return invoke$o('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
 };
 const getColorThemeCssNew = async colorThemeId => {
   const colorThemeJson = await getColorThemeJson(colorThemeId);
@@ -2132,13 +2132,13 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$q(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$r(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
 };
 
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$B = {
+const state$A = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2149,7 +2149,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$B.colorTheme = colorThemeId;
+    state$A.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     if (!colorThemeCss) {
       return new Error(`Color theme is empty`);
@@ -2177,11 +2177,11 @@ const setColorTheme = async colorThemeId => {
   return undefined;
 };
 const watch$1 = async id => {
-  if (state$B.watchedTheme === id) {
+  if (state$A.watchedTheme === id) {
     return;
   }
-  state$B.watchedTheme = id;
-  await invoke$o('ExtensionHost.watchColorTheme', id);
+  state$A.watchedTheme = id;
+  await invoke$p('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$f('workbench.colorTheme');
@@ -2220,27 +2220,27 @@ const handleEvent = (id, event) => {
   }));
 };
 
-const state$A = {
+const state$z = {
   id: 0
 };
 const set$e = value => {
-  state$A.id = value;
+  state$z.id = value;
 };
 const get$e = () => {
-  return state$A.id;
+  return state$z.id;
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
   const webContentsId = get$e();
-  const windowId = await invoke$o('GetWindowId.getWindowId', webContentsId);
+  const windowId = await invoke$p('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
 
 const forward$2 = key => async (...args) => {
   const windowId = await getWindowId();
-  return invoke$o(key, windowId, ...args);
+  return invoke$p(key, windowId, ...args);
 };
 const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$2 = forward$2('ElectronWindow.minimize');
@@ -2259,7 +2259,7 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$q('Window.reload');
+  return invoke$r('Window.reload');
 };
 
 const getFn$2 = () => {
@@ -2298,49 +2298,49 @@ const getUrlBaseName = href => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$o(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$p(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$o(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$p(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
   if (platform === Web$1) {
     return 'memfs://output';
   }
-  return invoke$o(/* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$p(/* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$o(/* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$p(/* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$o(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$p(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$o(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$p(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
   if (platform === Web$1) {
     return 'recently-opened';
   }
-  return invoke$o(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$p(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$o(/* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$p(/* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$o(/* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$p(/* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$o(/* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$p(/* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -2360,10 +2360,10 @@ const getTmpDir$1 = () => {
   if (platform === Web$1) {
     throw new Error('not implemented in web');
   }
-  return invoke$o(/* Platform.getTmpDir */'Platform.getTmpDir');
+  return invoke$p(/* Platform.getTmpDir */'Platform.getTmpDir');
 };
 const getRepository = () => {
-  return invoke$o('Platform.getRepository');
+  return invoke$p('Platform.getRepository');
 };
 
 // TODO determine with websocket request or some
@@ -2460,15 +2460,15 @@ const remove$9 = key => {
   delete contexts[key];
 };
 
-const state$z = {
+const state$y = {
   // TODO use numeric focus key
   currentFocus: ''
 };
 const get$c = () => {
-  return state$z.currentFocus;
+  return state$y.currentFocus;
 };
 const set$c = value => {
-  state$z.currentFocus = value;
+  state$y.currentFocus = value;
 };
 
 const warn = (...args) => {
@@ -2478,7 +2478,7 @@ const error = (...args) => {
   console.error(...args);
 };
 
-const state$y = {
+const state$x = {
   keyBindingSets: Object.create(null),
   /**
    * @type {Uint32Array}
@@ -2490,7 +2490,7 @@ const state$y = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$y.matchingKeyBindings) {
+  for (const keyBinding of state$x.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2513,26 +2513,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$y.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$x.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$q('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$y.matchingKeyBindings = matchingKeyBindings;
-  state$y.keyBindingIdentifiers = keyBindingIdentifiers;
+  invoke$r('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  state$x.matchingKeyBindings = matchingKeyBindings;
+  state$x.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings$1 = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$y.keyBindingSets) {
+  if (id in state$x.keyBindingSets) {
     warn(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$y.keyBindingSets[id] = keyBindings;
+  state$x.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$y;
+  } = state$x;
   if (!(id in keyBindingSets)) {
     warn(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2608,8 +2608,66 @@ const hydrate$6 = async () => {
   update();
 };
 
-const getIconThemeJson = async iconThemeId => {
-  return invoke$n('IconTheme.getJson', iconThemeId);
+const Resolved = 'resolved';
+const Rejected = 'rejected';
+
+const handleExtensionStatusUpdate = async () => {
+  // TODO inform all viewlets
+};
+const invalidateExtensionsCache = async () => {
+  try {
+    await invoke$o('Extensions.invalidateExtensionsCache');
+  } catch {
+    // ignore
+  }
+};
+const disable = async id => {
+  try {
+    if (isTest()) {
+      disabledIds = [...disabledIds, id];
+    } else {
+      await invoke$p(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+    }
+    await invalidateExtensionsCache();
+    return undefined;
+  } catch (error) {
+    return error;
+  }
+};
+const enable = async id => {
+  try {
+    if (isTest()) {
+      disabledIds = disabledIds.filter(existing => existing !== id);
+    } else {
+      await invoke$p(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+    }
+    await invalidateExtensionsCache();
+    return undefined;
+  } catch (error) {
+    return error;
+  }
+};
+const getAllExtensions = async () => {
+  if (platform === Web$1) {
+    return [];
+  }
+  return invoke$p(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+};
+let disabledIds = [];
+const getExtension2 = async id => {
+  const extension = await invoke$o('Extensions.getExtension', id);
+  if (disabledIds.includes(id)) {
+    return {
+      ...extension,
+      disabled: true
+    };
+  }
+  // console.log({ extension, disabledIds, platform: Platform.platform })
+  return extension;
+};
+const getExtensionsEtag = async () => {
+  const etag = await invoke$p('ExtensionManagement.getExtensionsEtag');
+  return etag;
 };
 
 const dispatch = key => (...args) => {
@@ -2646,14 +2704,14 @@ class CancelationError extends Error {
   }
 }
 
-const state$x = {
+const state$w = {
   idMap: Object.create(null)
 };
 const register$1 = (id, module) => {
-  state$x.idMap[id] = module;
+  state$w.idMap[id] = module;
 };
 const get$b = id => {
-  return state$x.idMap[id];
+  return state$w.idMap[id];
 };
 
 const registry = Object.create(null);
@@ -2690,13 +2748,13 @@ const serializeObjects = objects => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$q(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$r(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$q('WebStorage.getAll', storageType);
+  return invoke$r('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$q(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$r(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -2711,7 +2769,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$q(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$r(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2719,7 +2777,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$q('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$r('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2773,7 +2831,7 @@ const serializeInstances = async instances => {
   return serialized;
 };
 
-const state$w = {
+const state$v = {
   instances: Object.create(null)};
 const set$b = (key, value) => {
   // TODO separate factories from state
@@ -2781,10 +2839,10 @@ const set$b = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$w.instances[key] = value;
+  state$v.instances[key] = value;
 };
 const getInstance = key => {
-  const fast = state$w.instances[key];
+  const fast = state$v.instances[key];
   if (fast) {
     return fast;
   }
@@ -2797,7 +2855,7 @@ const getInstance = key => {
   if (key === 'EditorCompletion') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$w.instances)) {
+  for (const value of Object.values(state$v.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -2805,16 +2863,16 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$w.instances;
+  return key in state$v.instances;
 };
 const remove$8 = key => {
-  delete state$w.instances[key];
+  delete state$v.instances[key];
 };
 const getAllInstances = () => {
-  return state$w.instances;
+  return state$v.instances;
 };
 const getValues = () => {
-  return Object.values(state$w.instances);
+  return Object.values(state$v.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -2854,10 +2912,10 @@ const getStateToSave = async () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$C.workspacePath,
-      homeDir: state$C.homeDir,
-      pathSeparator: state$C.pathSeparator,
-      uri: state$C.workspaceUri
+      path: state$B.workspacePath,
+      homeDir: state$B.homeDir,
+      pathSeparator: state$B.pathSeparator,
+      uri: state$B.workspaceUri
     }
   };
 };
@@ -2894,7 +2952,7 @@ const ExtensionStateStorage = {
 };
 
 const saveState$m = async () => {
-  const state = await invoke$n('SaveState.saveState');
+  const state = await invoke$o('SaveState.saveState');
   return state;
 };
 const getSavedState = async () => {
@@ -2949,7 +3007,7 @@ const hydrate$5 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$q('Window.onVisibilityChange');
+  await invoke$r('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -2962,7 +3020,7 @@ const loadModule$3 = async (id, module) => {
     await (Array.isArray(module.Css) ? loadCssStyleSheets(module.Css) : loadCssStyleSheet(module.Css));
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$I);
+    await addDynamicCss(id, module.getDynamicCss, state$H);
   }
 };
 
@@ -2973,7 +3031,7 @@ const ViewletManagerVisitorCss = {
 
 const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
 
-const getConfiguredWorkerUrl$k = () => {
+const getConfiguredWorkerUrl$l = () => {
   let configuredWorkerUrl = get$f('develop.fileSearchWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -2989,30 +3047,30 @@ const launchFileSearchWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$k()
+    url: getConfiguredWorkerUrl$l()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$m} = getOrCreateWorker(launchFileSearchWorker);
+  invoke: invoke$n} = getOrCreateWorker(launchFileSearchWorker);
 
-const state$v = {
+const state$u = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$v.menuEntries;
+  return state$u.menuEntries;
 };
 const add$1 = async menuEntries => {
-  state$v.menuEntries = [...state$v.menuEntries, ...menuEntries];
+  state$u.menuEntries = [...state$u.menuEntries, ...menuEntries];
   // TODO store menu entries here or in file search worker?
   // Usually don't want to start worker for the menu entries
   // But also quickpick menu entries would be better stored there
-  await invoke$m('QuickPick.addMenuEntries', menuEntries);
+  await invoke$n('QuickPick.addMenuEntries', menuEntries);
 };
 
 const loadModule$2 = async (id, module) => {
@@ -3062,7 +3120,7 @@ const List$1 = 'List';
 const Locations = 'Locations';
 const Main$3 = 'Main';
 const MainTabs = 'MainTabs';
-const None$c = '';
+const None$b = '';
 const Noop = 'Noop';
 const Output = 'Output';
 const Panel$2 = 'Panel';
@@ -3133,7 +3191,7 @@ const ViewletModuleId = {
   Main: Main$3,
   MainTabs,
   MarkDownPreview,
-  None: None$c,
+  None: None$b,
   Noop,
   Output,
   Panel: Panel$2,
@@ -3162,7 +3220,7 @@ const ViewletModuleId = {
 };
 
 // @ts-nocheck
-const state$u = {
+const state$t = {
   pendingModules: Object.create(null)
 };
 const ViewletState = {
@@ -3201,7 +3259,7 @@ const runFn = async (instance, id, key, fn, args) => {
     const commands = render$J(instance.factory, oldState, newState, newState.uid || id);
     updateDynamicFocusContext(commands);
     setRenderedState(id, newState);
-    await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$r(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3226,7 +3284,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$r(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3431,7 +3489,7 @@ const maybeRegisterEvents = module => {
       const commands = render$J(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$r(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -3458,7 +3516,7 @@ const maybeRegisterEvents = module => {
         const commands = render$J(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$r(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3486,7 +3544,7 @@ const maybeRegisterMenuEntries = async module => {
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$q(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$r(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -3495,10 +3553,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$u.pendingModules)) {
-    state$u.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$t.pendingModules)) {
+    state$t.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$u.pendingModules[id];
+  return state$t.pendingModules[id];
 };
 
 // TODO add lots of unit tests for this
@@ -3579,7 +3637,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.renderEventListeners) {
       // TODO reuse event listeners between components
       const eventListeners = await module.renderEventListeners();
-      await invoke$q('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      await invoke$r('Viewlet.registerEventListeners', viewletUid, eventListeners);
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
       await module.show(newState);
@@ -3633,7 +3691,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$q(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$r(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3685,7 +3743,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
         return allCommands;
       }
       commands.push(...extraCommands);
-      await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$r(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3706,7 +3764,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$q(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$r(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3728,10 +3786,10 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$q(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$r(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$q(kLoadModule, Error$3);
+      await invoke$r(kLoadModule, Error$3);
       commands.push([kCreate, Error$3, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3740,7 +3798,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       if (module && module.customErrorRenderer) {
         const errorModule = await loadModule(viewlet.getModule, module.customErrorRenderer);
         const dom = await errorModule.render(error);
-        await invoke$q(kLoadModule, module.customErrorRenderer);
+        await invoke$r(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -3793,7 +3851,7 @@ const load$4 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$o('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$p('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -3816,15 +3874,15 @@ const handleKeyBinding$1 = async identifier => {
   // }
 };
 
-const state$t = {
+const state$s = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$t.isQuickPickOpen;
+  return state$s.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$t.isQuickPickOpen = false;
+  state$s.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -3843,7 +3901,7 @@ const focus$7 = async id => {
     commands.push(...render$J(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$q('Viewlet.sendMultiple', commands);
+  await invoke$r('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -3886,7 +3944,7 @@ const dispose$s = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$q(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$r(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4067,7 +4125,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$q(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$r(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4110,7 +4168,7 @@ const openWidget = async (moduleId, ...args) => {
   // TODO send focus changes to renderer process together with other message
   updateDynamicFocusContext(commands);
   commands.push(['Viewlet.focus', childUid]);
-  await invoke$q('Viewlet.executeCommands', commands);
+  await invoke$r('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4122,7 +4180,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$q(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$r(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4180,7 +4238,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$q(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$r(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4220,7 +4278,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$q('Viewlet.sendMultiple', commands);
+    await invoke$r('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4254,42 +4312,81 @@ const handleIconThemeChange$1 = async () => {
   }
 };
 
-const initialIconTheme = undefined;
+const iconThemeWorkerUrl = `${assetDir}/packages/icon-theme-worker/dist/iconThemeWorkerMain.js`;
 
-const state$s = {
-  /**
-   * @type{any}
-   */
-  iconTheme: initialIconTheme,
-  extensionPath: ''
-};
-const setTheme = iconTheme => {
-  state$s.iconTheme = iconTheme.json;
-  state$s.extensionPath = iconTheme.extensionPath;
+const getConfiguredWorkerUrl$k = () => {
+  let configuredWorkerUrl = get$f('develop.iconThemeWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || iconThemeWorkerUrl;
+  {
+    configuredWorkerUrl = iconThemeWorkerUrl;
+  }
+  return configuredWorkerUrl;
 };
-const getIconTheme = () => {
-  return state$s.iconTheme;
+const launchIconThemeWorker = async () => {
+  const name = 'Icon Theme Worker';
+  const ipc = await create$14({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$k()
+  });
+  handleIpc(ipc);
+  return ipc;
 };
 
-const File$4 = '_file';
-const Folder = '_folder';
-const FolderOpen = '_folder_open';
-const None$b = '';
+const {
+  invoke: invoke$m,
+  invokeAndTransfer: invokeAndTransfer$5
+} = getOrCreateWorker(launchIconThemeWorker);
 
-const BlockDevice = 1;
-const CharacterDevice = 2;
-const Directory$1 = 3;
-const DirectoryExpanded = 4;
-const File$3 = 7;
-const Socket = 8;
-const Symlink = 9;
-const SymLinkFile = 10;
-const SymLinkFolder = 11;
-const Unknown$1 = 12;
+const getFileIcon$1 = file => {
+  return invoke$m('IconTheme.getFileIcon', file);
+};
+const getFileIcons = fileNames => {
+  return invoke$m('IconTheme.getFileIcons', fileNames);
+};
+const getFolderIcon = folder => {
+  return invoke$m('IconTheme.getFolderIcon', folder);
+};
+const getIcon = dirent => {
+  return invoke$m('IconTheme.getIcon', dirent);
+};
+const getIcons = iconRequests => {
+  return invoke$m('IconTheme.getIcons', iconRequests);
+};
 
-const getAbsoluteIconPath = (iconTheme, icon) => {
-  const result = iconTheme.iconDefinitions[icon];
-  return `${assetDir}/file-icons/${result.slice(12)}`;
+const setIconTheme = async iconThemeId => {
+  try {
+    const extensions = await getAllExtensions();
+    await invoke$m('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, platform);
+    await handleIconThemeChange$1();
+  } catch (error) {
+    if (isTest()) ; else {
+      console.error(new VError(error, 'Failed to load icon theme'));
+    }
+  }
+};
+const hydrate$4 = async () => {
+  // TODO do this all in worker
+  const iconThemeId = get$f('icon-theme') || 'vscode-icons';
+  await setIconTheme(iconThemeId);
+};
+
+const getInitData = async () => {
+  const rendererProcessInitData = await invoke$r('InitData.getInitData');
+  // TODO get the following items
+  // - location.href
+  // - workspace
+  // - color theme
+  // - preferences
+  // - restoredState
+  // - layout bounds
+  // - keybindings
+  // - icon theme
+  // - languages
+  return rendererProcessInitData;
 };
 
 // based on https://github.com/babel/babel/blob/6be6e04f396f03feace4431f709564a8d842163a/packages/babel-code-frame/src/index.ts (License MIT)
@@ -4427,7 +4524,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$o(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$p(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -4440,7 +4537,7 @@ const getLanguageConfiguration$2 = async languageId => {
 
 const getLanguages = async () => {
   try {
-    return invoke$n('Languages.getLanguages');
+    return invoke$o('Languages.getLanguages');
   } catch (error) {
     throw new VError(error, 'Failed to load languages');
   }
@@ -4577,12 +4674,13 @@ const getTokenizeFunctionPath = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
   return getTokenizeFunctionPath$1(languageId);
 };
-const hydrate$4 = async () => {
+const hydrate$3 = async () => {
   setHydrating(true);
   // TODO handle error
   // TODO main parts should have nothing todo with shared process -> only sub components
   const languages = await getLanguages();
   // TODO avoid side effect here, but how?
+  await invoke$m('IconTheme.addLanguages', languages);
   await addLanguages(languages);
   const useJsx = get$f('languages.jsFilesAsJsx');
   if (useJsx) {
@@ -4721,155 +4819,6 @@ const getLanguageConfiguration = async editor => {
   }
 };
 
-const getFileNameIcon = file => {
-  string(file);
-  const iconTheme = getIconTheme();
-  const fileNameLower = file.toLowerCase();
-  if (!iconTheme) {
-    return '';
-  }
-  if (iconTheme.fileNames) {
-    const fileNameIcon = iconTheme.fileNames[fileNameLower];
-    if (fileNameIcon) {
-      return getAbsoluteIconPath(iconTheme, fileNameIcon);
-    }
-  }
-  if (iconTheme.fileExtensions) {
-    let index = -1;
-    while ((index = fileNameLower.indexOf(Dot, index + 1)) !== -1) {
-      const shorterExtension = fileNameLower.slice(index + 1);
-      const extensionIcon = iconTheme.fileExtensions[shorterExtension];
-      if (extensionIcon) {
-        return getAbsoluteIconPath(iconTheme, extensionIcon);
-      }
-    }
-  }
-  if (iconTheme.languageIds) {
-    const languageId = getLanguageId$1(fileNameLower);
-    const languageIcon = iconTheme.languageIds[languageId];
-    if (languageId === 'jsx' && fileNameLower.endsWith('.js')) {
-      const alternativeFileIcon = iconTheme.languageIds.javascript;
-      if (alternativeFileIcon) {
-        return getAbsoluteIconPath(iconTheme, alternativeFileIcon);
-      }
-    }
-    if (languageIcon) {
-      return getAbsoluteIconPath(iconTheme, languageIcon);
-    }
-  }
-  return getAbsoluteIconPath(iconTheme, File$4);
-};
-const getFileIcon$1 = file => {
-  return getFileNameIcon(file.name);
-};
-const getFileIcons = fileNames => {
-  const icons = [];
-  for (const fileName of fileNames) {
-    icons.push(getFileIcon$1(fileName));
-  }
-  return icons;
-};
-const getFolderNameIcon = folderName => {
-  const iconTheme = getIconTheme();
-  // @ts-ignore
-  if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
-    return '';
-  }
-  const folderNameLower = folderName.toLowerCase();
-  // @ts-ignore
-  const folderIcon = iconTheme.folderNames[folderNameLower];
-  if (folderIcon) {
-    return getAbsoluteIconPath(iconTheme, folderIcon);
-  }
-  return getAbsoluteIconPath(iconTheme, Folder);
-};
-const getFolderIcon = folder => {
-  return getFolderNameIcon(folder.name);
-};
-const getFolderIconExpanded = folder => {
-  const iconTheme = getIconTheme();
-  if (!iconTheme) {
-    return '';
-  }
-  // @ts-ignore
-  if (!iconTheme.folderNamesExpanded) {
-    return getAbsoluteIconPath(iconTheme, FolderOpen);
-  }
-  // @ts-ignore
-  const folderName = iconTheme.folderNamesExpanded[folder.name.toLowerCase()];
-  if (folderName) {
-    return getAbsoluteIconPath(iconTheme, folderName);
-  }
-  return getAbsoluteIconPath(iconTheme, FolderOpen);
-};
-const getIcon = dirent => {
-  switch (dirent.type) {
-    case File$3:
-    case SymLinkFile:
-      return getFileIcon$1(dirent);
-    case Directory$1:
-    case SymLinkFolder:
-      return getFolderIcon(dirent);
-    case DirectoryExpanded:
-      return getFolderIconExpanded(dirent);
-    case Symlink:
-    case CharacterDevice:
-    case BlockDevice:
-    case Socket:
-      return getAbsoluteIconPath(getIconTheme(), File$4);
-    default:
-      warn(`unsupported type ${dirent.type}`);
-      return None$b;
-  }
-};
-const getIcons = iconRequests => {
-  const Folder = 2;
-  return iconRequests.map(request => {
-    if (request.type === Folder) {
-      return getFolderIcon({
-        name: request.name
-      });
-    }
-    return getFileIcon$1({
-      name: request.name
-    });
-  });
-};
-
-const setIconTheme = async iconThemeId => {
-  try {
-    const iconTheme = await getIconThemeJson(iconThemeId);
-    if (!iconTheme) {
-      return;
-    }
-    setTheme(iconTheme);
-    await handleIconThemeChange$1();
-  } catch (error) {
-    if (isTest()) ; else {
-      console.error(new VError(error, 'Failed to load icon theme'));
-    }
-  }
-};
-const hydrate$3 = async () => {
-  const iconThemeId = get$f('icon-theme') || 'vscode-icons';
-  await setIconTheme(iconThemeId);
-};
-
-const getInitData = async () => {
-  const rendererProcessInitData = await invoke$q('InitData.getInitData');
-  // TODO get the following items
-  // - location.href
-  // - workspace
-  // - color theme
-  // - preferences
-  // - restoredState
-  // - layout bounds
-  // - keybindings
-  // - icon theme
-  // - languages
-  return rendererProcessInitData;
-};
-
 const RendererWorker = 108;
 
 const listen = method => {
@@ -4884,7 +4833,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$D.ipc = ipc;
+  state$C.ipc = ipc;
 };
 
 const Zero = 0;
@@ -5252,7 +5201,7 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$o(RecentlyOpenedAddPath, path);
+  await invoke$p(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
   switch (platform) {
@@ -5290,16 +5239,16 @@ const hydrate$2 = async () => {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const saveValue$1 = async (storeId, value) => {
-  await invoke$n('IndexedDb.saveValue', storeId, value);
+  await invoke$o('IndexedDb.saveValue', storeId, value);
 };
 const getValuesByIndexName$1 = async (storeId, indexName, only) => {
-  return invoke$n('IndexedDb.getValuesByIndexName', storeId, indexName, only);
+  return invoke$o('IndexedDb.getValuesByIndexName', storeId, indexName, only);
 };
 const addHandle$1 = async (uri, handle) => {
-  return invoke$n('IndexedDb.addHandle', uri, handle);
+  return invoke$o('IndexedDb.addHandle', uri, handle);
 };
 const getHandle$1 = async uri => {
-  return invoke$n('IndexedDb.getHandle', uri);
+  return invoke$o('IndexedDb.getHandle', uri);
 };
 
 const saveValue = async (sessionId, value) => {
@@ -5405,7 +5354,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$J.ipc;
+  const originalIpc = state$I.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -5420,33 +5369,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$J.ipc.onmessage = originalAddEventListsner;
-          state$J.ipc.send = originalSend;
+          state$I.ipc.onmessage = originalAddEventListsner;
+          state$I.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$J.ipc.onmessage = wrappedOnMessage;
-          state$J.ipc.send = wrappedSend;
+          state$I.ipc.onmessage = wrappedOnMessage;
+          state$I.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$J.ipc.onmessage = originalAddEventListsner;
-          state$J.ipc.send = originalSend;
+          state$I.ipc.onmessage = originalAddEventListsner;
+          state$I.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$J.ipc.onmessage = wrappedOnMessage;
-          state$J.ipc.send = wrappedSend;
+          state$I.ipc.onmessage = wrappedOnMessage;
+          state$I.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$J.ipc.onmessage = originalAddEventListsner;
-          state$J.ipc.send = originalSend;
+          state$I.ipc.onmessage = originalAddEventListsner;
+          state$I.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$J.ipc.onmessage = wrappedOnMessage;
-          state$J.ipc.send = wrappedSend;
+          state$I.ipc.onmessage = wrappedOnMessage;
+          state$I.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$J.ipc.send = wrappedSend;
-  state$J.ipc.addEventListener('message', wrappedOnMessage);
+  state$I.ipc.send = wrappedSend;
+  state$I.ipc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -5518,8 +5467,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$J.ipc = wrapIpc(state$J.ipc, 'renderer-process', event => event.data);
-  state$D.ipc = wrapIpc(state$D.ipc, 'shared-process', event => event);
+  state$I.ipc = wrapIpc(state$I.ipc, 'renderer-process', event => event.data);
+  state$C.ipc = wrapIpc(state$C.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -5696,7 +5645,7 @@ const watchFilesForHotReload = async platform => {
     if (config.length === 0) {
       return;
     }
-    await invoke$o('ExtensionHost.watchForHotReload', config);
+    await invoke$p('ExtensionHost.watchForHotReload', config);
   } catch (error) {
     console.warn(`Failed to watch ${error}`);
   }
@@ -5733,7 +5682,7 @@ const actions = [async () => {
   mark$1(Eleven);
   mark(WillLoadIconTheme);
   // TODO check preferences if icon theme is enabled
-  await hydrate$3();
+  await hydrate$4();
   mark(DidLoadIconTheme);
 }, async () => {
   mark$1(Twelve);
@@ -5814,11 +5763,11 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$q('Viewlet.executeCommands', commands);
+  await invoke$r('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
-  await hydrate$4();
+  await hydrate$3();
   mark(DidLoadLanguages);
   mark$1(Five);
   await Promise.all(actions.map(action => action()));
@@ -5909,7 +5858,7 @@ const getPort = async ipcId => {
     port2
   } = getPortTuple();
   // TODO call sendMessagePortToElectron function
-  const webContentsId = await invokeAndTransfer$8('IpcParent.create', {
+  const webContentsId = await invokeAndTransfer$9('IpcParent.create', {
     method: Electron,
     port: port1,
     ipcId
@@ -6389,7 +6338,7 @@ const IpcParentWithNode = {
 const sendMessagePortToElectron = async (port, initialCommand, ipcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$6(initialCommand, port, ipcId);
+  await invokeAndTransfer$7(initialCommand, port, ipcId);
 };
 
 const create$U = async options => {
@@ -6477,10 +6426,10 @@ const GetColorThemeCssCachedLocalStorage = {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const set$9 = async (key, value) => {
-  await invoke$n('IndexedDb.set', key, value);
+  await invoke$o('IndexedDb.set', key, value);
 };
 const get$8 = async key => {
-  return invoke$n('IndexedDb.get', key);
+  return invoke$o('IndexedDb.get', key);
 };
 
 const getCacheKey = colorThemeId => {
@@ -6538,9 +6487,6 @@ const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompl
 const TextSearchExecuteTextSearchProvider = 'ExtensionHostTextSearch.executeTextSearchProvider';
 const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider';
 
-const Resolved = 'resolved';
-const Rejected = 'rejected';
-
 const state$n = {
   webViews: []
 };
@@ -6552,7 +6498,7 @@ const get$5 = () => {
 };
 
 const addWebExtension = async path => {
-  const manifest = await invoke$n('Extensions.addWebExtension', path);
+  const manifest = await invoke$o('Extensions.addWebExtension', path);
   // TODO avoid side effect here
   if (manifest.languages) {
     for (const language of manifest.languages) {
@@ -6666,7 +6612,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getExtensions$1 = async () => {
-  return invoke$n('Extensions.getExtensions');
+  return invoke$o('Extensions.getExtensions');
 };
 const addNodeExtension = async path => {
   // TODO add support for dynamically loading node extensions
@@ -6708,13 +6654,13 @@ const state$m = {
 const actuallyActivateExtension = async (extension, event) => {
   if (!(extension.id in state$m.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, platform);
-    state$m.activatedExtensions[extension.id] = invoke$n(ExtensionActivate, extension, absolutePath, event);
+    state$m.activatedExtensions[extension.id] = invoke$o(ExtensionActivate, extension, absolutePath, event);
   }
   return state$m.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$n('Extensions.getExtensions');
+  const extensions = await invoke$o('Extensions.getExtensions');
   const {
     resolved,
     rejected
@@ -6760,7 +6706,7 @@ const executeProviders = async ({
   combineResults
 }) => {
   await activateByEvent(event);
-  const result = await invoke$n(method, ...params);
+  const result = await invoke$o(method, ...params);
   return result;
 };
 const executeProvider = async ({
@@ -6770,14 +6716,14 @@ const executeProvider = async ({
   noProviderFoundMessage
 }) => {
   await activateByEvent(event);
-  const result = invoke$n(method, ...params);
+  const result = invoke$o(method, ...params);
   return result;
 };
 const execute$3 = async ({
   method,
   params
 }) => {
-  await invoke$n(method, ...params);
+  await invoke$o(method, ...params);
 };
 
 const readFile$e = uri => {
@@ -6997,43 +6943,43 @@ const FileSystemData = {
 
 const name$2s = 'Memory';
 const readFile$b = uri => {
-  return invoke$n('FileSystemMemory.readFile', uri);
+  return invoke$o('FileSystemMemory.readFile', uri);
 };
 const exists$1 = uri => {
-  return invoke$n('FileSystemMemory.exists', uri);
+  return invoke$o('FileSystemMemory.exists', uri);
 };
 const writeFile$b = (uri, content) => {
-  return invoke$n('FileSystemMemory.writeFile', uri, content);
+  return invoke$o('FileSystemMemory.writeFile', uri, content);
 };
 const mkdir$4 = uri => {
-  return invoke$n('FileSystemMemory.mkdir', uri);
+  return invoke$o('FileSystemMemory.mkdir', uri);
 };
 const getPathSeparator$5 = () => {
   return Slash;
 };
 const remove$4 = uri => {
-  return invoke$n('FileSystemMemory.remove', uri);
+  return invoke$o('FileSystemMemory.remove', uri);
 };
 const readDirWithFileTypes$5 = uri => {
-  return invoke$n('FileSystemMemory.readDirWithFileTypes', uri);
+  return invoke$o('FileSystemMemory.readDirWithFileTypes', uri);
 };
 const getBlobUrl$2 = uri => {
-  return invoke$n('FileSystemMemory.getBlobUrl', uri);
+  return invoke$o('FileSystemMemory.getBlobUrl', uri);
 };
 const getBlob$5 = async uri => {
-  return invoke$n('FileSystemMemory.getBlob', uri);
+  return invoke$o('FileSystemMemory.getBlob', uri);
 };
 const chmod$3 = (path, permissions) => {
-  return invoke$n('FileSystemMemory.chmod', path, permissions);
+  return invoke$o('FileSystemMemory.chmod', path, permissions);
 };
 const rename$3 = (oldPath, newPath) => {
-  return invoke$n('FileSystemMemory.rename', oldPath, newPath);
+  return invoke$o('FileSystemMemory.rename', oldPath, newPath);
 };
 const copy$4 = (oldPath, newPath) => {
-  return invoke$n('FileSystemMemory.copy', oldPath, newPath);
+  return invoke$o('FileSystemMemory.copy', oldPath, newPath);
 };
 const getFiles$1 = () => {
-  return invoke$n('FileSystemMemory.getFiles');
+  return invoke$o('FileSystemMemory.getFiles');
 };
 
 const FileSystemMemory = {
@@ -7054,6 +7000,11 @@ const FileSystemMemory = {
   writeFile: writeFile$b
 };
 
+const Directory$1 = 3;
+const DirectoryExpanded = 4;
+const File$3 = 7;
+const Unknown$1 = 12;
+
 // TODO when it rejects, it should throw a custom error,
 // FileSystemError
 
@@ -7369,7 +7320,7 @@ const launchFileSystemWorker = async () => {
     url: getConfiguredWorkerUrl$j()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Initialize.initialize', platform);
+  await invoke$s(ipc, 'Initialize.initialize', platform);
   return ipc;
 };
 
@@ -7391,7 +7342,7 @@ const readFile$9 = async uri => {
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
     return invoke$l('FileSystemFetch.readFile', uri);
   }
-  return invoke$n('FileSystemFetch.readFile', uri);
+  return invoke$o('FileSystemFetch.readFile', uri);
 };
 const readJson$3 = async uri => {
   if (uri.startsWith('localhost:')) {
@@ -7400,28 +7351,28 @@ const readJson$3 = async uri => {
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
     return invoke$l('FileSystem.readJson', uri);
   }
-  return invoke$n('FileSystemFetch.readJson', uri);
+  return invoke$o('FileSystemFetch.readJson', uri);
 };
 const writeFile$9 = (uri, content) => {
-  return invoke$n('FileSystemFetch.writeFile', uri);
+  return invoke$o('FileSystemFetch.writeFile', uri);
 };
 const mkdir$2 = uri => {
-  return invoke$n('FileSystemFetch.mkdir', uri);
+  return invoke$o('FileSystemFetch.mkdir', uri);
 };
 const getPathSeparator$3 = () => {
   return Slash;
 };
 const remove$2 = uri => {
-  return invoke$n('FileSystemFetch.remove', uri);
+  return invoke$o('FileSystemFetch.remove', uri);
 };
 const readDirWithFileTypes$3 = async uri => {
-  return invoke$n('FileSystemFetch.readDirWithFileTypes', uri);
+  return invoke$o('FileSystemFetch.readDirWithFileTypes', uri);
 };
 const chmod$2 = (path, permissions) => {
-  return invoke$n('FileSystemFetch.chmod', path, permissions);
+  return invoke$o('FileSystemFetch.chmod', path, permissions);
 };
 const getBlob$4 = async (uri, type) => {
-  return invoke$n('FileSystemFetch.getBlob', uri, type);
+  return invoke$o('FileSystemFetch.getBlob', uri, type);
 };
 
 const FileSystemFetch = {
@@ -7669,7 +7620,7 @@ const requestPermission = async (handle, options) => {
   // query permission, but from renderer process
   // because handle.requestPermission is not implemented
   // in a worker, see https://github.com/WICG/file-system-access/issues/289
-  const permissionTypeNow = await invoke$q('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$r('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -7914,7 +7865,7 @@ const launchDebugWorker = async () => {
     url: getConfiguredWorkerUrl$i()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Initialize.initialize');
+  await invoke$s(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -8447,7 +8398,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$q(/* Audio.play */3211, /* src */src);
+  await invoke$r(/* Audio.play */3211, /* src */src);
 };
 
 const name$2l = 'Audio';
@@ -8514,11 +8465,11 @@ const promptRestart = () => {
 };
 
 const getAutoUpdateType = () => {
-  return invoke$o('AutoUpdater.getAutoUpdateType');
+  return invoke$p('AutoUpdater.getAutoUpdateType');
 };
 
 const getLatestVersion = () => {
-  return invoke$o('AutoUpdater.getLatestVersion');
+  return invoke$p('AutoUpdater.getLatestVersion');
 };
 
 const checkForUpdates$1 = async () => {
@@ -8634,14 +8585,14 @@ const PlatformPaths_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$q('FileHandles.get', ids);
+  return invoke$r('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$q('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$r('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$q('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$r('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$2g = 'FileSystemHandle';
@@ -8835,10 +8786,10 @@ const applyLegacyBulkReplacement = async (files, ranges, replacement) => {
   array(ranges);
   string(replacement);
   if (isSpecialScheme(files)) {
-    await invoke$n('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+    await invoke$o('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
     return;
   }
-  await invoke$o('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$p('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const applyFileReplacement = async edit => {
@@ -9093,7 +9044,7 @@ const launchClipBoardWorker = async () => {
     url: getConfiguredWorkerUrl$g()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'ClipBoard.initialize', platform);
+  await invoke$s(ipc, 'ClipBoard.initialize', platform);
   return ipc;
 };
 
@@ -9126,14 +9077,14 @@ const readNativeFiles = async () => {
 };
 const writeImage = async blob => {
   try {
-    return await invoke$q('ClipBoard.writeImage', blob);
+    return await invoke$r('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$q('ClipBoard.execCopy');
+    return await invoke$r('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -9160,7 +9111,7 @@ const ClipBoard_ipc = {
 };
 
 const getColorThemeNames = async () => {
-  return invoke$n('ColorTheme.getColorThemeNames');
+  return invoke$o('ColorTheme.getColorThemeNames');
 };
 
 const name$29 = 'ColorTheme';
@@ -9183,7 +9134,7 @@ const getProductNameLong = () => {
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$o('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$p('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -9195,7 +9146,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$o('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$p('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Question = 'question';
@@ -9212,7 +9163,7 @@ const prompt$3 = async (message, confirmMessage, title, cancelMessage) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$q('ConfirmPrompt.prompt', message);
+  const result = await invoke$r('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -9243,7 +9194,7 @@ const set$5 = ipc => {
 let _mockId$1 = 0;
 const showMockConfirmPrompt = async (message, options) => {
   const ipc = get$3();
-  const result = await invoke$r(ipc, 'Test.executeMock', _mockId$1, message, options);
+  const result = await invoke$s(ipc, 'Test.executeMock', _mockId$1, message, options);
   return result;
 };
 const prompt$1 = async (message, {
@@ -9283,21 +9234,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$o('ElectronContentTracing.startRecording', options);
+  return invoke$p('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$o('ElectronContentTracing.stopRecording');
+  return invoke$p('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$o('OpenExternal.showItemInFolder', fullPath);
+  return invoke$p('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$o('OpenExternal.openExternal', url);
+  return invoke$p('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -9305,7 +9256,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$o(OpenNativeFolder, /* path */absolutePath);
+    await invoke$p(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -9418,26 +9369,26 @@ const Debug_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$o('AttachDebugger.attachDebugger', pid);
+  await invoke$p('AttachDebugger.attachDebugger', pid);
 };
 
 const getPid = () => {
-  return invoke$o('Process.getPid');
+  return invoke$p('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$o('ElectronProcess.getElectronVersion');
+  return invoke$p('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$o('Process.getNodeVersion');
+  return invoke$p('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$o('ElectronProcess.getChromeVersion');
+  return invoke$p('ElectronProcess.getChromeVersion');
 };
 const getV8Version = () => {
-  return invoke$o('Process.getV8Version');
+  return invoke$p('Process.getV8Version');
 };
 const getArch = () => {
-  return invoke$o('Process.getArch');
+  return invoke$p('Process.getArch');
 };
 
 const debugSharedProcess = async () => {
@@ -9457,10 +9408,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$o('Crash.crashSharedProcess');
+  return invoke$p('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$o('Crash.crashMainProcess');
+  return invoke$p('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools$1 = () => {
@@ -9476,7 +9427,7 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$o(/* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$p(/* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
@@ -9489,7 +9440,7 @@ const openLogsFolder = async () => {
 };
 
 const getPerformanceEntries = () => {
-  return invoke$o('ElectronDeveloper.getPerformanceEntries');
+  return invoke$p('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -9730,7 +9681,7 @@ const getNodeTiming = () => {
   if (platform === Web$1) {
     return undefined;
   }
-  return invoke$o(/* command */'Performance.getNodeStartupTiming');
+  return invoke$p(/* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -9819,13 +9770,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$o(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$p(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$q('Performance.getMemory');
+  return invoke$r('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$q('Performance.measureUserAgentSpecificMemory');
+  return invoke$r('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -9874,16 +9825,16 @@ const showMemoryUsage = async () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$o(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$p(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$o(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$p(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$o(/* Developer.createProfile */'Developer.createProfile');
+  await invoke$p(/* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async () => {
-  await hydrate$3();
+  await hydrate$4();
 };
 const reloadColorTheme = async () => {
   await hydrate$8();
@@ -10061,12 +10012,12 @@ const Dialog_ipc = {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$q(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$r(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$o(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$p(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -10087,7 +10038,7 @@ const downloadJson = async (json, fileName) => {
 const downloadUrl = (url, outFile) => {
   string(url);
   string(outFile);
-  return invoke$o('Download.download', url, outFile);
+  return invoke$p('Download.download', url, outFile);
 };
 
 const name$21 = 'Download';
@@ -10165,7 +10116,7 @@ const show$9 = async (editor, message, rowIndex, columnIndex) => {
   const x$1 = x(editor, rowIndex, columnIndex);
   // @ts-ignore
   const y$1 = y(editor, rowIndex);
-  await invoke$q(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$r(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1V = {
@@ -10488,7 +10439,7 @@ const isAutoUpdateSupported = () => {
   if (platform !== Electron$1) {
     return false;
   }
-  return invoke$o('IsAutoUpdateSupported.isAutoUpdateSupported');
+  return invoke$p('IsAutoUpdateSupported.isAutoUpdateSupported');
 };
 
 const id$i = Help$1;
@@ -10800,7 +10751,7 @@ const state$g = {
 };
 const setItems = async items => {
   const windowId = await getWindowId();
-  return invoke$o('ElectronApplicationMenu.setItems', windowId, items);
+  return invoke$p('ElectronApplicationMenu.setItems', windowId, items);
 };
 const getEntryMap = async modules => {
   const map = Object.create(null);
@@ -10863,7 +10814,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$o('ElectronClipBoard.writeText', text);
+  return invoke$p('ElectronClipBoard.writeText', text);
 };
 
 const name$1Z = 'ElectronClipBoard';
@@ -10922,7 +10873,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$o('Exit.exit');
+  return invoke$p('Exit.exit');
 };
 
 const name$1V = 'Exit';
@@ -10963,13 +10914,13 @@ const executeCommand = (id, ...args) => {
   });
 };
 const searchFileWithFetch = (...args) => {
-  return invoke$n('SearchFileWithFetch.searchFileWithFetch', ...args);
+  return invoke$o('SearchFileWithFetch.searchFileWithFetch', ...args);
 };
 const searchFileWithHtml = (...args) => {
-  return invoke$n('SearchFileWithHtml.searchFileWithHtml', ...args);
+  return invoke$o('SearchFileWithHtml.searchFileWithHtml', ...args);
 };
 const searchFileWithMemory = (...args) => {
-  return invoke$n('SearchFileWithMemory.searchFileWithMemory', ...args);
+  return invoke$o('SearchFileWithMemory.searchFileWithMemory', ...args);
 };
 
 const state$f = {
@@ -11062,7 +11013,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$q('FilePicker.showDirectoryPicker', options);
+    return await invoke$r('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -11073,11 +11024,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$q('FilePicker.showFilePicker', options);
+  return invoke$r('FilePicker.showFilePicker', options);
 };
 const doShowSaveFilePicker = async options => {
   try {
-    return await invoke$q('FilePicker.showSaveFilePicker', options);
+    return await invoke$r('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -11090,7 +11041,7 @@ const doShowSaveFilePicker = async options => {
 let _mockId = 0;
 const doShowMockSaveFilePicker = async () => {
   const ipc = get$3();
-  const result = await invoke$r(ipc, 'Test.executeMock', _mockId);
+  const result = await invoke$s(ipc, 'Test.executeMock', _mockId);
   return result;
 };
 const showSaveFilePicker = async options => {
@@ -11146,7 +11097,7 @@ const name$1P = 'IconTheme';
 const Commands$1I = {
   // TODO command necessary?
   // TODO hydrate should be an alias for reload/load
-  hydrate: hydrate$3,
+  hydrate: hydrate$4,
   setIconTheme: setIconTheme,
   getFileIcon: getFileIcon$1,
   getFileIcons: getFileIcons,
@@ -11180,15 +11131,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$e.versionId) {
       return;
     }
-    await invoke$q(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$r(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$q(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$r(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$4 = async () => {
   ++state$e.versionId;
-  await invoke$q(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$r(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -11322,6 +11273,23 @@ const getCompletionWorkerUrl = () => {
   return configuredWorkerUrl;
 };
 
+const extensionHostSubWorkerUrl = `${assetDir}/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js`;
+
+const getConfiguredWorkerUrl$f = () => {
+  let configuredWorkerUrl = get$f('develop.extensionHostSubWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || extensionHostSubWorkerUrl;
+  {
+    configuredWorkerUrl = extensionHostSubWorkerUrl;
+  }
+  return configuredWorkerUrl;
+};
+const getExtensionHostSubWorkerUrl = () => {
+  return getConfiguredWorkerUrl$f();
+};
+
 const findWidgetWorkerUrl = `${assetDir}/packages/find-widget-worker/dist/findWidgetWorkerMain.js`;
 
 const getFindWidgetWorkerUrl = () => {
@@ -11336,22 +11304,19 @@ const getFindWidgetWorkerUrl = () => {
   return configuredWorkerUrl;
 };
 
-const extensionHostSubWorkerUrl = `${assetDir}/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js`;
+const hoverWorkerUrl = `${assetDir}/packages/hover-worker/dist/hoverWorkerMain.js`;
 
-const getConfiguredWorkerUrl$f = () => {
-  let configuredWorkerUrl = get$f('develop.extensionHostSubWorkerPath') || '';
+const getHoverWorkerUrl = () => {
+  let configuredWorkerUrl = get$f('develop.hoverWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
-  configuredWorkerUrl = configuredWorkerUrl || extensionHostSubWorkerUrl;
+  configuredWorkerUrl = configuredWorkerUrl || hoverWorkerUrl;
   {
-    configuredWorkerUrl = extensionHostSubWorkerUrl;
+    configuredWorkerUrl = hoverWorkerUrl;
   }
   return configuredWorkerUrl;
 };
-const getExtensionHostSubWorkerUrl = () => {
-  return getConfiguredWorkerUrl$f();
-};
 
 const renameWorkerUrl = `${assetDir}/packages/rename-worker/dist/renameWorkerMain.js`;
 
@@ -11397,6 +11362,9 @@ const wrappedCreate = options => {
   if (options && options.url && options.url.endsWith('completionWorkerMain.js')) {
     options.url = getCompletionWorkerUrl();
   }
+  if (options && options.url && options.url.endsWith('hoverWorkerMain.js')) {
+    options.url = getHoverWorkerUrl();
+  }
   if (options && options.url && options.url.endsWith('findWidgetWorkerMain.js')) {
     options.url = getFindWidgetWorkerUrl();
   }
@@ -11578,7 +11546,7 @@ const getMenuEntries$h = async (id, ...args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$y.matchingKeyBindings;
+  const keyBindings = state$x.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -12272,7 +12240,7 @@ const show$7 = async (x, y, id, mouseBlocking = false, ...args) => {
   });
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke$q(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
+  await invoke$r(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
 };
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
@@ -12294,7 +12262,7 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   const height = getMenuHeight(subMenuItems);
   const visible = getVisible(subMenu.items, -1, false, subMenu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  invoke$q(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
+  invoke$r(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
 };
 const showSubMenu = async (level, index) => {
   await showSubMenuAtEnter(level, index, -1, -1);
@@ -12354,7 +12322,7 @@ const hide$3 = async (restoreFocus = true) => {
     return;
   }
   state$b.menus = [];
-  await invoke$q(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
+  await invoke$r(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -12364,7 +12332,7 @@ const hide$3 = async (restoreFocus = true) => {
 const hideSubMenus = async level => {
   if (level < state$b.menus.length) {
     state$b.menus = state$b.menus.slice(0, level + 1);
-    await invoke$q(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
+    await invoke$r(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
   }
 };
 const MENU_DELAY_TRIANGLE = 300;
@@ -12409,7 +12377,7 @@ const handleMouseLeave = async () => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = -1;
-  await invoke$q(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
+  await invoke$r(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
 };
 const focusIndex$4 = async (menu, index) => {
   if (menu.items.length === 0) {
@@ -12417,7 +12385,7 @@ const focusIndex$4 = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  await invoke$q(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
+  await invoke$r(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
 };
 const getIndexToFocusNextStartingAt = (items, startIndex) => {
   for (let i = startIndex; i < startIndex + items.length; i++) {
@@ -12662,22 +12630,22 @@ const state$9 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$q(/* ActivityBar.focus */717115);
+  await invoke$r(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$q(/* StatusBar.focus */8882);
+  await invoke$r(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$q(/* Panel.focus */6664);
+  await invoke$r(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$q(/* SideBar.focus */5554);
+  await invoke$r(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$q(/* TitleBar.focus */1331);
+  await invoke$r(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$q(/* Main.focus */2145);
+  await invoke$r(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$9.focusedPart = part;
@@ -12788,7 +12756,7 @@ const create$T = async (type, text) => {
     type,
     text
   });
-  await invoke$q(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$r(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -12797,7 +12765,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$q(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$r(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$4 = index => {
   console.log('handle click');
@@ -12813,7 +12781,7 @@ const handleClick$4 = index => {
   });
 };
 const dispose$r = async id => {
-  await invoke$q(/* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$r(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1C = 'Notification';
@@ -12832,7 +12800,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$q(/* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$r(/* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -12908,7 +12876,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$q('Prompt.prompt', message, defaultValue);
+  return invoke$r('Prompt.prompt', message, defaultValue);
 };
 
 const name$1x = 'Prompt';
@@ -12923,7 +12891,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$o('RebuildNodePty.rebuildNodePty');
+  await invoke$p('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1w = 'RebuildNodePty';
@@ -13075,7 +13043,7 @@ const launchTestWorker = async () => {
 
 const execute$1 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$r(ipc, 'Test.execute', href);
+  await invoke$s(ipc, 'Test.execute', href);
 };
 
 const name$1p = 'Test';
@@ -13090,19 +13058,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$q('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$r('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$q('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$r('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$q('TestFrameWork.showOverlay', ...args);
+  return invoke$r('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$q('TestFrameWork.performAction', ...args);
+  return invoke$r('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$q('TestFrameWork.checkConditionError', ...args);
+  return invoke$r('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1o = 'TestFrameWork';
@@ -13197,10 +13165,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$q('PointerCapture.mock');
+  return invoke$r('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$q('PointerCapture.unmock');
+  return invoke$r('PointerCapture.unmock');
 };
 
 const name$1i = 'PointerCapture';
@@ -13303,7 +13271,7 @@ const set$4 = async (url, contentSecurityPolicy) => {
   if (platform === Web$1) {
     return;
   }
-  await invoke$o('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$p('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$3 = async (url, contentSecurityPolicy) => {
@@ -13353,7 +13321,7 @@ const {
 const create$S = async canvasId => {
   number(canvasId);
   const id = create$13();
-  await invoke$q('OffscreenCanvas.create', canvasId, id);
+  await invoke$r('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
@@ -13638,7 +13606,7 @@ const ExtensionHostClosingTagCompletion_ipc = {
 const sendMessagePortToRendererProcess$1 = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$8(initialCommand, port);
+  await invokeAndTransfer$9(initialCommand, port);
 };
 
 const name$10 = 'SendMessagePortToRendererProcess';
@@ -13699,7 +13667,7 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$r(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$s(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
@@ -13741,17 +13709,17 @@ const {
 const sendMessagePortToExtensionHostWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$5(initialCommand, port, rpcId);
+  await invokeAndTransfer$6(initialCommand, port, rpcId);
 };
 const sendMessagePortToSharedProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$6(initialCommand, port, rpcId);
+  await invokeAndTransfer$7(initialCommand, port, rpcId);
 };
 const sendMessagePortToErrorWorker = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$7(initialCommand, port, rpcId);
+  await invokeAndTransfer$8(initialCommand, port, rpcId);
 };
 const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13761,7 +13729,7 @@ const sendMessagePortToEditorWorker = async (port, initialCommand, rpcId) => {
 const sendMessagePortToRendererProcess = async (port, initialCommand, rpcId) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$8(initialCommand, port, rpcId);
+  await invokeAndTransfer$9(initialCommand, port, rpcId);
 };
 const sendMessagePortToMarkdownWorker = async (port, initialCommand, rpcId) => {
   object(port);
@@ -13773,6 +13741,11 @@ const sendMessagePortToFileSystemWorker = async (port, initialCommand, rpcId) =>
   string(initialCommand);
   await invokeAndTransfer$4(initialCommand, port, rpcId);
 };
+const sendMessagePortToIconThemeWorker = async (port, initialCommand, rpcId) => {
+  object(port);
+  string(initialCommand);
+  await invokeAndTransfer$5(initialCommand, port, rpcId);
+};
 
 // TODO add only one function sendMessagePortToRpc(rpcId) which sends it to the matching rpc module
 
@@ -13784,7 +13757,8 @@ const Commands$S = {
   sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker,
   sendMessagePortToMarkdownWorker: sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess: sendMessagePortToRendererProcess,
-  sendMessagePortToSharedProcess: sendMessagePortToSharedProcess
+  sendMessagePortToSharedProcess: sendMessagePortToSharedProcess,
+  sendMessagePortToIconThemeWorker: sendMessagePortToIconThemeWorker
 };
 
 const SendMessagePortToExtensionHostWorker_ipc = {
@@ -13871,7 +13845,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$o('ExtensionHost.getWebViews');
+  const webViews = await invoke$p('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -13904,20 +13878,20 @@ const isGitpod = getHost().endsWith('.gitpod.io');
 const WebView = 'lvce-oss-webview';
 
 const setPort = async (uid, port, origin, portType) => {
-  await invokeAndTransfer$8('WebView.setPort', uid, port, origin, portType);
+  await invokeAndTransfer$9('WebView.setPort', uid, port, origin, portType);
 };
 
 /**
  * @deprecated
  */
 const getWebViewInfo = providerId => {
-  return invoke$n('ExtensionHostWebView.getWebViewInfo', providerId);
+  return invoke$o('ExtensionHostWebView.getWebViewInfo', providerId);
 };
 const getWebViewInfo2 = providerId => {
-  return invoke$n('ExtensionHostWebView.getWebViewInfo2', providerId);
+  return invoke$o('ExtensionHostWebView.getWebViewInfo2', providerId);
 };
 const create3 = async (uri, id) => {
-  await invoke$n('WebView.create3', {
+  await invoke$o('WebView.create3', {
     id,
     uri,
     platform: platform,
@@ -13931,26 +13905,26 @@ const getSecret = key => {
   return get$f(key);
 };
 const registerInterceptor = async (id, port) => {
-  await invokeAndTransfer$5('WebView.registerInterceptor', id, port);
+  await invokeAndTransfer$6('WebView.registerInterceptor', id, port);
 };
 const unregisterInterceptor = async id => {
-  await invoke$n('WebView.unregisterInterceptor', id);
+  await invoke$o('WebView.unregisterInterceptor', id);
 };
 const compat = {
   sharedProcessInvoke(...args) {
-    return invoke$o(...args);
+    return invoke$p(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$q(...args);
+    return invoke$r(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
-    return invokeAndTransfer$8(...args);
+    return invokeAndTransfer$9(...args);
   },
   extensionHostWorkerInvokeAndTransfer(...args) {
-    return invokeAndTransfer$5(...args);
+    return invokeAndTransfer$6(...args);
   },
   extensionHostWorkerInvoke(...args) {
-    return invoke$n(...args);
+    return invoke$o(...args);
   },
   getWebViews() {
     return getWebViews$1();
@@ -14009,7 +13983,7 @@ const getOrCreate$1 = () => {
 };
 const invoke$e = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$r(ipc, method, ...params);
+  return invoke$s(ipc, method, ...params);
 };
 
 const name$V = 'SearchProcess';
@@ -14038,13 +14012,16 @@ const executeTextSearchProvider = async (scheme, query) => {
   return result;
 };
 const textSearchHtml = (...args) => {
-  return invoke$n('TextSearchHtml.textSearch', ...args);
+  return invoke$o('TextSearchHtml.textSearch', ...args);
 };
 const textSearchFetch = (...args) => {
-  return invoke$n('TextSearchFetch.textSearch', ...args);
+  return invoke$o('TextSearchFetch.textSearch', ...args);
 };
 const textSearchMemory = (...args) => {
-  return invoke$n('TextSearchMemory.textSearch', ...args);
+  return invoke$o('TextSearchMemory.textSearch', ...args);
+};
+const textSearchMemory2 = (...args) => {
+  return invoke$o('TextSearchMemory.textSearch2', ...args);
 };
 
 const name$U = 'ExtensionHostTextSearch';
@@ -14052,6 +14029,7 @@ const Commands$M = {
   executeTextSearchProvider: executeTextSearchProvider,
   textSearchFetch: textSearchFetch,
   textSearchMemory: textSearchMemory,
+  textSearchMemory2: textSearchMemory2,
   textSearchHtml: textSearchHtml
 };
 
@@ -14097,65 +14075,6 @@ const Process_ipc = {
   name: name$R
 };
 
-const handleExtensionStatusUpdate = async () => {
-  // TODO inform all viewlets
-};
-const invalidateExtensionsCache = async () => {
-  try {
-    await invoke$n('Extensions.invalidateExtensionsCache');
-  } catch {
-    // ignore
-  }
-};
-const disable = async id => {
-  try {
-    if (isTest()) {
-      disabledIds = [...disabledIds, id];
-    } else {
-      await invoke$o(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
-    }
-    await invalidateExtensionsCache();
-    return undefined;
-  } catch (error) {
-    return error;
-  }
-};
-const enable = async id => {
-  try {
-    if (isTest()) {
-      disabledIds = disabledIds.filter(existing => existing !== id);
-    } else {
-      await invoke$o(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
-    }
-    await invalidateExtensionsCache();
-    return undefined;
-  } catch (error) {
-    return error;
-  }
-};
-const getAllExtensions = async () => {
-  if (platform === Web$1) {
-    return [];
-  }
-  return invoke$o(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
-};
-let disabledIds = [];
-const getExtension2 = async id => {
-  const extension = await invoke$n('Extensions.getExtension', id);
-  if (disabledIds.includes(id)) {
-    return {
-      ...extension,
-      disabled: true
-    };
-  }
-  // console.log({ extension, disabledIds, platform: Platform.platform })
-  return extension;
-};
-const getExtensionsEtag = async () => {
-  const etag = await invoke$o('ExtensionManagement.getExtensionsEtag');
-  return etag;
-};
-
 const name$Q = 'ExtensionManagement';
 const Commands$I = {
   disable: disable,
@@ -14193,10 +14112,10 @@ const Markdown_ipc = {
 };
 
 const measureTextHeight = (text, fontFamily, fontSize) => {
-  return invoke$q('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
+  return invoke$r('MeasureTextHeight.measureTextHeight', text, fontFamily, fontSize);
 };
 const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$q('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+  return invoke$r('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
 const name$O = 'MeasureTextHeight';
@@ -15183,7 +15102,7 @@ const create$O = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$K = async state => {
-  const browserViewMap = await invoke$o('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$p('ElectronBrowserView.getAll');
   return {
     ...state,
     browserViewMap
@@ -15233,7 +15152,7 @@ const create$N = (id, uri, x, y, width, height) => {
 };
 const loadContent$J = state => {
   const update = async () => {
-    await invoke$q(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$r(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -16881,8 +16800,8 @@ const create$D = (id, uri, x, y, width, height) => {
   };
 };
 const getTests = async () => {
-  const root = await invoke$o('Platform.getRoot');
-  const testPath = await invoke$o('Platform.getTestPath');
+  const root = await invoke$p('Platform.getRoot');
+  const testPath = await invoke$p('Platform.getTestPath');
   const absolutePath = `${root}/${testPath}/src`;
   const dirents = await readDirWithFileTypes$9(absolutePath);
   const filteredDirents = dirents.slice(1);
@@ -17642,7 +17561,7 @@ const Commands$u = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$q(...args);
+    await invoke$r(...args);
     return state;
   },
   async hotReload(state, editor, ...args) {
@@ -17896,6 +17815,7 @@ const launchExplorerWorker = async () => {
     name: 'Explorer Worker'
   });
   handleIpc(ipc);
+  await invoke$s(ipc, 'Explorer.initialize');
   return ipc;
 };
 
@@ -18155,7 +18075,7 @@ const launchExtensionDetailViewWorker = async () => {
     url: getConfiguredWorkerUrl$b()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'ExtensionDetail.initialize');
+  await invoke$s(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
@@ -18741,7 +18661,7 @@ const launchReferencesWorker = async () => {
     url: getConfiguredWorkerUrl$8()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'References.initialize');
+  await invoke$s(ipc, 'References.initialize');
   return ipc;
 };
 
@@ -19842,8 +19762,8 @@ const show$4 = async (state, module, currentViewletId) => {
   const newPoints = new Uint16Array(points);
   newPoints[kVisible] = 1;
   getPoints(newPoints, newPoints);
-  const x = newPoints[kTop];
-  const y = newPoints[kLeft];
+  const x = newPoints[kLeft];
+  const y = newPoints[kTop];
   const width = newPoints[kWidth];
   const height = newPoints[kHeight];
   const uid = state.uid;
@@ -19929,7 +19849,7 @@ const showPanel = state => {
 const hidePanel$1 = state => {
   return hide$2(state, Panel);
 };
-const togglePanel = (state, moduleId = None$c) => {
+const togglePanel = (state, moduleId = None$b) => {
   return toggle(state, Panel);
 };
 const showActivityBar = state => {
@@ -20226,7 +20146,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$q('Viewlet.sendMultiple', commands);
+    await invoke$r('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -21314,6 +21234,12 @@ const getTitle = uri => {
 const getLabel$3 = uri => {
   return pathBaseName(uri);
 };
+
+/**
+ *
+ * @param {string} uri
+ * @returns
+ */
 const getFileIcon = uri => {
   if (uri === 'app://keybindings') {
     return `MaskIcon${RecordKey}`;
@@ -21795,7 +21721,7 @@ const openUri = async (state, uri, focus = true, {
   const tabLabel = getLabel$3(uri);
   const tabWidth = measureTabWidth(tabLabel, tabFontWeight, tabFontSize, tabFontFamily, tabLetterSpacing);
   const tabTitle = getTitle(uri);
-  const icon = getFileIcon(uri);
+  const icon = await getFileIcon(uri);
   const newEditor = {
     uri,
     uid: instanceUid,
@@ -22088,7 +22014,7 @@ const loadContent$p = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$q('Viewlet.loadModule', MainTabs);
+  await invoke$r('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -22177,7 +22103,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$q(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$r(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -22202,7 +22128,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$q('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$r('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -23002,7 +22928,7 @@ const create$n = (id, uri, x, y, width, height) => {
 };
 const loadContent$o = state => {
   const update = async () => {
-    await invoke$q(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$r(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -23077,7 +23003,7 @@ const launchOutputViewWorker = async () => {
     url: getConfiguredWorkerUrl$6()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Output.initialize');
+  await invoke$s(ipc, 'Output.initialize');
   return ipc;
 };
 
@@ -23361,7 +23287,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$q('Viewlet.sendMultiple', commands);
+    await invoke$r('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$3)) {
       state.currentViewletId = Error$3;
     }
@@ -23512,7 +23438,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$5()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Problems.initialize');
+  await invoke$s(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -24047,10 +23973,10 @@ const loadContent$j = async state => {
   } = state;
   const listItemHeight = 22;
   const renderAllItems = true;
-  await invoke$m('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$C.workspacePath);
-  await invoke$m('QuickPick.loadContent', state.uid);
-  const diffResult = await invoke$m('QuickPick.diff2', state.uid);
-  const commands = await invoke$m('QuickPick.render2', state.uid, diffResult);
+  await invoke$n('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$B.workspacePath);
+  await invoke$n('QuickPick.loadContent', state.uid);
+  const diffResult = await invoke$n('QuickPick.diff2', state.uid);
+  const commands = await invoke$n('QuickPick.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -24062,12 +23988,12 @@ const dispose$c = state => {
 
 const wrapQuickPickCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$m(`QuickPick.${key}`, state.uid, ...args);
-    const diffResult = await invoke$m('QuickPick.diff2', state.uid);
+    await invoke$n(`QuickPick.${key}`, state.uid, ...args);
+    const diffResult = await invoke$n('QuickPick.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$m('QuickPick.render2', state.uid, diffResult);
+    const commands = await invoke$n('QuickPick.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -24078,7 +24004,7 @@ const wrapQuickPickCommand = key => {
 
 const Commands$e = {};
 const getCommands$6 = async () => {
-  const commands = await invoke$m('QuickPick.getCommandIds');
+  const commands = await invoke$n('QuickPick.getCommandIds');
   for (const command of commands) {
     Commands$e[command] = wrapQuickPickCommand(command);
   }
@@ -24092,7 +24018,7 @@ const Css$i = ["/css/parts/Progress.css"];
 const Variables$5 = ['QuickPickBackground', 'ListForeground', 'ListHoverBackground', 'ListHoverForeground', 'ListActiveSelectionBackground'];
 
 const getKeyBindings$5 = () => {
-  return invoke$m('QuickPick.getKeyBindings');
+  return invoke$n('QuickPick.getKeyBindings');
 };
 
 const hasFunctionalRender$h = true;
@@ -24107,7 +24033,7 @@ const renderItems$5 = {
 };
 const render$h = [renderItems$5];
 const renderEventListeners$6 = async () => {
-  const listeners = await invoke$m('QuickPick.renderEventListeners');
+  const listeners = await invoke$n('QuickPick.renderEventListeners');
   return listeners;
 };
 
@@ -24511,18 +24437,18 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$o('DesktopCapturer.getSources', options);
+  const sources = await invoke$p('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$q('ScreenCapture.start', captureId, options);
+  await invoke$r('ScreenCapture.start', captureId, options);
 };
 const dispose$9 = async captureId => {
   number(captureId);
-  await invoke$q('ScreenCapture.dispose', captureId);
+  await invoke$r('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
@@ -24622,7 +24548,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$r(ipc, 'TextSearch.initialize', platform);
+    await invoke$s(ipc, 'TextSearch.initialize', platform);
   } catch (error) {
     // ignore
   }
@@ -24649,7 +24575,7 @@ const doCreate = async state => {
   const itemHeight = 22;
   const value = '';
   const replacement = '';
-  await invoke$4('TextSearch.create', state.uid, state.x, state.y, state.width, state.height, state$C.workspacePath, assetDir, itemHeight, value, replacement, platform);
+  await invoke$4('TextSearch.create', state.uid, state.x, state.y, state.width, state.height, state$B.workspacePath, assetDir, itemHeight, value, replacement, platform);
 };
 const loadContent$f = async (state, savedState) => {
   await doCreate(state);
@@ -24838,7 +24764,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$3()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Initialize.initialize');
+  await invoke$s(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -25111,7 +25037,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$q('Viewlet.sendMultiple', commands);
+    await invoke$r('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -25258,7 +25184,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Initialize.initialize');
+  await invoke$s(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -25285,7 +25211,7 @@ const disposeWebContentsView = async id => {
 const getWindowZoomLevel = async () => {
   // TODO speed up resizing by avoid too many round trips
   const windowId = await getWindowId();
-  const zoomLevel = await invoke$o('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$p('ElectronWindow.getZoom', windowId);
   return zoomLevel;
 };
 
@@ -26176,7 +26102,7 @@ const loadContent$b = async state => {
     height,
     minimumSliderSize
   } = state;
-  const root = state$C.workspacePath;
+  const root = state$B.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
@@ -26231,7 +26157,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1()
   });
   handleIpc(ipc);
-  await invoke$r(ipc, 'Initialize.initialize');
+  await invoke$s(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -26270,7 +26196,7 @@ const create$a = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$a = async (state, savedState) => {
-  await invoke$1('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$C.workspacePath // TODO use workspace uri
+  await invoke$1('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$B.workspacePath // TODO use workspace uri
   );
   await invoke$1('SourceControl.loadContent', state.uid, savedState);
   const diffResult = await invoke$1('SourceControl.diff2', state.uid);
@@ -26366,7 +26292,7 @@ const hotReload$1 = async state => {
     ...state,
     items: []
   };
-  await invoke$1('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$C.workspacePath // TODO use workspace uri
+  await invoke$1('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$B.workspacePath // TODO use workspace uri
   );
   await invoke$1('SourceControl.loadContent', state.uid, savedState);
   const diffResult = await invoke$1('SourceControl.diff2', state.uid);
@@ -26924,7 +26850,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$o('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$p('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -26953,7 +26879,7 @@ const loadContent$7 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$13();
   const canvasCursorId = create$13();
-  await invoke$h('Terminal.create', canvasTextId, canvasCursorId, uid, state$C.workspacePath, command, args);
+  await invoke$h('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
   const terminal = {
     handleBlur() {
       return invoke$h('Terminal.handleBlur', uid);
@@ -27042,7 +26968,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$q(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$r(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 const getActions = state => {
@@ -27190,7 +27116,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$q('Viewlet.sendMultiple', commands);
+  await invoke$r('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -27231,7 +27157,7 @@ const focusIndex = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$q('Viewlet.sendMultiple', commands);
+  await invoke$r('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -28035,7 +27961,7 @@ const getRealUri = pathOrUri => {
   if (protocol) {
     return pathOrUri;
   }
-  return invoke$o('FileSystem.getRealUri', pathOrUri);
+  return invoke$p('FileSystem.getRealUri', pathOrUri);
 };
 
 const create = (id, uri, x, y, width, height) => {
@@ -28077,7 +28003,7 @@ const resize = (state, dimensions) => {
   };
 };
 const dispose = async state => {
-  await invoke$q('WebView.dispose', state.uid);
+  await invoke$r('WebView.dispose', state.uid);
   return state;
 };
 
@@ -28273,11 +28199,11 @@ const FileSystemAppKeyBindings = {
 
 const downloadUpdate$2 = version => {
   string(version);
-  return invoke$o('AutoUpdaterAppImage.downloadUpdate', version);
+  return invoke$p('AutoUpdaterAppImage.downloadUpdate', version);
 };
 const installAndRestart$2 = downloadPath => {
   string(downloadPath);
-  return invoke$o('AutoUpdaterAppImage.installAndRestart', downloadPath);
+  return invoke$p('AutoUpdaterAppImage.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterAppImage = {
@@ -28288,11 +28214,11 @@ const AutoUpdaterAppImage = {
 
 const downloadUpdate$1 = version => {
   string(version);
-  return invoke$o('AutoUpdaterWindowsNsis.downloadUpdate', version);
+  return invoke$p('AutoUpdaterWindowsNsis.downloadUpdate', version);
 };
 const installAndRestart$1 = downloadPath => {
   string(downloadPath);
-  return invoke$o('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
+  return invoke$p('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterNsis = {
@@ -28305,7 +28231,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$o('Exec.exec', command, args, options);
+  return invoke$p('Exec.exec', command, args, options);
 };
 
 const getDebArch = processArch => {
@@ -28330,7 +28256,7 @@ const getDownloadUrl = (repository, version, applicationName, debArch) => {
 };
 
 const getTmpDir = () => {
-  return invoke$o('Os.getTmpDir');
+  return invoke$p('Os.getTmpDir');
 };
 
 // TODO remove this code when auto update through apt is supported
@@ -28398,7 +28324,7 @@ const getItem = (items, label) => {
 const openContextMenu = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$h(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$o('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$p('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -28435,7 +28361,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$o('ElectronWindowProcessExplorer.open');
+    await invoke$p('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }
@@ -30082,7 +30008,7 @@ const QuickPickEntriesView = {
 };
 
 const searchFile$1 = async (path, value, prepare) => {
-  return invoke$m('SearchFile.searchFile', path, value, prepare, assetDir);
+  return invoke$n('SearchFile.searchFile', path, value, prepare, assetDir);
 };
 
 const searchFile = async (path, value) => {
@@ -30111,7 +30037,7 @@ const getNoResults = () => {
   };
 };
 const getPicks = async searchValue => {
-  const workspace = state$C.workspacePath;
+  const workspace = state$B.workspacePath;
   if (!workspace) {
     return [];
   }
@@ -30123,7 +30049,7 @@ const selectPick = async pick => {
   if (typeof pick === 'object') {
     pick = pick.pick;
   }
-  const workspace = state$C.workspacePath;
+  const workspace = state$B.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */absolutePath);
   return {
@@ -30166,7 +30092,7 @@ const getPickFileIcon = pick => {
   });
 };
 const isPrepared = () => {
-  const workspace = state$C.workspacePath;
+  const workspace = state$B.workspacePath;
   // TODO protocol should always be defined. For files it should use file protocol
   const protocol = getProtocol(workspace);
   return !protocol;