@lvce-editor/server 0.36.7 → 0.37.0

package/static/{9bdc73a → 9c9d5bc}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -1,15 +1,15 @@
-const state$R = {
+const state$P = {
   width: 0,
   height: 0
 };
-const get$i = () => {
+const get$h = () => {
   return {
-    width: state$R.width,
-    height: state$R.height
+    width: state$P.width,
+    height: state$P.height
   };
 };
-const set$i = (width, height) => {
-  state$R.width = width, state$R.height = height;
+const set$h = (width, height) => {
+  state$P.width = width, state$P.height = height;
 };
 
 let AssertionError$1 = class AssertionError extends Error {
@@ -86,17 +86,17 @@ const fn = value => {
   }
 };
 
-const state$Q = {
+const state$O = {
   pending: Object.create(null)
 };
-const get$h = id => {
-  return state$Q.pending[id];
+const get$g = id => {
+  return state$O.pending[id];
 };
 const has$2 = id => {
-  return id in state$Q.pending;
+  return id in state$O.pending;
 };
-const set$h = (id, value) => {
-  state$Q.pending[id] = value;
+const set$g = (id, value) => {
+  state$O.pending[id] = value;
 };
 
 const Web$1 = 1;
@@ -110,7 +110,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/9bdc73a';
+    return '/9c9d5bc';
   }
 };
 const assetDir = getAssetDir();
@@ -270,20 +270,20 @@ const number = value => {
 const state$1$1 = {
   callbacks: Object.create(null)
 };
-const set$g = (id, fn) => {
+const set$f = (id, fn) => {
   state$1$1.callbacks[id] = fn;
 };
-const get$g = id => {
+const get$f = id => {
   return state$1$1.callbacks[id];
 };
 const remove$b = id => {
   delete state$1$1.callbacks[id];
 };
-const state$P = {
+const state$N = {
   id: 0
 };
 const create$3$1 = () => {
-  return ++state$P.id;
+  return ++state$N.id;
 };
 const warn$2 = (...args) => {
   console.warn(...args);
@@ -304,7 +304,7 @@ const registerPromise = () => {
     resolve: resolve2,
     promise
   } = withResolvers$1();
-  set$g(id, resolve2);
+  set$f(id, resolve2);
   return {
     id,
     promise
@@ -312,7 +312,7 @@ const registerPromise = () => {
 };
 const resolve = (id, args) => {
   number(id);
-  const fn = get$g(id);
+  const fn = get$f(id);
   if (!fn) {
     console.log(args);
     warn$2(`callback ${id} may already be disposed`);
@@ -824,7 +824,7 @@ const getModuleId$1 = commandId => {
   }
 };
 
-const state$O = {
+const state$M = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -847,29 +847,29 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$O.load(moduleId);
+    const module = await state$M.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$O.pendingModules[moduleId]) {
-    state$O.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$M.pendingModules[moduleId]) {
+    state$M.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$O.pendingModules[moduleId];
+  return state$M.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$6 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$O.commands[commandId] = listener;
+  state$M.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$O.commands) {
-    const fn = state$O.commands[command];
+  if (command in state$M.commands) {
+    const fn = state$M.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -878,7 +878,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$O.commands)) {
+    if (!(command in state$M.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -889,7 +889,7 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$O.load = load;
+  state$M.load = load;
 };
 
 const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
@@ -1067,7 +1067,7 @@ const IpcChildWithModuleWorker$1 = {
   wrap: wrap$6$1
 };
 
-const getModule$b = method => {
+const getModule$a = method => {
   switch (method) {
     case ModuleWorker$1:
       return IpcChildWithModuleWorker$1;
@@ -1079,7 +1079,7 @@ const getModule$b = method => {
 const listen$2 = async ({
   method
 }) => {
-  const module = await getModule$b(method);
+  const module = await getModule$a(method);
   const rawIpc = await module.listen();
   // @ts-ignore
   if (module.signal) {
@@ -1091,7 +1091,7 @@ const listen$2 = async ({
 };
 
 /* istanbul ignore file */
-const state$N = {
+const state$L = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1104,16 +1104,16 @@ const getIpc = () => {
   });
 };
 const listen$1 = async () => {
-  console.assert(state$N.pendingMessages.length === 0);
+  console.assert(state$L.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc);
-  state$N.ipc = ipc;
+  state$L.ipc = ipc;
 };
 const invoke$a = (method, ...params) => {
-  return invoke$b(state$N.ipc, method, ...params);
+  return invoke$b(state$L.ipc, method, ...params);
 };
 const invokeAndTransfer$9 = (method, ...params) => {
-  return invokeAndTransfer$a(state$N.ipc, method, ...params);
+  return invokeAndTransfer$a(state$L.ipc, method, ...params);
 };
 
 const actuallyLoadCssStyleSheet = async css => {
@@ -1123,9 +1123,9 @@ const actuallyLoadCssStyleSheet = async css => {
 };
 const loadCssStyleSheet = id => {
   if (!has$2(id)) {
-    set$h(id, actuallyLoadCssStyleSheet(id));
+    set$g(id, actuallyLoadCssStyleSheet(id));
   }
-  return get$h(id);
+  return get$g(id);
 };
 const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
@@ -1139,9 +1139,9 @@ const actuallyAddDynamicCss = async (id, getCss, preferences) => {
 };
 const addDynamicCss = (id, getCss, preferences) => {
   if (!has$2(id)) {
-    set$h(id, actuallyAddDynamicCss(id, getCss, preferences));
+    set$g(id, actuallyAddDynamicCss(id, getCss, preferences));
   }
-  return get$h(id);
+  return get$g(id);
 };
 
 /**
@@ -1780,7 +1780,7 @@ const getMessage$5 = error => {
   return `Error: ${error}`;
 };
 
-const state$M = {
+const state$K = {
   /**
    * @type {string[]}
    */
@@ -1813,14 +1813,14 @@ const showErrorDialog = async error => {
 };
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$M.seenWarnings.includes(stringified)) {
+  if (state$K.seenWarnings.includes(stringified)) {
     return;
   }
-  state$M.seenWarnings.push(stringified);
+  state$K.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
-const state$L = {
+const state$J = {
   /**
    * @type {any}
    */
@@ -1831,14 +1831,14 @@ const state$L = {
 const invoke$9 = async (method, ...params) => {
   const {
     ipc
-  } = state$L;
+  } = state$J;
   const result = await invoke$b(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$8 = async (method, ...params) => {
   const {
     ipc
-  } = state$L;
+  } = state$J;
   const result = await invokeAndTransfer$a(ipc, method, ...params);
   return result;
 };
@@ -1872,7 +1872,7 @@ const fileSystems = Object.create(null);
 const registerAll$1 = map => {
   Object.assign(fileSystems, map);
 };
-const get$f = id => {
+const get$e = id => {
   return fileSystems[id];
 };
 
@@ -1884,7 +1884,7 @@ const get$f = id => {
 // TODO extension host should be able to register arbitrary protocols (except app, http, https, file, )
 
 const getFileSystem = protocol => {
-  const fn = get$f(protocol);
+  const fn = get$e(protocol);
   if (!fn) {
     throw new Error(`file system for protocol ${protocol} not found`);
   }
@@ -2035,24 +2035,24 @@ const canBeRestored$6 = async uri => {
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$K = {
+const state$I = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$K.listenerMap[event] || [];
+  const listeners = state$I.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$K.listenerMap[event] ||= [];
-  if (state$K.listenerMap[event].includes(fn)) {
+  state$I.listenerMap[event] ||= [];
+  if (state$I.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$K.listenerMap[event].unshift(fn);
+    state$I.listenerMap[event].unshift(fn);
   } else {
-    state$K.listenerMap[event].push(fn);
+    state$I.listenerMap[event].push(fn);
   }
 };
 
@@ -2100,7 +2100,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$J = Object.create(null);
+const state$H = Object.create(null);
 const openSettingsJson = async () => {
   await openUri$1('app://settings.json');
 };
@@ -2131,25 +2131,25 @@ const hydrate$b = 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$J, preferences);
+    Object.assign(state$H, preferences);
   } catch (error) {
     logError(error);
   }
 };
-const get$e = key => {
-  return state$J[key];
+const get$d = key => {
+  return state$H[key];
 };
-const set$f = async (key, value) => {
-  state$J[key] = value;
+const set$e = async (key, value) => {
+  state$H[key] = value;
   if (platform === Web$1) {
     const preferences = {
-      ...state$J,
+      ...state$H,
       [key]: value
     };
     await execute$4(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
-  const content = stringify(state$J);
+  const content = stringify(state$H);
   await writeFile$e('app://settings.json', content);
 };
 
@@ -2167,7 +2167,7 @@ const getCacheFn = config => {
   }
 };
 const getColorThemeCssCached = async (colorThemeId, getData) => {
-  const config = get$e('colorTheme.cache');
+  const config = get$d('colorTheme.cache');
   const module = await getCacheFn(config);
   const cachedData = await module.get(colorThemeId);
   if (cachedData) {
@@ -2203,7 +2203,7 @@ const setThemeColor = async 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$I = {
+const state$G = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2214,14 +2214,14 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$I.colorTheme = colorThemeId;
+    state$G.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
     if (platform === Web$1) {
       const themeColor = getMetaThemeColor(colorThemeId) || '';
       await setThemeColor(themeColor);
     }
-    if (platform !== Web$1 && get$e('development.watchColorTheme')) {
+    if (platform !== Web$1 && get$d('development.watchColorTheme')) {
       watch$2(colorThemeId);
     }
   } catch (error) {
@@ -2231,17 +2231,17 @@ const applyColorTheme = async colorThemeId => {
 const setColorTheme$1 = async colorThemeId => {
   await applyColorTheme(colorThemeId);
   // TODO should preferences throw errors or should it call handleError directly?
-  await set$f('workbench.colorTheme', colorThemeId);
+  await set$e('workbench.colorTheme', colorThemeId);
 };
 const watch$2 = async id => {
-  if (state$I.watchedTheme === id) {
+  if (state$G.watchedTheme === id) {
     return;
   }
-  state$I.watchedTheme = id;
+  state$G.watchedTheme = id;
   await invoke$9('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
-  const preferredColorTheme = get$e('workbench.colorTheme');
+  const preferredColorTheme = get$d('workbench.colorTheme');
   return preferredColorTheme;
 };
 const reload$4 = async () => {
@@ -2321,28 +2321,28 @@ const contexts = Object.create(null);
 // e.g. map 'focus.explorer' -> 2
 // Context.get(1), Context.get(2)
 
-const get$d = key => {
+const get$c = key => {
   return contexts[key];
 };
-const set$e = (key, value) => {
+const set$d = (key, value) => {
   contexts[key] = value;
 };
 const remove$9 = key => {
   delete contexts[key];
 };
 
-const state$H = {
+const state$F = {
   // TODO use numeric focus key
   currentFocus: ''
 };
-const get$c = () => {
-  return state$H.currentFocus;
+const get$b = () => {
+  return state$F.currentFocus;
 };
-const set$d = value => {
-  state$H.currentFocus = value;
+const set$c = value => {
+  state$F.currentFocus = value;
 };
 
-const state$G = {
+const state$E = {
   keyBindings: [],
   keyBindingSets: Object.create(null),
   /**
@@ -2355,7 +2355,7 @@ const state$G = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$G.matchingKeyBindings) {
+  for (const keyBinding of state$E.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2369,7 +2369,7 @@ const matchesContext = keyBinding => {
   if (!keyBinding.when) {
     return true;
   }
-  return get$d(keyBinding.when);
+  return get$c(keyBinding.when);
 };
 const getMatchingKeyBindings = keyBindingSets => {
   return Object.values(keyBindingSets).reverse().flat(1).filter(matchesContext);
@@ -2378,26 +2378,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$G.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$E.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
   invoke$a('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$G.matchingKeyBindings = matchingKeyBindings;
-  state$G.keyBindingIdentifiers = keyBindingIdentifiers;
+  state$E.matchingKeyBindings = matchingKeyBindings;
+  state$E.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings$1 = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$G.keyBindingSets) {
+  if (id in state$E.keyBindingSets) {
     warn$1(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$G.keyBindingSets[id] = keyBindings;
+  state$E.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$G;
+  } = state$E;
   if (!(id in keyBindingSets)) {
     warn$1(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2456,11 +2456,11 @@ const FocusFindWidgetPreviousMatchButton = 50;
  */
 const setFocus = focusKey => {
   number$1(focusKey);
-  if (get$c()) {
-    remove$9(get$c());
+  if (get$b()) {
+    remove$9(get$b());
   }
-  set$d(focusKey);
-  set$e(get$c(), true);
+  set$c(focusKey);
+  set$d(get$b(), true);
   update();
 };
 
@@ -2468,7 +2468,7 @@ const setFocus = focusKey => {
  * @param {number} key
  */
 const setAdditionalFocus = key => {
-  set$e(key, true);
+  set$d(key, true);
   update();
 };
 const getBrowserContextString = browser => {
@@ -2488,11 +2488,11 @@ const hydrate$9 = async () => {
   // maybe in env file / env service
   const browser = getBrowser$1();
   const key = getBrowserContextString(browser);
-  set$e(key, true);
+  set$d(key, true);
   update();
 };
 
-const state$F = {
+const state$D = {
   /**
    * @type {any[]}
    */
@@ -2528,7 +2528,7 @@ const getStaticWebExtensions = () => {
 };
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$F.webExtensions];
+  return [...staticWebExtensions, ...state$D.webExtensions];
 };
 const isWebExtension = extension => {
   return extension && typeof extension.browser === 'string';
@@ -2537,7 +2537,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions$1();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$F.webExtensions];
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$D.webExtensions];
 };
 const getWebExtensions = async () => {
   try {
@@ -2548,7 +2548,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault();
     }
   } catch {
-    return state$F.webExtensions;
+    return state$D.webExtensions;
   }
 };
 
@@ -2577,7 +2577,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$F.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$D.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -2637,7 +2637,7 @@ const getNthFileExtension = (file, startIndex) => {
 
 // TODO merge all of this with extension host languages module
 
-const state$E = {
+const state$C = {
   loadState: false,
   isHydrating: false,
   fileNameMap: Object.create(null),
@@ -2653,53 +2653,53 @@ const state$E = {
   hasWarned: []
 };
 const getFirstLines = () => {
-  return state$E.firstLines;
+  return state$C.firstLines;
 };
 const hasLanguageByExtension = extension => {
-  return extension in state$E.extensionMap;
+  return extension in state$C.extensionMap;
 };
 const getLanguageByExtension = extension => {
-  return state$E.extensionMap[extension];
+  return state$C.extensionMap[extension];
 };
 const hasLanguageByFileName = fileName => {
-  return fileName in state$E.fileNameMap;
+  return fileName in state$C.fileNameMap;
 };
 const getLanguageByFileName = fileName => {
-  return state$E.fileNameMap[fileName];
+  return state$C.fileNameMap[fileName];
 };
 const getTokenizeFunctionPath$1 = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$E.tokenizerMap[languageId] || '';
+  return state$C.tokenizerMap[languageId] || '';
 };
 const setHydrating = value => {
-  state$E.isHydrating = value;
+  state$C.isHydrating = value;
 };
 const setLoaded = value => {
-  state$E.loaded = true;
+  state$C.loaded = true;
 };
 const addExtension = (extension, languageId) => {
-  state$E.extensionMap[extension] = languageId;
+  state$C.extensionMap[extension] = languageId;
 };
 const addFirstLine = (regex, languageId) => {
-  state$E.firstLines.push({
+  state$C.firstLines.push({
     regex,
     languageId
   });
 };
 const hasWarned = languageId => {
-  return state$E.hasWarned.includes(languageId);
+  return state$C.hasWarned.includes(languageId);
 };
 const addWarned = languageId => {
-  return state$E.hasWarned.push(languageId);
+  return state$C.hasWarned.push(languageId);
 };
 const addFileName = (fileName, languageId) => {
-  state$E.fileNameMap[fileName] = languageId;
+  state$C.fileNameMap[fileName] = languageId;
 };
 const addTokenizer = (languageId, tokenizer) => {
-  state$E.tokenizerMap[languageId] = tokenizer;
+  state$C.tokenizerMap[languageId] = tokenizer;
 };
 const hasLoaded$1 = () => {
-  return state$E.loaded;
+  return state$C.loaded;
 };
 
 // TODO merge all of this with extension host languages module
@@ -2748,7 +2748,7 @@ const hydrate$8 = async () => {
   const languages = await getLanguages();
   // TODO avoid side effect here, but how?
   await addLanguages(languages);
-  const useJsx = get$e('languages.jsFilesAsJsx');
+  const useJsx = get$d('languages.jsFilesAsJsx');
   if (useJsx) {
     addExtension('.js', 'jsx');
   }
@@ -2885,14 +2885,14 @@ const getLanguageConfiguration = async editor => {
   }
 };
 
-const state$D = {
+const state$B = {
   webViews: []
 };
 const addMany = webViews => {
-  state$D.webViews = [...state$D.webViews, ...webViews];
+  state$B.webViews = [...state$B.webViews, ...webViews];
 };
-const get$b = () => {
-  return state$D.webViews;
+const get$a = () => {
+  return state$B.webViews;
 };
 
 const getId$3 = path => {
@@ -2925,7 +2925,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$F.webExtensions.push(manifest);
+  state$D.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -3048,21 +3048,21 @@ const addNodeExtension = async path => {
 
 const cache = Object.create(null);
 const id$p = 1;
-const get$a = () => {
+const get$9 = () => {
   return cache[id$p];
 };
 const has$1 = () => {
   return id$p in cache;
 };
-const set$c = value => {
+const set$b = value => {
   cache[id$p] = value;
 };
 
 const getExtensions$1 = () => {
   if (!has$1()) {
-    set$c(getExtensions$2());
+    set$b(getExtensions$2());
   }
-  return get$a();
+  return get$9();
 };
 
 const getIconThemeUrl = iconThemeId => {
@@ -3078,7 +3078,7 @@ const getIconThemeJson = async iconThemeId => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
     };
   }
-  for (const webExtension of state$F.webExtensions) {
+  for (const webExtension of state$D.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -3114,11 +3114,11 @@ const isOpen = () => {
   return false;
 };
 
-const state$C = {
+const state$A = {
   id: 0
 };
 const create$15 = () => {
-  return ++state$C.id;
+  return ++state$A.id;
 };
 
 class CancelationError extends Error {
@@ -3160,12 +3160,12 @@ const getJson$4 = async (storageType, key) => {
     return undefined;
   }
 };
-const setText$2 = async (storageType, key, value) => {
+const setText$1 = async (storageType, key, value) => {
   await invoke$a(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$4 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
-  await setText$2(storageType, key, stringifiedValue);
+  await setText$1(storageType, key, stringifiedValue);
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = mapObject(objects, stringifyCompact);
@@ -3184,8 +3184,8 @@ const getText = key => {
 const getJson$3 = key => {
   return getJson$4(LocalStorage, key);
 };
-const setText$1 = (key, value) => {
-  return setText$2(LocalStorage, key, value);
+const setText = (key, value) => {
+  return setText$1(LocalStorage, key, value);
 };
 const setJson$3 = (key, value) => {
   return setJson$4(LocalStorage, key, value);
@@ -3232,23 +3232,23 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value);
 };
 
-const state$B = {
+const state$z = {
   instances: Object.create(null),
   /**
    * @type {any}
    */
   focusedInstance: undefined
 };
-const set$b = (key, value) => {
+const set$a = (key, value) => {
   // TODO separate factories from state
   object(value);
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$B.instances[key] = value;
+  state$z.instances[key] = value;
 };
 const getInstance = key => {
-  const fast = state$B.instances[key];
+  const fast = state$z.instances[key];
   if (fast) {
     return fast;
   }
@@ -3261,7 +3261,7 @@ const getInstance = key => {
   if (key === 'EditorCompletion') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$B.instances)) {
+  for (const value of Object.values(state$z.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -3269,16 +3269,16 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$B.instances;
+  return key in state$z.instances;
 };
 const remove$8 = key => {
-  delete state$B.instances[key];
+  delete state$z.instances[key];
 };
 const getAllInstances = () => {
-  return state$B.instances;
+  return state$z.instances;
 };
 const getValues = () => {
-  return Object.values(state$B.instances);
+  return Object.values(state$z.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -3326,11 +3326,11 @@ const getHost = () => {
 
 const Slash$1 = Slash$2;
 
-const set$a = title => {
+const set$9 = title => {
   return invoke$a('WindowTitle.set', title);
 };
 
-const state$A = {
+const state$y = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -3348,16 +3348,16 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$A.workspacePath = path;
+  state$y.workspacePath = path;
   // @ts-ignore
-  state$A.workspaceUri = path;
-  state$A.pathSeparator = pathSeparator;
+  state$y.workspaceUri = path;
+  state$y.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async uri => {
   const path = uri.slice('file://'.length);
-  state$A.workspacePath = path;
-  state$A.workspaceUri = uri;
+  state$y.workspacePath = path;
+  state$y.workspaceUri = uri;
   await onWorkspaceChange();
 };
 const close$7 = () => {
@@ -3378,12 +3378,12 @@ const getResolveRootFromSessionStorage = async () => {
   return resolvedRoot;
 };
 const isTest = () => {
-  return state$A.isTest;
+  return state$y.isTest;
 };
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$A.isTest = true;
+    state$y.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -3401,7 +3401,7 @@ const getResolvedRootFromRendererProcess = async href => {
     };
   }
   if (platform === Web$1) {
-    const defaultWorkspace = get$e('workspace.defaultWorkspace');
+    const defaultWorkspace = get$d('workspace.defaultWorkspace');
     const resolvedRoot = {
       path: defaultWorkspace,
       homeDir: '',
@@ -3432,7 +3432,7 @@ const getResolvedRoot = async href => {
   }
 };
 const getTitle$1 = workspacePath => {
-  const pathSeparator = state$A.pathSeparator;
+  const pathSeparator = state$y.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
 };
 const getPathName = workspacePath => {
@@ -3442,41 +3442,41 @@ const getPathName = workspacePath => {
   return '';
 };
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$A.workspacePath);
-  await set$a(title);
+  const title = getTitle$1(state$y.workspacePath);
+  await set$9(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$A.workspacePath);
+    const pathName = getPathName(state$y.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$A.workspacePath);
+  await emitEvent('workspace.change', state$y.workspacePath);
 };
 const hydrate$6 = async ({
   href
 }) => {
-  if (state$A.workspacePath) {
+  if (state$y.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$A.isTest) {
+  if (state$y.isTest) {
     return;
   }
-  if (state$A.workspacePath) {
+  if (state$y.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$A.homeDir !== resolvedRoot.homeDir) {
-    state$A.homeDir = resolvedRoot.homeDir;
+  if (state$y.homeDir !== resolvedRoot.homeDir) {
+    state$y.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$A.workspacePath = resolvedRoot.path;
-  state$A.homeDir = resolvedRoot.homeDir;
-  state$A.pathSeparator = resolvedRoot.pathSeparator;
-  state$A.workspaceUri = resolvedRoot.uri;
-  state$A.source = resolvedRoot.source;
+  state$y.workspacePath = resolvedRoot.path;
+  state$y.homeDir = resolvedRoot.homeDir;
+  state$y.pathSeparator = resolvedRoot.pathSeparator;
+  state$y.workspaceUri = resolvedRoot.uri;
+  state$y.source = resolvedRoot.source;
   await onWorkspaceChange();
 };
 
@@ -3485,10 +3485,10 @@ const hydrate$6 = async ({
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$A.workspacePath;
+  return state$y.workspacePath;
 };
 const getHomeDir = () => {
-  return state$A.homeDir;
+  return state$y.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -3496,15 +3496,15 @@ const pathBaseName = path => {
   return path.slice(path.lastIndexOf('/') + 1);
 };
 const pathRelative = path => {
-  if (path.startsWith(state$A.workspacePath)) {
-    return path.slice(state$A.workspacePath.length + 1, path.lastIndexOf('/'));
+  if (path.startsWith(state$y.workspacePath)) {
+    return path.slice(state$y.workspacePath.length + 1, path.lastIndexOf('/'));
   }
   return path;
 };
 
 // TODO this should be in FileSystem module
 const pathDirName = path => {
-  const pathSeparator = state$A.pathSeparator || '/';
+  const pathSeparator = state$y.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString;
@@ -3513,9 +3513,9 @@ const pathDirName = path => {
 };
 const getAbsolutePath = relativePath => {
   if (relativePath.startsWith('./')) {
-    return `${state$A.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
+    return `${state$y.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
   }
-  return `${state$A.workspacePath}/${relativePath}`; // TODO support windows paths
+  return `${state$y.workspacePath}/${relativePath}`; // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -3525,10 +3525,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$A.workspacePath,
-      homeDir: state$A.homeDir,
-      pathSeparator: state$A.pathSeparator,
-      uri: state$A.workspaceUri
+      path: state$y.workspacePath,
+      homeDir: state$y.homeDir,
+      pathSeparator: state$y.pathSeparator,
+      uri: state$y.workspaceUri
     }
   };
 };
@@ -3553,7 +3553,7 @@ const handleVisibilityChange = async visibilityState => {
 };
 const hydrate$5 = async () => {
   // TODO should set up listener in renderer process
-  if (!get$e('workbench.saveStateOnVisibilityChange')) {
+  if (!get$d('workbench.saveStateOnVisibilityChange')) {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
@@ -3563,14 +3563,14 @@ const getSavedViewletState = viewletId => {
   return getJson$2(viewletId);
 };
 
-const state$z = {
+const state$x = {
   idMap: Object.create(null)
 };
 const register$5 = (id, module) => {
-  state$z.idMap[id] = module;
+  state$x.idMap[id] = module;
 };
-const get$9 = id => {
-  return state$z.idMap[id];
+const get$8 = id => {
+  return state$x.idMap[id];
 };
 
 const loadModule$3 = async (id, module) => {
@@ -3580,7 +3580,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$J);
+    await addDynamicCss(id, module.getDynamicCss, state$H);
   }
 };
 
@@ -3589,17 +3589,17 @@ const ViewletManagerVisitorCss = {
   loadModule: loadModule$3
 };
 
-const state$y = {
+const state$w = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$y.menuEntries;
+  return state$w.menuEntries;
 };
 const add$1 = menuEntries => {
-  state$y.menuEntries = [...state$y.menuEntries, ...menuEntries];
+  state$w.menuEntries = [...state$w.menuEntries, ...menuEntries];
 };
 
 const loadModule$2 = (id, module) => {
@@ -3744,7 +3744,7 @@ const ViewletModuleId = {
 };
 
 // @ts-nocheck
-const state$x = {
+const state$v = {
   pendingModules: Object.create(null)
 };
 const ViewletState = {
@@ -4029,10 +4029,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$x.pendingModules)) {
-    state$x.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$v.pendingModules)) {
+    state$v.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$x.pendingModules[id];
+  return state$v.pendingModules[id];
 };
 
 // TODO add lots of unit tests for this
@@ -4166,7 +4166,7 @@ const load$7 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     // TODO race condition: viewlet state may have been updated again in the mean time
     state = ViewletState.RendererProcessViewletLoaded;
-    set$b(viewletUid, {
+    set$a(viewletUid, {
       state: newState,
       renderedState: viewletState,
       factory: module,
@@ -4304,20 +4304,20 @@ const disposeBrowserViewQuickPick = () => {
   return invoke$9('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
-const state$w = {
+const state$u = {
   id: 0
 };
-const set$9 = value => {
-  state$w.id = value;
+const set$8 = value => {
+  state$u.id = value;
 };
-const get$8 = () => {
-  return state$w.id;
+const get$7 = () => {
+  return state$u.id;
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
-  const webContentsId = get$8();
+  const webContentsId = get$7();
   const windowId = await invoke$9('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
@@ -4349,7 +4349,7 @@ const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 const Node = 7;
 const NodeAlternate = 8;
 
-const getModule$a = method => {
+const getModule$9 = method => {
   switch (method) {
     case ElectronMessagePort:
       return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; });
@@ -4380,7 +4380,7 @@ const create$13 = async ({
   if (options && options.url && options.url.endsWith('extensionHostSubWorkerMain.js')) {
     options.url = extensionHostSubWorkerUrl;
   }
-  const module = await getModule$a(method);
+  const module = await getModule$9(method);
   // @ts-ignore
   const rawIpc = await module.create(options);
   if (options.noReturn) {
@@ -4413,15 +4413,15 @@ const handleKeyBinding$1 = async identifier => {
   // }
 };
 
-const state$v = {
+const state$t = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$v.isQuickPickOpen;
+  return state$t.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$v.isQuickPickOpen = false;
+  state$t.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -4846,7 +4846,7 @@ const handleIconThemeChange$4 = async () => {
 
 const initialIconTheme = undefined;
 
-const state$u = {
+const state$s = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -4857,11 +4857,11 @@ const state$u = {
   extensionPath: ''
 };
 const setTheme = iconTheme => {
-  state$u.iconTheme = iconTheme.json;
-  state$u.extensionPath = iconTheme.extensionPath;
+  state$s.iconTheme = iconTheme.json;
+  state$s.extensionPath = iconTheme.extensionPath;
 };
 const getIconTheme = () => {
-  return state$u.iconTheme;
+  return state$s.iconTheme;
 };
 
 const File$6 = '_file';
@@ -4996,7 +4996,7 @@ const setIconTheme = async iconThemeId => {
   }
 };
 const hydrate$4 = async () => {
-  const iconThemeId = get$e('icon-theme') || 'vscode-icons';
+  const iconThemeId = get$d('icon-theme') || 'vscode-icons';
   await setIconTheme(iconThemeId);
 };
 
@@ -5029,7 +5029,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$L.ipc = ipc;
+  state$J.ipc = ipc;
 };
 
 const map$2 = Object.create(null);
@@ -5074,14 +5074,14 @@ const hydrate$3 = async () => {
   }
 };
 
-const state$t = {
+const state$r = {
   shouldLaunchMultipleWorkers: false
 };
 const setConfig = shouldLaunchMultipleWorkers => {
-  state$t.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+  state$r.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
 const getConfig = () => {
-  return state$t.shouldLaunchMultipleWorkers;
+  return state$r.shouldLaunchMultipleWorkers;
 };
 
 const Zero = 0;
@@ -5101,27 +5101,27 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$s = {
+const state$q = {
   listenerMap: Object.create(null),
   phase: Zero
 };
 const once = (event, listener) => {
-  if (state$s.phase >= event) {
+  if (state$q.phase >= event) {
     listener();
   } else {
     // TODO could also statically allocate listenermap at start as array[13]
-    state$s.listenerMap[event] ||= [];
-    state$s.listenerMap[event].push(listener);
+    state$q.listenerMap[event] ||= [];
+    state$q.listenerMap[event].push(listener);
   }
 };
 const mark$1 = event => {
-  const listeners = state$s.listenerMap[event] || [];
+  const listeners = state$q.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$s.phase = event;
+  state$q.phase = event;
   if (event === Twelve) {
-    state$s.listenerMap = Object.create(null);
+    state$q.listenerMap = Object.create(null);
   }
 };
 
@@ -5821,7 +5821,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state$r = {
+const state$p = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -5839,7 +5839,7 @@ const isDataCloneError = error => {
 
 const getDb$1 = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$r.dbVersion, {
+  const db = await openDB('session', state$p.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -5854,8 +5854,8 @@ const getDb$1 = async () => {
   return db;
 };
 const getDbMemoized$1 = async () => {
-  state$r.cachedDb ||= await getDb$1();
-  return state$r.cachedDb;
+  state$p.cachedDb ||= await getDb$1();
+  return state$p.cachedDb;
 };
 const saveValue$1 = async (storeId, value) => {
   try {
@@ -5882,7 +5882,7 @@ const getValuesByIndexName$1 = async (storeId, indexName, only) => {
 };
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state$r.dbVersion, {
+  const db = await openDB('handle', state$p.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         // @ts-ignore
@@ -5923,12 +5923,12 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`;
 };
 
-const state$q = {
+const state$o = {
   sessionId: ''
 };
 const getSessionId = () => {
-  state$q.sessionId ||= creareSessionId();
-  return state$q.sessionId;
+  state$o.sessionId ||= creareSessionId();
+  return state$o.sessionId;
 };
 
 const withResolvers = () => {
@@ -5989,7 +5989,7 @@ const addSearchParam = (href, key, value) => {
   return parsedUrl.toString();
 };
 const replayCurrentSession = async () => {
-  if (!state$q.sessionId) {
+  if (!state$o.sessionId) {
     throw new VError('session replay is disabled in settings');
   }
   // TODO
@@ -6009,7 +6009,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$N.ipc;
+  const originalIpc = state$L.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -6024,33 +6024,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$N.ipc.onmessage = originalAddEventListsner;
-          state$N.ipc.send = originalSend;
+          state$L.ipc.onmessage = originalAddEventListsner;
+          state$L.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$N.ipc.onmessage = wrappedOnMessage;
-          state$N.ipc.send = wrappedSend;
+          state$L.ipc.onmessage = wrappedOnMessage;
+          state$L.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$N.ipc.onmessage = originalAddEventListsner;
-          state$N.ipc.send = originalSend;
+          state$L.ipc.onmessage = originalAddEventListsner;
+          state$L.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$N.ipc.onmessage = wrappedOnMessage;
-          state$N.ipc.send = wrappedSend;
+          state$L.ipc.onmessage = wrappedOnMessage;
+          state$L.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$N.ipc.onmessage = originalAddEventListsner;
-          state$N.ipc.send = originalSend;
+          state$L.ipc.onmessage = originalAddEventListsner;
+          state$L.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$N.ipc.onmessage = wrappedOnMessage;
-          state$N.ipc.send = wrappedSend;
+          state$L.ipc.onmessage = wrappedOnMessage;
+          state$L.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$N.ipc.send = wrappedSend;
-  state$N.ipc.addEventListener('message', wrappedOnMessage);
+  state$L.ipc.send = wrappedSend;
+  state$L.ipc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -6122,8 +6122,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$N.ipc = wrapIpc(state$N.ipc, 'renderer-process', event => event.data);
-  state$L.ipc = wrapIpc(state$L.ipc, 'shared-process', event => event);
+  state$L.ipc = wrapIpc(state$L.ipc, 'renderer-process', event => event.data);
+  state$J.ipc = wrapIpc(state$J.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -6221,7 +6221,7 @@ const startup = async () => {
   }
   if (initData.Location.href.startsWith('http://localhost:3001/tests/')) ;
   setConfig(initData.Config?.shouldLaunchMultipleWorkers);
-  set$i(initData.Layout.bounds.windowWidth, initData.Layout.bounds.windowHeight);
+  set$h(initData.Layout.bounds.windowWidth, initData.Layout.bounds.windowHeight);
   mark(WillLoadPreferences);
   await hydrate$b();
   mark(DidLoadPreferences);
@@ -6230,7 +6230,7 @@ const startup = async () => {
   await getExtensions$1();
 
   // TODO only load this if session replay is enabled in preferences
-  if (get$e('sessionReplay.enabled')) {
+  if (get$d('sessionReplay.enabled')) {
     mark(WillLoadSessionReplay);
     await startRecording$1();
     mark(DidLoadSessionReplay);
@@ -6303,7 +6303,7 @@ const startup = async () => {
   mark$1(Twelve);
   mark$1(Thirteen);
   mark$1(Fourteen);
-  if (platform === Electron$1 && get$e('window.titleBarStyle') === 'native') {
+  if (platform === Electron$1 && get$d('window.titleBarStyle') === 'native') {
     await execute$4('ElectronApplicationMenu.hydrate');
   } else {
     mark(WillLoadTitleBar);
@@ -6354,24 +6354,24 @@ main();
 const getCacheKey$1 = colorThemeId => {
   return 'lvce-color-theme-' + colorThemeId;
 };
-const get$7 = colorThemeId => {
+const get$6 = colorThemeId => {
   const cacheKey = getCacheKey$1(colorThemeId);
   return getText(cacheKey);
 };
-const set$8 = (colorThemeId, data) => {
+const set$7 = (colorThemeId, data) => {
   const cacheKey = getCacheKey$1(colorThemeId);
-  return setText$1(cacheKey, data);
+  return setText(cacheKey, data);
 };
 
 const GetColorThemeCssCachedLocalStorage = {
   __proto__: null,
-  get: get$7,
-  set: set$8
+  get: get$6,
+  set: set$7
 };
 
 // TODO high memory usage in idb because of transactionDoneMap
 
-const state$p = {
+const state$n = {
   databases: Object.create(null),
   dbVersion: 2,
   /**
@@ -6382,7 +6382,7 @@ const state$p = {
 const storeId = 'lvce-keyvalue';
 const getDb = async () => {
   // @ts-ignore
-  const db = await openDB(storeId, state$p.dbVersion, {
+  const db = await openDB(storeId, state$n.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains(storeId)) {
         await db.createObjectStore(storeId, {
@@ -6394,10 +6394,10 @@ const getDb = async () => {
   return db;
 };
 const getDbMemoized = async () => {
-  state$p.cachedDb ||= await getDb();
-  return state$p.cachedDb;
+  state$n.cachedDb ||= await getDb();
+  return state$n.cachedDb;
 };
-const set$7 = async (key, value) => {
+const set$6 = async (key, value) => {
   try {
     const db = await getDbMemoized();
     await db.put(storeId, value, key);
@@ -6405,7 +6405,7 @@ const set$7 = async (key, value) => {
     throw new VError(error, 'Failed to save value to indexed db');
   }
 };
-const get$6 = async key => {
+const get$5 = async key => {
   try {
     const db = await getDbMemoized();
     const value = db.get(storeId, key);
@@ -6418,32 +6418,32 @@ const get$6 = async key => {
 const getCacheKey = colorThemeId => {
   return 'color-theme-' + colorThemeId;
 };
-const get$5 = colorThemeId => {
+const get$4 = colorThemeId => {
   const cacheKey = getCacheKey(colorThemeId);
-  return get$6(cacheKey);
+  return get$5(cacheKey);
 };
-const set$6 = (colorThemeId, data) => {
+const set$5 = (colorThemeId, data) => {
   const cacheKey = getCacheKey(colorThemeId);
-  return set$7(cacheKey, data);
+  return set$6(cacheKey, data);
 };
 
 const GetColorThemeCssCachedIndexedDb = {
   __proto__: null,
-  get: get$5,
-  set: set$6
+  get: get$4,
+  set: set$5
 };
 
-const get$4 = colorThemeId => {
+const get$3 = colorThemeId => {
   return '';
 };
-const set$5 = (colorThemeId, data) => {
+const set$4 = (colorThemeId, data) => {
   //  noop
 };
 
 const GetColorThemeCssCachedNoop = {
   __proto__: null,
-  get: get$4,
-  set: set$5
+  get: get$3,
+  set: set$4
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -6681,9 +6681,9 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$b(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
+  await invoke$b(ipc, 'Workspace.setWorkspacePath', state$y.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$b(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
+    await invoke$b(ipc, 'Workspace.setWorkspacePath', state$y.workspacePath);
   });
   return ipc;
 };
@@ -6714,7 +6714,7 @@ const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, orig
 
 const origin = typeof location === 'undefined' ? '' : location.origin;
 
-const state$o = {
+const state$m = {
   /**
    * @type {readonly any[]}
    */
@@ -6726,11 +6726,11 @@ const state$o = {
   activatedExtensions: Object.create(null)
 };
 const actuallyActivateExtension = async extension => {
-  if (!(extension.id in state$o.activatedExtensions)) {
+  if (!(extension.id in state$m.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin);
-    state$o.activatedExtensions[extension.id] = invoke$8(ExtensionActivate, extension, absolutePath);
+    state$m.activatedExtensions[extension.id] = invoke$8(ExtensionActivate, extension, absolutePath);
   }
-  return state$o.activatedExtensions[extension.id];
+  return state$m.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
@@ -6750,7 +6750,7 @@ const actuallyActivateByEvent = async event => {
   for (const extension of extensionsToActivate) {
     await actuallyActivateExtension(extension);
   }
-  const additionalExtensions = state$F.webExtensions;
+  const additionalExtensions = state$D.webExtensions;
   const additionalExtensionsToActivate = filterByMatchingEvent(additionalExtensions, event);
   for (const extension of additionalExtensionsToActivate) {
     await actuallyActivateExtension(extension);
@@ -6761,14 +6761,14 @@ const actuallyActivateByEvent = async event => {
 const activateByEvent = async event => {
   string(event);
   if (event === 'none') {
-    const all = await Promise.all(Object.values(state$o.cachedActivationEvents));
+    const all = await Promise.all(Object.values(state$m.cachedActivationEvents));
     const flatAll = all.flat(1);
     return [flatAll[0]];
   }
-  if (!(event in state$o.cachedActivationEvents)) {
-    state$o.cachedActivationEvents[event] = actuallyActivateByEvent(event);
+  if (!(event in state$m.cachedActivationEvents)) {
+    state$m.cachedActivationEvents[event] = actuallyActivateByEvent(event);
   }
-  return state$o.cachedActivationEvents[event];
+  return state$m.cachedActivationEvents[event];
 };
 
 const executeProviders = async ({
@@ -6914,7 +6914,7 @@ const ExtensionHostFileSystem = {
 };
 
 const name$2o = 'App';
-const getModule$9 = uri => {
+const getModule$8 = uri => {
   switch (uri) {
     case 'startup-performance':
       return Promise.resolve().then(function () { return FileSystemAppStartupPerformance; });
@@ -6933,11 +6933,11 @@ const getModule$9 = uri => {
   }
 };
 const readFile$c = async uri => {
-  const module = await getModule$9(uri);
+  const module = await getModule$8(uri);
   return module.readFile();
 };
 const writeFile$c = async (uri, content) => {
-  const module = await getModule$9(uri);
+  const module = await getModule$8(uri);
   return module.writeFile(content);
 };
 const readDirWithFileTypes$6 = () => {
@@ -7015,113 +7015,67 @@ const FileSystemData = {
   writeFile: writeFile$b
 };
 
-const name$2m = 'Memory';
-const state$n = {
-  files: Object.create(null)
-};
-const getDirent$2 = uri => {
-  return state$n.files[uri];
-};
-const readFile$a = uri => {
-  const dirent = getDirent$2(uri);
-  if (!dirent) {
-    throw new Error(`File not found: ${uri}`);
+const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
+
+const getConfiguredWorkerUrl$3 = () => {
+  let configuredWorkerUrl = get$d('develop.fileSearchWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
-  if (dirent.type !== File$5) {
-    throw new Error('file is a directory');
+  configuredWorkerUrl = configuredWorkerUrl || fileSearchWorkerUrl;
+  {
+    configuredWorkerUrl = fileSearchWorkerUrl;
   }
-  return dirent.content;
+  return configuredWorkerUrl;
 };
-const ensureParentDir = uri => {
-  const startIndex = 0;
-  let endIndex = uri.indexOf(Slash$1);
-  while (endIndex >= 0) {
-    const part = uri.slice(startIndex, endIndex + 1);
-    state$n.files[part] = {
-      type: Directory$1,
-      content: ''
-    };
-    endIndex = uri.indexOf(Slash$1, endIndex + 1);
-  }
+const launchFileSearchWorker = async () => {
+  const name = 'File Search Worker';
+  const ipc = await create$13({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$3()
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$6
+} = getOrCreateWorker(launchFileSearchWorker);
+
+const name$2m = 'Memory';
+const readFile$a = uri => {
+  return invoke$7('FileSystemMemory.readFile', uri);
 };
 const writeFile$a = (uri, content) => {
-  const dirent = getDirent$2(uri);
-  if (dirent) {
-    dirent.content = content;
-  } else {
-    ensureParentDir(uri);
-    state$n.files[uri] = {
-      type: File$5,
-      content
-    };
-  }
+  return invoke$7('FileSystemMemory.writeFile', uri, content);
 };
 const mkdir$3 = uri => {
-  if (!uri.endsWith(Slash$1)) {
-    uri += Slash$1;
-  }
-  ensureParentDir(uri);
-  state$n.files[uri] = {
-    type: Directory$1,
-    content: ''
-  };
+  return invoke$7('FileSystemMemory.mkdir', uri);
 };
 const getPathSeparator$5 = () => {
   return Slash$1;
 };
 const remove$4 = uri => {
-  const toDelete = [];
-  for (const key of Object.keys(state$n.files)) {
-    if (key.startsWith(uri)) {
-      toDelete.push(key);
-    }
-  }
-  for (const key of toDelete) {
-    delete state$n.files[key];
-  }
+  return invoke$7('FileSystemMemory.remove', uri);
 };
 const readDirWithFileTypes$4 = uri => {
-  if (!uri.endsWith(Slash$1)) {
-    uri += Slash$1;
-  }
-  const dirents = [];
-  for (const [key, value] of Object.entries(state$n.files)) {
-    if (key.startsWith(uri)) {
-      switch (value.type) {
-        case Directory$1:
-          if (!key.slice(0, -1).includes(Slash$1, uri.length) && key !== `${uri}/` && key !== uri) {
-            dirents.push({
-              type: value.type,
-              name: key.slice(uri.length, -1)
-            });
-          }
-          break;
-        case File$5:
-          if (!key.includes(Slash$1, uri.length + 1)) {
-            dirents.push({
-              type: value.type,
-              name: key.slice(uri.length)
-            });
-          }
-          break;
-      }
-    }
-  }
-  return dirents;
+  return invoke$7('FileSystemMemory.readDirWithFileTypes', uri);
 };
 const getBlobUrl$2 = uri => {
-  const content = readFile$a(uri);
-  const blob = new Blob([content]);
-  const url = URL.createObjectURL(blob);
-  return url;
+  return invoke$7('FileSystemMemory.getBlobUrl', uri);
 };
-const getBlob$2 = uri => {
-  const content = readFile$a(uri);
+const getBlob$2 = async uri => {
+  const content = await readFile$a(uri);
   const blob = new Blob([content]);
   return blob;
 };
 const chmod$2 = (path, permissions) => {
-  throw new Error('[memfs] chmod not implemented');
+  return invoke$7('FileSystemMemory.chmod', path, permissions);
+};
+const getFiles = () => {
+  return invoke$7('FileSystemMemory.getFiles');
 };
 
 const FileSystemMemory = {
@@ -7129,13 +7083,13 @@ const FileSystemMemory = {
   chmod: chmod$2,
   getBlob: getBlob$2,
   getBlobUrl: getBlobUrl$2,
+  getFiles,
   getPathSeparator: getPathSeparator$5,
   mkdir: mkdir$3,
   name: name$2m,
   readDirWithFileTypes: readDirWithFileTypes$4,
   readFile: readFile$a,
   remove: remove$4,
-  state: state$n,
   writeFile: writeFile$a
 };
 
@@ -7143,18 +7097,18 @@ const FileSystemMemory = {
 // FileSystemError
 
 const name$2l = 'Web';
-const state$m = {
+const state$l = {
   watchers: Object.create(null),
   saveListeners: [],
   files: Object.create(null)
 };
-state$m.files['/languages/index.dart'] = `void main() {
+state$l.files['/languages/index.dart'] = `void main() {
   print('Hello, World!');
 }`;
-state$m.files['/languages/index.js'] = `const add = (a, b) => {
+state$l.files['/languages/index.js'] = `const add = (a, b) => {
   return a + b;
 }`;
-state$m.files['/languages/scrolling.txt'] = `line 1
+state$l.files['/languages/scrolling.txt'] = `line 1
 line 2
 line 3
 line 4
@@ -7255,8 +7209,8 @@ line 98
 line 99
 line 100
 `;
-state$m.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
-state$m.files['/languages/index.css'] = `h1 {
+state$l.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
+state$l.files['/languages/index.css'] = `h1 {
   font-size: 24px;
 }
 
@@ -7276,7 +7230,7 @@ state$m.files['/languages/index.css'] = `h1 {
   tab-size: 2;
 }
 `;
-state$m.files['/languages/index.ex'] = `defmodule RealWorld do
+state$l.files['/languages/index.ex'] = `defmodule RealWorld do
   @moduledoc """
   RealWorld keeps the contexts that define your domain
   and business logic.
@@ -7284,7 +7238,7 @@ state$m.files['/languages/index.ex'] = `defmodule RealWorld do
   if it comes from the database, an external API or others.
   """
 end`;
-state$m.files['/languages/index.jl'] = `function mandelbrot(a)
+state$l.files['/languages/index.jl'] = `function mandelbrot(a)
 z = 0
 for i=1:50
 z = z^2 + a
@@ -7298,7 +7252,7 @@ abs(mandelbrot(complex(x, y))) < 2 ? print("*") : print(" ")
 end
 println()
 end`;
-state$m.files['/languages/index.pl'] = `#!/usr/bin/perl
+state$l.files['/languages/index.pl'] = `#!/usr/bin/perl
 #
 # The traditional first program.
 
@@ -7308,15 +7262,15 @@ use warnings;
 
 # Print a message.
 print "Hello, World!\n";`;
-state$m.files['/languages/index.kt'] = `fun main(args : Array<String>) {
+state$l.files['/languages/index.kt'] = `fun main(args : Array<String>) {
   println("Hello, World!")
 }`;
-state$m.files['/languages/index.java'] = `class HelloWorld {
+state$l.files['/languages/index.java'] = `class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello, World!");
   }
 }`;
-state$m.files['/languages/index.cpp'] = `using namespace std;
+state$l.files['/languages/index.cpp'] = `using namespace std;
 
 template <class ANYTYPE>
 void thing(int a, Blah other_thing, double c=10, ANYTYPE f) {
@@ -7335,17 +7289,17 @@ int main(char arg_num, char** vargs) {
 
     #error I should be able to write single quotes in here: Don't make errors
 }`;
-state$m.files['/languages/index.env'] = 'KEY=42';
-state$m.files['/sample-folder/a.txt'] = '';
-state$m.files['/sample-folder/b.txt'] = '';
-state$m.files['/sample-folder/c.txt'] = '';
+state$l.files['/languages/index.env'] = 'KEY=42';
+state$l.files['/sample-folder/a.txt'] = '';
+state$l.files['/sample-folder/b.txt'] = '';
+state$l.files['/sample-folder/c.txt'] = '';
 
 // const getRelativePath = (path) => {
 //   return path.slice('/workspace'.length)
 // }
 
 const readFile$9 = async path => {
-  const file = state$m.files[path];
+  const file = state$l.files[path];
   if (file === undefined) {
     throw new Error(`file not found ${path}`);
   }
@@ -7367,7 +7321,7 @@ const createFolder = async path => {
   throw new Error('not implemented');
 };
 const writeFile$9 = async (path, content) => {
-  state$m.files[path] = content;
+  state$l.files[path] = content;
 };
 const getDirent$1 = (path, relativePath) => {
   const rest = path.slice(relativePath.length + 1);
@@ -7384,7 +7338,7 @@ const getDirent$1 = (path, relativePath) => {
 };
 const readDirWithFileTypes$3 = path => {
   const dirents = [];
-  for (const key in state$m.files) {
+  for (const key in state$l.files) {
     if (key.startsWith(path)) {
       const dirent = getDirent$1(key, path);
       if (!dirents.some(otherDirent => otherDirent.name === dirent.name)) {
@@ -7430,7 +7384,7 @@ const FileSystemWeb = {
   readFile: readFile$9,
   remove: remove$3,
   rename: rename$4,
-  state: state$m,
+  state: state$l,
   unwatch,
   unwatchAll,
   watch: watch$1,
@@ -7439,7 +7393,7 @@ const FileSystemWeb = {
 
 const canBeRestored$3 = true;
 const name$2k = 'Fetch';
-const state$l = {
+const state$k = {
   files: Object.create(null)
 };
 const readFile$8 = async uri => {
@@ -7499,7 +7453,7 @@ const FileSystemFetch = {
   readDirWithFileTypes: readDirWithFileTypes$2,
   readFile: readFile$8,
   remove: remove$2,
-  state: state$l,
+  state: state$k,
   writeFile: writeFile$8
 };
 
@@ -8053,17 +8007,17 @@ class ContentSecurityPolicyError extends Error {
   }
 }
 
-const state$k = {
+const state$j = {
   /**
    * @type {any[]}
    */
   errors: []
 };
 const hasRecentErrors = () => {
-  return state$k.errors.length > 0;
+  return state$j.errors.length > 0;
 };
 const getRecentError = () => {
-  return state$k.errors.at(-1);
+  return state$j.errors.at(-1);
 };
 
 const getLineAndColumn = (text, start, end) => {
@@ -8379,7 +8333,7 @@ const getPort = async ipcId => {
     ipcId
   });
   // TODO avoid side effect?
-  set$9(webContentsId);
+  set$8(webContentsId);
   return port2;
 };
 const create$11 = async options => {
@@ -8815,7 +8769,7 @@ const IpcParentWithWebSocket = {
   wrap: wrap$2
 };
 
-const getModule$8 = () => {
+const getModule$7 = () => {
   switch (platform) {
     case Web$1:
     case Remote:
@@ -8827,7 +8781,7 @@ const getModule$8 = () => {
   }
 };
 const create$X = async options => {
-  const module = await getModule$8();
+  const module = await getModule$7();
   const rawIpc = await module.create(options);
   if (options.raw) {
     return rawIpc;
@@ -9327,9 +9281,9 @@ const formatAboutDate = isoDate => {
   return `${isoDate} (${ago})`;
 };
 
-const version = '0.36.7';
-const commit = '9bdc73a';
-const date = '2024-10-18T16:15:08.000Z';
+const version = '0.37.0';
+const commit = '9c9d5bc';
+const date = '2024-10-19T09:21:38.000Z';
 const getPid = () => {
   return invoke$9('Process.getPid');
 };
@@ -9446,7 +9400,7 @@ const AppImage = 'AppImage';
 const WindowsNsis = 'WindowsNsis';
 const Deb = 'Deb';
 
-const getModule$7 = type => {
+const getModule$6 = type => {
   switch (type) {
     case AppImage:
       return Promise.resolve().then(function () { return AutoUpdaterAppImage; });
@@ -9494,7 +9448,7 @@ const checkForUpdates$1 = async () => {
   if (!shouldUpdate) {
     return;
   }
-  const module = await getModule$7(type);
+  const module = await getModule$6(type);
   if (!module) {
     return;
   }
@@ -9728,7 +9682,6 @@ const BulkReplacement_ipc = {
   name: name$2b
 };
 
-const TextPlain = 'text/plain';
 const ApplicationJson = 'aplication/json';
 
 const shouldIgnoreCacheStorageError = error => {
@@ -9769,21 +9722,6 @@ const getJson = async key => {
     throw new VError(error, `Failed to get json from cache "${key}"`);
   }
 };
-const getTextFromCache = async key => {
-  try {
-    const response = await getResponse(key);
-    if (!response) {
-      return undefined;
-    }
-    const text = await getText$3(response);
-    return text;
-  } catch (error) {
-    if (shouldIgnoreCacheStorageError(error)) {
-      return undefined;
-    }
-    throw new VError(error, `Failed to get text from cache "${key}"`);
-  }
-};
 const setResponse = async (key, value, contentType) => {
   if (typeof caches === 'undefined') {
     return;
@@ -9807,16 +9745,6 @@ const setResponse = async (key, value, contentType) => {
     })
   }));
 };
-const setText = async (key, value, contentType) => {
-  try {
-    await setResponse(key, value, contentType);
-  } catch (error) {
-    if (shouldIgnoreCacheStorageError(error)) {
-      return undefined;
-    }
-    throw new VError(error, `Failed to put item into cache "${key}"`);
-  }
-};
 const setJson = async (key, value) => {
   try {
     await setResponse(key, JSON.stringify(value), ApplicationJson);
@@ -10242,10 +10170,10 @@ const ContentTracing_ipc = {
 };
 
 const hasContextMenuNativePreference = () => {
-  const value = get$e('window.titleBarStyle');
+  const value = get$d('window.titleBarStyle');
   return value === 'native';
 };
-const getModule$6 = () => {
+const getModule$5 = () => {
   if (platform === Electron$1 && hasContextMenuNativePreference()) {
     return Promise.resolve().then(function () { return ContextMenuElectron; });
   }
@@ -10255,7 +10183,7 @@ const show$a = async (x, y, id, ...args) => {
   number$1(x);
   number$1(y);
   number$1(id);
-  const module = await getModule$6();
+  const module = await getModule$5();
   return module.show(x, y, id, ...args);
 };
 
@@ -10658,7 +10586,7 @@ const formatBytes = bytes => {
   return prettyBytes(bytes);
 };
 
-const getModule$5 = () => {
+const getModule$4 = () => {
   switch (platform) {
     case Electron$1:
       return Promise.resolve().then(function () { return ProcessExplorerElectron; });
@@ -10671,7 +10599,7 @@ const getModule$5 = () => {
   }
 };
 const open$6 = async () => {
-  const module = await getModule$5();
+  const module = await getModule$4();
   return module.open();
 };
 
@@ -10930,7 +10858,7 @@ const openFolder$5 = async () => {
 };
 
 // @ts-ignore
-const state$j = {
+const state$i = {
   dialog: undefined
 };
 const openFileWeb = () => {
@@ -10957,7 +10885,7 @@ const handleClick$c = async index => {
   // @ts-ignore
   const {
     options
-  } = state$j.dialog;
+  } = state$i.dialog;
   const option = options[index];
   // TODO handle case when index is out of bounds
   switch (option) {
@@ -10970,7 +10898,7 @@ const handleClick$c = async index => {
   }
 };
 const showMessage = async (message, options) => {
-  if (state$j.dialog) {
+  if (state$i.dialog) {
     console.info('cannot show multiple dialogs at the same time', message);
     return;
   }
@@ -10979,7 +10907,7 @@ const showMessage = async (message, options) => {
   // TODO on electron use native dialog
   options ||= ['Show Command Output', 'Cancel', 'Open Git Log'];
   // @ts-ignore
-  state$j.dialog = {
+  state$i.dialog = {
     message,
     options
   };
@@ -11222,8 +11150,8 @@ const rename$2 = (editor, offset, newName) => {
 
 const editorWorkerUrl = `${assetDir}/packages/editor-worker/dist/editorWorkerMain.js`;
 
-const getConfiguredWorkerUrl$3 = (preferenceKey, fallback) => {
-  let configuredWorkerUrl = get$e(preferenceKey) || '';
+const getConfiguredWorkerUrl$2 = (preferenceKey, fallback) => {
+  let configuredWorkerUrl = get$d(preferenceKey) || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
@@ -11235,7 +11163,7 @@ const getConfiguredWorkerUrl$3 = (preferenceKey, fallback) => {
 };
 
 const launchEditorWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$3('developer.editorWorkerPath', editorWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$2('developer.editorWorkerPath', editorWorkerUrl);
   const id = create$15();
   let ipc = await create$13({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
@@ -11257,10 +11185,10 @@ const launchEditorWorker = async () => {
 };
 
 const {
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$6
+  invoke: invoke$6,
+  invokeAndTransfer: invokeAndTransfer$5
 } = getOrCreateWorker(launchEditorWorker);
-const actualInvoke = invoke$7;
+const actualInvoke = invoke$6;
 
 const offsetAt = async (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
@@ -12027,7 +11955,7 @@ const MenuEntriesTerminal = {
   id: id$h
 };
 
-const getModule$4 = () => {
+const getModule$3 = () => {
   switch (platform) {
     case Web$1:
       return Promise.resolve().then(function () { return MenuEntriesTitleBarWeb; });
@@ -12037,7 +11965,7 @@ const getModule$4 = () => {
 };
 const id$g = TitleBar$1;
 const getMenuEntries$l = async () => {
-  const module = await getModule$4();
+  const module = await getModule$3();
   return module.getMenuEntries();
 };
 
@@ -12208,7 +12136,7 @@ const toElectronMenu = (map, rootId) => {
 };
 
 const menuEntries = [MenuEntriesFile, MenuEntriesEdit, MenuEntriesSelection, MenuEntriesView, MenuEntriesGo, MenuEntriesRun, MenuEntriesTerminal, MenuEntriesHelp, MenuEntriesTitleBar, MenuEntriesOpenRecent];
-const state$i = {
+const state$h = {
   commandMap: Object.create(null)
 };
 const setItems = async items => {
@@ -12230,7 +12158,7 @@ const hydrate = async () => {
     electronMenu,
     commandMap
   } = toElectronMenu(map, TitleBar$1);
-  state$i.commandMap = commandMap;
+  state$h.commandMap = commandMap;
   // console.log({ electronMenu })
   await setItems(electronMenu);
   // TODO get all menu items
@@ -12238,7 +12166,7 @@ const hydrate = async () => {
   // TODO add listener for when menu items change
 };
 const handleClick$b = async label => {
-  const commandPair = state$i.commandMap[label];
+  const commandPair = state$h.commandMap[label];
   if (!commandPair) {
     throw new Error(`no command found for ${label}`);
   }
@@ -12350,7 +12278,7 @@ const Exit_ipc = {
 };
 
 const STATUS_OFF = 0;
-const state$h = {
+const state$g = {
   status: STATUS_OFF,
   // TODO should be an enum state
   /**
@@ -12381,9 +12309,9 @@ const getWebExtensionManifest = async path => {
   };
 };
 const loadWebExtension = async path => {
-  object(state$h.extensionHostWorker);
+  object(state$g.extensionHostWorker);
   const manifest = await getWebExtensionManifest(path);
-  state$h.webExtensions.push(manifest);
+  state$g.webExtensions.push(manifest);
   // TODO use invoke
   // await new Promise((resolve) => {
   //   setTimeout(resolve, 120)
@@ -12556,7 +12484,7 @@ const IconTheme_ipc = {
   name: name$1I
 };
 
-const state$g = {
+const state$f = {
   uri: '',
   versionId: 0
 };
@@ -12568,11 +12496,11 @@ const TREE_ITEM_HEIGHT = 22;
 const TOP = TRIANGLE_OFFSET_TOP + (TREE_ITEM_HEIGHT - TRIANGLE_HEIGHT) / 2;
 const show$8 = async (uri, top, left) => {
   try {
-    const version = ++state$g.versionId;
+    const version = ++state$f.versionId;
     // TODO what to do on web? probably need to create blob url
     // or use https url for external images
     const blobUrl = await getBlobUrl$4(uri);
-    if (version !== state$g.versionId) {
+    if (version !== state$f.versionId) {
       return;
     }
     await invoke$a(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
@@ -12582,7 +12510,7 @@ const show$8 = async (uri, top, left) => {
   }
 };
 const hide$4 = async () => {
-  ++state$g.versionId;
+  ++state$f.versionId;
   await invoke$a(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
@@ -12636,24 +12564,24 @@ const getRipGrepArgs = ({
   return ripGrepArgs;
 };
 
-const state$f = {
+const state$e = {
   searches: Object.create(null)
 };
 const handleFinished = id => {
-  const search = state$f.searches[id];
+  const search = state$e.searches[id];
   if (!search) {
     return;
   }
   search.dispatchEvent(new Event('finished'));
-  delete state$f.searches[id];
+  delete state$e.searches[id];
 };
 const handleExit = id => {
-  const search = state$f.searches[id];
+  const search = state$e.searches[id];
   if (!search) {
     return;
   }
   search.dispatchEvent(new Event('exit'));
-  delete state$f.searches[id];
+  delete state$e.searches[id];
 };
 class RawDataEvent extends Event {
   constructor(data) {
@@ -12662,23 +12590,23 @@ class RawDataEvent extends Event {
   }
 }
 const handleData$2 = (id, data) => {
-  const search = state$f.searches[id];
+  const search = state$e.searches[id];
   if (!search) {
     return;
   }
   search.dispatchEvent(new RawDataEvent(data));
-  delete state$f.searches[id];
+  delete state$e.searches[id];
 };
 const handleCanceled = id => {
-  const search = state$f.searches[id];
+  const search = state$e.searches[id];
   if (!search) {
     return;
   }
   search.dispatchEvent(new Event('canceled'));
-  delete state$f.searches[id];
+  delete state$e.searches[id];
 };
 const handleError$1 = (id, error) => {
-  const search = state$f.searches[id];
+  const search = state$e.searches[id];
   if (!search) {
     return;
   }
@@ -12773,15 +12701,15 @@ const KeyBindingsInitial_ipc = {
   name: name$1B
 };
 
-const state$e = Object.create(null);
+const state$d = Object.create(null);
 const register$4 = listener => {
   const id = create$15();
-  state$e[id] = listener;
+  state$d[id] = listener;
   return id;
 };
 const execute$1 = (id, ...args) => {
   number$1(id);
-  const listener = state$e[id];
+  const listener = state$d[id];
   if (!listener) {
     warn$1(`listener with id ${id} not found`);
     return;
@@ -12806,7 +12734,7 @@ const Commands$1q = {
   getJson: getJson$3,
   getText: getText,
   setJson: setJson$3,
-  setText: setText$1
+  setText: setText
 };
 
 const LocalStorage_ipc = {
@@ -12865,8 +12793,8 @@ const load$2 = id => {
   }
 };
 
-const getModule$3 = id => {
-  const module = get$9(id);
+const getModule$2 = id => {
+  const module = get$8(id);
   if (module) {
     return module;
   }
@@ -12874,7 +12802,7 @@ const getModule$3 = id => {
 };
 const getMenuEntries$j = async (id, ...args) => {
   try {
-    const module = await getModule$3(id);
+    const module = await getModule$2(id);
     // @ts-ignore
     const inject = module.inject || [];
     const viewletStates = inject.map(getState$1);
@@ -12885,7 +12813,7 @@ const getMenuEntries$j = async (id, ...args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$G.matchingKeyBindings;
+  const keyBindings = state$E.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -13678,7 +13606,7 @@ const getVisible$2 = (items, focusedIndex, expanded, level) => {
   return visibleItems;
 };
 
-const state$d = {
+const state$c = {
   /**
    * @type {any[]}
    */
@@ -13709,16 +13637,16 @@ const getMenuHeight = items => {
   return height;
 };
 const getCurrentMenu = () => {
-  if (state$d.menus.length === 0) {
+  if (state$c.menus.length === 0) {
     warn$1('menu not available');
   }
-  return state$d.menus.at(-1);
+  return state$c.menus.at(-1);
 };
 const addMenuInternal = menu => {
-  if (state$d.menus.length > 5) {
+  if (state$c.menus.length > 5) {
     throw new Error('too many menus');
   }
-  state$d.menus.push(menu);
+  state$c.menus.push(menu);
   return menu;
 };
 const getMenuBounds = (x, y, items) => {
@@ -13750,7 +13678,7 @@ const show$7 = async (x, y, id, mouseBlocking = false, ...args) => {
     id,
     items,
     focusedIndex: -1,
-    level: state$d.menus.length,
+    level: state$c.menus.length,
     x: bounds.x,
     y: bounds.y
   });
@@ -13760,15 +13688,15 @@ const show$7 = async (x, y, id, mouseBlocking = false, ...args) => {
 };
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
-  state$d.menus = state$d.menus.slice(0, level + 1);
-  const parentMenu = state$d.menus[level];
+  state$c.menus = state$c.menus.slice(0, level + 1);
+  const parentMenu = state$c.menus[level];
   const item = parentMenu.items[index];
   const subMenuItems = await getMenuEntries$j(item.id);
   const subMenu = addMenuInternal({
     id: item.id,
     items: subMenuItems,
     focusedIndex: -1,
-    level: state$d.menus.length,
+    level: state$c.menus.length,
     y: parentMenu.y + index * 25,
     x: parentMenu.x + MENU_WIDTH,
     enterX,
@@ -13814,7 +13742,7 @@ const getSelectIndexFunction = flags => {
   }
 };
 const selectIndex$4 = async (level, index) => {
-  const menu = state$d.menus[level];
+  const menu = state$c.menus[level];
   // TODO avoid assignment
   menu.focusedIndex = index;
   const item = menu.items[menu.focusedIndex];
@@ -13822,8 +13750,8 @@ const selectIndex$4 = async (level, index) => {
   fn(menu, item, index);
 };
 const selectItem$1 = text => {
-  for (let level = 0; level < state$d.menus.length; level++) {
-    const menu = state$d.menus[level];
+  for (let level = 0; level < state$c.menus.length; level++) {
+    const menu = state$c.menus[level];
     for (let i = 0; i < menu.items.length; i++) {
       const item = menu.items[i];
       if (item.label === text) {
@@ -13834,10 +13762,10 @@ const selectItem$1 = text => {
   throw new Error(`menu item not found: ${text}`);
 };
 const hide$3 = async (restoreFocus = true) => {
-  if (state$d.menus.length === 0) {
+  if (state$c.menus.length === 0) {
     return;
   }
-  state$d.menus = [];
+  state$c.menus = [];
   await invoke$a(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
@@ -13846,8 +13774,8 @@ const hide$3 = async (restoreFocus = true) => {
 // with keyboard -> don't open submenu, only focus
 
 const hideSubMenus = async level => {
-  if (level < state$d.menus.length) {
-    state$d.menus = state$d.menus.slice(0, level + 1);
+  if (level < state$c.menus.length) {
+    state$c.menus = state$c.menus.slice(0, level + 1);
     await invoke$a(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
   }
 };
@@ -13856,21 +13784,21 @@ const resolveAfterTimeout = fn => {
   setTimeout(fn, MENU_DELAY_TRIANGLE);
 };
 const handleMouseEnter$1 = async (level, index, enterX, enterY, enterTimeStamp) => {
-  state$d.latestTimeStamp = enterTimeStamp;
-  if (level >= state$d.menus.length) {
+  state$c.latestTimeStamp = enterTimeStamp;
+  if (level >= state$c.menus.length) {
     return;
   }
-  const menu = state$d.menus[level];
+  const menu = state$c.menus[level];
   if (menu.focusedIndex === index) {
     return;
   }
-  if (level < state$d.menus.length - 1) {
-    const subMenu = state$d.menus[level + 1];
+  if (level < state$c.menus.length - 1) {
+    const subMenu = state$c.menus[level + 1];
     const subMenuEnterX = subMenu.enterX;
     // TODO should check for triangle position here
     if (enterX >= subMenuEnterX) {
       await new Promise(resolveAfterTimeout);
-      if (state$d.latestTimeStamp !== enterTimeStamp) {
+      if (state$c.latestTimeStamp !== enterTimeStamp) {
         return;
       }
     }
@@ -13887,7 +13815,7 @@ const handleMouseEnter$1 = async (level, index, enterX, enterY, enterTimeStamp)
   }
 };
 const handleMouseLeave$1 = async () => {
-  const menu = state$d.menus[0];
+  const menu = state$c.menus[0];
   if (menu.items.length === 0) {
     return;
   }
@@ -14097,18 +14025,18 @@ const HandleMaximized = 'handleMaximized';
 const HandleUnmaximized = 'handleUnmaximized';
 const HandleMinimized = 'handleMinimized';
 
-const state$c = {
+const state$b = {
   isMaximized: false,
   isMinimized: false
 };
 const setMaximized = value => {
-  state$c.isMaximized = value;
+  state$b.isMaximized = value;
 };
 const setMinimized = value => {
-  state$c.isMinimized = value;
+  state$b.isMinimized = value;
 };
 const isMaximized = () => {
-  return state$c.isMaximized;
+  return state$b.isMaximized;
 };
 
 const handleMaximized = () => {
@@ -14145,7 +14073,7 @@ const PART_PANEL = 3;
 const PART_STATUS_BAR = 4;
 const PART_SIDE_BAR = 5;
 const PART_ACTIVITY_BAR = 6;
-const state$b = {
+const state$a = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
@@ -14167,8 +14095,8 @@ const focusMain = async () => {
   await invoke$a(/* Main.focus */2145);
 };
 const focusPart = part => {
-  state$b.focusedPart = part;
-  switch (state$b.focusedPart) {
+  state$a.focusedPart = part;
+  switch (state$a.focusedPart) {
     case PART_TITLE_BAR:
       return focusTitleBar();
     case PART_MAIN:
@@ -14235,7 +14163,7 @@ const getVisiblePartPrevious = part => {
 };
 const getCurrentPart = () => {
   // TODO ask renderer process
-  return state$b.focusedPart;
+  return state$a.focusedPart;
 };
 const focusNextPart = async () => {
   const currentPart = getCurrentPart();
@@ -14266,12 +14194,12 @@ const Navigation_ipc = {
   name: name$1w
 };
 
-const state$a = {
+const state$9 = {
   notifications: []
 };
 const create$V = async (type, text) => {
   // @ts-ignore
-  state$a.notifications.push({
+  state$9.notifications.push({
     type,
     text
   });
@@ -14279,7 +14207,7 @@ const create$V = async (type, text) => {
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
-  state$a.notifications.push({
+  state$9.notifications.push({
     type,
     text,
     options
@@ -14288,7 +14216,7 @@ const showWithOptions = async (type, text, options) => {
 };
 const handleClick$a = index => {
   console.log('handle click');
-  const notification = state$a.notifications[0];
+  const notification = state$9.notifications[0];
   if (!notification.options) {
     throw new Error('notification has no options that can be clicked');
   }
@@ -14533,7 +14461,7 @@ const SessionStorage_ipc = {
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
 
 const launchTestWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$3('develop.testWorkerPath', testWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$2('develop.testWorkerPath', testWorkerUrl);
   const ipc = await create$13({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
@@ -14651,7 +14579,7 @@ const Workspace_ipc = {
 
 const name$1c = 'WindowTitle';
 const Commands$12 = {
-  set: set$a
+  set: set$9
 };
 
 const WindowTitle_ipc = {
@@ -14761,7 +14689,7 @@ const ExtensionHostDialog_ipc = {
   name: name$18
 };
 
-const set$4 = async (url, contentSecurityPolicy) => {
+const set$3 = async (url, contentSecurityPolicy) => {
   string(url);
   string(contentSecurityPolicy);
   if (platform === Web$1) {
@@ -14770,13 +14698,13 @@ const set$4 = async (url, contentSecurityPolicy) => {
   await invoke$9('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
-const set$3 = async (url, contentSecurityPolicy) => {
-  await set$4(url, contentSecurityPolicy);
+const set$2 = async (url, contentSecurityPolicy) => {
+  await set$3(url, contentSecurityPolicy);
 };
 
 const name$17 = 'ExtensionHostWorkerContentSecurityPolicy';
 const Commands$Z = {
-  set: set$3
+  set: set$2
 };
 
 const ExtensionHostWorkerContentSecurityPolicy_ipc = {
@@ -14810,8 +14738,8 @@ const launchTerminalWorker = async () => {
 };
 
 const {
-  invoke: invoke$6,
-  invokeAndTransfer: invokeAndTransfer$5
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$4
 } = getOrCreateWorker(launchTerminalWorker);
 
 const create$U = async canvasId => {
@@ -14823,7 +14751,7 @@ const create$U = async canvasId => {
 };
 const createForTerminal = async (canvasId, callbackId) => {
   const canvas = await create$U(canvasId);
-  await invokeAndTransfer$5('OffscreenCanvas.handleResult', callbackId, canvas);
+  await invokeAndTransfer$4('OffscreenCanvas.handleResult', callbackId, canvas);
 };
 
 const name$15 = 'OffscreenCanvas';
@@ -15116,8 +15044,8 @@ const ExtensionHostManagement_ipc = {
 
 const syntaxHighlightingWorkerUrl = `${assetDir}/packages/syntax-highlighting-worker/dist/syntaxHighlightingWorkerMain.js`;
 
-const getConfiguredWorkerUrl$2 = () => {
-  let configuredWorkerUrl = get$e('developer.syntaxHighlightingWorkerPath') || '';
+const getConfiguredWorkerUrl$1 = () => {
+  let configuredWorkerUrl = get$d('developer.syntaxHighlightingWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
@@ -15128,7 +15056,7 @@ const getConfiguredWorkerUrl$2 = () => {
   return configuredWorkerUrl;
 };
 const launchSyntaxHighlightingWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$2();
+  const configuredWorkerUrl = getConfiguredWorkerUrl$1();
   const name = 'Syntax Highlighting Worker';
   const id = create$15();
   let ipc = await create$13({
@@ -15147,14 +15075,14 @@ const launchSyntaxHighlightingWorker = async () => {
 };
 
 const {
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$3
 } = getOrCreateWorker(launchSyntaxHighlightingWorker);
 
 const sendMessagePortToSyntaxHighlightingWorker = async (port, initialCommand) => {
   object(port);
   string(initialCommand);
-  await invokeAndTransfer$4(initialCommand, port);
+  await invokeAndTransfer$3(initialCommand, port);
 };
 
 const name$T = 'SendMessagePortToSyntaxHighlightingWorker';
@@ -15292,8 +15220,8 @@ const getBlobUrl = (content, contentType) => {
 
 const iframeWorkerUrl = `${assetDir}/packages/iframe-worker/dist/iframeWorkerMain.js`;
 
-const getConfiguredWorkerUrl$1 = () => {
-  let configuredWorkerUrl = get$e('developer.iframeWorkerPath') || '';
+const getConfiguredWorkerUrl = () => {
+  let configuredWorkerUrl = get$d('developer.iframeWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
@@ -15304,7 +15232,7 @@ const getConfiguredWorkerUrl$1 = () => {
   return configuredWorkerUrl;
 };
 const launchIframeWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$1();
+  const configuredWorkerUrl = getConfiguredWorkerUrl();
   const name = 'Iframe Worker';
   const id = create$15();
   let ipc = await create$13({
@@ -15318,13 +15246,13 @@ const launchIframeWorker = async () => {
 };
 
 const {
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$3
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2
 } = getOrCreateWorker(launchIframeWorker);
 
 const getIframeSrc$1 = async (webView, locationOrigin) => {
-  const baseUrl = await invoke$4('WebView.getBaseUrl', webView);
-  const srcHtml = await invoke$4('WebView.getHtml', baseUrl, locationOrigin, webView.elements);
+  const baseUrl = await invoke$3('WebView.getBaseUrl', webView);
+  const srcHtml = await invoke$3('WebView.getHtml', baseUrl, locationOrigin, webView.elements);
   if (srcHtml) {
     const blobUrl = getBlobUrl(srcHtml, 'text/html');
     return {
@@ -15395,7 +15323,7 @@ const getWebViewsDefault = async () => {
 };
 const getWebViews = async () => {
   const nodeWebViews = await getWebViewsDefault();
-  const registeredWebViews = get$b();
+  const registeredWebViews = get$a();
   const allWebViews = [...nodeWebViews, ...registeredWebViews];
   return allWebViews;
 };
@@ -15465,7 +15393,7 @@ const WebViewProtocolWeb = {
   register: register$1
 };
 
-const getModule$2 = platform => {
+const getModule$1 = platform => {
   switch (platform) {
     case Remote:
       return WebViewProtocolRemote;
@@ -15477,7 +15405,7 @@ const getModule$2 = platform => {
   }
 };
 const register = async (previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent) => {
-  const module = getModule$2(platform);
+  const module = getModule$1(platform);
   return module.register(previewServerId, webViewPort, frameAncestors, webViewRoot, csp, iframeContent);
 };
 
@@ -15490,9 +15418,9 @@ const create$S = async (id, webViewPort, webViewId, previewServerId, uri) => {
     root = await invoke$9('Platform.getRoot');
   }
   const webViews = await getWebViews();
-  const locationProtocol = await invoke$4('Location.getProtocol');
-  const locationHost = await invoke$4('Location.getHost');
-  const locationOrigin = await invoke$4('Location.getOrigin');
+  const locationProtocol = await invoke$3('Location.getProtocol');
+  const locationHost = await invoke$3('Location.getHost');
+  const locationOrigin = await invoke$3('Location.getOrigin');
   const iframeResult = await getIframeSrc(webViews, webViewId, webViewPort, root, isGitpod, locationProtocol, locationHost, locationOrigin);
   if (!iframeResult) {
     return undefined;
@@ -15504,7 +15432,7 @@ const create$S = async (id, webViewPort, webViewId, previewServerId, uri) => {
     srcDoc,
     iframeContent
   } = iframeResult;
-  const frameAncestors = await invoke$4('WebView.getFrameAncestors', locationProtocol, locationHost);
+  const frameAncestors = await invoke$3('WebView.getFrameAncestors', locationProtocol, locationHost);
 
   // TODO figure out order for events, e.g.
   // 1. activate extension, create webview and ports in parallel
@@ -15512,7 +15440,7 @@ const create$S = async (id, webViewPort, webViewId, previewServerId, uri) => {
   // 3. setup extension host worker rpc
   // 4. create webview in extension host worker and load content
 
-  const csp = await invoke$4('WebView.getWebViewCsp', webView);
+  const csp = await invoke$3('WebView.getWebViewCsp', webView);
   const sandbox = getIframeSandbox(webView);
   const iframeCsp = platform === Web$1 ? csp : '';
   const credentialless = true;
@@ -15565,27 +15493,27 @@ const launchSearchProcess = async () => {
   return ipc;
 };
 
-const state$9 = {
+const state$8 = {
   /**
    * @type {Promise<any>|undefined}
    */
   ipc: undefined
 };
 const getOrCreate$1 = () => {
-  if (!state$9.ipc) {
+  if (!state$8.ipc) {
     // @ts-ignore
-    state$9.ipc = launchSearchProcess();
+    state$8.ipc = launchSearchProcess();
   }
-  return state$9.ipc;
+  return state$8.ipc;
 };
-const invoke$3 = async (method, ...params) => {
+const invoke$2 = async (method, ...params) => {
   const ipc = await getOrCreate$1();
   return invoke$b(ipc, method, ...params);
 };
 
 const name$Q = 'SearchProcess';
 const Commands$G = {
-  invoke: invoke$3
+  invoke: invoke$2
 };
 
 const SearchProcess_ipc = {
@@ -17566,8 +17494,8 @@ const launchDiffWorker = async () => {
 };
 
 const {
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$2
+  invoke: invoke$1,
+  invokeAndTransfer: invokeAndTransfer$1
 } = getOrCreateWorker(launchDiffWorker);
 
 /**
@@ -17577,7 +17505,7 @@ const {
  * @returns
  */
 const diff = (linesA, linesB) => {
-  return invoke$2('Diff.diff', linesA, linesB);
+  return invoke$1('Diff.diff', linesA, linesB);
 };
 
 const getDiffEditorContents = async (left, right) => {
@@ -17637,7 +17565,7 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-const state$8 = {
+const state$7 = {
   tokenizers: Object.create(null),
   tokenizePaths: Object.create(null),
   listeners: [],
@@ -17648,33 +17576,33 @@ const state$8 = {
   connectedEditors: []
 };
 const has = languageId => {
-  return languageId in state$8.tokenizers;
+  return languageId in state$7.tokenizers;
 };
-const set$2 = (languageId, tokenizer) => {
-  state$8.tokenizers[languageId] = tokenizer;
+const set$1 = (languageId, tokenizer) => {
+  state$7.tokenizers[languageId] = tokenizer;
 };
-const get$3 = languageId => {
-  return state$8.tokenizers[languageId];
+const get$2 = languageId => {
+  return state$7.tokenizers[languageId];
 };
 const isPending = languageId => {
-  return languageId in state$8.pending;
+  return languageId in state$7.pending;
 };
 const removeConnectedEditor$1 = id => {
-  const index = state$8.connectedEditors.indexOf(id);
+  const index = state$7.connectedEditors.indexOf(id);
   if (index === -1) {
     return;
   }
-  state$8.connectedEditors.splice(index, 1);
+  state$7.connectedEditors.splice(index, 1);
 };
 const isConnectedEditor = id => {
-  return state$8.connectedEditors.includes(id);
+  return state$7.connectedEditors.includes(id);
 };
 
 const tokenizers = Object.create(null);
-const set$1 = (id, value) => {
+const set = (id, value) => {
   tokenizers[id] = value;
 };
-const get$2 = id => {
+const get$1 = id => {
   return tokenizers[id] || TokenizePlainText;
 };
 
@@ -17688,7 +17616,7 @@ const handleTokenizeChange$1 = async () => {
       }
       const tokenizerId = create$15();
       const tokenizer = getTokenizer(state.languageId);
-      set$1(tokenizerId, tokenizer);
+      set(tokenizerId, tokenizer);
       const newState = {
         ...instance.state,
         tokenizerId,
@@ -17721,7 +17649,7 @@ const loadTokenizer = async languageId => {
       console.warn(`tokenizer.TokenMap should be an object in "${tokenizePath}"`);
       return;
     }
-    set$2(languageId, tokenizer);
+    set$1(languageId, tokenizer);
   } catch (error) {
     // TODO better error handling
     console.error(error);
@@ -17731,7 +17659,7 @@ const loadTokenizer = async languageId => {
 };
 const getTokenizer = languageId => {
   if (has(languageId)) {
-    return get$3(languageId);
+    return get$2(languageId);
   }
   if (isPending(languageId)) {
     return TokenizePlainText;
@@ -18091,7 +18019,7 @@ const getInitialLineState = initialLineState => {
   return deepCopy(initialLineState);
 };
 
-const state$7 = {
+const state$6 = {
   /**
    * @type {any}
    */
@@ -18106,10 +18034,10 @@ const flattenTokensArray = tokens => {
   return flattened;
 };
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$7.warned.includes(fn)) {
+  if (state$6.warned.includes(fn)) {
     return;
   }
-  state$7.warned.push(fn);
+  state$6.warned.push(fn);
   warn$1(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 /**
@@ -18207,7 +18135,7 @@ const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
     lines,
     languageId
   } = editor;
-  const tokenizer = get$2(tokenizerId);
+  const tokenizer = get$1(tokenizerId);
   const {
     hasArrayReturn,
     tokenizeLine,
@@ -19420,7 +19348,7 @@ const getFontString = (fontWeight, fontSize, fontFamily) => {
   return `${fontWeight} ${fontSize}px ${fontFamily}`;
 };
 
-const state$6 = {
+const state$5 = {
   /**
    * @type {OffscreenCanvasRenderingContext2D|undefined|null}
    */
@@ -19432,11 +19360,11 @@ const state$6 = {
  * @returns {OffscreenCanvasRenderingContext2D}
  */
 const getOrCreate = createCtx => {
-  if (state$6.ctx) {
-    return state$6.ctx;
+  if (state$5.ctx) {
+    return state$5.ctx;
   }
-  state$6.ctx = createCtx();
-  return state$6.ctx;
+  state$5.ctx = createCtx();
+  return state$5.ctx;
 };
 
 const createCtx = () => {
@@ -19652,46 +19580,46 @@ const kTabSize = 'editor.tabSize';
 const kLineNumbers = 'editor.lineNumbers';
 const kFormatOnSave = 'editor.formatOnSave';
 const isAutoClosingBracketsEnabled = () => {
-  return Boolean(get$e('editor.autoClosingBrackets'));
+  return Boolean(get$d('editor.autoClosingBrackets'));
 };
 const isAutoClosingQuotesEnabled = () => {
-  return Boolean(get$e('editor.autoClosingQuotes'));
+  return Boolean(get$d('editor.autoClosingQuotes'));
 };
 const isQuickSuggestionsEnabled = () => {
-  return Boolean(get$e('editor.quickSuggestions'));
+  return Boolean(get$d('editor.quickSuggestions'));
 };
 const isAutoClosingTagsEnabled = () => {
   return true;
 };
 const getRowHeight = () => {
-  return get$e(kLineHeight) || 20;
+  return get$d(kLineHeight) || 20;
 };
 const getFontSize = () => {
-  return get$e(kFontSize) || 15; // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
+  return get$d(kFontSize) || 15; // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
 };
 const getHoverEnabled = () => {
-  return get$e('editor.hover') ?? false;
+  return get$d('editor.hover') ?? false;
 };
 const getFontFamily = () => {
-  return get$e(kFontFamily) || 'Fira Code';
+  return get$d(kFontFamily) || 'Fira Code';
 };
 const getLetterSpacing = () => {
-  return get$e(kLetterSpacing) ?? 0.5;
+  return get$d(kLetterSpacing) ?? 0.5;
 };
 const getTabSize = () => {
-  return get$e(kTabSize) || 2;
+  return get$d(kTabSize) || 2;
 };
 const getLinks = () => {
-  return get$e(kLinks) || false;
+  return get$d(kLinks) || false;
 };
 const getLineNumbers = () => {
-  return get$e(kLineNumbers) ?? false;
+  return get$d(kLineNumbers) ?? false;
 };
 const getCompletionTriggerCharacters = () => {
   return ['.', '/'];
 };
 const getFormatOnSave = () => {
-  return get$e(kFormatOnSave) ?? false;
+  return get$d(kFormatOnSave) ?? false;
 };
 
 const combineResults$4 = results => {
@@ -19793,7 +19721,7 @@ const handleTokenizeChange = () => {
   const state = instance.state;
   const tokenizer = getTokenizer(state.languageId);
   const tokenizerId = create$15();
-  set$1(tokenizerId, tokenizer);
+  set(tokenizerId, tokenizer);
   const newState = {
     ...instance.state,
     tokenizerId
@@ -19866,7 +19794,7 @@ const loadContent$y = async (state, savedState, context) => {
   const languageId = getLanguageId(state);
   const tokenizer = getTokenizer(languageId);
   const tokenizerId = create$15();
-  set$1(tokenizerId, tokenizer);
+  set(tokenizerId, tokenizer);
   let savedSelections = getSavedSelections(savedState);
   const savedDeltaY = getSavedDeltaY(savedState);
   let newState2 = setDeltaYFixedValue(state, savedDeltaY);
@@ -19922,7 +19850,7 @@ const contentLoaded$7 = async state => {
   return [];
 };
 const updateSemanticTokens = async state => {
-  if (!get$e('editor.semanticTokens')) {
+  if (!get$d('editor.semanticTokens')) {
     return;
   }
   try {
@@ -19941,7 +19869,7 @@ const updateSemanticTokens = async state => {
   }
 };
 const updateDiagnostics = async state => {
-  if (!get$e('editor.diagnostics')) {
+  if (!get$d('editor.diagnostics')) {
     return;
   }
   try {
@@ -20977,7 +20905,7 @@ const restoreExpandedState = async (savedState, root, pathSeparator, excluded) =
   return dirents;
 };
 const getExcluded = () => {
-  const excludedObject = get$e('files.exclude') || {};
+  const excludedObject = get$d('files.exclude') || {};
   const excluded = [];
   for (const [key, value] of Object.entries(excludedObject)) {
     if (value) {
@@ -20990,7 +20918,7 @@ const getSavedRoot$1 = (savedState, workspacePath) => {
   return workspacePath;
 };
 const loadContent$w = async (state, savedState) => {
-  const root = getSavedRoot$1(savedState, state$A.workspacePath);
+  const root = getSavedRoot$1(savedState, state$y.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -21036,7 +20964,7 @@ const handleLanguagesChanged = state => {
   return updateIcons$1(state);
 };
 const handleWorkspaceChange$1 = async state => {
-  const newRoot = state$A.workspacePath;
+  const newRoot = state$y.workspacePath;
   const state1 = {
     ...state,
     root: newRoot
@@ -22614,7 +22542,7 @@ const restoreState = savedState => {
       deltaY: 0
     };
   }
-  const root = getSavedRoot(savedState, state$A.workspacePath);
+  const root = getSavedRoot(savedState, state$y.workspacePath);
   let minLineY = 0;
   if (savedState && typeof savedState.minLineY === 'number') {
     minLineY = savedState.minLineY;
@@ -24723,7 +24651,7 @@ const loadContent$s = async state => {
   return loadContent$t(state, getImplementations);
 };
 const contentLoaded$6 = state => {
-  set$b('Locations', {
+  set$a('Locations', {
     factory: ViewletLocations,
     state
   });
@@ -24879,7 +24807,7 @@ const ViewletImplementations_ipc = {
 };
 
 const getInlineDiffChanges = (linesLeft, linesRight) => {
-  return invoke$2('Diff.diffInline', linesLeft, linesRight);
+  return invoke$1('Diff.diffInline', linesLeft, linesRight);
 };
 
 const create$r = (id, uri, x, y, width, height) => {
@@ -26403,7 +26331,7 @@ const saveState$6 = state => {
   };
 };
 const getSideBarLocationType = () => {
-  const location = get$e('workbench.sideBarLocation');
+  const location = get$d('workbench.sideBarLocation');
   switch (location) {
     case 'left':
       return Left$2;
@@ -26423,7 +26351,7 @@ const getSavedPoints = savedState => {
   return new Uint16Array(Total);
 };
 const isNativeTitleBarStyle = () => {
-  return platform === Electron$1 && get$e('window.titleBarStyle') === 'native';
+  return platform === Electron$1 && get$d('window.titleBarStyle') === 'native';
 };
 const loadContent$p = (state, savedState) => {
   const {
@@ -27683,11 +27611,11 @@ const ViewletLayout_ipc = {
   toggleTitleBar
 };
 
-const state$5 = {
+const state$4 = {
   backgroundTabs: Object.create(null)
 };
 const add = (uri, props) => {
-  state$5.backgroundTabs[uri] = props;
+  state$4.backgroundTabs[uri] = props;
 };
 
 const measureTabWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing) => {
@@ -28888,7 +28816,7 @@ const handleTabContextMenu = async (state, eventX, eventY) => {
 };
 const handleFocusChange$1 = (state, isFocused) => {
   if (!isFocused) {
-    const autoSavePreference = get$e('files.autoSave');
+    const autoSavePreference = get$d('files.autoSave');
     if (autoSavePreference === 'onFocusChange') {
       return save(state);
     }
@@ -31011,7 +30939,7 @@ const None$7 = '';
 
 // TODO avoid global variable
 
-const state$4 = {
+const state$3 = {
   // providerId: PROVIDER_NOOP,
   provider: QuickPickNoop,
   prefix: 'string-that-should-never-match-another-string'
@@ -31022,16 +30950,16 @@ const state$4 = {
  */
 const name$o = 'everything';
 const getPlaceholder$a = () => {
-  return state$4.provider.getPlaceholder();
+  return state$3.provider.getPlaceholder();
 };
 const getLabel$5 = () => {
   return '';
 };
 const getHelpEntries$8 = () => {
-  return state$4.provider.getHelpEntries();
+  return state$3.provider.getHelpEntries();
 };
 const getNoResults$9 = () => {
-  return state$4.provider.getNoResults();
+  return state$3.provider.getNoResults();
 };
 const getPrefix = value => {
   if (value.startsWith(Command)) {
@@ -31073,20 +31001,20 @@ const getQuickPickProvider = prefix => {
 const getPicks$a = async value => {
   const prefix = getPrefix(value);
   // TODO race condition
-  if (state$4.prefix !== prefix) {
-    state$4.prefix = prefix;
+  if (state$3.prefix !== prefix) {
+    state$3.prefix = prefix;
     // @ts-ignore
-    state$4.provider = await getQuickPickProvider(prefix);
+    state$3.provider = await getQuickPickProvider(prefix);
   }
   // TODO this line is a bit duplicated with getFilterValue
   const slicedValue = value.slice(prefix.length);
-  const picks = await state$4.provider.getPicks(slicedValue);
+  const picks = await state$3.provider.getPicks(slicedValue);
   return picks;
 };
 const selectPick$a = item => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   return provider.selectPick(item);
 };
 const openCommandPalette = () => {
@@ -31096,18 +31024,18 @@ const openView = () => {
   // show('view ')
 };
 const getFilterValue$9 = value => {
-  return value.slice(state$4.prefix.length);
+  return value.slice(state$3.prefix.length);
 };
 const getPickFilterValue$5 = pick => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   return provider.getPickFilterValue(pick);
 };
 const getPickDescription$4 = pick => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   // @ts-ignore
   if (provider.getPickDescription) {
     // @ts-ignore
@@ -31118,21 +31046,21 @@ const getPickDescription$4 = pick => {
 const getPickLabel$5 = pick => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   // @ts-ignore
   return provider.getPickLabel(pick);
 };
 const getPickIcon$5 = pick => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   // @ts-ignore
   return provider.getPickIcon(pick);
 };
 const getPickFileIcon$2 = pick => {
   const {
     provider
-  } = state$4;
+  } = state$3;
   // @ts-ignore
   if (provider.getPickFileIcon) {
     // @ts-ignore
@@ -31140,6 +31068,17 @@ const getPickFileIcon$2 = pick => {
   }
   return '';
 };
+const isPrepared$1 = () => {
+  const {
+    provider
+  } = state$3;
+  // @ts-ignore
+  if (provider.isPrepared) {
+    // @ts-ignore
+    return provider.isPrepared();
+  }
+  return false;
+};
 
 const QuickPickEveryThing = {
   __proto__: null,
@@ -31154,11 +31093,12 @@ const QuickPickEveryThing = {
   getPickLabel: getPickLabel$5,
   getPicks: getPicks$a,
   getPlaceholder: getPlaceholder$a,
+  isPrepared: isPrepared$1,
   name: name$o,
   openCommandPalette,
   openView,
   selectPick: selectPick$a,
-  state: state$4
+  state: state$3
 };
 
 const filterQuickPickItem = (pattern, word) => {
@@ -31172,6 +31112,9 @@ const addEmptyMatch = pick => {
   };
 };
 const filterPicks = (state, picks, exclude, value, provider) => {
+  if (provider && provider.isPrepared && provider.isPrepared()) {
+    return picks;
+  }
   if (value === EmptyString) {
     return picks.map(addEmptyMatch);
   }
@@ -31773,7 +31716,7 @@ const loadContent$h = async state => {
 
 // TODO side effect is not good here, find a way to call ViewletLocations
 const contentLoaded$2 = state => {
-  set$b('Locations', {
+  set$a('Locations', {
     factory: ViewletLocations,
     state,
     renderedState: state
@@ -33705,7 +33648,7 @@ const handleUpdate = async (state, update) => {
         loaded: true
       };
     }
-    const root = state$A.workspacePath;
+    const root = state$y.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -33788,7 +33731,7 @@ const create$e = (id, uri, x, y, width, height) => {
     listFocused: false,
     listFocusedIndex: -1,
     inputSource: User,
-    workspacePath: state$A.workspacePath,
+    workspacePath: state$y.workspacePath,
     includeValue: '',
     excludeValue: '',
     detailsExpanded: false,
@@ -33817,7 +33760,7 @@ const getSavedCollapsedPaths = savedState => {
   return [];
 };
 const getThreads = () => {
-  const value = get$e('search.threads');
+  const value = get$d('search.threads');
   if (typeof value !== 'number' || value < 0 || value > 8) {
     return 0;
   }
@@ -34809,22 +34752,22 @@ const launchEmbedsWorker = async () => {
 };
 
 const {
-  invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
+  invoke,
+  invokeAndTransfer,
   dispose: dispose$6
 } = getOrCreateWorker(launchEmbedsWorker);
 
-const state$3 = {
+const state$2 = {
   refs: 0
 };
 const createWebContentsView = async (restoreId, fallThroughKeyBindings) => {
-  state$3.refs++;
-  return invoke$1('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
+  state$2.refs++;
+  return invoke('ElectronWebContentsView.createWebContentsView', restoreId, fallThroughKeyBindings);
 };
 const disposeWebContentsView = async id => {
-  await invoke$1('ElectronWebContentsView.disposeWebContentsView', id);
-  state$3.refs--;
-  if (state$3.refs === 0) {
+  await invoke('ElectronWebContentsView.disposeWebContentsView', id);
+  state$2.refs--;
+  if (state$2.refs === 0) {
     await dispose$6();
   }
 };
@@ -34855,25 +34798,25 @@ const resizeWebContentsView = async (id, x, y, width, height) => {
   const zoomValue = getZoomLevelToPercentValue(zoomLevel);
   const modifiedWidth = Math.round(width * zoomValue);
   const modifiedHeight = Math.round(height * zoomValue);
-  return invoke$1('ElectronWebContentsView.resizeWebContentsView', id, x, y, modifiedWidth, modifiedHeight);
+  return invoke('ElectronWebContentsView.resizeWebContentsView', id, x, y, modifiedWidth, modifiedHeight);
 };
 const setIframeSrc = async (id, iframeSrc) => {
-  return invoke$1('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
+  return invoke('ElectronWebContentsView.setIframeSrc', id, iframeSrc);
 };
 const focus$3 = id => {
-  return invoke$1('ElectronWebContentsView.focus', id);
+  return invoke('ElectronWebContentsView.focus', id);
 };
 const show$3 = id => {
-  return invoke$1('ElectronWebContentsView.show', id);
+  return invoke('ElectronWebContentsView.show', id);
 };
 const hide$1 = id => {
-  return invoke$1('ElectronWebContentsView.hide', id);
+  return invoke('ElectronWebContentsView.hide', id);
 };
 const setFallthroughKeyBindings = fallthroughKeyBindings => {
-  return invoke$1('ElectronWebContentsView.setFallthroughKeyBindings', fallthroughKeyBindings);
+  return invoke('ElectronWebContentsView.setFallthroughKeyBindings', fallthroughKeyBindings);
 };
 const getStats$1 = id => {
-  return invoke$1('ElectronWebContentsView.getStats', id);
+  return invoke('ElectronWebContentsView.getStats', id);
 };
 
 const isFallThroughKeyBinding = keyBinding => {
@@ -34949,7 +34892,7 @@ const getDefaultUrl = () => {
   return 'https://example.com';
 };
 const getShortCuts = () => {
-  const shortcuts = get$e('simpleBrowser.shortcuts') || [];
+  const shortcuts = get$d('simpleBrowser.shortcuts') || [];
   return shortcuts;
 };
 
@@ -35041,7 +34984,7 @@ const loadContent$c = async (state, savedState) => {
   const iframeSrc = getUrlFromSavedState(savedState);
   // TODO load keybindings in parallel with creating browserview
   const keyBindings = await getKeyBindings$i();
-  const suggestionsEnabled = get$e('simpleBrowser.suggestions');
+  const suggestionsEnabled = get$d('simpleBrowser.suggestions');
   const browserViewX = x;
   const browserViewY = y + headerHeight;
   const browserViewWidth = width;
@@ -35463,7 +35406,7 @@ const ViewletSimpleBrowser_ipc = {
   show: show$2
 };
 
-const state$2 = {
+const state$1 = {
   cache: Object.create(null)
 };
 const getContextId = (groupId, type) => {
@@ -35473,14 +35416,14 @@ const getContextId = (groupId, type) => {
   return groupId;
 };
 const ensureActions = async () => {
-  if (Object.keys(state$2.cache).length > 0) {
+  if (Object.keys(state$1.cache).length > 0) {
     return;
   }
   const extensions = await getExtensions$2();
   for (const extension of extensions) {
     if (extension && extension['source-control-actions']) {
       for (const [key, value] of Object.entries(extension['source-control-actions'])) {
-        state$2.cache[key] = value;
+        state$1.cache[key] = value;
       }
     }
   }
@@ -35489,7 +35432,7 @@ const getSourceControlActions = async (providerId, groupId, type) => {
   string(groupId);
   await ensureActions();
   const contextId = getContextId(groupId, type);
-  const value = state$2.cache[contextId] || [];
+  const value = state$1.cache[contextId] || [];
   return value;
 };
 
@@ -35651,7 +35594,7 @@ const loadContent$b = async state => {
     height,
     minimumSliderSize
   } = state;
-  const root = state$A.workspacePath;
+  const root = state$y.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
@@ -35661,7 +35604,7 @@ const loadContent$b = async state => {
   const isExpanded = true;
   const items = getDisplayItems(allGroups, isExpanded);
   const buttons = await getNewButtons(items, state.providerId, state.buttonIndex);
-  const splitButtonEnabled = get$e('sourceControl.splitButtonEnabled');
+  const splitButtonEnabled = get$d('sourceControl.splitButtonEnabled');
   const total = items.length;
   const contentHeight = total * itemHeight;
   const listHeight = getListHeight(total, itemHeight, height);
@@ -36272,7 +36215,7 @@ const getStatusBarItems = async showItems => {
 };
 
 const itemsVisible = () => {
-  const statusBarItemsPreference = get$e('statusBar.itemsVisible') ?? false;
+  const statusBarItemsPreference = get$d('statusBar.itemsVisible') ?? false;
   return statusBarItemsPreference;
 };
 
@@ -36587,16 +36530,16 @@ const loadContent$8 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$15();
   const canvasCursorId = create$15();
-  await invoke$6('Terminal.create', canvasTextId, canvasCursorId, uid, state$A.workspacePath, command, args);
+  await invoke$5('Terminal.create', canvasTextId, canvasCursorId, uid, state$y.workspacePath, command, args);
   const terminal = {
     handleBlur() {
-      return invoke$6('Terminal.handleBlur', uid);
+      return invoke$5('Terminal.handleBlur', uid);
     },
     handleKeyDown(key) {
-      return invoke$6('Terminal.handleKeyDown', uid, key);
+      return invoke$5('Terminal.handleKeyDown', uid, key);
     },
     handleMouseDown() {
-      return invoke$6('Terminal.handleMouseDown', uid);
+      return invoke$5('Terminal.handleMouseDown', uid);
     },
     resize() {
       // TODO
@@ -36775,7 +36718,7 @@ const getChildren$1 = state => {
   }];
 };
 const loadContent$7 = async state => {
-  const terminalTabsEnabled = get$e('terminal.tabs.enabled');
+  const terminalTabsEnabled = get$d('terminal.tabs.enabled');
   return {
     ...state,
     tabs: [{
@@ -37008,7 +36951,7 @@ const create$6 = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$6 = state => {
-  const titleBarTitleEnabled = get$e('titleBar.titleEnabled') ?? false;
+  const titleBarTitleEnabled = get$d('titleBar.titleEnabled') ?? false;
   return {
     ...state,
     isFocused: true,
@@ -37161,10 +37104,10 @@ const getTitleBarButtonsRemote = () => {
   return [];
 };
 const getTitleBarButtonsElectron = () => {
-  if (get$e('window.controlsOverlay.enabled')) {
+  if (get$d('window.controlsOverlay.enabled')) {
     return [];
   }
-  if (get$e('window.titleBarStyle') === 'custom') {
+  if (get$d('window.titleBarStyle') === 'custom') {
     // TODO don't render title bar buttons on windows when electron window controls overlay is enabled
     return [{
       label: minimize(),
@@ -37184,7 +37127,7 @@ const getTitleBarButtonsElectron = () => {
 };
 
 // @ts-ignore
-const get$1 = () => {
+const get = () => {
   switch (platform) {
     case Electron$1:
       return getTitleBarButtonsElectron();
@@ -37206,7 +37149,7 @@ const create$5 = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$5 = async state => {
-  const buttons = get$1();
+  const buttons = get();
   return {
     ...state,
     buttons
@@ -39196,7 +39139,7 @@ const ViewletExplorerHandleDragOver = {
   handleDragOver
 };
 
-const getModule$1 = () => {
+const getModule = () => {
   switch (platform) {
     case Electron$1:
       return Promise.resolve().then(function () { return ViewletExplorerHandleDropRootElectron; });
@@ -39205,7 +39148,7 @@ const getModule$1 = () => {
   }
 };
 const handleDropRoot = async (state, files) => {
-  const module = await getModule$1();
+  const module = await getModule();
   return module.handleDrop(state, files);
 };
 
@@ -41168,11 +41111,11 @@ const Cloud = 2;
 const Tag = 3;
 
 const name$4 = 'custom';
-const state$1 = {
+const state = {
   args: []
 };
 const setArgs = args => {
-  state$1.args = args;
+  state.args = args;
 };
 const getPlaceholder$4 = () => {
   return '';
@@ -41191,13 +41134,13 @@ const getNoResults$4 = () => {
   };
 };
 const getPicks$4 = async searchValue => {
-  const items = state$1.args[1] || [];
+  const items = state.args[1] || [];
   return items;
 };
 const selectPick$4 = async pick => {
   const {
     args
-  } = state$1;
+  } = state;
   const resolve = args[2];
   resolve(pick);
   return {
@@ -41247,7 +41190,7 @@ const QuickPickEntriesCustom = {
   name: name$4,
   selectPick: selectPick$4,
   setArgs,
-  state: state$1
+  state
 };
 
 const getCommandsFromExtension = extension => {
@@ -41490,35 +41433,13 @@ const QuickPickEntriesGoToLine = {
   selectPick: selectPick$1
 };
 
-const getModule = protocol => {
-  if (isEmptyString(protocol)) {
-    // TODO only read preference once when opening quickpick
-    const preference = get$e('search.searchWith');
-    if (preference === 'git-ls-files') {
-      return Promise.resolve().then(function () { return SearchFileWIthGitLsFiles; });
-    }
-  }
-  switch (protocol) {
-    case Web:
-      return Promise.resolve().then(function () { return SearchFileWeb; });
-    case Memfs:
-      return Promise.resolve().then(function () { return SearchFileMemfs; });
-    case Fetch:
-      return Promise.resolve().then(function () { return SearchFileWithFetch; });
-    case Html:
-      return Promise.resolve().then(function () { return SearchFileWithHtml; });
-    default:
-      return Promise.resolve().then(function () { return SearchFileWithRipGrep; });
-  }
-};
-const searchFile$7 = async (path, value) => {
-  const protocol = getProtocol(path);
-  const module = await getModule(protocol);
-  return module.searchFile(path, value);
+const searchFile$1 = async (path, value, prepare) => {
+  return invoke$7('SearchFile.searchFile', path, value, prepare, assetDir);
 };
 
-const searchFile$6 = async (path, value) => {
-  const files = await searchFile$7(/* path */path, /* searchTerm */value);
+const searchFile = async (path, value) => {
+  const prepare = true;
+  const files = await searchFile$1(/* path */path, /* searchTerm */value, prepare);
   return files;
 };
 const name = 'file';
@@ -41542,16 +41463,16 @@ const getNoResults = () => {
   };
 };
 const getPicks = async searchValue => {
-  const workspace = state$A.workspacePath;
+  const workspace = state$y.workspacePath;
   if (!workspace) {
     return [];
   }
-  const files = await searchFile$6(workspace, searchValue);
+  const files = await searchFile(workspace, searchValue);
   // const picks = files.map(toPick)
   return files;
 };
 const selectPick = async pick => {
-  const workspace = state$A.workspacePath;
+  const workspace = state$y.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */absolutePath);
   return {
@@ -41562,13 +41483,22 @@ const getFilterValue = value => {
   return value;
 };
 const getPickFilterValue = pick => {
+  if (typeof pick === 'object') {
+    pick = pick.pick;
+  }
   return pick;
 };
 const getPickLabel = pick => {
+  if (typeof pick === 'object') {
+    pick = pick.pick;
+  }
   const baseName = pathBaseName(pick);
   return baseName;
 };
 const getPickDescription = pick => {
+  if (typeof pick === 'object') {
+    pick = pick.pick;
+  }
   const dirName = pathDirName(pick);
   return dirName;
 };
@@ -41576,11 +41506,20 @@ const getPickIcon = () => {
   return '';
 };
 const getPickFileIcon = pick => {
+  if (typeof pick === 'object') {
+    pick = pick.pick;
+  }
   const baseName = pathBaseName(pick);
   return getFileIcon$2({
     name: baseName
   });
 };
+const isPrepared = () => {
+  const workspace = state$y.workspacePath;
+  // TODO protocol should always be defined. For files it should use file protocol
+  const protocol = getProtocol(workspace);
+  return !protocol;
+};
 
 const QuickPickEntriesFile = {
   __proto__: null,
@@ -41595,6 +41534,7 @@ const QuickPickEntriesFile = {
   getPickLabel,
   getPicks,
   getPlaceholder,
+  isPrepared,
   name,
   selectPick
 };
@@ -41888,7 +41828,7 @@ const textSearch$4 = async (scheme, root, query, options) => {
     ripGrepArgs,
     searchDir: root
   };
-  const result = await invoke$3(TextSearchSearch, actualOptions);
+  const result = await invoke$2(TextSearchSearch, actualOptions);
   // TODO api is weird
   return result.results;
 };
@@ -41899,7 +41839,7 @@ const TextSearchNode = {
 };
 
 const textSearch$3 = (scheme, root, query) => {
-  const entries = Object.entries(state$m.files);
+  const entries = Object.entries(state$l.files);
   const results = [];
   for (const [key, value] of entries) {
     if (value.includes(query)) {
@@ -42731,28 +42671,28 @@ const ViewletSimpleBrowserHandleContextMenu = {
 };
 
 const openDevtools$1 = id => {
-  return invoke$1('ElectronWebContentsView.openDevtools', id);
+  return invoke('ElectronWebContentsView.openDevtools', id);
 };
 const reload$1 = id => {
-  return invoke$1('ElectronWebContentsView.reload', id);
+  return invoke('ElectronWebContentsView.reload', id);
 };
 const forward$1 = id => {
-  return invoke$1('ElectronWebContentsView.forward', id);
+  return invoke('ElectronWebContentsView.forward', id);
 };
 const backward$1 = id => {
-  return invoke$1('ElectronWebContentsView.backward', id);
+  return invoke('ElectronWebContentsView.backward', id);
 };
 const cancelNavigation$1 = id => {
-  return invoke$1('ElectronWebContentsView.cancelNavigation', id);
+  return invoke('ElectronWebContentsView.cancelNavigation', id);
 };
 const inspectElement$1 = (id, x, y) => {
-  return invoke$1('ElectronWebContentsView.inspectElement', id, x, y);
+  return invoke('ElectronWebContentsView.inspectElement', id, x, y);
 };
 const copyImageAt = (id, x, y) => {
-  return invoke$1('ElectronWebContentsView.copyImageAt', id, x, y);
+  return invoke('ElectronWebContentsView.copyImageAt', id, x, y);
 };
 const getStats = id => {
-  return invoke$1('ElectronWebContentsView.getStats', id);
+  return invoke('ElectronWebContentsView.getStats', id);
 };
 
 const inspectElement = async (state, x, y) => {
@@ -42903,7 +42843,7 @@ const handleClickFile = async (state, item) => {
   const absolutePath = `${root}/${item.file}`;
   // TODO handle error
   const [fileBefore] = await Promise.all([getFileBefore(providerId, item.file), readFile$e(absolutePath)]);
-  if (get$i().width < inlineDiffEditorBreakpoint) {
+  if (get$h().width < inlineDiffEditorBreakpoint) {
     await execute$4('Main.openUri', `inline-diff://data://${fileBefore}<->${absolutePath}`);
   } else {
     await execute$4('Main.openUri', `diff://data://${fileBefore}<->${absolutePath}`);
@@ -43878,157 +43818,3 @@ const ViewletExplorerHandleDropRootDefault = {
   __proto__: null,
   handleDrop
 };
-
-const normalizeCacheKey = cacheKey => {
-  if (cacheKey.startsWith(Slash$2)) {
-    return cacheKey;
-  }
-  return `/${cacheKey}`;
-};
-const get = async cacheKey => {
-  try {
-    const normalizedCacheKey = normalizeCacheKey(cacheKey);
-    const text = await getTextFromCache(normalizedCacheKey);
-    return text;
-  } catch (error) {
-    throw new VError(error, 'Failed to get value from file search cache');
-  }
-};
-const set = async (cacheKey, value) => {
-  try {
-    const normalizedCacheKey = normalizeCacheKey(cacheKey);
-    await setText(normalizedCacheKey, value, TextPlain);
-  } catch (error) {
-    throw new VError(error, 'Failed to put value into file search cache');
-  }
-};
-
-const gitLsFiles = (gitPath, cwd, limit) => {
-  return invoke$9('GitLsFiles.gitLsFiles', gitPath, cwd, limit);
-};
-const gitLsFilesHash = (gitPath, cwd, limit) => {
-  return invoke$9('GitLsFiles.gitLsFilesHash', gitPath, cwd, limit);
-};
-const resolveGit$1 = () => {
-  return invoke$9('GitLsFiles.resolveGit');
-};
-
-const state = {
-  resolvedGit: ''
-};
-const resolveGit = async () => {
-  return resolveGit$1();
-};
-const getOrResolveGit = async () => {
-  state.resolvedGit ||= await resolveGit();
-  return state.resolvedGit;
-};
-const searchFile$5 = async (path, value) => {
-  const limit = 512;
-  const gitPath = await getOrResolveGit();
-  const cacheId = await gitLsFilesHash(gitPath, path, limit);
-  const cachedResult = await get(cacheId);
-  if (cachedResult) {
-    return splitLines(cachedResult);
-  }
-  const actualResult = await gitLsFiles(gitPath, path, limit);
-  await set(actualResult.cacheId, actualResult.stdout);
-  const files = splitLines(actualResult.stdout);
-  return files;
-};
-
-const SearchFileWIthGitLsFiles = {
-  __proto__: null,
-  searchFile: searchFile$5,
-  state
-};
-
-const removeLeadingSlash$1 = file => {
-  return file.slice(1);
-};
-const searchFile$4 = async (path, value) => {
-  const files = state$m.files;
-  const keys = Object.keys(files).map(removeLeadingSlash$1);
-  return keys;
-};
-
-const SearchFileWeb = {
-  __proto__: null,
-  searchFile: searchFile$4
-};
-
-const searchFile$3 = async (path, value) => {
-  const files = state$n.files;
-  const keys = Object.keys(files);
-  return keys;
-};
-
-const SearchFileMemfs = {
-  __proto__: null,
-  searchFile: searchFile$3
-};
-
-const removeLeadingSlash = path => {
-  const workspacePath = state$A.workspacePath;
-  return path.slice(workspacePath.length - Fetch.length - 2);
-};
-const searchFile$2 = async (path, value) => {
-  const fetchUri = `${assetDir}/config/fileMap.json`;
-  const fileList = await execute$4('Ajax.getJson', fetchUri);
-  const result = fileList.map(removeLeadingSlash);
-  return result;
-};
-
-const SearchFileWithFetch = {
-  __proto__: null,
-  searchFile: searchFile$2
-};
-
-const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
-
-const getConfiguredWorkerUrl = () => {
-  let configuredWorkerUrl = get$e('develop.fileSearchWorkerPath') || '';
-  if (configuredWorkerUrl) {
-    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
-  }
-  configuredWorkerUrl = configuredWorkerUrl || fileSearchWorkerUrl;
-  {
-    configuredWorkerUrl = fileSearchWorkerUrl;
-  }
-  return configuredWorkerUrl;
-};
-const launchFileSearchWorker = async () => {
-  const name = 'File Search Worker';
-  const ipc = await create$13({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name,
-    url: getConfiguredWorkerUrl()
-  });
-  handleIpc(ipc);
-  return ipc;
-};
-
-const {
-  invoke,
-  invokeAndTransfer
-} = getOrCreateWorker(launchFileSearchWorker);
-
-const searchFile$1 = async uri => {
-  const files = await invoke('SearchFile.searchFileWithHtml', uri);
-  return files;
-};
-
-const SearchFileWithHtml = {
-  __proto__: null,
-  searchFile: searchFile$1
-};
-
-const searchFile = async (path, value) => {
-  const lines = await invoke('SearchFile.searchFileWithRipGrep', path, value);
-  return lines;
-};
-
-const SearchFileWithRipGrep = {
-  __proto__: null,
-  searchFile
-};