@lvce-editor/static-server 0.56.12 → 0.57.0

package/static/{cbe19f6 → 8f6701c}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -96,7 +96,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/cbe19f6';
+    return '/8f6701c';
   }
 };
 const assetDir = getAssetDir();
@@ -420,7 +420,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const invoke$q = (ipc, method, ...params) => {
+const invoke$r = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$9 = (ipc, method, ...params) => {
@@ -1071,8 +1071,8 @@ const listen$1 = async () => {
   handleIpc(ipc);
   state$I.ipc = ipc;
 };
-const invoke$p = (method, ...params) => {
-  return invoke$q(state$I.ipc, method, ...params);
+const invoke$q = (method, ...params) => {
+  return invoke$r(state$I.ipc, method, ...params);
 };
 const invokeAndTransfer$8 = (method, ...params) => {
   return invokeAndTransfer$9(state$I.ipc, method, ...params);
@@ -1093,7 +1093,7 @@ const loadCssStyleSheets = css => {
   return Promise.all(css.map(loadCssStyleSheet));
 };
 const addCssStyleSheet = (id, css) => {
-  return invoke$p('Css.addCssStyleSheet', id, css);
+  return invoke$q('Css.addCssStyleSheet', id, css);
 };
 const actuallyAddDynamicCss = async (id, getCss, preferences) => {
   const css = await getCss(preferences);
@@ -1117,7 +1117,7 @@ const getOrCreateWorker = fn => {
   return {
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
-      return invoke$q(ipc, method, ...params);
+      return invoke$r(ipc, method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
       const ipc = await getOrCreate$2(fn);
@@ -1209,7 +1209,7 @@ const set$g = async (key, value) => {
   state$H[key] = value;
 };
 
-const getConfiguredWorkerUrl$k = () => {
+const getConfiguredWorkerUrl$l = () => {
   let configuredWorkerUrl = get$g('develop.errorWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -1225,14 +1225,14 @@ const launchErrorWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$k()
+    url: getConfiguredWorkerUrl$l()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$o,
+  invoke: invoke$p,
   invokeAndTransfer: invokeAndTransfer$7
 } = getOrCreateWorker(launchErrorWorker);
 
@@ -1254,14 +1254,14 @@ const serializeError = error => {
 const prepare = async error => {
   try {
     const serialized = serializeError(error);
-    const prepared = await invoke$o('Errors.prepare', serialized);
+    const prepared = await invoke$p('Errors.prepare', serialized);
     return prepared;
   } catch {
     return error;
   }
 };
 const print = async (error, prefix = '') => {
-  await invoke$o('Errors.print', error, prefix);
+  await invoke$p('Errors.print', error, prefix);
 };
 const getMessage$3 = error => {
   if (error && error.type && error.message) {
@@ -1284,7 +1284,7 @@ const logError = async (error, prefix = '') => {
   await print(prettyError, prefix);
   return prettyError;
 };
-const handleError$2 = async (error, notify = true, prefix = '') => {
+const handleError$1 = async (error, notify = true, prefix = '') => {
   try {
     const prettyError = await logError(error, prefix);
     if (notify) {
@@ -1749,11 +1749,11 @@ const state$C = {
 };
 
 /* istanbul ignore file */
-const invoke$n = async (method, ...params) => {
+const invoke$o = async (method, ...params) => {
   const {
     ipc
   } = state$C;
-  const result = await invoke$q(ipc, method, ...params);
+  const result = await invoke$r(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$6 = async (method, ...params) => {
@@ -1798,7 +1798,7 @@ const getPreferencesJson = async () => {
     const url = `${assetDir}/config/defaultSettings.json`;
     return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
   }
-  return invoke$n(PreferencesGetAll);
+  return invoke$o(PreferencesGetAll);
 };
 const getPreferences = async () => {
   // TODO cache preferences, but they should not be stale
@@ -1848,7 +1848,7 @@ const state$B = {
 };
 
 const getResolvedRootFromSharedProcess = async () => {
-  const resolvedRoot = await invoke$n(/* Workspace.resolveRoot */WorkspaceResolveRoot);
+  const resolvedRoot = await invoke$o(/* Workspace.resolveRoot */WorkspaceResolveRoot);
   return resolvedRoot;
 };
 const isValid$1 = resolvedRoot => {
@@ -1914,13 +1914,13 @@ const getResolvedRoot = async href => {
 };
 
 const getHref = () => {
-  return invoke$p(/* Location.getHref */'Location.getHref');
+  return invoke$q(/* Location.getHref */'Location.getHref');
 };
 const setPathName = pathName => {
-  return invoke$p(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
+  return invoke$q(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
 const hydrate$a = () => {
-  return invoke$p(/* Location.hydrate */'Location.hydrate');
+  return invoke$q(/* Location.hydrate */'Location.hydrate');
 };
 const getOrigin = () => {
   return location.origin;
@@ -1930,7 +1930,7 @@ const getHost = () => {
 };
 
 const set$e = title => {
-  return invoke$p('WindowTitle.set', title);
+  return invoke$q('WindowTitle.set', title);
 };
 
 /**
@@ -1959,7 +1959,7 @@ const getPath = () => {
 const getUri$1 = () => {
   return state$B.workspaceUri;
 };
-const close$6 = () => {
+const close$5 = () => {
   return setPath('');
 };
 const isTest = () => {
@@ -2062,15 +2062,15 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$q(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
+  await invoke$r(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$q(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
+    await invoke$r(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   });
   return ipc;
 };
 
 const {
-  invoke: invoke$m,
+  invoke: invoke$n,
   invokeAndTransfer: invokeAndTransfer$5
 } = getOrCreateWorker(launchExtensionHostWorker);
 
@@ -2100,11 +2100,11 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
 };
 
 const getColorThemeJson = colorThemeId => {
-  return invoke$m('ColorTheme.getColorThemeJson', colorThemeId);
+  return invoke$n('ColorTheme.getColorThemeJson', colorThemeId);
 };
 
 const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
-  return invoke$m('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
+  return invoke$n('ColorTheme.getColorThemeCssFromJson', colorThemeId, colorThemeJson);
 };
 const getColorThemeCssNew = async colorThemeId => {
   const colorThemeJson = await getColorThemeJson(colorThemeId);
@@ -2120,7 +2120,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$p(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$q(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
 };
 
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
@@ -2161,7 +2161,7 @@ const watch$1 = async id => {
     return;
   }
   state$A.watchedTheme = id;
-  await invoke$n('ExtensionHost.watchColorTheme', id);
+  await invoke$o('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get$e('workbench.colorTheme');
@@ -2183,7 +2183,7 @@ const hydrate$8 = async () => {
     if (colorThemeId === FALLBACK_COLOR_THEME_ID) {
       throw error;
     }
-    handleError$2(error);
+    handleError$1(error);
     await applyColorTheme(FALLBACK_COLOR_THEME_ID);
   }
 };
@@ -2214,19 +2214,19 @@ const get$d = () => {
 
 const getWindowId = async () => {
   const webContentsId = get$d();
-  const windowId = await invoke$n('GetWindowId.getWindowId', webContentsId);
+  const windowId = await invoke$o('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
 
 const forward$2 = key => async (...args) => {
   const windowId = await getWindowId();
-  return invoke$n(key, windowId, ...args);
+  return invoke$o(key, windowId, ...args);
 };
 const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$2 = forward$2('ElectronWindow.minimize');
 const unmaximize$1 = forward$2('ElectronWindow.unmaximize');
 const maximize$2 = forward$2('ElectronWindow.maximize');
-const close$5 = forward$2('ElectronWindow.close');
+const close$4 = forward$2('ElectronWindow.close');
 const openNew$1 = forward$2('ElectronWindow.openNew');
 const toggleDevtools = forward$2('ElectronWindow.toggleDevtools');
 const zoomIn$1 = forward$2('ElectronWindow.zoomIn');
@@ -2239,7 +2239,7 @@ const reloadElectron = () => {
 };
 
 const reloadWeb = () => {
-  return invoke$p('Window.reload');
+  return invoke$q('Window.reload');
 };
 
 const getFn$2 = () => {
@@ -2278,46 +2278,46 @@ const getUrlBaseName = href => {
 // TODO treeshake this function out when targeting electron
 
 const getExtensionsPath = () => {
-  return invoke$n(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
+  return invoke$o(/* Platform.getExtensionsPath */'Platform.getExtensionsPath');
 };
 const getCachedExtensionsPath = () => {
-  return invoke$n(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
+  return invoke$o(/* Platform.getCachedExtensionsPath */'Platform.getCachedExtensionsPath');
 };
 const getLogsDir = () => {
-  return invoke$n(/* Platform.getLogsDir */'Platform.getLogsDir');
+  return invoke$o(/* Platform.getLogsDir */'Platform.getLogsDir');
 };
 const getDownloadDir = () => {
-  return invoke$n(/* Platform.getDownloadDir */'Platform.getDownloadDir');
+  return invoke$o(/* Platform.getDownloadDir */'Platform.getDownloadDir');
 };
 const getUserSettingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$n(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
+  return invoke$o(/* Platform.getUserSettingsPath */'Platform.getUserSettingsPath');
 };
 const getUserKeyBindingsPath = () => {
   if (platform === Web$1) {
     return 'settings';
   }
-  return invoke$n(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
+  return invoke$o(/* Platform.getUserSettingsPath */'Platform.getUserKeyBindingsPath');
 };
 const getRecentlyOpenedPath = () => {
   if (platform === Web$1) {
     return 'recently-opened';
   }
-  return invoke$n(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
+  return invoke$o(/* Platform.getRecentlyOpenedPath */'Platform.getRecentlyOpenedPath');
 };
 const getConfigPath = () => {
-  return invoke$n(/* Platform.getConfigDir */'Platform.getConfigDir');
+  return invoke$o(/* Platform.getConfigDir */'Platform.getConfigDir');
 };
 const getCachePath = () => {
-  return invoke$n(/* Platform.getCacheDir */'Platform.getCacheDir');
+  return invoke$o(/* Platform.getCacheDir */'Platform.getCacheDir');
 };
 const getCacheName = () => {
   return 'lvce-runtime';
 };
 const getTestPathRemote = () => {
-  return invoke$n(/* Platform.getTestPath */'Platform.getTestPath');
+  return invoke$o(/* Platform.getTestPath */'Platform.getTestPath');
 };
 const getTestPathWeb = () => {
   return `${assetDir}/packages/extension-host-worker-tests`;
@@ -2334,7 +2334,7 @@ const getTestPath = () => {
   }
 };
 const getRepository = () => {
-  return invoke$n('Platform.getRepository');
+  return invoke$o('Platform.getRepository');
 };
 
 // TODO determine with websocket request or some
@@ -2486,7 +2486,7 @@ const getAvailableKeyBindings = keyBindings => {
 const update = () => {
   const matchingKeyBindings = getMatchingKeyBindings(state$x.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  invoke$p('KeyBindings.setIdentifiers', keyBindingIdentifiers);
+  invoke$q('KeyBindings.setIdentifiers', keyBindingIdentifiers);
   state$x.matchingKeyBindings = matchingKeyBindings;
   state$x.keyBindingIdentifiers = keyBindingIdentifiers;
 };
@@ -2580,7 +2580,7 @@ const hydrate$6 = async () => {
 };
 
 const getIconThemeJson = async iconThemeId => {
-  return invoke$m('IconTheme.getJson', iconThemeId);
+  return invoke$n('IconTheme.getJson', iconThemeId);
 };
 
 const dispatch = key => (...args) => {
@@ -2661,13 +2661,13 @@ const serializeObjects = objects => {
 };
 
 const clear$5 = async storageType => {
-  await invoke$p(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
+  await invoke$q(/* WebStorage.clear */'WebStorage.clear', /* StorageType */storageType);
 };
 const getAll$1 = storageType => {
-  return invoke$p('WebStorage.getAll', storageType);
+  return invoke$q('WebStorage.getAll', storageType);
 };
 const getText$2 = async (storageType, key) => {
-  const item = await invoke$p(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
+  const item = await invoke$q(/* WebStorage.getItem */'WebStorage.getItem', /* storageType */storageType, /* key */key);
   return item || '';
 };
 const getJson$6 = async (storageType, key) => {
@@ -2682,7 +2682,7 @@ const getJson$6 = async (storageType, key) => {
   }
 };
 const setText$1 = async (storageType, key, value) => {
-  await invoke$p(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
+  await invoke$q(/* WebStorage.setItem */'WebStorage.setItem', /* storageType */storageType, /* key */key, /* value */value);
 };
 const setJson$5 = async (storageType, key, value) => {
   const stringifiedValue = stringifyCompact(value);
@@ -2690,7 +2690,7 @@ const setJson$5 = async (storageType, key, value) => {
 };
 const setJsonObjects$2 = async (storageType, objects) => {
   const serializedObjects = serializeObjects(objects);
-  await invoke$p('WebStorage.setJsonObjects', storageType, serializedObjects);
+  await invoke$q('WebStorage.setJsonObjects', storageType, serializedObjects);
 };
 
 const LocalStorage = 1;
@@ -2865,7 +2865,7 @@ const ExtensionStateStorage = {
 };
 
 const saveState$l = async () => {
-  const state = await invoke$m('SaveState.saveState');
+  const state = await invoke$n('SaveState.saveState');
   return state;
 };
 const getSavedState = async () => {
@@ -2920,7 +2920,7 @@ const hydrate$5 = async () => {
     console.info('[info] not saving state on visibility change - disabled by settings');
     return;
   }
-  await invoke$p('Window.onVisibilityChange');
+  await invoke$q('Window.onVisibilityChange');
 };
 const getSavedViewletState = viewletId => {
   return getJson$4(viewletId);
@@ -2944,7 +2944,7 @@ const ViewletManagerVisitorCss = {
 
 const fileSearchWorkerUrl = `${assetDir}/packages/file-search-worker/dist/fileSearchWorkerMain.js`;
 
-const getConfiguredWorkerUrl$j = () => {
+const getConfiguredWorkerUrl$k = () => {
   let configuredWorkerUrl = get$e('develop.fileSearchWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -2960,14 +2960,14 @@ const launchFileSearchWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$j()
+    url: getConfiguredWorkerUrl$k()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$l} = getOrCreateWorker(launchFileSearchWorker);
+  invoke: invoke$m} = getOrCreateWorker(launchFileSearchWorker);
 
 const state$u = {
   /**
@@ -2983,7 +2983,7 @@ const add$1 = async menuEntries => {
   // TODO store menu entries here or in file search worker?
   // Usually don't want to start worker for the menu entries
   // But also quickpick menu entries would be better stored there
-  await invoke$l('QuickPick.addMenuEntries', menuEntries);
+  await invoke$m('QuickPick.addMenuEntries', menuEntries);
 };
 
 const loadModule$2 = async (id, module) => {
@@ -3172,7 +3172,7 @@ const runFn = async (instance, id, key, fn, args) => {
     const commands = render$J(instance.factory, oldState, newState, newState.uid || id);
     updateDynamicFocusContext(commands);
     setRenderedState(id, newState);
-    await invoke$p(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+    await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
   } else {
     return fn(instance.state, ...args);
   }
@@ -3197,7 +3197,7 @@ const runFnWithSideEffect = async (instance, id, key, fn, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$p(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+  await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
 };
 
 // TODO maybe wrapViewletCommand should accept module instead of id string
@@ -3402,7 +3402,7 @@ const maybeRegisterEvents = module => {
       const commands = render$J(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
       instance.state = newState;
       instance.renderedState = newState;
-      await invoke$p(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     };
     addListener('workspace.change', handleUpdate);
   }
@@ -3429,7 +3429,7 @@ const maybeRegisterEvents = module => {
         const commands = render$J(instance.factory, instance.renderedState, newState, uid, newState.parentUid);
         instance.state = newState;
         instance.renderedState = newState;
-        await invoke$p(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+        await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
       };
       addListener(key, handleUpdate);
     }
@@ -3457,7 +3457,7 @@ const maybeRegisterMenuEntries = async module => {
 const actuallyLoadModule = async (getModule, id) => {
   const module = await getModule(id);
   if (!module.hasFunctionalEvents) {
-    await invoke$p(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
+    await invoke$q(/* Viewlet.load */kLoadModule, /* id */id, /* hasFunctionalEvents */module.hasFunctionalEvents);
   }
   await loadModule$1(id, module);
   await maybeRegisterWrappedCommands(id, module);
@@ -3550,7 +3550,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.renderEventListeners) {
       // TODO reuse event listeners between components
       const eventListeners = await module.renderEventListeners();
-      await invoke$p('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      await invoke$q('Viewlet.registerEventListeners', viewletUid, eventListeners);
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
       await module.show(newState);
@@ -3604,7 +3604,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentLoaded;
     if (viewlet.show === false) {} else {
-      await invoke$p(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+      await invoke$q(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
     }
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
@@ -3656,7 +3656,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
         return allCommands;
       }
       commands.push(...extraCommands);
-      await invoke$p(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
+      await invoke$q(/* Viewlet.sendMultiple */kSendMultiple, /* commands */commands);
     } else {
       const allCommands = [...commands, ...extraCommands
       // ['Viewlet.show', viewlet.id],
@@ -3677,7 +3677,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     state = ViewletState.ContentRendered;
     if (viewlet.parentUid && viewlet.show !== false) {
-      await invoke$p(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
+      await invoke$q(/* Viewlet.append */kAppendViewlet, /* parentUid */viewlet.parentUid, /* id */viewletUid, /* focus */focus);
     }
     state = ViewletState.Appended;
     if (viewlet.disposed) {
@@ -3699,10 +3699,10 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       }
       const commands = [];
       if (state < ViewletState.RendererProcessViewletLoaded) {
-        await invoke$p(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
+        await invoke$q(/* Viewlet.loadModule */kLoadModule, /* id */viewlet.id);
       }
       const parentUid = viewlet.parentUid;
-      await invoke$p(kLoadModule, Error$3);
+      await invoke$q(kLoadModule, Error$3);
       commands.push([kCreate, Error$3, viewletUid]);
       // @ts-ignore
       if (viewlet.setBounds !== false) {
@@ -3711,7 +3711,7 @@ const load$6 = async (viewlet, focus = false, restore = false, restoreState = un
       if (module && module.customErrorRenderer) {
         const errorModule = await loadModule(viewlet.getModule, module.customErrorRenderer);
         const dom = await errorModule.render(error);
-        await invoke$p(kLoadModule, module.customErrorRenderer);
+        await invoke$q(kLoadModule, module.customErrorRenderer);
         commands.push([kCreate, module.customErrorRenderer, viewletUid]);
         commands.push(['Viewlet.setDom2', viewletUid, dom]);
         commands.push([kAppend, parentUid, viewletUid]);
@@ -3764,7 +3764,7 @@ const load$4 = async moduleId => {
 };
 
 const disposeBrowserViewQuickPick = () => {
-  return invoke$n('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
+  return invoke$o('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
 const handleKeyBinding$1 = async identifier => {
@@ -3814,7 +3814,7 @@ const focus$7 = async id => {
     commands.push(...render$J(instance.factory, oldState, newState));
   }
   setFocusedInstance(instance);
-  await invoke$p('Viewlet.sendMultiple', commands);
+  await invoke$q('Viewlet.sendMultiple', commands);
 };
 
 /**
@@ -3839,7 +3839,7 @@ const send = (id, method, ...args) => {
 /**
  * @deprecated
  */
-const dispose$t = async id => {
+const dispose$s = async id => {
   if (!id) {
     console.warn('no instance to dispose');
     return;
@@ -3857,7 +3857,7 @@ const dispose$t = async id => {
       throw new Error(`${id} is missing a factory function`);
     }
     instance.factory.dispose(instance.state);
-    await invoke$p(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
+    await invoke$q(/* Viewlet.dispose */'Viewlet.dispose', /* id */instanceUid);
     if (instance.factory.getKeyBindings) {
       removeKeyBindings(instanceUid);
     }
@@ -4038,7 +4038,7 @@ const setStateFunctional = (id, newState) => {
 const setState = async (id, newState) => {
   const commands = setStateFunctional(id, newState);
   if (commands.length > 0) {
-    await invoke$p(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+    await invoke$q(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
   }
 };
 const getAllStates = () => {
@@ -4081,7 +4081,7 @@ const openWidget = async (moduleId, ...args) => {
   // TODO send focus changes to renderer process together with other message
   updateDynamicFocusContext(commands);
   commands.push(['Viewlet.focus', childUid]);
-  await invoke$p('Viewlet.executeCommands', commands);
+  await invoke$q('Viewlet.executeCommands', commands);
 };
 const closeWidget = async id => {
   try {
@@ -4093,7 +4093,7 @@ const closeWidget = async id => {
     const child = childInstance.state;
     const childUid = child.uid;
     const commands = disposeFunctional(childUid);
-    await invoke$p(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    await invoke$q(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
     // TODO restore focus
   } catch (error) {
     throw new VError(error, `Failed to close widget ${id}`);
@@ -4151,7 +4151,7 @@ const executeViewletCommand = async (uid, fnName, ...args) => {
   if (commands.length === 0) {
     return;
   }
-  await invoke$p(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
+  await invoke$q(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
 
 // @ts-ignore
@@ -4191,7 +4191,7 @@ const disposeWidgetWithValue = async (id, value) => {
     instance.status = 'disposed';
     remove$8(id);
     remove$8(uid);
-    await invoke$p('Viewlet.sendMultiple', commands);
+    await invoke$q('Viewlet.sendMultiple', commands);
     // return commands
     const parentInstance = getInstance(KeyBindings);
     if (!parentInstance) {
@@ -4398,7 +4398,7 @@ const getLanguageConfigurationFromWebExtension = async languageId => {
   return json;
 };
 const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$n(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  const languageConfiguration = await invoke$o(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
   if (languageConfiguration) {
     return languageConfiguration;
   }
@@ -4411,7 +4411,7 @@ const getLanguageConfiguration$2 = async languageId => {
 
 const getLanguages = async () => {
   try {
-    return invoke$m('Languages.getLanguages');
+    return invoke$n('Languages.getLanguages');
   } catch (error) {
     throw new VError(error, 'Failed to load languages');
   }
@@ -4827,7 +4827,7 @@ const hydrate$3 = async () => {
 };
 
 const getInitData = async () => {
-  const rendererProcessInitData = await invoke$p('InitData.getInitData');
+  const rendererProcessInitData = await invoke$q('InitData.getInitData');
   // TODO get the following items
   // - location.href
   // - workspace
@@ -5219,7 +5219,7 @@ const addToRecentlyOpenedWeb = async path => {
   await setRecentlyOpened(newRecentlyOpened);
 };
 const addToRecentlyOpenedRemote = async path => {
-  await invoke$n(RecentlyOpenedAddPath, path);
+  await invoke$o(RecentlyOpenedAddPath, path);
 };
 const addToRecentlyOpened = async path => {
   switch (platform) {
@@ -5257,16 +5257,16 @@ const hydrate$2 = async () => {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const saveValue$1 = async (storeId, value) => {
-  await invoke$m('IndexedDb.saveValue', storeId, value);
+  await invoke$n('IndexedDb.saveValue', storeId, value);
 };
 const getValuesByIndexName$1 = async (storeId, indexName, only) => {
-  return invoke$m('IndexedDb.getValuesByIndexName', storeId, indexName, only);
+  return invoke$n('IndexedDb.getValuesByIndexName', storeId, indexName, only);
 };
 const addHandle$1 = async (uri, handle) => {
-  return invoke$m('IndexedDb.addHandle', uri, handle);
+  return invoke$n('IndexedDb.addHandle', uri, handle);
 };
 const getHandle$1 = async uri => {
-  return invoke$m('IndexedDb.getHandle', uri);
+  return invoke$n('IndexedDb.getHandle', uri);
 };
 
 const saveValue = async (sessionId, value) => {
@@ -5497,14 +5497,14 @@ const openSession = async () => {
  */
 const handleUnhandledRejection = event => {
   event.preventDefault();
-  handleError$2(event.reason, false, '[renderer-worker] Unhandled Rejection: ');
+  handleError$1(event.reason, false, '[renderer-worker] Unhandled Rejection: ');
 };
 
 /**
  * @param {Error} error
  */
 const handleUnhandledError = (message, filename, lineno, colno, error) => {
-  handleError$2(error, false, '[renderer-worker] Unhandled Error: ');
+  handleError$1(error, false, '[renderer-worker] Unhandled Error: ');
   return true;
 };
 
@@ -5639,6 +5639,13 @@ const getWatchConfig = () => {
       command: 'Settings.hotReload'
     });
   }
+  const output = get$e('develop.outputViewWorkerPath');
+  if (settings) {
+    watchConfig.push({
+      path: output,
+      command: 'Output.hotReload'
+    });
+  }
   return watchConfig;
 };
 
@@ -5649,7 +5656,7 @@ const watchFilesForHotReload = async platform => {
     if (config.length === 0) {
       return;
     }
-    await invoke$n('ExtensionHost.watchForHotReload', config);
+    await invoke$o('ExtensionHost.watchForHotReload', config);
   } catch (error) {
     console.warn(`Failed to watch ${error}`);
   }
@@ -5767,7 +5774,7 @@ const startup = async () => {
   const placeholderCommands = layoutModule.factory.getInitialPlaceholderCommands(layoutModule.state);
   commands.push(...placeholderCommands);
   commands.push(['Viewlet.appendToBody', layout.uid]);
-  await invoke$p('Viewlet.executeCommands', commands);
+  await invoke$q('Viewlet.executeCommands', commands);
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
@@ -6430,10 +6437,10 @@ const GetColorThemeCssCachedLocalStorage = {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const set$8 = async (key, value) => {
-  await invoke$m('IndexedDb.set', key, value);
+  await invoke$n('IndexedDb.set', key, value);
 };
 const get$7 = async key => {
-  return invoke$m('IndexedDb.get', key);
+  return invoke$n('IndexedDb.get', key);
 };
 
 const getCacheKey = colorThemeId => {
@@ -6505,7 +6512,7 @@ const get$4 = () => {
 };
 
 const addWebExtension = async path => {
-  const manifest = await invoke$m('Extensions.addWebExtension', path);
+  const manifest = await invoke$n('Extensions.addWebExtension', path);
   // TODO avoid side effect here
   if (manifest.languages) {
     for (const language of manifest.languages) {
@@ -6619,7 +6626,7 @@ const handleRejectedExtensions = async extensions => {
   }
 };
 const getExtensions$1 = async () => {
-  return invoke$m('Extensions.getExtensions');
+  return invoke$n('Extensions.getExtensions');
 };
 const addNodeExtension = async path => {
   // TODO add support for dynamically loading node extensions
@@ -6661,13 +6668,13 @@ const state$l = {
 const actuallyActivateExtension = async (extension, event) => {
   if (!(extension.id in state$l.activatedExtensions)) {
     const absolutePath = getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.path, extension.browser, origin, platform);
-    state$l.activatedExtensions[extension.id] = invoke$m(ExtensionActivate, extension, absolutePath, event);
+    state$l.activatedExtensions[extension.id] = invoke$n(ExtensionActivate, extension, absolutePath, event);
   }
   return state$l.activatedExtensions[extension.id];
 };
 const actuallyActivateByEvent = async event => {
   // TODO should not query extensions multiple times
-  const extensions = await invoke$m('Extensions.getExtensions');
+  const extensions = await invoke$n('Extensions.getExtensions');
   const {
     resolved,
     rejected
@@ -6713,7 +6720,7 @@ const executeProviders = async ({
   combineResults
 }) => {
   await activateByEvent(event);
-  const result = await invoke$m(method, ...params);
+  const result = await invoke$n(method, ...params);
   return result;
 };
 const executeProvider = async ({
@@ -6723,14 +6730,14 @@ const executeProvider = async ({
   noProviderFoundMessage
 }) => {
   await activateByEvent(event);
-  const result = invoke$m(method, ...params);
+  const result = invoke$n(method, ...params);
   return result;
 };
 const execute$3 = async ({
   method,
   params
 }) => {
-  await invoke$m(method, ...params);
+  await invoke$n(method, ...params);
 };
 
 const readFile$e = uri => {
@@ -6950,40 +6957,40 @@ const FileSystemData = {
 
 const name$2q = 'Memory';
 const readFile$b = uri => {
-  return invoke$m('FileSystemMemory.readFile', uri);
+  return invoke$n('FileSystemMemory.readFile', uri);
 };
 const writeFile$b = (uri, content) => {
-  return invoke$m('FileSystemMemory.writeFile', uri, content);
+  return invoke$n('FileSystemMemory.writeFile', uri, content);
 };
 const mkdir$4 = uri => {
-  return invoke$m('FileSystemMemory.mkdir', uri);
+  return invoke$n('FileSystemMemory.mkdir', uri);
 };
 const getPathSeparator$5 = () => {
   return Slash;
 };
 const remove$4 = uri => {
-  return invoke$m('FileSystemMemory.remove', uri);
+  return invoke$n('FileSystemMemory.remove', uri);
 };
 const readDirWithFileTypes$5 = uri => {
-  return invoke$m('FileSystemMemory.readDirWithFileTypes', uri);
+  return invoke$n('FileSystemMemory.readDirWithFileTypes', uri);
 };
 const getBlobUrl$2 = uri => {
-  return invoke$m('FileSystemMemory.getBlobUrl', uri);
+  return invoke$n('FileSystemMemory.getBlobUrl', uri);
 };
 const getBlob$5 = async uri => {
-  return invoke$m('FileSystemMemory.getBlob', uri);
+  return invoke$n('FileSystemMemory.getBlob', uri);
 };
 const chmod$3 = (path, permissions) => {
-  return invoke$m('FileSystemMemory.chmod', path, permissions);
+  return invoke$n('FileSystemMemory.chmod', path, permissions);
 };
 const rename$3 = (oldPath, newPath) => {
-  return invoke$m('FileSystemMemory.rename', oldPath, newPath);
+  return invoke$n('FileSystemMemory.rename', oldPath, newPath);
 };
 const copy$4 = (oldPath, newPath) => {
-  return invoke$m('FileSystemMemory.copy', oldPath, newPath);
+  return invoke$n('FileSystemMemory.copy', oldPath, newPath);
 };
 const getFiles$1 = () => {
-  return invoke$m('FileSystemMemory.getFiles');
+  return invoke$n('FileSystemMemory.getFiles');
 };
 
 const FileSystemMemory = {
@@ -7299,7 +7306,7 @@ const FileSystemWeb = {
 
 const fileSystemWorkerUrl = `${assetDir}/packages/file-system-worker/dist/fileSystemWorkerMain.js`;
 
-const getConfiguredWorkerUrl$i = () => {
+const getConfiguredWorkerUrl$j = () => {
   let configuredWorkerUrl = get$e('develop.fileSystemWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -7315,15 +7322,15 @@ const launchFileSystemWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$i()
+    url: getConfiguredWorkerUrl$j()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Initialize.initialize', platform);
+  await invoke$r(ipc, 'Initialize.initialize', platform);
   return ipc;
 };
 
 const {
-  invoke: invoke$k,
+  invoke: invoke$l,
   invokeAndTransfer: invokeAndTransfer$4} = getOrCreateWorker(launchFileSystemWorker);
 
 // TODO move all of this to an extension
@@ -7335,30 +7342,30 @@ const state$j = {
 };
 const readFile$9 = async uri => {
   if (uri.startsWith('http://') || uri.startsWith('https://')) {
-    return invoke$k('FileSystemFetch.readFile', uri);
+    return invoke$l('FileSystemFetch.readFile', uri);
   }
-  return invoke$m('FileSystemFetch.readFile', uri);
+  return invoke$n('FileSystemFetch.readFile', uri);
 };
 const writeFile$9 = (uri, content) => {
-  return invoke$m('FileSystemFetch.writeFile', uri);
+  return invoke$n('FileSystemFetch.writeFile', uri);
 };
 const mkdir$2 = uri => {
-  return invoke$m('FileSystemFetch.mkdir', uri);
+  return invoke$n('FileSystemFetch.mkdir', uri);
 };
 const getPathSeparator$3 = () => {
   return Slash;
 };
 const remove$2 = uri => {
-  return invoke$m('FileSystemFetch.remove', uri);
+  return invoke$n('FileSystemFetch.remove', uri);
 };
 const readDirWithFileTypes$3 = async uri => {
-  return invoke$m('FileSystemFetch.readDirWithFileTypes', uri);
+  return invoke$n('FileSystemFetch.readDirWithFileTypes', uri);
 };
 const chmod$2 = (path, permissions) => {
-  return invoke$m('FileSystemFetch.chmod', path, permissions);
+  return invoke$n('FileSystemFetch.chmod', path, permissions);
 };
 const getBlob$4 = async (uri, type) => {
-  return invoke$m('FileSystemFetch.getBlob', uri, type);
+  return invoke$n('FileSystemFetch.getBlob', uri, type);
 };
 
 const FileSystemFetch = {
@@ -7391,37 +7398,37 @@ const toUri = item => {
 const copy$3 = (source, target) => {
   source = toUri(source);
   target = toUri(target);
-  return invoke$k('FileSystem.copy', /* source */source, /* target */target);
+  return invoke$l('FileSystem.copy', /* source */source, /* target */target);
 };
 const readFile$8 = (path, encoding) => {
   path = toUri(path);
-  return invoke$k('FileSystem.readFile', /* path */path, /* encoding */encoding);
+  return invoke$l('FileSystem.readFile', /* path */path, /* encoding */encoding);
 };
 const readJson$2 = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.readJson', /* path */path);
+  return invoke$l('FileSystem.readJson', /* path */path);
 };
 const remove$1 = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.remove', /* path */path);
+  return invoke$l('FileSystem.remove', /* path */path);
 };
 const rename$1 = (oldUri, newUri) => {
   oldUri = toUri(oldUri);
   newUri = toUri(newUri);
-  return invoke$k('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
+  return invoke$l('FileSystem.rename', /* oldPath */oldUri, /* newPath */newUri);
 };
 const mkdir$1 = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.mkdir', /* path */path);
+  return invoke$l('FileSystem.mkdir', /* path */path);
 };
 const writeFile$8 = async (path, content, encoding) => {
   path = toUri(path);
-  await invoke$k(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
+  await invoke$l(/* FileSystem.writeFile */'FileSystem.writeFile', /* path */path, /* content */content, /* encoding */encoding);
 };
 const ensureFile = async () => {};
 const readDirWithFileTypes$2 = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.readDirWithFileTypes', /* path */path);
+  return invoke$l('FileSystem.readDirWithFileTypes', /* path */path);
 };
 const getBlobUrl$1 = path => {
   if (!path.startsWith('/')) {
@@ -7430,7 +7437,7 @@ const getBlobUrl$1 = path => {
   return getRemoteSrc(path);
 };
 const getBlob$3 = async (path, type) => {
-  const content = await invoke$k('FileSystem.readFileAsBuffer', path);
+  const content = await invoke$l('FileSystem.readFileAsBuffer', path);
   const array = new Uint8Array(content.data);
   const blob = new Blob([array], {
     type
@@ -7441,22 +7448,22 @@ const getPathSeparator$2 = () => {
   if (platform === Web$1) {
     return Slash;
   }
-  return invoke$k('FileSystem.getPathSeparator');
+  return invoke$l('FileSystem.getPathSeparator');
 };
 const getRealPath = path => {
-  return invoke$k('FileSystem.getRealPath', /* path */path);
+  return invoke$l('FileSystem.getRealPath', /* path */path);
 };
 const stat = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.stat', /* path */path);
+  return invoke$l('FileSystem.stat', /* path */path);
 };
 const getFolderSize = path => {
   path = toUri(path);
-  return invoke$k('FileSystem.getFolderSize', /* path */path);
+  return invoke$l('FileSystem.getFolderSize', /* path */path);
 };
 const chmod$1 = (path, permissions) => {
   path = toUri(path);
-  return invoke$k('FileSystem.chmod', /* path */path, /* permissions */permissions);
+  return invoke$l('FileSystem.chmod', /* path */path, /* permissions */permissions);
 };
 const canBeRestored$2 = true;
 
@@ -7600,7 +7607,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$p('FileSystemHandle.requestPermission', handle, options);
+  const permissionTypeNow = await invoke$q('FileSystemHandle.requestPermission', handle, options);
   return permissionTypeNow;
 };
 const queryPermission = async (handle, options) => {
@@ -7826,7 +7833,7 @@ const FileSystemHtml = {
 
 const debugWorkerUrl = `${assetDir}/packages/debug-worker/dist/debugWorkerMain.js`;
 
-const getConfiguredWorkerUrl$h = () => {
+const getConfiguredWorkerUrl$i = () => {
   let configuredWorkerUrl = get$e('develop.debugWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -7842,21 +7849,21 @@ const launchDebugWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$h()
+    url: getConfiguredWorkerUrl$i()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Initialize.initialize');
+  await invoke$r(ipc, 'Initialize.initialize');
   return ipc;
 };
 
 const {
-  invoke: invoke$j,
-  restart: restart$9
+  invoke: invoke$k,
+  restart: restart$a
 } = getOrCreateWorker(launchDebugWorker);
 
 const name$2m = 'Debug';
 const readFile$6 = uri => {
-  return invoke$j('RunAndDebug.readFile', uri);
+  return invoke$k('RunAndDebug.readFile', uri);
 };
 const writeFile$6 = (uri, content) => {
   throw new Error('not implemented');
@@ -8241,7 +8248,7 @@ const TryToGetActualImportErrorMessage = {
 
 const aboutViewWorkerUrl = `${assetDir}/packages/about-view-worker/dist/aboutWorkerMain.js`;
 
-const getConfiguredWorkerUrl$g = () => {
+const getConfiguredWorkerUrl$h = () => {
   let configuredWorkerUrl = get$e('develop.aboutViewWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -8257,18 +8264,18 @@ const launchAboutViewWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$g()
+    url: getConfiguredWorkerUrl$h()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$i
+  invoke: invoke$j
 } = getOrCreateWorker(launchAboutViewWorker);
 
 const showAboutElectron = async () => {
-  return invoke$i('About.showAboutElectron');
+  return invoke$j('About.showAboutElectron');
 };
 
 const showAboutDefault = async () => {
@@ -8378,7 +8385,7 @@ const Ajax_ipc = {
 
 const playBell = async () => {
   const src = '/sounds/bell.oga';
-  await invoke$p(/* Audio.play */3211, /* src */src);
+  await invoke$q(/* Audio.play */3211, /* src */src);
 };
 
 const name$2j = 'Audio';
@@ -8431,25 +8438,25 @@ const i18nString = (key, placeholders = emptyObject) => {
 /**
  * @enum {string}
  */
-const UiStrings$j = {
+const UiStrings$i = {
   DoYouWantToUpdate: 'Do you want to update to version {PH1}?',
   DoYouWantToRestart: 'The Update has been downloaded. Do you want to restart now?'
 };
 const promptMessage = version => {
-  return i18nString(UiStrings$j.DoYouWantToUpdate, {
+  return i18nString(UiStrings$i.DoYouWantToUpdate, {
     PH1: version
   });
 };
 const promptRestart = () => {
-  return i18nString(UiStrings$j.DoYouWantToRestart);
+  return i18nString(UiStrings$i.DoYouWantToRestart);
 };
 
 const getAutoUpdateType = () => {
-  return invoke$n('AutoUpdater.getAutoUpdateType');
+  return invoke$o('AutoUpdater.getAutoUpdateType');
 };
 
 const getLatestVersion = () => {
-  return invoke$n('AutoUpdater.getLatestVersion');
+  return invoke$o('AutoUpdater.getLatestVersion');
 };
 
 const checkForUpdates$1 = async () => {
@@ -8553,14 +8560,14 @@ const GetEditorSourceActions_ipc = {
 };
 
 const getFileHandles = ids => {
-  return invoke$p('FileHandles.get', ids);
+  return invoke$q('FileHandles.get', ids);
 };
 const addFileHandle = fileHandle => {
-  return invoke$p('FileSystemHandle.addFileHandle', fileHandle);
+  return invoke$q('FileSystemHandle.addFileHandle', fileHandle);
 };
 
 const getFilePathElectron = async file => {
-  return invoke$p('GetFilePathElectron.getFilePathElectron', file);
+  return invoke$q('GetFilePathElectron.getFilePathElectron', file);
 };
 
 const name$2f = 'FileSystemHandle';
@@ -8754,10 +8761,10 @@ const applyLegacyBulkReplacement = async (files, ranges, replacement) => {
   array(ranges);
   string(replacement);
   if (isSpecialScheme(files)) {
-    await invoke$m('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+    await invoke$n('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
     return;
   }
-  await invoke$n('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$o('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
 };
 
 const applyFileReplacement = async edit => {
@@ -8927,7 +8934,7 @@ const unmaximize = () => {
       throw new Error('not implemented');
   }
 };
-const close$4 = () => {
+const close$3 = () => {
   switch (platform) {
     case Electron$1:
       return execute$4('ElectronWindow.close');
@@ -8978,7 +8985,7 @@ const zoomReset = () => {
 
 const name$2a = 'Chrome';
 const Commands$24 = {
-  close: close$4,
+  close: close$3,
   exit: exit$2,
   maximize: maximize$1,
   minimize: minimize$1,
@@ -8993,7 +9000,7 @@ const Chrome_ipc = {
 
 const clipBoardWorkerUrl = `${assetDir}/packages/clipboard-worker/dist/clipBoardWorkerMain.js`;
 
-const getConfiguredWorkerUrl$f = () => {
+const getConfiguredWorkerUrl$g = () => {
   let configuredWorkerUrl = get$e('develop.clipBoardWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -9009,47 +9016,47 @@ const launchClipBoardWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$f()
+    url: getConfiguredWorkerUrl$g()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'ClipBoard.initialize', platform);
+  await invoke$r(ipc, 'ClipBoard.initialize', platform);
   return ipc;
 };
 
 const {
-  invoke: invoke$h} = getOrCreateWorker(launchClipBoardWorker);
+  invoke: invoke$i} = getOrCreateWorker(launchClipBoardWorker);
 
 const readText = async () => {
-  return await invoke$h('ClipBoard.readText');
+  return await invoke$i('ClipBoard.readText');
 };
 const writeText$1 = async text => {
-  return await invoke$h('ClipBoard.writeText', text);
+  return await invoke$i('ClipBoard.writeText', text);
 };
 const enableMemoryClipBoard = async () => {
-  return await invoke$h('ClipBoard.enableMemoryClipBoard');
+  return await invoke$i('ClipBoard.enableMemoryClipBoard');
 };
 const disableMemoryClipBoard = async () => {
-  return await invoke$h('ClipBoard.disableMemoryClipBoard');
+  return await invoke$i('ClipBoard.disableMemoryClipBoard');
 };
-const hotReload$b = async () => {
-  return await invoke$h('ClipBoard.hotReload');
+const hotReload$c = async () => {
+  return await invoke$i('ClipBoard.hotReload');
 };
 const writeNativeFiles = async (type, files) => {
-  return await invoke$h('ClipBoard.writeNativeFiles', type, files);
+  return await invoke$i('ClipBoard.writeNativeFiles', type, files);
 };
 const readNativeFiles = async () => {
-  return await invoke$h('ClipBoard.readNativeFiles');
+  return await invoke$i('ClipBoard.readNativeFiles');
 };
 const writeImage = async blob => {
   try {
-    return await invoke$p('ClipBoard.writeImage', blob);
+    return await invoke$q('ClipBoard.writeImage', blob);
   } catch (error) {
     throw new VError(error, 'Failed to write image to clipboard');
   }
 };
 const execCopy = async () => {
   try {
-    return await invoke$p('ClipBoard.execCopy');
+    return await invoke$q('ClipBoard.execCopy');
   } catch (error) {
     throw new VError(error, 'Failed to copy selected text');
   }
@@ -9058,7 +9065,7 @@ const execCopy = async () => {
 const name$29 = 'ClipBoard';
 const Commands$23 = {
   execCopy: execCopy,
-  hotReload: hotReload$b,
+  hotReload: hotReload$c,
   readNativeFiles: readNativeFiles,
   readText: readText,
   writeImage: writeImage,
@@ -9075,7 +9082,7 @@ const ClipBoard_ipc = {
 };
 
 const getColorThemeNames = async () => {
-  return invoke$m('ColorTheme.getColorThemeNames');
+  return invoke$n('ColorTheme.getColorThemeNames');
 };
 
 const name$28 = 'ColorTheme';
@@ -9098,7 +9105,7 @@ const getProductNameLong = () => {
 };
 
 const showOpenDialog = (title, properties) => {
-  return invoke$n('ElectronDialog.showOpenDialog', title, properties);
+  return invoke$o('ElectronDialog.showOpenDialog', title, properties);
 };
 const showMessageBox = async options => {
   // TODO maybe request window id here instead of at caller
@@ -9110,7 +9117,7 @@ const showMessageBox = async options => {
     productName,
     windowId
   };
-  return invoke$n('ElectronDialog.showMessageBox', finalOptions);
+  return invoke$o('ElectronDialog.showMessageBox', finalOptions);
 };
 
 const Question = 'question';
@@ -9127,22 +9134,22 @@ const prompt$3 = async (message, confirmMessage, title, cancelMessage) => {
 };
 
 const prompt$2 = async (message, confirmMessage, title) => {
-  const result = await invoke$p('ConfirmPrompt.prompt', message);
+  const result = await invoke$q('ConfirmPrompt.prompt', message);
   return result;
 };
 
 /**
  * @enum {string}
  */
-const UiStrings$i = {
+const UiStrings$h = {
   Cancel: 'Cancel',
   Ok: 'Ok'
 };
 const cancel = () => {
-  return i18nString(UiStrings$i.Cancel);
+  return i18nString(UiStrings$h.Cancel);
 };
 const ok = () => {
-  return i18nString(UiStrings$i.Ok);
+  return i18nString(UiStrings$h.Ok);
 };
 
 const prompt$1 = async (message, {
@@ -9171,21 +9178,21 @@ const ConfirmPrompt_ipc = {
 };
 
 const startRecording = options => {
-  return invoke$n('ElectronContentTracing.startRecording', options);
+  return invoke$o('ElectronContentTracing.startRecording', options);
 };
 
 /**
  * @returns {Promise<string>}
  */
 const stopRecording = () => {
-  return invoke$n('ElectronContentTracing.stopRecording');
+  return invoke$o('ElectronContentTracing.stopRecording');
 };
 
 const showItemInFolder = fullPath => {
-  return invoke$n('OpenExternal.showItemInFolder', fullPath);
+  return invoke$o('OpenExternal.showItemInFolder', fullPath);
 };
 const openExternal$2 = url => {
-  return invoke$n('OpenExternal.openExternal', url);
+  return invoke$o('OpenExternal.openExternal', url);
 };
 
 const openNativeFolderWeb = absolutePath => {
@@ -9193,7 +9200,7 @@ const openNativeFolderWeb = absolutePath => {
 };
 const openNativeFolderRemote = async absolutePath => {
   try {
-    await invoke$n(OpenNativeFolder, /* path */absolutePath);
+    await invoke$o(OpenNativeFolder, /* path */absolutePath);
   } catch (error) {
     throw new VError(error, `Failed to open folder ${absolutePath}`);
   }
@@ -9306,26 +9313,26 @@ const Debug_ipc = {
 
 const attachDebugger = async pid => {
   number(pid);
-  await invoke$n('AttachDebugger.attachDebugger', pid);
+  await invoke$o('AttachDebugger.attachDebugger', pid);
 };
 
 const getPid = () => {
-  return invoke$n('Process.getPid');
+  return invoke$o('Process.getPid');
 };
 const getElectronVersion = () => {
-  return invoke$n('ElectronProcess.getElectronVersion');
+  return invoke$o('ElectronProcess.getElectronVersion');
 };
 const getNodeVersion = () => {
-  return invoke$n('Process.getNodeVersion');
+  return invoke$o('Process.getNodeVersion');
 };
 const getChromeVersion = () => {
-  return invoke$n('ElectronProcess.getChromeVersion');
+  return invoke$o('ElectronProcess.getChromeVersion');
 };
 const getV8Version = () => {
-  return invoke$n('Process.getV8Version');
+  return invoke$o('Process.getV8Version');
 };
 const getArch = () => {
-  return invoke$n('Process.getArch');
+  return invoke$o('Process.getArch');
 };
 
 const debugSharedProcess = async () => {
@@ -9345,10 +9352,10 @@ const DebugSharedProcess_ipc = {
 };
 
 const crashSharedProcess = () => {
-  return invoke$n('Crash.crashSharedProcess');
+  return invoke$o('Crash.crashSharedProcess');
 };
 const crashMainProcess = () => {
-  return invoke$n('Crash.crashMainProcess');
+  return invoke$o('Crash.crashMainProcess');
 };
 
 const toggleDeveloperTools$1 = () => {
@@ -9364,7 +9371,7 @@ const openCacheFolder = async () => {
   await openNativeFolder(cacheFolder);
 };
 const openDataFolder = async () => {
-  const dataFolder = await invoke$n(/* Platform.getDataDir */'Platform.getDataDir');
+  const dataFolder = await invoke$o(/* Platform.getDataDir */'Platform.getDataDir');
   await openNativeFolder(dataFolder);
 };
 const openLogsFolder = async () => {
@@ -9377,7 +9384,7 @@ const openLogsFolder = async () => {
 };
 
 const getPerformanceEntries = () => {
-  return invoke$n('ElectronDeveloper.getPerformanceEntries');
+  return invoke$o('ElectronDeveloper.getPerformanceEntries');
 };
 
 const toMarkdownTable = (header, rows) => {
@@ -9604,7 +9611,7 @@ const getModule$2 = () => {
       throw new Error('unsupported platform');
   }
 };
-const open$5 = async () => {
+const open$4 = async () => {
   const module = await getModule$2();
   return module.open();
 };
@@ -9618,7 +9625,7 @@ const getNodeTiming = () => {
   if (platform === Web$1) {
     return undefined;
   }
-  return invoke$n(/* command */'Performance.getNodeStartupTiming');
+  return invoke$o(/* command */'Performance.getNodeStartupTiming');
 };
 const getMeasureEntries = () => {
   const measureEntries = getEntriesByType(Measure);
@@ -9707,13 +9714,13 @@ const formatRendererProcessData = ({
   return toMarkdownTable(header, rows);
 };
 const getSharedProcessMemoryUsage = () => {
-  return invoke$n(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
+  return invoke$o(/* Developer.sharedProcessMemoryUsage */'Developer.sharedProcessMemoryUsage');
 };
 const getPerformanceMemory = () => {
-  return invoke$p('Performance.getMemory');
+  return invoke$q('Performance.getMemory');
 };
 const getPerformanceUserAgentSpecificMemory = () => {
-  return invoke$p('Performance.measureUserAgentSpecificMemory');
+  return invoke$q('Performance.measureUserAgentSpecificMemory');
 };
 
 // TODO handle case when renderer process and renderer worker are same process communicating via messagePort
@@ -9762,13 +9769,13 @@ const showMemoryUsage = async () => {
 
 // TODO not sure if this function is useful
 const allocateMemoryInSharedProcess = () => {
-  return invoke$n(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
+  return invoke$o(/* Developer.allocateMemoryInSharedProcess */'Developer.allocateMemoryInSharedProcess');
 };
 const createSharedProcessHeapSnapshot = async () => {
-  await invoke$n(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
+  await invoke$o(/* Developer.createSharedProcessHeapSnapshot */'Developer.createSharedProcessHeapSnapshot');
 };
 const createSharedProcessProfile = async () => {
-  await invoke$n(/* Developer.createProfile */'Developer.createProfile');
+  await invoke$o(/* Developer.createProfile */'Developer.createProfile');
 };
 const reloadIconTheme = async () => {
   await hydrate$3();
@@ -9788,7 +9795,7 @@ const clearCache = async () => {
   await execute$4(/* SessionStorage.clear */'SessionStorage.clear');
 };
 const openProcessExplorer$1 = () => {
-  return open$5();
+  return open$4();
 };
 const downloadViewletState = async () => {
   const states = await execute$4('Viewlet.getAllStates');
@@ -9949,12 +9956,12 @@ const Dialog_ipc = {
 const downloadFile = async (fileName, url) => {
   string(fileName);
   string(url);
-  await invoke$p(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
+  await invoke$q(/* Download.downloadFile */'Download.downloadFile', /* fileName */fileName, /* url */url);
 };
 const downloadToDownloadsFolder = async (fileName, url) => {
   const downloadFolder = await getDownloadDir();
   const outFile = `${downloadFolder}/${fileName}`;
-  await invoke$n(DownloadDownload, /* url */url, /* outFile */outFile);
+  await invoke$o(DownloadDownload, /* url */url, /* outFile */outFile);
 };
 const downloadJson = async (json, fileName) => {
   let url = '';
@@ -9975,7 +9982,7 @@ const downloadJson = async (json, fileName) => {
 const downloadUrl = (url, outFile) => {
   string(url);
   string(outFile);
-  return invoke$n('Download.download', url, outFile);
+  return invoke$o('Download.download', url, outFile);
 };
 
 const name$20 = 'Download';
@@ -10053,7 +10060,7 @@ const show$9 = async (editor, message, rowIndex, columnIndex) => {
   const x$1 = x(editor, rowIndex, columnIndex);
   // @ts-ignore
   const y$1 = y(editor, rowIndex);
-  await invoke$p(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
+  await invoke$q(/* EditorError.show */'EditorError.show', /* message */message, /* x */x$1, /* y */y$1);
 };
 
 const Commands$1U = {
@@ -10068,7 +10075,7 @@ const EditorError_ipc = {
 /**
  * @enum {string}
  */
-const UiStrings$h = {
+const UiStrings$g = {
   Copy: 'Copy',
   CopyLineDown: 'Copy Line Down',
   CopyLineUp: 'Copy Line Up',
@@ -10088,58 +10095,58 @@ const UiStrings$h = {
   FormatDocument: 'Format Document',
   SourceActions: 'Source Actions'};
 const goToDefinition = () => {
-  return i18nString(UiStrings$h.GoToDefinition);
+  return i18nString(UiStrings$g.GoToDefinition);
 };
 const goToTypeDefinition = () => {
-  return i18nString(UiStrings$h.GoToTypeDefinition);
+  return i18nString(UiStrings$g.GoToTypeDefinition);
 };
 const findAllReferences = () => {
-  return i18nString(UiStrings$h.FindAllReferences);
+  return i18nString(UiStrings$g.FindAllReferences);
 };
 const findAllImplementations = () => {
-  return i18nString(UiStrings$h.FindAllImplementations);
+  return i18nString(UiStrings$g.FindAllImplementations);
 };
 const cut = () => {
-  return i18nString(UiStrings$h.Cut);
+  return i18nString(UiStrings$g.Cut);
 };
 const copy$2 = () => {
-  return i18nString(UiStrings$h.Copy);
+  return i18nString(UiStrings$g.Copy);
 };
 const paste = () => {
-  return i18nString(UiStrings$h.Paste);
+  return i18nString(UiStrings$g.Paste);
 };
 const undo = () => {
-  return i18nString(UiStrings$h.Undo);
+  return i18nString(UiStrings$g.Undo);
 };
 const redo = () => {
-  return i18nString(UiStrings$h.Redo);
+  return i18nString(UiStrings$g.Redo);
 };
 const toggleLineComment = () => {
-  return i18nString(UiStrings$h.ToggleLineComment);
+  return i18nString(UiStrings$g.ToggleLineComment);
 };
 const toggleBlockComment = () => {
-  return i18nString(UiStrings$h.ToggleBlockComment);
+  return i18nString(UiStrings$g.ToggleBlockComment);
 };
 const selectAll = () => {
-  return i18nString(UiStrings$h.SelectAll);
+  return i18nString(UiStrings$g.SelectAll);
 };
 const copyLineUp = () => {
-  return i18nString(UiStrings$h.CopyLineUp);
+  return i18nString(UiStrings$g.CopyLineUp);
 };
 const copyLineDown = () => {
-  return i18nString(UiStrings$h.CopyLineDown);
+  return i18nString(UiStrings$g.CopyLineDown);
 };
 const moveLineUp = () => {
-  return i18nString(UiStrings$h.MoveLineUp);
+  return i18nString(UiStrings$g.MoveLineUp);
 };
 const moveLineDown = () => {
-  return i18nString(UiStrings$h.MoveLineDown);
+  return i18nString(UiStrings$g.MoveLineDown);
 };
 const formatDocument = () => {
-  return i18nString(UiStrings$h.FormatDocument);
+  return i18nString(UiStrings$g.FormatDocument);
 };
 const sourceAction = () => {
-  return i18nString(UiStrings$h.SourceActions);
+  return i18nString(UiStrings$g.SourceActions);
 };
 
 const Separator$3 = 1;
@@ -10233,7 +10240,7 @@ const MenuEntriesEdit = {
 /**
  * @enum {string}
  */
-const UiStrings$g = {
+const UiStrings$f = {
   NewFile: 'New File',
   NewWindow: 'New Window',
   OpenFile: 'Open File',
@@ -10244,28 +10251,28 @@ const UiStrings$g = {
   SaveAll: 'Save All'
 };
 const newFile = () => {
-  return i18nString(UiStrings$g.NewFile);
+  return i18nString(UiStrings$f.NewFile);
 };
 const newWindow$1 = () => {
-  return i18nString(UiStrings$g.NewWindow);
+  return i18nString(UiStrings$f.NewWindow);
 };
 const openFile$2 = () => {
-  return i18nString(UiStrings$g.OpenFile);
+  return i18nString(UiStrings$f.OpenFile);
 };
 const openFolder$3 = () => {
-  return i18nString(UiStrings$g.OpenFolder);
+  return i18nString(UiStrings$f.OpenFolder);
 };
 const openRecent = () => {
-  return i18nString(UiStrings$g.OpenRecent);
+  return i18nString(UiStrings$f.OpenRecent);
 };
 const save$1 = () => {
-  return i18nString(UiStrings$g.Save);
+  return i18nString(UiStrings$f.Save);
 };
 const saveAll = () => {
-  return i18nString(UiStrings$g.SaveAll);
+  return i18nString(UiStrings$f.SaveAll);
 };
 const exit$1 = () => {
-  return i18nString(UiStrings$g.Exit);
+  return i18nString(UiStrings$f.Exit);
 };
 
 const id$k = File;
@@ -10337,7 +10344,7 @@ const MenuEntriesGo = {
 /**
  * @enum {string}
  */
-const UiStrings$f = {
+const UiStrings$e = {
   About: 'About',
   CheckForUpdates: 'Check For Updates',
   ColorTheme: 'Color Theme',
@@ -10348,35 +10355,35 @@ const UiStrings$f = {
   ToggleDeveloperTools: 'Toggle Developer Tools'
 };
 const toggleDeveloperTools = () => {
-  return i18nString(UiStrings$f.ToggleDeveloperTools);
+  return i18nString(UiStrings$e.ToggleDeveloperTools);
 };
 const openProcessExplorer = () => {
-  return i18nString(UiStrings$f.OpenProcessExplorer);
+  return i18nString(UiStrings$e.OpenProcessExplorer);
 };
 const checkForUpdates = () => {
-  return i18nString(UiStrings$f.CheckForUpdates);
+  return i18nString(UiStrings$e.CheckForUpdates);
 };
 const about = () => {
-  return i18nString(UiStrings$f.About);
+  return i18nString(UiStrings$e.About);
 };
 const commandPalette = () => {
-  return i18nString(UiStrings$f.CommandPalette);
+  return i18nString(UiStrings$e.CommandPalette);
 };
 const settings$1 = () => {
-  return i18nString(UiStrings$f.Settings);
+  return i18nString(UiStrings$e.Settings);
 };
 const keyboardShortcuts = () => {
-  return i18nString(UiStrings$f.KeyboardShortcuts);
+  return i18nString(UiStrings$e.KeyboardShortcuts);
 };
 const colorTheme = () => {
-  return i18nString(UiStrings$f.ColorTheme);
+  return i18nString(UiStrings$e.ColorTheme);
 };
 
 const isAutoUpdateSupported = () => {
   if (platform !== Electron$1) {
     return false;
   }
-  return invoke$n('IsAutoUpdateSupported.isAutoUpdateSupported');
+  return invoke$o('IsAutoUpdateSupported.isAutoUpdateSupported');
 };
 
 const id$i = Help$1;
@@ -10472,19 +10479,19 @@ const MenuEntriesSelection = {
 /**
  * @enum {string}
  */
-const UiStrings$e = {
+const UiStrings$d = {
   SplitTerminal: 'Split Terminal',
   KillTerminal: 'Kill Terminal',
   NewTerminal: 'New Terminal'
 };
 const splitTerminal = () => {
-  return i18nString(UiStrings$e.SplitTerminal);
+  return i18nString(UiStrings$d.SplitTerminal);
 };
 const killTerminal = () => {
-  return i18nString(UiStrings$e.KillTerminal);
+  return i18nString(UiStrings$d.KillTerminal);
 };
 const newTerminal = () => {
-  return i18nString(UiStrings$e.NewTerminal);
+  return i18nString(UiStrings$d.NewTerminal);
 };
 
 const id$f = Terminal;
@@ -10556,7 +10563,7 @@ const SubMenu = 'submenu';
 /**
  * @enum {string}
  */
-const UiStrings$d = {
+const UiStrings$c = {
   Help: 'Help',
   File: 'File',
   Edit: 'Edit',
@@ -10570,60 +10577,60 @@ const UiStrings$d = {
   ToggleDeveloperTools: 'Toggle Developer Tools'};
 const toElectronMenuItem = entry => {
   switch (entry.label) {
-    case UiStrings$d.Help:
+    case UiStrings$c.Help:
       return {
         label: entry.label,
         role: Help,
         submenu: []
       };
-    case UiStrings$d.File:
+    case UiStrings$c.File:
       return {
         label: entry.label,
         role: FileMenu,
         submenu: []
       };
-    case UiStrings$d.Edit:
+    case UiStrings$c.Edit:
       return {
         label: entry.label,
         role: EditMenu,
         submenu: []
       };
-    case UiStrings$d.Exit:
+    case UiStrings$c.Exit:
       return {
         label: entry.label,
         role: Quit
       };
-    case UiStrings$d.Undo:
+    case UiStrings$c.Undo:
       return {
         label: entry.label,
         role: Undo
       };
-    case UiStrings$d.Redo:
+    case UiStrings$c.Redo:
       return {
         label: entry.label,
         role: Redo
       };
-    case UiStrings$d.Cut:
+    case UiStrings$c.Cut:
       return {
         label: entry.label,
         role: Cut
       };
-    case UiStrings$d.Copy:
+    case UiStrings$c.Copy:
       return {
         label: entry.label,
         role: Copy
       };
-    case UiStrings$d.Paste:
+    case UiStrings$c.Paste:
       return {
         label: entry.label,
         role: Paste
       };
-    case UiStrings$d.SelectAll:
+    case UiStrings$c.SelectAll:
       return {
         label: entry.label,
         role: SelectAll
       };
-    case UiStrings$d.ToggleDeveloperTools:
+    case UiStrings$c.ToggleDeveloperTools:
       return {
         label: entry.label,
         role: ToggleDevTools
@@ -10688,7 +10695,7 @@ const state$g = {
 };
 const setItems = async items => {
   const windowId = await getWindowId();
-  return invoke$n('ElectronApplicationMenu.setItems', windowId, items);
+  return invoke$o('ElectronApplicationMenu.setItems', windowId, items);
 };
 const getEntryMap = async modules => {
   const map = Object.create(null);
@@ -10751,7 +10758,7 @@ const ElectronBrowserView_ipc = {
 };
 
 const writeText = text => {
-  return invoke$n('ElectronClipBoard.writeText', text);
+  return invoke$o('ElectronClipBoard.writeText', text);
 };
 
 const name$1Y = 'ElectronClipBoard';
@@ -10780,7 +10787,7 @@ const ElectronContextMenu_ipc = {
 
 const name$1W = 'ElectronWindow';
 const Commands$1P = {
-  close: close$5,
+  close: close$4,
   maximize: maximize$2,
   minimize: minimize$2,
   openNew: openNew$1,
@@ -10799,7 +10806,7 @@ const ElectronWindow_ipc = {
 
 const name$1V = 'ErrorHandling';
 const Commands$1O = {
-  handleError: handleError$2,
+  handleError: handleError$1,
   showErrorDialog: showErrorDialog
 };
 
@@ -10810,7 +10817,7 @@ const ErrorHandling_ipc = {
 };
 
 const exit = () => {
-  return invoke$n('Exit.exit');
+  return invoke$o('Exit.exit');
 };
 
 const name$1U = 'Exit';
@@ -10833,7 +10840,7 @@ const getCommandsFromExtension = extension => {
 const getCommandsFromExtensions = extensions => {
   return extensions.flatMap(getCommandsFromExtension);
 };
-const getCommands$e = async () => {
+const getCommands$f = async () => {
   const extensions = await getExtensions$1();
   const commands = getCommandsFromExtensions(extensions);
   return commands;
@@ -10851,13 +10858,13 @@ const executeCommand = (id, ...args) => {
   });
 };
 const searchFileWithFetch = (...args) => {
-  return invoke$m('SearchFileWithFetch.searchFileWithFetch', ...args);
+  return invoke$n('SearchFileWithFetch.searchFileWithFetch', ...args);
 };
 const searchFileWithHtml = (...args) => {
-  return invoke$m('SearchFileWithHtml.searchFileWithHtml', ...args);
+  return invoke$n('SearchFileWithHtml.searchFileWithHtml', ...args);
 };
 const searchFileWithMemory = (...args) => {
-  return invoke$m('SearchFileWithMemory.searchFileWithMemory', ...args);
+  return invoke$n('SearchFileWithMemory.searchFileWithMemory', ...args);
 };
 
 const state$f = {
@@ -10898,7 +10905,7 @@ const name$1T = 'ExtensionHost';
 // prettier-ignore
 const Commands$1M = {
   loadWebExtension: loadWebExtension,
-  getCommands: getCommands$e,
+  getCommands: getCommands$f,
   executeCommand: executeCommand,
   searchFileWithFetch: searchFileWithFetch,
   searchFileWithHtml: searchFileWithHtml,
@@ -10950,7 +10957,7 @@ const Extensions_ipc = {
 
 const showDirectoryPicker = async options => {
   try {
-    return await invoke$p('FilePicker.showDirectoryPicker', options);
+    return await invoke$q('FilePicker.showDirectoryPicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -10961,11 +10968,11 @@ const showDirectoryPicker = async options => {
   }
 };
 const showFilePicker = options => {
-  return invoke$p('FilePicker.showFilePicker', options);
+  return invoke$q('FilePicker.showFilePicker', options);
 };
 const showSaveFilePicker = async options => {
   try {
-    return await invoke$p('FilePicker.showSaveFilePicker', options);
+    return await invoke$q('FilePicker.showSaveFilePicker', options);
   } catch (error) {
     if (error &&
     // @ts-ignore
@@ -11051,15 +11058,15 @@ const show$8 = async (uri, top, left) => {
     if (version !== state$e.versionId) {
       return;
     }
-    await invoke$p(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$q(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* imageUrl */blobUrl, /* top */top - TOP, /* left */left - WIDTH - SPACE);
   } catch (error) {
     console.error(error);
-    await invoke$p(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
+    await invoke$q(/* Viewlet.hydrate */3028, /* id */'ImagePreview', /* message */'Image could not be loaded', /* top */top - TOP, /* left */left - WIDTH - SPACE);
   }
 };
 const hide$4 = async () => {
   ++state$e.versionId;
-  await invoke$p(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
+  await invoke$q(/* Viewlet.dispose */'Viewlet.dispose', /* id */'ImagePreview');
 };
 
 // TODO only use ImagePreview module via ipc -> that way is is always lazyloaded
@@ -11114,7 +11121,7 @@ class RawDataEvent extends Event {
     this.data = data;
   }
 }
-const handleData$2 = (id, data) => {
+const handleData$1 = (id, data) => {
   const search = state$d.searches[id];
   if (!search) {
     return;
@@ -11130,7 +11137,7 @@ const handleCanceled = id => {
   search.dispatchEvent(new Event('canceled'));
   delete state$d.searches[id];
 };
-const handleError$1 = (id, error) => {
+const handleError = (id, error) => {
   const search = state$d.searches[id];
   if (!search) {
     return;
@@ -11141,8 +11148,8 @@ const handleError$1 = (id, error) => {
 const name$1L = 'IncrementalTextSearch';
 const Commands$1E = {
   handleCanceled: handleCanceled,
-  handleData: handleData$2,
-  handleError: handleError$1,
+  handleData: handleData$1,
+  handleError: handleError,
   handleExit: handleExit,
   handleFinished: handleFinished
 };
@@ -11209,7 +11216,7 @@ const getFindWidgetWorkerUrl = () => {
 
 const extensionHostSubWorkerUrl = `${assetDir}/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js`;
 
-const getConfiguredWorkerUrl$e = () => {
+const getConfiguredWorkerUrl$f = () => {
   let configuredWorkerUrl = get$e('develop.extensionHostSubWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -11221,7 +11228,7 @@ const getConfiguredWorkerUrl$e = () => {
   return configuredWorkerUrl;
 };
 const getExtensionHostSubWorkerUrl = () => {
-  return getConfiguredWorkerUrl$e();
+  return getConfiguredWorkerUrl$f();
 };
 
 const renameWorkerUrl = `${assetDir}/packages/rename-worker/dist/renameWorkerMain.js`;
@@ -12126,7 +12133,7 @@ const show$7 = async (x, y, id, mouseBlocking = false, ...args) => {
   });
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  await invoke$p(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
+  await invoke$q(/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking);
 };
 const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   // TODO delete old menus
@@ -12148,7 +12155,7 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   const height = getMenuHeight(subMenuItems);
   const visible = getVisible(subMenu.items, -1, false, subMenu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
-  invoke$p(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
+  invoke$q(/* Menu.showMenu */'Menu.showMenu', /* x */subMenu.x, /* y */subMenu.y, /* width */width, /* height */height, /* items */subMenu.items, /* level */subMenu.level, /* parentIndex */index, /* dom */dom);
 };
 const showSubMenu = async (level, index) => {
   await showSubMenuAtEnter(level, index, -1, -1);
@@ -12208,7 +12215,7 @@ const hide$3 = async (restoreFocus = true) => {
     return;
   }
   state$b.menus = [];
-  await invoke$p(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
+  await invoke$q(/* Menu.hide */'Menu.hide', /* restoreFocus */restoreFocus);
 };
 
 // TODO difference between focusing with mouse or keyboard
@@ -12218,7 +12225,7 @@ const hide$3 = async (restoreFocus = true) => {
 const hideSubMenus = async level => {
   if (level < state$b.menus.length) {
     state$b.menus = state$b.menus.slice(0, level + 1);
-    await invoke$p(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
+    await invoke$q(/* Menu.hideSubMenu */'Menu.hideSubMenu', /* level */level + 1);
   }
 };
 const MENU_DELAY_TRIANGLE = 300;
@@ -12263,7 +12270,7 @@ const handleMouseLeave = async () => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = -1;
-  await invoke$p(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
+  await invoke$q(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */-1);
 };
 const focusIndex$4 = async (menu, index) => {
   if (menu.items.length === 0) {
@@ -12271,7 +12278,7 @@ const focusIndex$4 = async (menu, index) => {
   }
   const oldFocusedIndex = menu.focusedIndex;
   menu.focusedIndex = index;
-  await invoke$p(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
+  await invoke$q(/* Menu.focusIndex */'Menu.focusIndex', /* level */menu.level, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */index);
 };
 const getIndexToFocusNextStartingAt = (items, startIndex) => {
   for (let i = startIndex; i < startIndex + items.length; i++) {
@@ -12516,22 +12523,22 @@ const state$9 = {
   focusedPart: PART_TITLE_BAR
 };
 const focusActivityBar = async () => {
-  await invoke$p(/* ActivityBar.focus */717115);
+  await invoke$q(/* ActivityBar.focus */717115);
 };
 const focusStatusBar = async () => {
-  await invoke$p(/* StatusBar.focus */8882);
+  await invoke$q(/* StatusBar.focus */8882);
 };
 const focusPanel = async () => {
-  await invoke$p(/* Panel.focus */6664);
+  await invoke$q(/* Panel.focus */6664);
 };
 const focusSideBar = async () => {
-  await invoke$p(/* SideBar.focus */5554);
+  await invoke$q(/* SideBar.focus */5554);
 };
 const focusTitleBar = async () => {
-  await invoke$p(/* TitleBar.focus */1331);
+  await invoke$q(/* TitleBar.focus */1331);
 };
 const focusMain = async () => {
-  await invoke$p(/* Main.focus */2145);
+  await invoke$q(/* Main.focus */2145);
 };
 const focusPart = part => {
   state$9.focusedPart = part;
@@ -12642,7 +12649,7 @@ const create$T = async (type, text) => {
     type,
     text
   });
-  await invoke$p(/* Notification.create */'Notification.create', /* type */type, /* text */text);
+  await invoke$q(/* Notification.create */'Notification.create', /* type */type, /* text */text);
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
@@ -12651,7 +12658,7 @@ const showWithOptions = async (type, text, options) => {
     text,
     options
   });
-  await invoke$p(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
+  await invoke$q(/* Notification.createWithOptions */993, /* type */type, /* text */text, /* options */options);
 };
 const handleClick$4 = index => {
   console.log('handle click');
@@ -12666,14 +12673,14 @@ const handleClick$4 = index => {
     option
   });
 };
-const dispose$s = async id => {
-  await invoke$p(/* Notification.dispose */'Notification.dispose', /* id */id);
+const dispose$r = async id => {
+  await invoke$q(/* Notification.dispose */'Notification.dispose', /* id */id);
 };
 
 const name$1B = 'Notification';
 const Commands$1t = {
   create: create$T,
-  dispose: dispose$s,
+  dispose: dispose$r,
   handleClick: handleClick$4,
   showWithOptions: showWithOptions
 };
@@ -12686,7 +12693,7 @@ const Notification_ipc = {
 
 const openUrlWeb = async url => {
   try {
-    await invoke$p(/* Open.openUrl */'Open.openUrl', /* url */url);
+    await invoke$q(/* Open.openUrl */'Open.openUrl', /* url */url);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -12762,7 +12769,7 @@ const Preferences_ipc = {
 };
 
 const prompt = (message, defaultValue) => {
-  return invoke$p('Prompt.prompt', message, defaultValue);
+  return invoke$q('Prompt.prompt', message, defaultValue);
 };
 
 const name$1w = 'Prompt';
@@ -12777,7 +12784,7 @@ const Prompt_ipc = {
 };
 
 const rebuildNodePty = async () => {
-  await invoke$n('RebuildNodePty.rebuildNodePty');
+  await invoke$o('RebuildNodePty.rebuildNodePty');
 };
 
 const name$1v = 'RebuildNodePty';
@@ -12901,7 +12908,7 @@ const SessionStorage_ipc = {
   name: name$1p
 };
 
-const getConfiguredWorkerUrl$d = (preferenceKey, fallback) => {
+const getConfiguredWorkerUrl$e = (preferenceKey, fallback) => {
   let configuredWorkerUrl = get$e(preferenceKey) || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -12916,7 +12923,7 @@ const getConfiguredWorkerUrl$d = (preferenceKey, fallback) => {
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
 
 const launchTestWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$d('develop.testWorkerPath', testWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$e('develop.testWorkerPath', testWorkerUrl);
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
@@ -12928,7 +12935,7 @@ const launchTestWorker = async () => {
 
 const execute$1 = async href => {
   const ipc = await launchTestWorker();
-  await invoke$q(ipc, 'Test.execute', href);
+  await invoke$r(ipc, 'Test.execute', href);
 };
 
 const name$1o = 'Test';
@@ -12943,19 +12950,19 @@ const Test_ipc = {
 };
 
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return invoke$p('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$q('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return invoke$p('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$q('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay = (...args) => {
-  return invoke$p('TestFrameWork.showOverlay', ...args);
+  return invoke$q('TestFrameWork.showOverlay', ...args);
 };
 const performAction = (...args) => {
-  return invoke$p('TestFrameWork.performAction', ...args);
+  return invoke$q('TestFrameWork.performAction', ...args);
 };
 const checkConditionError = (...args) => {
-  return invoke$p('TestFrameWork.checkConditionError', ...args);
+  return invoke$q('TestFrameWork.checkConditionError', ...args);
 };
 
 const name$1n = 'TestFrameWork';
@@ -12994,7 +13001,7 @@ const Commands$1d = {
   getAllStates: getAllStates,
   openWidget: openWidget,
   send: send,
-  dispose: dispose$t
+  dispose: dispose$s
 };
 
 const Viewlet_ipc = {
@@ -13005,7 +13012,7 @@ const Viewlet_ipc = {
 
 const name$1k = 'Window';
 const Commands$1c = {
-  close: close$4,
+  close: close$3,
   exit: exit$2,
   maximize: maximize$1,
   minimize: minimize$1,
@@ -13024,7 +13031,7 @@ const Window_ipc = {
 
 const name$1j = 'Workspace';
 const Commands$1b = {
-  close: close$6,
+  close: close$5,
   getPath: getPath,
   getUri: getUri$1,
   hydrate: hydrate$9,
@@ -13050,10 +13057,10 @@ const WindowTitle_ipc = {
 };
 
 const mock = () => {
-  return invoke$p('PointerCapture.mock');
+  return invoke$q('PointerCapture.mock');
 };
 const unmock = () => {
-  return invoke$p('PointerCapture.unmock');
+  return invoke$q('PointerCapture.unmock');
 };
 
 const name$1h = 'PointerCapture';
@@ -13156,7 +13163,7 @@ const set$4 = async (url, contentSecurityPolicy) => {
   if (platform === Web$1) {
     return;
   }
-  await invoke$n('ContentSecurityPolicy.set', url, contentSecurityPolicy);
+  await invoke$o('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
 const set$3 = async (url, contentSecurityPolicy) => {
@@ -13199,14 +13206,14 @@ const launchTerminalWorker = async () => {
 };
 
 const {
-  invoke: invoke$g,
+  invoke: invoke$h,
   invokeAndTransfer: invokeAndTransfer$3
 } = getOrCreateWorker(launchTerminalWorker);
 
 const create$S = async canvasId => {
   number(canvasId);
   const id = create$13();
-  await invoke$p('OffscreenCanvas.create', canvasId, id);
+  await invoke$q('OffscreenCanvas.create', canvasId, id);
   const canvas = acquire(id);
   return canvas;
 };
@@ -13535,7 +13542,7 @@ const ExtensionHostHover_ipc = {
 const editorWorkerUrl = `${assetDir}/packages/editor-worker/dist/editorWorkerMain.js`;
 
 const launchEditorWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$d('developer.editorWorkerPath', editorWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$e('developer.editorWorkerPath', editorWorkerUrl);
   const id = create$13();
   let ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
@@ -13552,19 +13559,19 @@ const launchEditorWorker = async () => {
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
-  await invoke$q(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
+  await invoke$r(ipc, 'Initialize.initialize', syntaxHighlightingWorker, syncIncremental);
   return ipc;
 };
 
 const {
-  invoke: invoke$f,
+  invoke: invoke$g,
   invokeAndTransfer: invokeAndTransfer$2
 } = getOrCreateWorker(launchEditorWorker);
-const actualInvoke = invoke$f;
+const actualInvoke = invoke$g;
 
 const markdownWorkerUrl = `${assetDir}/packages/markdown-worker/dist/markdownWorkerMain.js`;
 
-const getConfiguredWorkerUrl$c = () => {
+const getConfiguredWorkerUrl$d = () => {
   let configuredWorkerUrl = get$e('develop.markdownWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -13580,14 +13587,14 @@ const launchMarkdownWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$c()
+    url: getConfiguredWorkerUrl$d()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$e,
+  invoke: invoke$f,
   invokeAndTransfer: invokeAndTransfer$1
 } = getOrCreateWorker(launchMarkdownWorker);
 
@@ -13659,7 +13666,7 @@ const ExtensionHostManagement_ipc = {
 
 const syntaxHighlightingWorkerUrl = `${assetDir}/packages/syntax-highlighting-worker/dist/syntaxHighlightingWorkerMain.js`;
 
-const getConfiguredWorkerUrl$b = () => {
+const getConfiguredWorkerUrl$c = () => {
   let configuredWorkerUrl = get$e('developer.syntaxHighlightingWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -13671,7 +13678,7 @@ const getConfiguredWorkerUrl$b = () => {
   return configuredWorkerUrl;
 };
 const launchSyntaxHighlightingWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$b();
+  const configuredWorkerUrl = getConfiguredWorkerUrl$c();
   const name = 'Syntax Highlighting Worker';
   const id = create$13();
   let ipc = await create$14({
@@ -13724,7 +13731,7 @@ const Transferrable_ipc = {
 };
 
 const getWebViewsNode = async () => {
-  const webViews = await invoke$n('ExtensionHost.getWebViews');
+  const webViews = await invoke$o('ExtensionHost.getWebViews');
   return webViews;
 };
 
@@ -13764,13 +13771,13 @@ const setPort = async (uid, port, origin, portType) => {
  * @deprecated
  */
 const getWebViewInfo = providerId => {
-  return invoke$m('ExtensionHostWebView.getWebViewInfo', providerId);
+  return invoke$n('ExtensionHostWebView.getWebViewInfo', providerId);
 };
 const getWebViewInfo2 = providerId => {
-  return invoke$m('ExtensionHostWebView.getWebViewInfo2', providerId);
+  return invoke$n('ExtensionHostWebView.getWebViewInfo2', providerId);
 };
 const create3 = async (uri, id) => {
-  await invoke$m('WebView.create3', {
+  await invoke$n('WebView.create3', {
     id,
     uri,
     platform: platform,
@@ -13787,14 +13794,14 @@ const registerInterceptor = async (id, port) => {
   await invokeAndTransfer$5('WebView.registerInterceptor', id, port);
 };
 const unregisterInterceptor = async id => {
-  await invoke$m('WebView.unregisterInterceptor', id);
+  await invoke$n('WebView.unregisterInterceptor', id);
 };
 const compat = {
   sharedProcessInvoke(...args) {
-    return invoke$n(...args);
+    return invoke$o(...args);
   },
   rendererProcessInvoke(...args) {
-    return invoke$p(...args);
+    return invoke$q(...args);
   },
   rendererProcessInvokeAndTransfer(...args) {
     return invokeAndTransfer$8(...args);
@@ -13803,7 +13810,7 @@ const compat = {
     return invokeAndTransfer$5(...args);
   },
   extensionHostWorkerInvoke(...args) {
-    return invoke$m(...args);
+    return invoke$n(...args);
   },
   getWebViews() {
     return getWebViews$1();
@@ -13860,14 +13867,14 @@ const getOrCreate$1 = () => {
   }
   return state$7.ipc;
 };
-const invoke$d = async (method, ...params) => {
+const invoke$e = async (method, ...params) => {
   const ipc = await getOrCreate$1();
-  return invoke$q(ipc, method, ...params);
+  return invoke$r(ipc, method, ...params);
 };
 
 const name$U = 'SearchProcess';
 const Commands$M = {
-  invoke: invoke$d
+  invoke: invoke$e
 };
 
 const SearchProcess_ipc = {
@@ -13891,13 +13898,13 @@ const executeTextSearchProvider = async (scheme, query) => {
   return result;
 };
 const textSearchHtml = (...args) => {
-  return invoke$m('TextSearchHtml.textSearch', ...args);
+  return invoke$n('TextSearchHtml.textSearch', ...args);
 };
 const textSearchFetch = (...args) => {
-  return invoke$m('TextSearchFetch.textSearch', ...args);
+  return invoke$n('TextSearchFetch.textSearch', ...args);
 };
 const textSearchMemory = (...args) => {
-  return invoke$m('TextSearchMemory.textSearch', ...args);
+  return invoke$n('TextSearchMemory.textSearch', ...args);
 };
 
 const name$T = 'ExtensionHostTextSearch';
@@ -13954,22 +13961,22 @@ const handleExtensionStatusUpdate = async () => {
   // TODO inform all viewlets
 };
 const disable = async id => {
-  return invoke$n(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
+  return invoke$o(/* ExtensionManagement.disable */'ExtensionManagement.disable', /* id */id);
 };
 const enable = async id => {
-  return invoke$n(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
+  return invoke$o(/* ExtensionManagement.enable */'ExtensionManagement.enable', /* id */id);
 };
 const getAllExtensions = async () => {
   if (platform === Web$1) {
     return [];
   }
-  return invoke$n(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
+  return invoke$o(/* ExtensionManagement.getAllExtensions */'ExtensionManagement.getAllExtensions');
 };
 const getExtension2 = async id => {
-  return invoke$m('Extensions.getExtension', id);
+  return invoke$n('Extensions.getExtension', id);
 };
 const getExtensionsEtag = async () => {
-  const etag = await invoke$n('ExtensionManagement.getExtensionsEtag');
+  const etag = await invoke$o('ExtensionManagement.getExtensionsEtag');
   return etag;
 };
 
@@ -13991,10 +13998,10 @@ const ExtensionManagement_ipc = {
 };
 
 const getVirtualDom$3 = html => {
-  return invoke$e('Markdown.getMarkDownVirtualDom', html);
+  return invoke$f('Markdown.getMarkDownVirtualDom', html);
 };
 const renderMarkdown = (markdown, options) => {
-  return invoke$e('Markdown.renderMarkdown', markdown, options);
+  return invoke$f('Markdown.renderMarkdown', markdown, options);
 };
 
 const name$O = 'Markdown';
@@ -14016,10 +14023,10 @@ const create$R = id => {
   };
 };
 const loadContent$N = async state => {
-  await invoke$i('About.create', state.id);
-  await invoke$i('About.loadContent2', state.id);
-  const diffResult = await invoke$i('About.diff2', state.id);
-  const commands = await invoke$i('About.render2', state.id, diffResult);
+  await invoke$j('About.create', state.id);
+  await invoke$j('About.loadContent2', state.id);
+  const diffResult = await invoke$j('About.diff2', state.id);
+  const commands = await invoke$j('About.render2', state.id, diffResult);
   return {
     ...state,
     commands
@@ -14028,9 +14035,9 @@ const loadContent$N = async state => {
 
 const wrapAboutCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$i(`About.${key}`, state.id, ...args);
-    const diffResult = await invoke$i(`About.diff2`, state.id);
-    const commands = await invoke$i('About.render2', state.id, diffResult);
+    await invoke$j(`About.${key}`, state.id, ...args);
+    const diffResult = await invoke$j(`About.diff2`, state.id);
+    const commands = await invoke$j('About.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -14043,8 +14050,8 @@ const wrapAboutCommand = key => {
 };
 
 const Commands$F = {};
-const getCommands$d = async () => {
-  const commands = await invoke$i('About.getCommandIds');
+const getCommands$e = async () => {
+  const commands = await invoke$j('About.getCommandIds');
   for (const command of commands) {
     Commands$F[command] = wrapAboutCommand(command);
   }
@@ -14054,7 +14061,7 @@ const getCommands$d = async () => {
 const Css$H = ["/css/parts/ViewletAbout.css", "/css/parts/ViewletDialog.css"];
 
 const getKeyBindings$j = () => {
-  return invoke$i('About.getKeyBindings');
+  return invoke$j('About.getKeyBindings');
 };
 
 const name$N = 'About';
@@ -14096,18 +14103,18 @@ const apply = (oldState, newState) => {
 };
 
 const hasFunctionalRender$F = true;
-const hasFunctionalRootRender$q = true;
-const hasFunctionalEvents$f = true;
-const renderDialog$1 = {
+const hasFunctionalRootRender$r = true;
+const hasFunctionalEvents$g = true;
+const renderDialog$2 = {
   isEqual(oldState, newState) {
     return false;
   },
   apply: apply,
   multiple: true
 };
-const render$I = [renderDialog$1];
-const renderEventListeners$e = async () => {
-  const listeners = await invoke$i('About.renderEventListeners');
+const render$I = [renderDialog$2];
+const renderEventListeners$f = async () => {
+  const listeners = await invoke$j('About.renderEventListeners');
   return listeners;
 };
 
@@ -14116,16 +14123,16 @@ const ViewletAbout_ipc = {
   Commands: Commands$F,
   Css: Css$H,
   create: create$R,
-  getCommands: getCommands$d,
+  getCommands: getCommands$e,
   getKeyBindings: getKeyBindings$j,
-  hasFunctionalEvents: hasFunctionalEvents$f,
+  hasFunctionalEvents: hasFunctionalEvents$g,
   hasFunctionalRender: hasFunctionalRender$F,
-  hasFunctionalRootRender: hasFunctionalRootRender$q,
+  hasFunctionalRootRender: hasFunctionalRootRender$r,
   loadContent: loadContent$N,
   name: name$N,
   render: render$I,
-  renderDialog: renderDialog$1,
-  renderEventListeners: renderEventListeners$e
+  renderDialog: renderDialog$2,
+  renderEventListeners: renderEventListeners$f
 };
 
 const Tab = 1;
@@ -14137,7 +14144,6 @@ const Focused = 1 << 5;
 const MarginTop = 1 << 6;
 
 const Add = 'Add';
-const Blank = 'Blank';
 const ClearAll = 'ClearAll';
 const CollapseAll = 'CollapseAll';
 const DebugAlt2 = 'DebugAlt2';
@@ -14155,7 +14161,7 @@ const Trash = 'Trash';
 /**
  * @enum {string}
  */
-const UiStrings$c = {
+const UiStrings$b = {
   Explorer: 'Explorer',
   Search: 'Search',
   SourceControl: 'Source Control',
@@ -14169,37 +14175,37 @@ const UiStrings$c = {
   HideActivityBar: 'Hide Activity Bar'
 };
 const explorer$1 = () => {
-  return i18nString(UiStrings$c.Explorer);
+  return i18nString(UiStrings$b.Explorer);
 };
 const search = () => {
-  return i18nString(UiStrings$c.Search);
+  return i18nString(UiStrings$b.Search);
 };
 const sourceControl = () => {
-  return i18nString(UiStrings$c.SourceControl);
+  return i18nString(UiStrings$b.SourceControl);
 };
 const runAndDebug = () => {
-  return i18nString(UiStrings$c.RunAndDebug);
+  return i18nString(UiStrings$b.RunAndDebug);
 };
 const extensions = () => {
-  return i18nString(UiStrings$c.Extensions);
+  return i18nString(UiStrings$b.Extensions);
 };
 const settings = () => {
-  return i18nString(UiStrings$c.Settings);
+  return i18nString(UiStrings$b.Settings);
 };
 const additionalViews = () => {
-  return i18nString(UiStrings$c.AdditionalViews);
+  return i18nString(UiStrings$b.AdditionalViews);
 };
 const activityBar = () => {
-  return i18nString(UiStrings$c.ActivityBar);
+  return i18nString(UiStrings$b.ActivityBar);
 };
 const moveSideBarRight$1 = () => {
-  return i18nString(UiStrings$c.MoveSideBarRight);
+  return i18nString(UiStrings$b.MoveSideBarRight);
 };
 const moveSideBarLeft$1 = () => {
-  return i18nString(UiStrings$c.MoveSideBarLeft);
+  return i18nString(UiStrings$b.MoveSideBarLeft);
 };
 const hideActivityBar$1 = () => {
-  return i18nString(UiStrings$c.HideActivityBar);
+  return i18nString(UiStrings$b.HideActivityBar);
 };
 
 const getActivityBarItems = () => {
@@ -14780,7 +14786,7 @@ const getVisibleActivityBarItems = state => {
 };
 
 const hasFunctionalRender$E = true;
-const hasFunctionalRootRender$p = true;
+const hasFunctionalRootRender$q = true;
 const renderItems$a = {
   isEqual(oldState, newState) {
     return oldState.filteredItems === newState.filteredItems && oldState.height === newState.height && oldState.selectedIndex === newState.selectedIndex && oldState.focusedIndex === newState.focusedIndex;
@@ -14846,7 +14852,7 @@ const ViewletActivityBar_ipc = {
   handleSideBarViewletChange,
   hasFunctionalRender: hasFunctionalRender$E,
   hasFunctionalResize: hasFunctionalResize$j,
-  hasFunctionalRootRender: hasFunctionalRootRender$p,
+  hasFunctionalRootRender: hasFunctionalRootRender$q,
   loadContent: loadContent$M,
   menus: menus$d,
   name: name$M,
@@ -14861,11 +14867,11 @@ const ViewletActivityBar_ipc = {
 /**
  * @enum {string}
  */
-const UiStrings$b = {
+const UiStrings$a = {
   FailedToLoadAudio: 'Failed to load audio: {PH1}'
 };
 const getImprovedErrorMessage = message => {
-  return i18nString(UiStrings$b.FailedToLoadAudio, {
+  return i18nString(UiStrings$a.FailedToLoadAudio, {
     PH1: message
   });
 };
@@ -14894,7 +14900,7 @@ const handleAudioError = (state, code, message) => {
     audioErrorMessage: improvedMessage
   };
 };
-const dispose$r = async state => {
+const dispose$q = async state => {
   const {
     src
   } = state;
@@ -14944,7 +14950,7 @@ const getAudioVirtualDom = (src, errorMessage) => {
 };
 
 const hasFunctionalRender$D = true;
-const hasFunctionalRootRender$o = true;
+const hasFunctionalRootRender$p = true;
 const renderAudio = {
   isEqual(oldState, newState) {
     return oldState.src === newState.src && oldState.audioErrorMessage === newState.audioErrorMessage;
@@ -14963,10 +14969,10 @@ const ViewletAudio_ipc = {
   Commands: Commands$D,
   Css: Css$F,
   create: create$P,
-  dispose: dispose$r,
+  dispose: dispose$q,
   handleAudioError,
   hasFunctionalRender: hasFunctionalRender$D,
-  hasFunctionalRootRender: hasFunctionalRootRender$o,
+  hasFunctionalRootRender: hasFunctionalRootRender$p,
   loadContent: loadContent$L,
   name: name$L,
   render: render$G
@@ -14982,7 +14988,7 @@ const create$O = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$K = async state => {
-  const browserViewMap = await invoke$n('ElectronBrowserView.getAll');
+  const browserViewMap = await invoke$o('ElectronBrowserView.getAll');
   return {
     ...state,
     browserViewMap
@@ -15032,7 +15038,7 @@ const create$N = (id, uri, x, y, width, height) => {
 };
 const loadContent$J = state => {
   const update = async () => {
-    await invoke$p(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$q(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -15042,7 +15048,7 @@ const loadContent$J = state => {
 
 // TODO use contentLoadedEffects
 
-const dispose$q = state => {
+const dispose$p = state => {
   clearInterval(state.interval);
   state.interval = -1;
   state.disposed = true;
@@ -15055,7 +15061,7 @@ const ViewletClock_ipc = {
   __proto__: null,
   Commands: Commands$C,
   create: create$N,
-  dispose: dispose$q,
+  dispose: dispose$p,
   loadContent: loadContent$J,
   name: name$K
 };
@@ -15104,8 +15110,8 @@ const getKeyBindings$h = () => {
 };
 
 const hasFunctionalRender$B = true;
-const hasFunctionalRootRender$n = true;
-const renderDialog = {
+const hasFunctionalRootRender$o = true;
+const renderDialog$1 = {
   isEqual(oldState, newState) {
     return oldState.productName === newState.productName && oldState.lines === newState.lines;
   },
@@ -15122,7 +15128,7 @@ const renderFocus$2 = {
     return ['setFocused', newState.focused];
   }
 };
-const render$E = [renderDialog, renderFocus$2];
+const render$E = [renderDialog$1, renderFocus$2];
 
 const name$J = 'Confirm';
 
@@ -15137,11 +15143,11 @@ const ViewletConfirm_ipc = {
   handleClickOk,
   handleFocusIn,
   hasFunctionalRender: hasFunctionalRender$B,
-  hasFunctionalRootRender: hasFunctionalRootRender$n,
+  hasFunctionalRootRender: hasFunctionalRootRender$o,
   loadContent: loadContent$I,
   name: name$J,
   render: render$E,
-  renderDialog,
+  renderDialog: renderDialog$1,
   renderFocus: renderFocus$2
 };
 
@@ -15256,7 +15262,7 @@ const getVirtualDom$1 = textContent => {
 };
 
 const hasFunctionalRender$A = true;
-const renderText$1 = {
+const renderText = {
   isEqual(oldState, newState) {
     return oldState.text === newState.text;
   },
@@ -15265,7 +15271,7 @@ const renderText$1 = {
     return ['setDom', dom];
   }
 };
-const render$D = [renderText$1];
+const render$D = [renderText];
 
 const Button = 1;
 const Select = 2;
@@ -15358,7 +15364,7 @@ const getActionsVirtualDom = actions => {
   }, ...actions.flatMap(getActionVirtualDom$1)];
 };
 
-const getActions$7 = () => {
+const getActions$6 = () => {
   return [{
     type: Filter$1,
     id: ''
@@ -15375,7 +15381,7 @@ const renderActions$a = {
     return oldState === newState;
   },
   apply(oldState, newState) {
-    const actions = getActions$7();
+    const actions = getActions$6();
     const dom = getActionsVirtualDom(actions);
     return dom;
   }
@@ -15408,7 +15414,7 @@ const Escape = 'Escape';
 /**
  * @enum {string}
  */
-const UiStrings$a = {
+const UiStrings$9 = {
   PressDesiredKeyCombinationThenPressEnter: 'Press Desired Key Combination, Then Press Enter',
   Copy: 'Copy',
   CopyCommandId: 'Copy Command ID',
@@ -15421,34 +15427,34 @@ const UiStrings$a = {
   ShowSameKeyBindings: 'Show Same Keybindings'
 };
 const pressDesiredKeyCombinationThenPressEnter = () => {
-  return i18nString(UiStrings$a.PressDesiredKeyCombinationThenPressEnter);
+  return i18nString(UiStrings$9.PressDesiredKeyCombinationThenPressEnter);
 };
 const copy$1 = () => {
-  return i18nString(UiStrings$a.Copy);
+  return i18nString(UiStrings$9.Copy);
 };
 const copyCommandId = () => {
-  return i18nString(UiStrings$a.CopyCommandId);
+  return i18nString(UiStrings$9.CopyCommandId);
 };
 const copyCommandTitle = () => {
-  return i18nString(UiStrings$a.CopyCommandTitle);
+  return i18nString(UiStrings$9.CopyCommandTitle);
 };
 const changeKeyBinding = () => {
-  return i18nString(UiStrings$a.ChangeKeyBinding);
+  return i18nString(UiStrings$9.ChangeKeyBinding);
 };
 const addKeyBinding = () => {
-  return i18nString(UiStrings$a.AddKeyBinding);
+  return i18nString(UiStrings$9.AddKeyBinding);
 };
 const removeKeyBinding = () => {
-  return i18nString(UiStrings$a.RemoveKeyBinding);
+  return i18nString(UiStrings$9.RemoveKeyBinding);
 };
 const resetKeyBinding = () => {
-  return i18nString(UiStrings$a.ResetKeyBinding);
+  return i18nString(UiStrings$9.ResetKeyBinding);
 };
 const changeWhenExpression = () => {
-  return i18nString(UiStrings$a.ChangeWhenExpression);
+  return i18nString(UiStrings$9.ChangeWhenExpression);
 };
 const showSameKeyBindings = () => {
-  return i18nString(UiStrings$a.ShowSameKeyBindings);
+  return i18nString(UiStrings$9.ShowSameKeyBindings);
 };
 
 const create$K = (id, uri, x, y, width, height) => {
@@ -15467,7 +15473,7 @@ const loadContent$G = state => {
     message: pressDesiredKeyCombinationThenPressEnter()
   };
 };
-const dispose$p = (state, value) => {
+const dispose$o = (state, value) => {
   const {
     uid
   } = state;
@@ -15475,7 +15481,7 @@ const dispose$p = (state, value) => {
   return state;
 };
 const handleBlur$2 = state => {
-  return dispose$p(state, '');
+  return dispose$o(state, '');
 };
 const handleKeyDown$1 = (state, key, altKey, ctrlKey, shiftKey, metaKey) => {
   // TODO handle with keybindings?
@@ -15483,10 +15489,10 @@ const handleKeyDown$1 = (state, key, altKey, ctrlKey, shiftKey, metaKey) => {
     return state;
   }
   if (key === Enter) {
-    return dispose$p(state, key);
+    return dispose$o(state, key);
   }
   if (key === Escape) {
-    return dispose$p(state, '');
+    return dispose$o(state, '');
   }
   const keyBindingString = getKeyBindingString(key, altKey, ctrlKey, shiftKey);
   return {
@@ -15525,7 +15531,7 @@ const getDefineKeyBindingsVirtualDom = message => {
 };
 
 const hasFunctionalRender$z = true;
-const hasFunctionalRootRender$m = true;
+const hasFunctionalRootRender$n = true;
 const renderValue = {
   isEqual(oldState, newState) {
     return oldState.value === newState.value;
@@ -15561,7 +15567,7 @@ const ViewletDefineKeyBinding_ipc = {
   handleBlur: handleBlur$2,
   handleKeyDown: handleKeyDown$1,
   hasFunctionalRender: hasFunctionalRender$z,
-  hasFunctionalRootRender: hasFunctionalRootRender$m,
+  hasFunctionalRootRender: hasFunctionalRootRender$n,
   loadContent: loadContent$G,
   render: render$C
 };
@@ -15604,7 +15610,7 @@ const loadContent$F = (state, savedState, ...args) => {
     buttons
   };
 };
-const dispose$o = async state => {};
+const dispose$n = async state => {};
 const handleClick$3 = async (state, index) => {
   const {
     options
@@ -15613,7 +15619,7 @@ const handleClick$3 = async (state, index) => {
   // TODO handle case when index is out of bounds
   switch (option) {
     case 'Show Command Output':
-      await dispose$o();
+      await dispose$n();
       const uri = 'data://';
       await execute$4(/* Main.openUri */'Main.openUri', uri);
       // TODO show stderr in editor
@@ -15623,7 +15629,7 @@ const handleClick$3 = async (state, index) => {
 };
 
 const Commands$y = {
-  close: dispose$o,
+  close: dispose$n,
   handleClick: handleClick$3
 };
 
@@ -15679,7 +15685,7 @@ const ViewletDialog_ipc = {
   Commands: Commands$y,
   Css: Css$A,
   create: create$J,
-  dispose: dispose$o,
+  dispose: dispose$n,
   handleClick: handleClick$3,
   hasFunctionalRender: hasFunctionalRender$y,
   loadContent: loadContent$F,
@@ -15700,7 +15706,7 @@ const launchDiffWorker = async () => {
 };
 
 const {
-  invoke: invoke$c} = getOrCreateWorker(launchDiffWorker);
+  invoke: invoke$d} = getOrCreateWorker(launchDiffWorker);
 
 /**
  *
@@ -15709,7 +15715,7 @@ const {
  * @returns
  */
 const diff = (linesA, linesB) => {
-  return invoke$c('Diff.diff', linesA, linesB);
+  return invoke$d('Diff.diff', linesA, linesB);
 };
 
 const getDiffEditorContents = async (left, right) => {
@@ -16387,11 +16393,10 @@ const getVisibleDiffLinesWithTokens = (lines, changes, minLineY, maxLineY, langu
 
 const SetFocused = 'setFocused';
 const SetScrollBar = 'setScrollBar';
-const SetText = 'setText';
 const SetTitle = 'setTitle';
 
 const hasFunctionalRender$x = true;
-const hasFunctionalRootRender$l = true;
+const hasFunctionalRootRender$m = true;
 const renderChanges$1 = {
   isEqual(oldState, newState) {
     return oldState.changes === newState.changes && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY;
@@ -16429,7 +16434,7 @@ const ViewletDiffEditor_ipc = {
   create: create$H,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$x,
-  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  hasFunctionalRootRender: hasFunctionalRootRender$m,
   loadContent: loadContent$E,
   name: name$G,
   render: render$A,
@@ -16600,7 +16605,7 @@ const getE2eTestVirtualDom = content => {
 };
 
 const hasFunctionalRender$w = true;
-const hasFunctionalRootRender$k = true;
+const hasFunctionalRootRender$l = true;
 const renderElements = {
   isEqual(oldState, newState) {
     return oldState.name === newState.name && oldState.content === newState.content;
@@ -16628,7 +16633,7 @@ const renderPreviewTransform = {
 };
 const render$z = [renderElements, renderIframe$2, renderPreviewTransform];
 
-const getActions$6 = () => {
+const getActions$5 = () => {
   return [];
 };
 
@@ -16637,7 +16642,7 @@ const renderActions$9 = {
     return oldState.name === newState.name;
   },
   apply(oldState, newState) {
-    const actions = getActions$6();
+    const actions = getActions$5();
     const dom = getActionsVirtualDom(actions);
     return dom;
   }
@@ -16657,7 +16662,7 @@ const ViewletE2eTest_ipc = {
   handleSashCornerPointerUp,
   hasFunctionalRender: hasFunctionalRender$w,
   hasFunctionalResize: hasFunctionalResize$i,
-  hasFunctionalRootRender: hasFunctionalRootRender$k,
+  hasFunctionalRootRender: hasFunctionalRootRender$l,
   loadContent: loadContent$D,
   menus: menus$c,
   name: name$F,
@@ -16681,8 +16686,8 @@ const create$D = (id, uri, x, y, width, height) => {
   };
 };
 const getTests = async () => {
-  const root = await invoke$n('Platform.getRoot');
-  const testPath = await invoke$n('Platform.getTestPath');
+  const root = await invoke$o('Platform.getRoot');
+  const testPath = await invoke$o('Platform.getTestPath');
   const absolutePath = `${root}/${testPath}/src`;
   const dirents = await readDirWithFileTypes$9(absolutePath);
   const filteredDirents = dirents.slice(1);
@@ -16848,7 +16853,7 @@ const getVisibleE2eTests = (tests, index) => {
 };
 
 const hasFunctionalRender$v = true;
-const hasFunctionalRootRender$j = true;
+const hasFunctionalRootRender$k = true;
 const renderTests = {
   isEqual(oldState, newState) {
     return oldState.tests === newState.tests && oldState.index === newState.index;
@@ -16877,7 +16882,7 @@ const renderMessagePort = {
 };
 const render$y = [renderTests, renderIframe$1, renderMessagePort];
 
-const getActions$5 = () => {
+const getActions$4 = () => {
   return [{
     type: Button,
     id: 'runAll',
@@ -16891,7 +16896,7 @@ const renderActions$8 = {
     return oldState.tests === newState.tests;
   },
   apply(oldState, newState) {
-    const actions = getActions$5();
+    const actions = getActions$4();
     const dom = getActionsVirtualDom(actions);
     return dom;
   }
@@ -16908,7 +16913,7 @@ const ViewletE2eTests_ipc = {
   handleContextMenu: handleContextMenu$4,
   handleLoad,
   hasFunctionalRender: hasFunctionalRender$v,
-  hasFunctionalRootRender: hasFunctionalRootRender$j,
+  hasFunctionalRootRender: hasFunctionalRootRender$k,
   loadContent: loadContent$C,
   menus: menus$b,
   name: name$E,
@@ -17320,7 +17325,7 @@ const rerender = async state => {
     commands
   };
 };
-const contentLoaded$7 = async state => {
+const contentLoaded$6 = async state => {
   const {
     languageId
   } = state;
@@ -17343,7 +17348,7 @@ const updateSemanticTokens = async state => {
     if (error && error instanceof Error && error.message.startsWith('Failed to execute semantic token provider: VError: no semantic token provider found for')) {
       return;
     }
-    await handleError$2(error, false);
+    await handleError$1(error, false);
   }
 };
 const updateDiagnostics = async state => {
@@ -17396,7 +17401,7 @@ const resize$l = (state, dimensions) => {
   const newState = setBounds(state, dimensions.x, dimensions.y, dimensions.width, dimensions.height, state.columnWidth);
   return newState;
 };
-const dispose$n = state => {
+const dispose$m = state => {
   removeConnectedEditor(state.id);
 };
 const hasFunctionalRender$u = true;
@@ -17442,7 +17447,7 @@ const Commands$u = {
   ...wrapEditorCommands(ids),
   // TODO
   async showOverlayMessage(state, editor, ...args) {
-    await invoke$p(...args);
+    await invoke$q(...args);
     return state;
   }
 };
@@ -17493,11 +17498,11 @@ const ViewletEditorText_ipc = {
   CommandsWithSideEffectsLazy: CommandsWithSideEffectsLazy$1,
   Css: Css$z,
   Events: Events$5,
-  contentLoaded: contentLoaded$7,
+  contentLoaded: contentLoaded$6,
   contentLoadedEffects: contentLoadedEffects$1,
   create: create$B,
   customErrorRenderer,
-  dispose: dispose$n,
+  dispose: dispose$m,
   focus: focus$5,
   getDynamicCss,
   getKeyBindings: getKeyBindings$d,
@@ -17667,7 +17672,7 @@ const loadContent$z = state => {
     ...state
   };
 };
-const dispose$m = state => {};
+const dispose$l = state => {};
 
 const name$B = 'EmptyEditor';
 const Commands$t = {};
@@ -17676,7 +17681,7 @@ const ViewletEmptyEditor_ipc = {
   __proto__: null,
   Commands: Commands$t,
   create: create$y,
-  dispose: dispose$m,
+  dispose: dispose$l,
   loadContent: loadContent$z,
   name: name$B
 };
@@ -17684,7 +17689,7 @@ const ViewletEmptyEditor_ipc = {
 const explorerWorkerUrl = `${assetDir}/packages/explorer-worker/dist/explorerViewWorkerMain.js`;
 
 const launchExplorerWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$d('develop.explorerWorkerPath', explorerWorkerUrl);
+  const configuredWorkerUrl = getConfiguredWorkerUrl$e('develop.explorerWorkerPath', explorerWorkerUrl);
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
@@ -17695,8 +17700,8 @@ const launchExplorerWorker = async () => {
 };
 
 const {
-  invoke: invoke$b,
-  restart: restart$8
+  invoke: invoke$c,
+  restart: restart$9
 } = getOrCreateWorker(launchExplorerWorker);
 
 // TODO viewlet should only have create and refresh functions
@@ -17721,18 +17726,18 @@ const create$x = (id, uri, x, y, width, height, args, parentUid) => {
   };
 };
 const loadContent$y = async (state, savedState) => {
-  await invoke$b('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$b('Explorer.loadContent', state.uid, savedState);
-  const diffResult = await invoke$b('Explorer.diff2', state.uid);
-  const commands = await invoke$b('Explorer.render2', state.uid, diffResult);
-  const actionsDom = await invoke$b('Explorer.renderActions2', state.uid);
+  await invoke$c('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$c('Explorer.loadContent', state.uid, savedState);
+  const diffResult = await invoke$c('Explorer.diff2', state.uid);
+  const commands = await invoke$c('Explorer.render2', state.uid, diffResult);
+  const actionsDom = await invoke$c('Explorer.renderActions2', state.uid);
   return {
     ...state,
     commands,
     actionsDom
   };
 };
-const dispose$l = state => {};
+const dispose$k = state => {};
 const hasFunctionalResize$g = true;
 const resize$k = (state, dimensions) => {
   const {
@@ -17748,12 +17753,12 @@ const resize$k = (state, dimensions) => {
 };
 const getMouseActions = async () => {
   try {
-    return await invoke$b('Explorer.getMouseActions');
+    return await invoke$c('Explorer.getMouseActions');
   } catch {
     return [];
   }
 };
-const hotReload$a = async state => {
+const hotReload$b = async state => {
   if (state.isHotReloading) {
     return state;
   }
@@ -17761,16 +17766,16 @@ const hotReload$a = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$b('Explorer.saveState', state.uid);
-  await restart$8('Explorer.terminate');
+  const savedState = await invoke$c('Explorer.saveState', state.uid);
+  await restart$9('Explorer.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$b('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$b('Explorer.loadContent', state.uid, savedState);
-  const diffResult = await invoke$b('Explorer.diff2', state.uid);
-  const commands = await invoke$b('Explorer.render2', state.uid, diffResult);
+  await invoke$c('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$c('Explorer.loadContent', state.uid, savedState);
+  const diffResult = await invoke$c('Explorer.diff2', state.uid);
+  const commands = await invoke$c('Explorer.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -17780,12 +17785,12 @@ const hotReload$a = async state => {
 
 const wrapExplorerCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$b(`Explorer.${key}`, state.uid, ...args);
-    const diffResult = await invoke$b('Explorer.diff2', state.uid);
+    await invoke$c(`Explorer.${key}`, state.uid, ...args);
+    const diffResult = await invoke$c('Explorer.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$b('Explorer.render2', state.uid, diffResult);
+    const commands = await invoke$c('Explorer.render2', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -17798,12 +17803,12 @@ const wrapExplorerCommand = key => {
 };
 
 const Commands$s = {};
-const getCommands$c = async () => {
-  const commands = await invoke$b('Explorer.getCommandIds');
+const getCommands$d = async () => {
+  const commands = await invoke$c('Explorer.getCommandIds');
   for (const command of commands) {
     Commands$s[command] = wrapExplorerCommand(command);
   }
-  Commands$s['hotReload'] = hotReload$a;
+  Commands$s['hotReload'] = hotReload$b;
   Commands$s['getMouseActions'] = getMouseActions;
   return Commands$s;
 };
@@ -17811,13 +17816,13 @@ const getCommands$c = async () => {
 const Css$t = [];
 
 const getKeyBindings$c = () => {
-  return invoke$b('Explorer.getKeyBindings');
+  return invoke$c('Explorer.getKeyBindings');
 };
 
 const id$8 = Explorer;
 const getMenuEntries$c = () => {
   const explorerState = getState('Explorer');
-  return invoke$b('Explorer.getMenuEntries2', explorerState.uid);
+  return invoke$c('Explorer.getMenuEntries2', explorerState.uid);
 };
 
 const MenuEntriesExplorer = {
@@ -17831,15 +17836,15 @@ const menus$a = [MenuEntriesExplorer];
 /**
  * @enum {string}
  */
-const UiStrings$9 = {
+const UiStrings$8 = {
   Explorer: 'Explorer',
   NoFolderOpen: 'No Folder Open'
 };
 const explorer = () => {
-  return i18nString(UiStrings$9.Explorer);
+  return i18nString(UiStrings$8.Explorer);
 };
 const noFolderOpen = () => {
-  return i18nString(UiStrings$9.NoFolderOpen);
+  return i18nString(UiStrings$8.NoFolderOpen);
 };
 
 const name$A = 'Explorer';
@@ -17848,8 +17853,8 @@ const getDisplayName$1 = () => {
 };
 
 const hasFunctionalRender$t = true;
-const hasFunctionalRootRender$i = true;
-const hasFunctionalEvents$e = true;
+const hasFunctionalRootRender$j = true;
+const hasFunctionalEvents$f = true;
 const renderItems$9 = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -17858,8 +17863,8 @@ const renderItems$9 = {
   multiple: true
 };
 const render$t = [renderItems$9];
-const renderEventListeners$d = async () => {
-  const listeners = await invoke$b('Explorer.renderEventListeners');
+const renderEventListeners$e = async () => {
+  const listeners = await invoke$c('Explorer.renderEventListeners');
   return listeners;
 };
 
@@ -17892,11 +17897,11 @@ const renderTitle$4 = {
 };
 
 const restoreState = savedState => {
-  return invoke$b('Explorer.restoreState', savedState);
+  return invoke$c('Explorer.restoreState', savedState);
 };
 
 const saveState$h = state => {
-  return invoke$b('Explorer.saveState', state.uid);
+  return invoke$c('Explorer.saveState', state.uid);
 };
 
 const Events$4 = {};
@@ -17907,22 +17912,22 @@ const ViewletExplorer_ipc = {
   Css: Css$t,
   Events: Events$4,
   create: create$x,
-  dispose: dispose$l,
-  getCommands: getCommands$c,
+  dispose: dispose$k,
+  getCommands: getCommands$d,
   getDisplayName: getDisplayName$1,
   getKeyBindings: getKeyBindings$c,
   getMouseActions,
-  hasFunctionalEvents: hasFunctionalEvents$e,
+  hasFunctionalEvents: hasFunctionalEvents$f,
   hasFunctionalRender: hasFunctionalRender$t,
   hasFunctionalResize: hasFunctionalResize$g,
-  hasFunctionalRootRender: hasFunctionalRootRender$i,
-  hotReload: hotReload$a,
+  hasFunctionalRootRender: hasFunctionalRootRender$j,
+  hotReload: hotReload$b,
   loadContent: loadContent$y,
   menus: menus$a,
   name: name$A,
   render: render$t,
   renderActions: renderActions$7,
-  renderEventListeners: renderEventListeners$d,
+  renderEventListeners: renderEventListeners$e,
   renderTitle: renderTitle$4,
   resize: resize$k,
   restoreState,
@@ -17931,7 +17936,7 @@ const ViewletExplorer_ipc = {
 
 const extensionDetailViewWorkerUrl = `${assetDir}/packages/extension-detail-view-worker/dist/extensionDetailViewWorkerMain.js`;
 
-const getConfiguredWorkerUrl$a = () => {
+const getConfiguredWorkerUrl$b = () => {
   let configuredWorkerUrl = get$e('develop.extensionDetailViewWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -17947,16 +17952,16 @@ const launchExtensionDetailViewWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$a()
+    url: getConfiguredWorkerUrl$b()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'ExtensionDetail.initialize');
+  await invoke$r(ipc, 'ExtensionDetail.initialize');
   return ipc;
 };
 
 const {
-  invoke: invoke$a,
-  restart: restart$7
+  invoke: invoke$b,
+  restart: restart$8
 } = getOrCreateWorker(launchExtensionDetailViewWorker);
 
 const create$w = (id, uri, x, y, width, height) => {
@@ -17981,17 +17986,17 @@ const create$w = (id, uri, x, y, width, height) => {
 // TODO when there are multiple extension with the same id,
 // probably need to pass extension location from extensions viewlet
 const loadContent$x = async (state, savedState) => {
-  await invoke$a('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, platform, assetDir);
+  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, platform, assetDir);
   const isTest$1 = isTest();
-  await invoke$a('ExtensionDetail.loadContent2', state.uid, savedState, isTest$1);
-  const diffResult = await invoke$a('ExtensionDetail.diff2', state.uid);
-  const commands = await invoke$a('ExtensionDetail.render2', state.uid, diffResult);
+  await invoke$b('ExtensionDetail.loadContent2', state.uid, savedState, isTest$1);
+  const diffResult = await invoke$b('ExtensionDetail.diff2', state.uid);
+  const commands = await invoke$b('ExtensionDetail.render2', state.uid, diffResult);
   return {
     ...state,
     commands
   };
 };
-const hotReload$9 = async state => {
+const hotReload$a = async state => {
   if (state.isHotReloading) {
     return state;
   }
@@ -17999,11 +18004,11 @@ const hotReload$9 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  await restart$7('ExtensionDetail.terminate');
-  await invoke$a('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, platform, assetDir);
-  await invoke$a('ExtensionDetail.loadContent2', state.uid, {});
-  const diffResult = await invoke$a('ExtensionDetail.diff2', state.uid);
-  const commands = await invoke$a('ExtensionDetail.render2', state.uid, diffResult);
+  await restart$8('ExtensionDetail.terminate');
+  await invoke$b('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, platform, assetDir);
+  await invoke$b('ExtensionDetail.loadContent2', state.uid, {});
+  const diffResult = await invoke$b('ExtensionDetail.diff2', state.uid);
+  const commands = await invoke$b('ExtensionDetail.render2', state.uid, diffResult);
   state.isHotReloading = false;
   return {
     ...state,
@@ -18011,19 +18016,19 @@ const hotReload$9 = async state => {
   };
 };
 const saveState$g = async state => {
-  const savedState = await invoke$a('ExtensionDetail.saveState', state.uid);
+  const savedState = await invoke$b('ExtensionDetail.saveState', state.uid);
   return savedState;
 };
 const hasFunctionalResize$f = true;
 
 const wrapExtensionDetailCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$a(`ExtensionDetail.${key}`, state.uid, ...args);
-    const diffResult = await invoke$a('ExtensionDetail.diff2', state.uid);
+    await invoke$b(`ExtensionDetail.${key}`, state.uid, ...args);
+    const diffResult = await invoke$b('ExtensionDetail.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$a('ExtensionDetail.render2', state.uid, diffResult);
+    const commands = await invoke$b('ExtensionDetail.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -18033,12 +18038,12 @@ const wrapExtensionDetailCommand = key => {
 };
 
 const Commands$r = {};
-const getCommands$b = async () => {
-  const commands = await invoke$a('ExtensionDetail.getCommandIds');
+const getCommands$c = async () => {
+  const commands = await invoke$b('ExtensionDetail.getCommandIds');
   for (const command of commands) {
     Commands$r[command] = wrapExtensionDetailCommand(command);
   }
-  Commands$r['hotReload'] = hotReload$9;
+  Commands$r['hotReload'] = hotReload$a;
   return Commands$r;
 };
 
@@ -18047,7 +18052,7 @@ const Css$s = ["/css/parts/AdditionalDetails.css", "/css/parts/BrowserScrollBar.
 const menus$9 = [];
 const getMenus$2 = async () => {
   try {
-    const modules = await invoke$a('ExtensionDetail.getMenus');
+    const modules = await invoke$b('ExtensionDetail.getMenus');
     const adjusted = modules.map(module => {
       return {
         ...module,
@@ -18065,8 +18070,8 @@ const getMenus$2 = async () => {
 const name$z = 'ExtensionDetail';
 
 const hasFunctionalRender$s = true;
-const hasFunctionalRootRender$h = true;
-const hasFunctionalEvents$d = true;
+const hasFunctionalRootRender$i = true;
+const hasFunctionalEvents$e = true;
 const renderDom$1 = {
   isEqual(oldState, newState) {
     return false;
@@ -18075,8 +18080,8 @@ const renderDom$1 = {
   multiple: true
 };
 const render$s = [renderDom$1];
-const renderEventListeners$c = async () => {
-  const listeners = await invoke$a('ExtensionDetail.renderEventListeners');
+const renderEventListeners$d = async () => {
+  const listeners = await invoke$b('ExtensionDetail.renderEventListeners');
   return listeners;
 };
 
@@ -18085,24 +18090,24 @@ const ViewletExtensionDetail_ipc = {
   Commands: Commands$r,
   Css: Css$s,
   create: create$w,
-  getCommands: getCommands$b,
+  getCommands: getCommands$c,
   getMenus: getMenus$2,
-  hasFunctionalEvents: hasFunctionalEvents$d,
+  hasFunctionalEvents: hasFunctionalEvents$e,
   hasFunctionalRender: hasFunctionalRender$s,
   hasFunctionalResize: hasFunctionalResize$f,
-  hasFunctionalRootRender: hasFunctionalRootRender$h,
-  hotReload: hotReload$9,
+  hasFunctionalRootRender: hasFunctionalRootRender$i,
+  hotReload: hotReload$a,
   loadContent: loadContent$x,
   menus: menus$9,
   name: name$z,
   render: render$s,
-  renderEventListeners: renderEventListeners$c,
+  renderEventListeners: renderEventListeners$d,
   saveState: saveState$g
 };
 
 const extensionSearchViewWorkerUrl = `${assetDir}/packages/extension-search-view-worker/dist/extensionSearchViewWorkerMain.js`;
 
-const getConfiguredWorkerUrl$9 = () => {
+const getConfiguredWorkerUrl$a = () => {
   let configuredWorkerUrl = get$e('develop.extensionSearchViewWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -18118,21 +18123,21 @@ const launchExtensionSearchViewWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$9()
+    url: getConfiguredWorkerUrl$a()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$9,
-  restart: restart$6
+  invoke: invoke$a,
+  restart: restart$7
 } = getOrCreateWorker(launchExtensionSearchViewWorker);
 
 // then state can be recycled by Viewlet when there is only a single ViewletExtensions instance
 
 const saveState$f = async state => {
-  const savedState = await invoke$9('SearchExtensions.saveState', state.id);
+  const savedState = await invoke$a('SearchExtensions.saveState', state.id);
   return savedState;
 };
 const create$v = (id, uri, x, y, width, height) => {
@@ -18149,20 +18154,20 @@ const create$v = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$w = async (state, savedState) => {
-  await invoke$9('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
-  await invoke$9('SearchExtensions.loadContent', state.id, savedState);
-  const diffResult = await invoke$9('SearchExtensions.diff2', state.id);
-  const commands = await invoke$9('SearchExtensions.render3', state.id, diffResult);
+  await invoke$a('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
+  await invoke$a('SearchExtensions.loadContent', state.id, savedState);
+  const diffResult = await invoke$a('SearchExtensions.diff2', state.id);
+  const commands = await invoke$a('SearchExtensions.render3', state.id, diffResult);
   return {
     ...state,
     commands
   };
 };
-const dispose$k = () => {};
+const dispose$j = () => {};
 
 // TODO lazyload this
 
-const hotReload$8 = async state => {
+const hotReload$9 = async state => {
   if (state.isHotReloading) {
     return state;
   }
@@ -18170,16 +18175,16 @@ const hotReload$8 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$9('SearchExtensions.saveState', state.uid);
-  await restart$6('SearchExtensions.terminate');
+  const savedState = await invoke$a('SearchExtensions.saveState', state.uid);
+  await restart$7('SearchExtensions.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$9('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
-  await invoke$9('SearchExtensions.loadContent', state.id, savedState);
-  const diffResult = await invoke$9('SearchExtensions.diff2', state.id);
-  const commands = await invoke$9('SearchExtensions.render3', oldState.id, diffResult);
+  await invoke$a('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
+  await invoke$a('SearchExtensions.loadContent', state.id, savedState);
+  const diffResult = await invoke$a('SearchExtensions.diff2', state.id);
+  const commands = await invoke$a('SearchExtensions.render3', oldState.id, diffResult);
   return {
     ...oldState,
     commands,
@@ -18189,9 +18194,9 @@ const hotReload$8 = async state => {
 
 const wrapExtensionSearchCommand = key => {
   const wrapped = async (state, ...args) => {
-    await invoke$9(`SearchExtensions.${key}`, state.uid, ...args);
-    const diffResult = await invoke$9(`SearchExtensions.diff2`, state.uid);
-    const commands = await invoke$9('SearchExtensions.render3', state.uid, diffResult);
+    await invoke$a(`SearchExtensions.${key}`, state.uid, ...args);
+    const diffResult = await invoke$a(`SearchExtensions.diff2`, state.uid);
+    const commands = await invoke$a('SearchExtensions.render3', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -18201,23 +18206,23 @@ const wrapExtensionSearchCommand = key => {
 };
 
 const Commands$q = {};
-const getCommands$a = async () => {
-  const commands = await invoke$9('SearchExtensions.getCommandIds');
+const getCommands$b = async () => {
+  const commands = await invoke$a('SearchExtensions.getCommandIds');
   for (const command of commands) {
     Commands$q[command] = wrapExtensionSearchCommand(command);
   }
-  Commands$q['hotReload'] = hotReload$8;
+  Commands$q['hotReload'] = hotReload$9;
   return Commands$q;
 };
 
 const Css$r = ["/css/parts/ViewletExtensions.css"];
 
 const getKeyBindings$b = () => {
-  return invoke$9('SearchExtensions.getKeyBindings');
+  return invoke$a('SearchExtensions.getKeyBindings');
 };
 
 const getMenuEntries$b = async () => {
-  const entries = await invoke$9('SearchExtensions.getMenuEntries');
+  const entries = await invoke$a('SearchExtensions.getMenuEntries');
   return entries;
   // {
   //   id: 'enable',
@@ -18258,8 +18263,8 @@ const menus$8 = [{
 const name$y = 'Extensions';
 
 const hasFunctionalRender$r = true;
-const hasFunctionalRootRender$g = true;
-const hasFunctionalEvents$c = true;
+const hasFunctionalRootRender$h = true;
+const hasFunctionalEvents$d = true;
 const renderItems$8 = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -18268,8 +18273,8 @@ const renderItems$8 = {
   multiple: true
 };
 const render$r = [renderItems$8];
-const renderEventListeners$b = async () => {
-  const listeners = await invoke$9('SearchExtensions.renderEventListeners');
+const renderEventListeners$c = async () => {
+  const listeners = await invoke$a('SearchExtensions.renderEventListeners');
   return listeners;
 };
 
@@ -18277,7 +18282,7 @@ const Check = 'Check';
 const ListFlat = 'ListFlat';
 const Refresh = 'Refresh';
 
-const getActions$4 = () => {
+const getActions$3 = () => {
   // TODO compute from worker
   return [{
     type: Button,
@@ -18295,7 +18300,7 @@ const renderActions$6 = {
     return oldState === newState;
   },
   apply(oldState, newState) {
-    const actions = getActions$4();
+    const actions = getActions$3();
     const dom = getActionsVirtualDom(actions);
     return dom;
   }
@@ -18333,20 +18338,20 @@ const ViewletExtensions_ipc = {
   Commands: Commands$q,
   Css: Css$r,
   create: create$v,
-  dispose: dispose$k,
-  getCommands: getCommands$a,
+  dispose: dispose$j,
+  getCommands: getCommands$b,
   getKeyBindings: getKeyBindings$b,
-  hasFunctionalEvents: hasFunctionalEvents$c,
+  hasFunctionalEvents: hasFunctionalEvents$d,
   hasFunctionalRender: hasFunctionalRender$r,
   hasFunctionalResize: hasFunctionalResize$e,
-  hasFunctionalRootRender: hasFunctionalRootRender$g,
-  hotReload: hotReload$8,
+  hasFunctionalRootRender: hasFunctionalRootRender$h,
+  hotReload: hotReload$9,
   loadContent: loadContent$w,
   menus: menus$8,
   name: name$y,
   render: render$r,
   renderActions: renderActions$6,
-  renderEventListeners: renderEventListeners$b,
+  renderEventListeners: renderEventListeners$c,
   renderTitle: renderTitle$3,
   resize: resize$j,
   saveState: saveState$f
@@ -18354,7 +18359,7 @@ const ViewletExtensions_ipc = {
 
 const iframeInspectorWorkerUrl = `${assetDir}/packages/iframe-inspector/dist/iframeInspectorWorkerMain.js`;
 
-const getConfiguredWorkerUrl$8 = () => {
+const getConfiguredWorkerUrl$9 = () => {
   let configuredWorkerUrl = get$e('develop.iframeInspectorWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -18370,15 +18375,15 @@ const launchIframeInspectorWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$8()
+    url: getConfiguredWorkerUrl$9()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$8,
-  restart: restart$5
+  invoke: invoke$9,
+  restart: restart$6
 } = getOrCreateWorker(launchIframeInspectorWorker);
 
 const create$u = (id, uri, x, y, width, height) => {
@@ -18393,16 +18398,16 @@ const create$u = (id, uri, x, y, width, height) => {
   };
 };
 const loadContent$v = async state => {
-  await invoke$8('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
-  await invoke$8('IframeInspector.loadContent', state.id);
-  const diffResult = await invoke$8('IframeInspector.diff2', state.id);
-  const commands = await invoke$8('IframeInspector.render2', state.id, diffResult);
+  await invoke$9('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
+  await invoke$9('IframeInspector.loadContent', state.id);
+  const diffResult = await invoke$9('IframeInspector.diff2', state.id);
+  const commands = await invoke$9('IframeInspector.render2', state.id, diffResult);
   return {
     ...state,
     commands
   };
 };
-const hotReload$7 = async state => {
+const hotReload$8 = async state => {
   if (state.isHotReloading) {
     return state;
   }
@@ -18410,16 +18415,16 @@ const hotReload$7 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$8('IframeInspector.saveState', state.uid);
-  await restart$5('IframeInspector.terminate');
+  const savedState = await invoke$9('IframeInspector.saveState', state.uid);
+  await restart$6('IframeInspector.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$8('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
-  await invoke$8('IframeInspector.loadContent', state.id, savedState);
-  const diffResult = await invoke$8('IframeInspector.diff2', oldState.id);
-  const commands = await invoke$8('IframeInspector.render2', oldState.id, diffResult);
+  await invoke$9('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
+  await invoke$9('IframeInspector.loadContent', state.id, savedState);
+  const diffResult = await invoke$9('IframeInspector.diff2', oldState.id);
+  const commands = await invoke$9('IframeInspector.render2', oldState.id, diffResult);
   return {
     ...oldState,
     commands,
@@ -18429,9 +18434,9 @@ const hotReload$7 = async state => {
 
 const wrapIframeInspectorCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$8(`IframeInspector.${key}`, state.id, ...args);
-    const diffResult = await invoke$8('IframeInspector.diff2', state.id);
-    const commands = await invoke$8('IframeInspector.render2', state.id, diffResult);
+    await invoke$9(`IframeInspector.${key}`, state.id, ...args);
+    const diffResult = await invoke$9('IframeInspector.diff2', state.id);
+    const commands = await invoke$9('IframeInspector.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -18444,26 +18449,26 @@ const wrapIframeInspectorCommand = key => {
 };
 
 const Commands$p = {};
-const getCommands$9 = async () => {
-  const commands = await invoke$8('IframeInspector.getCommandIds');
+const getCommands$a = async () => {
+  const commands = await invoke$9('IframeInspector.getCommandIds');
   for (const command of commands) {
     Commands$p[command] = wrapIframeInspectorCommand(command);
   }
-  Commands$p['hotReload'] = hotReload$7;
+  Commands$p['hotReload'] = hotReload$8;
   return Commands$p;
 };
 
 const Css$q = ["/css/parts/Table.css", "/css/parts/ViewletIframeInspector.css"];
 
 const getKeyBindings$a = () => {
-  return invoke$8('IframeInspector.getKeyBindings');
+  return invoke$9('IframeInspector.getKeyBindings');
 };
 
 const name$x = 'IframeInspector';
 
 const hasFunctionalRender$q = true;
-const hasFunctionalRootRender$f = true;
-const hasFunctionalEvents$b = true;
+const hasFunctionalRootRender$g = true;
+const hasFunctionalEvents$c = true;
 const renderContent = {
   isEqual(oldState, newState) {
     return false;
@@ -18472,8 +18477,8 @@ const renderContent = {
   multiple: true
 };
 const render$q = [renderContent];
-const renderEventListeners$a = async () => {
-  const listeners = await invoke$8('IframeInspector.renderEventListeners');
+const renderEventListeners$b = async () => {
+  const listeners = await invoke$9('IframeInspector.renderEventListeners');
   return listeners;
 };
 
@@ -18482,17 +18487,17 @@ const ViewletIframeInspector_ipc = {
   Commands: Commands$p,
   Css: Css$q,
   create: create$u,
-  getCommands: getCommands$9,
+  getCommands: getCommands$a,
   getKeyBindings: getKeyBindings$a,
-  hasFunctionalEvents: hasFunctionalEvents$b,
+  hasFunctionalEvents: hasFunctionalEvents$c,
   hasFunctionalRender: hasFunctionalRender$q,
-  hasFunctionalRootRender: hasFunctionalRootRender$f,
-  hotReload: hotReload$7,
+  hasFunctionalRootRender: hasFunctionalRootRender$g,
+  hotReload: hotReload$8,
   loadContent: loadContent$v,
   name: name$x,
   render: render$q,
   renderContent,
-  renderEventListeners: renderEventListeners$a
+  renderEventListeners: renderEventListeners$b
 };
 
 const first = () => {
@@ -18517,7 +18522,7 @@ const Collapsed = 3;
 
 const referencesWorkerUrl = `${assetDir}/packages/references-view/dist/referencesViewWorkerMain.js`;
 
-const getConfiguredWorkerUrl$7 = () => {
+const getConfiguredWorkerUrl$8 = () => {
   let configuredWorkerUrl = get$e('develop.referencesWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -18533,15 +18538,15 @@ const launchReferencesWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$7()
+    url: getConfiguredWorkerUrl$8()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'References.initialize');
+  await invoke$r(ipc, 'References.initialize');
   return ipc;
 };
 
 const {
-  invoke: invoke$7} = getOrCreateWorker(launchReferencesWorker);
+  invoke: invoke$8} = getOrCreateWorker(launchReferencesWorker);
 
 const create$t = (id, uri, x, y, width, height, args) => {
   return {
@@ -18557,16 +18562,16 @@ const create$t = (id, uri, x, y, width, height, args) => {
 // TODO speed up this function by 130% by not running activation event (onReferences) again and again
 // e.g. (21ms activation event, 11ms getReferences) => (11ms getReferences)
 const loadContent$u = async (state, savedState) => {
-  await invoke$7('References.create', state.id, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$7('References.loadContent', state.id, savedState);
-  const diff = await invoke$7('References.diff2', state.id);
-  const commands = await invoke$7('References.render2', state.id, diff);
+  await invoke$8('References.create', state.id, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$8('References.loadContent', state.id, savedState);
+  const diff = await invoke$8('References.diff2', state.id);
+  const commands = await invoke$8('References.render2', state.id, diff);
   return {
     ...state,
     commands
   };
 };
-const dispose$j = state => {
+const dispose$i = state => {
   return {
     ...state,
     disposed: true
@@ -18625,7 +18630,7 @@ const focusIndex$2 = (state, index) => {
     focusedIndex: index
   };
 };
-const hotReload$6 = state => {
+const hotReload$7 = state => {
   return {
     ...state
   };
@@ -18670,20 +18675,20 @@ const selectCurrent$1 = state => {
   return selectIndex$1(state, state.focusedIndex);
 };
 const saveState$e = async state => {
-  const savedState = await invoke$7('References.saveState', state.uid);
+  const savedState = await invoke$8('References.saveState', state.uid);
   return savedState;
 };
 
 const ViewletLocations = {
   __proto__: null,
   create: create$t,
-  dispose: dispose$j,
+  dispose: dispose$i,
   focusFirst: focusFirst$2,
   focusIndex: focusIndex$2,
   focusLast: focusLast$2,
   focusNext: focusNext$2,
   focusPrevious: focusPrevious$2,
-  hotReload: hotReload$6,
+  hotReload: hotReload$7,
   loadContent: loadContent$u,
   saveState: saveState$e,
   selectCurrent: selectCurrent$1,
@@ -18702,18 +18707,18 @@ const loadContent$t = async (state, savedState) => {
   // @ts-ignore
   return loadContent$u(state, savedState);
 };
-const contentLoaded$6 = state => {
+const contentLoaded$5 = state => {
   set$a('Locations', {
     factory: ViewletLocations,
     state
   });
   return [];
 };
-const dispose$i = dispose$j;
+const dispose$h = dispose$i;
 
 const hasFunctionalRender$p = true;
-const hasFunctionalRootRender$e = true;
-const hasFunctionalEvents$a = true;
+const hasFunctionalRootRender$f = true;
+const hasFunctionalEvents$b = true;
 const renderItems$7 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
@@ -18722,8 +18727,8 @@ const renderItems$7 = {
   multiple: true
 };
 const render$p = [renderItems$7];
-const renderEventListeners$9 = async () => {
-  const listeners = await invoke$7('References.renderEventListeners');
+const renderEventListeners$a = async () => {
+  const listeners = await invoke$8('References.renderEventListeners');
   return listeners;
 };
 
@@ -18733,20 +18738,20 @@ const Commands$o = {};
 const ViewletImplementations_ipc = {
   __proto__: null,
   Commands: Commands$o,
-  contentLoaded: contentLoaded$6,
+  contentLoaded: contentLoaded$5,
   create: create$s,
-  dispose: dispose$i,
-  hasFunctionalEvents: hasFunctionalEvents$a,
+  dispose: dispose$h,
+  hasFunctionalEvents: hasFunctionalEvents$b,
   hasFunctionalRender: hasFunctionalRender$p,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
   loadContent: loadContent$t,
   name: name$w,
   render: render$p,
-  renderEventListeners: renderEventListeners$9
+  renderEventListeners: renderEventListeners$a
 };
 
 const getInlineDiffChanges = (linesLeft, linesRight) => {
-  return invoke$c('Diff.diffInline', linesLeft, linesRight);
+  return invoke$d('Diff.diffInline', linesLeft, linesRight);
 };
 
 const create$r = (id, uri, x, y, width, height) => {
@@ -18958,7 +18963,7 @@ const getVisibleInlineDiffEditorLines = (inlineDiffLines, minLineY, maxLineY) =>
 };
 
 const hasFunctionalRender$o = true;
-const hasFunctionalRootRender$d = true;
+const hasFunctionalRootRender$e = true;
 const renderChanges = {
   isEqual(oldState, newState) {
     return oldState.inlineChanges === newState.inlineChanges && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.deltaY === newState.deltaY && oldState.height === newState.height && oldState.finalDeltaY === newState.finalDeltaY && oldState.lineNumbers === newState.lineNumbers;
@@ -18991,7 +18996,7 @@ const ViewletInlineDiffEditor_ipc = {
   create: create$r,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$o,
-  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  hasFunctionalRootRender: hasFunctionalRootRender$e,
   loadContent: loadContent$s,
   name: name$v,
   render: render$o,
@@ -19000,7 +19005,7 @@ const ViewletInlineDiffEditor_ipc = {
 
 const keyBindingsViewWorkerUrl = `${assetDir}/packages/keybindings-view-worker/dist/keyBindingsViewWorkerMain.js`;
 
-const getConfiguredWorkerUrl$6 = () => {
+const getConfiguredWorkerUrl$7 = () => {
   let configuredWorkerUrl = get$e('develop.keyBindingsViewWorkerPath') || '';
   if (configuredWorkerUrl) {
     configuredWorkerUrl = '/remote' + configuredWorkerUrl;
@@ -19016,15 +19021,15 @@ const launchKeyBindingsViewWorker = async () => {
   const ipc = await create$14({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: getConfiguredWorkerUrl$6()
+    url: getConfiguredWorkerUrl$7()
   });
   handleIpc(ipc);
   return ipc;
 };
 
 const {
-  invoke: invoke$6,
-  restart: restart$4
+  invoke: invoke$7,
+  restart: restart$5
 } = getOrCreateWorker(launchKeyBindingsViewWorker);
 
 // Based on VS Code's KeyBindings Editor (License MIT):
@@ -19044,19 +19049,19 @@ const create$q = (id, uri, x, y, width, height) => {
   };
 };
 const saveState$c = state => {
-  return invoke$6('KeyBindings.saveState', state.uid);
+  return invoke$7('KeyBindings.saveState', state.uid);
 };
 const loadContent$r = async (state, savedState) => {
-  await invoke$6('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$6('KeyBindings.loadContent', state.uid, savedState);
-  const diffResult = await invoke$6('KeyBindings.diff2', state.uid);
-  const commands = await invoke$6('KeyBindings.render3', state.uid, diffResult);
+  await invoke$7('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$7('KeyBindings.loadContent', state.uid, savedState);
+  const diffResult = await invoke$7('KeyBindings.diff2', state.uid);
+  const commands = await invoke$7('KeyBindings.render3', state.uid, diffResult);
   return {
     ...state,
     commands
   };
 };
-const hotReload$5 = async state => {
+const hotReload$6 = async state => {
   if (state.isHotReloading) {
     return state;
   }
@@ -19064,16 +19069,16 @@ const hotReload$5 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$6('KeyBindings.saveState', state.uid);
-  await restart$4('KeyBindings.terminate');
+  const savedState = await invoke$7('KeyBindings.saveState', state.uid);
+  await restart$5('KeyBindings.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$6('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$6('KeyBindings.loadContent', state.uid, savedState);
-  const diffResult = await invoke$6('KeyBindings.diff2', state.uid);
-  const commands = await invoke$6('KeyBindings.render3', oldState.uid, diffResult);
+  await invoke$7('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$7('KeyBindings.loadContent', state.uid, savedState);
+  const diffResult = await invoke$7('KeyBindings.diff2', state.uid);
+  const commands = await invoke$7('KeyBindings.render3', oldState.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -19083,9 +19088,9 @@ const hotReload$5 = async state => {
 
 const wrapKeyBindingCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$6(`KeyBindings.${key}`, state.uid, ...args);
-    const diffResult = await invoke$6('KeyBindings.diff2', state.uid);
-    const commands = await invoke$6('KeyBindings.render3', state.uid, diffResult);
+    await invoke$7(`KeyBindings.${key}`, state.uid, ...args);
+    const diffResult = await invoke$7('KeyBindings.diff2', state.uid);
+    const commands = await invoke$7('KeyBindings.render3', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -19098,19 +19103,19 @@ const wrapKeyBindingCommand = key => {
 };
 
 const Commands$m = {};
-const getCommands$8 = async () => {
-  const commands = await invoke$6('KeyBindings.getCommandIds');
+const getCommands$9 = async () => {
+  const commands = await invoke$7('KeyBindings.getCommandIds');
   for (const command of commands) {
     Commands$m[command] = wrapKeyBindingCommand(command);
   }
-  Commands$m['hotReload'] = hotReload$5;
+  Commands$m['hotReload'] = hotReload$6;
   return Commands$m;
 };
 
 const Css$o = ["/css/parts/InputBadge.css", "/css/parts/Key.css", "/css/parts/KeyBindingsHeader.css", "/css/parts/KeyBindingsTable.css", "/css/parts/Table.css", "/css/parts/ViewletKeyBindings.css"];
 
 const getKeyBindings$9 = () => {
-  return invoke$6('KeyBindings.getKeyBindings');
+  return invoke$7('KeyBindings.getKeyBindings');
 };
 
 const id$7 = KeyBindingsTable;
@@ -19174,8 +19179,8 @@ const menus$7 = [MenuEntriesKeyBindingsTable];
 const name$u = 'KeyBindings';
 
 const hasFunctionalRender$n = true;
-const hasFunctionalRootRender$c = true;
-const hasFunctionalEvents$9 = true;
+const hasFunctionalRootRender$d = true;
+const hasFunctionalEvents$a = true;
 const renderKeyBindings = {
   isEqual(oldState, newState) {
     return newState.commands && newState.commands.length === 0;
@@ -19184,8 +19189,8 @@ const renderKeyBindings = {
   multiple: true
 };
 const render$n = [renderKeyBindings];
-const renderEventListeners$8 = async () => {
-  const listeners = await invoke$6('KeyBindings.renderEventListeners');
+const renderEventListeners$9 = async () => {
+  const listeners = await invoke$7('KeyBindings.renderEventListeners');
   return listeners;
 };
 
@@ -19215,18 +19220,18 @@ const ViewletKeyBindings_ipc = {
   Commands: Commands$m,
   Css: Css$o,
   create: create$q,
-  getCommands: getCommands$8,
+  getCommands: getCommands$9,
   getKeyBindings: getKeyBindings$9,
-  hasFunctionalEvents: hasFunctionalEvents$9,
+  hasFunctionalEvents: hasFunctionalEvents$a,
   hasFunctionalRender: hasFunctionalRender$n,
   hasFunctionalResize: hasFunctionalResize$d,
-  hasFunctionalRootRender: hasFunctionalRootRender$c,
-  hotReload: hotReload$5,
+  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  hotReload: hotReload$6,
   loadContent: loadContent$r,
   menus: menus$7,
   name: name$u,
   render: render$n,
-  renderEventListeners: renderEventListeners$8,
+  renderEventListeners: renderEventListeners$9,
   resize: resize$i,
   saveState: saveState$c
 };
@@ -20008,7 +20013,7 @@ const showAsync = async (uid, points, module) => {
     if (commands) {
       commands.push(['Viewlet.append', uid, viewletUid]);
     }
-    await invoke$p('Viewlet.sendMultiple', commands);
+    await invoke$q('Viewlet.sendMultiple', commands);
     // TODO
     // 2. load module
     // 3. if module is still visible, replace placeholder with actual viewlet
@@ -21870,7 +21875,7 @@ const loadContent$p = async (state, savedState) => {
   once(Twelve, hydrateLazy);
   addListener('editor.change', handleEditorChange);
   addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$p('Viewlet.loadModule', MainTabs);
+  await invoke$q('Viewlet.loadModule', MainTabs);
   return {
     ...state,
     groups,
@@ -21893,7 +21898,7 @@ const getChildren$4 = state => {
 
 // TODO content loaded should return commands which
 // get picked up by viewletlayout and sent to renderer process
-const contentLoaded$5 = async state => {
+const contentLoaded$4 = async state => {
   const {
     groups,
     y,
@@ -21959,7 +21964,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$p(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$q(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -21984,7 +21989,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
     title,
     ...props
   });
-  await invoke$p('Viewlet.send', 'Main', 'updateTab', 1, title);
+  await invoke$q('Viewlet.send', 'Main', 'updateTab', 1, title);
   // TODO update tab title with new title
   return state;
 };
@@ -22136,7 +22141,7 @@ const handleDragOver = (state, eventX, eventY) => {
     dragOverlayVisible: true
   };
 };
-const dispose$h = () => {};
+const dispose$g = () => {};
 const handleClickClose$1 = (state, button, index) => {
   if (button !== LeftClick) {
     return state;
@@ -22745,9 +22750,9 @@ const ViewletMain_ipc = {
   Css: Css$m,
   LazyCommands: LazyCommands$3,
   Variables: Variables$7,
-  contentLoaded: contentLoaded$5,
+  contentLoaded: contentLoaded$4,
   create: create$o,
-  dispose: dispose$h,
+  dispose: dispose$g,
   focus: focus$3,
   getChildren: getChildren$4,
   getKeyBindings: getKeyBindings$7,
@@ -22784,7 +22789,7 @@ const create$n = (id, uri, x, y, width, height) => {
 };
 const loadContent$o = state => {
   const update = async () => {
-    await invoke$p(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
+    await invoke$q(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
   return {
     ...state,
@@ -22794,7 +22799,7 @@ const loadContent$o = state => {
 
 // TODO use contentLoadedEffects
 
-const dispose$g = state => {
+const dispose$f = state => {
   clearInterval(state.interval);
   state.interval = -1;
   state.disposed = true;
@@ -22807,7 +22812,7 @@ const ViewletMarkDownPreview_ipc = {
   __proto__: null,
   Commands: Commands$j,
   create: create$n,
-  dispose: dispose$g,
+  dispose: dispose$f,
   loadContent: loadContent$o,
   name: name$r
 };
@@ -22821,7 +22826,7 @@ const loadContent$n = async state => {
   console.log('noop');
   return state;
 };
-const dispose$f = state => {
+const dispose$e = state => {
   return {
     ...state,
     disposed: true
@@ -22834,48 +22839,42 @@ const ViewletNoop_ipc = {
   __proto__: null,
   Commands: Commands$i,
   create: create$m,
-  dispose: dispose$f,
+  dispose: dispose$e,
   loadContent: loadContent$n
 };
 
-const open$4 = async (id, file) => {
-  await invoke$n(/* OutputChannel.open */'OutputChannel.open', id, /* path */file);
-};
-const close$3 = async id => {
-  await invoke$n(/* OutputChannel.close */'OutputChannel.close', /* id */id);
-};
+const outputViewWorkerUrl = `${assetDir}/packages/output-view/dist/outputViewWorkerMain.js`;
 
-const getOutputChannels = () => {
-  if (platform === Web$1) {
-    return [];
+const getConfiguredWorkerUrl$6 = () => {
+  let configuredWorkerUrl = get$e('develop.outputViewWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
   }
-  return [];
-  // return ExtensionHost.invoke(
-  // /* ExtensionHostOutput.getOutputChannels */ 'ExtensionHostOutput.getOutputChannels'
-  // )
-};
-
-const toExtensionHostOption = outputChannel => {
-  return {
-    name: outputChannel.id,
-    file: outputChannel.path
-  };
+  configuredWorkerUrl = configuredWorkerUrl || outputViewWorkerUrl;
+  {
+    configuredWorkerUrl = outputViewWorkerUrl;
+  }
+  return configuredWorkerUrl;
 };
-const getOptions = async () => {
-  // TODO get list of outputChannels from extension host
-  const channels = await getOutputChannels();
-  const options = [{
-    name: 'Main',
-    file: '/tmp/log-main-process.txt'
-  }, {
-    name: 'Shared Process',
-    file: '/tmp/log-shared-process.txt'
-  }, ...channels.map(toExtensionHostOption)];
-  return options;
+const launchOutputViewWorker = async () => {
+  const name = 'Output View Worker';
+  const ipc = await create$14({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl$6()
+  });
+  handleIpc(ipc);
+  return ipc;
 };
 
+const {
+  invoke: invoke$6,
+  restart: restart$4
+} = getOrCreateWorker(launchOutputViewWorker);
+
 const create$l = uid => {
   return {
+    id: uid,
     uid,
     selectedIndex: -1,
     // TODO get list of outputChannels from extension host
@@ -22885,140 +22884,92 @@ const create$l = uid => {
   };
 };
 const loadContent$m = async state => {
-  const options = await getOptions();
-  const selectedIndex = 0;
-  // TODO duplicate send here
-  const id = 0;
-  const file = options[selectedIndex].file;
-  await open$4(id, file);
+  await invoke$6('Output.create', state.id, state.x, state.y, state.width, state.height);
+  await invoke$6('Output.loadContent2', state.id);
+  const diffResult = await invoke$6('Output.diff2', state.id);
+  const commands = await invoke$6('Output.render2', state.id, diffResult);
+  const actionsDom = await invoke$6('Output.renderActions', state.uid);
   return {
     ...state,
-    options,
-    selectedIndex
+    commands,
+    actionsDom
   };
 };
-const contentLoaded$4 = async state => {
-  return [[/* Viewlet.invoke */'Viewlet.send', /* id */'Output', /* method */'setOptions', /* options */state.options, /* selectedOptionIndex */state.selectedIndex]];
-};
-const setOutputChannel = async (state, option) => {
-  state.selectedOption = option;
-  // TODO race condition
-  await invoke$p(/* viewletSend */'Viewlet.send', /* id */'Output', /* method */'clear');
-  // TODO race condition
-  // TODO should use invoke
-  await open$4('Output', state.selectedOption);
-};
-const handleData$1 = async (state, data) => {
-  const {
-    text
-  } = state;
-  const newText = text + data;
-  return {
+const hotReload$5 = async (state, option) => {
+  if (state.isHotReloading) {
+    return state;
+  }
+  // TODO avoid mutation
+  state.isHotReloading = true;
+  const savedState = await invoke$6('Output.saveState', state.uid);
+  await restart$4('Output.terminate');
+  const oldState = {
     ...state,
-    text: newText
+    items: []
   };
-};
-const handleError = async (state, data) => {
-  const {
-    text
-  } = state;
-  const newText = text + data;
+  await invoke$6('Output.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$6('Output.loadContent2', state.uid, savedState);
+  const diffResult = await invoke$6('Output.diff2', state.uid);
+  const commands = await invoke$6('Output.render2', state.uid, diffResult);
+  const actionsDom = await invoke$6('Output.renderActions', state.uid);
   return {
-    ...state,
-    text: newText
+    ...oldState,
+    commands,
+    actionsDom,
+    isHotReloading: false
   };
 };
-const dispose$e = async state => {
-  state.disposed = true;
-  // TODO close output channel in shared process
-  await close$3('Output');
-};
-const openFindWidget = async state => {
-  // TODO use command.execute instead
-  // TODO no lazy import here
-};
-const closeFindWidget = async state => {};
 
-// export const handleError = (state, error) => {
-//   console.error(error)
-// }
+const wrapOutputCommand = key => {
+  const fn = async (state, ...args) => {
+    await invoke$6(`Output.${key}`, state.id, ...args);
+    const diffResult = await invoke$6(`Output.diff2`, state.id);
+    const commands = await invoke$6('Output.render2', state.id, diffResult);
+    if (commands.length === 0) {
+      return state;
+    }
+    return {
+      ...state,
+      commands
+    };
+  };
+  return fn;
+};
 
-const Commands$h = {
-  handleData: handleData$1,
-  handleError: handleError
+const Commands$h = {};
+const getCommands$8 = async () => {
+  const commands = await invoke$6('Output.getCommandIds');
+  for (const command of commands) {
+    Commands$h[command] = wrapOutputCommand(command);
+  }
+  Commands$h['hotReload'] = hotReload$5;
+  return Commands$h;
 };
 
 const Css$l = ["/css/parts/ViewletOutput.css", "/css/parts/Select.css"];
 
-const renderText = {
+const hasFunctionalRender$k = true;
+const hasFunctionalRootRender$c = true;
+const hasFunctionalEvents$9 = true;
+const renderDialog = {
   isEqual(oldState, newState) {
-    return oldState === newState;
+    return false;
   },
-  apply(oldState, newState) {
-    return [SetText, newState.text];
-  }
-};
-const hasFunctionalRender$k = true;
-const render$k = [renderText];
-
-/**
- * @enum {string}
- */
-const UiStrings$8 = {
-  Output: 'output',
-  ClearOutput: 'clear output',
-  TurnOffAutoScroll: 'Turn auto scrolling off',
-  OpenLogFile: 'open output log file'
-};
-const output = () => {
-  return i18nString(UiStrings$8.Output);
-};
-const clearOutput = () => {
-  return i18nString(UiStrings$8.ClearOutput);
-};
-const turnOffAutoScroll = () => {
-  return i18nString(UiStrings$8.TurnOffAutoScroll);
-};
-const openLogFile = () => {
-  return i18nString(UiStrings$8.OpenLogFile);
-};
-
-const toSelectOption = option => {
-  return option.name;
-};
-const toSelectOptions = options => {
-  return options.map(toSelectOption);
+  apply: apply,
+  multiple: true
 };
-const getActions$3 = state => {
-  const {
-    options
-  } = state;
-  return [{
-    type: Select,
-    id: output(),
-    options: toSelectOptions(options)
-  }, {
-    type: Button,
-    id: clearOutput(),
-    icon: ClearAll
-  }, {
-    type: Button,
-    id: turnOffAutoScroll(),
-    icon: Blank
-  }, {
-    type: Button,
-    id: openLogFile(),
-    icon: Blank
-  }];
+const render$k = [renderDialog];
+const renderEventListeners$8 = async () => {
+  const listeners = await invoke$6('Output.renderEventListeners');
+  return listeners;
 };
 
 const renderActions$5 = {
   isEqual(oldState, newState) {
-    return oldState === newState;
+    return false;
   },
   apply(oldState, newState) {
-    const actions = getActions$3(newState);
-    const dom = getActionsVirtualDom(actions);
+    const dom = newState.actionsDom;
     return dom;
   }
 };
@@ -23029,19 +22980,18 @@ const ViewletOutput_ipc = {
   __proto__: null,
   Commands: Commands$h,
   Css: Css$l,
-  closeFindWidget,
-  contentLoaded: contentLoaded$4,
   create: create$l,
-  dispose: dispose$e,
-  handleData: handleData$1,
-  handleError,
+  getCommands: getCommands$8,
+  hasFunctionalEvents: hasFunctionalEvents$9,
   hasFunctionalRender: hasFunctionalRender$k,
+  hasFunctionalRootRender: hasFunctionalRootRender$c,
+  hotReload: hotReload$5,
   loadContent: loadContent$m,
   name: name$q,
-  openFindWidget,
   render: render$k,
   renderActions: renderActions$5,
-  setOutputChannel
+  renderDialog,
+  renderEventListeners: renderEventListeners$8
 };
 
 const getPanelViews = () => {
@@ -23189,7 +23139,7 @@ const openViewlet$1 = async (state, id, focus = false) => {
     const currentViewletUid = currentViewletState.uid;
     number(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    await invoke$p('Viewlet.sendMultiple', commands);
+    await invoke$q('Viewlet.sendMultiple', commands);
     if (commands.at(-1).includes(Error$3)) {
       state.currentViewletId = Error$3;
     }
@@ -23340,7 +23290,7 @@ const launchProblemsWorker = async () => {
     url: getConfiguredWorkerUrl$5()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Problems.initialize');
+  await invoke$r(ipc, 'Problems.initialize');
   return ipc;
 };
 
@@ -23875,10 +23825,10 @@ const loadContent$j = async state => {
   } = state;
   const listItemHeight = 22;
   const renderAllItems = true;
-  await invoke$l('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$B.workspacePath);
-  await invoke$l('QuickPick.loadContent', state.uid);
-  const diffResult = await invoke$l('QuickPick.diff2', state.uid);
-  const commands = await invoke$l('QuickPick.render2', state.uid, diffResult);
+  await invoke$m('QuickPick.create2', state.uid, uri, listItemHeight, state.x, state.y, state.width, state.height, platform, args, renderAllItems, state$B.workspacePath);
+  await invoke$m('QuickPick.loadContent', state.uid);
+  const diffResult = await invoke$m('QuickPick.diff2', state.uid);
+  const commands = await invoke$m('QuickPick.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -23890,12 +23840,12 @@ const dispose$c = state => {
 
 const wrapQuickPickCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$l(`QuickPick.${key}`, state.uid, ...args);
-    const diffResult = await invoke$l('QuickPick.diff2', state.uid);
+    await invoke$m(`QuickPick.${key}`, state.uid, ...args);
+    const diffResult = await invoke$m('QuickPick.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$l('QuickPick.render2', state.uid, diffResult);
+    const commands = await invoke$m('QuickPick.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -23906,7 +23856,7 @@ const wrapQuickPickCommand = key => {
 
 const Commands$e = {};
 const getCommands$6 = async () => {
-  const commands = await invoke$l('QuickPick.getCommandIds');
+  const commands = await invoke$m('QuickPick.getCommandIds');
   for (const command of commands) {
     Commands$e[command] = wrapQuickPickCommand(command);
   }
@@ -23920,7 +23870,7 @@ const Css$i = ["/css/parts/Progress.css"];
 const Variables$5 = ['QuickPickBackground', 'ListForeground', 'ListHoverBackground', 'ListHoverForeground', 'ListActiveSelectionBackground'];
 
 const getKeyBindings$5 = () => {
-  return invoke$l('QuickPick.getKeyBindings');
+  return invoke$m('QuickPick.getKeyBindings');
 };
 
 const hasFunctionalRender$h = true;
@@ -23935,7 +23885,7 @@ const renderItems$5 = {
 };
 const render$h = [renderItems$5];
 const renderEventListeners$6 = async () => {
-  const listeners = await invoke$l('QuickPick.renderEventListeners');
+  const listeners = await invoke$m('QuickPick.renderEventListeners');
   return listeners;
 };
 
@@ -23980,7 +23930,7 @@ const contentLoaded$2 = state => {
   });
   return [];
 };
-const dispose$b = dispose$j;
+const dispose$b = dispose$i;
 
 /**
  * @enum {string}
@@ -24021,13 +23971,13 @@ const getActions$2 = () => {
 
 const wrapReferencesCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$7(`References.${key}`, state.uid, ...args);
-    const diffResult = await invoke$7('References.diff2', state.uid);
+    await invoke$8(`References.${key}`, state.uid, ...args);
+    const diffResult = await invoke$8('References.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$7('References.render2', state.uid, diffResult);
-    const actionsDom = await invoke$7('References.renderActions', state.uid);
+    const commands = await invoke$8('References.render2', state.uid, diffResult);
+    const actionsDom = await invoke$8('References.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -24044,11 +23994,11 @@ const wrapReferencesCommand = key => {
 
 const Commands$d = {};
 const getCommands$5 = async () => {
-  const commands = await invoke$7('References.getCommandIds');
+  const commands = await invoke$8('References.getCommandIds');
   for (const command of commands) {
     Commands$d[command] = wrapReferencesCommand(command);
   }
-  Commands$d['hotReload'] = hotReload$6;
+  Commands$d['hotReload'] = hotReload$7;
   return Commands$d;
 };
 
@@ -24076,13 +24026,13 @@ const ViewletReferences_ipc = {
   getActions: getActions$2,
   getCommands: getCommands$5,
   getDisplayName,
-  hasFunctionalEvents: hasFunctionalEvents$a,
+  hasFunctionalEvents: hasFunctionalEvents$b,
   hasFunctionalRender: hasFunctionalRender$p,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
   loadContent: loadContent$i,
   name: name$k,
   render: render$p,
-  renderEventListeners: renderEventListeners$9,
+  renderEventListeners: renderEventListeners$a,
   saveState: saveState$6
 };
 
@@ -24125,11 +24075,11 @@ const create$g = (id, uri, x, y, width, height, args, parentUid) => {
 };
 const loadContent$h = async (state, savedState) => {
   const isTest$1 = isTest();
-  await invoke$j('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$j('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
-  const diffResult = await invoke$j('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$j('RunAndDebug.render2', state.uid, diffResult);
-  const actionsDom = await invoke$j('RunAndDebug.renderActions', state.uid);
+  await invoke$k('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$k('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
+  const diffResult = await invoke$k('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$k('RunAndDebug.render2', state.uid, diffResult);
+  const actionsDom = await invoke$k('RunAndDebug.renderActions', state.uid);
   const debugId = isTest$1 ? 'test-debug' : 'node-debug'; // TODO
   return {
     ...state,
@@ -24150,17 +24100,17 @@ const hotReload$4 = async state => {
   state.isHotReloading = true;
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
-  const savedState = await invoke$j('RunAndDebug.saveState', state.uid);
-  await restart$9('RunAndDebug.terminate');
+  const savedState = await invoke$k('RunAndDebug.saveState', state.uid);
+  await restart$a('RunAndDebug.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$j('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
-  await invoke$j('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
-  await invoke$j('RunAndDebug.loadContentLater', state.uid);
-  const diffResult = await invoke$j('RunAndDebug.diff2', state.uid);
-  const commands = await invoke$j('RunAndDebug.render2', state.uid, diffResult);
+  await invoke$k('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform);
+  await invoke$k('RunAndDebug.loadContent', state.uid, state.isTest, savedState);
+  await invoke$k('RunAndDebug.loadContentLater', state.uid);
+  const diffResult = await invoke$k('RunAndDebug.diff2', state.uid);
+  const commands = await invoke$k('RunAndDebug.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -24215,19 +24165,19 @@ const resize$e = (state, dimensions) => {
   };
 };
 const saveState$5 = async state => {
-  const savedState = await invoke$j('RunAndDebug.saveState', state.uid);
+  const savedState = await invoke$k('RunAndDebug.saveState', state.uid);
   return savedState;
 };
 
 const wrapRunAndDebugCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$j(`RunAndDebug.${key}`, state.uid, ...args);
-    const diffResult = await invoke$j('RunAndDebug.diff2', state.uid);
+    await invoke$k(`RunAndDebug.${key}`, state.uid, ...args);
+    const diffResult = await invoke$k('RunAndDebug.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$j('RunAndDebug.render2', state.uid, diffResult);
-    const actionsDom = await invoke$j('RunAndDebug.renderActions', state.uid);
+    const commands = await invoke$k('RunAndDebug.render2', state.uid, diffResult);
+    const actionsDom = await invoke$k('RunAndDebug.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -24244,7 +24194,7 @@ const wrapRunAndDebugCommand = key => {
 
 const Commands$c = {};
 const getCommands$4 = async () => {
-  const commands = await invoke$j('RunAndDebug.getCommandIds');
+  const commands = await invoke$k('RunAndDebug.getCommandIds');
   for (const command of commands) {
     Commands$c[command] = wrapRunAndDebugCommand(command);
   }
@@ -24258,13 +24208,13 @@ const Variables$4 = ['TitleBarForeground', 'DebugSectionHeaderBackground', 'Side
 const Events$3 = {};
 
 const getKeyBindings$4 = () => {
-  return invoke$j('RunAndDebug.getKeyBindings');
+  return invoke$k('RunAndDebug.getKeyBindings');
 };
 
 const menus$5 = [];
 const getMenus$1 = async () => {
   try {
-    const modules = await invoke$j('RunAndDebug.getMenuEntries');
+    const modules = await invoke$k('RunAndDebug.getMenuEntries');
     const adjusted = modules.map(module => {
       return {
         ...module,
@@ -24291,7 +24241,7 @@ const renderItems$4 = {
 };
 const render$g = [renderItems$4];
 const renderEventListeners$5 = async () => {
-  const listeners = await invoke$j('RunAndDebug.renderEventListeners');
+  const listeners = await invoke$k('RunAndDebug.renderEventListeners');
   return listeners;
 };
 
@@ -24337,18 +24287,18 @@ const ViewletRunAndDebug_ipc = {
 };
 
 const getSources = async options => {
-  const sources = await invoke$n('DesktopCapturer.getSources', options);
+  const sources = await invoke$o('DesktopCapturer.getSources', options);
   return sources;
 };
 
 const getUserMedia = async (captureId, options) => {
   number(captureId);
   object(options);
-  await invoke$p('ScreenCapture.start', captureId, options);
+  await invoke$q('ScreenCapture.start', captureId, options);
 };
 const dispose$9 = async captureId => {
   number(captureId);
-  await invoke$p('ScreenCapture.dispose', captureId);
+  await invoke$q('ScreenCapture.dispose', captureId);
 };
 
 const createScreenCaptureStream = async captureId => {
@@ -24448,7 +24398,7 @@ const launchTextSearchWorker = async () => {
   });
   handleIpc(ipc);
   try {
-    await invoke$q(ipc, 'TextSearch.initialize', platform);
+    await invoke$r(ipc, 'TextSearch.initialize', platform);
   } catch (error) {
     // ignore
   }
@@ -24664,7 +24614,7 @@ const launchSettingsWorker = async () => {
     url: getConfiguredWorkerUrl$3()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Initialize.initialize');
+  await invoke$r(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -24937,7 +24887,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
       activityBar.state = newState;
       commands.push(...extraCommands);
     }
-    await invoke$p('Viewlet.sendMultiple', commands);
+    await invoke$q('Viewlet.sendMultiple', commands);
   }
 
   // // TODO race condition (check if disposed after created)
@@ -24968,7 +24918,7 @@ const openDefaultViewlet = async state => {
 };
 const close$2 = state => {
   if (state.currentViewletId) {
-    dispose$t(state.currentViewletId);
+    dispose$s(state.currentViewletId);
   }
   state.currentViewletId = undefined;
   // RendererProcess.send([/* sideBarHide */ 5552, /* id */ id])
@@ -25084,7 +25034,7 @@ const launchEmbedsWorker = async () => {
     name: 'Embeds Worker'
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Initialize.initialize');
+  await invoke$r(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -25111,7 +25061,7 @@ const disposeWebContentsView = async id => {
 const getWindowZoomLevel = async () => {
   // TODO speed up resizing by avoid too many round trips
   const windowId = await getWindowId();
-  const zoomLevel = await invoke$n('ElectronWindow.getZoom', windowId);
+  const zoomLevel = await invoke$o('ElectronWindow.getZoom', windowId);
   return zoomLevel;
 };
 
@@ -26057,7 +26007,7 @@ const launchSourceControlWorker = async () => {
     url: getConfiguredWorkerUrl$1()
   });
   handleIpc(ipc);
-  await invoke$q(ipc, 'Initialize.initialize');
+  await invoke$r(ipc, 'Initialize.initialize');
   return ipc;
 };
 
@@ -26750,7 +26700,7 @@ const ViewletStorage_ipc = {
 };
 
 const getTerminalSpawnOptions = () => {
-  return invoke$n('GetTerminalSpawnOptions.getTerminalSpawnOptions');
+  return invoke$o('GetTerminalSpawnOptions.getTerminalSpawnOptions');
 };
 
 // TODO implement a functional terminal component, maybe using offscreencanvas
@@ -26779,16 +26729,16 @@ const loadContent$7 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$13();
   const canvasCursorId = create$13();
-  await invoke$g('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
+  await invoke$h('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
   const terminal = {
     handleBlur() {
-      return invoke$g('Terminal.handleBlur', uid);
+      return invoke$h('Terminal.handleBlur', uid);
     },
     handleKeyDown(key) {
-      return invoke$g('Terminal.handleKeyDown', uid, key);
+      return invoke$h('Terminal.handleKeyDown', uid, key);
     },
     handleMouseDown() {
-      return invoke$g('Terminal.handleMouseDown', uid);
+      return invoke$h('Terminal.handleMouseDown', uid);
     },
     resize() {
       // TODO
@@ -26868,7 +26818,7 @@ const resizeEffect = async state => {
   // Terminal.resize(state, width, height)
 };
 const clear = async state => {
-  await invoke$p(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
+  await invoke$q(/* ViewletTerminal.write */'Terminal.write', /* data */new TextEncoder().encode('TODO clear terminal'));
 };
 
 const getActions = state => {
@@ -27016,7 +26966,7 @@ const addTerminal = async state => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$p('Viewlet.sendMultiple', commands);
+  await invoke$q('Viewlet.sendMultiple', commands);
   return {
     ...state,
     tabs: newTabs,
@@ -27057,7 +27007,7 @@ const focusIndex = async (state, index) => {
   const oldTab = tabs[selectedIndex];
   const disposeCommands = disposeFunctional(oldTab.uid);
   commands.push(...disposeCommands);
-  await invoke$p('Viewlet.sendMultiple', commands);
+  await invoke$q('Viewlet.sendMultiple', commands);
   return {
     ...state,
     selectedIndex: index
@@ -27861,7 +27811,7 @@ const getRealUri = pathOrUri => {
   if (protocol) {
     return pathOrUri;
   }
-  return invoke$n('FileSystem.getRealUri', pathOrUri);
+  return invoke$o('FileSystem.getRealUri', pathOrUri);
 };
 
 const create = (id, uri, x, y, width, height) => {
@@ -27903,7 +27853,7 @@ const resize = (state, dimensions) => {
   };
 };
 const dispose = async state => {
-  await invoke$p('WebView.dispose', state.uid);
+  await invoke$q('WebView.dispose', state.uid);
   return state;
 };
 
@@ -28099,11 +28049,11 @@ const FileSystemAppKeyBindings = {
 
 const downloadUpdate$2 = version => {
   string(version);
-  return invoke$n('AutoUpdaterAppImage.downloadUpdate', version);
+  return invoke$o('AutoUpdaterAppImage.downloadUpdate', version);
 };
 const installAndRestart$2 = downloadPath => {
   string(downloadPath);
-  return invoke$n('AutoUpdaterAppImage.installAndRestart', downloadPath);
+  return invoke$o('AutoUpdaterAppImage.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterAppImage = {
@@ -28114,11 +28064,11 @@ const AutoUpdaterAppImage = {
 
 const downloadUpdate$1 = version => {
   string(version);
-  return invoke$n('AutoUpdaterWindowsNsis.downloadUpdate', version);
+  return invoke$o('AutoUpdaterWindowsNsis.downloadUpdate', version);
 };
 const installAndRestart$1 = downloadPath => {
   string(downloadPath);
-  return invoke$n('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
+  return invoke$o('AutoUpdaterWindowsNsis.installAndRestart', downloadPath);
 };
 
 const AutoUpdaterNsis = {
@@ -28131,7 +28081,7 @@ const exec = (command, args, options) => {
   string(command);
   array(args);
   object(options);
-  return invoke$n('Exec.exec', command, args, options);
+  return invoke$o('Exec.exec', command, args, options);
 };
 
 const getDebArch = processArch => {
@@ -28156,7 +28106,7 @@ const getDownloadUrl = (repository, version, applicationName, debArch) => {
 };
 
 const getTmpDir = () => {
-  return invoke$n('Os.getTmpDir');
+  return invoke$o('Os.getTmpDir');
 };
 
 // TODO remove this code when auto update through apt is supported
@@ -28224,7 +28174,7 @@ const getItem = (items, label) => {
 const openContextMenu = async (x, y, id, ...args) => {
   const entries = await getMenuEntries$h(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
-  const event = await invoke$n('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
+  const event = await invoke$o('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
     return;
   }
@@ -28261,7 +28211,7 @@ const ContextMenuBrowser = {
 
 const open$3 = async () => {
   try {
-    await invoke$n('ElectronWindowProcessExplorer.open');
+    await invoke$o('ElectronWindowProcessExplorer.open');
   } catch (error) {
     throw new VError(error, 'Failed to open process explorer');
   }
@@ -29665,7 +29615,7 @@ const prefixIdWithExt = item => {
 const getExtensionPicks = async () => {
   try {
     // TODO don't call this every time
-    const extensionPicks = await getCommands$e();
+    const extensionPicks = await getCommands$f();
     if (!extensionPicks) {
       return [];
     }
@@ -29708,7 +29658,7 @@ const selectPickExtension = async item => {
   try {
     await executeCommand(id);
   } catch (error) {
-    await handleError$2(error, false);
+    await handleError$1(error, false);
     await showErrorDialog(error);
   }
   return {
@@ -29908,7 +29858,7 @@ const QuickPickEntriesView = {
 };
 
 const searchFile$1 = async (path, value, prepare) => {
-  return invoke$l('SearchFile.searchFile', path, value, prepare, assetDir);
+  return invoke$m('SearchFile.searchFile', path, value, prepare, assetDir);
 };
 
 const searchFile = async (path, value) => {