@lvce-editor/server 0.21.0 → 0.21.2

package/static/{f639638 → ba057bc}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -447,7 +447,7 @@ class VError extends Error {
   }
 }
 
-const state$X = {
+const state$W = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -472,7 +472,7 @@ const initializeModule = (module) => {
 
 const loadModule$1 = async (moduleId) => {
   try {
-    const module = await state$X.load(moduleId);
+    const module = await state$W.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`)
@@ -480,23 +480,23 @@ const loadModule$1 = async (moduleId) => {
 };
 
 const getOrLoadModule = (moduleId) => {
-  if (!state$X.pendingModules[moduleId]) {
-    state$X.pendingModules[moduleId] = loadModule$1(moduleId);
+  if (!state$W.pendingModules[moduleId]) {
+    state$W.pendingModules[moduleId] = loadModule$1(moduleId);
   }
-  return state$X.pendingModules[moduleId]
+  return state$W.pendingModules[moduleId]
 };
 
 const loadCommand = (command) => getOrLoadModule(getModuleId$1(command));
 
 const register$1 = (commandId, listener) => {
-  state$X.commands[commandId] = listener;
+  state$W.commands[commandId] = listener;
 };
 
 const hasThrown = new Set();
 
 const execute$5 = (command, ...args) => {
-  if (command in state$X.commands) {
-    const fn = state$X.commands[command];
+  if (command in state$W.commands) {
+    const fn = state$W.commands[command];
     if (typeof fn !== 'function') {
       throw new Error(`[renderer-worker] Command ${command} is not a function`)
     }
@@ -506,7 +506,7 @@ const execute$5 = (command, ...args) => {
     loadCommand(command)
       // TODO can skip then block in prod (only to prevent endless loop in dev)
       .then(() => {
-        if (!(command in state$X.commands)) {
+        if (!(command in state$W.commands)) {
           if (hasThrown.has(command)) {
             return
           }
@@ -519,7 +519,7 @@ const execute$5 = (command, ...args) => {
 };
 
 const setLoad = (load) => {
-  state$X.load = load;
+  state$W.load = load;
 };
 
 const Web$1 = 1;
@@ -534,36 +534,36 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/f639638'
+    return '/ba057bc'
   }
 };
 
 const assetDir = getAssetDir();
 
-const state$W = {
+const state$V = {
   pending: Object.create(null),
 };
 
 const get$8 = (id) => {
-  return state$W.pending[id]
+  return state$V.pending[id]
 };
 
 const has$1 = (id) => {
-  return id in state$W.pending
+  return id in state$V.pending
 };
 
 const set$7 = (id, value) => {
-  state$W.pending[id] = value;
+  state$V.pending[id] = value;
 };
 
 const NotFound = 404;
 
-const state$V = {
+const state$U = {
   id: 0,
 };
 
-const create$12 = () => {
-  return ++state$V.id
+const create$13 = () => {
+  return ++state$U.id
 };
 
 const info = (...args) => {
@@ -598,26 +598,26 @@ const withResolvers = () => {
   }
 };
 
-const state$U = {
+const state$T = {
   callbacks: Object.create(null),
 };
 
 const registerPromise = () => {
-  const id = create$12();
+  const id = create$13();
   const { resolve, promise } = withResolvers();
-  state$U.callbacks[id] = resolve;
+  state$T.callbacks[id] = resolve;
   return { id, promise }
 };
 
 const resolve = (id, args) => {
   number(id);
-  if (!(id in state$U.callbacks)) {
+  if (!(id in state$T.callbacks)) {
     console.log(args);
     warn$1(`callback ${id} may already be disposed`);
     return
   }
-  state$U.callbacks[id](args);
-  delete state$U.callbacks[id];
+  state$T.callbacks[id](args);
+  delete state$T.callbacks[id];
 };
 
 const Two = '2.0';
@@ -698,7 +698,7 @@ const listen$a = async ({ method }) => {
   return ipc
 };
 
-const create$11 = (method, params) => {
+const create$12 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -706,7 +706,7 @@ const create$11 = (method, params) => {
   }
 };
 
-const create$10 = (method, params) => {
+const create$11 = (method, params) => {
   const { id, promise } = registerPromise();
   const message = {
     jsonrpc: Two,
@@ -859,21 +859,29 @@ const unwrapJsonRpcResult = (responseMessage) => {
 };
 
 const send$2 = (transport, method, ...params) => {
-  const message = create$11(method, params);
+  const message = create$12(method, params);
   transport.send(message);
 };
 
 const invoke$3 = async (ipc, method, ...params) => {
-  const { message, promise } = create$10(method, params);
+  const { message, promise } = create$11(method, params);
   ipc.send(message);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
   return result
 };
 
+const invokeAndTransfer$1 = async (ipc, transfer, method, ...params) => {
+  const { message, promise } = create$11(method, params);
+  ipc.sendAndTransfer(message, transfer);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result
+};
+
 /* istanbul ignore file */
 
-const state$T = {
+const state$S = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -886,14 +894,18 @@ const getIpc = () => {
 };
 
 const listen$9 = async () => {
-  console.assert(state$T.pendingMessages.length === 0);
+  console.assert(state$S.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc, 'renderer process');
-  state$T.ipc = ipc;
+  state$S.ipc = ipc;
 };
 
 const invoke$2 = async (method, ...params) => {
-  return invoke$3(state$T.ipc, method, ...params)
+  return invoke$3(state$S.ipc, method, ...params)
+};
+
+const invokeAndTransfer = async (method, transfer, ...params) => {
+  return invokeAndTransfer$1(state$S.ipc, transfer, method, ...params)
 };
 
 const getText$4 = (response) => {
@@ -904,7 +916,7 @@ const getJson$7 = (response) => {
   return response.json()
 };
 
-const create$$ = (value, options) => {
+const create$10 = (value, options) => {
   return new Response(value, options)
 };
 
@@ -1203,7 +1215,7 @@ const getMarkerLines = (loc, source, opts) => {
   return { start, end, markerLines }
 };
 
-const create$_ = (rawLines, loc, opts = {}) => {
+const create$$ = (rawLines, loc, opts = {}) => {
   const lines = rawLines.split(NEWLINE);
   const { start, end, markerLines } = getMarkerLines(loc, lines, opts);
   const hasColumns = loc.start && typeof loc.start.column === 'number';
@@ -1535,7 +1547,7 @@ const prepareErrorMessageWithoutCodeFrame = async (error) => {
       const { source, originalLine, originalColumn } = getOriginalPosition(sourceMap, parsedLine, parsedColumn);
       const absoluteSourceUrl = toAbsoluteUrl(path, source);
       const originalSourceContent = await getText$3(absoluteSourceUrl);
-      const codeFrame = create$_(originalSourceContent, {
+      const codeFrame = create$$(originalSourceContent, {
         start: {
           line: originalLine,
           column: originalColumn,
@@ -1553,7 +1565,7 @@ const prepareErrorMessageWithoutCodeFrame = async (error) => {
         _error: error,
       }
     }
-    const codeFrame = create$_(text, {
+    const codeFrame = create$$(text, {
       start: {
         line: parsedLine,
         column: parsedColumn,
@@ -1629,7 +1641,7 @@ const getMessage$8 = (error) => {
   return `Error: ${error}`
 };
 
-const state$S = {
+const state$R = {
   /**
    * @type {string[]}
    */
@@ -1666,10 +1678,10 @@ const showErrorDialog = async (error) => {
 
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$S.seenWarnings.includes(stringified)) {
+  if (state$R.seenWarnings.includes(stringified)) {
     return
   }
-  state$S.seenWarnings.push(stringified);
+  state$R.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
@@ -1680,11 +1692,12 @@ const ReferencePort = 4;
 const WebSocket$1 = 5;
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 const Node = 7;
+const NodeAlternate = 8;
 
 const getModule$8 = (method) => {
   switch (method) {
     case ElectronMessagePort:
-      return Promise.resolve().then(function () { return IpcParentWithElectron; })
+      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; })
     case MessagePort$1:
       return Promise.resolve().then(function () { return IpcParentWithMessagePort; })
     case ModuleWorker:
@@ -1697,12 +1710,14 @@ const getModule$8 = (method) => {
       return Promise.resolve().then(function () { return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug; })
     case Node:
       return Promise.resolve().then(function () { return IpcParentWithNode; })
+    case NodeAlternate:
+      return Promise.resolve().then(function () { return IpcParentWithNodeAlternate; })
     default:
       throw new Error('unexpected ipc type')
   }
 };
 
-const create$Z = async ({ method, ...options }) => {
+const create$_ = async ({ method, ...options }) => {
   const module = await getModule$8(method);
   // @ts-ignore
   const rawIpc = await module.create(options);
@@ -1716,7 +1731,7 @@ const create$Z = async ({ method, ...options }) => {
 const SharedProcess = 'lvce.shared-process';
 
 const listen$8 = (method) => {
-  return create$Z({
+  return create$_({
     method,
     type: 'shared-process',
     name: 'Shared Process',
@@ -1724,20 +1739,20 @@ const listen$8 = (method) => {
   })
 };
 
-/* istanbul ignore file */
-
-const state$R = {
+const state$Q = {
   /**
    * @type {any}
    */
   ipc: undefined,
 };
 
+/* istanbul ignore file */
+
 const handleMessageFromSharedProcess = async (message) => {
   if (message.method) {
     const result = await execute$5(message.method, ...message.params);
     if (message.id) {
-      state$R.send({
+      state$Q.ipc.send({
         jsonrpc: Two,
         id: message.id,
         result,
@@ -1753,7 +1768,7 @@ const handleMessageFromSharedProcess = async (message) => {
 const listen$7 = async () => {
   const ipc = await listen$8(Node);
   ipc.onmessage = handleMessageFromSharedProcess;
-  state$R.ipc = ipc;
+  state$Q.ipc = ipc;
 };
 
 const invoke$1 = async (method, ...params) => {
@@ -1761,7 +1776,7 @@ const invoke$1 = async (method, ...params) => {
   //   console.warn('SharedProcess is not available on web')
   //   return
   // }
-  const result = await invoke$3(state$R.ipc, method, ...params);
+  const result = await invoke$3(state$Q.ipc, method, ...params);
   return result
 };
 
@@ -1824,7 +1839,7 @@ const Disk = '';
 
 // TODO lazyload different file system providers
 
-const state$Q = {
+const state$P = {
   fileSystems: Object.create(null),
 };
 
@@ -1854,10 +1869,10 @@ const loadFileSystem = (procotol) => {
 };
 
 const getFileSystem = (protocol) => {
-  if (!(protocol in state$Q.fileSystems)) {
-    state$Q.fileSystems[protocol] = loadFileSystem(protocol);
+  if (!(protocol in state$P.fileSystems)) {
+    state$P.fileSystems[protocol] = loadFileSystem(protocol);
   }
-  return state$Q.fileSystems[protocol]
+  return state$P.fileSystems[protocol]
 };
 
 const RE_PROTOCOL = /^([a-z\-]+):\/\//;
@@ -1998,27 +2013,27 @@ const canBeRestored$6 = async (uri) => {
 // pros
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
-const state$P = {
+const state$O = {
   listenerMap: Object.create(null),
 };
 
 const emitEvent = async (event, ...args) => {
-  const listeners = state$P.listenerMap[event] || [];
+  const listeners = state$O.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 
 const addListener = (event, fn) => {
-  state$P.listenerMap[event] ||= [];
-  if (state$P.listenerMap[event].includes(fn)) {
+  state$O.listenerMap[event] ||= [];
+  if (state$O.listenerMap[event].includes(fn)) {
     return
   }
-  state$P.listenerMap[event].push(fn);
+  state$O.listenerMap[event].push(fn);
 };
 
 const removeListener$1 = (event, fn) => {
-  const listeners = state$P.listenerMap[event];
+  const listeners = state$O.listenerMap[event];
   if (!listeners) {
     console.info(`[info] listener for event ${event} is not registered and cannot be unregistered`);
     return
@@ -2026,7 +2041,7 @@ const removeListener$1 = (event, fn) => {
   const index = listeners.indexOf(fn);
   listeners.splice(index, 1);
   if (listeners.length === 0) {
-    delete state$P.listenerMap[event];
+    delete state$O.listenerMap[event];
   }
 };
 
@@ -2077,7 +2092,7 @@ const TextSearchSearch = 'TextSearch.search';
 
 const WorkspaceResolveRoot = 'Workspace.resolveRoot';
 
-const state$O = Object.create(null);
+const state$N = Object.create(null);
 
 const openSettingsJson = async () => {
   await execute$5(/* Main.openUri */ 'Main.openUri', /* uri */ 'app://settings.json');
@@ -2112,29 +2127,29 @@ const hydrate$a = async () => {
     // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
     // TODO probably not all preferences need to be kept in memory
     const preferences = await getPreferences();
-    Object.assign(state$O, preferences);
+    Object.assign(state$N, preferences);
   } catch (error) {
     logError(error);
   }
 };
 
 const get$7 = (key) => {
-  return state$O[key]
+  return state$N[key]
 };
 
 const set$6 = async (key, value) => {
-  state$O[key] = value;
+  state$N[key] = value;
   if (platform === Web$1) {
-    const preferences = { ...state$O, [key]: value };
+    const preferences = { ...state$N, [key]: value };
     await execute$5(/* LocalStorage.setJson */ 'LocalStorage.setJson', /* key */ 'preferences', /* value */ preferences);
     return
   }
-  const content = stringify(state$O);
+  const content = stringify(state$N);
   await writeFile$f('app://settings.json', content);
 };
 
 const update$3 = async (settings) => {
-  const newSettings = { ...state$O, ...settings };
+  const newSettings = { ...state$N, ...settings };
   const content = stringify(newSettings);
   await writeFile$f('app://settings.json', content);
   await emitEvent('preferences.changed');
@@ -2143,7 +2158,7 @@ const update$3 = async (settings) => {
 // 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$N = {
+const state$M = {
   watchedTheme: '',
 };
 
@@ -2164,7 +2179,7 @@ const getColorThemeCss = async (colorThemeId, colorThemeJson) => {
 const applyColorTheme = async (colorThemeId) => {
   try {
     string(colorThemeId);
-    state$N.colorTheme = colorThemeId;
+    state$M.colorTheme = colorThemeId;
     const colorThemeJson = await getColorThemeJson(colorThemeId);
     const colorThemeCss = await getColorThemeCss(colorThemeId, colorThemeJson);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
@@ -2187,10 +2202,10 @@ const setColorTheme$1 = async (colorThemeId) => {
 };
 
 const watch$1 = async (id) => {
-  if (state$N.watchedTheme === id) {
+  if (state$M.watchedTheme === id) {
     return
   }
-  state$N.watchedTheme = id;
+  state$M.watchedTheme = id;
   await invoke$1('ExtensionHost.watchColorTheme', id);
 };
 
@@ -2248,7 +2263,7 @@ const getBrowser = () => {
   return 'chromium'
 };
 
-const state$M = {
+const state$L = {
   // contexts: Object.create(null),
   contexts: {},
 };
@@ -2260,31 +2275,31 @@ const state$M = {
 // Context.get(1), Context.get(2)
 
 const get$6 = (key) => {
-  return state$M.contexts[key]
+  return state$L.contexts[key]
 };
 
 const set$5 = (key, value) => {
-  state$M.contexts[key] = value;
+  state$L.contexts[key] = value;
 };
 
 const remove$9 = (key) => {
-  delete state$M.contexts[key];
+  delete state$L.contexts[key];
 };
 
-const state$L = {
+const state$K = {
   // TODO use numeric focus key
   currentFocus: '',
 };
 
 const get$5 = () => {
-  return state$L.currentFocus
+  return state$K.currentFocus
 };
 
 const set$4 = (value) => {
-  state$L.currentFocus = value;
+  state$K.currentFocus = value;
 };
 
-const state$K = {
+const state$J = {
   keyBindings: [],
   keyBindingSets: Object.create(null),
   /**
@@ -2298,7 +2313,7 @@ const state$K = {
 };
 
 const getKeyBinding = (identifier) => {
-  for (const keyBinding of state$K.matchingKeyBindings) {
+  for (const keyBinding of state$J.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding
     }
@@ -2325,24 +2340,24 @@ const getAvailableKeyBindings = (keyBindings) => {
 };
 
 const update$2 = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$K.keyBindingSets);
-  state$K.matchingKeyBindings = matchingKeyBindings;
-  state$K.keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$2('KeyBindings.setIdentifiers', state$K.keyBindingIdentifiers);
+  const matchingKeyBindings = getMatchingKeyBindings(state$J.keyBindingSets);
+  state$J.matchingKeyBindings = matchingKeyBindings;
+  state$J.keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
+  invoke$2('KeyBindings.setIdentifiers', state$J.keyBindingIdentifiers);
 };
 
 const addKeyBindings = (id, keyBindings) => {
   array(keyBindings);
-  if (id in state$K.keyBindingSets) {
+  if (id in state$J.keyBindingSets) {
     warn$1(`cannot add keybindings multiple times: ${id}`);
     return
   }
-  state$K.keyBindingSets[id] = keyBindings;
+  state$J.keyBindingSets[id] = keyBindings;
   update$2();
 };
 
 const removeKeyBindings = (id) => {
-  const { keyBindingSets } = state$K;
+  const { keyBindingSets } = state$J;
   if (!(id in keyBindingSets)) {
     warn$1(`cannot remove keybindings that are not registered: ${id}`);
     return
@@ -2410,7 +2425,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
 };
 
 const getLanguageConfigurationFromWebExtension = async (languageId) => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$I.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$H.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined
   }
@@ -2479,7 +2494,7 @@ const getNthFileExtension = (file, startIndex) => {
 // TODO merge all of this with extension host languages module
 
 
-const state$J = {
+const state$I = {
   loadState: false,
   isHydrating: false,
   fileNameMap: Object.create(null),
@@ -2496,64 +2511,64 @@ const state$J = {
 };
 
 const getFirstLines = () => {
-  return state$J.firstLines
+  return state$I.firstLines
 };
 
 const hasLanguageByExtension = (extension) => {
-  return extension in state$J.extensionMap
+  return extension in state$I.extensionMap
 };
 
 const getLanguageByExtension = (extension) => {
-  return state$J.extensionMap[extension]
+  return state$I.extensionMap[extension]
 };
 
 const hasLanguageByFileName = (fileName) => {
-  return fileName in state$J.fileNameMap
+  return fileName in state$I.fileNameMap
 };
 
 const getLanguageByFileName = (fileName) => {
-  return state$J.fileNameMap[fileName]
+  return state$I.fileNameMap[fileName]
 };
 
 const getTokenizeFunctionPath$1 = (languageId) => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$J.tokenizerMap[languageId] || ''
+  return state$I.tokenizerMap[languageId] || ''
 };
 
 const setHydrating = (value) => {
-  state$J.isHydrating = value;
+  state$I.isHydrating = value;
 };
 
 const setLoaded = (value) => {
-  state$J.loaded = true;
+  state$I.loaded = true;
 };
 
 const addExtension = (extension, languageId) => {
-  state$J.extensionMap[extension] = languageId;
+  state$I.extensionMap[extension] = languageId;
 };
 
 const addFirstLine = (regex, languageId) => {
-  state$J.firstLines.push({ regex, languageId });
+  state$I.firstLines.push({ regex, languageId });
 };
 
 const hasWarned = (languageId) => {
-  return state$J.hasWarned.includes(languageId)
+  return state$I.hasWarned.includes(languageId)
 };
 
 const addWarned = (languageId) => {
-  return state$J.hasWarned.push(languageId)
+  return state$I.hasWarned.push(languageId)
 };
 
 const addFileName = (fileName, languageId) => {
-  state$J.fileNameMap[fileName] = languageId;
+  state$I.fileNameMap[fileName] = languageId;
 };
 
 const addTokenizer = (languageId, tokenizer) => {
-  state$J.tokenizerMap[languageId] = tokenizer;
+  state$I.tokenizerMap[languageId] = tokenizer;
 };
 
 const hasLoaded$1 = () => {
-  return state$J.loaded
+  return state$I.loaded
 };
 
 // TODO merge all of this with extension host languages module
@@ -2661,7 +2676,7 @@ const warnFileNames = (languageId, language) => {
       break
     }
   }
-  const codeFrame = create$_(code, {
+  const codeFrame = create$$(code, {
     start: {
       line: rowIndex + 1,
       column: columnIndex + 1,
@@ -2859,7 +2874,7 @@ const getRepository = () => {
   return invoke$1('Platform.getRepository')
 };
 
-const state$I = {
+const state$H = {
   /**
    * @type {any[]}
    */
@@ -2896,7 +2911,7 @@ const addWebExtension$1 = async (path) => {
     }
   }
   manifest.status = Resolved;
-  state$I.webExtensions.push(manifest);
+  state$H.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -2914,7 +2929,7 @@ const getStaticWebExtensions = () => {
 
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$I.webExtensions]
+  return [...staticWebExtensions, ...state$H.webExtensions]
 };
 
 const isWebExtension = (extension) => {
@@ -2925,7 +2940,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$I.webExtensions]
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$H.webExtensions]
 };
 
 const getWebExtensions = async () => {
@@ -2937,7 +2952,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault()
     }
   } catch {
-    return state$I.webExtensions
+    return state$H.webExtensions
   }
 };
 
@@ -3039,7 +3054,7 @@ const getIconThemeJson = async (iconThemeId) => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`,
     }
   }
-  for (const webExtension of state$I.webExtensions) {
+  for (const webExtension of state$H.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -3057,7 +3072,7 @@ const getIconThemeJson = async (iconThemeId) => {
 
 const initialIconTheme = undefined;
 
-const state$H = {
+const state$G = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -3067,22 +3082,22 @@ const state$H = {
   iconTheme: initialIconTheme,
 };
 
-const state$G = {
+const state$F = {
   openCount: 0,
 };
 
 const createBrowserView$1 = (restoreId, fallThroughKeyBindings) => {
-  state$G.openCount++;
+  state$F.openCount++;
   return invoke$1('ElectronBrowserView.createBrowserView', restoreId, fallThroughKeyBindings)
 };
 
 const disposeBrowserView$1 = (id) => {
-  state$G.openCount--;
+  state$F.openCount--;
   return invoke$1('ElectronBrowserView.disposeBrowserView', id)
 };
 
 const isOpen = () => {
-  return state$G.openCount > 0
+  return state$F.openCount > 0
 };
 
 class CancelationError extends Error {
@@ -3212,7 +3227,7 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value)
 };
 
-const state$F = {
+const state$E = {
   instances: Object.create(null),
   /**
    * @type {any}
@@ -3226,11 +3241,11 @@ const set$3 = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$F.instances[key] = value;
+  state$E.instances[key] = value;
 };
 
 const getInstance = (key) => {
-  const fast = state$F.instances[key];
+  const fast = state$E.instances[key];
   if (fast) {
     return fast
   }
@@ -3240,7 +3255,7 @@ const getInstance = (key) => {
   if (key === 'EditorText') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$F.instances)) {
+  for (const value of Object.values(state$E.instances)) {
     if (value.moduleId === key) {
       return value
     }
@@ -3249,19 +3264,19 @@ const getInstance = (key) => {
 };
 
 const hasInstance = (key) => {
-  return key in state$F.instances
+  return key in state$E.instances
 };
 
 const remove$8 = (key) => {
-  delete state$F.instances[key];
+  delete state$E.instances[key];
 };
 
 const getAllInstances = () => {
-  return state$F.instances
+  return state$E.instances
 };
 
 const getValues = () => {
-  return Object.values(state$F.instances)
+  return Object.values(state$E.instances)
 };
 
 const getState$1 = (key) => {
@@ -3317,7 +3332,7 @@ const set$2 = (title) => {
   return invoke$2('WindowTitle.set', title)
 };
 
-const state$E = {
+const state$D = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -3335,17 +3350,17 @@ const setPath$1 = async (path) => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$E.workspacePath = path;
+  state$D.workspacePath = path;
   // @ts-ignore
-  state$E.workspaceUri = path;
-  state$E.pathSeparator = pathSeparator;
+  state$D.workspaceUri = path;
+  state$D.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 
 const setUri = async (uri) => {
   const path = uri.slice('file://'.length);
-  state$E.workspacePath = path;
-  state$E.workspaceUri = uri;
+  state$D.workspacePath = path;
+  state$D.workspaceUri = uri;
   await onWorkspaceChange();
 };
 
@@ -3373,13 +3388,13 @@ const getResolveRootFromSessionStorage = async () => {
 };
 
 const isTest = () => {
-  return state$E.isTest
+  return state$D.isTest
 };
 
 const getResolvedRootFromRendererProcess = async (href) => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$E.isTest = true;
+    state$D.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -3433,7 +3448,7 @@ const getResolvedRoot = async (href) => {
 };
 
 const getTitle$1 = (workspacePath) => {
-  const pathSeparator = state$E.pathSeparator;
+  const pathSeparator = state$D.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1)
 };
 
@@ -3445,40 +3460,40 @@ const getPathName = (workspacePath) => {
 };
 
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$E.workspacePath);
+  const title = getTitle$1(state$D.workspacePath);
   await set$2(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$E.workspacePath);
+    const pathName = getPathName(state$D.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$E.workspacePath);
+  await emitEvent('workspace.change', state$D.workspacePath);
 };
 
 const hydrate$5 = async ({ href }) => {
-  if (state$E.workspacePath) {
+  if (state$D.workspacePath) {
     return
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$E.isTest) {
+  if (state$D.isTest) {
     return
   }
-  if (state$E.workspacePath) {
+  if (state$D.workspacePath) {
     return
   }
   // TODO why is this if statement here?
-  if (state$E.homeDir !== resolvedRoot.homeDir) {
-    state$E.homeDir = resolvedRoot.homeDir;
+  if (state$D.homeDir !== resolvedRoot.homeDir) {
+    state$D.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$E.workspacePath = resolvedRoot.path;
-  state$E.homeDir = resolvedRoot.homeDir;
-  state$E.pathSeparator = resolvedRoot.pathSeparator;
-  state$E.workspaceUri = resolvedRoot.uri;
-  state$E.source = resolvedRoot.source;
+  state$D.workspacePath = resolvedRoot.path;
+  state$D.homeDir = resolvedRoot.homeDir;
+  state$D.pathSeparator = resolvedRoot.pathSeparator;
+  state$D.workspaceUri = resolvedRoot.uri;
+  state$D.source = resolvedRoot.source;
   await onWorkspaceChange();
 };
 
@@ -3487,11 +3502,11 @@ const hydrate$5 = async ({ href }) => {
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$E.workspacePath
+  return state$D.workspacePath
 };
 
 const getHomeDir = () => {
-  return state$E.homeDir
+  return state$D.homeDir
 };
 
 // TODO this should be in FileSystem module
@@ -3501,7 +3516,7 @@ const pathBaseName = (path) => {
 
 // TODO this should be in FileSystem module
 const pathDirName = (path) => {
-  const pathSeparator = state$E.pathSeparator || '/';
+  const pathSeparator = state$D.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString
@@ -3511,9 +3526,9 @@ const pathDirName = (path) => {
 
 const getAbsolutePath = (relativePath) => {
   if (relativePath.startsWith('./')) {
-    return `${state$E.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
+    return `${state$D.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
   }
-  return `${state$E.workspacePath}/${relativePath}` // TODO support windows paths
+  return `${state$D.workspacePath}/${relativePath}` // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -3523,10 +3538,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$E.workspacePath,
-      homeDir: state$E.homeDir,
-      pathSeparator: state$E.pathSeparator,
-      uri: state$E.workspaceUri,
+      path: state$D.workspacePath,
+      homeDir: state$D.homeDir,
+      pathSeparator: state$D.pathSeparator,
+      uri: state$D.workspaceUri,
     },
   }
 };
@@ -3729,7 +3744,7 @@ const ViewletModuleId = {
   Video
 };
 
-const state$D = {
+const state$C = {
   pendingModules: Object.create(null),
 };
 
@@ -3850,7 +3865,7 @@ const wrapViewletCommandWithSideEffectLazy = (id, key, importFn) => {
  * @param {()=>any} getModule
  * @returns
  */
-const create$Y = (getModule, id, parentUid, uri, x, y, width, height) => {
+const create$Z = (getModule, id, parentUid, uri, x, y, width, height) => {
   fn(getModule);
   string(id);
   number(parentUid);
@@ -3973,7 +3988,7 @@ const actuallyLoadModule = async (getModule, id) => {
     }
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$O);
+    await addDynamicCss(id, module.getDynamicCss, state$N);
   }
   maybeRegisterWrappedCommands(id, module);
   maybeRegisterEvents(module);
@@ -3981,10 +3996,10 @@ const actuallyLoadModule = async (getModule, id) => {
 };
 
 const loadModule = (getModule, id) => {
-  if (!(id in state$D.pendingModules)) {
-    state$D.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$C.pendingModules)) {
+    state$C.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$D.pendingModules[id]
+  return state$C.pendingModules[id]
 };
 
 // TODO add lots of unit tests for this
@@ -4011,7 +4026,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
   }
   let state = ViewletState.Default;
   // @ts-ignore
-  const viewletUid = viewlet.uid || create$12();
+  const viewletUid = viewlet.uid || create$13();
   let module;
   try {
     viewlet.type = 1;
@@ -4063,7 +4078,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.getChildren) {
       const children = module.getChildren(newState);
       for (const child of children) {
-        const childUid = child.uid || create$12();
+        const childUid = child.uid || create$13();
         const childId = child.id;
         const childViewlet = {
           x: child.x,
@@ -4426,7 +4441,7 @@ const handleKeyBinding = async (identifier) => {
   // }
 };
 
-const state$C = {
+const state$B = {
   isQuickPickOpen: false,
 };
 
@@ -4439,12 +4454,12 @@ const getQuickPickKeyBindings = (keyBindings) => {
 };
 
 const isQuickPickOpen = () => {
-  return state$C.isQuickPickOpen
+  return state$B.isQuickPickOpen
 };
 
 const openElectronQuickPick = async (...args) => {
   // TODO avoid side effect
-  state$C.isQuickPickOpen = true;
+  state$B.isQuickPickOpen = true;
   const id = QuickPick;
   const width = 600;
   const height = 300;
@@ -4455,7 +4470,7 @@ const openElectronQuickPick = async (...args) => {
   const keyBindings = await undefined();
   const quickPickKeyBindings = getQuickPickKeyBindings(keyBindings);
   await createBrowserViewQuickPick(x, y, width, height);
-  const ipc = await create$Z({
+  const ipc = await create$_({
     method: ElectronMessagePort,
     type: 'quickpick',
   });
@@ -4497,7 +4512,7 @@ const openElectronQuickPick = async (...args) => {
 
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$C.isQuickPickOpen = false;
+  state$B.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -4701,7 +4716,7 @@ const openWidget = async (moduleId, ...args) => {
     }
     return openElectronQuickPick(...args)
   }
-  const childUid = create$12();
+  const childUid = create$13();
   const commands = await load$8({
     getModule: load$6,
     id: moduleId,
@@ -4885,7 +4900,7 @@ const getAbsoluteIconPath = (iconTheme, icon) => {
 
 const getFileNameIcon = (file) => {
   string(file);
-  const { iconTheme } = state$H;
+  const { iconTheme } = state$G;
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return ''
@@ -4927,7 +4942,7 @@ const getFileIcon$1 = (file) => {
 };
 
 const getFolderIcon = (folder) => {
-  const iconTheme = state$H.iconTheme;
+  const iconTheme = state$G.iconTheme;
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return ''
@@ -4942,7 +4957,7 @@ const getFolderIcon = (folder) => {
 };
 
 const getFolderIconExpanded = (folder) => {
-  const iconTheme = state$H.iconTheme;
+  const iconTheme = state$G.iconTheme;
   if (!iconTheme) {
     return ''
   }
@@ -4972,7 +4987,7 @@ const getIcon$1 = (dirent) => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$H.iconTheme, File$6)
+      return getAbsoluteIconPath(state$G.iconTheme, File$6)
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$c
@@ -4982,8 +4997,8 @@ const getIcon$1 = (dirent) => {
 const setIconTheme$1 = async (iconThemeId) => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$H.iconTheme = iconTheme.json;
-    state$H.extensionPath = iconTheme.extensionPath;
+    state$G.iconTheme = iconTheme.json;
+    state$G.extensionPath = iconTheme.extensionPath;
     const instances = getAllInstances();
     // TODO have one recalculate style and one paint
     for (const [key, value] of Object.entries(instances)) {
@@ -5039,29 +5054,29 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$B = {
+const state$A = {
   listenerMap: Object.create(null),
   phase: Zero,
 };
 
 const once = (event, listener) => {
-  if (state$B.phase >= event) {
+  if (state$A.phase >= event) {
     listener();
   } else {
     // TODO could also statically allocate listenermap at start as array[13]
-    state$B.listenerMap[event] ||= [];
-    state$B.listenerMap[event].push(listener);
+    state$A.listenerMap[event] ||= [];
+    state$A.listenerMap[event].push(listener);
   }
 };
 
 const mark$1 = (event) => {
-  const listeners = state$B.listenerMap[event] || [];
+  const listeners = state$A.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$B.phase = event;
+  state$A.phase = event;
   if (event === Twelve) {
-    state$B.listenerMap = Object.create(null);
+    state$A.listenerMap = Object.create(null);
   }
 };
 
@@ -5374,15 +5389,15 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`
 };
 
-const state$A = {
+const state$z = {
   sessionId: '',
 };
 
 const getSessionId = () => {
-  if (!state$A.sessionId) {
-    state$A.sessionId = creareSessionId();
+  if (!state$z.sessionId) {
+    state$z.sessionId = creareSessionId();
   }
-  return state$A.sessionId
+  return state$z.sessionId
 };
 
 const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
@@ -5421,7 +5436,7 @@ function promisifyRequest(request) {
             request.removeEventListener('error', error);
         };
         const success = () => {
-            resolve(wrap$a(request.result));
+            resolve(wrap$b(request.result));
             unlisten();
         };
         const error = () => {
@@ -5489,7 +5504,7 @@ let idbProxyTraps = {
             }
         }
         // Else transform whatever we get back.
-        return wrap$a(target[prop]);
+        return wrap$b(target[prop]);
     },
     set(target, prop, value) {
         target[prop] = value;
@@ -5515,7 +5530,7 @@ function wrapFunction(func) {
         return function (storeNames, ...args) {
             const tx = func.call(unwrap(this), storeNames, ...args);
             transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
-            return wrap$a(tx);
+            return wrap$b(tx);
         };
     }
     // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
@@ -5528,13 +5543,13 @@ function wrapFunction(func) {
             // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
             // the original object.
             func.apply(unwrap(this), args);
-            return wrap$a(cursorRequestMap.get(this));
+            return wrap$b(cursorRequestMap.get(this));
         };
     }
     return function (...args) {
         // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
         // the original object.
-        return wrap$a(func.apply(unwrap(this), args));
+        return wrap$b(func.apply(unwrap(this), args));
     };
 }
 function transformCachableValue(value) {
@@ -5549,7 +5564,7 @@ function transformCachableValue(value) {
     // Return the same value back if we're not going to transform it.
     return value;
 }
-function wrap$a(value) {
+function wrap$b(value) {
     // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
     // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
     if (value instanceof IDBRequest)
@@ -5578,10 +5593,10 @@ const unwrap = (value) => reverseTransformCache.get(value);
  */
 function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
     const request = indexedDB.open(name, version);
-    const openPromise = wrap$a(request);
+    const openPromise = wrap$b(request);
     if (upgrade) {
         request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrap$a(request.result), event.oldVersion, event.newVersion, wrap$a(request.transaction), event);
+            upgrade(wrap$b(request.result), event.oldVersion, event.newVersion, wrap$b(request.transaction), event);
         });
     }
     if (blocked) {
@@ -5703,7 +5718,7 @@ replaceTraps((oldTraps) => ({
 // TODO high memory usage in idb because of transactionDoneMap
 
 
-const state$z = {
+const state$y = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -5715,7 +5730,7 @@ const state$z = {
 
 const getDb = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$z.dbVersion, {
+  const db = await openDB('session', state$y.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -5729,10 +5744,10 @@ const getDb = async () => {
 };
 
 const getDbMemoized = async () => {
-  if (!state$z.cachedDb) {
-    state$z.cachedDb = await getDb();
+  if (!state$y.cachedDb) {
+    state$y.cachedDb = await getDb();
   }
-  return state$z.cachedDb
+  return state$y.cachedDb
 };
 
 const saveValue$1 = async (storeId, value) => {
@@ -5763,7 +5778,7 @@ const getValuesByIndexName$1 = async (storeId, indexName, only) => {
 
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state$z.dbVersion, {
+  const db = await openDB('handle', state$y.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         await db.createObjectStore('file-handles-store', {});
@@ -5824,7 +5839,7 @@ const addSearchParam = (href, key, value) => {
 };
 
 const replayCurrentSession = async () => {
-  if (!state$A.sessionId) {
+  if (!state$z.sessionId) {
     throw new VError(`session replay is disabled in settings`)
   }
   // TODO
@@ -5847,7 +5862,7 @@ const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 
 const replaySession = async (sessionId) => {
   const events = await getEvents(sessionId);
-  const originalIpc = state$T.ipc;
+  const originalIpc = state$S.ipc;
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalOnMessage = originalIpc.onmessage.bind(originalIpc);
   const wrappedSend = () => {};
@@ -5862,33 +5877,33 @@ const replaySession = async (sessionId) => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$T.ipc.onmessage = originalOnMessage;
-          state$T.ipc.send = originalSend;
+          state$S.ipc.onmessage = originalOnMessage;
+          state$S.ipc.send = originalSend;
           await execute$5('ElectronWindow.close');
-          state$T.ipc.onmessage = wrappedOnMessage;
-          state$T.ipc.send = wrappedSend;
+          state$S.ipc.onmessage = wrappedOnMessage;
+          state$S.ipc.send = wrappedSend;
           break
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$T.ipc.onmessage = originalOnMessage;
-          state$T.ipc.send = originalSend;
+          state$S.ipc.onmessage = originalOnMessage;
+          state$S.ipc.send = originalSend;
           await execute$5('ElectronWindow.minimize');
-          state$T.ipc.onmessage = wrappedOnMessage;
-          state$T.ipc.send = wrappedSend;
+          state$S.ipc.onmessage = wrappedOnMessage;
+          state$S.ipc.send = wrappedSend;
           break
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$T.ipc.onmessage = originalOnMessage;
-          state$T.ipc.send = originalSend;
+          state$S.ipc.onmessage = originalOnMessage;
+          state$S.ipc.send = originalSend;
           await execute$5('ElectronWindow.maximize');
-          state$T.ipc.onmessage = wrappedOnMessage;
-          state$T.ipc.send = wrappedSend;
+          state$S.ipc.onmessage = wrappedOnMessage;
+          state$S.ipc.send = wrappedSend;
           break
       }
     } else {
       throw new Error('unexpected message from renderer worker')
     }
   };
-  state$T.ipc.send = wrappedSend;
-  state$T.ipc.onmessage = wrappedOnMessage;
+  state$S.ipc.send = wrappedSend;
+  state$S.ipc.onmessage = wrappedOnMessage;
   const callbacks = Object.create(null);
   const invoke = (event) => {
     return new Promise((resolve, reject) => {
@@ -5970,8 +5985,8 @@ const wrapIpc = (ipc, name, getData) => {
 };
 
 const startRecording$1 = () => {
-  state$T.ipc = wrapIpc(state$T.ipc, 'renderer-process', (event) => event.data);
-  state$R.ipc = wrapIpc(state$R.ipc, 'shared-process', (event) => event);
+  state$S.ipc = wrapIpc(state$S.ipc, 'renderer-process', (event) => event.data);
+  undefined.ipc = wrapIpc(undefined.ipc, 'shared-process', (event) => event);
 };
 
 const openSession = async () => {
@@ -6048,8 +6063,8 @@ const startup = async () => {
   mark$1(Four);
 
   mark(WillShowLayout);
-  const layout = create$Y(load$6, Layout, 0, '', 0, 0, 0, 0);
-  layout.uid = create$12();
+  const layout = create$Z(load$6, Layout, 0, '', 0, 0, 0, 0);
+  layout.uid = create$13();
   const layoutState = await getSavedViewletState(Layout);
   const commands = await load$8(
     {
@@ -6189,7 +6204,7 @@ const getMessage$7 = (event) => {
   return event.data
 };
 
-const wrap$9 = (port) => {
+const wrap$a = (port) => {
   return {
     port,
     /**
@@ -6219,7 +6234,7 @@ const wrap$9 = (port) => {
 const IpcChildWithMessagePort = {
   __proto__: null,
   listen: listen$6,
-  wrap: wrap$9
+  wrap: wrap$a
 };
 
 const listen$5 = () => {
@@ -6237,7 +6252,7 @@ const getMessage$6 = (event) => {
   return event.data
 };
 
-const wrap$8 = (global) => {
+const wrap$9 = (global) => {
   return {
     global,
     /**
@@ -6268,7 +6283,7 @@ const IpcChildWithModuleWorker = {
   __proto__: null,
   listen: listen$5,
   signal,
-  wrap: wrap$8
+  wrap: wrap$9
 };
 
 const listen$4 = () => {
@@ -6281,7 +6296,7 @@ const listen$4 = () => {
   return referencePort
 };
 
-const wrap$7 = (referencePort) => {
+const wrap$8 = (referencePort) => {
   return {
     referencePort,
     send(message) {
@@ -6303,22 +6318,24 @@ const wrap$7 = (referencePort) => {
 const IpcChildWithReferencePort = {
   __proto__: null,
   listen: listen$4,
-  wrap: wrap$7
+  wrap: wrap$8
 };
 
 const ModuleWorkerWithMessagePort = 4;
 const Electron = 5;
 
 const getPort = async (type, name) => {
-  const port = await invoke$2('IpcParent.create', {
+  const { port1, port2 } = new MessageChannel();
+  await invokeAndTransfer('IpcParent.create', [port1], {
     method: Electron,
     type,
     name,
+    port: port1,
   });
-  return port
+  return port2
 };
 
-const create$X = async (options) => {
+const create$Y = async (options) => {
   const type = options.type;
   const name = options.name || 'electron ipc';
   string(type);
@@ -6327,11 +6344,11 @@ const create$X = async (options) => {
   return port
 };
 
-const getActualData = (event) => {
+const getActualData$1 = (event) => {
   return event.data
 };
 
-const wrap$6 = (port) => {
+const wrap$7 = (port) => {
   return {
     port,
     /**
@@ -6344,7 +6361,7 @@ const wrap$6 = (port) => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = (event) => {
-        const data = getActualData(event);
+        const data = getActualData$1(event);
         listener(data);
       };
       this.port.onmessage = wrappedListener;
@@ -6352,13 +6369,16 @@ const wrap$6 = (port) => {
     send(message) {
       this.port.postMessage(message);
     },
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
+    },
   }
 };
 
-const IpcParentWithElectron = {
+const IpcParentWithElectronMessagePort = {
   __proto__: null,
-  create: create$X,
-  wrap: wrap$6
+  create: create$Y,
+  wrap: wrap$7
 };
 
 class IpcError extends Error {
@@ -6372,7 +6392,7 @@ const isMessagePort = (value) => {
   return value instanceof MessagePort
 };
 
-const create$W = async ({ url }) => {
+const create$X = async ({ url }) => {
   string(url);
   const portPromise = new Promise((resolve) => {
     globalThis.acceptPort = resolve;
@@ -6393,7 +6413,7 @@ const getMessage$5 = (event) => {
   return event.data
 };
 
-const wrap$5 = (port) => {
+const wrap$6 = (port) => {
   return {
     /**
      * @type {any}
@@ -6421,8 +6441,8 @@ const wrap$5 = (port) => {
 
 const IpcParentWithMessagePort = {
   __proto__: null,
-  create: create$W,
-  wrap: wrap$5
+  create: create$X,
+  wrap: wrap$6
 };
 
 const Message = 'message';
@@ -6483,7 +6503,7 @@ const tryToGetActualErrorMessage$1 = async ({ url, name }) => {
 
 const Module$2 = 'module';
 
-const create$V = async ({ url, name }) => {
+const create$W = async ({ url, name }) => {
   const worker = new Worker(url, {
     type: Module$2,
     name,
@@ -6507,7 +6527,7 @@ const create$V = async ({ url, name }) => {
 
 const getMessage$4 = (event) => {};
 
-const wrap$4 = (worker) => {
+const wrap$5 = (worker) => {
   return {
     worker,
     /**
@@ -6536,11 +6556,11 @@ const wrap$4 = (worker) => {
 
 const IpcParentWithModuleWorker = {
   __proto__: null,
-  create: create$V,
-  wrap: wrap$4
+  create: create$W,
+  wrap: wrap$5
 };
 
-const create$U = async ({ url }) => {
+const create$V = async ({ url }) => {
   const referencePort = await new Promise((resolve) => {
     globalThis.acceptReferencePort = resolve;
     import(url);
@@ -6553,7 +6573,7 @@ const getMessage$3 = (message) => {
   return message
 };
 
-const wrap$3 = (referencePort) => {
+const wrap$4 = (referencePort) => {
   return {
     referencePort,
     /**
@@ -6579,8 +6599,8 @@ const wrap$3 = (referencePort) => {
 
 const IpcParentWithReferencePort = {
   __proto__: null,
-  create: create$U,
-  wrap: wrap$3
+  create: create$V,
+  wrap: wrap$4
 };
 
 const Open = 1;
@@ -6629,7 +6649,7 @@ const waitForWebSocketToBeOpen = (webSocket) => {
   })
 };
 
-const create$T = async ({ protocol }) => {
+const create$U = async ({ protocol }) => {
   string(protocol);
   // TODO replace this during build
   const wsUrl = getWsUrl();
@@ -6645,7 +6665,7 @@ const getMessage$2 = (event) => {
   return parse$1(event.data)
 };
 
-const wrap$2 = (webSocket) => {
+const wrap$3 = (webSocket) => {
   return {
     webSocket,
     /**
@@ -6672,27 +6692,23 @@ const wrap$2 = (webSocket) => {
 
 const IpcParentWithWebSocket = {
   __proto__: null,
-  create: create$T,
-  wrap: wrap$2
+  create: create$U,
+  wrap: wrap$3
 };
 
-const create$S = async ({ url, name }) => {
-  const port = await invoke$2('IpcParent.create', {
+const create$T = async ({ url, name }) => {
+  const { port1, port2 } = new MessageChannel();
+  await invokeAndTransfer('IpcParent.create', [port1], {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
     raw: true,
+    port: port1,
   });
-  if (!port) {
-    throw new IpcError('port must be defined')
-  }
-  if (!isMessagePort(port)) {
-    throw new IpcError('port must be of type MessagePort')
-  }
-  return port
+  return port2
 };
 
-const wrap$1 = (port) => {
+const wrap$2 = (port) => {
   const fakeEvent = {
     target: {
       send(message, transfer) {
@@ -6735,8 +6751,8 @@ const wrap$1 = (port) => {
 
 const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   __proto__: null,
-  create: create$S,
-  wrap: wrap$1
+  create: create$T,
+  wrap: wrap$2
 };
 
 const getModule$7 = () => {
@@ -6745,13 +6761,13 @@ const getModule$7 = () => {
     case Remote:
       return Promise.resolve().then(function () { return IpcParentWithWebSocket; })
     case Electron$1:
-      return Promise.resolve().then(function () { return IpcParentWithElectron; })
+      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; })
     default:
       throw new Error('unsupported platform')
   }
 };
 
-const create$R = async (options) => {
+const create$S = async (options) => {
   const module = await getModule$7();
   const rawIpc = await module.create(options);
   if (options.raw) {
@@ -6763,11 +6779,71 @@ const create$R = async (options) => {
   }
 };
 
-const wrap = ({ rawIpc, module }) => {
+const wrap$1 = ({ rawIpc, module }) => {
   return module.wrap(rawIpc)
 };
 
 const IpcParentWithNode = {
+  __proto__: null,
+  create: create$S,
+  wrap: wrap$1
+};
+
+const create$R = async (options) => {
+  switch (platform) {
+    case Web$1:
+    case Remote:
+      const module = await Promise.resolve().then(function () { return IpcParentWithWebSocket; });
+      const rawIpc = await module.create(options);
+      if (options.raw) {
+        return rawIpc
+      }
+      return {
+        rawIpc,
+        module,
+      }
+    case Electron$1:
+      const ipc = state$Q.ipc;
+      const { port1, port2 } = new MessageChannel();
+      await invokeAndTransfer$1(ipc, [port2], 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess');
+      return port1
+    default:
+      throw new Error('unsupported platform')
+  }
+};
+
+const getActualData = (event) => {
+  return event.data
+};
+
+const wrap = (port) => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener
+    },
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = (event) => {
+        const data = getActualData(event);
+        listener(data);
+      };
+      this.port.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
+    },
+  }
+};
+
+const IpcParentWithNodeAlternate = {
   __proto__: null,
   create: create$R,
   wrap
@@ -6804,7 +6880,7 @@ const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition
 const GetStatusBarItems = 'ExtensionHost.getStatusBarItems';
 const RegisterStatusBarChangeListener = 'ExtensionHostStatusBar.registerChangeListener';
 
-const state$y = {
+const state$x = {
   /**
    * @type {any[]}
    */
@@ -6814,31 +6890,31 @@ const state$y = {
 };
 
 const addTest = (name, fn) => {
-  state$y.pendingTests.push({ name, fn });
+  state$x.pendingTests.push({ name, fn });
 };
 
 const getTests = () => {
-  const tests = state$y.pendingTests;
-  state$y.pendingTests = [];
+  const tests = state$x.pendingTests;
+  state$x.pendingTests = [];
   return tests
 };
 
 const setMockExec = (fn) => {
-  state$y.mockExec = fn;
+  state$x.mockExec = fn;
 };
 
 const getMockExec = () => {
-  return state$y.mockExec
+  return state$x.mockExec
 };
 
 const setMockRpc = (mockRpc) => {
   object(mockRpc);
   string(mockRpc.name);
-  state$y.mockRpcs[mockRpc.name] = mockRpc;
+  state$x.mockRpcs[mockRpc.name] = mockRpc;
 };
 
 const getMockRpc = (name) => {
-  return state$y.mockRpcs[name]
+  return state$x.mockRpcs[name]
 };
 
 // based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
@@ -7111,7 +7187,7 @@ const getName$2 = () => {
 };
 
 const listen$3 = (method) => {
-  return create$Z({
+  return create$_({
     method,
     type: 'extension-host',
     name: getName$2(),
@@ -7262,7 +7338,7 @@ const ExtensionHostState = {
   Error: 3,
 };
 
-const state$x = {
+const state$w = {
   extensionPromiseCache: Object.create(null),
   extensionHosts: Object.create(null),
   pendingIpcs: Object.create(null),
@@ -7273,7 +7349,7 @@ const state$x = {
 // }
 
 const startExtensionHost = async (name, ipcType) => {
-  const exisingIpcPromise = state$x.pendingIpcs[name];
+  const exisingIpcPromise = state$w.pendingIpcs[name];
   if (exisingIpcPromise) {
     const ipc = await exisingIpcPromise;
     return {
@@ -7281,22 +7357,22 @@ const startExtensionHost = async (name, ipcType) => {
       ipc,
     }
   }
-  if (state$x.extensionHosts[name]) {
-    return state$x.extensionHosts[name]
+  if (state$w.extensionHosts[name]) {
+    return state$w.extensionHosts[name]
   }
   const promise = listen$3(ipcType).then(listen$2);
-  state$x.pendingIpcs[name] = promise;
+  state$w.pendingIpcs[name] = promise;
   const ipc = await promise;
-  delete state$x.pendingIpcs[name];
-  state$x.extensionHosts[name] = {
+  delete state$w.pendingIpcs[name];
+  state$w.extensionHosts[name] = {
     state: ExtensionHostState.Running,
     ipc,
     name: ipcType,
   };
-  return state$x.extensionHosts[name]
+  return state$w.extensionHosts[name]
 };
 
-const state$w = {
+const state$v = {
   /**
    * @type {any[]}
    */
@@ -7358,10 +7434,10 @@ const startSynching = async (extensionHost) => {
 
   const handleWorkspaceChange = async (workspacePath) => {
     await extensionHost.ipc.invoke('Workspace.setWorkspacePath', workspacePath);
-    if (state$y.mockExec) {
+    if (state$x.mockExec) {
       await extensionHost.ipc.invoke('ExtensionHostMockExec.mockExec');
     }
-    const names = Object.values(state$y.mockRpcs).map((value) => value.name);
+    const names = Object.values(state$x.mockRpcs).map((value) => value.name);
     if (names.length > 0) {
       await extensionHost.ipc.invoke('ExtensionHostMockRpc.mockRpc', names);
     }
@@ -7378,14 +7454,14 @@ const startSynching = async (extensionHost) => {
     await handleEditorCreate(editorInstance.state);
   }
   // @ts-ignore
-  await handleWorkspaceChange(state$E.workspacePath);
+  await handleWorkspaceChange(state$D.workspacePath);
 };
 
 const actuallyActivateExtension = async (extensionHost, extension) => {
-  if (!(extension.id in state$w.activatedExtensions)) {
-    state$w.activatedExtensions[extension.id] = extensionHost.ipc.invoke(ExtensionActivate, extension);
+  if (!(extension.id in state$v.activatedExtensions)) {
+    state$v.activatedExtensions[extension.id] = extensionHost.ipc.invoke(ExtensionActivate, extension);
   }
-  return state$w.activatedExtensions[extension.id]
+  return state$v.activatedExtensions[extension.id]
 };
 
 const actuallyActivateByEvent = async (event) => {
@@ -7417,7 +7493,7 @@ const actuallyActivateByEvent = async (event) => {
     extensionHosts.push(extensionHost);
   }
 
-  state$w.extensionHosts = extensionHosts;
+  state$v.extensionHosts = extensionHosts;
 
   // TODO support querying completion items from multiple extension hosts
   // e.g. completion items from node extension host and word based completions from web worker extension host
@@ -7428,17 +7504,17 @@ const actuallyActivateByEvent = async (event) => {
 const activateByEvent = async (event) => {
   string(event);
   if (event === 'none') {
-    const all = await Promise.all(Object.values(state$w.cachedActivationEvents));
+    const all = await Promise.all(Object.values(state$v.cachedActivationEvents));
     return all.flat(1)
   }
-  if (!(event in state$w.cachedActivationEvents)) {
-    state$w.cachedActivationEvents[event] = actuallyActivateByEvent(event);
+  if (!(event in state$v.cachedActivationEvents)) {
+    state$v.cachedActivationEvents[event] = actuallyActivateByEvent(event);
   }
-  return state$w.cachedActivationEvents[event]
+  return state$v.cachedActivationEvents[event]
 };
 
 const getExtensionHosts = () => {
-  return state$w.extensionHosts
+  return state$v.extensionHosts
 };
 
 const executeProviders = async ({
@@ -7725,12 +7801,12 @@ const FileSystemData = {
 
 const name$1S = 'Memory';
 
-const state$v = {
+const state$u = {
   files: Object.create(null),
 };
 
 const getDirent$2 = (uri) => {
-  return state$v.files[uri]
+  return state$u.files[uri]
 };
 
 const readFile$a = (uri) => {
@@ -7749,7 +7825,7 @@ const ensureParentDir = (uri) => {
   let endIndex = uri.indexOf(Slash$2);
   while (endIndex >= 0) {
     const part = uri.slice(startIndex, endIndex + 1);
-    state$v.files[part] = {
+    state$u.files[part] = {
       type: Directory$1,
       content: '',
     };
@@ -7763,7 +7839,7 @@ const writeFile$b = (uri, content) => {
     dirent.content = content;
   } else {
     ensureParentDir(uri);
-    state$v.files[uri] = {
+    state$u.files[uri] = {
       type: File$5,
       content,
     };
@@ -7775,7 +7851,7 @@ const mkdir$4 = (uri) => {
     uri += Slash$2;
   }
   ensureParentDir(uri);
-  state$v.files[uri] = {
+  state$u.files[uri] = {
     type: Directory$1,
     content: '',
   };
@@ -7787,13 +7863,13 @@ const getPathSeparator$5 = () => {
 
 const remove$3 = (uri) => {
   const toDelete = [];
-  for (const key of Object.keys(state$v.files)) {
+  for (const key of Object.keys(state$u.files)) {
     if (key.startsWith(uri)) {
       toDelete.push(key);
     }
   }
   for (const key of toDelete) {
-    delete state$v.files[key];
+    delete state$u.files[key];
   }
 };
 
@@ -7802,7 +7878,7 @@ const readDirWithFileTypes$4 = (uri) => {
     uri += Slash$2;
   }
   const dirents = [];
-  for (const [key, value] of Object.entries(state$v.files)) {
+  for (const [key, value] of Object.entries(state$u.files)) {
     if (key.startsWith(uri)) {
       switch (value.type) {
         case Directory$1:
@@ -7840,7 +7916,7 @@ const FileSystemMemory = {
   readDirWithFileTypes: readDirWithFileTypes$4,
   readFile: readFile$a,
   remove: remove$3,
-  state: state$v,
+  state: state$u,
   writeFile: writeFile$b
 };
 
@@ -7849,21 +7925,21 @@ const FileSystemMemory = {
 
 const name$1R = 'Web';
 
-const state$u = {
+const state$t = {
   watchers: Object.create(null),
   saveListeners: [],
   files: Object.create(null),
 };
 
-state$u.files['/languages/index.dart'] = `void main() {
+state$t.files['/languages/index.dart'] = `void main() {
   print('Hello, World!');
 }`;
 
-state$u.files['/languages/index.js'] = `const add = (a, b) => {
+state$t.files['/languages/index.js'] = `const add = (a, b) => {
   return a + b;
 }`;
 
-state$u.files['/languages/scrolling.txt'] = `line 1
+state$t.files['/languages/scrolling.txt'] = `line 1
 line 2
 line 3
 line 4
@@ -7965,9 +8041,9 @@ line 99
 line 100
 `;
 
-state$u.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
+state$t.files['/languages/index.html'] = '<h1 class="abc">hello world</h1>';
 
-state$u.files['/languages/index.css'] = `h1 {
+state$t.files['/languages/index.css'] = `h1 {
   font-size: 24px;
 }
 
@@ -7988,7 +8064,7 @@ state$u.files['/languages/index.css'] = `h1 {
 }
 `;
 
-state$u.files['/languages/index.ex'] = `defmodule RealWorld do
+state$t.files['/languages/index.ex'] = `defmodule RealWorld do
   @moduledoc """
   RealWorld keeps the contexts that define your domain
   and business logic.
@@ -7997,7 +8073,7 @@ state$u.files['/languages/index.ex'] = `defmodule RealWorld do
   """
 end`;
 
-state$u.files['/languages/index.jl'] = `function mandelbrot(a)
+state$t.files['/languages/index.jl'] = `function mandelbrot(a)
 z = 0
 for i=1:50
 z = z^2 + a
@@ -8012,7 +8088,7 @@ end
 println()
 end`;
 
-state$u.files['/languages/index.pl'] = `#!/usr/bin/perl
+state$t.files['/languages/index.pl'] = `#!/usr/bin/perl
 #
 # The traditional first program.
 
@@ -8023,17 +8099,17 @@ use warnings;
 # Print a message.
 print "Hello, World!\n";`;
 
-state$u.files['/languages/index.kt'] = `fun main(args : Array<String>) {
+state$t.files['/languages/index.kt'] = `fun main(args : Array<String>) {
   println("Hello, World!")
 }`;
 
-state$u.files['/languages/index.java'] = `class HelloWorld {
+state$t.files['/languages/index.java'] = `class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello, World!");
   }
 }`;
 
-state$u.files['/languages/index.cpp'] = `using namespace std;
+state$t.files['/languages/index.cpp'] = `using namespace std;
 
 template <class ANYTYPE>
 void thing(int a, Blah other_thing, double c=10, ANYTYPE f) {
@@ -8053,18 +8129,18 @@ int main(char arg_num, char** vargs) {
     #error I should be able to write single quotes in here: Don't make errors
 }`;
 
-state$u.files['/languages/index.env'] = 'KEY=42';
+state$t.files['/languages/index.env'] = 'KEY=42';
 
-state$u.files['/sample-folder/a.txt'] = '';
-state$u.files['/sample-folder/b.txt'] = '';
-state$u.files['/sample-folder/c.txt'] = '';
+state$t.files['/sample-folder/a.txt'] = '';
+state$t.files['/sample-folder/b.txt'] = '';
+state$t.files['/sample-folder/c.txt'] = '';
 
 // const getRelativePath = (path) => {
 //   return path.slice('/workspace'.length)
 // }
 
 const readFile$9 = async (path) => {
-  const file = state$u.files[path];
+  const file = state$t.files[path];
   if (file === undefined) {
     throw new Error(`file not found ${path}`)
   }
@@ -8092,7 +8168,7 @@ const createFolder = async (path) => {
 };
 
 const writeFile$a = async (path, content) => {
-  state$u.files[path] = content;
+  state$t.files[path] = content;
 };
 
 const getDirent$1 = (path, relativePath) => {
@@ -8111,7 +8187,7 @@ const getDirent$1 = (path, relativePath) => {
 
 const readDirWithFileTypes$3 = (path) => {
   const dirents = [];
-  for (const key in state$u.files) {
+  for (const key in state$t.files) {
     if (key.startsWith(path)) {
       const dirent = getDirent$1(key, path);
       if (!dirents.some((otherDirent) => otherDirent.name === dirent.name)) {
@@ -8159,7 +8235,7 @@ const FileSystemWeb = {
   readFile: readFile$9,
   remove: remove$2,
   rename: rename$4,
-  state: state$u,
+  state: state$t,
   unwatch,
   unwatchAll,
   watch,
@@ -8170,7 +8246,7 @@ const canBeRestored$3 = true;
 
 const name$1Q = 'Fetch';
 
-const state$t = {
+const state$s = {
   files: Object.create(null),
 };
 
@@ -8237,7 +8313,7 @@ const FileSystemFetch = {
   readDirWithFileTypes: readDirWithFileTypes$2,
   readFile: readFile$8,
   remove: remove$1,
-  state: state$t,
+  state: state$s,
   writeFile: writeFile$9
 };
 
@@ -8477,14 +8553,14 @@ const getBaseName = (pathSeparator, path) => {
   return path.slice(path.lastIndexOf(pathSeparator) + 1)
 };
 
-const state$s = {
+const state$r = {
   handles: Object.create(null),
 };
 
 const addHandle = async (uri, handle) => {
   try {
     // TODO save handle in indexeddb
-    state$s.handles[uri] = handle;
+    state$r.handles[uri] = handle;
     await execute$5('IndexedDb.addHandle', uri, handle);
   } catch (error) {
     throw new VError(error, 'Failed to add handle')
@@ -8495,10 +8571,10 @@ const addHandles = async (parentUri, childHandles) => {
   const promises = [];
   for (const childHandle of childHandles) {
     const childUri = parentUri + '/' + childHandle.name;
-    if (childUri in state$s.handles) {
+    if (childUri in state$r.handles) {
       continue
     }
-    state$s.handles[childUri] = childHandle;
+    state$r.handles[childUri] = childHandle;
     promises.push(addHandle(childUri, childHandle));
   }
   await Promise.all(promises);
@@ -9702,7 +9778,6 @@ const hasFunctionalRender$z = true;
 
 const renderText$1 = {
   isEqual(oldState, newState) {
-    console.log('ren');
     return oldState.text === newState.text
   },
   apply(oldState, newState) {
@@ -10413,7 +10488,7 @@ const clamp = (num, min, max) => {
   return Math.min(Math.max(num, min), max)
 };
 
-const state$r = {
+const state$q = {
   /**
    * @type {OffscreenCanvasRenderingContext2D|undefined|null}
    */
@@ -10425,11 +10500,11 @@ const state$r = {
  * @returns {OffscreenCanvasRenderingContext2D}
  */
 const getOrCreate = (createCtx) => {
-  if (state$r.ctx) {
-    return state$r.ctx
+  if (state$q.ctx) {
+    return state$q.ctx
   }
-  state$r.ctx = createCtx();
-  return state$r.ctx
+  state$q.ctx = createCtx();
+  return state$q.ctx
 };
 
 const createCtx = () => {
@@ -10692,7 +10767,7 @@ const y = (editor, rowIndex) => {
   return offsetY
 };
 
-const state$q = {
+const state$p = {
   timeout: -1,
 };
 
@@ -10729,7 +10804,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
 
     // TODO use wrapper timing module instead of this
     // @ts-ignore
-    state$q.timeout = setTimeout(handleTimeout, 3_000);
+    state$p.timeout = setTimeout(handleTimeout, 3_000);
   }
   return editor
 };
@@ -10747,8 +10822,8 @@ const showErrorMessage = (editor, rowIndex, columnIndex, message) => {
 };
 
 const editorHideMessage = async (editor) => {
-  clearTimeout(state$q.timeout);
-  state$q.timeout = -1;
+  clearTimeout(state$p.timeout);
+  state$p.timeout = -1;
   await invoke$2(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage');
   return editor
 };
@@ -11595,7 +11670,7 @@ const getInitialLineState = (initialLineState) => {
   return deepCopy(initialLineState)
 };
 
-const state$p = {
+const state$o = {
   /**
    * @type {any}
    */
@@ -11612,10 +11687,10 @@ const flattenTokensArray = (tokens) => {
 };
 
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$p.warned.includes(fn)) {
+  if (state$o.warned.includes(fn)) {
     return
   }
-  state$p.warned.push(fn);
+  state$o.warned.push(fn);
   warn$1(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 /**
@@ -11688,7 +11763,7 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-const state$o = {
+const state$n = {
   tokenizers: Object.create(null),
   tokenizePaths: Object.create(null),
   listeners: [],
@@ -11700,35 +11775,35 @@ const state$o = {
 };
 
 const has = (languageId) => {
-  return languageId in state$o.tokenizers
+  return languageId in state$n.tokenizers
 };
 
 const set$1 = (languageId, tokenizer) => {
-  state$o.tokenizers[languageId] = tokenizer;
+  state$n.tokenizers[languageId] = tokenizer;
 };
 
 const get$4 = (languageId) => {
-  return state$o.tokenizers[languageId]
+  return state$n.tokenizers[languageId]
 };
 
 const isPending = (languageId) => {
-  return languageId in state$o.pending
+  return languageId in state$n.pending
 };
 
 const addConnectedEditor$1 = (id) => {
-  state$o.connectedEditors.push(id);
+  state$n.connectedEditors.push(id);
 };
 
 const removeConnectedEditor$1 = (id) => {
-  const index = state$o.connectedEditors.indexOf(id);
+  const index = state$n.connectedEditors.indexOf(id);
   if (index === -1) {
     return
   }
-  state$o.connectedEditors.splice(index, 1);
+  state$n.connectedEditors.splice(index, 1);
 };
 
 const isConnectedEditor = (id) => {
-  return state$o.connectedEditors.includes(id)
+  return state$n.connectedEditors.includes(id)
 };
 
 const getTokenizePath = (languageId) => {
@@ -13990,29 +14065,29 @@ const load$4 = async (language) => {
   await activateByEvent(`onLanguage:${language}`);
 };
 
-const state$n = {
+const state$m = {
   pending: Object.create(null),
   loaded: Object.create(null),
 };
 
 const setPending = (id, promise) => {
-  state$n.pending[id] = promise;
+  state$m.pending[id] = promise;
 };
 
 const getPending = (id) => {
-  return state$n.pending[id]
+  return state$m.pending[id]
 };
 
 const hasPending = (id) => {
-  return id in state$n.pending
+  return id in state$m.pending
 };
 
 const removePending = (id) => {
-  delete state$n.pending[id];
+  delete state$m.pending[id];
 };
 
 const isLoaded = (id) => {
-  return state$n.loaded[id]
+  return state$m.loaded[id]
 };
 
 const getFonts = () => {
@@ -15275,7 +15350,7 @@ const getSavedRoot = (savedState, workspacePath) => {
 };
 
 const loadContent$u = async (state, savedState) => {
-  const root = getSavedRoot(savedState, state$E.workspacePath);
+  const root = getSavedRoot(savedState, state$D.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -15319,7 +15394,7 @@ const handleLanguagesChanged = (state) => {
 };
 
 const handleWorkspaceChange = async (state) => {
-  const newRoot = state$E.workspacePath;
+  const newRoot = state$D.workspacePath;
   const state1 = { ...state, root: newRoot };
   const newState = await loadContent$u(state1);
   return newState
@@ -20011,7 +20086,7 @@ const show$8 = async (state, module, currentViewletId) => {
   const width = newPoints[kWidth];
   const height = newPoints[kHeight];
   const uid = state.uid;
-  const childUid = create$12();
+  const childUid = create$13();
   const commands = await load$8(
     {
       getModule: load$6,
@@ -20186,7 +20261,7 @@ const loadIfVisible = async (state, module) => {
     let commands = [];
     const parentUid = state.uid;
     if (visible) {
-      const childUid = create$12();
+      const childUid = create$13();
       commands = await load$8(
         {
           getModule: load$6,
@@ -20364,7 +20439,7 @@ const showAsync = async (uid, points, module) => {
   try {
     number(uid);
     const { moduleId, kTop, kLeft, kWidth, kHeight } = module;
-    const viewletUid = create$12();
+    const viewletUid = create$13();
     const commands = await load$8(
       {
         getModule: load$6,
@@ -20969,12 +21044,12 @@ const ViewletLayout_ipc = {
   toggleTitleBar
 };
 
-const state$m = {
+const state$l = {
   backgroundTabs: Object.create(null),
 };
 
 const add = (uri, props) => {
-  state$m.backgroundTabs[uri] = props;
+  state$l.backgroundTabs[uri] = props;
 };
 
 const None$5 = 0;
@@ -21355,8 +21430,8 @@ const focusIndex$a = async (state, index) => {
   const oldId = getModuleId(oldEditor.uri);
   getInstance(oldId);
 
-  const instanceUid = create$12();
-  const instance = create$Y(load$6, id, uid, editor.uri, x, y, width, contentHeight);
+  const instanceUid = create$13();
+  const instance = create$Z(load$6, id, uid, editor.uri, x, y, width, contentHeight);
   instance.show = false;
   instance.setBounds = false;
   instance.uid = instanceUid;
@@ -21478,11 +21553,11 @@ const openUri$1 = async (state, uri, focus = true, { preview = false, ...context
   let activeGroup = groups[activeGroupIndex];
   if (!activeGroup) {
     activeGroup = {
-      uid: create$12(),
+      uid: create$13(),
       editors: [],
       activeIndex: -1,
       focusedIndex: -1,
-      tabsUid: create$12(),
+      tabsUid: create$13(),
       x,
       y: 0,
       width,
@@ -21511,8 +21586,8 @@ const openUri$1 = async (state, uri, focus = true, { preview = false, ...context
     const previousUid = previousEditor.uid;
     disposeCommands = disposeFunctional(previousUid);
   }
-  const instanceUid = create$12();
-  const instance = create$Y(load$6, moduleId, state.uid, uri, x, y, width, contentHeight);
+  const instanceUid = create$13();
+  const instance = create$Z(load$6, moduleId, state.uid, uri, x, y, width, contentHeight);
   instance.uid = instanceUid;
   // const oldActiveIndex = state.activeIndex
   const tabLabel = getLabel$5(uri);
@@ -21549,7 +21624,7 @@ const openUri$1 = async (state, uri, focus = true, { preview = false, ...context
   commands.push(['Viewlet.setBounds', instanceUid, x, state.tabHeight, width, contentHeight]);
   let tabsUid = state.tabsUid;
   if (tabsUid === -1) {
-    tabsUid = create$12();
+    tabsUid = create$13();
   }
   if (disposeCommands) {
     commands.push(...disposeCommands);
@@ -21632,13 +21707,13 @@ const getMainGroups = (savedState, state) => {
     }
     const restoredEditors = group.editors.filter(canBeRestored);
     for (const editor of restoredEditors) {
-      editor.uid = create$12();
+      editor.uid = create$13();
       const label = editor.label;
       editor.tabWidth = measureTabWidth(label, tabFontWeight, tabFontSize, tabFontFamily, tabLetterSpacing);
     }
     const restoredGroup = {
       ...group,
-      tabsUid: create$12(),
+      tabsUid: create$13(),
     };
     restoredGroups.push(restoredGroup);
   }
@@ -21700,7 +21775,7 @@ const getRestoredGroups = (savedState, state) => {
           height,
           editors: [],
           tabsUid: 0,
-          uid: create$12(),
+          uid: create$13(),
         },
       ],
       activeGroupIndex: 0,
@@ -21717,7 +21792,7 @@ const getRestoredGroups = (savedState, state) => {
           height,
           editors: [],
           tabsUid: 0,
-          uid: create$12(),
+          uid: create$13(),
         },
       ],
       activeGroupIndex: 0,
@@ -21734,7 +21809,7 @@ const getRestoredGroups = (savedState, state) => {
           height,
           editors: [],
           tabsUid: 0,
-          uid: create$12(),
+          uid: create$13(),
         },
       ],
       activeGroupIndex: 0,
@@ -21748,7 +21823,7 @@ const getRestoredGroups = (savedState, state) => {
     y: 0,
     width,
     height,
-    uid: create$12(),
+    uid: create$13(),
   };
   return {
     groups: [newGroup],
@@ -21896,7 +21971,7 @@ const contentLoaded$4 = async (state) => {
     editor.title = tabTitle;
     const childUid = editor.uid;
     commands.push(['Viewlet.setBounds', childUid, x, state.tabHeight, width, contentHeight]);
-    const tabsUid = create$12();
+    const tabsUid = create$13();
     state.tabsUid = tabsUid;
     // commands.push(['Viewlet.create', ViewletModuleId.MainTabs, tabsUid])
     // commands.push(['Viewlet.send', tabsUid, 'setTabs', state.editors])
@@ -22536,7 +22611,7 @@ const close$4 = async (id) => {
 
 const STATUS_OFF = 0;
 
-const state$l = {
+const state$k = {
   status: STATUS_OFF, // TODO should be an enum state
   /**
    * @type {any[]}
@@ -22569,9 +22644,9 @@ const getWebExtensionManifest = async (path) => {
 };
 
 const loadWebExtension = async (path) => {
-  object(state$l.extensionHostWorker);
+  object(state$k.extensionHostWorker);
   const manifest = await getWebExtensionManifest(path);
-  state$l.webExtensions.push(manifest);
+  state$k.webExtensions.push(manifest);
   // TODO use invoke
   // await new Promise((resolve) => {
   //   setTimeout(resolve, 120)
@@ -23447,7 +23522,7 @@ const None$4 = '';
 
 // TODO avoid global variable
 
-const state$k = {
+const state$j = {
   // providerId: PROVIDER_NOOP,
   provider: QuickPickNoop,
   prefix: 'string-that-should-never-match-another-string',
@@ -23459,7 +23534,7 @@ const state$k = {
 const name$1r = 'everything';
 
 const getPlaceholder$9 = () => {
-  return state$k.provider.getPlaceholder()
+  return state$j.provider.getPlaceholder()
 };
 
 const getLabel$4 = () => {
@@ -23467,11 +23542,11 @@ const getLabel$4 = () => {
 };
 
 const getHelpEntries$7 = () => {
-  return state$k.provider.getHelpEntries()
+  return state$j.provider.getHelpEntries()
 };
 
 const getNoResults$8 = () => {
-  return state$k.provider.getNoResults()
+  return state$j.provider.getNoResults()
 };
 
 const getPrefix = (value) => {
@@ -23516,19 +23591,19 @@ const getQuickPickProvider = (prefix) => {
 const getPicks$9 = async (value) => {
   const prefix = getPrefix(value);
   // TODO race condition
-  if (state$k.prefix !== prefix) {
-    state$k.prefix = prefix;
+  if (state$j.prefix !== prefix) {
+    state$j.prefix = prefix;
     // @ts-ignore
-    state$k.provider = await getQuickPickProvider(prefix);
+    state$j.provider = await getQuickPickProvider(prefix);
   }
   // TODO this line is a bit duplicated with getFilterValue
   const slicedValue = value.slice(prefix.length);
-  const picks = await state$k.provider.getPicks(slicedValue);
+  const picks = await state$j.provider.getPicks(slicedValue);
   return picks
 };
 
 const selectPick$9 = (item) => {
-  const { provider } = state$k;
+  const { provider } = state$j;
   return provider.selectPick(item)
 };
 
@@ -23541,16 +23616,16 @@ const openView = () => {
 };
 
 const getFilterValue$8 = (value) => {
-  return value.slice(state$k.prefix.length)
+  return value.slice(state$j.prefix.length)
 };
 
 const getPickFilterValue$4 = (pick) => {
-  const { provider } = state$k;
+  const { provider } = state$j;
   return provider.getPickFilterValue(pick)
 };
 
 const getPickDescription$2 = (pick) => {
-  const { provider } = state$k;
+  const { provider } = state$j;
   if (provider.getPickDescription) {
     // @ts-ignore
     return provider.getPickDescription(pick)
@@ -23559,12 +23634,12 @@ const getPickDescription$2 = (pick) => {
 };
 
 const getPickLabel$4 = (pick) => {
-  const { provider } = state$k;
+  const { provider } = state$j;
   return provider.getPickLabel(pick)
 };
 
 const getPickIcon$4 = (pick) => {
-  const { provider } = state$k;
+  const { provider } = state$j;
   return provider.getPickIcon(pick)
 };
 
@@ -23584,7 +23659,7 @@ const QuickPickEveryThing = {
   openCommandPalette,
   openView,
   selectPick: selectPick$9,
-  state: state$k
+  state: state$j
 };
 
 const User = 1;
@@ -25267,7 +25342,7 @@ const create$h = (id, uri) => {
 };
 
 const loadContent$e = async (state) => {
-  const captureId = create$12();
+  const captureId = create$13();
   if (platform === Electron$1) {
     const sources = await getSources({
       types: ['screen'],
@@ -25527,7 +25602,7 @@ const handleUpdate = async (state, update) => {
         message: '',
       }
     }
-    const root = state$E.workspacePath;
+    const root = state$D.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -25604,7 +25679,7 @@ const create$g = (id, uri, x, y, width, height) => {
     listFocused: false,
     listFocusedIndex: -1,
     inputSource: User,
-    workspacePath: state$E.workspacePath,
+    workspacePath: state$D.workspacePath,
   }
 };
 
@@ -27190,7 +27265,7 @@ const getNewButtons = async (displayItems, providerId, buttonIndex) => {
 };
 
 const loadContent$a = async (state) => {
-  const root = state$E.workspacePath;
+  const root = state$D.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const { allGroups, gitRoot } = await getGroups(enabledProviderIds);
@@ -27382,17 +27457,17 @@ const ViewletSourceControl_ipc = {
   updateIcons
 };
 
-const state$j = Object.create(null);
+const state$i = Object.create(null);
 
 const register = (listener) => {
-  const id = create$12();
-  state$j[id] = listener;
+  const id = create$13();
+  state$i[id] = listener;
   return id
 };
 
 const execute$2 = (id, ...args) => {
   number(id);
-  const listener = state$j[id];
+  const listener = state$i[id];
   if (!listener) {
     warn$1(`listener with id ${id} not found`);
     return
@@ -27445,6 +27520,8 @@ const getStatusBarItems = async (showItems) => {
   if (!showItems) {
     return []
   }
+  await activateByEvent('onSourceControl');
+
   const extensionStatusBarItems = await getStatusBarItems$1();
   const uiStatusBarItems = toUiStatusBarItems(extensionStatusBarItems);
   return uiStatusBarItems
@@ -27458,7 +27535,6 @@ const create$c = () => {
 };
 
 const loadContent$9 = async (state) => {
-  await activateByEvent('onSourceControl');
   const statusBarItemsPreference = get$7('statusBar.itemsVisible') ?? false;
   const statusBarItems = await getStatusBarItems(statusBarItemsPreference);
   return {
@@ -27754,7 +27830,7 @@ const getTerminalSpawnOptions = () => {
 };
 
 const listen$1 = (method) => {
-  return create$Z({
+  return create$_({
     method,
     type: 'terminal-process',
     name: 'Terminal Process',
@@ -27764,7 +27840,7 @@ const listen$1 = (method) => {
 
 /* istanbul ignore file */
 
-const state$i = {
+const state$h = {
   /**
    * @type {any}
    */
@@ -27777,27 +27853,27 @@ const state$i = {
 
 const actuallyListen = async () => {
   try {
-    const ipc = await listen$1(Node);
+    const ipc = await listen$1(NodeAlternate);
     handleIpc(ipc, 'terminal process');
-    state$i.ipc = ipc;
+    state$h.ipc = ipc;
   } catch (error) {
     throw new VError(error, `Failed to create terminal connection`)
   }
 };
 
 const listen = async () => {
-  if (!state$i.ipcPromise) {
-    state$i.ipcPromise = actuallyListen();
+  if (!state$h.ipcPromise) {
+    state$h.ipcPromise = actuallyListen();
   }
-  return state$i.ipcPromise
+  return state$h.ipcPromise
 };
 
 const invoke = (method, ...params) => {
-  return invoke$3(state$i.ipc, method, ...params)
+  return invoke$3(state$h.ipc, method, ...params)
 };
 
 const send = (method, ...params) => {
-  return send$2(state$i.ipc, method, ...params)
+  return send$2(state$h.ipc, method, ...params)
 };
 
 let _separateConnection = false;
@@ -27874,7 +27950,7 @@ const loadContent$7 = async (state) => {
   const { command, args } = await getTerminalSpawnOptions();
   return {
     ...state,
-    id: create$12(),
+    id: create$13(),
     command,
     args,
   }
@@ -27882,7 +27958,7 @@ const loadContent$7 = async (state) => {
 
 const contentLoadedEffects = async (state) => {
   const { uid, separateConnection, command, args } = state;
-  await create$a(separateConnection, uid, state$E.workspacePath, command, args);
+  await create$a(separateConnection, uid, state$D.workspacePath, command, args);
 };
 
 const handleData$1 = async (state, data) => {
@@ -28041,7 +28117,7 @@ const loadContent$6 = async (state) => {
       {
         label: 'tab 1',
         icon: 'Terminal',
-        uid: create$12(),
+        uid: create$13(),
       },
     ],
     selectedIndex: 0,
@@ -28051,7 +28127,7 @@ const loadContent$6 = async (state) => {
 
 const addTerminal = async (state) => {
   const { tabs, x, y, width, height, uid, selectedIndex } = state;
-  const childUid = create$12();
+  const childUid = create$13();
   const newTab = {
     label: `tab ${tabs.length + 1}`,
     icon: 'Terminal',
@@ -28089,7 +28165,7 @@ const focusIndex$8 = async (state, index) => {
   object(state);
   number(index);
   const { tabs, x, y, width, height, uid, selectedIndex } = state;
-  const childUid = create$12();
+  const childUid = create$13();
   const newTab = tabs[index];
   newTab.uid = childUid;
   const commands = await load$8({
@@ -29146,7 +29222,7 @@ class ContentSecurityPolicyError extends Error {
   }
 }
 
-const state$h = {
+const state$g = {
   /**
    * @type {any[]}
    */
@@ -29154,11 +29230,11 @@ const state$h = {
 };
 
 const hasRecentErrors = () => {
-  return state$h.errors.length > 0
+  return state$g.errors.length > 0
 };
 
 const getRecentError = () => {
-  return state$h.errors.at(-1)
+  return state$g.errors.at(-1)
 };
 
 const getLineAndColumn = (text, start, end) => {
@@ -30315,7 +30391,7 @@ const setResponse = async (key, value, contentType) => {
   const cache = await caches.open(cacheName);
   await cache.put(
     key,
-    create$$(value, {
+    create$10(value, {
       headers: new Headers({
         'Content-Type': contentType,
         'Content-Length': `${value.length}`,
@@ -30956,16 +31032,6 @@ const formatStartupPerformanceEntries = (entries, firstTimeOrigin) => {
   return formatStartupPerformanceEntriesWithDuration(entries, firstTimeOrigin)
 };
 
-const formatWebVitals = (vitals) => {
-  const header = ['Name', 'Start Time'];
-  const rows = vitals.map((entry) => {
-    const name = entry.name;
-    const startTime = `${entry.startTime.toFixed(2)}ms`;
-    return [name, startTime]
-  });
-  return toMarkdownTable(header, rows)
-};
-
 const formatNodeTiming = (nodeStartupTiming) => {
   const header = ['Name', 'Value'];
   const rows = Object.entries(nodeStartupTiming).map(([key, value]) => {
@@ -30987,7 +31053,7 @@ const getFirstTimeOrigin = ({ measureEntries, electronEntries }) => {
   return 0
 };
 
-const formatStartupPerformance = ({ measureEntries, webVitals, nodeStartupTiming, electronEntries }) => {
+const formatStartupPerformance = ({ measureEntries, nodeStartupTiming, electronEntries }) => {
   const firstTimeOrigin = getFirstTimeOrigin({
     measureEntries,
     electronEntries,
@@ -31014,13 +31080,6 @@ const formatStartupPerformance = ({ measureEntries, webVitals, nodeStartupTiming
     lines.push(...splitLines(formattedMeasureEntries));
     lines.push('');
   }
-  if (webVitals) {
-    const formattedWebVitals = formatWebVitals(webVitals);
-    lines.push('## Web Vitals');
-    lines.push('');
-    lines.push(...splitLines(formattedWebVitals));
-    lines.push('');
-  }
   if (nodeStartupTiming) {
     const formattedNodeStartupTiming = formatNodeTiming(nodeStartupTiming);
     lines.push('## Node Startup Timing');
@@ -31035,49 +31094,6 @@ const formatStartupPerformance = ({ measureEntries, webVitals, nodeStartupTiming
 };
 
 const Measure = 'measure';
-const Paint = 'paint';
-
-const getWebVitals = async () => {
-  let firstPaint = -1;
-  let firstContentfulPaint = -1;
-  let largestContentfulPaint = -1;
-  const paintEntries = getEntriesByType(Paint);
-  for (const paintEntry of paintEntries) {
-    switch (paintEntry.name) {
-      case 'first-paint':
-        firstPaint = paintEntry.startTime;
-        break
-      case 'first-contentful-paint':
-        firstContentfulPaint = paintEntry.startTime;
-        break
-    }
-  }
-  const performanceObserver = new PerformanceObserver(() => {});
-  performanceObserver.observe({
-    type: 'largest-contentful-paint',
-    buffered: true,
-  });
-  const records = performanceObserver.takeRecords();
-  performanceObserver.disconnect();
-  if (records.length > 0) {
-    largestContentfulPaint = records[0].startTime;
-  }
-
-  return [
-    {
-      name: 'first-paint',
-      startTime: firstPaint,
-    },
-    {
-      name: 'firstContentfulPaint',
-      startTime: firstContentfulPaint,
-    },
-    {
-      name: 'largestContentfulPaint',
-      startTime: largestContentfulPaint,
-    },
-  ]
-};
 
 const BYTE_UNITS = [
   "B",
@@ -31236,7 +31252,6 @@ const getStartupPerformanceContent = async () => {
     nodeStartupTiming = await getNodeTiming();
   }
   const measureEntries = getMeasureEntries();
-  const webVitals = await getWebVitals();
   let electronEntries;
   if (platform === Electron$1) {
     electronEntries = await getElectronEntries();
@@ -31244,7 +31259,6 @@ const getStartupPerformanceContent = async () => {
   const text = formatStartupPerformance({
     nodeStartupTiming,
     measureEntries,
-    webVitals,
     electronEntries,
   });
   return text
@@ -31316,8 +31330,8 @@ const getMemoryUsageContent = async () => {
   const sharedProcessMemoryUsage = await getSharedProcessMemoryUsage();
   const formattedSharedProcessMemoryUsage = formatNodeMemoryUsage(sharedProcessMemoryUsage);
   const userAgentSpecificMemory = await getPerformanceUserAgentSpecificMemory();
-  const totalSent = state$R.totalSent;
-  const totalReceived = state$R.totalReceived;
+  const totalSent = 0;
+  const totalReceived = 0;
   const formattedRendererWorkerMemoryUsage = formatRendererWorkerData({
     userAgentSpecificMemory,
     sent: totalSent,
@@ -31474,7 +31488,7 @@ const openFolder$3 = async () => {
   await module.openFolder();
 };
 
-const state$g = {
+const state$f = {
   dialog: undefined,
 };
 
@@ -31506,7 +31520,7 @@ const openFile = () => {
 
 const handleClick$a = async (index) => {
   // @ts-ignore
-  const { options } = state$g.dialog;
+  const { options } = state$f.dialog;
   const option = options[index];
   // TODO handle case when index is out of bounds
   switch (option) {
@@ -31520,7 +31534,7 @@ const handleClick$a = async (index) => {
 };
 
 const showMessage = async (message, options) => {
-  if (state$g.dialog) {
+  if (state$f.dialog) {
     console.info('cannot show multiple dialogs at the same time', message);
     return
   }
@@ -31531,7 +31545,7 @@ const showMessage = async (message, options) => {
     options = ['Show Command Output', 'Cancel', 'Open Git Log'];
   }
   // @ts-ignore
-  state$g.dialog = {
+  state$f.dialog = {
     message,
     options,
   };
@@ -31959,7 +31973,7 @@ const toElectronMenu = (map, rootId) => {
   return { electronMenu, commandMap }
 };
 
-const state$f = {
+const state$e = {
   commandMap: Object.create(null),
 };
 
@@ -31998,7 +32012,7 @@ const hydrate = async () => {
   const entries = await getEntries(ids);
   const map = getEntryMap(ids, entries);
   const { electronMenu, commandMap } = toElectronMenu(map, TitleBar);
-  state$f.commandMap = commandMap;
+  state$e.commandMap = commandMap;
   // console.log({ electronMenu })
   await setItems(electronMenu);
   // TODO get all menu items
@@ -32007,7 +32021,7 @@ const hydrate = async () => {
 };
 
 const handleClick$9 = async (label) => {
-  const commandPair = state$f.commandMap[label];
+  const commandPair = state$e.commandMap[label];
   if (!commandPair) {
     throw new Error(`no command found for ${label}`)
   }
@@ -32055,69 +32069,10 @@ const ElectronClipBoard_ipc = {
   name: name$O
 };
 
-const Separator = 'separator';
-
-const EmptyMenu = [];
-
-const state$e = {
-  pendingMenus: EmptyMenu,
-};
-
-const convertMenuItem = (menuItem) => {
-  const { flags, label } = menuItem;
-  switch (flags) {
-    case Separator$1:
-      return {
-        type: Separator,
-      }
-    default:
-      return {
-        label,
-      }
-  }
-};
-
-const convertMenuItems = (menuItems) => {
-  return menuItems.map(convertMenuItem)
-};
-
-const openContextMenu$1 = async (x, y, id, ...args) => {
-  const entries = await getMenuEntries$p(id, ...args);
-  state$e.pendingMenus = entries;
-  const electronMenuItems = convertMenuItems(entries);
-  return invoke$1('ElectronContextMenu.openContextMenu', electronMenuItems, x, y)
-};
-
-const handleMenuClose = () => {
-  state$e.pendingMenus = EmptyMenu;
-};
-
-const getItem = (items, label) => {
-  for (const item of items) {
-    if (item.label === label) {
-      return item
-    }
-  }
-  return undefined
-};
-
-const handleSelect = async (label) => {
-  const items = state$e.pendingMenus;
-  state$e.pendingMenus = EmptyMenu;
-  const item = getItem(items, label);
-  if (!item) {
-    return
-  }
-  const args = item.args || [];
-  await execute$5(item.command, ...args);
-};
-
 const name$N = 'ElectronContextMenu';
 
 // prettier-ignore
 const Commands$J = {
-  handleMenuClose: handleMenuClose,
-  handleSelect: handleSelect,
 };
 
 const ElectronContextMenu_ipc = {
@@ -32548,7 +32503,7 @@ const IndexedDb_ipc = {
 const name$x = 'IpcParent';
 
 const Commands$t = {
-  create: create$Z,
+  create: create$_,
 };
 
 const IpcParent_ipc = {
@@ -34073,7 +34028,7 @@ const TestFrameWorkComponentEval = {
   evalInRendererProcess
 };
 
-const openContextMenu = async (index) => {
+const openContextMenu$1 = async (index) => {
   await execute$5('Explorer.handleContextMenuKeyboard', index);
 };
 
@@ -34156,7 +34111,7 @@ const TestFrameWorkComponentExplorer = {
   handleArrowLeft,
   handleClick: handleClick$7,
   newFile,
-  openContextMenu,
+  openContextMenu: openContextMenu$1,
   removeDirent,
   rename,
   updateEditingValue
@@ -38229,10 +38184,10 @@ const openCompletion$1 = async (editor, openingReason = 1) => {
   if (editor.completionUid !== 0) {
     return editor
   }
-  const completionUid = create$12();
+  const completionUid = create$13();
   editor.completionUid = completionUid;
-  const widgetId = create$12();
-  const viewlet = create$Y(load$6, EditorCompletion$1, widgetId, 'builtin://', 0, 0, 0, 0);
+  const widgetId = create$13();
+  const viewlet = create$Z(load$6, EditorCompletion$1, widgetId, 'builtin://', 0, 0, 0, 0);
   viewlet.show = false;
   viewlet.uid = completionUid;
   // @ts-ignore
@@ -40692,7 +40647,7 @@ const closeTabsRight = async (state) => {
     const uri = newActiveEditor.uri;
     const moduleId = getModuleId(uri);
     const uid = newActiveEditor.uid;
-    const instance = create$Y(load$6, moduleId, state.uid, uri, x, y, width, contentHeight);
+    const instance = create$Z(load$6, moduleId, state.uid, uri, x, y, width, contentHeight);
     // @ts-ignore
     instance.show = false;
     instance.setBounds = false;
@@ -40749,13 +40704,13 @@ const closeOthers = async (state) => {
     newActiveIndex = 0;
     const disposeCommands = disposeFunctional(activeEditor.uid);
     commands.push(...disposeCommands);
-    const instanceUid = create$12();
+    const instanceUid = create$13();
     const moduleId = getModuleId(activeEditor.uri);
     const x = state.x;
     const y = state.y + state.tabHeight;
     const width = state.width;
     const contentHeight = state.height - state.tabHeight;
-    const instance = create$Y(load$6, moduleId, state.uid, focusedEditor.uri, x, y, width, contentHeight);
+    const instance = create$Z(load$6, moduleId, state.uid, focusedEditor.uri, x, y, width, contentHeight);
     instance.uid = instanceUid;
     instance.show = false;
     instance.setBounds = false;
@@ -41003,10 +40958,10 @@ const handleDropFilePathSplit = async (state, eventX, eventY, filePath, splitDir
   ];
   const uri = filePath;
   const id = undefined(uri);
-  const instanceUid = create$12();
-  const tabsUid = create$12();
-  const sashUid = create$12();
-  const instance = create$Y(load$6, id, state.uid, uri, overlayX, overlayY, overlayWidth, overlayHeight);
+  const instanceUid = create$13();
+  const tabsUid = create$13();
+  const sashUid = create$13();
+  const instance = create$Z(load$6, id, state.uid, uri, overlayX, overlayY, overlayWidth, overlayHeight);
   instance.show = false;
   instance.uid = instanceUid;
   // const sashGridItem = {
@@ -41954,7 +41909,7 @@ const getNoResults = () => {
 };
 
 const getPicks = async (searchValue) => {
-  const workspace = state$E.workspacePath;
+  const workspace = state$D.workspacePath;
   if (!workspace) {
     return []
   }
@@ -41964,7 +41919,7 @@ const getPicks = async (searchValue) => {
 };
 
 const selectPick = async (pick) => {
-  const workspace = state$E.workspacePath;
+  const workspace = state$D.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$5(/* Main.openUri */ 'Main.openUri', /* uri */ absolutePath);
   return {
@@ -42345,7 +42300,7 @@ const TextSearchNode = {
 };
 
 const textSearch$3 = (scheme, root, query) => {
-  const entries = Object.entries(state$u.files);
+  const entries = Object.entries(state$t.files);
   const results = [];
   for (const [key, value] of entries) {
     if (value.includes(query)) {
@@ -43060,6 +43015,50 @@ const ViewletSimpleBrowserOpenBackgroundTab = {
   openBackgroundTab
 };
 
+const Separator = 'separator';
+
+const convertMenuItem = (menuItem) => {
+  const { flags, label } = menuItem;
+  switch (flags) {
+    case Separator$1:
+      return {
+        type: Separator,
+      }
+    default:
+      return {
+        label,
+      }
+  }
+};
+
+const convertMenuItems = (menuItems) => {
+  return menuItems.map(convertMenuItem)
+};
+
+const getItem = (items, label) => {
+  for (const item of items) {
+    if (item.label === label) {
+      return item
+    }
+  }
+  return undefined
+};
+
+const openContextMenu = async (x, y, id, ...args) => {
+  const entries = await getMenuEntries$p(id, ...args);
+  const electronMenuItems = convertMenuItems(entries);
+  const event = await invoke$1('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  if (event.type === 'close') {
+    return
+  }
+  const item = getItem(entries, event.data);
+  if (!item) {
+    return
+  }
+  const commandArgs = item.args || [];
+  await execute$5(item.command, ...commandArgs);
+};
+
 const handleContextMenu$1 = async (state, params) => {
   object(state);
   object(params);
@@ -43068,7 +43067,7 @@ const handleContextMenu$1 = async (state, params) => {
   const actualX = x + paramsX;
   const actualY = y + headerHeight + paramsY;
   const args = [actualX, actualY, params];
-  await openContextMenu$1(actualX, actualY, SimpleBrowser, ...args);
+  await openContextMenu(actualX, actualY, SimpleBrowser, ...args);
   return state
 };
 
@@ -45341,7 +45340,7 @@ const AutoUpdaterDeb = {
 };
 
 const show$1 = (x, y, id, ...args) => {
-  return openContextMenu$1(x, y, id, ...args)
+  return openContextMenu(x, y, id, ...args)
 };
 
 const ContextMenuElectron = {
@@ -45658,7 +45657,7 @@ const removeLeadingSlash$1 = (file) => {
 };
 
 const searchFile$4 = async (path, value) => {
-  const files = state$u.files;
+  const files = state$t.files;
   const keys = Object.keys(files).map(removeLeadingSlash$1);
   return keys
 };
@@ -45669,7 +45668,7 @@ const SearchFileWeb = {
 };
 
 const searchFile$3 = async (path, value) => {
-  const files = state$v.files;
+  const files = state$u.files;
   const keys = Object.keys(files);
   return keys
 };
@@ -45680,7 +45679,7 @@ const SearchFileMemfs = {
 };
 
 const removeLeadingSlash = (path) => {
-  const workspacePath = state$E.workspacePath;
+  const workspacePath = state$D.workspacePath;
   return path.slice(workspacePath.length - Fetch.length - 2)
 };