@lvce-editor/server 0.25.11 → 0.25.12

package/static/{da5cd48 → 0181bc1}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -93,7 +93,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/da5cd48';
+    return '/0181bc1';
   }
 };
 const assetDir = getAssetDir();
@@ -109,26 +109,26 @@ const Underline = '_';
 const T = 't';
 const DiffSeparator = '<->';
 
-const state$10 = {
+const state$11 = {
   pending: Object.create(null)
 };
 const get$e = id => {
-  return state$10.pending[id];
+  return state$11.pending[id];
 };
 const has$1 = id => {
-  return id in state$10.pending;
+  return id in state$11.pending;
 };
 const set$e = (id, value) => {
-  state$10.pending[id] = value;
+  state$11.pending[id] = value;
 };
 
 const NotFound = 404;
 
-const state$$ = {
+const state$10 = {
   id: 0
 };
 const create$17 = () => {
-  return ++state$$.id;
+  return ++state$10.id;
 };
 
 const info$1 = (...args) => {
@@ -161,7 +161,7 @@ const withResolvers = () => {
   };
 };
 
-const state$_ = {
+const state$$ = {
   callbacks: Object.create(null)
 };
 const registerPromise = () => {
@@ -170,7 +170,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = withResolvers();
-  state$_.callbacks[id] = resolve;
+  state$$.callbacks[id] = resolve;
   return {
     id,
     promise
@@ -178,13 +178,13 @@ const registerPromise = () => {
 };
 const resolve = (id, args) => {
   number(id);
-  if (!(id in state$_.callbacks)) {
+  if (!(id in state$$.callbacks)) {
     console.log(args);
     warn$1(`callback ${id} may already be disposed`);
     return;
   }
-  state$_.callbacks[id](args);
-  delete state$_.callbacks[id];
+  state$$.callbacks[id](args);
+  delete state$$.callbacks[id];
 };
 
 const ENOENT = 'ENOENT';
@@ -540,7 +540,7 @@ class VError extends Error {
   }
 }
 
-const state$Z = {
+const state$_ = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -563,26 +563,26 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$Z.load(moduleId);
+    const module = await state$_.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$Z.pendingModules[moduleId]) {
-    state$Z.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$_.pendingModules[moduleId]) {
+    state$_.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$Z.pendingModules[moduleId];
+  return state$_.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$2 = (commandId, listener) => {
-  state$Z.commands[commandId] = listener;
+  state$_.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$Z.commands) {
-    const fn = state$Z.commands[command];
+  if (command in state$_.commands) {
+    const fn = state$_.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -591,7 +591,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$Z.commands)) {
+    if (!(command in state$_.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -602,7 +602,7 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$Z.load = load;
+  state$_.load = load;
 };
 
 const Two = '2.0';
@@ -837,7 +837,7 @@ const unwrapJsonRpcResult = responseMessage => {
   throw new JsonRpcError('unexpected response message');
 };
 
-const invoke$4 = async (ipc, method, ...params) => {
+const invoke$5 = async (ipc, method, ...params) => {
   const {
     message,
     promise
@@ -859,7 +859,7 @@ const invokeAndTransfer$2 = async (ipc, transfer, method, ...params) => {
 };
 
 /* istanbul ignore file */
-const state$Y = {
+const state$Z = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -872,16 +872,16 @@ const getIpc = () => {
   });
 };
 const listen$7 = async () => {
-  console.assert(state$Y.pendingMessages.length === 0);
+  console.assert(state$Z.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc, 'renderer process');
-  state$Y.ipc = ipc;
+  state$Z.ipc = ipc;
 };
-const invoke$3 = async (method, ...params) => {
-  return invoke$4(state$Y.ipc, method, ...params);
+const invoke$4 = async (method, ...params) => {
+  return invoke$5(state$Z.ipc, method, ...params);
 };
 const invokeAndTransfer$1 = async (method, transfer, ...params) => {
-  return invokeAndTransfer$2(state$Y.ipc, transfer, method, ...params);
+  return invokeAndTransfer$2(state$Z.ipc, transfer, method, ...params);
 };
 
 const getText$4 = response => {
@@ -924,7 +924,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$3('Css.addCssStyleSheet', id, css);
+  return invoke$4('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1569,7 +1569,7 @@ const getMessage$5 = error => {
   return `Error: ${error}`;
 };
 
-const state$X = {
+const state$Y = {
   /**
    * @type {string[]}
    */
@@ -1602,10 +1602,10 @@ const showErrorDialog = async error => {
 };
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$X.seenWarnings.includes(stringified)) {
+  if (state$Y.seenWarnings.includes(stringified)) {
     return;
   }
-  state$X.seenWarnings.push(stringified);
+  state$Y.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
@@ -1663,7 +1663,7 @@ const listen$6 = method => {
   });
 };
 
-const state$W = {
+const state$X = {
   /**
    * @type {any}
    */
@@ -1674,17 +1674,17 @@ const state$W = {
 const listen$5 = async () => {
   const ipc = await listen$6(Node);
   handleIpc(ipc);
-  state$W.ipc = ipc;
+  state$X.ipc = ipc;
 };
-const invoke$2 = async (method, ...params) => {
-  const result = await invoke$4(state$W.ipc, method, ...params);
+const invoke$3 = async (method, ...params) => {
+  const result = await invoke$5(state$X.ipc, method, ...params);
   return result;
 };
 
 // TODO when shared process crashes / connection is lost: reconnect or show notification
 
 const getColorThemeJson$2 = colorThemeId => {
-  return invoke$2( /* ExtensionHost.getColorThemeJson */'ExtensionHost.getColorThemeJson', /* colorThemeId */colorThemeId);
+  return invoke$3( /* ExtensionHost.getColorThemeJson */'ExtensionHost.getColorThemeJson', /* colorThemeId */colorThemeId);
 };
 
 const getColorThemeUrlWeb = colorThemeId => {
@@ -1720,7 +1720,7 @@ const Disk = '';
 
 // TODO lazyload different file system providers
 
-const state$V = {
+const state$W = {
   fileSystems: Object.create(null)
 };
 
@@ -1749,10 +1749,10 @@ const loadFileSystem = procotol => {
   }
 };
 const getFileSystem = protocol => {
-  if (!(protocol in state$V.fileSystems)) {
-    state$V.fileSystems[protocol] = loadFileSystem(protocol);
+  if (!(protocol in state$W.fileSystems)) {
+    state$W.fileSystems[protocol] = loadFileSystem(protocol);
   }
-  return state$V.fileSystems[protocol];
+  return state$W.fileSystems[protocol];
 };
 
 const RE_PROTOCOL = /^([a-z\-]+):\/\//;
@@ -1877,28 +1877,28 @@ const canBeRestored$6 = async uri => {
 // pros
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
-const state$U = {
+const state$V = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$U.listenerMap[event] || [];
+  const listeners = state$V.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$U.listenerMap[event] ||= [];
-  if (state$U.listenerMap[event].includes(fn)) {
+  state$V.listenerMap[event] ||= [];
+  if (state$V.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$U.listenerMap[event].unshift(fn);
+    state$V.listenerMap[event].unshift(fn);
   } else {
-    state$U.listenerMap[event].push(fn);
+    state$V.listenerMap[event].push(fn);
   }
 };
 const removeListener$1 = (event, fn) => {
-  const listeners = state$U.listenerMap[event];
+  const listeners = state$V.listenerMap[event];
   if (!listeners) {
     console.info(`[info] listener for event ${event} is not registered and cannot be unregistered`);
     return;
@@ -1906,7 +1906,7 @@ const removeListener$1 = (event, fn) => {
   const index = listeners.indexOf(fn);
   listeners.splice(index, 1);
   if (listeners.length === 0) {
-    delete state$U.listenerMap[event];
+    delete state$V.listenerMap[event];
   }
 };
 
@@ -1949,7 +1949,7 @@ const SearchFileSearchFile = 'SearchFile.searchFile';
 const TextSearchSearch = 'TextSearch.search';
 const WorkspaceResolveRoot = 'Workspace.resolveRoot';
 
-const state$T = Object.create(null);
+const state$U = Object.create(null);
 const openSettingsJson = async () => {
   await execute$4( /* Main.openUri */'Main.openUri', /* uri */'app://settings.json');
 };
@@ -1968,7 +1968,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$4( /* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$2(PreferencesGetAll);
+  return invoke$3(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -1980,28 +1980,28 @@ const hydrate$a = async () => {
     // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
     // TODO probably not all preferences need to be kept in memory
     const preferences = await getPreferences();
-    Object.assign(state$T, preferences);
+    Object.assign(state$U, preferences);
   } catch (error) {
     logError(error);
   }
 };
 const get$d = key => {
-  return state$T[key];
+  return state$U[key];
 };
 const getAll$2 = () => {
-  return state$T;
+  return state$U;
 };
 const set$d = async (key, value) => {
-  state$T[key] = value;
+  state$U[key] = value;
   if (platform === Web$1) {
     const preferences = {
-      ...state$T,
+      ...state$U,
       [key]: value
     };
     await execute$4( /* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
-  const content = stringify(state$T);
+  const content = stringify(state$U);
   await writeFile$e('app://settings.json', content);
 };
 
@@ -2049,13 +2049,13 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$3( /* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$4( /* 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$S = {
+const state$T = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2066,7 +2066,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$S.colorTheme = colorThemeId;
+    state$T.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
     if (platform === Web$1) {
@@ -2086,11 +2086,11 @@ const setColorTheme$1 = async colorThemeId => {
   await set$d('workbench.colorTheme', colorThemeId);
 };
 const watch$2 = async id => {
-  if (state$S.watchedTheme === id) {
+  if (state$T.watchedTheme === id) {
     return;
   }
-  state$S.watchedTheme = id;
-  await invoke$2('ExtensionHost.watchColorTheme', id);
+  state$T.watchedTheme = id;
+  await invoke$3('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$d('workbench.colorTheme');
@@ -2145,7 +2145,7 @@ const getBrowser$1 = () => {
   return 'chromium';
 };
 
-const state$R = {
+const state$S = {
   // contexts: Object.create(null),
   contexts: {}
 };
@@ -2157,27 +2157,27 @@ const state$R = {
 // Context.get(1), Context.get(2)
 
 const get$c = key => {
-  return state$R.contexts[key];
+  return state$S.contexts[key];
 };
 const set$c = (key, value) => {
-  state$R.contexts[key] = value;
+  state$S.contexts[key] = value;
 };
 const remove$9 = key => {
-  delete state$R.contexts[key];
+  delete state$S.contexts[key];
 };
 
-const state$Q = {
+const state$R = {
   // TODO use numeric focus key
   currentFocus: ''
 };
 const get$b = () => {
-  return state$Q.currentFocus;
+  return state$R.currentFocus;
 };
 const set$b = value => {
-  state$Q.currentFocus = value;
+  state$R.currentFocus = value;
 };
 
-const state$P = {
+const state$Q = {
   keyBindings: [],
   keyBindingSets: Object.create(null),
   /**
@@ -2190,7 +2190,7 @@ const state$P = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$P.matchingKeyBindings) {
+  for (const keyBinding of state$Q.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2213,26 +2213,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$P.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$Q.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$3('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$P.matchingKeyBindings = matchingKeyBindings;
-  state$P.keyBindingIdentifiers = keyBindingIdentifiers;
+  invoke$4('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  state$Q.matchingKeyBindings = matchingKeyBindings;
+  state$Q.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings$1 = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$P.keyBindingSets) {
+  if (id in state$Q.keyBindingSets) {
     warn$1(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$P.keyBindingSets[id] = keyBindings;
+  state$Q.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$P;
+  } = state$Q;
   if (!(id in keyBindingSets)) {
     warn$1(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2327,7 +2327,7 @@ const hydrate$8 = async () => {
   update();
 };
 
-const state$O = {
+const state$P = {
   /**
    * @type {any[]}
    */
@@ -2346,7 +2346,7 @@ const getIconThemeJson = async iconThemeId => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
     };
   }
-  for (const webExtension of state$O.webExtensions) {
+  for (const webExtension of state$P.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -2359,12 +2359,12 @@ const getIconThemeJson = async iconThemeId => {
       }
     }
   }
-  return invoke$2(ExtensionHostGetIconThemeJson, /* iconThemeId */iconThemeId);
+  return invoke$3(ExtensionHostGetIconThemeJson, /* iconThemeId */iconThemeId);
 };
 
 const initialIconTheme = undefined;
 
-const state$N = {
+const state$O = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -2374,11 +2374,11 @@ const state$N = {
   iconTheme: initialIconTheme
 };
 
-const state$M = {
+const state$N = {
   openCount: 0
 };
 const isOpen = () => {
-  return state$M.openCount > 0;
+  return state$N.openCount > 0;
 };
 
 class CancelationError extends Error {
@@ -2400,13 +2400,13 @@ const mapObject = (object, fn) => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$3( /* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$4( /* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$3('WebStorage.getAll', storageType);
+  return invoke$4('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$3( /* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$4( /* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$5 = async (storageType, key) => {
@@ -2421,7 +2421,7 @@ const getJson$5 = async (storageType, key) => {
   }
 };
 const setText$3 = async (storageType, key, value) => {
-  await invoke$3( /* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$4( /* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$4 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2429,7 +2429,7 @@ const setJson$4 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = mapObject(objects, stringifyCompact);
-  await invoke$3('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$4('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2491,7 +2491,7 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value);
 };
 
-const state$L = {
+const state$M = {
   instances: Object.create(null),
   /**
    * @type {any}
@@ -2504,10 +2504,10 @@ const set$a = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$L.instances[key] = value;
+  state$M.instances[key] = value;
 };
 const getInstance = key => {
-  const fast = state$L.instances[key];
+  const fast = state$M.instances[key];
   if (fast) {
     return fast;
   }
@@ -2517,7 +2517,7 @@ const getInstance = key => {
   if (key === 'EditorText') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$L.instances)) {
+  for (const value of Object.values(state$M.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -2525,16 +2525,16 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$L.instances;
+  return key in state$M.instances;
 };
 const remove$8 = key => {
-  delete state$L.instances[key];
+  delete state$M.instances[key];
 };
 const getAllInstances = () => {
-  return state$L.instances;
+  return state$M.instances;
 };
 const getValues = () => {
-  return Object.values(state$L.instances);
+  return Object.values(state$M.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -2565,13 +2565,13 @@ const setFocusedInstance = (state, instance) => {
 };
 
 const getHref = () => {
-  return invoke$3( /* Location.getHref */'Location.getHref');
+  return invoke$4( /* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$3( /* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$4( /* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$7 = () => {
-  return invoke$3( /* Location.hydrate */'Location.hydrate');
+  return invoke$4( /* Location.hydrate */'Location.hydrate');
 };
 const getOrigin = () => {
   return location.origin;
@@ -2580,10 +2580,10 @@ const getOrigin = () => {
 const Slash$2 = Slash$3;
 
 const set$9 = title => {
-  return invoke$3('WindowTitle.set', title);
+  return invoke$4('WindowTitle.set', title);
 };
 
-const state$K = {
+const state$L = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -2601,20 +2601,20 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$K.workspacePath = path;
+  state$L.workspacePath = path;
   // @ts-ignore
-  state$K.workspaceUri = path;
-  state$K.pathSeparator = pathSeparator;
+  state$L.workspaceUri = path;
+  state$L.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async uri => {
   const path = uri.slice('file://'.length);
-  state$K.workspacePath = path;
-  state$K.workspaceUri = uri;
+  state$L.workspacePath = path;
+  state$L.workspaceUri = uri;
   await onWorkspaceChange();
 };
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$2( /* Workspace.resolveRoot */WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$3( /* Workspace.resolveRoot */WorkspaceResolveRoot);
   return resolvedRoot;
 };
 const isValid$1 = resolvedRoot => {
@@ -2628,12 +2628,12 @@ const getResolveRootFromSessionStorage = async () => {
   return resolvedRoot;
 };
 const isTest = () => {
-  return state$K.isTest;
+  return state$L.isTest;
 };
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$K.isTest = true;
+    state$L.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -2682,7 +2682,7 @@ const getResolvedRoot = async href => {
   }
 };
 const getTitle$1 = workspacePath => {
-  const pathSeparator = state$K.pathSeparator;
+  const pathSeparator = state$L.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
 };
 const getPathName = workspacePath => {
@@ -2692,41 +2692,41 @@ const getPathName = workspacePath => {
   return '';
 };
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$K.workspacePath);
+  const title = getTitle$1(state$L.workspacePath);
   await set$9(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$K.workspacePath);
+    const pathName = getPathName(state$L.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$K.workspacePath);
+  await emitEvent('workspace.change', state$L.workspacePath);
 };
 const hydrate$6 = async ({
   href
 }) => {
-  if (state$K.workspacePath) {
+  if (state$L.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$K.isTest) {
+  if (state$L.isTest) {
     return;
   }
-  if (state$K.workspacePath) {
+  if (state$L.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$K.homeDir !== resolvedRoot.homeDir) {
-    state$K.homeDir = resolvedRoot.homeDir;
+  if (state$L.homeDir !== resolvedRoot.homeDir) {
+    state$L.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$K.workspacePath = resolvedRoot.path;
-  state$K.homeDir = resolvedRoot.homeDir;
-  state$K.pathSeparator = resolvedRoot.pathSeparator;
-  state$K.workspaceUri = resolvedRoot.uri;
-  state$K.source = resolvedRoot.source;
+  state$L.workspacePath = resolvedRoot.path;
+  state$L.homeDir = resolvedRoot.homeDir;
+  state$L.pathSeparator = resolvedRoot.pathSeparator;
+  state$L.workspaceUri = resolvedRoot.uri;
+  state$L.source = resolvedRoot.source;
   await onWorkspaceChange();
 };
 
@@ -2735,10 +2735,10 @@ const hydrate$6 = async ({
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$K.workspacePath;
+  return state$L.workspacePath;
 };
 const getHomeDir = () => {
-  return state$K.homeDir;
+  return state$L.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -2746,15 +2746,15 @@ const pathBaseName = path => {
   return path.slice(path.lastIndexOf('/') + 1);
 };
 const pathRelative = path => {
-  if (path.startsWith(state$K.workspacePath)) {
-    return path.slice(state$K.workspacePath.length + 1, path.lastIndexOf('/'));
+  if (path.startsWith(state$L.workspacePath)) {
+    return path.slice(state$L.workspacePath.length + 1, path.lastIndexOf('/'));
   }
   return path;
 };
 
 // TODO this should be in FileSystem module
 const pathDirName = path => {
-  const pathSeparator = state$K.pathSeparator || '/';
+  const pathSeparator = state$L.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString;
@@ -2763,9 +2763,9 @@ const pathDirName = path => {
 };
 const getAbsolutePath = relativePath => {
   if (relativePath.startsWith('./')) {
-    return `${state$K.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
+    return `${state$L.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
   }
-  return `${state$K.workspacePath}/${relativePath}`; // TODO support windows paths
+  return `${state$L.workspacePath}/${relativePath}`; // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -2775,10 +2775,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$K.workspacePath,
-      homeDir: state$K.homeDir,
-      pathSeparator: state$K.pathSeparator,
-      uri: state$K.workspaceUri
+      path: state$L.workspacePath,
+      homeDir: state$L.homeDir,
+      pathSeparator: state$L.pathSeparator,
+      uri: state$L.workspaceUri
     }
   };
 };
@@ -2807,20 +2807,20 @@ const hydrate$5 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$3('Window.onVisibilityChange');
+  await invoke$4('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$3(viewletId);
 };
 
-const state$J = {
+const state$K = {
   idMap: Object.create(null)
 };
 const register$1 = (id, module) => {
-  state$J.idMap[id] = module;
+  state$K.idMap[id] = module;
 };
 const get$a = id => {
-  return state$J.idMap[id];
+  return state$K.idMap[id];
 };
 
 const loadModule$3 = async (id, module) => {
@@ -2830,7 +2830,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$T);
+    await addDynamicCss(id, module.getDynamicCss, state$U);
   }
 };
 
@@ -2839,17 +2839,17 @@ const ViewletManagerVisitorCss = {
   loadModule: loadModule$3
 };
 
-const state$I = {
+const state$J = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$I.menuEntries;
+  return state$J.menuEntries;
 };
 const add$1 = menuEntries => {
-  state$I.menuEntries = [...state$I.menuEntries, ...menuEntries];
+  state$J.menuEntries = [...state$J.menuEntries, ...menuEntries];
 };
 
 const loadModule$2 = (id, module) => {
@@ -2990,7 +2990,7 @@ const ViewletModuleId = {
 };
 
 // @ts-nocheck
-const state$H = {
+const state$I = {
   pendingModules: Object.create(null)
 };
 const ViewletState = {
@@ -3028,7 +3028,7 @@ const runFn = async (instance, id, key, fn, args) => {
     }
     const commands = render$J(instance.factory, oldState, newState, newState.uid || id);
     setRenderedState(id, newState);
-    await invoke$3( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$4( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3053,7 +3053,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$3( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$4( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3229,7 +3229,7 @@ const maybeRegisterEvents = module => {
         const commands = render$J(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$3( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$4( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3247,7 +3247,7 @@ const maybeRegisterMenuEntries = module => {
 };
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
-  await invoke$3( /* Viewlet.load */kLoadModule, /* id */id);
+  await invoke$4( /* Viewlet.load */kLoadModule, /* id */id);
   await loadModule$1(id, module);
   maybeRegisterWrappedCommands(id, module);
   maybeRegisterEvents(module);
@@ -3255,10 +3255,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$H.pendingModules)) {
-    state$H.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$I.pendingModules)) {
+    state$I.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$H.pendingModules[id];
+  return state$I.pendingModules[id];
 };
 
 // TODO add lots of unit tests for this
@@ -3384,7 +3384,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$3( /* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$4( /* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3433,7 +3433,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
         return allCommands;
       }
       commands.push(...extraCommands);
-      await invoke$3( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$4( /* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3454,7 +3454,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$3( /* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$4( /* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3476,10 +3476,10 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$3( /* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$4( /* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$3(kLoadModule, Error$2);
+      await invoke$4(kLoadModule, Error$2);
       commands.push([kCreate, Error$2, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3624,58 +3624,58 @@ const load$6 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$2('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$3('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
-  const windowId = await invoke$2('GetWindowId.getWindowId');
+  const windowId = await invoke$3('GetWindowId.getWindowId');
   return windowId;
 };
 
 const reload$3 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.reload', windowId);
+  return invoke$3('ElectronWindow.reload', windowId);
 };
 const minimize$2 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.minimize', windowId);
+  return invoke$3('ElectronWindow.minimize', windowId);
 };
 const unmaximize$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.unmaximize', windowId);
+  return invoke$3('ElectronWindow.unmaximize', windowId);
 };
 const maximize$2 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.maximize', windowId);
+  return invoke$3('ElectronWindow.maximize', windowId);
 };
 const close$9 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.close', windowId);
+  return invoke$3('ElectronWindow.close', windowId);
 };
 const openNew$1 = async url => {
-  return invoke$2('ElectronWindow.openNew', url);
+  return invoke$3('ElectronWindow.openNew', url);
 };
 const toggleDevtools = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.toggleDevtools', windowId);
+  return invoke$3('ElectronWindow.toggleDevtools', windowId);
 };
 const zoomIn$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.zoomIn', windowId);
+  return invoke$3('ElectronWindow.zoomIn', windowId);
 };
 const zoomOut$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.zoomOut', windowId);
+  return invoke$3('ElectronWindow.zoomOut', windowId);
 };
 const zoomReset$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.zoomReset', windowId);
+  return invoke$3('ElectronWindow.zoomReset', windowId);
 };
 const focus$a = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.focus', windowId);
+  return invoke$3('ElectronWindow.focus', windowId);
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -3698,15 +3698,15 @@ const handleKeyBinding$1 = async identifier => {
   // }
 };
 
-const state$G = {
+const state$H = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$G.isQuickPickOpen;
+  return state$H.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$G.isQuickPickOpen = false;
+  state$H.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -3725,7 +3725,7 @@ const focus$9 = async id => {
     commands.push(...render$J(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$4('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -3768,7 +3768,7 @@ const dispose$w = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$3( /* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$4( /* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -3946,7 +3946,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$3( /* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$4( /* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -3980,7 +3980,7 @@ const openWidget = async (moduleId, ...args) => {
   const layout = getState$1(Layout);
   commands.push(['Viewlet.append', layout.uid, childUid]);
   commands.push(['Viewlet.focus', childUid]);
-  await invoke$3('Viewlet.executeCommands', commands);
+  await invoke$4('Viewlet.executeCommands', commands);
   // TODO commands should be like this
   // viewlet.create quickpick
   // quickpick.setItems
@@ -3999,7 +3999,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$3( /* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$4( /* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4056,7 +4056,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$3( /* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$4( /* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 const disposeWidgetWithValue = async (id, value) => {
   try {
@@ -4094,7 +4094,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$4('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4132,7 +4132,7 @@ const getAbsoluteIconPath = (iconTheme, icon) => {
 
 const getLanguages$2 = async () => {
   // TODO handle error
-  const languages = await invoke$2( /* ExtensionHost.getLanguages */'ExtensionHost.getLanguages');
+  const languages = await invoke$3( /* ExtensionHost.getLanguages */'ExtensionHost.getLanguages');
   return languages;
 };
 const joinPath = (extensionPath, relativePath) => {
@@ -4155,7 +4155,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$O.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$P.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -4163,7 +4163,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$2( /* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$3( /* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -4215,7 +4215,7 @@ const getNthFileExtension = (file, startIndex) => {
 
 // TODO merge all of this with extension host languages module
 
-const state$F = {
+const state$G = {
   loadState: false,
   isHydrating: false,
   fileNameMap: Object.create(null),
@@ -4231,53 +4231,53 @@ const state$F = {
   hasWarned: []
 };
 const getFirstLines = () => {
-  return state$F.firstLines;
+  return state$G.firstLines;
 };
 const hasLanguageByExtension = extension => {
-  return extension in state$F.extensionMap;
+  return extension in state$G.extensionMap;
 };
 const getLanguageByExtension = extension => {
-  return state$F.extensionMap[extension];
+  return state$G.extensionMap[extension];
 };
 const hasLanguageByFileName = fileName => {
-  return fileName in state$F.fileNameMap;
+  return fileName in state$G.fileNameMap;
 };
 const getLanguageByFileName = fileName => {
-  return state$F.fileNameMap[fileName];
+  return state$G.fileNameMap[fileName];
 };
 const getTokenizeFunctionPath$1 = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$F.tokenizerMap[languageId] || '';
+  return state$G.tokenizerMap[languageId] || '';
 };
 const setHydrating = value => {
-  state$F.isHydrating = value;
+  state$G.isHydrating = value;
 };
 const setLoaded = value => {
-  state$F.loaded = true;
+  state$G.loaded = true;
 };
 const addExtension = (extension, languageId) => {
-  state$F.extensionMap[extension] = languageId;
+  state$G.extensionMap[extension] = languageId;
 };
 const addFirstLine = (regex, languageId) => {
-  state$F.firstLines.push({
+  state$G.firstLines.push({
     regex,
     languageId
   });
 };
 const hasWarned = languageId => {
-  return state$F.hasWarned.includes(languageId);
+  return state$G.hasWarned.includes(languageId);
 };
 const addWarned = languageId => {
-  return state$F.hasWarned.push(languageId);
+  return state$G.hasWarned.push(languageId);
 };
 const addFileName = (fileName, languageId) => {
-  state$F.fileNameMap[fileName] = languageId;
+  state$G.fileNameMap[fileName] = languageId;
 };
 const addTokenizer = (languageId, tokenizer) => {
-  state$F.tokenizerMap[languageId] = tokenizer;
+  state$G.tokenizerMap[languageId] = tokenizer;
 };
 const hasLoaded$1 = () => {
-  return state$F.loaded;
+  return state$G.loaded;
 };
 
 // TODO merge all of this with extension host languages module
@@ -4467,7 +4467,7 @@ const getFileNameIcon = file => {
   string(file);
   const {
     iconTheme
-  } = state$N;
+  } = state$O;
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return '';
@@ -4507,7 +4507,7 @@ const getFileIcon$2 = file => {
   return getFileNameIcon(file.name);
 };
 const getFolderIcon = folder => {
-  const iconTheme = state$N.iconTheme;
+  const iconTheme = state$O.iconTheme;
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return '';
@@ -4521,7 +4521,7 @@ const getFolderIcon = folder => {
   return getAbsoluteIconPath(iconTheme, Folder);
 };
 const getFolderIconExpanded = folder => {
-  const iconTheme = state$N.iconTheme;
+  const iconTheme = state$O.iconTheme;
   if (!iconTheme) {
     return '';
   }
@@ -4550,7 +4550,7 @@ const getIcon$2 = dirent => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$N.iconTheme, File$6);
+      return getAbsoluteIconPath(state$O.iconTheme, File$6);
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$h;
@@ -4560,8 +4560,8 @@ const getIcon$2 = dirent => {
 const setIconTheme = async iconThemeId => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$N.iconTheme = iconTheme.json;
-    state$N.extensionPath = iconTheme.extensionPath;
+    state$O.iconTheme = iconTheme.json;
+    state$O.extensionPath = iconTheme.extensionPath;
     const instances = getAllInstances();
     // TODO have one recalculate style and one paint
     for (const [key, value] of Object.entries(instances)) {
@@ -4586,7 +4586,7 @@ const hydrate$3 = async () => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$3('InitData.getInitData');
+  const rendererProcessInitData = await invoke$4('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -4617,27 +4617,27 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$E = {
+const state$F = {
   listenerMap: Object.create(null),
   phase: Zero
 };
 const once = (event, listener) => {
-  if (state$E.phase >= event) {
+  if (state$F.phase >= event) {
     listener();
   } else {
     // TODO could also statically allocate listenermap at start as array[13]
-    state$E.listenerMap[event] ||= [];
-    state$E.listenerMap[event].push(listener);
+    state$F.listenerMap[event] ||= [];
+    state$F.listenerMap[event].push(listener);
   }
 };
 const mark$1 = event => {
-  const listeners = state$E.listenerMap[event] || [];
+  const listeners = state$F.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$E.phase = event;
+  state$F.phase = event;
   if (event === Twelve) {
-    state$E.listenerMap = Object.create(null);
+    state$F.listenerMap = Object.create(null);
   }
 };
 
@@ -4868,40 +4868,40 @@ const LoadIconTheme = 'code/loadIconTheme';
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$2( /* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$3( /* Platform.getExtensionsPath */'Platform.getExtensionsPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$2( /* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$3( /* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
-  return invoke$2( /* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$3( /* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$2( /* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$3( /* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$2( /* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$3( /* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$2( /* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$3( /* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
   if (platform === Web$1) {
     return 'recently-opened';
   }
-  return invoke$2( /* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$3( /* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$2( /* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$3( /* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$2( /* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$3( /* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getExtensionHostWorkerUrl = () => {
   return `${assetDir}/packages/extension-host-worker/dist/extensionHostWorkerMain.js`;
@@ -4910,7 +4910,7 @@ const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$2( /* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$3( /* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -4925,7 +4925,7 @@ const getTestPath = () => {
   }
 };
 const getRepository = () => {
-  return invoke$2('Platform.getRepository');
+  return invoke$3('Platform.getRepository');
 };
 
 const addPath = (paths, path) => {
@@ -4979,7 +4979,7 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$2(RecentlyOpenedAddPath, path);
+  await invoke$3(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
   switch (platform) {
@@ -5018,12 +5018,12 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`;
 };
 
-const state$D = {
+const state$E = {
   sessionId: ''
 };
 const getSessionId = () => {
-  state$D.sessionId ||= creareSessionId();
-  return state$D.sessionId;
+  state$E.sessionId ||= creareSessionId();
+  return state$E.sessionId;
 };
 
 const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
@@ -5313,7 +5313,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state$C = {
+const state$D = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -5331,7 +5331,7 @@ const isDataCloneError = error => {
 
 const getDb$1 = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$C.dbVersion, {
+  const db = await openDB('session', state$D.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -5346,8 +5346,8 @@ const getDb$1 = async () => {
   return db;
 };
 const getDbMemoized$1 = async () => {
-  state$C.cachedDb ||= await getDb$1();
-  return state$C.cachedDb;
+  state$D.cachedDb ||= await getDb$1();
+  return state$D.cachedDb;
 };
 const saveValue$1 = async (storeId, value) => {
   try {
@@ -5374,7 +5374,7 @@ const getValuesByIndexName$1 = async (storeId, indexName, only) => {
 };
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state$C.dbVersion, {
+  const db = await openDB('handle', state$D.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         await db.createObjectStore('file-handles-store', {});
@@ -5430,7 +5430,7 @@ const addSearchParam = (href, key, value) => {
   return parsedUrl.toString();
 };
 const replayCurrentSession = async () => {
-  if (!state$D.sessionId) {
+  if (!state$E.sessionId) {
     throw new VError('session replay is disabled in settings');
   }
   // TODO
@@ -5450,7 +5450,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getEvents(sessionId);
-  const originalIpc = state$Y.ipc;
+  const originalIpc = state$Z.ipc;
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalOnMessage = originalIpc.onmessage.bind(originalIpc);
   const wrappedSend = () => {};
@@ -5465,33 +5465,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$Y.ipc.onmessage = originalOnMessage;
-          state$Y.ipc.send = originalSend;
+          state$Z.ipc.onmessage = originalOnMessage;
+          state$Z.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$Y.ipc.onmessage = wrappedOnMessage;
-          state$Y.ipc.send = wrappedSend;
+          state$Z.ipc.onmessage = wrappedOnMessage;
+          state$Z.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$Y.ipc.onmessage = originalOnMessage;
-          state$Y.ipc.send = originalSend;
+          state$Z.ipc.onmessage = originalOnMessage;
+          state$Z.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$Y.ipc.onmessage = wrappedOnMessage;
-          state$Y.ipc.send = wrappedSend;
+          state$Z.ipc.onmessage = wrappedOnMessage;
+          state$Z.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$Y.ipc.onmessage = originalOnMessage;
-          state$Y.ipc.send = originalSend;
+          state$Z.ipc.onmessage = originalOnMessage;
+          state$Z.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$Y.ipc.onmessage = wrappedOnMessage;
-          state$Y.ipc.send = wrappedSend;
+          state$Z.ipc.onmessage = wrappedOnMessage;
+          state$Z.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$Y.ipc.send = wrappedSend;
-  state$Y.ipc.onmessage = wrappedOnMessage;
+  state$Z.ipc.send = wrappedSend;
+  state$Z.ipc.onmessage = wrappedOnMessage;
   const callbacks = Object.create(null);
   const invoke = event => {
     return new Promise((resolve, reject) => {
@@ -5572,8 +5572,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$Y.ipc = wrapIpc(state$Y.ipc, 'renderer-process', event => event.data);
-  state$W.ipc = wrapIpc(state$W.ipc, 'shared-process', event => event);
+  state$Z.ipc = wrapIpc(state$Z.ipc, 'renderer-process', event => event.data);
+  state$X.ipc = wrapIpc(state$X.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4( /* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -5657,7 +5657,7 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$3('Viewlet.executeCommands', commands);
+  await invoke$4('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -6393,10 +6393,27 @@ const IpcParentWithNode = {
 const sendMessagePortToElectron = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  const ipc = state$W.ipc;
+  const ipc = state$X.ipc;
   await invokeAndTransfer$2(ipc, [port], initialCommand);
 };
 
+const getPortTuple = initialPort => {
+  if (initialPort) {
+    return {
+      port1: undefined,
+      port2: initialPort
+    };
+  }
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
 const create$V = async options => {
   switch (platform) {
     case Web$1:
@@ -6414,7 +6431,7 @@ const create$V = async options => {
       const {
         port1,
         port2
-      } = new MessageChannel();
+      } = getPortTuple(options.port);
       await sendMessagePortToElectron(port2, options.initialCommand);
       return port1;
     default:
@@ -6497,14 +6514,14 @@ const Rejected$1 = 'rejected';
 const webExtensionsUrl = `${assetDir}/config/webExtensions.json`;
 
 const getSharedProcessExtensions$1 = () => {
-  return invoke$2( /* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+  return invoke$3( /* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
 };
 const getStaticWebExtensions = () => {
   return execute$4('Ajax.getJson', webExtensionsUrl);
 };
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$O.webExtensions];
+  return [...staticWebExtensions, ...state$P.webExtensions];
 };
 const isWebExtension = extension => {
   return extension && typeof extension.browser === 'string';
@@ -6513,7 +6530,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions$1();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$O.webExtensions];
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$P.webExtensions];
 };
 const getWebExtensions = async () => {
   try {
@@ -6524,7 +6541,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault();
     }
   } catch {
-    return state$O.webExtensions;
+    return state$P.webExtensions;
   }
 };
 
@@ -6554,7 +6571,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$O.webExtensions.push(manifest);
+  state$P.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -6626,7 +6643,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getSharedProcessExtensions = () => {
-  return invoke$2( /* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+  return invoke$3( /* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
 };
 const getExtensions$1 = async () => {
   if (platform === Web$1) {
@@ -7021,7 +7038,7 @@ const listen = ipc => {
   ipc.onmessage = handleMessage;
   return {
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
+      return invoke$5(ipc, method, ...params);
     }
   };
 };
@@ -7035,7 +7052,7 @@ const ExtensionHostState = {
   Running: 2,
   Error: 3
 };
-const state$B = {
+const state$C = {
   extensionPromiseCache: Object.create(null),
   extensionHosts: Object.create(null),
   pendingIpcs: Object.create(null)
@@ -7046,7 +7063,7 @@ const state$B = {
 // }
 
 const startExtensionHost = async (name, ipcType) => {
-  const exisingIpcPromise = state$B.pendingIpcs[name];
+  const exisingIpcPromise = state$C.pendingIpcs[name];
   if (exisingIpcPromise) {
     const ipc = await exisingIpcPromise;
     return {
@@ -7054,21 +7071,21 @@ const startExtensionHost = async (name, ipcType) => {
       ipc
     };
   }
-  if (state$B.extensionHosts[name]) {
-    return state$B.extensionHosts[name];
+  if (state$C.extensionHosts[name]) {
+    return state$C.extensionHosts[name];
   }
   const promise = listen$1(ipcType).then(listen);
-  state$B.pendingIpcs[name] = promise;
+  state$C.pendingIpcs[name] = promise;
   const ipc = await promise;
-  state$B.extensionHosts[name] = {
+  state$C.extensionHosts[name] = {
     state: ExtensionHostState.Running,
     ipc,
     name: ipcType
   };
-  return state$B.extensionHosts[name];
+  return state$C.extensionHosts[name];
 };
 
-const state$A = {
+const state$B = {
   /**
    * @type {readonly any[]}
    */
@@ -7130,15 +7147,15 @@ const startSynching = async extensionHost => {
     await handleEditorCreate(editorInstance.state);
   }
   // @ts-ignore
-  await handleWorkspaceChange(state$K.workspacePath);
+  await handleWorkspaceChange(state$L.workspacePath);
   extensionHost.ipc.invoke('ExtensionHostConfiguration.setConfiguration', getAll$2());
 };
 const actuallyActivateExtension = async (extensionHost, extension) => {
-  if (!(extension.id in state$A.activatedExtensions)) {
+  if (!(extension.id in state$B.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin$1);
-    state$A.activatedExtensions[extension.id] = extensionHost.ipc.invoke(ExtensionActivate, extension, absolutePath);
+    state$B.activatedExtensions[extension.id] = extensionHost.ipc.invoke(ExtensionActivate, extension, absolutePath);
   }
-  return state$A.activatedExtensions[extension.id];
+  return state$B.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
@@ -7170,7 +7187,7 @@ const actuallyActivateByEvent = async event => {
       extensionHosts.push(extensionHost);
     }
   }
-  state$A.extensionHosts = extensionHosts;
+  state$B.extensionHosts = extensionHosts;
 
   // TODO support querying completion items from multiple extension hosts
   // e.g. completion items from node extension host and word based completions from web worker extension host
@@ -7181,17 +7198,17 @@ const actuallyActivateByEvent = async event => {
 const activateByEvent = async event => {
   string(event);
   if (event === 'none') {
-    const all = await Promise.all(Object.values(state$A.cachedActivationEvents));
+    const all = await Promise.all(Object.values(state$B.cachedActivationEvents));
     const flatAll = all.flat(1);
     return [flatAll[0]];
   }
-  if (!(event in state$A.cachedActivationEvents)) {
-    state$A.cachedActivationEvents[event] = actuallyActivateByEvent(event);
+  if (!(event in state$B.cachedActivationEvents)) {
+    state$B.cachedActivationEvents[event] = actuallyActivateByEvent(event);
   }
-  return state$A.cachedActivationEvents[event];
+  return state$B.cachedActivationEvents[event];
 };
 const getExtensionHosts = () => {
-  return state$A.extensionHosts;
+  return state$B.extensionHosts;
 };
 
 const executeProviders = async ({
@@ -7457,11 +7474,11 @@ const FileSystemData = {
 };
 
 const name$22 = 'Memory';
-const state$z = {
+const state$A = {
   files: Object.create(null)
 };
 const getDirent$2 = uri => {
-  return state$z.files[uri];
+  return state$A.files[uri];
 };
 const readFile$a = uri => {
   const dirent = getDirent$2(uri);
@@ -7478,7 +7495,7 @@ const ensureParentDir = uri => {
   let endIndex = uri.indexOf(Slash$2);
   while (endIndex >= 0) {
     const part = uri.slice(startIndex, endIndex + 1);
-    state$z.files[part] = {
+    state$A.files[part] = {
       type: Directory$1,
       content: ''
     };
@@ -7491,7 +7508,7 @@ const writeFile$a = (uri, content) => {
     dirent.content = content;
   } else {
     ensureParentDir(uri);
-    state$z.files[uri] = {
+    state$A.files[uri] = {
       type: File$5,
       content
     };
@@ -7502,7 +7519,7 @@ const mkdir$3 = uri => {
     uri += Slash$2;
   }
   ensureParentDir(uri);
-  state$z.files[uri] = {
+  state$A.files[uri] = {
     type: Directory$1,
     content: ''
   };
@@ -7512,13 +7529,13 @@ const getPathSeparator$5 = () => {
 };
 const remove$3 = uri => {
   const toDelete = [];
-  for (const key of Object.keys(state$z.files)) {
+  for (const key of Object.keys(state$A.files)) {
     if (key.startsWith(uri)) {
       toDelete.push(key);
     }
   }
   for (const key of toDelete) {
-    delete state$z.files[key];
+    delete state$A.files[key];
   }
 };
 const readDirWithFileTypes$4 = uri => {
@@ -7526,7 +7543,7 @@ const readDirWithFileTypes$4 = uri => {
     uri += Slash$2;
   }
   const dirents = [];
-  for (const [key, value] of Object.entries(state$z.files)) {
+  for (const [key, value] of Object.entries(state$A.files)) {
     if (key.startsWith(uri)) {
       switch (value.type) {
         case Directory$1:
@@ -7563,7 +7580,7 @@ const FileSystemMemory = {
   readDirWithFileTypes: readDirWithFileTypes$4,
   readFile: readFile$a,
   remove: remove$3,
-  state: state$z,
+  state: state$A,
   writeFile: writeFile$a
 };
 
@@ -7571,18 +7588,18 @@ const FileSystemMemory = {
 // FileSystemError
 
 const name$21 = 'Web';
-const state$y = {
+const state$z = {
   watchers: Object.create(null),
   saveListeners: [],
   files: Object.create(null)
 };
-state$y.files['/languages/index.dart'] = `void main() {
+state$z.files['/languages/index.dart'] = `void main() {
   print('Hello, World!');
 }`;
-state$y.files['/languages/index.js'] = `const add = (a, b) => {
+state$z.files['/languages/index.js'] = `const add = (a, b) => {
   return a + b;
 }`;
-state$y.files['/languages/scrolling.txt'] = `line 1
+state$z.files['/languages/scrolling.txt'] = `line 1
 line 2
 line 3
 line 4
@@ -7683,8 +7700,8 @@ line 98
 line 99
 line 100
 `;
-state$y.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
-state$y.files['/languages/index.css'] = `h1 {
+state$z.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
+state$z.files['/languages/index.css'] = `h1 {
   font-size: 24px;
 }
 
@@ -7704,7 +7721,7 @@ state$y.files['/languages/index.css'] = `h1 {
   tab-size: 2;
 }
 `;
-state$y.files['/languages/index.ex'] = `defmodule RealWorld do
+state$z.files['/languages/index.ex'] = `defmodule RealWorld do
   @moduledoc """
   RealWorld keeps the contexts that define your domain
   and business logic.
@@ -7712,7 +7729,7 @@ state$y.files['/languages/index.ex'] = `defmodule RealWorld do
   if it comes from the database, an external API or others.
   """
 end`;
-state$y.files['/languages/index.jl'] = `function mandelbrot(a)
+state$z.files['/languages/index.jl'] = `function mandelbrot(a)
 z = 0
 for i=1:50
 z = z^2 + a
@@ -7726,7 +7743,7 @@ abs(mandelbrot(complex(x, y))) < 2 ? print("*") : print(" ")
 end
 println()
 end`;
-state$y.files['/languages/index.pl'] = `#!/usr/bin/perl
+state$z.files['/languages/index.pl'] = `#!/usr/bin/perl
 #
 # The traditional first program.
 
@@ -7736,15 +7753,15 @@ use warnings;
 
 # Print a message.
 print "Hello, World!\n";`;
-state$y.files['/languages/index.kt'] = `fun main(args : Array<String>) {
+state$z.files['/languages/index.kt'] = `fun main(args : Array<String>) {
   println("Hello, World!")
 }`;
-state$y.files['/languages/index.java'] = `class HelloWorld {
+state$z.files['/languages/index.java'] = `class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello, World!");
   }
 }`;
-state$y.files['/languages/index.cpp'] = `using namespace std;
+state$z.files['/languages/index.cpp'] = `using namespace std;
 
 template <class ANYTYPE>
 void thing(int a, Blah other_thing, double c=10, ANYTYPE f) {
@@ -7763,17 +7780,17 @@ int main(char arg_num, char** vargs) {
 
     #error I should be able to write single quotes in here: Don't make errors
 }`;
-state$y.files['/languages/index.env'] = 'KEY=42';
-state$y.files['/sample-folder/a.txt'] = '';
-state$y.files['/sample-folder/b.txt'] = '';
-state$y.files['/sample-folder/c.txt'] = '';
+state$z.files['/languages/index.env'] = 'KEY=42';
+state$z.files['/sample-folder/a.txt'] = '';
+state$z.files['/sample-folder/b.txt'] = '';
+state$z.files['/sample-folder/c.txt'] = '';
 
 // const getRelativePath = (path) => {
 //   return path.slice('/workspace'.length)
 // }
 
 const readFile$9 = async path => {
-  const file = state$y.files[path];
+  const file = state$z.files[path];
   if (file === undefined) {
     throw new Error(`file not found ${path}`);
   }
@@ -7795,7 +7812,7 @@ const createFolder = async path => {
   throw new Error('not implemented');
 };
 const writeFile$9 = async (path, content) => {
-  state$y.files[path] = content;
+  state$z.files[path] = content;
 };
 const getDirent$1 = (path, relativePath) => {
   const rest = path.slice(relativePath.length + 1);
@@ -7812,7 +7829,7 @@ const getDirent$1 = (path, relativePath) => {
 };
 const readDirWithFileTypes$3 = path => {
   const dirents = [];
-  for (const key in state$y.files) {
+  for (const key in state$z.files) {
     if (key.startsWith(path)) {
       const dirent = getDirent$1(key, path);
       if (!dirents.some(otherDirent => otherDirent.name === dirent.name)) {
@@ -7858,7 +7875,7 @@ const FileSystemWeb = {
   readFile: readFile$9,
   remove: remove$2,
   rename: rename$4,
-  state: state$y,
+  state: state$z,
   unwatch,
   unwatchAll,
   watch: watch$1,
@@ -7867,7 +7884,7 @@ const FileSystemWeb = {
 
 const canBeRestored$3 = true;
 const name$20 = 'Fetch';
-const state$x = {
+const state$y = {
   files: Object.create(null)
 };
 const readFile$8 = async uri => {
@@ -7927,7 +7944,7 @@ const FileSystemFetch = {
   readDirWithFileTypes: readDirWithFileTypes$2,
   readFile: readFile$8,
   remove: remove$1,
-  state: state$x,
+  state: state$y,
   writeFile: writeFile$8
 };
 
@@ -7938,26 +7955,26 @@ const getRemoteSrc = uri => {
 
 const name$1$ = 'Disk';
 const copy$9 = (source, target) => {
-  return invoke$2(FileSystemCopy, /* source */source, /* target */target);
+  return invoke$3(FileSystemCopy, /* source */source, /* target */target);
 };
 const readFile$7 = (path, encoding) => {
-  return invoke$2(FileSystemReadFile$1, /* path */path, /* encoding */encoding);
+  return invoke$3(FileSystemReadFile$1, /* path */path, /* encoding */encoding);
 };
 const remove = path => {
-  return invoke$2(FileSystemRemove$1, /* path */path);
+  return invoke$3(FileSystemRemove$1, /* path */path);
 };
 const rename$3 = (oldUri, newUri) => {
-  return invoke$2(FileSystemRename$1, /* oldPath */oldUri, /* newPath */newUri);
+  return invoke$3(FileSystemRename$1, /* oldPath */oldUri, /* newPath */newUri);
 };
 const mkdir = path => {
-  return invoke$2(FileSystemMkdir$1, /* path */path);
+  return invoke$3(FileSystemMkdir$1, /* path */path);
 };
 const writeFile$7 = async (path, content, encoding) => {
-  await invoke$2( /* FileSystem.writeFile */FileSystemWriteFile$1, /* path */path, /* content */content, /* encoding */encoding);
+  await invoke$3( /* FileSystem.writeFile */FileSystemWriteFile$1, /* path */path, /* content */content, /* encoding */encoding);
 };
 const ensureFile = async () => {};
 const readDirWithFileTypes$1 = path => {
-  return invoke$2(FileSystemReadDirWithFileTypes$1, /* path */path);
+  return invoke$3(FileSystemReadDirWithFileTypes$1, /* path */path);
 };
 const getBlobUrl = path => {
   return getRemoteSrc(`/${path}`);
@@ -7966,16 +7983,16 @@ const getPathSeparator$2 = () => {
   if (platform === Web$1) {
     return Slash$2;
   }
-  return invoke$2(FileSystemGetPathSeparator$1);
+  return invoke$3(FileSystemGetPathSeparator$1);
 };
 const getRealPath = path => {
-  return invoke$2(FileSystemGetRealPath, /* path */path);
+  return invoke$3(FileSystemGetRealPath, /* path */path);
 };
 const stat = path => {
-  return invoke$2(FileSystemStat, /* path */path);
+  return invoke$3(FileSystemStat, /* path */path);
 };
 const chmod = (path, permissions) => {
-  return invoke$2(FileSystemChmod, /* path */path, /* permissions */permissions);
+  return invoke$3(FileSystemChmod, /* path */path, /* permissions */permissions);
 };
 const canBeRestored$2 = true;
 
@@ -8117,7 +8134,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$3('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$4('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -8142,13 +8159,13 @@ const getBaseName = (pathSeparator, path) => {
   return path.slice(path.lastIndexOf(pathSeparator) + 1);
 };
 
-const state$w = {
+const state$x = {
   handles: Object.create(null)
 };
 const addHandle = async (uri, handle) => {
   try {
     // TODO save handle in indexeddb
-    state$w.handles[uri] = handle;
+    state$x.handles[uri] = handle;
     await execute$4('IndexedDb.addHandle', uri, handle);
   } catch (error) {
     throw new VError(error, 'Failed to add handle');
@@ -8158,10 +8175,10 @@ const addHandles = async (parentUri, childHandles) => {
   const promises = [];
   for (const childHandle of childHandles) {
     const childUri = parentUri + '/' + childHandle.name;
-    if (childUri in state$w.handles) {
+    if (childUri in state$x.handles) {
       continue;
     }
-    state$w.handles[childUri] = childHandle;
+    state$x.handles[childUri] = childHandle;
     promises.push(addHandle(childUri, childHandle));
   }
   await Promise.all(promises);
@@ -8344,7 +8361,7 @@ const GetColorThemeCssCachedLocalStorage = {
 
 // TODO high memory usage in idb because of transactionDoneMap
 
-const state$v = {
+const state$w = {
   databases: Object.create(null),
   dbVersion: 2,
   /**
@@ -8355,7 +8372,7 @@ const state$v = {
 const storeId = 'lvce-keyvalue';
 const getDb = async () => {
   // @ts-ignore
-  const db = await openDB(storeId, state$v.dbVersion, {
+  const db = await openDB(storeId, state$w.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains(storeId)) {
         await db.createObjectStore(storeId, {
@@ -8367,8 +8384,8 @@ const getDb = async () => {
   return db;
 };
 const getDbMemoized = async () => {
-  state$v.cachedDb ||= await getDb();
-  return state$v.cachedDb;
+  state$w.cachedDb ||= await getDb();
+  return state$w.cachedDb;
 };
 const set$7 = async (key, value) => {
   try {
@@ -9699,7 +9716,7 @@ const create$S = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$K = async state => {
-  const browserViewMap = await invoke$2('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$3('ElectronBrowserView.getAll');
   console.log({
     browserViewMap
   });
@@ -9752,7 +9769,7 @@ const create$R = (id, uri, x, y, width, height) => {
 };
 const loadContent$J = state => {
   const update = async () => {
-    await invoke$3( /* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$4( /* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -10647,7 +10664,7 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-const state$u = {
+const state$v = {
   tokenizers: Object.create(null),
   tokenizePaths: Object.create(null),
   listeners: [],
@@ -10658,29 +10675,29 @@ const state$u = {
   connectedEditors: []
 };
 const has = languageId => {
-  return languageId in state$u.tokenizers;
+  return languageId in state$v.tokenizers;
 };
 const set$4 = (languageId, tokenizer) => {
-  state$u.tokenizers[languageId] = tokenizer;
+  state$v.tokenizers[languageId] = tokenizer;
 };
 const get$5 = languageId => {
-  return state$u.tokenizers[languageId];
+  return state$v.tokenizers[languageId];
 };
 const isPending = languageId => {
-  return languageId in state$u.pending;
+  return languageId in state$v.pending;
 };
 const addConnectedEditor$1 = id => {
-  state$u.connectedEditors.push(id);
+  state$v.connectedEditors.push(id);
 };
 const removeConnectedEditor$1 = id => {
-  const index = state$u.connectedEditors.indexOf(id);
+  const index = state$v.connectedEditors.indexOf(id);
   if (index === -1) {
     return;
   }
-  state$u.connectedEditors.splice(index, 1);
+  state$v.connectedEditors.splice(index, 1);
 };
 const isConnectedEditor = id => {
-  return state$u.connectedEditors.includes(id);
+  return state$v.connectedEditors.includes(id);
 };
 
 const handleTokenizeChange$1 = async () => {
@@ -11092,7 +11109,7 @@ const getInitialLineState = initialLineState => {
   return deepCopy(initialLineState);
 };
 
-const state$t = {
+const state$u = {
   /**
    * @type {any}
    */
@@ -11107,10 +11124,10 @@ const flattenTokensArray = tokens => {
   return flattened;
 };
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$t.warned.includes(fn)) {
+  if (state$u.warned.includes(fn)) {
     return;
   }
-  state$t.warned.push(fn);
+  state$u.warned.push(fn);
   warn$1(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 /**
@@ -11488,7 +11505,7 @@ const clamp = (num, min, max) => {
   return Math.min(Math.max(num, min), max);
 };
 
-const state$s = {
+const state$t = {
   /**
    * @type {OffscreenCanvasRenderingContext2D|undefined|null}
    */
@@ -11499,12 +11516,12 @@ const state$s = {
  * @param {()=>OffscreenCanvasRenderingContext2D} createCtx
  * @returns {OffscreenCanvasRenderingContext2D}
  */
-const getOrCreate$2 = createCtx => {
-  if (state$s.ctx) {
-    return state$s.ctx;
+const getOrCreate$3 = createCtx => {
+  if (state$t.ctx) {
+    return state$t.ctx;
   }
-  state$s.ctx = createCtx();
-  return state$s.ctx;
+  state$t.ctx = createCtx();
+  return state$t.ctx;
 };
 
 const createCtx = () => {
@@ -11516,7 +11533,7 @@ const createCtx = () => {
   return ctx;
 };
 const getContext = () => {
-  const ctx = getOrCreate$2(createCtx);
+  const ctx = getOrCreate$3(createCtx);
   return ctx;
 };
 
@@ -11729,7 +11746,7 @@ const y = (editor, rowIndex) => {
   return offsetY;
 };
 
-const state$r = {
+const state$s = {
   timeout: -1
 };
 
@@ -11751,7 +11768,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
   // @ts-ignore
   const y$1 = y(editor, rowIndex);
   const displayErrorMessage = message;
-  await invoke$3( /* Viewlet.send */'Viewlet.send', /* id */editor.uid, /* method */'showOverlayMessage', /* x */x$1, /* y */y$1, /* content */displayErrorMessage);
+  await invoke$4( /* Viewlet.send */'Viewlet.send', /* id */editor.uid, /* method */'showOverlayMessage', /* x */x$1, /* y */y$1, /* content */displayErrorMessage);
   if (!isError) {
     const handleTimeout = () => {
       editorHideMessage(editor);
@@ -11759,7 +11776,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
 
     // TODO use wrapper timing module instead of this
     // @ts-ignore
-    state$r.timeout = setTimeout(handleTimeout, 3_000);
+    state$s.timeout = setTimeout(handleTimeout, 3_000);
   }
   return editor;
 };
@@ -11776,9 +11793,9 @@ const showErrorMessage = (editor, rowIndex, columnIndex, message) => {
   return editorShowMessage(editor, rowIndex, columnIndex, message, /* isError */true);
 };
 const editorHideMessage = async editor => {
-  clearTimeout(state$r.timeout);
-  state$r.timeout = -1;
-  await invoke$3( /* Viewlet.send */'Viewlet.send', /* id */editor.uid, /* method */'hideOverlayMessage');
+  clearTimeout(state$s.timeout);
+  state$s.timeout = -1;
+  await invoke$4( /* Viewlet.send */'Viewlet.send', /* id */editor.uid, /* method */'hideOverlayMessage');
   return editor;
 };
 
@@ -12590,19 +12607,19 @@ const launchSyntaxHighlightingWorker = async () => {
   return ipc;
 };
 
-const state$q = {
+const state$r = {
   /**
    * @type {any}
    */
   workerPromise: undefined
 };
-const getOrCreate$1 = () => {
-  state$q.workerPromise ||= launchSyntaxHighlightingWorker();
-  return state$q.workerPromise;
+const getOrCreate$2 = () => {
+  state$r.workerPromise ||= launchSyntaxHighlightingWorker();
+  return state$r.workerPromise;
 };
-const invoke$1 = async (method, ...params) => {
-  const ipc = await state$q.workerPromise;
-  return invoke$4(ipc, method, ...params);
+const invoke$2 = async (method, ...params) => {
+  const ipc = await state$r.workerPromise;
+  return invoke$5(ipc, method, ...params);
 };
 
 const getLineInfo$1 = (line, tokens, TokenMap) => {
@@ -12643,8 +12660,8 @@ const getLineInfos = (lines, tokenizer, languageId) => {
   return lineInfos;
 };
 const tokenizeCodeBlockWorker = async (codeBlock, languageId, tokenizePath) => {
-  await getOrCreate$1();
-  return invoke$1('Tokenizer.tokenizeCodeBlock', codeBlock, languageId, tokenizePath);
+  await getOrCreate$2();
+  return invoke$2('Tokenizer.tokenizeCodeBlock', codeBlock, languageId, tokenizePath);
 };
 const tokenizeCodeBlock = async (codeBlock, languageId) => {
   const useSyntaxHighlightingWorker = get$d('editor.useSyntaxHighlightingWorker');
@@ -14597,24 +14614,24 @@ const load$4 = async language => {
   await activateByEvent(`onLanguage:${language}`);
 };
 
-const state$p = {
+const state$q = {
   pending: Object.create(null),
   loaded: Object.create(null)
 };
 const setPending = (id, promise) => {
-  state$p.pending[id] = promise;
+  state$q.pending[id] = promise;
 };
 const getPending = id => {
-  return state$p.pending[id];
+  return state$q.pending[id];
 };
 const hasPending = id => {
-  return id in state$p.pending;
+  return id in state$q.pending;
 };
 const removePending = id => {
-  delete state$p.pending[id];
+  delete state$q.pending[id];
 };
 const isLoaded = id => {
-  return state$p.loaded[id];
+  return state$q.loaded[id];
 };
 
 const getFonts = () => {
@@ -16016,7 +16033,7 @@ const getSavedRoot$1 = (savedState, workspacePath) => {
   return workspacePath;
 };
 const loadContent$z = async (state, savedState) => {
-  const root = getSavedRoot$1(savedState, state$K.workspacePath);
+  const root = getSavedRoot$1(savedState, state$L.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -16062,7 +16079,7 @@ const handleLanguagesChanged = state => {
   return updateIcons$1(state);
 };
 const handleWorkspaceChange$1 = async state => {
-  const newRoot = state$K.workspacePath;
+  const newRoot = state$L.workspacePath;
   const state1 = {
     ...state,
     root: newRoot
@@ -17556,7 +17573,7 @@ const restoreState = savedState => {
       deltaY: 0
     };
   }
-  const root = getSavedRoot(savedState, state$K.workspacePath);
+  const root = getSavedRoot(savedState, state$L.workspacePath);
   let minLineY = 0;
   if (savedState && typeof savedState.minLineY === 'number') {
     minLineY = savedState.minLineY;
@@ -17722,26 +17739,26 @@ const getId$2 = extension => {
 };
 
 const install$1 = id => {
-  return invoke$2(InstallExtensionInstallExtension, /* id */id);
+  return invoke$3(InstallExtensionInstallExtension, /* id */id);
 };
 
 const install = id => {
   return install$1(id);
 };
 const uninstall$1 = id => {
-  return invoke$2( /* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
+  return invoke$3( /* ExtensionManagement.uninstall */'ExtensionManagement.uninstall', /* id */id);
 };
 const disable$1 = async id => {
-  return invoke$2( /* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+  return invoke$3( /* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
 };
 const enable$1 = async id => {
-  return invoke$2( /* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+  return invoke$3( /* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
 };
 const getAllExtensions = async () => {
   if (platform === Web$1) {
     return [];
   }
-  return invoke$2( /* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke$3( /* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
 };
 const getExtension = async id => {
   const allExtensions = await getAllExtensions();
@@ -18788,30 +18805,30 @@ const dispose$m = () => {};
 
 // TODO show error / warning  when installment fails / times out
 const handleInstall = async (state, id) => {
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installing');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installing');
   try {
     await install( /* id */id);
   } catch (error) {
     // TODO have multi send command
-    await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalled');
+    await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalled');
     // TODO use command.execute
     handleError$3(error);
     return;
   }
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installed');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installed');
 };
 
 // TODO lazyload this
 const handleUninstall = async (state, id) => {
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalling');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalling');
   try {
     await uninstall$1(id);
   } catch (error) {
-    await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installed');
+    await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'installed');
     handleError$3(error);
     return;
   }
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalled');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'uninstalled');
 };
 
 // TODO lazyload this
@@ -18819,11 +18836,11 @@ const handleEnable = async (state, id) => {
   try {
     await enable$1(id);
   } catch (error) {
-    await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'disabled');
+    await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'disabled');
     handleError$3(error);
     return;
   }
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'enabled');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'enabled');
 };
 
 // TODO lazyload this
@@ -18835,16 +18852,16 @@ const handleDisable = async (state, id) => {
     handleError$3(error);
     return;
   }
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'disabled');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'setExtensionState', /* id */id, /* state */'disabled');
 };
 const openSuggest = async state => {
   const filteredSuggestions = SUGGESTIONS;
   state.suggestionState = /* Open */1;
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'openSuggest', /* suggestions */filteredSuggestions);
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'openSuggest', /* suggestions */filteredSuggestions);
 };
 const closeSuggest = async state => {
   state.suggestionState = /* Closed */0;
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'closeSuggest');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */Extensions$2, /* method */'closeSuggest');
 };
 const toggleSuggest = async state => {
   switch (state.suggestionState) {
@@ -21796,7 +21813,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$4('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -22593,11 +22610,11 @@ const ViewletLayout_ipc = {
   toggleTitleBar
 };
 
-const state$o = {
+const state$p = {
   backgroundTabs: Object.create(null)
 };
 const add = (uri, props) => {
-  state$o.backgroundTabs[uri] = props;
+  state$p.backgroundTabs[uri] = props;
 };
 
 const measureTabWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing) => {
@@ -23502,7 +23519,7 @@ const loadContent$r = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange$1);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$3('Viewlet.loadModule', MainTabs);
+  await invoke$4('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -23594,7 +23611,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$3( /* Viewlet.send */'Viewlet.send', /* id */Main$2, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$4( /* Viewlet.send */'Viewlet.send', /* id */Main$2, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -23619,7 +23636,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$3('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$4('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -24217,14 +24234,14 @@ const ViewletNoop_ipc = {
 };
 
 const open$7 = async (id, file) => {
-  await invoke$2( /* OutputChannel.open */'OutputChannel.open', id, /* path */file);
+  await invoke$3( /* OutputChannel.open */'OutputChannel.open', id, /* path */file);
 };
 const close$6 = async id => {
-  await invoke$2( /* OutputChannel.close */'OutputChannel.close', /* id */id);
+  await invoke$3( /* OutputChannel.close */'OutputChannel.close', /* id */id);
 };
 
 const STATUS_OFF = 0;
-const state$n = {
+const state$o = {
   status: STATUS_OFF,
   // TODO should be an enum state
   /**
@@ -24255,9 +24272,9 @@ const getWebExtensionManifest = async path => {
   };
 };
 const loadWebExtension = async path => {
-  object(state$n.extensionHostWorker);
+  object(state$o.extensionHostWorker);
   const manifest = await getWebExtensionManifest(path);
-  state$n.webExtensions.push(manifest);
+  state$o.webExtensions.push(manifest);
   // TODO use invoke
   // await new Promise((resolve) => {
   //   setTimeout(resolve, 120)
@@ -24327,7 +24344,7 @@ const contentLoaded$4 = async state => {
 const setOutputChannel = async (state, option) => {
   state.selectedOption = option;
   // TODO race condition
-  await invoke$3( /* viewletSend */'Viewlet.send', /* id */'Output', /* method */'clear');
+  await invoke$4( /* viewletSend */'Viewlet.send', /* id */'Output', /* method */'clear');
   // TODO race condition
   // TODO should use invoke
   await open$7('Output', state.selectedOption);
@@ -24619,7 +24636,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$4('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$2)) {
       state.currentViewletId = Error$2;
     }
@@ -25914,7 +25931,7 @@ const None$5 = '';
 
 // TODO avoid global variable
 
-const state$m = {
+const state$n = {
   // providerId: PROVIDER_NOOP,
   provider: QuickPickNoop,
   prefix: 'string-that-should-never-match-another-string'
@@ -25925,16 +25942,16 @@ const state$m = {
  */
 const name$1D = 'everything';
 const getPlaceholder$a = () => {
-  return state$m.provider.getPlaceholder();
+  return state$n.provider.getPlaceholder();
 };
 const getLabel$5 = () => {
   return '';
 };
 const getHelpEntries$8 = () => {
-  return state$m.provider.getHelpEntries();
+  return state$n.provider.getHelpEntries();
 };
 const getNoResults$9 = () => {
-  return state$m.provider.getNoResults();
+  return state$n.provider.getNoResults();
 };
 const getPrefix = value => {
   if (value.startsWith(Command)) {
@@ -25976,20 +25993,20 @@ const getQuickPickProvider = prefix => {
 const getPicks$a = async value => {
   const prefix = getPrefix(value);
   // TODO race condition
-  if (state$m.prefix !== prefix) {
-    state$m.prefix = prefix;
+  if (state$n.prefix !== prefix) {
+    state$n.prefix = prefix;
     // @ts-ignore
-    state$m.provider = await getQuickPickProvider(prefix);
+    state$n.provider = await getQuickPickProvider(prefix);
   }
   // TODO this line is a bit duplicated with getFilterValue
   const slicedValue = value.slice(prefix.length);
-  const picks = await state$m.provider.getPicks(slicedValue);
+  const picks = await state$n.provider.getPicks(slicedValue);
   return picks;
 };
 const selectPick$a = item => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   return provider.selectPick(item);
 };
 const openCommandPalette = () => {
@@ -25999,18 +26016,18 @@ const openView = () => {
   // show('view ')
 };
 const getFilterValue$9 = value => {
-  return value.slice(state$m.prefix.length);
+  return value.slice(state$n.prefix.length);
 };
 const getPickFilterValue$5 = pick => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   return provider.getPickFilterValue(pick);
 };
 const getPickDescription$4 = pick => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   // @ts-ignore
   if (provider.getPickDescription) {
     // @ts-ignore
@@ -26021,21 +26038,21 @@ const getPickDescription$4 = pick => {
 const getPickLabel$5 = pick => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   // @ts-ignore
   return provider.getPickLabel(pick);
 };
 const getPickIcon$5 = pick => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   // @ts-ignore
   return provider.getPickIcon(pick);
 };
 const getPickFileIcon$2 = pick => {
   const {
     provider
-  } = state$m;
+  } = state$n;
   // @ts-ignore
   if (provider.getPickFileIcon) {
     // @ts-ignore
@@ -26061,7 +26078,7 @@ const QuickPickEveryThing = {
   openCommandPalette,
   openView,
   selectPick: selectPick$a,
-  state: state$m
+  state: state$n
 };
 
 const filterQuickPickItem = (pattern, word) => {
@@ -28080,18 +28097,18 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$2('DesktopCapturer.getSources', options);
+  const sources = await invoke$3('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$3('ScreenCapture.start', captureId, options);
+  await invoke$4('ScreenCapture.start', captureId, options);
 };
 const dispose$b = async captureId => {
   number(captureId);
-  await invoke$3('ScreenCapture.dispose', captureId);
+  await invoke$4('ScreenCapture.dispose', captureId);
 };
 
 const create$l = (id, uri) => {
@@ -28411,7 +28428,7 @@ const handleUpdate = async (state, update) => {
         loaded: true
       };
     }
-    const root = state$K.workspacePath;
+    const root = state$L.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -28494,7 +28511,7 @@ const create$k = (id, uri, x, y, width, height) => {
     listFocused: false,
     listFocusedIndex: -1,
     inputSource: User,
-    workspacePath: state$K.workspacePath,
+    workspacePath: state$L.workspacePath,
     includeValue: '',
     excludeValue: '',
     detailsExpanded: false,
@@ -29326,7 +29343,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$4('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -29454,7 +29471,7 @@ const ViewletSideBar_ipc = {
 };
 
 const getJson$1 = url => {
-  return invoke$2('ElectronNet.getJson', url);
+  return invoke$3('ElectronNet.getJson', url);
 };
 
 const get$4 = async query => {
@@ -29469,11 +29486,38 @@ const get$3 = query => {
   return get$4(query);
 };
 
-const createWebContentsView = (restoreId, fallThroughKeyBindings) => {
-  return invoke$2('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
+const embedsWorkerUrl = `${assetDir}/packages/embeds-worker/dist/embedsWorkerMain.js`;
+
+const launchEmbedsWorker = async () => {
+  const ipc = await create$13({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url: embedsWorkerUrl,
+    name: 'Embeds Worker'
+  });
+  handleIpc(ipc, 'embeds-worker');
+  return ipc;
 };
-const disposeWebContentsView = id => {
-  return invoke$2('ElectronWebContentsView.disposeWebContentsView', id);
+
+const state$m = {
+  /**
+   * @type {any}
+   */
+  workerPromise: undefined
+};
+const getOrCreate$1 = () => {
+  state$m.workerPromise ||= launchEmbedsWorker();
+  return state$m.workerPromise;
+};
+const invoke$1 = async (method, ...params) => {
+  const ipc = await getOrCreate$1();
+  return invoke$5(ipc, method, ...params);
+};
+
+const createWebContentsView = async (restoreId, fallThroughKeyBindings) => {
+  return invoke$1('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
+};
+const disposeWebContentsView = async id => {
+  return invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
 };
 
 // TODO improve and test function
@@ -29489,32 +29533,33 @@ const getZoomLevelToPercentValue = zoomLevel => {
   }
   return 1;
 };
+
 const resizeWebContentsView = async (id, x, y, width, height) => {
   // TODO speed up resizing by avoid too many round trips
   const windowId = await getWindowId();
-  const zoomLevel = await invoke$2('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$3('ElectronWindow.getZoom', windowId);
   const zoomValue = getZoomLevelToPercentValue(zoomLevel);
   const modifiedWidth = Math.round(width * zoomValue);
   const modifiedHeight = Math.round(height * zoomValue);
-  return invoke$2('ElectronWebContentsViewFunctions.resizeBrowserView', id, x, y, modifiedWidth, modifiedHeight);
+  return invoke$1('ElectronWebContentsView.resizeWebContentsView', id, x, y, modifiedWidth, modifiedHeight);
 };
 const setIframeSrc = async (id, iframeSrc) => {
-  return invoke$2('ElectronWebContentsViewFunctions.setIframeSrc', id, iframeSrc);
+  return invoke$1('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
 };
 const focus$3 = id => {
-  return invoke$2('ElectronWebContentsViewFunctions.focus', id);
+  return invoke$3('ElectronWebContentsViewFunctions.focus', id);
 };
 const show$9 = id => {
-  return invoke$2('ElectronWebContentsViewFunctions.show', id);
+  return invoke$3('ElectronWebContentsViewFunctions.show', id);
 };
 const hide$3 = id => {
-  return invoke$2('ElectronWebContentsViewFunctions.hide', id);
+  return invoke$3('ElectronWebContentsViewFunctions.hide', id);
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  return invoke$2('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', fallthroughKeyBindings);
+  return invoke$3('ElectronWebContentsViewFunctions.setFallthroughKeyBindings', fallthroughKeyBindings);
 };
 const getStats$1 = id => {
-  return invoke$2('ElectronWebContentsViewFunctions.getStats', id);
+  return invoke$3('ElectronWebContentsViewFunctions.getStats', id);
 };
 
 const isFallThroughKeyBinding = keyBinding => {
@@ -30257,7 +30302,7 @@ const loadContent$f = async state => {
     height,
     minimumSliderSize
   } = state;
-  const root = state$K.workspacePath;
+  const root = state$L.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
@@ -31085,7 +31130,7 @@ const create$f = (id, uri, x, y, width, height) => {
 };
 const loadContent$d = state => {
   const update = async () => {
-    await invoke$3( /* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$4( /* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -31208,7 +31253,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$2('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$3('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 const terminalWorkerUrl = `${assetDir}/packages/terminal-worker/dist/terminalWorkerMain.js`;
@@ -31240,7 +31285,7 @@ const invokeAndTransfer = async (transfer, method, ...params) => {
 };
 const invoke = async (method, ...params) => {
   const ipc = await state$j.workerPromise;
-  await invoke$4(ipc, method, ...params);
+  await invoke$5(ipc, method, ...params);
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -31270,7 +31315,7 @@ const loadContent$b = async state => {
   const canvasTextId = create$17();
   const canvasCursorId = create$17();
   await getOrCreate();
-  await invoke('Terminal.create', canvasTextId, canvasCursorId, uid, state$K.workspacePath, command, args);
+  await invoke('Terminal.create', canvasTextId, canvasCursorId, uid, state$L.workspacePath, command, args);
   const terminal = {
     handleBlur() {
       return invoke('Terminal.handleBlur', uid);
@@ -31359,7 +31404,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$3( /* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$4( /* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 /**
@@ -31525,7 +31570,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$4('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -31566,7 +31611,7 @@ const focusIndex$5 = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$4('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -32368,7 +32413,7 @@ const isAutoUpdateSupported = () => {
   if (platform !== Electron$1) {
     return false;
   }
-  return invoke$2('IsAutoUpdateSupported.isAutoUpdateSupported');
+  return invoke$3('IsAutoUpdateSupported.isAutoUpdateSupported');
 };
 
 const id$8 = Help$1;
@@ -33527,20 +33572,20 @@ const getBrowser = () => {
   return `${navigator.userAgent}`;
 };
 
-const version = '0.25.11';
-const commit = 'da5cd48';
-const date = '2024-04-15T19:21:13.000Z';
+const version = '0.25.12';
+const commit = '0181bc1';
+const date = '2024-04-16T20:00:32.000Z';
 const getPid = () => {
-  return invoke$2('Process.getPid');
+  return invoke$3('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$2('ElectronProcess.getElectronVersion');
+  return invoke$3('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$2('Process.getNodeVersion');
+  return invoke$3('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$2('ElectronProcess.getChromeVersion');
+  return invoke$3('ElectronProcess.getChromeVersion');
 };
 const getVersion = () => {
   return version;
@@ -33549,13 +33594,13 @@ const getCommit = () => {
   return commit;
 };
 const getV8Version = () => {
-  return invoke$2('Process.getV8Version');
+  return invoke$3('Process.getV8Version');
 };
 const getDate = () => {
   return date;
 };
 const getArch = () => {
-  return invoke$2('Process.getArch');
+  return invoke$3('Process.getArch');
 };
 
 const getDetailStringWeb = () => {
@@ -34276,7 +34321,7 @@ const TryToGetActualImportErrorMessage = {
 
 const readText = async () => {
   try {
-    return await invoke$3('ClipBoard.readText');
+    return await invoke$4('ClipBoard.readText');
   } catch (error) {
     // @ts-ignore
     if (error.message === 'Read permission denied.') {
@@ -34293,7 +34338,7 @@ const readText = async () => {
 const writeText$1 = async text => {
   try {
     string(text);
-    await invoke$3('ClipBoard.writeText', /* text */text);
+    await invoke$4('ClipBoard.writeText', /* text */text);
   } catch (error) {
     throw new VError(error, 'Failed to write text to clipboard');
   }
@@ -34303,7 +34348,7 @@ const writeNativeFiles = async (type, files) => {
     if (platform === Web$1) {
       throw new Error('not supported');
     }
-    await invoke$2( /* command */'ClipBoard.writeFiles', /* type */type, /* files */files);
+    await invoke$3( /* command */'ClipBoard.writeFiles', /* type */type, /* files */files);
   } catch (error) {
     throw new VError(error, 'Failed to write files to native clipboard');
   }
@@ -34313,28 +34358,28 @@ const readNativeFiles = async () => {
     if (platform === Web$1) {
       throw new Error('not supported');
     }
-    return await invoke$2( /* command */'ClipBoard.readFiles');
+    return await invoke$3( /* command */'ClipBoard.readFiles');
   } catch (error) {
     throw new VError(error, 'Failed to read files from native clipboard');
   }
 };
 const writeImage = async blob => {
   try {
-    return await invoke$3('ClipBoard.writeImage', blob);
+    return await invoke$4('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$3('ClipBoard.execCopy');
+    return await invoke$4('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$2('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$3('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -34346,7 +34391,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$2('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$3('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Info = 'info';
@@ -34422,7 +34467,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$3( /* Audio.play */3211, /* src */src);
+  await invoke$4( /* Audio.play */3211, /* src */src);
 };
 
 const name$1f = 'Audio';
@@ -34470,11 +34515,11 @@ const promptRestart = () => {
 };
 
 const getAutoUpdateType = () => {
-  return invoke$2('AutoUpdater.getAutoUpdateType');
+  return invoke$3('AutoUpdater.getAutoUpdateType');
 };
 
 const getLatestVersion = () => {
-  return invoke$2('AutoUpdater.getLatestVersion');
+  return invoke$3('AutoUpdater.getLatestVersion');
 };
 
 const checkForUpdates = async () => {
@@ -34671,7 +34716,7 @@ const applyBulkReplacement = async (files, ranges, replacement) => {
   array(files);
   array(ranges);
   string(replacement);
-  await invoke$2('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$3('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const name$1b = 'BulkReplacement';
@@ -35084,7 +35129,7 @@ const prompt$3 = async (message, confirmMessage, title, cancelMessage) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$3('ConfirmPrompt.prompt', message);
+  const result = await invoke$4('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -35128,21 +35173,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$2('ElectronContentTracing.startRecording', options);
+  return invoke$3('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$2('ElectronContentTracing.stopRecording');
+  return invoke$3('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$2('OpenExternal.showItemInFolder', fullPath);
+  return invoke$3('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$2('OpenExternal.openExternal', url);
+  return invoke$3('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -35150,7 +35195,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$2(OpenNativeFolder, /* path */absolutePath);
+    await invoke$3(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -35229,7 +35274,7 @@ const ContextMenu_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$2('AttachDebugger.attachDebugger', pid);
+  await invoke$3('AttachDebugger.attachDebugger', pid);
 };
 
 const debugSharedProcess = async () => {
@@ -35249,10 +35294,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$2('Crash.crashSharedProcess');
+  return invoke$3('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$2('Crash.crashMainProcess');
+  return invoke$3('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools = () => {
@@ -35268,7 +35313,7 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$2( /* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$3( /* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
@@ -35281,7 +35326,7 @@ const openLogsFolder = async () => {
 };
 
 const getPerformanceEntries = () => {
-  return invoke$2('ElectronDeveloper.getPerformanceEntries');
+  return invoke$3('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -35518,7 +35563,7 @@ const getNodeTiming = () => {
   if (platform === Web$1) {
     return undefined;
   }
-  return invoke$2( /* command */'Performance.getNodeStartupTiming');
+  return invoke$3( /* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -35607,13 +35652,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$2( /* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$3( /* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$3('Performance.getMemory');
+  return invoke$4('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$3('Performance.measureUserAgentSpecificMemory');
+  return invoke$4('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -35666,13 +35711,13 @@ const showMemoryUsage = () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$2( /* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$3( /* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$2( /* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$3( /* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$2( /* Developer.createProfile */'Developer.createProfile');
+  await invoke$3( /* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async () => {
   await hydrate$3();
@@ -35848,12 +35893,12 @@ const Dialog_ipc = {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$3( /* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$4( /* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$2(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$3(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -35873,7 +35918,7 @@ const downloadJson = async (json, fileName) => {
 const downloadUrl = (url, outFile) => {
   string(url);
   string(outFile);
-  return invoke$2('Download.download', url, outFile);
+  return invoke$3('Download.download', url, outFile);
 };
 
 const name$Z = 'Download';
@@ -35925,7 +35970,7 @@ const show$6 = async (editor, message, rowIndex, columnIndex) => {
   const x$1 = x(editor, rowIndex, columnIndex);
   // @ts-ignore
   const y$1 = y(editor, rowIndex);
-  await invoke$3( /* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$4( /* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$U = {
@@ -36004,7 +36049,7 @@ const open$4 = async () => {
     const y$1 = y(editor, rowIndex);
     // const prepareRenameResult = await prepareRename(editor)
     // console.log({ prepareRenameResult })
-    await invoke$3( /* EditorRename.openWidget */4512, /* x */x$1, /* y */y$1);
+    await invoke$4( /* EditorRename.openWidget */4512, /* x */x$1, /* y */y$1);
   } else {
     // TODO also show error when promise rejects
     await execute$4( /* EditorError.show */3900, /* editor */editor, /* message */'You cannot rename this element', /* rowIndex */rowIndex, /* columnIndex */columnIndex);
@@ -36041,7 +36086,7 @@ const finish = async editor => {
   // TODO what happens when file is closed while rename is in progress?
   const rowIndex = editor.selections[0];
   const columnIndex = editor.selections[1];
-  await invoke$3( /* EditorRename.finish */4513);
+  await invoke$4( /* EditorRename.finish */4513);
   // TODO support canceling rename (e.g. when user presses escape)
   const workspaceEdits = await rename(editor, rowIndex, columnIndex);
   await applyWorkspaceEdits(editor, workspaceEdits);
@@ -36050,7 +36095,7 @@ const finish = async editor => {
   // console.log({ workspaceEdits })
 };
 const abort = async () => {
-  await invoke$3( /* EditorRename.closeWidget */4514);
+  await invoke$4( /* EditorRename.closeWidget */4514);
 };
 
 const name$X = 'EditorRename';
@@ -36219,7 +36264,7 @@ const state$g = {
 };
 const setItems = async items => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronApplicationMenu.setItems', windowId, items);
+  return invoke$3('ElectronApplicationMenu.setItems', windowId, items);
 };
 const getEntries = ids => {
   return Promise.all(ids.map(getMenuEntries$f));
@@ -36283,7 +36328,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$2('ElectronClipBoard.writeText', text);
+  return invoke$3('ElectronClipBoard.writeText', text);
 };
 
 const name$V = 'ElectronClipBoard';
@@ -36341,7 +36386,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$2('Exit.exit');
+  return invoke$3('Exit.exit');
 };
 
 const name$R = 'Exit';
@@ -36407,7 +36452,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$3('FilePicker.showDirectoryPicker', options);
+    return await invoke$4('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -36418,11 +36463,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$3('FilePicker.showFilePicker', options);
+  return invoke$4('FilePicker.showFilePicker', options);
 };
 const showSaveFilePicker = async options => {
   try {
-    return await invoke$3('FilePicker.showSaveFilePicker', options);
+    return await invoke$4('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -36537,15 +36582,15 @@ const show$5 = async (uri, top, left) => {
     if (version !== state$f.versionId) {
       return;
     }
-    await invoke$3( /* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$4( /* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$3( /* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$4( /* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$1 = async () => {
   ++state$f.versionId;
-  await invoke$3( /* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$4( /* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -36774,7 +36819,7 @@ const getCommandKeyBinding = (keyBindings, command, args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$P.matchingKeyBindings;
+  const keyBindings = state$Q.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -36871,7 +36916,7 @@ const show$4 = async (x, y, id, mouseBlocking = false, ...args) => {
   });
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke$3( /* 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$4( /* 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
@@ -36893,7 +36938,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$3( /* 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$4( /* 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);
@@ -36953,7 +36998,7 @@ const hide = async (restoreFocus = true) => {
     return;
   }
   state$d.menus = [];
-  await invoke$3( /* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
+  await invoke$4( /* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -36963,7 +37008,7 @@ const hide = async (restoreFocus = true) => {
 const hideSubMenus = async level => {
   if (level < state$d.menus.length) {
     state$d.menus = state$d.menus.slice(0, level + 1);
-    await invoke$3( /* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
+    await invoke$4( /* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
   }
 };
 const MENU_DELAY_TRIANGLE = 300;
@@ -37008,7 +37053,7 @@ const handleMouseLeave = async () => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = -1;
-  await invoke$3( /* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
+  await invoke$4( /* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
 };
 const focusIndex$4 = async (menu, index) => {
   if (menu.items.length === 0) {
@@ -37016,7 +37061,7 @@ const focusIndex$4 = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  await invoke$3( /* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
+  await invoke$4( /* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
 };
 const getIndexToFocusNextStartingAt = (items, startIndex) => {
   for (let i = startIndex; i < startIndex + items.length; i++) {
@@ -37260,22 +37305,22 @@ const state$b = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$3( /* ActivityBar.focus */717115);
+  await invoke$4( /* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$3( /* StatusBar.focus */8882);
+  await invoke$4( /* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$3( /* Panel.focus */6664);
+  await invoke$4( /* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$3( /* SideBar.focus */5554);
+  await invoke$4( /* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$3( /* TitleBar.focus */1331);
+  await invoke$4( /* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$3( /* Main.focus */2145);
+  await invoke$4( /* Main.focus */2145);
 };
 const focusPart = part => {
   state$b.focusedPart = part;
@@ -37386,7 +37431,7 @@ const create$1 = async (type, text) => {
     type,
     text
   });
-  await invoke$3( /* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$4( /* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -37395,7 +37440,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$3( /* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$4( /* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$6 = index => {
   console.log('handle click');
@@ -37411,7 +37456,7 @@ const handleClick$6 = index => {
   });
 };
 const dispose = async id => {
-  await invoke$3( /* Notification.dispose */'Notification.dispose', /* id */id);
+  await invoke$4( /* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$x = 'Notification';
@@ -37430,7 +37475,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$3( /* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$4( /* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -37502,7 +37547,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$3('Prompt.prompt', message, defaultValue);
+  return invoke$4('Prompt.prompt', message, defaultValue);
 };
 
 const name$s = 'Prompt';
@@ -37517,7 +37562,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$2('RebuildNodePty.rebuildNodePty');
+  await invoke$3('RebuildNodePty.rebuildNodePty');
 };
 
 const name$r = 'RebuildNodePty';
@@ -37548,10 +37593,10 @@ const RecentlyOpened_ipc = {
 };
 
 const reloadWeb = () => {
-  return invoke$3('Window.reload');
+  return invoke$4('Window.reload');
 };
 const reloadRemote = () => {
-  return invoke$3('Window.reload');
+  return invoke$4('Window.reload');
 };
 const reloadElectron = () => {
   return reload$3();
@@ -37683,7 +37728,7 @@ const launchTestWorker = async () => {
 
 const execute = async href => {
   const ipc = await launchTestWorker();
-  await invoke$4(ipc, 'Test.execute', href);
+  await invoke$5(ipc, 'Test.execute', href);
 };
 
 const name$k = 'Test';
@@ -37698,16 +37743,16 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$3('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$4('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$3('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$4('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$3('TestFrameWork.showOverlay', ...args);
+  return invoke$4('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$3('TestFrameWork.performAction', ...args);
+  return invoke$4('TestFrameWork.performAction', ...args);
 };
 
 const name$j = 'TestFrameWork';
@@ -37804,10 +37849,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$3('PointerCapture.mock');
+  return invoke$4('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$3('PointerCapture.unmock');
+  return invoke$4('PointerCapture.unmock');
 };
 
 const name$d = 'PointerCapture';
@@ -37910,7 +37955,7 @@ const set$3 = async (url, contentSecurityPolicy) => {
   if (platform === Web$1) {
     return;
   }
-  await invoke$2('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$3('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$2 = async (url, contentSecurityPolicy) => {
@@ -37945,7 +37990,7 @@ const create = async canvasId => {
     id,
     promise
   } = registerPromise();
-  await invoke$3('OffscreenCanvas.create', canvasId, id);
+  await invoke$4('OffscreenCanvas.create', canvasId, id);
   const response = await promise;
   const canvas = response.params[0];
   return canvas;
@@ -40155,7 +40200,7 @@ const handleMouseMoveWithAltKey = async (editor, x, y) => {
       token: tokenIndex
     });
     // .tokens
-    await invoke$3( /* Viewlet.invoke */'Viewlet.send', /* id */EditorText$1, /* method */'highlightAsLink', /* relativeY */definitionRelativeY, /* tokenIndex */tokenIndex);
+    await invoke$4( /* Viewlet.invoke */'Viewlet.send', /* id */EditorText$1, /* method */'highlightAsLink', /* relativeY */definitionRelativeY, /* tokenIndex */tokenIndex);
     console.log({
       definition
     });
@@ -41371,7 +41416,7 @@ const handleSelectionChange = (editor, selectionChanges) => {
   });
   const x$1 = x(editor);
   const y$1 = y(editor, editor.cursor);
-  invoke$3( /* Viewlet.send */'Viewlet.send', /* id */'EditorCompletion', /* method */'show', /* x */x$1, /* y */y$1, /* completionItems */filteredCompletionItems, /* reason */1);
+  invoke$4( /* Viewlet.send */'Viewlet.send', /* id */'EditorCompletion', /* method */'show', /* x */x$1, /* y */y$1, /* completionItems */filteredCompletionItems, /* reason */1);
 };
 const handleCursorChange = (anyEditor, cursorChange) => {
   console.log('cursor changed');
@@ -41395,7 +41440,7 @@ const openCompletion$1 = async (editor, openingReason = 1) => {
   if (editor.completionUid !== completionUid) {
     return editor;
   }
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$4('Viewlet.sendMultiple', commands);
   return editor;
 
   // if (state.isOpened) {
@@ -41480,7 +41525,7 @@ const advance = word => {
     return completionItem.includes(word);
   };
   const filteredCompletions = state.completionItems.filter(includesWord);
-  invoke$3( /* EditorCompletion.open */836, /* items */filteredCompletions, /* reason */state.openingReason);
+  invoke$4( /* EditorCompletion.open */836, /* items */filteredCompletions, /* reason */state.openingReason);
 };
 
 // export const onDidType = () => {}
@@ -44893,7 +44938,7 @@ const getColorThemeNames = async () => {
     const url = `${assetDir}/config/themes.json`;
     return execute$4( /* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$2( /* ExtensionHost.getColorThemeNames */'ExtensionHost.getColorThemeNames');
+  return invoke$3( /* ExtensionHost.getColorThemeNames */'ExtensionHost.getColorThemeNames');
 };
 
 const setColorTheme = id => {
@@ -45398,7 +45443,7 @@ const getNoResults = () => {
   };
 };
 const getPicks = async searchValue => {
-  const workspace = state$K.workspacePath;
+  const workspace = state$L.workspacePath;
   if (!workspace) {
     return [];
   }
@@ -45407,7 +45452,7 @@ const getPicks = async searchValue => {
   return files;
 };
 const selectPick = async pick => {
-  const workspace = state$K.workspacePath;
+  const workspace = state$L.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$4( /* Main.openUri */'Main.openUri', /* uri */absolutePath);
   return {
@@ -45744,7 +45789,7 @@ const textSearch$4 = async (scheme, root, query, options) => {
     ripGrepArgs,
     searchDir: root
   };
-  const result = await invoke$2(TextSearchSearch, actualOptions);
+  const result = await invoke$3(TextSearchSearch, actualOptions);
   // TODO api is weird
   return result.results;
 };
@@ -45755,7 +45800,7 @@ const TextSearchNode = {
 };
 
 const textSearch$3 = (scheme, root, query) => {
-  const entries = Object.entries(state$y.files);
+  const entries = Object.entries(state$z.files);
   const results = [];
   for (const [key, value] of entries) {
     if (value.includes(query)) {
@@ -46366,7 +46411,7 @@ const getItem = (items, label) => {
 const openContextMenu = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$f(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$2('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$3('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -46403,28 +46448,28 @@ const ViewletSimpleBrowserHandleContextMenu = {
 };
 
 const openDevtools$1 = id => {
-  return invoke$2('ElectronBrowserViewFunctions.openDevtools', id);
+  return invoke$3('ElectronBrowserViewFunctions.openDevtools', id);
 };
 const reload$1 = id => {
-  return invoke$2('ElectronBrowserViewFunctions.reload', id);
+  return invoke$3('ElectronBrowserViewFunctions.reload', id);
 };
 const forward$1 = id => {
-  return invoke$2('ElectronBrowserViewFunctions.forward', id);
+  return invoke$3('ElectronBrowserViewFunctions.forward', id);
 };
 const backward$1 = id => {
-  return invoke$2('ElectronBrowserViewFunctions.backward', id);
+  return invoke$3('ElectronBrowserViewFunctions.backward', id);
 };
 const cancelNavigation$1 = id => {
-  return invoke$2('ElectronBrowserViewFunctions.cancelNavigation', id);
+  return invoke$3('ElectronBrowserViewFunctions.cancelNavigation', id);
 };
 const inspectElement$1 = (id, x, y) => {
-  return invoke$2('ElectronBrowserViewFunctions.inspectElement', id, x, y);
+  return invoke$3('ElectronBrowserViewFunctions.inspectElement', id, x, y);
 };
 const copyImageAt = (id, x, y) => {
-  return invoke$2('ElectronBrowserViewFunctions.copyImageAt', id, x, y);
+  return invoke$3('ElectronBrowserViewFunctions.copyImageAt', id, x, y);
 };
 const getStats = id => {
-  return invoke$2('ElectronBrowserViewFunctions.getStats', id);
+  return invoke$3('ElectronBrowserViewFunctions.getStats', id);
 };
 
 const inspectElement = async (state, x, y) => {
@@ -47733,11 +47778,11 @@ const MenuEntriesTitleBarRemote = {
 
 const downloadUpdate$2 = version => {
   string(version);
-  return invoke$2('AutoUpdaterAppImage.downloadUpdate', version);
+  return invoke$3('AutoUpdaterAppImage.downloadUpdate', version);
 };
 const installAndRestart$2 = downloadPath => {
   string(downloadPath);
-  return invoke$2('AutoUpdaterAppImage.installAndRestart', downloadPath);
+  return invoke$3('AutoUpdaterAppImage.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterAppImage = {
@@ -47748,11 +47793,11 @@ const AutoUpdaterAppImage = {
 
 const downloadUpdate$1 = version => {
   string(version);
-  return invoke$2('AutoUpdaterWindowsNsis.downloadUpdate', version);
+  return invoke$3('AutoUpdaterWindowsNsis.downloadUpdate', version);
 };
 const installAndRestart$1 = downloadPath => {
   string(downloadPath);
-  return invoke$2('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
+  return invoke$3('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterNsis = {
@@ -47765,7 +47810,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$2('Exec.exec', command, args, options);
+  return invoke$3('Exec.exec', command, args, options);
 };
 
 const getDebArch = processArch => {
@@ -47790,7 +47835,7 @@ const getDownloadUrl = (repository, version, applicationName, debArch) => {
 };
 
 const getTmpDir = () => {
-  return invoke$2('Os.getTmpDir');
+  return invoke$3('Os.getTmpDir');
 };
 
 // TODO remove this code when auto update through apt is supported
@@ -47851,7 +47896,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$2('ElectronWindowProcessExplorer.open');
+    await invoke$3('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }
@@ -48096,13 +48141,13 @@ const set = async (cacheKey, value) => {
 };
 
 const gitLsFiles = (gitPath, cwd, limit) => {
-  return invoke$2('GitLsFiles.gitLsFiles', gitPath, cwd, limit);
+  return invoke$3('GitLsFiles.gitLsFiles', gitPath, cwd, limit);
 };
 const gitLsFilesHash = (gitPath, cwd, limit) => {
-  return invoke$2('GitLsFiles.gitLsFilesHash', gitPath, cwd, limit);
+  return invoke$3('GitLsFiles.gitLsFilesHash', gitPath, cwd, limit);
 };
 const resolveGit$1 = () => {
-  return invoke$2('GitLsFiles.resolveGit');
+  return invoke$3('GitLsFiles.resolveGit');
 };
 
 const state$1 = {
@@ -48139,7 +48184,7 @@ const removeLeadingSlash$1 = file => {
   return file.slice(1);
 };
 const searchFile$4 = async (path, value) => {
-  const files = state$y.files;
+  const files = state$z.files;
   const keys = Object.keys(files).map(removeLeadingSlash$1);
   return keys;
 };
@@ -48150,7 +48195,7 @@ const SearchFileWeb = {
 };
 
 const searchFile$3 = async (path, value) => {
-  const files = state$z.files;
+  const files = state$A.files;
   const keys = Object.keys(files);
   return keys;
 };
@@ -48161,7 +48206,7 @@ const SearchFileMemfs = {
 };
 
 const removeLeadingSlash = path => {
-  const workspacePath = state$K.workspacePath;
+  const workspacePath = state$L.workspacePath;
   return path.slice(workspacePath.length - Fetch.length - 2);
 };
 const searchFile$2 = async (path, value) => {
@@ -48231,7 +48276,7 @@ const searchFile = async (path, value) => {
     searchPath: path,
     limit: 9999999
   };
-  const stdout = await invoke$2(SearchFileSearchFile, options);
+  const stdout = await invoke$3(SearchFileSearchFile, options);
   const lines = splitLines(stdout);
   return lines;
 };