@lvce-editor/server 0.18.12 → 0.18.14

package/static/{1045890 → e6135d8}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -438,7 +438,7 @@ class VError extends Error {
   }
 }
 
-const state$V = {
+const state$U = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -463,7 +463,7 @@ const initializeModule = (module) => {
 
 const loadModule$1 = async (moduleId) => {
   try {
-    const module = await state$V.load(moduleId);
+    const module = await state$U.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`)
@@ -471,23 +471,23 @@ const loadModule$1 = async (moduleId) => {
 };
 
 const getOrLoadModule = (moduleId) => {
-  if (!state$V.pendingModules[moduleId]) {
-    state$V.pendingModules[moduleId] = loadModule$1(moduleId);
+  if (!state$U.pendingModules[moduleId]) {
+    state$U.pendingModules[moduleId] = loadModule$1(moduleId);
   }
-  return state$V.pendingModules[moduleId]
+  return state$U.pendingModules[moduleId]
 };
 
 const loadCommand = (command) => getOrLoadModule(getModuleId$1(command));
 
 const register$1 = (commandId, listener) => {
-  state$V.commands[commandId] = listener;
+  state$U.commands[commandId] = listener;
 };
 
 const hasThrown = new Set();
 
 const execute$5 = (command, ...args) => {
-  if (command in state$V.commands) {
-    const fn = state$V.commands[command];
+  if (command in state$U.commands) {
+    const fn = state$U.commands[command];
     if (typeof fn !== 'function') {
       throw new Error(`[renderer-worker] Command ${command} is not a function`)
     }
@@ -497,7 +497,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$V.commands)) {
+        if (!(command in state$U.commands)) {
           if (hasThrown.has(command)) {
             return
           }
@@ -510,7 +510,7 @@ const execute$5 = (command, ...args) => {
 };
 
 const setLoad = (load) => {
-  state$V.load = load;
+  state$U.load = load;
 };
 
 const Web$1 = 1;
@@ -525,7 +525,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/1045890'
+    return '/e6135d8'
   }
 };
 
@@ -533,12 +533,12 @@ const assetDir = getAssetDir();
 
 const NotFound = 404;
 
-const state$U = {
+const state$T = {
   id: 0,
 };
 
 const create$11 = () => {
-  return ++state$U.id
+  return ++state$T.id
 };
 
 const info = (...args) => {
@@ -553,7 +553,7 @@ const error = (...args) => {
   console.error(...args);
 };
 
-const state$T = {
+const state$S = {
   callbacks: Object.create(null),
   onceListeners: new Set(),
 };
@@ -561,7 +561,7 @@ const state$T = {
 const registerPromise = () => {
   const id = create$11();
   const promise = new Promise((resolve, reject) => {
-    state$T.callbacks[id] = { resolve, reject };
+    state$S.callbacks[id] = { resolve, reject };
   });
   return { id, promise }
 };
@@ -569,23 +569,23 @@ const registerPromise = () => {
 // TODO merge resolve and resolveEmpty
 const resolve = (id, args) => {
   number(id);
-  if (!(id in state$T.callbacks)) {
+  if (!(id in state$S.callbacks)) {
     console.log(args);
     warn$1(`callback ${id} may already be disposed`);
     return
   }
-  state$T.callbacks[id].resolve(args);
-  delete state$T.callbacks[id];
+  state$S.callbacks[id].resolve(args);
+  delete state$S.callbacks[id];
 };
 
 const reject = (id, error) => {
   number(id);
-  if (!(id in state$T.callbacks)) {
+  if (!(id in state$S.callbacks)) {
     warn$1(`callback ${id} may already be disposed`);
     return
   }
-  state$T.callbacks[id].reject(error);
-  delete state$T.callbacks[id];
+  state$S.callbacks[id].reject(error);
+  delete state$S.callbacks[id];
 };
 
 const Two = '2.0';
@@ -831,7 +831,7 @@ const send$2 = (transport, method, ...params) => {
   transport.send(message);
 };
 
-const invoke$4 = async (ipc, method, ...params) => {
+const invoke$3 = async (ipc, method, ...params) => {
   const { message, promise } = create$$(method, params);
   ipc.send(message);
   const responseMessage = await promise;
@@ -841,7 +841,7 @@ const invoke$4 = async (ipc, method, ...params) => {
 
 /* istanbul ignore file */
 
-const state$S = {
+const state$R = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -849,19 +849,19 @@ const state$S = {
   ipc: undefined,
 };
 
-const getIpc$1 = () => {
+const getIpc = () => {
   return listen$a({ method: Auto() })
 };
 
 const listen$9 = async () => {
-  console.assert(state$S.pendingMessages.length === 0);
-  const ipc = await getIpc$1();
+  console.assert(state$R.pendingMessages.length === 0);
+  const ipc = await getIpc();
   handleIpc(ipc, 'renderer process');
-  state$S.ipc = ipc;
+  state$R.ipc = ipc;
 };
 
-const invoke$3 = async (method, ...params) => {
-  return invoke$4(state$S.ipc, method, ...params)
+const invoke$2 = async (method, ...params) => {
+  return invoke$3(state$R.ipc, method, ...params)
 };
 
 const getText$4 = (response) => {
@@ -876,7 +876,7 @@ const create$_ = (value, options) => {
   return new Response(value, options)
 };
 
-const state$R = {
+const state$Q = {
   pending: Object.create(null),
 };
 
@@ -903,10 +903,10 @@ const actuallyLoadCssStyleSheet = async (css) => {
 };
 
 const loadCssStyleSheet = async (css) => {
-  if (!state$R.pending[css]) {
-    state$R.pending[css] = actuallyLoadCssStyleSheet(css);
+  if (!state$Q.pending[css]) {
+    state$Q.pending[css] = actuallyLoadCssStyleSheet(css);
   }
-  return state$R.pending[css]
+  return state$Q.pending[css]
 };
 
 const loadCssStyleSheets = async (css) => {
@@ -914,7 +914,7 @@ const loadCssStyleSheets = async (css) => {
 };
 
 const addCssStyleSheet = async (id, css) => {
-  await invoke$3('Css.addCssStyleSheet', id, css);
+  await invoke$2('Css.addCssStyleSheet', id, css);
 };
 
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
@@ -923,10 +923,10 @@ const actuallyAddDynamicCss = async (id, getCss, preferences) => {
 };
 
 const addDynamicCss = async (id, getCss, preferences) => {
-  if (!state$R.pending[id]) {
-    state$R.pending[id] = actuallyAddDynamicCss(id, getCss, preferences);
+  if (!state$Q.pending[id]) {
+    state$Q.pending[id] = actuallyAddDynamicCss(id, getCss, preferences);
   }
-  return state$R.pending[id]
+  return state$Q.pending[id]
 };
 
 class HTTPError extends Error {
@@ -2061,7 +2061,7 @@ const getMessage$8 = (error) => {
   return `Error: ${error}`
 };
 
-const state$Q = {
+const state$P = {
   /**
    * @type {string[]}
    */
@@ -2098,10 +2098,10 @@ const showErrorDialog = async (error) => {
 
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$Q.seenWarnings.includes(stringified)) {
+  if (state$P.seenWarnings.includes(stringified)) {
     return
   }
-  state$Q.seenWarnings.push(stringified);
+  state$P.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
@@ -2158,7 +2158,7 @@ const listen$8 = (method) => {
 
 /* istanbul ignore file */
 
-const state$P = {
+const state$O = {
   /**
    * @type {any}
    */
@@ -2169,7 +2169,7 @@ const handleMessageFromSharedProcess = async (message) => {
   if (message.method) {
     const result = await execute$5(message.method, ...message.params);
     if (message.id) {
-      state$P.send({
+      state$O.send({
         jsonrpc: Two,
         id: message.id,
         result,
@@ -2185,22 +2185,22 @@ const handleMessageFromSharedProcess = async (message) => {
 const listen$7 = async () => {
   const ipc = await listen$8(Node);
   ipc.onmessage = handleMessageFromSharedProcess;
-  state$P.ipc = ipc;
+  state$O.ipc = ipc;
 };
 
-const invoke$2 = async (method, ...params) => {
+const invoke$1 = async (method, ...params) => {
   // if (platform === 'web') {
   //   console.warn('SharedProcess is not available on web')
   //   return
   // }
-  const result = await invoke$4(state$P.ipc, method, ...params);
+  const result = await invoke$3(state$O.ipc, method, ...params);
   return result
 };
 
 // TODO when shared process crashes / connection is lost: reconnect or show notification
 
 const getColorThemeJson$2 = (colorThemeId) => {
-  return invoke$2(/* ExtensionHost.getColorThemeJson */ 'ExtensionHost.getColorThemeJson', /* colorThemeId */ colorThemeId)
+  return invoke$1(/* ExtensionHost.getColorThemeJson */ 'ExtensionHost.getColorThemeJson', /* colorThemeId */ colorThemeId)
 };
 
 const getColorThemeUrlWeb = (colorThemeId) => {
@@ -2221,7 +2221,7 @@ const getColorThemeJson = (colorThemeId) => {
 };
 
 const setThemeColor = async (themeColor) => {
-  await invoke$3(
+  await invoke$2(
     /* Meta.setThemeColor */ 'Meta.setThemeColor',
     /* color */ themeColor
   );
@@ -2254,7 +2254,7 @@ const Disk = '';
 
 // TODO lazyload different file system providers
 
-const state$O = {
+const state$N = {
   fileSystems: Object.create(null),
 };
 
@@ -2286,10 +2286,10 @@ const loadFileSystem = (procotol) => {
 };
 
 const getFileSystem = (protocol) => {
-  if (!(protocol in state$O.fileSystems)) {
-    state$O.fileSystems[protocol] = loadFileSystem(protocol);
+  if (!(protocol in state$N.fileSystems)) {
+    state$N.fileSystems[protocol] = loadFileSystem(protocol);
   }
-  return state$O.fileSystems[protocol]
+  return state$N.fileSystems[protocol]
 };
 
 const RE_PROTOCOL = /^([a-z\-]+):\/\//;
@@ -2430,27 +2430,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$N = {
+const state$M = {
   listenerMap: Object.create(null),
 };
 
 const emitEvent = async (event, ...args) => {
-  const listeners = state$N.listenerMap[event] || [];
+  const listeners = state$M.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 
 const addListener = (event, fn) => {
-  state$N.listenerMap[event] ||= [];
-  if (state$N.listenerMap[event].includes(fn)) {
+  state$M.listenerMap[event] ||= [];
+  if (state$M.listenerMap[event].includes(fn)) {
     return
   }
-  state$N.listenerMap[event].push(fn);
+  state$M.listenerMap[event].push(fn);
 };
 
 const removeListener$1 = (event, fn) => {
-  const listeners = state$N.listenerMap[event];
+  const listeners = state$M.listenerMap[event];
   if (!listeners) {
     console.info(
       `[info] listener for event ${event} is not registered and cannot be unregistered`
@@ -2460,7 +2460,7 @@ const removeListener$1 = (event, fn) => {
   const index = listeners.indexOf(fn);
   listeners.splice(index, 1);
   if (listeners.length === 0) {
-    delete state$N.listenerMap[event];
+    delete state$M.listenerMap[event];
   }
 };
 
@@ -2511,7 +2511,7 @@ const TextSearchSearch = 'TextSearch.search';
 
 const WorkspaceResolveRoot = 'Workspace.resolveRoot';
 
-const state$M = Object.create(null);
+const state$L = Object.create(null);
 
 const openSettingsJson = async () => {
   await execute$5(/* Main.openUri */ 'Main.openUri', /* uri */ 'app://settings.json');
@@ -2532,7 +2532,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$5(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
   }
-  return invoke$2(PreferencesGetAll)
+  return invoke$1(PreferencesGetAll)
 };
 
 const getPreferences = async () => {
@@ -2546,29 +2546,29 @@ const hydrate$9 = async () => {
     // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
     // TODO probably not all preferences need to be kept in memory
     const preferences = await getPreferences();
-    Object.assign(state$M, preferences);
+    Object.assign(state$L, preferences);
   } catch (error) {
     logError(error);
   }
 };
 
 const get$5 = (key) => {
-  return state$M[key]
+  return state$L[key]
 };
 
 const set$3 = async (key, value) => {
-  state$M[key] = value;
+  state$L[key] = value;
   if (platform === Web$1) {
-    const preferences = { ...state$M, [key]: value };
+    const preferences = { ...state$L, [key]: value };
     await execute$5(/* LocalStorage.setJson */ 'LocalStorage.setJson', /* key */ 'preferences', /* value */ preferences);
     return
   }
-  const content = stringify(state$M);
+  const content = stringify(state$L);
   await writeFile$f('app://settings.json', content);
 };
 
 const update$1 = async (settings) => {
-  const newSettings = { ...state$M, ...settings };
+  const newSettings = { ...state$L, ...settings };
   const content = stringify(newSettings);
   await writeFile$f('app://settings.json', content);
   await emitEvent('preferences.changed');
@@ -2577,7 +2577,7 @@ const update$1 = 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$L = {
+const state$K = {
   watchedTheme: '',
 };
 
@@ -2602,7 +2602,7 @@ const getMetaThemeColor = (colorThemeJson) => {
 const applyColorTheme = async (colorThemeId) => {
   try {
     string(colorThemeId);
-    state$L.colorTheme = colorThemeId;
+    state$K.colorTheme = colorThemeId;
     const colorThemeJson = await getColorThemeJson(colorThemeId);
     const colorThemeCss = await getColorThemeCss(colorThemeId, colorThemeJson);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
@@ -2625,11 +2625,11 @@ const setColorTheme$1 = async (colorThemeId) => {
 };
 
 const watch$1 = async (id) => {
-  if (state$L.watchedTheme === id) {
+  if (state$K.watchedTheme === id) {
     return
   }
-  state$L.watchedTheme = id;
-  await invoke$2('ExtensionHost.watchColorTheme', id);
+  state$K.watchedTheme = id;
+  await invoke$1('ExtensionHost.watchColorTheme', id);
 };
 
 const getPreferredColorTheme = () => {
@@ -2664,7 +2664,7 @@ const Rejected$1 = 'rejected';
 
 const getLanguages$2 = async () => {
   // TODO handle error
-  const languages = await invoke$2(/* ExtensionHost.getLanguages */ 'ExtensionHost.getLanguages');
+  const languages = await invoke$1(/* ExtensionHost.getLanguages */ 'ExtensionHost.getLanguages');
   return languages
 };
 
@@ -2690,7 +2690,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
 };
 
 const getLanguageConfigurationFromWebExtension = async (languageId) => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$J.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$I.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined
   }
@@ -2699,7 +2699,7 @@ const getLanguageConfigurationFromWebExtension = async (languageId) => {
 };
 
 const getLanguageConfiguration$3 = async (languageId) => {
-  const languageConfiguration = await invoke$2(
+  const languageConfiguration = await invoke$1(
     /* ExtensionHost.getLanguageConfiguration */ 'ExtensionHost.getLanguageConfiguration',
     /* languageId */ languageId
   );
@@ -2759,7 +2759,7 @@ const getNthFileExtension = (file, startIndex) => {
 // TODO merge all of this with extension host languages module
 
 
-const state$K = {
+const state$J = {
   loadState: false,
   isHydrating: false,
   fileNameMap: Object.create(null),
@@ -2776,64 +2776,64 @@ const state$K = {
 };
 
 const getFirstLines = () => {
-  return state$K.firstLines
+  return state$J.firstLines
 };
 
 const hasLanguageByExtension = (extension) => {
-  return extension in state$K.extensionMap
+  return extension in state$J.extensionMap
 };
 
 const getLanguageByExtension = (extension) => {
-  return state$K.extensionMap[extension]
+  return state$J.extensionMap[extension]
 };
 
 const hasLanguageByFileName = (fileName) => {
-  return fileName in state$K.fileNameMap
+  return fileName in state$J.fileNameMap
 };
 
 const getLanguageByFileName = (fileName) => {
-  return state$K.fileNameMap[fileName]
+  return state$J.fileNameMap[fileName]
 };
 
 const getTokenizeFunctionPath$1 = (languageId) => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$K.tokenizerMap[languageId] || ''
+  return state$J.tokenizerMap[languageId] || ''
 };
 
 const setHydrating = (value) => {
-  state$K.isHydrating = value;
+  state$J.isHydrating = value;
 };
 
 const setLoaded = (value) => {
-  state$K.loaded = true;
+  state$J.loaded = true;
 };
 
 const addExtension = (extension, languageId) => {
-  state$K.extensionMap[extension] = languageId;
+  state$J.extensionMap[extension] = languageId;
 };
 
 const addFirstLine = (regex, languageId) => {
-  state$K.firstLines.push({ regex, languageId });
+  state$J.firstLines.push({ regex, languageId });
 };
 
 const hasWarned = (languageId) => {
-  return state$K.hasWarned.includes(languageId)
+  return state$J.hasWarned.includes(languageId)
 };
 
 const addWarned = (languageId) => {
-  return state$K.hasWarned.push(languageId)
+  return state$J.hasWarned.push(languageId)
 };
 
 const addFileName = (fileName, languageId) => {
-  state$K.fileNameMap[fileName] = languageId;
+  state$J.fileNameMap[fileName] = languageId;
 };
 
 const addTokenizer = (languageId, tokenizer) => {
-  state$K.tokenizerMap[languageId] = tokenizer;
+  state$J.tokenizerMap[languageId] = tokenizer;
 };
 
 const hasLoaded$1 = () => {
-  return state$K.loaded
+  return state$J.loaded
 };
 
 // TODO merge all of this with extension host languages module
@@ -3042,48 +3042,48 @@ const getLanguageConfiguration = async (editor) => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$2(/* Platform.getExtensionsPath */ 'Platform.getExtensionsPath')
+  return invoke$1(/* Platform.getExtensionsPath */ 'Platform.getExtensionsPath')
 };
 
 const getCachedExtensionsPath = () => {
-  return invoke$2(/* Platform.getCachedExtensionsPath */ 'Platform.getCachedExtensionsPath')
+  return invoke$1(/* Platform.getCachedExtensionsPath */ 'Platform.getCachedExtensionsPath')
 };
 
 const getLogsDir = () => {
-  return invoke$2(/* Platform.getLogsDir */ 'Platform.getLogsDir')
+  return invoke$1(/* Platform.getLogsDir */ 'Platform.getLogsDir')
 };
 
 const getDownloadDir = () => {
-  return invoke$2(/* Platform.getDownloadDir */ 'Platform.getDownloadDir')
+  return invoke$1(/* Platform.getDownloadDir */ 'Platform.getDownloadDir')
 };
 
 const getUserSettingsPath = () => {
   if (platform === Web$1) {
     return 'settings'
   }
-  return invoke$2(/* Platform.getUserSettingsPath */ 'Platform.getUserSettingsPath')
+  return invoke$1(/* Platform.getUserSettingsPath */ 'Platform.getUserSettingsPath')
 };
 
 const getUserKeyBindingsPath = () => {
   if (platform === Web$1) {
     return 'settings'
   }
-  return invoke$2(/* Platform.getUserSettingsPath */ 'Platform.getUserKeyBindingsPath')
+  return invoke$1(/* Platform.getUserSettingsPath */ 'Platform.getUserKeyBindingsPath')
 };
 
 const getRecentlyOpenedPath = () => {
   if (platform === Web$1) {
     return 'recently-opened'
   }
-  return invoke$2(/* Platform.getRecentlyOpenedPath */ 'Platform.getRecentlyOpenedPath')
+  return invoke$1(/* Platform.getRecentlyOpenedPath */ 'Platform.getRecentlyOpenedPath')
 };
 
 const getConfigPath = () => {
-  return invoke$2(/* Platform.getConfigDir */ 'Platform.getConfigDir')
+  return invoke$1(/* Platform.getConfigDir */ 'Platform.getConfigDir')
 };
 
 const getCachePath = () => {
-  return invoke$2(/* Platform.getCacheDir */ 'Platform.getCacheDir')
+  return invoke$1(/* Platform.getCacheDir */ 'Platform.getCacheDir')
 };
 
 const getExtensionHostWorkerUrl = () => {
@@ -3103,7 +3103,7 @@ const getCacheName = () => {
 };
 
 const getTestPathRemote = () => {
-  return invoke$2(/* Platform.getTestPath */ 'Platform.getTestPath')
+  return invoke$1(/* Platform.getTestPath */ 'Platform.getTestPath')
 };
 
 const getTestPathWeb = () => {
@@ -3124,21 +3124,21 @@ const getNodePath$1 = () => {
   if (platform === Web$1) {
     throw new Error('not implemented in web')
   }
-  return invoke$2(/* Platform.getNodePath */ 'Platform.getNodePath')
+  return invoke$1(/* Platform.getNodePath */ 'Platform.getNodePath')
 };
 
 const getTmpDir$3 = () => {
   if (platform === Web$1) {
     throw new Error('not implemented in web')
   }
-  return invoke$2(/* Platform.getTmpDir */ 'Platform.getTmpDir')
+  return invoke$1(/* Platform.getTmpDir */ 'Platform.getTmpDir')
 };
 
 const getRepository = () => {
-  return invoke$2('Platform.getRepository')
+  return invoke$1('Platform.getRepository')
 };
 
-const state$J = {
+const state$I = {
   /**
    * @type {any[]}
    */
@@ -3175,7 +3175,7 @@ const addWebExtension$1 = async (path) => {
     }
   }
   manifest.status = Resolved;
-  state$J.webExtensions.push(manifest);
+  state$I.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -3183,7 +3183,7 @@ const addWebExtension$1 = async (path) => {
 };
 
 const getSharedProcessExtensions = () => {
-  return invoke$2(/* ExtensionManagement.getExtensions */ 'ExtensionManagement.getExtensions')
+  return invoke$1(/* ExtensionManagement.getExtensions */ 'ExtensionManagement.getExtensions')
 };
 
 const getStaticWebExtensions = () => {
@@ -3193,7 +3193,7 @@ const getStaticWebExtensions = () => {
 
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$J.webExtensions]
+  return [...staticWebExtensions, ...state$I.webExtensions]
 };
 
 const isWebExtension = (extension) => {
@@ -3204,7 +3204,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$J.webExtensions]
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$I.webExtensions]
 };
 
 const getWebExtensions = async () => {
@@ -3216,7 +3216,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault()
     }
   } catch {
-    return state$J.webExtensions
+    return state$I.webExtensions
   }
 };
 
@@ -3318,7 +3318,7 @@ const getIconThemeJson = async (iconThemeId) => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`,
     }
   }
-  for (const webExtension of state$J.webExtensions) {
+  for (const webExtension of state$I.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -3331,12 +3331,12 @@ const getIconThemeJson = async (iconThemeId) => {
       }
     }
   }
-  return invoke$2(ExtensionHostGetIconThemeJson, /* iconThemeId */ iconThemeId)
+  return invoke$1(ExtensionHostGetIconThemeJson, /* iconThemeId */ iconThemeId)
 };
 
 const initialIconTheme = undefined;
 
-const state$I = {
+const state$H = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -3346,22 +3346,22 @@ const state$I = {
   iconTheme: initialIconTheme,
 };
 
-const state$H = {
+const state$G = {
   openCount: 0,
 };
 
 const createBrowserView$1 = (restoreId, fallThroughKeyBindings) => {
-  state$H.openCount++;
-  return invoke$2('ElectronBrowserView.createBrowserView', restoreId, fallThroughKeyBindings)
+  state$G.openCount++;
+  return invoke$1('ElectronBrowserView.createBrowserView', restoreId, fallThroughKeyBindings)
 };
 
 const disposeBrowserView$1 = (id) => {
-  state$H.openCount--;
-  return invoke$2('ElectronBrowserView.disposeBrowserView', id)
+  state$G.openCount--;
+  return invoke$1('ElectronBrowserView.disposeBrowserView', id)
 };
 
 const isOpen = () => {
-  return state$H.openCount > 0
+  return state$G.openCount > 0
 };
 
 class CancelationError extends Error {
@@ -3383,15 +3383,15 @@ const mapObject = (object, fn) => {
 };
 
 const clear$3 = async (storageType) => {
-  await invoke$3(/* WebStorage.clear */ 'WebStorage.clear', /* StorageType */ storageType);
+  await invoke$2(/* WebStorage.clear */ 'WebStorage.clear', /* StorageType */ storageType);
 };
 
 const getAll = (storageType) => {
-  return invoke$3('WebStorage.getAll', storageType)
+  return invoke$2('WebStorage.getAll', storageType)
 };
 
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$3(/* WebStorage.getItem */ 'WebStorage.getItem', /* storageType */ storageType, /* key */ key);
+  const item = await invoke$2(/* WebStorage.getItem */ 'WebStorage.getItem', /* storageType */ storageType, /* key */ key);
   return item || ''
 };
 
@@ -3408,7 +3408,7 @@ const getJson$5 = async (storageType, key) => {
 };
 
 const setText$3 = async (storageType, key, value) => {
-  await invoke$3(/* WebStorage.setItem */ 'WebStorage.setItem', /* storageType */ storageType, /* key */ key, /* value */ value);
+  await invoke$2(/* WebStorage.setItem */ 'WebStorage.setItem', /* storageType */ storageType, /* key */ key, /* value */ value);
 };
 
 const setJson$4 = async (storageType, key, value) => {
@@ -3418,7 +3418,7 @@ const setJson$4 = async (storageType, key, value) => {
 
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = mapObject(objects, stringifyCompact);
-  await invoke$3('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$2('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -3491,7 +3491,7 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value)
 };
 
-const state$G = {
+const state$F = {
   instances: Object.create(null),
   /**
    * @type {any}
@@ -3505,11 +3505,11 @@ const set$2 = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$G.instances[key] = value;
+  state$F.instances[key] = value;
 };
 
 const getInstance = (key) => {
-  const fast = state$G.instances[key];
+  const fast = state$F.instances[key];
   if (fast) {
     return fast
   }
@@ -3519,7 +3519,7 @@ const getInstance = (key) => {
   if (key === 'EditorText') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$G.instances)) {
+  for (const value of Object.values(state$F.instances)) {
     if (value.moduleId === key) {
       return value
     }
@@ -3528,19 +3528,19 @@ const getInstance = (key) => {
 };
 
 const hasInstance = (key) => {
-  return key in state$G.instances
+  return key in state$F.instances
 };
 
 const remove$8 = (key) => {
-  delete state$G.instances[key];
+  delete state$F.instances[key];
 };
 
 const getAllInstances = () => {
-  return state$G.instances
+  return state$F.instances
 };
 
 const getValues = () => {
-  return Object.values(state$G.instances)
+  return Object.values(state$F.instances)
 };
 
 const getState$1 = (key) => {
@@ -3575,15 +3575,15 @@ const setFocusedInstance = (state, instance) => {
 };
 
 const getHref = () => {
-  return invoke$3(/* Location.getHref */ 'Location.getHref')
+  return invoke$2(/* Location.getHref */ 'Location.getHref')
 };
 
 const setPathName = (pathName) => {
-  return invoke$3(/* Location.setPathName */ 'Location.setPathName', /* pathName */ pathName)
+  return invoke$2(/* Location.setPathName */ 'Location.setPathName', /* pathName */ pathName)
 };
 
 const hydrate$6 = () => {
-  return invoke$3(/* Location.hydrate */ 'Location.hydrate')
+  return invoke$2(/* Location.hydrate */ 'Location.hydrate')
 };
 
 const getOrigin = () => {
@@ -3591,12 +3591,12 @@ const getOrigin = () => {
 };
 
 const setTitle = async (title) => {
-  await invoke$3(/* Window.setTitle */ 'Window.setTitle', /* title */ title);
+  await invoke$2(/* Window.setTitle */ 'Window.setTitle', /* title */ title);
 };
 
 const Slash$1 = Slash$2;
 
-const state$F = {
+const state$E = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -3614,22 +3614,22 @@ const setPath$1 = async (path) => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$a(path);
   // @ts-ignore
-  state$F.workspacePath = path;
+  state$E.workspacePath = path;
   // @ts-ignore
-  state$F.workspaceUri = path;
-  state$F.pathSeparator = pathSeparator;
+  state$E.workspaceUri = path;
+  state$E.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 
 const setUri = async (uri) => {
   const path = uri.slice('file://'.length);
-  state$F.workspacePath = path;
-  state$F.workspaceUri = uri;
+  state$E.workspacePath = path;
+  state$E.workspaceUri = uri;
   await onWorkspaceChange();
 };
 
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$2(/* Workspace.resolveRoot */ WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$1(/* Workspace.resolveRoot */ WorkspaceResolveRoot);
   return resolvedRoot
 };
 
@@ -3652,13 +3652,13 @@ const getResolveRootFromSessionStorage = async () => {
 };
 
 const isTest = () => {
-  return state$F.isTest
+  return state$E.isTest
 };
 
 const getResolvedRootFromRendererProcess = async (href) => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$F.isTest = true;
+    state$E.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -3712,7 +3712,7 @@ const getResolvedRoot = async (href) => {
 };
 
 const getTitle$1 = (workspacePath) => {
-  const pathSeparator = state$F.pathSeparator;
+  const pathSeparator = state$E.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1)
 };
 
@@ -3724,40 +3724,40 @@ const getPathName = (workspacePath) => {
 };
 
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$F.workspacePath);
+  const title = getTitle$1(state$E.workspacePath);
   await setTitle(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$F.workspacePath);
+    const pathName = getPathName(state$E.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$F.workspacePath);
+  await emitEvent('workspace.change', state$E.workspacePath);
 };
 
 const hydrate$5 = async ({ href }) => {
-  if (state$F.workspacePath) {
+  if (state$E.workspacePath) {
     return
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$F.isTest) {
+  if (state$E.isTest) {
     return
   }
-  if (state$F.workspacePath) {
+  if (state$E.workspacePath) {
     return
   }
   // TODO why is this if statement here?
-  if (state$F.homeDir !== resolvedRoot.homeDir) {
-    state$F.homeDir = resolvedRoot.homeDir;
+  if (state$E.homeDir !== resolvedRoot.homeDir) {
+    state$E.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$F.workspacePath = resolvedRoot.path;
-  state$F.homeDir = resolvedRoot.homeDir;
-  state$F.pathSeparator = resolvedRoot.pathSeparator;
-  state$F.workspaceUri = resolvedRoot.uri;
-  state$F.source = resolvedRoot.source;
+  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;
   await onWorkspaceChange();
 };
 
@@ -3766,11 +3766,11 @@ const hydrate$5 = async ({ href }) => {
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$F.workspacePath
+  return state$E.workspacePath
 };
 
 const getHomeDir = () => {
-  return state$F.homeDir
+  return state$E.homeDir
 };
 
 // TODO this should be in FileSystem module
@@ -3780,7 +3780,7 @@ const pathBaseName = (path) => {
 
 // TODO this should be in FileSystem module
 const pathDirName = (path) => {
-  const pathSeparator = state$F.pathSeparator || '/';
+  const pathSeparator = state$E.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString
@@ -3790,9 +3790,9 @@ const pathDirName = (path) => {
 
 const getAbsolutePath = (relativePath) => {
   if (relativePath.startsWith('./')) {
-    return `${state$F.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
+    return `${state$E.workspacePath}/${relativePath.slice(2)}` // TODO support windows paths
   }
-  return `${state$F.workspacePath}/${relativePath}` // TODO support windows paths
+  return `${state$E.workspacePath}/${relativePath}` // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -3802,10 +3802,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$F.workspacePath,
-      homeDir: state$F.homeDir,
-      pathSeparator: state$F.pathSeparator,
-      uri: state$F.workspaceUri,
+      path: state$E.workspacePath,
+      homeDir: state$E.homeDir,
+      pathSeparator: state$E.pathSeparator,
+      uri: state$E.workspaceUri,
     },
   }
 };
@@ -3841,7 +3841,7 @@ const hydrate$4 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return
   }
-  await invoke$3('Window.onVisibilityChange');
+  await invoke$2('Window.onVisibilityChange');
 };
 
 const getSavedViewletState = (viewletId) => {
@@ -4008,7 +4008,7 @@ const ViewletModuleId = {
   Video
 };
 
-const state$E = {
+const state$D = {
   pendingModules: Object.create(null),
 };
 
@@ -4046,7 +4046,7 @@ const runFn = async (instance, id, key, fn, args) => {
     }
     const commands = render$G(instance.factory, oldState, newState, newState.uid || id);
     setRenderedState(id, newState);
-    await invoke$3(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
+    await invoke$2(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
   } else {
     return fn(instance.state, ...args)
   }
@@ -4069,7 +4069,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
   if (commands.length === 0) {
     return
   }
-  await invoke$3(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
+  await invoke$2(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -4232,7 +4232,7 @@ const maybeRegisterEvents = (module) => {
         const commands = render$G(instance.factory, instance.renderedState, newState, uid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$3(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
+        await invoke$2(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
       };
       addListener(key, handleUpdate);
     }
@@ -4241,7 +4241,7 @@ const maybeRegisterEvents = (module) => {
 
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
-  await invoke$3(/* Viewlet.load */ kLoadModule, /* id */ id);
+  await invoke$2(/* Viewlet.load */ kLoadModule, /* id */ id);
   if (module.Css) {
     // this is a memory leak but it is not too important
     // because javascript modules also cannot be unloaded
@@ -4252,7 +4252,7 @@ const actuallyLoadModule = async (getModule, id) => {
     }
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$M);
+    await addDynamicCss(id, module.getDynamicCss, state$L);
   }
   maybeRegisterWrappedCommands(id, module);
   maybeRegisterEvents(module);
@@ -4260,10 +4260,10 @@ const actuallyLoadModule = async (getModule, id) => {
 };
 
 const loadModule = (getModule, id) => {
-  if (!(id in state$E.pendingModules)) {
-    state$E.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$D.pendingModules)) {
+    state$D.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$E.pendingModules[id]
+  return state$D.pendingModules[id]
 };
 
 // TODO add lots of unit tests for this
@@ -4379,7 +4379,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {
     } else {
-      await invoke$3(/* Viewlet.loadModule */ kLoadModule, /* id */ viewlet.id);
+      await invoke$2(/* Viewlet.loadModule */ kLoadModule, /* id */ viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -4427,7 +4427,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
         return allCommands
       }
       commands.push(...extraCommands);
-      await invoke$3(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
+      await invoke$2(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands);
     } else {
       const allCommands = [
         ...commands,
@@ -4451,7 +4451,7 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$3(/* Viewlet.append */ kAppendViewlet, /* parentUid */ viewlet.parentUid, /* id */ viewletUid, /* focus */ focus);
+      await invoke$2(/* Viewlet.append */ kAppendViewlet, /* parentUid */ viewlet.parentUid, /* id */ viewletUid, /* focus */ focus);
     }
     state = ViewletState.Appended;
 
@@ -4475,10 +4475,10 @@ const load$8 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$3(/* Viewlet.loadModule */ kLoadModule, /* id */ viewlet.id);
+        await invoke$2(/* Viewlet.loadModule */ kLoadModule, /* id */ viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$3(kLoadModule, Error$2);
+      await invoke$2(kLoadModule, Error$2);
       commands.push([kCreate, Error$2, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -4611,44 +4611,6 @@ const load$6 = async (moduleId) => {
   }
 };
 
-const state$D = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-};
-
-const createIpc = async () => {
-  return create$Y({
-    method: ElectronMessagePort,
-    type: 'electron-process',
-  })
-};
-
-const handleMessage$2 = async (message) => {
-  if ('id' in message) {
-    resolve(message.id, message);
-  } else if ('method' in message) {
-    await execute$5(message.method, ...message.params);
-  } else ;
-};
-
-// TODO race condition
-const getIpc = async () => {
-  if (!state$D.ipc) {
-    const ipc = await createIpc();
-    ipc.onmessage = handleMessage$2;
-    state$D.ipc = ipc;
-  }
-  return state$D.ipc
-};
-
-const invoke$1 = async (method, ...params) => {
-  const ipc = await getIpc();
-  const result = await invoke$4(ipc, method, ...params);
-  return result
-};
-
 const createBrowserViewQuickPick = (x, y, width, height) => {
   return invoke$1('ElectronBrowserViewQuickPick.createBrowserViewQuickPick', x, y, width, height)
 };
@@ -4666,56 +4628,56 @@ const getWindowId = async () => {
 
 const reload$3 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.reload', windowId)
+  return invoke$1('ElectronWindow.reload', windowId)
 };
 
 const minimize$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.minimize', windowId)
+  return invoke$1('ElectronWindow.minimize', windowId)
 };
 
 const unmaximize$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.unmaximize', windowId)
+  return invoke$1('ElectronWindow.unmaximize', windowId)
 };
 
 const maximize$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.maximize', windowId)
+  return invoke$1('ElectronWindow.maximize', windowId)
 };
 
 const close$6 = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.close', windowId)
+  return invoke$1('ElectronWindow.close', windowId)
 };
 
 const openNew$1 = async (url) => {
-  return invoke$1('AppWindow.openNew', url)
+  return invoke$1('ElectronWindow.openNew', url)
 };
 
 const toggleDevtools = async () => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronWindow.toggleDevtools', windowId)
+  return invoke$1('ElectronWindow.toggleDevtools', windowId)
 };
 
 const zoomIn$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$1('ElectronElectronWindow.zoomIn', windowId)
+  return invoke$1('ElectronWindow.zoomIn', windowId)
 };
 
 const zoomOut$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$1('ElectronElectronWindow.zoomOut', windowId)
+  return invoke$1('ElectronWindow.zoomOut', windowId)
 };
 
 const zoomReset$1 = async () => {
   const windowId = await getWindowId();
-  return invoke$1('ElectronElectronWindow.zoomReset', windowId)
+  return invoke$1('ElectronWindow.zoomReset', windowId)
 };
 
 const focus$d = async () => {
   const windowId = await getWindowId();
-  return invoke$1('ElectronElectronWindow.focus', windowId)
+  return invoke$1('ElectronWindow.focus', windowId)
 };
 
 const handleKeyBinding = async (keyBinding) => {
@@ -4825,7 +4787,7 @@ const focus$c = async (id) => {
     commands.push(...render$G(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$2('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -4864,9 +4826,9 @@ const dispose$v = async (id) => {
       throw new Error(`${id} is missing a factory function`)
     }
     instance.factory.dispose(instance.state);
-    await invoke$3(/* Viewlet.dispose */ 'Viewlet.dispose', /* id */ instanceUid);
+    await invoke$2(/* Viewlet.dispose */ 'Viewlet.dispose', /* id */ instanceUid);
     if (instance.factory.getKeyBindings) {
-      await invoke$3('Viewlet.removeKeyBindings', instanceUid);
+      await invoke$2('Viewlet.removeKeyBindings', instanceUid);
     }
   } catch (error) {
     console.error(error);
@@ -4988,7 +4950,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$3(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ commands);
+    await invoke$2(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ commands);
   }
 };
 
@@ -5032,7 +4994,7 @@ const openWidget = async (moduleId, ...args) => {
   const layout = getState$1(Layout);
   commands.push(['Viewlet.append', layout.uid, childUid]);
   commands.push(['Viewlet.focus', childUid]);
-  await invoke$3('Viewlet.executeCommands', commands);
+  await invoke$2('Viewlet.executeCommands', commands);
   // TODO commands should be like this
   // viewlet.create quickpick
   // quickpick.setItems
@@ -5054,7 +5016,7 @@ const closeWidget = async (id) => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$3(/* Viewlet.dispose */ 'Viewlet.sendMultiple', commands);
+    await invoke$2(/* Viewlet.dispose */ 'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`)
@@ -5114,7 +5076,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return
   }
-  await invoke$3(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ commands);
+  await invoke$2(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ commands);
 };
 
 const disposeWidgetWithValue = async (id, value) => {
@@ -5153,7 +5115,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$2('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -5194,7 +5156,7 @@ const getAbsoluteIconPath = (iconTheme, icon) => {
 
 const getFileNameIcon = (file) => {
   string(file);
-  const { iconTheme } = state$I;
+  const { iconTheme } = state$H;
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return ''
@@ -5236,7 +5198,7 @@ const getFileIcon$1 = (file) => {
 };
 
 const getFolderIcon = (folder) => {
-  const iconTheme = state$I.iconTheme;
+  const iconTheme = state$H.iconTheme;
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return ''
@@ -5251,7 +5213,7 @@ const getFolderIcon = (folder) => {
 };
 
 const getFolderIconExpanded = (folder) => {
-  const iconTheme = state$I.iconTheme;
+  const iconTheme = state$H.iconTheme;
   if (!iconTheme) {
     return ''
   }
@@ -5281,7 +5243,7 @@ const getIcon$1 = (dirent) => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$I.iconTheme, File$6)
+      return getAbsoluteIconPath(state$H.iconTheme, File$6)
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$b
@@ -5291,8 +5253,8 @@ const getIcon$1 = (dirent) => {
 const setIconTheme$1 = async (iconThemeId) => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$I.iconTheme = iconTheme.json;
-    state$I.extensionPath = iconTheme.extensionPath;
+    state$H.iconTheme = iconTheme.json;
+    state$H.extensionPath = iconTheme.extensionPath;
     const instances = getAllInstances();
     // TODO have one recalculate style and one paint
     for (const [key, value] of Object.entries(instances)) {
@@ -5315,7 +5277,7 @@ const hydrate$3 = async () => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$3(
+  const rendererProcessInitData = await invoke$2(
     'InitData.getInitData'
   );
   // TODO get the following items
@@ -5635,7 +5597,7 @@ const addToRecentlyOpenedWeb = async (path) => {
 };
 
 const addToRecentlyOpenedRemote = async (path) => {
-  await invoke$2(RecentlyOpenedAddPath, path);
+  await invoke$1(RecentlyOpenedAddPath, path);
 };
 
 const addToRecentlyOpened = async (path) => {
@@ -6150,7 +6112,7 @@ const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 
 const replaySession = async (sessionId) => {
   const events = await getEvents(sessionId);
-  const originalIpc = state$S.ipc;
+  const originalIpc = state$R.ipc;
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalOnMessage = originalIpc.onmessage.bind(originalIpc);
   const wrappedSend = () => {};
@@ -6165,33 +6127,33 @@ const replaySession = async (sessionId) => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$S.ipc.onmessage = originalOnMessage;
-          state$S.ipc.send = originalSend;
+          state$R.ipc.onmessage = originalOnMessage;
+          state$R.ipc.send = originalSend;
           await execute$5('ElectronWindow.close');
-          state$S.ipc.onmessage = wrappedOnMessage;
-          state$S.ipc.send = wrappedSend;
+          state$R.ipc.onmessage = wrappedOnMessage;
+          state$R.ipc.send = wrappedSend;
           break
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$S.ipc.onmessage = originalOnMessage;
-          state$S.ipc.send = originalSend;
+          state$R.ipc.onmessage = originalOnMessage;
+          state$R.ipc.send = originalSend;
           await execute$5('ElectronWindow.minimize');
-          state$S.ipc.onmessage = wrappedOnMessage;
-          state$S.ipc.send = wrappedSend;
+          state$R.ipc.onmessage = wrappedOnMessage;
+          state$R.ipc.send = wrappedSend;
           break
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$S.ipc.onmessage = originalOnMessage;
-          state$S.ipc.send = originalSend;
+          state$R.ipc.onmessage = originalOnMessage;
+          state$R.ipc.send = originalSend;
           await execute$5('ElectronWindow.maximize');
-          state$S.ipc.onmessage = wrappedOnMessage;
-          state$S.ipc.send = wrappedSend;
+          state$R.ipc.onmessage = wrappedOnMessage;
+          state$R.ipc.send = wrappedSend;
           break
       }
     } else {
       throw new Error('unexpected message from renderer worker')
     }
   };
-  state$S.ipc.send = wrappedSend;
-  state$S.ipc.onmessage = wrappedOnMessage;
+  state$R.ipc.send = wrappedSend;
+  state$R.ipc.onmessage = wrappedOnMessage;
   const callbacks = Object.create(null);
   const invoke = (event) => {
     return new Promise((resolve, reject) => {
@@ -6273,8 +6235,8 @@ const wrapIpc = (ipc, name, getData) => {
 };
 
 const startRecording$1 = () => {
-  state$S.ipc = wrapIpc(state$S.ipc, 'renderer-process', (event) => event.data);
-  state$P.ipc = wrapIpc(state$P.ipc, 'shared-process', (event) => event);
+  state$R.ipc = wrapIpc(state$R.ipc, 'renderer-process', (event) => event.data);
+  state$O.ipc = wrapIpc(state$O.ipc, 'shared-process', (event) => event);
 };
 
 const openSession = async () => {
@@ -6372,7 +6334,7 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$3('Viewlet.executeCommands', commands);
+  await invoke$2('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
 
@@ -6611,7 +6573,7 @@ const ModuleWorkerWithMessagePort = 4;
 const Electron = 5;
 
 const getPort = async (type, name) => {
-  const port = await invoke$3('IpcParent.create', {
+  const port = await invoke$2('IpcParent.create', {
     method: Electron,
     type,
     name,
@@ -6998,7 +6960,7 @@ const IpcParentWithWebSocket = {
 };
 
 const create$R = async ({ url, name }) => {
-  const port = await invoke$3('IpcParent.create', {
+  const port = await invoke$2('IpcParent.create', {
     method: ModuleWorkerWithMessagePort,
     url,
     name,
@@ -7566,7 +7528,7 @@ const listen$2 = (ipc) => {
   ipc.onmessage = handleMessage;
   return {
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params)
+      return invoke$3(ipc, method, ...params)
     },
   }
 };
@@ -7697,7 +7659,7 @@ const startSynching = async (extensionHost) => {
     await handleEditorCreate(editorInstance.state);
   }
   // @ts-ignore
-  await handleWorkspaceChange(state$F.workspacePath);
+  await handleWorkspaceChange(state$E.workspacePath);
 };
 
 const actuallyActivateExtension = async (extensionHost, extension) => {
@@ -8676,27 +8638,27 @@ const FileSystemFetch = {
 const name$1M = 'Disk';
 
 const copy$3 = (source, target) => {
-  return invoke$2(FileSystemCopy, /* source */ source, /* target */ target)
+  return invoke$1(FileSystemCopy, /* source */ source, /* target */ target)
 };
 
 const readFile$7 = (path, encoding) => {
-  return invoke$2(FileSystemReadFile$1, /* path */ path, /* encoding */ encoding)
+  return invoke$1(FileSystemReadFile$1, /* path */ path, /* encoding */ encoding)
 };
 
 const remove = (path) => {
-  return invoke$2(FileSystemRemove$1, /* path */ path)
+  return invoke$1(FileSystemRemove$1, /* path */ path)
 };
 
 const rename$3 = (oldUri, newUri) => {
-  return invoke$2(FileSystemRename$1, /* oldPath */ oldUri, /* newPath */ newUri)
+  return invoke$1(FileSystemRename$1, /* oldPath */ oldUri, /* newPath */ newUri)
 };
 
 const mkdir$1 = (path) => {
-  return invoke$2(FileSystemMkdir$1, /* path */ path)
+  return invoke$1(FileSystemMkdir$1, /* path */ path)
 };
 
 const writeFile$8 = async (path, content, encoding) => {
-  await invoke$2(
+  await invoke$1(
     /* FileSystem.writeFile */ FileSystemWriteFile$1,
     /* path */ path,
     /* content */ content,
@@ -8707,7 +8669,7 @@ const writeFile$8 = async (path, content, encoding) => {
 const ensureFile = async () => {};
 
 const readDirWithFileTypes$1 = (path) => {
-  return invoke$2(FileSystemReadDirWithFileTypes$1, /* path */ path)
+  return invoke$1(FileSystemReadDirWithFileTypes$1, /* path */ path)
 };
 
 const getBlobUrl = (path) => {
@@ -8718,19 +8680,19 @@ const getPathSeparator$2 = () => {
   if (platform === Web$1) {
     return Slash$1
   }
-  return invoke$2(FileSystemGetPathSeparator$1)
+  return invoke$1(FileSystemGetPathSeparator$1)
 };
 
 const getRealPath = (path) => {
-  return invoke$2(FileSystemGetRealPath, /* path */ path)
+  return invoke$1(FileSystemGetRealPath, /* path */ path)
 };
 
 const stat = (path) => {
-  return invoke$2(FileSystemStat, /* path */ path)
+  return invoke$1(FileSystemStat, /* path */ path)
 };
 
 const chmod$1 = (path, permissions) => {
-  return invoke$2(FileSystemChmod, /* path */ path, /* permissions */ permissions)
+  return invoke$1(FileSystemChmod, /* path */ path, /* permissions */ permissions)
 };
 
 const canBeRestored$2 = true;
@@ -8876,7 +8838,7 @@ const requestPermission = async (handle, options) => {
   // query permission, but from renderer process
   // because handle.requestPermission is not implemented
   // in a worker, see https://github.com/WICG/file-system-access/issues/289
-  const permissionTypeNow = await invoke$3(
+  const permissionTypeNow = await invoke$2(
     'FileSystemHandle.requestPermission',
     handle,
     options
@@ -10012,7 +9974,7 @@ const create$M = (id, uri, x, y, width, height) => {
 
 const loadContent$D = (state) => {
   const update = async () => {
-    await invoke$3(/* Viewlet.invoke */ 'Viewlet.send', /* id */ Clock, /* method */ 'setTime', /* time */ Date.now());
+    await invoke$2(/* Viewlet.invoke */ 'Viewlet.send', /* id */ Clock, /* method */ 'setTime', /* time */ Date.now());
   };
   return {
     ...state,
@@ -11090,7 +11052,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
   const x$1 = x(editor, rowIndex, columnIndex);
   const y$1 = y(editor, rowIndex);
   const displayErrorMessage = message;
-  await invoke$3(
+  await invoke$2(
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ editor.uid,
     /* method */ 'showOverlayMessage',
@@ -11126,7 +11088,7 @@ const showErrorMessage = (editor, rowIndex, columnIndex, message) => {
 const editorHideMessage = async (editor) => {
   clearTimeout(state$p.timeout);
   state$p.timeout = -1;
-  await invoke$3(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage');
+  await invoke$2(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage');
   return editor
 };
 
@@ -11953,7 +11915,7 @@ const getHover = async (editor, offset) => {
 };
 
 const sanitizeHtml = (html) => {
-  return invoke$3('SanitizeHtml.sanitizeHtml', html)
+  return invoke$2('SanitizeHtml.sanitizeHtml', html)
 };
 
 const RE_ESCAPE = /[<>&]/g;
@@ -13450,6 +13412,17 @@ const push = (
   return newSelections
 };
 
+const getSelectionPairs = (selections, i) => {
+  const first = selections[i];
+  const second = selections[i + 1];
+  const third = selections[i + 2];
+  const fourth = selections[i + 3];
+  if (first > third || (first === third && second >= fourth)) {
+    return [third, fourth, first, second, 1]
+  }
+  return [first, second, third, fourth, 0]
+};
+
 const getSelectionFromChange = (change) => {
   const { start, inserted, end } = change;
   const startRowIndex = start.rowIndex;
@@ -13521,7 +13494,7 @@ const getX = (
   halfCursorWidth,
   width,
   averageCharWidth,
-  difference = 0
+  difference = 0,
 ) => {
   if (!line) {
     return 0
@@ -13557,17 +13530,6 @@ const getY = (row, minLineY, rowHeight) => {
 
 const emptyCursors = new Float32Array();
 
-const getPairs = (selections, i) => {
-  const first = selections[i];
-  const second = selections[i + 1];
-  const third = selections[i + 2];
-  const fourth = selections[i + 3];
-  if (first > third || (first === third && second >= fourth)) {
-    return [third, fourth, first, second, 1]
-  }
-  return [first, second, third, fourth, 0]
-};
-
 const getVisible$4 = (editor) => {
   const visibleCursors = [];
   const visibleSelections = [];
@@ -13591,10 +13553,14 @@ const getVisible$4 = (editor) => {
     charWidth,
     isMonospaceFont,
   } = editor;
+
   const averageCharWidth = charWidth;
   const halfCursorWidth = cursorWidth / 2;
   for (let i = 0; i < selections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getPairs(selections, i);
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(
+      selections,
+      i,
+    );
     if (selectionEndRow < minLineY || selectionStartRow > maxLineY) {
       continue
     }
@@ -13613,7 +13579,7 @@ const getVisible$4 = (editor) => {
       halfCursorWidth,
       width,
       averageCharWidth,
-      endLineDifference
+      endLineDifference,
     );
     const endLineY = getY(selectionEndRow, minLineY, rowHeight);
     if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
@@ -13636,9 +13602,11 @@ const getVisible$4 = (editor) => {
         halfCursorWidth,
         width,
         averageCharWidth,
-        startLineDifference
+        startLineDifference,
       );
-      if (endLineEndX >= 0) {
+      if (reversed) {
+        visibleCursors.push(startX, endLineY);
+      } else if (endLineEndX >= 0) {
         visibleCursors.push(endLineEndX, endLineY);
       }
       const selectionWidth = endLineEndX - startX;
@@ -13658,7 +13626,7 @@ const getVisible$4 = (editor) => {
           halfCursorWidth,
           width,
           averageCharWidth,
-          startLineDifference
+          startLineDifference,
         );
         const startLineEndX = getX(
           startLine,
@@ -13672,7 +13640,7 @@ const getVisible$4 = (editor) => {
           halfCursorWidth,
           width,
           averageCharWidth,
-          startLineDifference
+          startLineDifference,
         );
         const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
         const selectionWidth = startLineEndX - startLineStartX;
@@ -13700,7 +13668,7 @@ const getVisible$4 = (editor) => {
           halfCursorWidth,
           width,
           averageCharWidth,
-          difference
+          difference,
         );
         visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
       }
@@ -15464,6 +15432,8 @@ const Rejected = 'rejected';
 
 const ClipBoardWriteText = 'ClipBoard.writeText';
 
+const RE_CHARACTERS = /^[a-zA-Z\.\-]+$/;
+
 const compareString = (a, b) => {
   return a.localeCompare(b)
 };
@@ -15475,6 +15445,9 @@ const compareString = (a, b) => {
  * @returns boolean
  */
 const compareStringNumeric = (a, b) => {
+  if (RE_CHARACTERS.test(a) && RE_CHARACTERS.test(b)) {
+    return a < b ? -1 : 1
+  }
   return a.localeCompare(b, 'en', { numeric: true })
 };
 
@@ -15869,7 +15842,7 @@ const getSavedRoot = (savedState, workspacePath) => {
 };
 
 const loadContent$t = async (state, savedState) => {
-  const root = getSavedRoot(savedState, state$F.workspacePath);
+  const root = getSavedRoot(savedState, state$E.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -15913,7 +15886,7 @@ const handleLanguagesChanged = (state) => {
 };
 
 const handleWorkspaceChange = async (state) => {
-  const newRoot = state$F.workspacePath;
+  const newRoot = state$E.workspacePath;
   const state1 = { ...state, root: newRoot };
   const newState = await loadContent$t(state1);
   return newState
@@ -17141,7 +17114,7 @@ const getId$1 = (extension) => {
 };
 
 const install$1 = (id) => {
-  return invoke$2(InstallExtensionInstallExtension, /* id */ id)
+  return invoke$1(InstallExtensionInstallExtension, /* id */ id)
 };
 
 const install = (id) => {
@@ -17149,22 +17122,22 @@ const install = (id) => {
 };
 
 const uninstall = (id) => {
-  return invoke$2(/* ExtensionManagement.uninstall */ 'ExtensionManagement.uninstall', /* id */ id)
+  return invoke$1(/* ExtensionManagement.uninstall */ 'ExtensionManagement.uninstall', /* id */ id)
 };
 
 const disable = async (id) => {
-  return invoke$2(/* ExtensionManagement.disable */ 'ExtensionManagement.disable', /* id */ id)
+  return invoke$1(/* ExtensionManagement.disable */ 'ExtensionManagement.disable', /* id */ id)
 };
 
 const enable = async (id) => {
-  return invoke$2(/* ExtensionManagement.enable */ 'ExtensionManagement.enable', /* id */ id)
+  return invoke$1(/* ExtensionManagement.enable */ 'ExtensionManagement.enable', /* id */ id)
 };
 
 const getAllExtensions = async () => {
   if (platform === Web$1) {
     return []
   }
-  return invoke$2(/* ExtensionManagement.getAllExtensions */ 'ExtensionManagement.getAllExtensions')
+  return invoke$1(/* ExtensionManagement.getAllExtensions */ 'ExtensionManagement.getAllExtensions')
 };
 
 const getExtension = async (id) => {
@@ -19587,7 +19560,7 @@ const dispose$l = () => {};
 
 // TODO show error / warning  when installment fails / times out
 const handleInstall = async (state, id) => {
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19598,7 +19571,7 @@ const handleInstall = async (state, id) => {
     await install(/* id */ id);
   } catch (error) {
     // TODO have multi send command
-    await invoke$3(
+    await invoke$2(
       /* viewletSend */ 'Viewlet.send',
       /* id */ Extensions$1,
       /* method */ 'setExtensionState',
@@ -19609,7 +19582,7 @@ const handleInstall = async (state, id) => {
     handleError$3(error);
     return
   }
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19620,7 +19593,7 @@ const handleInstall = async (state, id) => {
 
 // TODO lazyload this
 const handleUninstall = async (state, id) => {
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19630,7 +19603,7 @@ const handleUninstall = async (state, id) => {
   try {
     await uninstall(id);
   } catch (error) {
-    await invoke$3(
+    await invoke$2(
       /* viewletSend */ 'Viewlet.send',
       /* id */ Extensions$1,
       /* method */ 'setExtensionState',
@@ -19640,7 +19613,7 @@ const handleUninstall = async (state, id) => {
     handleError$3(error);
     return
   }
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19654,7 +19627,7 @@ const handleEnable = async (state, id) => {
   try {
     await enable(id);
   } catch (error) {
-    await invoke$3(
+    await invoke$2(
       /* viewletSend */ 'Viewlet.send',
       /* id */ Extensions$1,
       /* method */ 'setExtensionState',
@@ -19664,7 +19637,7 @@ const handleEnable = async (state, id) => {
     handleError$3(error);
     return
   }
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19682,7 +19655,7 @@ const handleDisable = async (state, id) => {
     handleError$3(error);
     return
   }
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'setExtensionState',
@@ -19694,7 +19667,7 @@ const handleDisable = async (state, id) => {
 const openSuggest = async (state) => {
   const filteredSuggestions = SUGGESTIONS;
   state.suggestionState = /* Open */ 1;
-  await invoke$3(
+  await invoke$2(
     /* viewletSend */ 'Viewlet.send',
     /* id */ Extensions$1,
     /* method */ 'openSuggest',
@@ -19704,7 +19677,7 @@ const openSuggest = async (state) => {
 
 const closeSuggest = async (state) => {
   state.suggestionState = /* Closed */ 0;
-  await invoke$3(/* viewletSend */ 'Viewlet.send', /* id */ Extensions$1, /* method */ 'closeSuggest');
+  await invoke$2(/* viewletSend */ 'Viewlet.send', /* id */ Extensions$1, /* method */ 'closeSuggest');
 };
 
 const toggleSuggest = async (state) => {
@@ -22088,7 +22061,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$2('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -23559,7 +23532,7 @@ const loadContent$l = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$3('Viewlet.loadModule', MainTabs);
+  await invoke$2('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -23644,7 +23617,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$3(
+  await invoke$2(
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ Main$1,
     /* method */ 'openViewlet',
@@ -23669,7 +23642,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
 
   state.editors.push({ uri });
   add(uri, { uri, title, ...props });
-  await invoke$3('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$2('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state
 };
@@ -24226,11 +24199,11 @@ const ViewletNoop_ipc = {
 };
 
 const open$9 = async (id, file) => {
-  await invoke$2(/* OutputChannel.open */ 'OutputChannel.open', id, /* path */ file);
+  await invoke$1(/* OutputChannel.open */ 'OutputChannel.open', id, /* path */ file);
 };
 
 const close$4 = async (id) => {
-  await invoke$2(/* OutputChannel.close */ 'OutputChannel.close', /* id */ id);
+  await invoke$1(/* OutputChannel.close */ 'OutputChannel.close', /* id */ id);
 };
 
 const STATUS_OFF = 0;
@@ -24356,7 +24329,7 @@ const contentLoaded$3 = async (state) => {
 const setOutputChannel = async (state, option) => {
   state.selectedOption = option;
   // TODO race condition
-  await invoke$3(/* viewletSend */ 'Viewlet.send', /* id */ 'Output', /* method */ 'clear');
+  await invoke$2(/* viewletSend */ 'Viewlet.send', /* id */ 'Output', /* method */ 'clear');
   // TODO race condition
   // TODO should use invoke
   await open$9('Output', state.selectedOption);
@@ -24632,7 +24605,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     commands.unshift(...disposeFunctional(currentViewletUid));
     const actions = getActions$5(id);
     commands.push(['Viewlet.send', uid, 'setActions', actions]);
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$2('Viewlet.sendMultiple', commands);
     if (commands[commands.length - 1].includes(Error$2)) {
       state.currentViewletId = Error$2;
     }
@@ -26820,19 +26793,19 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async (options) => {
-  const sources = await invoke$2('DesktopCapturer.getSources', options);
+  const sources = await invoke$1('DesktopCapturer.getSources', options);
   return sources
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$3('ScreenCapture.start', captureId, options);
+  await invoke$2('ScreenCapture.start', captureId, options);
 };
 
 const dispose$a = async (captureId) => {
   number(captureId);
-  await invoke$3('ScreenCapture.dispose', captureId);
+  await invoke$2('ScreenCapture.dispose', captureId);
 };
 
 const create$g = (id, uri) => {
@@ -27083,7 +27056,7 @@ const handleUpdate = async (state, update) => {
         message: '',
       }
     }
-    const root = state$F.workspacePath;
+    const root = state$E.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -27757,7 +27730,7 @@ const openViewlet = async (state, moduleId, focus = false) => {
     }
     const actions = getActions$5(moduleId);
     commands.push(['Viewlet.send', uid, 'setActions', actions]);
-    await invoke$3('Viewlet.sendMultiple', commands);
+    await invoke$2('Viewlet.sendMultiple', commands);
     state.actions = actions;
   }
 
@@ -28764,7 +28737,7 @@ const getNewButtons = async (displayItems, providerId, buttonIndex) => {
 };
 
 const loadContent$9 = async (state) => {
-  const root = state$F.workspacePath;
+  const root = state$E.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const { allGroups, gitRoot } = await getGroups(enabledProviderIds);
@@ -29248,7 +29221,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$2('GetTerminalSpawnOptions.getTerminalSpawnOptions')
+  return invoke$1('GetTerminalSpawnOptions.getTerminalSpawnOptions')
 };
 
 const listen$1 = (method) => {
@@ -29291,7 +29264,7 @@ const listen = async () => {
 };
 
 const invoke = (method, ...params) => {
-  return invoke$4(state$i.ipc, method, ...params)
+  return invoke$3(state$i.ipc, method, ...params)
 };
 
 const send = (method, ...params) => {
@@ -29306,7 +29279,7 @@ const create$9 = async (separateConnection, id, cwd, command, args) => {
     await listen();
     await invoke('Terminal.create', id, cwd, command, args);
   } else {
-    await invoke$2('Terminal.create', id, cwd, command, args);
+    await invoke$1('Terminal.create', id, cwd, command, args);
   }
 };
 
@@ -29314,7 +29287,7 @@ const dispose$4 = async (id) => {
   if (_separateConnection) {
     await invoke('Terminal.dispose', id);
   } else {
-    await invoke$2('Terminal.dispose', id);
+    await invoke$1('Terminal.dispose', id);
   }
 };
 
@@ -29322,7 +29295,7 @@ const write$1 = async (id, input) => {
   if (_separateConnection) {
     await send('Terminal.write', id, input);
   } else {
-    await invoke$2('Terminal.write', id, input);
+    await invoke$1('Terminal.write', id, input);
   }
 };
 
@@ -29330,7 +29303,7 @@ const resize$6 = async (id, columns, rows) => {
   if (_separateConnection) {
     await invoke('Terminal.resize', id, columns, rows);
   } else {
-    await invoke$2('Terminal.resize', id, columns, rows);
+    await invoke$1('Terminal.resize', id, columns, rows);
   }
 };
 
@@ -29380,13 +29353,13 @@ const loadContent$6 = async (state) => {
 
 const contentLoadedEffects = async (state) => {
   const { uid, separateConnection, command, args } = state;
-  await create$9(separateConnection, uid, state$F.workspacePath, command, args);
+  await create$9(separateConnection, uid, state$E.workspacePath, command, args);
 };
 
 const handleData$1 = async (state, data) => {
   const { uid } = state;
   const parsedData = toUint8Array(data);
-  await invoke$3(/* Viewlet.send */ 'Viewlet.send', /* id */ uid, /* method */ 'write', /* data */ parsedData);
+  await invoke$2(/* Viewlet.send */ 'Viewlet.send', /* id */ uid, /* method */ 'write', /* data */ parsedData);
 };
 
 const write = async (state, input) => {
@@ -29425,7 +29398,7 @@ const resizeEffect = async (state) => {
 };
 
 const clear = async (state) => {
-  await invoke$3(/* ViewletTerminal.write */ 'Terminal.write', /* data */ new TextEncoder().encode('TODO clear terminal'));
+  await invoke$2(/* ViewletTerminal.write */ 'Terminal.write', /* data */ new TextEncoder().encode('TODO clear terminal'));
 };
 
 // prettier-ignore
@@ -29575,7 +29548,7 @@ const addTerminal = async (state) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$2('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -29608,7 +29581,7 @@ const focusIndex$8 = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$2('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index,
@@ -45366,7 +45339,7 @@ const copy$2 = () => {
 
 const readText = async () => {
   try {
-    return await invoke$3('ClipBoard.readText')
+    return await invoke$2('ClipBoard.readText')
   } catch (error) {
     // @ts-ignore
     if (error.message === 'Read permission denied.') {
@@ -45389,7 +45362,7 @@ const readText = async () => {
 const writeText$1 = async (text) => {
   try {
     string(text);
-    await invoke$3('ClipBoard.writeText', /* text */ text);
+    await invoke$2('ClipBoard.writeText', /* text */ text);
   } catch (error) {
     throw new VError(error, 'Failed to write text to clipboard')
   }
@@ -45400,7 +45373,7 @@ const writeNativeFiles = async (type, files) => {
     if (platform === Web$1) {
       throw new Error('not supported')
     }
-    await invoke$2(
+    await invoke$1(
       /* command */ 'ClipBoard.writeFiles',
       /* type */ type,
       /* files */ files
@@ -45415,7 +45388,7 @@ const readNativeFiles = async () => {
     if (platform === Web$1) {
       throw new Error('not supported')
     }
-    return await invoke$2(/* command */ 'ClipBoard.readFiles')
+    return await invoke$1(/* command */ 'ClipBoard.readFiles')
   } catch (error) {
     throw new VError(error, 'Failed to read files from native clipboard')
   }
@@ -45423,7 +45396,7 @@ const readNativeFiles = async () => {
 
 const writeImage = async (blob) => {
   try {
-    return await invoke$3('ClipBoard.writeImage', blob)
+    return await invoke$2('ClipBoard.writeImage', blob)
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard')
   }
@@ -45431,18 +45404,18 @@ const writeImage = async (blob) => {
 
 const execCopy = async () => {
   try {
-    return await invoke$3('ClipBoard.execCopy')
+    return await invoke$2('ClipBoard.execCopy')
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text')
   }
 };
 
 const getProductNameLong = () => {
-  return invoke$2('Platform.getProductNameLong')
+  return invoke$1('Platform.getProductNameLong')
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$2('ElectronDialog.showOpenDialog', title, properties)
+  return invoke$1('ElectronDialog.showOpenDialog', title, properties)
 };
 
 const showMessageBox = async (options) => {
@@ -45453,7 +45426,7 @@ const showMessageBox = async (options) => {
     ...options,
     productName,
   };
-  return invoke$2('ElectronDialog.showMessageBox', finalOptions)
+  return invoke$1('ElectronDialog.showMessageBox', finalOptions)
 };
 
 const Info = 'info';
@@ -45769,39 +45742,39 @@ const formatAboutDate = (isoDate) => {
 };
 
 const getPid = () => {
-  return invoke$2('Process.getPid')
+  return invoke$1('Process.getPid')
 };
 
 const getElectronVersion = () => {
-  return invoke$2('ElectronProcess.getElectronVersion')
+  return invoke$1('ElectronProcess.getElectronVersion')
 };
 
 const getNodeVersion = () => {
-  return invoke$2('Process.getNodeVersion')
+  return invoke$1('Process.getNodeVersion')
 };
 
 const getChromeVersion = () => {
-  return invoke$2('ElectronProcess.getChromeVersion')
+  return invoke$1('ElectronProcess.getChromeVersion')
 };
 
 const getVersion = () => {
-  return invoke$2('Platform.getVersion')
+  return invoke$1('Platform.getVersion')
 };
 
 const getCommit = () => {
-  return invoke$2('Platform.getCommit')
+  return invoke$1('Platform.getCommit')
 };
 
 const getV8Version = () => {
-  return invoke$2('Process.getV8Version')
+  return invoke$1('Process.getV8Version')
 };
 
 const getDate = () => {
-  return invoke$2('Platform.getDate')
+  return invoke$1('Platform.getDate')
 };
 
 const getArch = () => {
-  return invoke$2('Process.getArch')
+  return invoke$1('Process.getArch')
 };
 
 const getDetailString = async () => {
@@ -45894,7 +45867,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$3(/* Audio.play */ 3211, /* src */ src);
+  await invoke$2(/* Audio.play */ 3211, /* src */ src);
 };
 
 const name$16 = 'Audio';
@@ -45943,11 +45916,11 @@ const promptRestart = () => {
 };
 
 const getAutoUpdateType = () => {
-  return invoke$2('AutoUpdater.getAutoUpdateType')
+  return invoke$1('AutoUpdater.getAutoUpdateType')
 };
 
 const getLatestVersion = () => {
-  return invoke$2('AutoUpdater.getLatestVersion')
+  return invoke$1('AutoUpdater.getLatestVersion')
 };
 
 const checkForUpdates = async () => {
@@ -46326,7 +46299,7 @@ const applyBulkReplacement = async (files, ranges, replacement) => {
   array(files);
   array(ranges);
   string(replacement);
-  await invoke$2('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$1('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const name$12 = 'BulkReplacement';
@@ -46780,7 +46753,7 @@ const prompt$3 = async (message, confirmMessage, title, cancelMessage) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$3('ConfirmPrompt.prompt', message);
+  const result = await invoke$2('ConfirmPrompt.prompt', message);
   return result
 };
 
@@ -46812,22 +46785,22 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = (options) => {
-  return invoke$2('ElectronContentTracing.startRecording', options)
+  return invoke$1('ElectronContentTracing.startRecording', options)
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$2('ElectronContentTracing.stopRecording')
+  return invoke$1('ElectronContentTracing.stopRecording')
 };
 
 const showItemInFolder = (fullPath) => {
-  return invoke$2('OpenExternal.showItemInFolder', fullPath)
+  return invoke$1('OpenExternal.showItemInFolder', fullPath)
 };
 
 const openExternal$2 = (url) => {
-  return invoke$2('OpenExternal.openExternal', url)
+  return invoke$1('OpenExternal.openExternal', url)
 };
 
 const openNativeFolderWeb = (absolutePath) => {
@@ -46836,7 +46809,7 @@ const openNativeFolderWeb = (absolutePath) => {
 
 const openNativeFolderRemote = async (absolutePath) => {
   try {
-    await invoke$2(OpenNativeFolder, /* path */ absolutePath);
+    await invoke$1(OpenNativeFolder, /* path */ absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`)
   }
@@ -46927,7 +46900,7 @@ const ContextMenu_ipc = {
 
 const attachDebugger = async (pid) => {
   number(pid);
-  await invoke$2('AttachDebugger.attachDebugger', pid);
+  await invoke$1('AttachDebugger.attachDebugger', pid);
 };
 
 const debugSharedProcess = async () => {
@@ -46948,11 +46921,11 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$2('Crash.crashSharedProcess')
+  return invoke$1('Crash.crashSharedProcess')
 };
 
 const crashMainProcess = () => {
-  return invoke$2('Crash.crashMainProcess')
+  return invoke$1('Crash.crashMainProcess')
 };
 
 const openConfigFolder = async () => {
@@ -46966,7 +46939,7 @@ const openCacheFolder = async () => {
 };
 
 const openDataFolder = async () => {
-  const dataFolder = await invoke$2(/* Platform.getDataDir */ 'Platform.getDataDir');
+  const dataFolder = await invoke$1(/* Platform.getDataDir */ 'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 
@@ -47310,7 +47283,7 @@ const getNodeTiming = () => {
   if (platform === Web$1) {
     return undefined
   }
-  return invoke$2(/* command */ 'Performance.getNodeStartupTiming')
+  return invoke$1(/* command */ 'Performance.getNodeStartupTiming')
 };
 
 const getMeasureEntries = () => {
@@ -47406,15 +47379,15 @@ const formatRendererProcessData = ({ memoryUsage }) => {
 };
 
 const getSharedProcessMemoryUsage = () => {
-  return invoke$2(/* Developer.sharedProcessMemoryUsage */ 'Developer.sharedProcessMemoryUsage')
+  return invoke$1(/* Developer.sharedProcessMemoryUsage */ 'Developer.sharedProcessMemoryUsage')
 };
 
 const getPerformanceMemory = () => {
-  return invoke$3('Performance.getMemory')
+  return invoke$2('Performance.getMemory')
 };
 
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$3('Performance.measureUserAgentSpecificMemory')
+  return invoke$2('Performance.measureUserAgentSpecificMemory')
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -47422,8 +47395,8 @@ const getMemoryUsageContent = async () => {
   const sharedProcessMemoryUsage = await getSharedProcessMemoryUsage();
   const formattedSharedProcessMemoryUsage = formatNodeMemoryUsage(sharedProcessMemoryUsage);
   const userAgentSpecificMemory = await getPerformanceUserAgentSpecificMemory();
-  const totalSent = state$P.totalSent;
-  const totalReceived = state$P.totalReceived;
+  const totalSent = state$O.totalSent;
+  const totalReceived = state$O.totalReceived;
   const formattedRendererWorkerMemoryUsage = formatRendererWorkerData({
     userAgentSpecificMemory,
     sent: totalSent,
@@ -47468,15 +47441,15 @@ const showMemoryUsage = () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$2(/* Developer.allocateMemoryInSharedProcess */ 'Developer.allocateMemoryInSharedProcess')
+  return invoke$1(/* Developer.allocateMemoryInSharedProcess */ 'Developer.allocateMemoryInSharedProcess')
 };
 
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$2(/* Developer.createSharedProcessHeapSnapshot */ 'Developer.createSharedProcessHeapSnapshot');
+  await invoke$1(/* Developer.createSharedProcessHeapSnapshot */ 'Developer.createSharedProcessHeapSnapshot');
 };
 
 const createSharedProcessProfile = async () => {
-  await invoke$2(/* Developer.createProfile */ 'Developer.createProfile');
+  await invoke$1(/* Developer.createProfile */ 'Developer.createProfile');
 };
 
 const reloadIconTheme = async () => {
@@ -47674,13 +47647,13 @@ const Dialog_ipc = {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$3(/* Download.downloadFile */ 'Download.downloadFile', /* fileName */ fileName, /* url */ url);
+  await invoke$2(/* Download.downloadFile */ 'Download.downloadFile', /* fileName */ fileName, /* url */ url);
 };
 
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$2(DownloadDownload, /* url */ url, /* outFile */ outFile);
+  await invoke$1(DownloadDownload, /* url */ url, /* outFile */ outFile);
 };
 
 const downloadJson = async (json, fileName) => {
@@ -47702,7 +47675,7 @@ const downloadJson = async (json, fileName) => {
 const downloadUrl = (url, outFile) => {
   string(url);
   string(outFile);
-  return invoke$2('Download.download', url, outFile)
+  return invoke$1('Download.download', url, outFile)
 };
 
 const name$Q = 'Download';
@@ -47755,7 +47728,7 @@ const EditorDiagnostics_ipc = {
 const show$4 = async (editor, message, rowIndex, columnIndex) => {
   const x$1 = x(editor, rowIndex, columnIndex);
   const y$1 = y(editor, rowIndex);
-  await invoke$3(
+  await invoke$2(
     /* EditorError.show */ 'EditorError.show',
     /* message */ message,
     /* x */ x$1,
@@ -47832,7 +47805,7 @@ const open$6 = async (editor) => {
     const y$1 = y(editor, rowIndex);
     // const prepareRenameResult = await prepareRename(editor)
     // console.log({ prepareRenameResult })
-    await invoke$3(/* EditorRename.openWidget */ 4512, /* x */ x$1, /* y */ y$1);
+    await invoke$2(/* EditorRename.openWidget */ 4512, /* x */ x$1, /* y */ y$1);
   } else {
     // TODO also show error when promise rejects
     await execute$5(
@@ -47877,7 +47850,7 @@ const finish = async (editor) => {
   // TODO what happens when file is closed while rename is in progress?
   const rowIndex = editor.selections[0];
   const columnIndex = editor.selections[1];
-  await invoke$3(/* EditorRename.finish */ 4513);
+  await invoke$2(/* EditorRename.finish */ 4513);
   // TODO support canceling rename (e.g. when user presses escape)
   const workspaceEdits = await rename$1(editor, rowIndex, columnIndex);
   await applyWorkspaceEdits(editor, workspaceEdits);
@@ -47887,7 +47860,7 @@ const finish = async (editor) => {
 };
 
 const abort = async () => {
-  await invoke$3(/* EditorRename.closeWidget */ 4514);
+  await invoke$2(/* EditorRename.closeWidget */ 4514);
 };
 
 const name$O = 'EditorRename';
@@ -48077,7 +48050,7 @@ const state$f = {
 
 const setItems = async (items) => {
   const windowId = await getWindowId();
-  return invoke$2('ElectronApplicationMenu.setItems', windowId, items)
+  return invoke$1('ElectronApplicationMenu.setItems', windowId, items)
 };
 
 const getEntries = (ids) => {
@@ -48151,7 +48124,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = (text) => {
-  return invoke$2('ElectronClipBoard.writeText', text)
+  return invoke$1('ElectronClipBoard.writeText', text)
 };
 
 const name$M = 'ElectronClipBoard';
@@ -48197,7 +48170,7 @@ const openContextMenu$1 = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$o(id, ...args);
   state$e.pendingMenus = entries;
   const electronMenuItems = convertMenuItems(entries);
-  return invoke$2('ElectronContextMenu.openContextMenu', electronMenuItems, x, y)
+  return invoke$1('ElectronContextMenu.openContextMenu', electronMenuItems, x, y)
 };
 
 const handleMenuClose = () => {
@@ -48274,7 +48247,7 @@ const ErrorHandling_ipc = {
  * should only be used for testing
  */
 const evalInRendererProcess$1 = (code) => {
-  return invoke$3('Eval.evalCode', code)
+  return invoke$2('Eval.evalCode', code)
 };
 
 const name$I = 'Eval';
@@ -48290,7 +48263,7 @@ const Eval_ipc = {
 };
 
 const exit = () => {
-  return invoke$2('Exit.exit')
+  return invoke$1('Exit.exit')
 };
 
 const name$H = 'Exit';
@@ -48358,7 +48331,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async (options) => {
   try {
-    return await invoke$3(
+    return await invoke$2(
       'FilePicker.showDirectoryPicker',
       options
     )
@@ -48375,12 +48348,12 @@ const showDirectoryPicker = async (options) => {
 };
 
 const showFilePicker = (options) => {
-  return invoke$3('FilePicker.showFilePicker', options)
+  return invoke$2('FilePicker.showFilePicker', options)
 };
 
 const showSaveFilePicker = async (options) => {
   try {
-    return await invoke$3(
+    return await invoke$2(
       'FilePicker.showSaveFilePicker',
       options
     )
@@ -48504,7 +48477,7 @@ const show$3 = async (uri, top, left) => {
     if (version !== state$d.versionId) {
       return
     }
-    await invoke$3(
+    await invoke$2(
       /* Viewlet.hydrate */ 3028,
       /* id */ 'ImagePreview',
       /* imageUrl */ blobUrl,
@@ -48513,7 +48486,7 @@ const show$3 = async (uri, top, left) => {
     );
   } catch (error) {
     console.error(error);
-    await invoke$3(
+    await invoke$2(
       /* Viewlet.hydrate */ 3028,
       /* id */ 'ImagePreview',
       /* message */ 'Image could not be loaded',
@@ -48525,7 +48498,7 @@ const show$3 = async (uri, top, left) => {
 
 const hide$1 = async () => {
   ++state$d.versionId;
-  await invoke$3(
+  await invoke$2(
     /* Viewlet.dispose */ 'Viewlet.dispose',
     /* id */ 'ImagePreview'
   );
@@ -48804,7 +48777,7 @@ const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
     x: bounds.x,
     y: bounds.y,
   });
-  await invoke$3(
+  await invoke$2(
     /* Menu.show */ 'Menu.showMenu',
     /* x */ bounds.x,
     /* y */ bounds.y,
@@ -48835,7 +48808,7 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   });
   const width = getMenuWidth();
   const height = getMenuHeight(subMenuItems);
-  invoke$3(
+  invoke$2(
     /* Menu.showMenu */ 'Menu.showMenu',
     /* x */ subMenu.x,
     /* y */ subMenu.y,
@@ -48914,7 +48887,7 @@ const hide = async (restoreFocus = true) => {
     return
   }
   state$b.menus = [];
-  await invoke$3(/* Menu.hide */ 'Menu.hide', /* restoreFocus */ restoreFocus);
+  await invoke$2(/* Menu.hide */ 'Menu.hide', /* restoreFocus */ restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -48924,7 +48897,7 @@ const hide = async (restoreFocus = true) => {
 const hideSubMenus = async (level) => {
   if (level < state$b.menus.length) {
     state$b.menus = state$b.menus.slice(0, level + 1);
-    await invoke$3(/* Menu.hideSubMenu */ 'Menu.hideSubMenu', /* level */ level + 1);
+    await invoke$2(/* Menu.hideSubMenu */ 'Menu.hideSubMenu', /* level */ level + 1);
   }
 };
 
@@ -48973,7 +48946,7 @@ const handleMouseLeave = async () => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = -1;
-  await invoke$3(
+  await invoke$2(
     /* Menu.focusIndex */ 'Menu.focusIndex',
     /* level */ menu.level,
     /* oldFocusedIndex */ oldFocusedIndex,
@@ -48987,7 +48960,7 @@ const focusIndex$7 = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  await invoke$3(
+  await invoke$2(
     /* Menu.focusIndex */ 'Menu.focusIndex',
     /* level */ menu.level,
     /* oldFocusedIndex */ oldFocusedIndex,
@@ -49260,27 +49233,27 @@ const state$9 = {
 };
 
 const focusActivityBar = async () => {
-  await invoke$3(/* ActivityBar.focus */ 717115);
+  await invoke$2(/* ActivityBar.focus */ 717115);
 };
 
 const focusStatusBar = async () => {
-  await invoke$3(/* StatusBar.focus */ 8882);
+  await invoke$2(/* StatusBar.focus */ 8882);
 };
 
 const focusPanel = async () => {
-  await invoke$3(/* Panel.focus */ 6664);
+  await invoke$2(/* Panel.focus */ 6664);
 };
 
 const focusSideBar = async () => {
-  await invoke$3(/* SideBar.focus */ 5554);
+  await invoke$2(/* SideBar.focus */ 5554);
 };
 
 const focusTitleBar = async () => {
-  await invoke$3(/* TitleBar.focus */ 1331);
+  await invoke$2(/* TitleBar.focus */ 1331);
 };
 
 const focusMain = async () => {
-  await invoke$3(/* Main.focus */ 2145);
+  await invoke$2(/* Main.focus */ 2145);
 };
 
 const focusPart = (part) => {
@@ -49398,7 +49371,7 @@ const state$8 = {
 
 const create$1 = async (type, text) => {
   state$8.notifications.push({ type, text });
-  await invoke$3(
+  await invoke$2(
     /* Notification.create */ 'Notification.create',
     /* type */ type,
     /* text */ text
@@ -49408,7 +49381,7 @@ const create$1 = async (type, text) => {
 const showWithOptions = async (type, text, options) => {
   state$8.notifications.push({ type, text, options });
   console.log({ type, text, options });
-  await invoke$3(
+  await invoke$2(
     /* Notification.createWithOptions */ 993,
     /* type */ type,
     /* text */ text,
@@ -49427,7 +49400,7 @@ const handleClick$8 = (index) => {
 };
 
 const dispose = async (id) => {
-  await invoke$3(
+  await invoke$2(
     /* Notification.dispose */ 'Notification.dispose',
     /* id */ id
   );
@@ -49450,7 +49423,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async (url) => {
   try {
-    await invoke$3(/* Open.openUrl */ 'Open.openUrl', /* url */ url);
+    await invoke$2(/* Open.openUrl */ 'Open.openUrl', /* url */ url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`)
   }
@@ -49528,7 +49501,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$3('Prompt.prompt', message, defaultValue)
+  return invoke$2('Prompt.prompt', message, defaultValue)
 };
 
 const name$j = 'Prompt';
@@ -49544,7 +49517,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$2('RebuildNodePty.rebuildNodePty');
+  await invoke$1('RebuildNodePty.rebuildNodePty');
 };
 
 const name$i = 'RebuildNodePty';
@@ -49576,11 +49549,11 @@ const RecentlyOpened_ipc = {
 };
 
 const reloadWeb = () => {
-  return invoke$3('Window.reload')
+  return invoke$2('Window.reload')
 };
 
 const reloadRemote = () => {
-  return invoke$3('Window.reload')
+  return invoke$2('Window.reload')
 };
 
 const reloadElectron = () => {
@@ -49770,7 +49743,7 @@ const executeTest = async (name, fn, globals = {}) => {
     text = `test passed in ${_formattedDuration}`;
     state = Pass;
   }
-  await invoke$3('TestFrameWork.showOverlay', state, background, text);
+  await invoke$2('TestFrameWork.showOverlay', state, background, text);
 };
 
 const exposeGlobals = (global, object) => {
@@ -49812,7 +49785,7 @@ const Locator = function (selector, { nth = -1, hasText = '' } = {}) {
 };
 
 const performAction = async (locator, fnName, options) => {
-  return invoke$3('TestFrameWork.performAction', locator, fnName, options)
+  return invoke$2('TestFrameWork.performAction', locator, fnName, options)
 };
 
 const toButtonNumber = (buttonType) => {
@@ -49885,7 +49858,7 @@ test.skip = async (id, fn) => {
   const state = 'skip';
   const background = 'yellow';
   const text = `test skipped ${id}`;
-  await invoke$3(
+  await invoke$2(
     'TestFrameWork.showOverlay',
     state,
     background,
@@ -49910,7 +49883,7 @@ const expect = (locator) => {
   return {
     async checkSingleElementCondition(fnName, options) {
       Assert.string(fnName);
-      return invoke$3(
+      return invoke$2(
         'TestFrameWork.checkSingleElementCondition',
         locator,
         fnName,
@@ -49918,7 +49891,7 @@ const expect = (locator) => {
       )
     },
     async checkMultiElementCondition(fnName, options) {
-      return invoke$3(
+      return invoke$2(
         'TestFrameWork.checkMultiElementCondition',
         locator,
         fnName,
@@ -50414,7 +50387,7 @@ const press = async (key) => {
     bubbles: true,
     ...keyOptions,
   };
-  await invoke$3(
+  await invoke$2(
     'TestFrameWork.performKeyBoardAction',
     'press',
     options
@@ -51881,12 +51854,7 @@ const EditorCommandCopyLineUp = {
   copyLineUp
 };
 
-const editorGetPositionLeft = (
-  rowIndex,
-  columnIndex,
-  lines,
-  getDelta
-) => {
+const editorGetPositionLeft = (rowIndex, columnIndex, lines, getDelta) => {
   if (columnIndex === 0) {
     if (rowIndex === 0) {
       return { rowIndex: 0, columnIndex: 0 }
@@ -51913,14 +51881,7 @@ const moveRangeToPosition = (selections, i, rowIndex, columnIndex) => {
   selections[i + 1] = selections[i + 3] = columnIndex;
 };
 
-const moveToPositionLeft = (
-  selections,
-  i,
-  rowIndex,
-  columnIndex,
-  lines,
-  getDelta
-) => {
+const moveToPositionLeft = (selections, i, rowIndex, columnIndex, lines, getDelta) => {
   if (columnIndex === 0) {
     if (rowIndex === 0) {
       selections[i] = 0;
@@ -52997,7 +52958,7 @@ const handleMouseMoveWithAltKey = async (editor, x, y) => {
     }
     console.log({ token: tokenIndex });
     // .tokens
-    await invoke$3(
+    await invoke$2(
       /* Viewlet.invoke */ 'Viewlet.send',
       /* id */ EditorText,
       /* method */ 'highlightAsLink',
@@ -54211,7 +54172,7 @@ const handleSelectionChange = (editor, selectionChanges) => {
   console.log({ leadingWord });
   const x$1 = x(editor);
   const y$1 = y(editor, editor.cursor);
-  invoke$3(
+  invoke$2(
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ 'EditorCompletion',
     /* method */ 'show',
@@ -54244,7 +54205,7 @@ const openCompletion$1 = async (editor, openingReason = 1) => {
   if (editor.completionUid !== completionUid) {
     return editor
   }
-  await invoke$3('Viewlet.sendMultiple', commands);
+  await invoke$2('Viewlet.sendMultiple', commands);
   return editor
 
   // if (state.isOpened) {
@@ -54330,7 +54291,7 @@ const advance = (word) => {
     return completionItem.includes(word)
   };
   const filteredCompletions = state.completionItems.filter(includesWord);
-  invoke$3(/* EditorCompletion.open */ 836, /* items */ filteredCompletions, /* reason */ state.openingReason);
+  invoke$2(/* EditorCompletion.open */ 836, /* items */ filteredCompletions, /* reason */ state.openingReason);
 };
 
 // export const onDidType = () => {}
@@ -54612,36 +54573,23 @@ const EditorCommandSelectAllOccurrences = {
 const getNewSelections$3 = (selections, lines, getDelta) => {
   const newSelections = clone(selections);
   for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i];
-    const selectionStartColumn = selections[i + 1];
-    const selectionEndRow = selections[i + 2];
-    const selectionEndColumn = selections[i + 3];
-    if (
-      selectionStartRow === selectionEndRow &&
-      selectionStartColumn === selectionEndColumn
-    ) {
-      moveToPositionLeft(
-        newSelections,
-        i,
-        selectionStartRow,
-        selectionStartColumn,
-        lines,
-        getDelta
-      );
-      moveToPositionEqual(
-        newSelections,
-        i + 2,
-        selectionEndRow,
-        selectionEndColumn
-      );
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(
+      selections,
+      i,
+    );
+    if (selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn) {
+      moveToPositionLeft(newSelections, i + 2, selectionStartRow, selectionStartColumn, lines, getDelta);
+      moveToPositionEqual(newSelections, i, selectionEndRow, selectionEndColumn);
+    } else {
+      moveToPositionLeft(newSelections, i + 2, selectionStartRow, selectionStartColumn, lines, getDelta);
+      moveToPositionEqual(newSelections, i, selectionEndRow, selectionEndColumn);
     }
   }
   return newSelections
 };
 
 const editorSelectHorizontalLeft = (editor, getDelta) => {
-  const lines = editor.lines;
-  const selections = editor.selections;
+  const { lines, selections } = editor;
   const newSelections = getNewSelections$3(selections, lines, getDelta);
   return scheduleSelections(editor, newSelections)
 };
@@ -57111,12 +57059,12 @@ const handleDropFilePathSplit = async (state, eventX, eventY, filePath, splitDir
   // const sashOrientation = splitDirection===
   // TODO sash could be horizontal or vertical
   const sashModuleId = getSashModuleId(sashOrientation);
-  await invoke$3('Viewlet.loadModule', sashModuleId);
+  await invoke$2('Viewlet.loadModule', sashModuleId);
   allCommands.push([/* Viewlet.create */ 'Viewlet.create', /* id */ sashModuleId, sashUid]);
   allCommands.push(['Viewlet.setBounds', sashUid, sashX, sashY, sashWidth, sashHeight]);
   allCommands.push(['Viewlet.append', Main$1, sashUid]);
   console.log({ allCommands });
-  await invoke$3(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ allCommands);
+  await invoke$2(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ allCommands);
   return state
 };
 
@@ -57465,7 +57413,7 @@ const getColorThemeNames = async () => {
     const url = `${assetDir}/config/themes.json`;
     return execute$5(/* Ajax.getJson */ 'Ajax.getJson', /* url */ url)
   }
-  return invoke$2(/* ExtensionHost.getColorThemeNames */ 'ExtensionHost.getColorThemeNames')
+  return invoke$1(/* ExtensionHost.getColorThemeNames */ 'ExtensionHost.getColorThemeNames')
 };
 
 /**
@@ -57985,7 +57933,7 @@ const getNoResults = () => {
 };
 
 const getPicks = async (searchValue) => {
-  const workspace = state$F.workspacePath;
+  const workspace = state$E.workspacePath;
   if (!workspace) {
     return []
   }
@@ -57995,7 +57943,7 @@ const getPicks = async (searchValue) => {
 };
 
 const selectPick = async (pick) => {
-  const workspace = state$F.workspacePath;
+  const workspace = state$E.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$5(/* Main.openUri */ 'Main.openUri', /* uri */ absolutePath);
   return {
@@ -58365,7 +58313,7 @@ const textSearch$4 = async (scheme, root, query, options) => {
     ripGrepArgs,
     searchDir: root,
   };
-  const result = await invoke$2(TextSearchSearch, actualOptions);
+  const result = await invoke$1(TextSearchSearch, actualOptions);
   // TODO api is weird
   return result.results
 };
@@ -59859,7 +59807,7 @@ const isAutoUpdateSupported = () => {
   if (platform !== Electron$1) {
     return false
   }
-  return invoke$2('IsAutoUpdateSupported.isAutoUpdateSupported')
+  return invoke$1('IsAutoUpdateSupported.isAutoUpdateSupported')
 };
 
 /**
@@ -61200,12 +61148,12 @@ const ViewletTitleBarMenuBarHandleClick = {
 
 const downloadUpdate$2 = (version) => {
   string(version);
-  return invoke$2('AutoUpdaterAppImage.downloadUpdate', version)
+  return invoke$1('AutoUpdaterAppImage.downloadUpdate', version)
 };
 
 const installAndRestart$2 = (downloadPath) => {
   string(downloadPath);
-  return invoke$2('AutoUpdaterAppImage.installAndRestart', downloadPath)
+  return invoke$1('AutoUpdaterAppImage.installAndRestart', downloadPath)
 };
 
 const AutoUpdaterAppImage = {
@@ -61216,12 +61164,12 @@ const AutoUpdaterAppImage = {
 
 const downloadUpdate$1 = (version) => {
   string(version);
-  return invoke$2('AutoUpdaterWindowsNsis.downloadUpdate', version)
+  return invoke$1('AutoUpdaterWindowsNsis.downloadUpdate', version)
 };
 
 const installAndRestart$1 = (downloadPath) => {
   string(downloadPath);
-  return invoke$2('AutoUpdaterWindowsNsis.installAndRestart', downloadPath)
+  return invoke$1('AutoUpdaterWindowsNsis.installAndRestart', downloadPath)
 };
 
 const AutoUpdaterNsis = {
@@ -61234,7 +61182,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$2('Exec.exec', command, args, options)
+  return invoke$1('Exec.exec', command, args, options)
 };
 
 const getDebArch = (processArch) => {
@@ -61259,7 +61207,7 @@ const getDownloadUrl = (repository, version, applicationName, debArch) => {
 };
 
 const getTmpDir = () => {
-  return invoke$2('Os.getTmpDir')
+  return invoke$1('Os.getTmpDir')
 };
 
 // TODO remove this code when auto update through apt is supported
@@ -61324,7 +61272,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$2('ElectronWindowProcessExplorer.open');
+    await invoke$1('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, `Failed to open process explorer`)
   }
@@ -61566,15 +61514,15 @@ const set = async (cacheKey, value) => {
 };
 
 const gitLsFiles = (gitPath, cwd, limit) => {
-  return invoke$2('GitLsFiles.gitLsFiles', gitPath, cwd, limit)
+  return invoke$1('GitLsFiles.gitLsFiles', gitPath, cwd, limit)
 };
 
 const gitLsFilesHash = (gitPath, cwd, limit) => {
-  return invoke$2('GitLsFiles.gitLsFilesHash', gitPath, cwd, limit)
+  return invoke$1('GitLsFiles.gitLsFilesHash', gitPath, cwd, limit)
 };
 
 const resolveGit$1 = () => {
-  return invoke$2('GitLsFiles.resolveGit')
+  return invoke$1('GitLsFiles.resolveGit')
 };
 
 const state$1 = {
@@ -61639,7 +61587,7 @@ const SearchFileMemfs = {
 };
 
 const removeLeadingSlash = (path) => {
-  const workspacePath = state$F.workspacePath;
+  const workspacePath = state$E.workspacePath;
   return path.slice(workspacePath.length - Fetch.length - 2)
 };
 
@@ -61712,7 +61660,7 @@ const searchFile = async (path, value) => {
     searchPath: path,
     limit: 9999999,
   };
-  const stdout = await invoke$2(SearchFileSearchFile, options);
+  const stdout = await invoke$1(SearchFileSearchFile, options);
   const lines = splitLines(stdout);
   return lines
 };