@lvce-editor/static-server 0.86.12 → 0.86.13

package/static/{9f107dc → cc29179}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -108,7 +108,7 @@ const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/9f107dc';
+    return '/cc29179';
   }
 };
 const assetDir = getAssetDir$1();
@@ -7069,7 +7069,6 @@ const map = {
   [DiffEditor]: () => Promise.resolve().then(function () { return ViewletDiffEditor2_ipc; }),
   [E2eTest]: () => Promise.resolve().then(function () { return ViewletE2eTest_ipc; }),
   [LanguageModels]: () => Promise.resolve().then(function () { return ViewletLanguageModels_ipc; }),
-  [RunningExtensions]: () => Promise.resolve().then(function () { return ViewletRunningExtensions_ipc; }),
   [Preview$3]: () => Promise.resolve().then(function () { return ViewletPreview_ipc; }),
   [Terminal2]: () => Promise.resolve().then(function () { return ViewletTerminal2_ipc; }),
   [E2eTests$1]: () => Promise.resolve().then(function () { return ViewletE2eTests_ipc; }),
@@ -7096,6 +7095,7 @@ const map = {
   [QuickPick]: () => Promise.resolve().then(function () { return ViewletQuickPick_ipc; }),
   [References]: () => Promise.resolve().then(function () { return ViewletReferences_ipc; }),
   [RunAndDebug]: () => Promise.resolve().then(function () { return ViewletRunAndDebug_ipc; }),
+  [RunningExtensions]: () => Promise.resolve().then(function () { return ViewletRunningExtensions_ipc; }),
   [ScreenCapture]: () => Promise.resolve().then(function () { return ViewletScreenCapture_ipc; }),
   [Search]: () => Promise.resolve().then(function () { return ViewletSearch_ipc; }),
   [Settings]: () => Promise.resolve().then(function () { return ViewletSettings_ipc; }),
@@ -11010,8 +11010,8 @@ const attachDebugger = async pid => {
   await invoke$F('AttachDebugger.attachDebugger', pid);
 };
 
-const version = '0.86.12';
-const commit$1 = '9f107dc';
+const version = '0.86.13';
+const commit$1 = 'cc29179';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$F('Process.getPid');
@@ -17059,103 +17059,6 @@ const ViewletLanguageModels_ipc = {
   renderEventListeners: renderEventListeners$o
 };
 
-const runningExtensionsViewWorkerUrl = `${assetDir}/packages/running-extensions-view/dist/runningExtensionsViewMain.js`;
-
-const launchRunningExtensionsViewWorker = async () => {
-  const ipc = await create$19({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name: 'Running Extensions View Worker',
-    url: getConfiguredWorkerUrl$1('develop.runningExtensionsViewPath', runningExtensionsViewWorkerUrl)
-  });
-  handleIpc(ipc);
-  return ipc;
-};
-
-const {
-  invoke: invoke$f} = getOrCreateWorker(launchRunningExtensionsViewWorker);
-
-const create$E = (uid, uri, x, y, width, height) => {
-  return {
-    commands: [],
-    height,
-    uid,
-    uri,
-    width,
-    x,
-    y
-  };
-};
-const loadContent$C = async state => {
-  const {
-    height,
-    uid,
-    uri,
-    width,
-    x,
-    y
-  } = state;
-  await invoke$f('RunningExtensions.create', uid, uri, x, y, width, height);
-  await invoke$f('RunningExtensions.loadContent', uid);
-  const diffResult = await invoke$f('RunningExtensions.diff2', uid);
-  const commands = await invoke$f('RunningExtensions.render2', uid, diffResult);
-  return {
-    ...state,
-    commands
-  };
-};
-
-const wrapRunningExtensionsCommand = key => {
-  return async (state, ...args) => {
-    await invoke$f(`RunningExtensions.${key}`, state.uid, ...args);
-    const diffResult = await invoke$f('RunningExtensions.diff2', state.uid);
-    const commands = await invoke$f('RunningExtensions.render2', state.uid, diffResult);
-    return {
-      ...state,
-      commands
-    };
-  };
-};
-
-const Commands$y = {};
-const getCommands$l = async () => {
-  const commands = await invoke$f('RunningExtensions.getCommandIds');
-  for (const command of commands) {
-    Commands$y[command] = wrapRunningExtensionsCommand(command);
-  }
-  return Commands$y;
-};
-
-const Css$w = ["/css/parts/ViewletRunningExtensions.css"];
-
-const hasFunctionalEvents$p = true;
-const hasFunctionalRender$w = true;
-const hasFunctionalRootRender$t = true;
-const renderDom$8 = {
-  apply: apply,
-  isEqual(oldState, newState) {
-    return newState.commands.length === 0;
-  },
-  multiple: true
-};
-const render$z = [renderDom$8];
-const renderEventListeners$n = async () => {
-  return invoke$f('RunningExtensions.renderEventListeners');
-};
-
-const ViewletRunningExtensions_ipc = {
-  __proto__: null,
-  Commands: Commands$y,
-  Css: Css$w,
-  create: create$E,
-  getCommands: getCommands$l,
-  hasFunctionalEvents: hasFunctionalEvents$p,
-  hasFunctionalRender: hasFunctionalRender$w,
-  hasFunctionalRootRender: hasFunctionalRootRender$t,
-  loadContent: loadContent$C,
-  render: render$z,
-  renderEventListeners: renderEventListeners$n
-};
-
 const wrapPreviewCommand = key => {
   const fn = async (state, ...args) => {
     await invoke$r(`Preview.${key}`, state.uid, ...args);
@@ -17175,7 +17078,7 @@ const wrapPreviewCommand = key => {
   return fn;
 };
 
-const create$D = (id, uri, x, y, width, height) => {
+const create$E = (id, uri, x, y, width, height) => {
   return {
     uid: id,
     uri,
@@ -17188,7 +17091,7 @@ const create$D = (id, uri, x, y, width, height) => {
     commands: []
   };
 };
-const loadContent$B = async state => {
+const loadContent$C = async state => {
   const layoutState = getState$1(Layout);
   const uri = layoutState.previewUri || state.uri;
   const savedState = {};
@@ -17214,7 +17117,7 @@ const decrement = state => {
     count: state.count - 1
   };
 };
-const renderEventListeners$m = () => invoke$r('Preview.renderEventListeners');
+const renderEventListeners$n = () => invoke$r('Preview.renderEventListeners');
 const dispose$p = state => {
   return {
     ...state,
@@ -17241,19 +17144,19 @@ const hotReload$h = async state => {
     commands
   };
 };
-const Commands$x = {};
-const getCommands$k = async () => {
+const Commands$y = {};
+const getCommands$l = async () => {
   const commands = await invoke$r('Preview.getCommandIds');
   for (const command of commands) {
-    Commands$x[command] = wrapPreviewCommand(command);
+    Commands$y[command] = wrapPreviewCommand(command);
   }
-  Commands$x['hotReload'] = hotReload$h;
-  return Commands$x;
+  Commands$y['hotReload'] = hotReload$h;
+  return Commands$y;
 };
-const hasFunctionalRender$v = true;
-const hasFunctionalRootRender$s = true;
+const hasFunctionalRender$w = true;
+const hasFunctionalRootRender$t = true;
 const hasFunctionalResize$l = true;
-const hasFunctionalEvents$o = true;
+const hasFunctionalEvents$p = true;
 const renderItems$e = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -17261,29 +17164,29 @@ const renderItems$e = {
   apply: apply,
   multiple: true
 };
-const render$y = [renderItems$e];
-const Css$v = ['/css/parts/Preview.css'];
+const render$z = [renderItems$e];
+const Css$w = ['/css/parts/Preview.css'];
 
 const name$w = 'Preview';
 
 const ViewletPreview_ipc = {
   __proto__: null,
-  Commands: Commands$x,
-  Css: Css$v,
-  create: create$D,
+  Commands: Commands$y,
+  Css: Css$w,
+  create: create$E,
   decrement,
   dispose: dispose$p,
-  getCommands: getCommands$k,
-  hasFunctionalEvents: hasFunctionalEvents$o,
-  hasFunctionalRender: hasFunctionalRender$v,
+  getCommands: getCommands$l,
+  hasFunctionalEvents: hasFunctionalEvents$p,
+  hasFunctionalRender: hasFunctionalRender$w,
   hasFunctionalResize: hasFunctionalResize$l,
-  hasFunctionalRootRender: hasFunctionalRootRender$s,
+  hasFunctionalRootRender: hasFunctionalRootRender$t,
   hotReload: hotReload$h,
   increment,
-  loadContent: loadContent$B,
+  loadContent: loadContent$C,
   name: name$w,
-  render: render$y,
-  renderEventListeners: renderEventListeners$m
+  render: render$z,
+  renderEventListeners: renderEventListeners$n
 };
 
 const getTerminalSpawnOptions = () => {
@@ -17295,7 +17198,7 @@ const defaultBackend = 'real';
 const getBackend = () => {
   return get$d('terminal.backend') || defaultBackend;
 };
-const create$C = id => {
+const create$D = id => {
   number(id);
   return {
     disposed: false,
@@ -17310,7 +17213,7 @@ const create$C = id => {
     xtermMounted: false
   };
 };
-const loadContent$A = async state => {
+const loadContent$B = async state => {
   const {
     uid
   } = state;
@@ -17377,7 +17280,7 @@ const clear$2 = async state => {
   return state;
 };
 
-const Commands$w = {
+const Commands$x = {
   clear: clear$2,
   handleBlur: handleBlur$3,
   handleInput: handleInput$3,
@@ -17386,7 +17289,7 @@ const Commands$w = {
   resize: resize$k
 };
 
-const hasFunctionalRender$u = true;
+const hasFunctionalRender$v = true;
 const renderTerminal = {
   isEqual(oldState, newState) {
     return oldState.uid === newState.uid && oldState.xtermMounted === newState.xtermMounted;
@@ -17395,18 +17298,18 @@ const renderTerminal = {
     return ['setTerminal', newState.uid];
   }
 };
-const render$x = [renderTerminal];
+const render$y = [renderTerminal];
 
-const Css$u = ['/css/parts/ViewletTerminal.css', '/lib-css/xterm.css'];
+const Css$v = ['/css/parts/ViewletTerminal.css', '/lib-css/xterm.css'];
 
 const name$v = 'Terminal2';
 
 const ViewletTerminal2_ipc = {
   __proto__: null,
-  Commands: Commands$w,
-  Css: Css$u,
+  Commands: Commands$x,
+  Css: Css$v,
   clear: clear$2,
-  create: create$C,
+  create: create$D,
   dispose: dispose$o,
   focus: focus$5,
   handleBlur: handleBlur$3,
@@ -17414,16 +17317,16 @@ const ViewletTerminal2_ipc = {
   handleInput: handleInput$3,
   handleKeyDown: handleKeyDown$1,
   handleMouseDown: handleMouseDown$1,
-  hasFunctionalRender: hasFunctionalRender$u,
+  hasFunctionalRender: hasFunctionalRender$v,
   hasFunctionalResize: hasFunctionalResize$k,
-  loadContent: loadContent$A,
+  loadContent: loadContent$B,
   name: name$v,
-  render: render$x,
+  render: render$y,
   resize: resize$k,
   resizeEffect: resizeEffect$2
 };
 
-const create$B = (id, uri, x, y, width, height) => {
+const create$C = (id, uri, x, y, width, height) => {
   return {
     x,
     y,
@@ -17452,7 +17355,7 @@ const getTests = async () => {
 const toHtmlFileName = testFileName => {
   return testFileName.replace(/\.(js|ts)$/, '.html');
 };
-const loadContent$z = async state => {
+const loadContent$A = async state => {
   const tests = await getTests();
   const sandbox = getE2eTestsSandbox();
   return {
@@ -17528,7 +17431,7 @@ const openInNewTab = async state => {
   return state;
 };
 
-const Commands$v = {
+const Commands$w = {
   handleClickAt: handleClickAt,
   handleLoad: handleLoad,
   runAll: runAll,
@@ -17536,7 +17439,7 @@ const Commands$v = {
   openInNewTab: openInNewTab
 };
 
-const Css$t = ["/css/parts/E2eTests.css"];
+const Css$u = ["/css/parts/E2eTests.css"];
 
 const getKeyBindings$h = () => {
   return [];
@@ -17611,8 +17514,8 @@ const getVisibleE2eTests = (tests, index) => {
   return visible;
 };
 
-const hasFunctionalRender$t = true;
-const hasFunctionalRootRender$r = true;
+const hasFunctionalRender$u = true;
+const hasFunctionalRootRender$s = true;
 const renderTests = {
   isEqual(oldState, newState) {
     return oldState.tests === newState.tests && oldState.index === newState.index;
@@ -17639,7 +17542,7 @@ const renderMessagePort = {
     return ['setPort', newState.portId, newState.iframeOrigin];
   }
 };
-const render$w = [renderTests, renderIframe$1, renderMessagePort];
+const render$x = [renderTests, renderIframe$1, renderMessagePort];
 
 const getActions$3 = () => {
   return [{
@@ -17663,21 +17566,21 @@ const renderActions$b = {
 
 const ViewletE2eTests_ipc = {
   __proto__: null,
-  Commands: Commands$v,
-  Css: Css$t,
-  create: create$B,
+  Commands: Commands$w,
+  Css: Css$u,
+  create: create$C,
   executeTest,
   getKeyBindings: getKeyBindings$h,
   handleClickAt,
   handleContextMenu: handleContextMenu$3,
   handleLoad,
-  hasFunctionalRender: hasFunctionalRender$t,
-  hasFunctionalRootRender: hasFunctionalRootRender$r,
-  loadContent: loadContent$z,
+  hasFunctionalRender: hasFunctionalRender$u,
+  hasFunctionalRootRender: hasFunctionalRootRender$s,
+  loadContent: loadContent$A,
   menus: menus$g,
   name: name$u,
   openInNewTab,
-  render: render$w,
+  render: render$x,
   renderActions: renderActions$b,
   runAll
 };
@@ -17760,10 +17663,10 @@ const renderAll = {
   },
   multiple: true
 };
-const render$v = [renderAll];
+const render$w = [renderAll];
 
 // TODO
-const create$A = (id, uri, languageId) => {
+const create$B = (id, uri, languageId) => {
   // TODO flatten structure
   return {
     uri,
@@ -18071,10 +17974,10 @@ const handleTokenizeChange = () => {
 const useFunctionalRendering = true;
 
 // TODO uri?
-const create$z = (id, uri, x, y, width, height) => {
+const create$A = (id, uri, x, y, width, height) => {
   const fileName = pathBaseName(uri);
   const languageId = getLanguageId$1(fileName);
-  const state = create$A(id, uri, languageId);
+  const state = create$B(id, uri, languageId);
   const newState = setBounds(state, x, y, width, height, COLUMN_WIDTH);
   return {
     ...newState,
@@ -18114,7 +18017,7 @@ const getLanguageId = state => {
   }
   return languageId;
 };
-const loadContent$y = async (state, savedState, context) => {
+const loadContent$z = async (state, savedState, context) => {
   const {
     uri,
     id,
@@ -18297,10 +18200,10 @@ const resize$j = async (state, dimensions) => {
 const dispose$n = state => {
   removeConnectedEditor(state.id);
 };
-const hasFunctionalRender$s = true;
-const hasFunctionalRootRender$q = true;
-const hasFunctionalEvents$n = true;
-const render$u = render$v;
+const hasFunctionalRender$t = true;
+const hasFunctionalRootRender$r = true;
+const hasFunctionalEvents$o = true;
+const render$v = render$w;
 const focus$4 = state => {
   return {
     ...state,
@@ -18308,7 +18211,7 @@ const focus$4 = state => {
   };
 };
 const customErrorRenderer = EditorTextError;
-const renderEventListeners$l = async () => {
+const renderEventListeners$m = async () => {
   const listeners = await actualInvoke('Editor.renderEventListeners');
   return listeners;
 };
@@ -18339,7 +18242,7 @@ const wrapEditorCommands = ids => {
 };
 
 const subWidgetCommandIds = ['ColorPicker.handleSliderPointerDown', 'ColorPicker.handleSliderPointerMove', 'EditorCodeGenerator.accept', 'EditorCompletion.close', 'EditorCompletion.closeDetails', 'EditorCompletion.dispose', 'EditorCompletion.focusFirst', 'EditorCompletion.focusIndex', 'EditorCompletion.focusLast', 'EditorCompletion.focusNext', 'EditorCompletion.focusNextPage', 'EditorCompletion.focusPrevious', 'EditorCompletion.focusPreviousPage', 'EditorCompletion.handleClickAt', 'EditorCompletion.handlePointerDown', 'EditorCompletion.handleScrollBarCaptureLost', 'EditorCompletion.handleScrollBarClick', 'EditorCompletion.handleScrollBarMove', 'EditorCompletion.handleScrollBarThumbPointerMove', 'EditorCompletion.handleWheel', 'EditorCompletion.openDetails', 'EditorCompletion.scrollDown', 'EditorCompletion.selectCurrent', 'EditorCompletion.selectIndex', 'EditorCompletion.toggleDetails', 'EditorRename.accept', 'EditorRename.handleBlur', 'EditorRename.handleInput', 'EditorRename.close', 'EditorSourceActions.close', 'EditorSourceActions.focusFirst', 'EditorSourceActions.focusLast', 'EditorSourceActions.focusNext', 'EditorSourceActions.focusPrevious', 'EditorSourceActions.selectCurrent', 'FindWidget.close', 'FindWidget.focusNextElement', 'FindWidget.focusPreviousElement', 'FindWidget.focusCloseButton', 'FindWidget.focusFind', 'FindWidget.focusNext', 'FindWidget.focusNextMatchButton', 'FindWidget.focusPrevious', 'FindWidget.focusPreviousMatchButton', 'FindWidget.focusReplace', 'FindWidget.focusReplaceAllButton', 'FindWidget.focusReplaceButton', 'FindWidget.focusToggleReplace', 'FindWidget.handleBlur', 'FindWidget.handleFocus', 'FindWidget.handleFocusClose', 'FindWidget.handleFocusNext', 'FindWidget.handleFocusPrevious', 'FindWidget.handleFocusReplaceAll', 'FindWidget.handleInput', 'FindWidget.handleReplaceFocus', 'FindWidget.handleReplaceInput', 'FindWidget.handleToggleReplaceFocus', 'FindWidget.replace', 'FindWidget.replaceAll', 'FindWidget.toggleMatchCase', 'FindWidget.toggleMatchWholeWord', 'FindWidget.toggleReplace', 'FindWidget.toggleUseRegularExpression', 'FindWidget.togglePreserveCase', 'EditorSourceAction.close', 'EditorSourceAction.closeDetails', 'EditorSourceAction.focusFirst', 'EditorSourceAction.focusIndex', 'EditorSourceAction.focusNext', 'EditorSourceAction.focusPrevious', 'EditorSourceAction.handleWheel', 'EditorSourceAction.selectCurrent', 'EditorSourceAction.selectIndex', 'EditorSourceAction.selectItem', 'EditorSourceAction.toggleDetails'];
-const Commands$u = {};
+const Commands$v = {};
 const showOverlayMessage = async (state, editor, ...args) => {
   await invoke$I(...args);
   return state;
@@ -18349,13 +18252,13 @@ const hotReload$g = async (state, editor, ...args) => {
   await actualInvoke(`Editor.hotReload`);
   return state;
 };
-const getCommands$j = async () => {
+const getCommands$k = async () => {
   const commandIds = await actualInvoke('Editor.getCommandIds');
-  Object.assign(Commands$u, wrapEditorCommands(commandIds), wrapEditorCommands(subWidgetCommandIds), {
+  Object.assign(Commands$v, wrapEditorCommands(commandIds), wrapEditorCommands(subWidgetCommandIds), {
     showOverlayMessage,
     hotReload: hotReload$g
   });
-  return Commands$u;
+  return Commands$v;
 };
 const CommandsWithSideEffectsLazy = {
   typeWithAutoClosing: () => {
@@ -18421,17 +18324,17 @@ const Events$4 = {
 
 const ViewletEditorText_ipc = {
   __proto__: null,
-  Commands: Commands$u,
+  Commands: Commands$v,
   CommandsWithSideEffectsLazy,
   Css: Css$A,
   Events: Events$4,
   contentLoaded: contentLoaded$3,
   contentLoadedEffects: contentLoadedEffects$1,
-  create: create$z,
+  create: create$A,
   customErrorRenderer,
   dispose: dispose$n,
   focus: focus$4,
-  getCommands: getCommands$j,
+  getCommands: getCommands$k,
   getDynamicCss,
   getKeyBindings: getKeyBindings$g,
   getMenus: getMenus$b,
@@ -18439,15 +18342,15 @@ const ViewletEditorText_ipc = {
   handleEditorChange,
   handleLanguagesChanged,
   handleTokenizeChange,
-  hasFunctionalEvents: hasFunctionalEvents$n,
-  hasFunctionalRender: hasFunctionalRender$s,
+  hasFunctionalEvents: hasFunctionalEvents$o,
+  hasFunctionalRender: hasFunctionalRender$t,
   hasFunctionalResize: hasFunctionalResize$j,
-  hasFunctionalRootRender: hasFunctionalRootRender$q,
-  loadContent: loadContent$y,
+  hasFunctionalRootRender: hasFunctionalRootRender$r,
+  loadContent: loadContent$z,
   menus: menus$f,
   name: name$t,
-  render: render$u,
-  renderEventListeners: renderEventListeners$l,
+  render: render$v,
+  renderEventListeners: renderEventListeners$m,
   rerender: rerender$1,
   resize: resize$j,
   saveState: saveState$g
@@ -18500,17 +18403,17 @@ const getEditorErrorInfo = error => {
 };
 
 const name$s = 'TextEditorError';
-const create$y = () => {
+const create$z = () => {
   return {
     id: 0,
     error: undefined
   };
 };
-const loadContent$x = state => {
+const loadContent$y = state => {
   // TODO
   return state;
 };
-const render$t = error => {
+const render$u = error => {
   const info = getEditorErrorInfo(error);
   return renderTextEditorError(info);
 };
@@ -18518,19 +18421,19 @@ const handleClickCreate = state => {
   return state;
 };
 
-const Css$s = [];
+const Css$t = [];
 
 const ViewletTextEditorError_ipc = {
   __proto__: null,
-  Css: Css$s,
-  create: create$y,
+  Css: Css$t,
+  create: create$z,
   handleClickCreate,
-  loadContent: loadContent$x,
+  loadContent: loadContent$y,
   name: name$s,
-  render: render$t
+  render: render$u
 };
 
-const create$x = (id, uri, x, y, width, height) => {
+const create$y = (id, uri, x, y, width, height) => {
   return {
     id,
     uri,
@@ -18581,26 +18484,26 @@ const renderBounds = {
     return ['setBounds', newState.x, newState.y, newState.width, newState.height];
   }
 };
-const render$s = [renderMessage$1, renderBounds];
+const render$t = [renderMessage$1, renderBounds];
 
-const Css$r = ["/css/parts/ViewletEditorWidgetError.css"];
+const Css$s = ["/css/parts/ViewletEditorWidgetError.css"];
 
 const ViewletEditorWidgetError_ipc = {
   __proto__: null,
-  Css: Css$r,
-  create: create$x,
-  render: render$s,
+  Css: Css$s,
+  create: create$y,
+  render: render$t,
   setError
 };
 
-const create$w = (id, uri, x, y, width, height) => {
+const create$x = (id, uri, x, y, width, height) => {
   return {
     id,
     interval: -1,
     disposed: false
   };
 };
-const loadContent$w = state => {
+const loadContent$x = state => {
   return {
     ...state
   };
@@ -18608,14 +18511,14 @@ const loadContent$w = state => {
 const dispose$m = state => {};
 
 const name$r = 'EmptyEditor';
-const Commands$t = {};
+const Commands$u = {};
 
 const ViewletEmptyEditor_ipc = {
   __proto__: null,
-  Commands: Commands$t,
-  create: create$w,
+  Commands: Commands$u,
+  create: create$x,
   dispose: dispose$m,
-  loadContent: loadContent$w,
+  loadContent: loadContent$x,
   name: name$r
 };
 
@@ -18634,7 +18537,7 @@ const launchExplorerWorker = async () => {
 };
 
 const {
-  invoke: invoke$e,
+  invoke: invoke$f,
   restart: restart$a
 } = getOrCreateWorker(launchExplorerWorker);
 
@@ -18647,7 +18550,7 @@ const {
 
 // TODO instead of root string, there should be a root dirent
 
-const create$v = (id, uri, x, y, width, height, args, parentUid) => {
+const create$w = (id, uri, x, y, width, height, args, parentUid) => {
   number(id);
   return {
     uid: id,
@@ -18663,17 +18566,17 @@ const create$v = (id, uri, x, y, width, height, args, parentUid) => {
 };
 const getTitle$1 = async uid => {
   try {
-    return await invoke$e('Explorer.getTitle', uid);
+    return await invoke$f('Explorer.getTitle', uid);
   } catch {
     return 'Explorer';
   }
 };
-const loadContent$v = async (state, savedState) => {
-  await invoke$e('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
-  await invoke$e('Explorer.loadContent', state.uid, savedState);
-  const diffResult = await invoke$e('Explorer.diff2', state.uid);
-  const commands = await invoke$e('Explorer.render2', state.uid, diffResult);
-  const actionsDom = await invoke$e('Explorer.renderActions2', state.uid);
+const loadContent$w = async (state, savedState) => {
+  await invoke$f('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
+  await invoke$f('Explorer.loadContent', state.uid, savedState);
+  const diffResult = await invoke$f('Explorer.diff2', state.uid);
+  const commands = await invoke$f('Explorer.render2', state.uid, diffResult);
+  const actionsDom = await invoke$f('Explorer.renderActions2', state.uid);
   const title = await getTitle$1(state.uid);
   return {
     ...state,
@@ -18698,7 +18601,7 @@ const resize$i = (state, dimensions) => {
 };
 const getMouseActions = async () => {
   try {
-    return await invoke$e('Explorer.getMouseActions');
+    return await invoke$f('Explorer.getMouseActions');
   } catch {
     return [];
   }
@@ -18711,16 +18614,16 @@ const hotReload$f = 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$e('Explorer.saveState', state.uid);
+  const savedState = await invoke$f('Explorer.saveState', state.uid);
   await restart$a('Explorer.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$e('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
-  await invoke$e('Explorer.loadContent', state.uid, savedState);
-  const diffResult = await invoke$e('Explorer.diff2', state.uid);
-  const commands = await invoke$e('Explorer.render2', state.uid, diffResult);
+  await invoke$f('Explorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
+  await invoke$f('Explorer.loadContent', state.uid, savedState);
+  const diffResult = await invoke$f('Explorer.diff2', state.uid);
+  const commands = await invoke$f('Explorer.render2', state.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -18730,8 +18633,8 @@ const hotReload$f = async state => {
 
 const wrapExplorerCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$e(`Explorer.${key}`, state.uid, ...args);
-    const diffResult = await invoke$e('Explorer.diff2', state.uid);
+    await invoke$f(`Explorer.${key}`, state.uid, ...args);
+    const diffResult = await invoke$f('Explorer.diff2', state.uid);
     const title = await getTitle$1(state.uid);
     if (diffResult.length === 0) {
       if (state.title === title) {
@@ -18742,7 +18645,7 @@ const wrapExplorerCommand = key => {
         title
       };
     }
-    const commands = await invoke$e('Explorer.render2', state.uid, diffResult);
+    const commands = await invoke$f('Explorer.render2', state.uid, diffResult);
     if (commands.length === 0) {
       if (state.title === title) {
         return state;
@@ -18761,27 +18664,27 @@ const wrapExplorerCommand = key => {
   return fn;
 };
 
-const Commands$s = {};
-const getCommands$i = async () => {
-  const commands = await invoke$e('Explorer.getCommandIds');
+const Commands$t = {};
+const getCommands$j = async () => {
+  const commands = await invoke$f('Explorer.getCommandIds');
   for (const command of commands) {
-    Commands$s[command] = wrapExplorerCommand(command);
+    Commands$t[command] = wrapExplorerCommand(command);
   }
-  Commands$s['hotReload'] = hotReload$f;
-  Commands$s['getMouseActions'] = getMouseActions;
-  return Commands$s;
+  Commands$t['hotReload'] = hotReload$f;
+  Commands$t['getMouseActions'] = getMouseActions;
+  return Commands$t;
 };
 
-const Css$q = [];
+const Css$r = [];
 
 const getKeyBindings$f = () => {
-  return invoke$e('Explorer.getKeyBindings');
+  return invoke$f('Explorer.getKeyBindings');
 };
 
 const id$2 = Explorer;
 const getMenuEntries$3 = () => {
   const explorerState = getState('Explorer');
-  return invoke$e('Explorer.getMenuEntries2', explorerState.uid);
+  return invoke$f('Explorer.getMenuEntries2', explorerState.uid);
 };
 
 const MenuEntriesExplorer = {
@@ -18806,9 +18709,9 @@ const getDisplayName$1 = () => {
   return explorer();
 };
 
-const hasFunctionalRender$r = true;
-const hasFunctionalRootRender$p = true;
-const hasFunctionalEvents$m = true;
+const hasFunctionalRender$s = true;
+const hasFunctionalRootRender$q = true;
+const hasFunctionalEvents$n = true;
 const renderItems$d = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -18816,9 +18719,9 @@ const renderItems$d = {
   apply: apply,
   multiple: true
 };
-const render$r = [renderItems$d];
-const renderEventListeners$k = async () => {
-  const listeners = await invoke$e('Explorer.renderEventListeners');
+const render$s = [renderItems$d];
+const renderEventListeners$l = async () => {
+  const listeners = await invoke$f('Explorer.renderEventListeners');
   return listeners;
 };
 
@@ -18842,38 +18745,38 @@ const renderTitle$3 = {
 };
 
 const restoreState = savedState => {
-  return invoke$e('Explorer.restoreState', savedState);
+  return invoke$f('Explorer.restoreState', savedState);
 };
 
 const saveState$f = state => {
-  return invoke$e('Explorer.saveState', state.uid);
+  return invoke$f('Explorer.saveState', state.uid);
 };
 
 const Events$3 = {};
 
 const ViewletExplorer_ipc = {
   __proto__: null,
-  Commands: Commands$s,
-  Css: Css$q,
+  Commands: Commands$t,
+  Css: Css$r,
   Events: Events$3,
-  create: create$v,
+  create: create$w,
   dispose: dispose$l,
-  getCommands: getCommands$i,
+  getCommands: getCommands$j,
   getDisplayName: getDisplayName$1,
   getKeyBindings: getKeyBindings$f,
   getMouseActions,
   getTitle: getTitle$1,
-  hasFunctionalEvents: hasFunctionalEvents$m,
-  hasFunctionalRender: hasFunctionalRender$r,
+  hasFunctionalEvents: hasFunctionalEvents$n,
+  hasFunctionalRender: hasFunctionalRender$s,
   hasFunctionalResize: hasFunctionalResize$i,
-  hasFunctionalRootRender: hasFunctionalRootRender$p,
+  hasFunctionalRootRender: hasFunctionalRootRender$q,
   hotReload: hotReload$f,
-  loadContent: loadContent$v,
+  loadContent: loadContent$w,
   menus: menus$e,
   name: name$q,
-  render: render$r,
+  render: render$s,
   renderActions: renderActions$a,
-  renderEventListeners: renderEventListeners$k,
+  renderEventListeners: renderEventListeners$l,
   renderTitle: renderTitle$3,
   resize: resize$i,
   restoreState,
@@ -18895,11 +18798,11 @@ const launchExtensionDetailViewWorker = async () => {
 };
 
 const {
-  invoke: invoke$d,
+  invoke: invoke$e,
   restart: restart$9
 } = getOrCreateWorker(launchExtensionDetailViewWorker);
 
-const create$u = (id, uri, x, y, width, height) => {
+const create$v = (id, uri, x, y, width, height) => {
   return {
     name: '',
     uri,
@@ -18920,12 +18823,12 @@ const create$u = (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$u = async (state, savedState) => {
-  await invoke$d('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
+const loadContent$v = async (state, savedState) => {
+  await invoke$e('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
   const isTest$1 = isTest();
-  await invoke$d('ExtensionDetail.loadContent2', state.uid, savedState, isTest$1);
-  const diffResult = await invoke$d('ExtensionDetail.diff2', state.uid);
-  const commands = await invoke$d('ExtensionDetail.render2', state.uid, diffResult);
+  await invoke$e('ExtensionDetail.loadContent2', state.uid, savedState, isTest$1);
+  const diffResult = await invoke$e('ExtensionDetail.diff2', state.uid);
+  const commands = await invoke$e('ExtensionDetail.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -18940,10 +18843,10 @@ const hotReload$e = async state => {
   // possible TODO race condition during hot reload
   // there could still be pending promises when the worker is disposed
   await restart$9('ExtensionDetail.terminate');
-  await invoke$d('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
-  await invoke$d('ExtensionDetail.loadContent2', state.uid, {});
-  const diffResult = await invoke$d('ExtensionDetail.diff2', state.uid);
-  const commands = await invoke$d('ExtensionDetail.render2', state.uid, diffResult);
+  await invoke$e('ExtensionDetail.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getPlatform$1(), assetDir);
+  await invoke$e('ExtensionDetail.loadContent2', state.uid, {});
+  const diffResult = await invoke$e('ExtensionDetail.diff2', state.uid);
+  const commands = await invoke$e('ExtensionDetail.render2', state.uid, diffResult);
   state.isHotReloading = false;
   return {
     ...state,
@@ -18951,19 +18854,19 @@ const hotReload$e = async state => {
   };
 };
 const saveState$e = async state => {
-  const savedState = await invoke$d('ExtensionDetail.saveState', state.uid);
+  const savedState = await invoke$e('ExtensionDetail.saveState', state.uid);
   return savedState;
 };
 const hasFunctionalResize$h = true;
 
 const wrapExtensionDetailCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$d(`ExtensionDetail.${key}`, state.uid, ...args);
-    const diffResult = await invoke$d('ExtensionDetail.diff2', state.uid);
+    await invoke$e(`ExtensionDetail.${key}`, state.uid, ...args);
+    const diffResult = await invoke$e('ExtensionDetail.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$d('ExtensionDetail.render2', state.uid, diffResult);
+    const commands = await invoke$e('ExtensionDetail.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -18972,21 +18875,21 @@ const wrapExtensionDetailCommand = key => {
   return fn;
 };
 
-const Commands$r = {};
-const getCommands$h = async () => {
-  const commands = await invoke$d('ExtensionDetail.getCommandIds');
+const Commands$s = {};
+const getCommands$i = async () => {
+  const commands = await invoke$e('ExtensionDetail.getCommandIds');
   for (const command of commands) {
-    Commands$r[command] = wrapExtensionDetailCommand(command);
+    Commands$s[command] = wrapExtensionDetailCommand(command);
   }
-  Commands$r['hotReload'] = hotReload$e;
-  return Commands$r;
+  Commands$s['hotReload'] = hotReload$e;
+  return Commands$s;
 };
 
-const Css$p = ["/css/parts/AdditionalDetails.css", "/css/parts/BrowserScrollBar.css", "/css/parts/Category.css", "/css/parts/FeatureContent.css", "/css/parts/Features.css", "/css/parts/Markdown.css", "/css/parts/Message.css", "/css/parts/ScrollToTop.css", "/css/parts/ViewletExtensionDetail.css", "/css/parts/ViewletExtensionDetailHeader.css", "/css/parts/ViewletExtensionDetailTabs.css"];
+const Css$q = ["/css/parts/AdditionalDetails.css", "/css/parts/BrowserScrollBar.css", "/css/parts/Category.css", "/css/parts/FeatureContent.css", "/css/parts/Features.css", "/css/parts/Markdown.css", "/css/parts/Message.css", "/css/parts/ScrollToTop.css", "/css/parts/ViewletExtensionDetail.css", "/css/parts/ViewletExtensionDetailHeader.css", "/css/parts/ViewletExtensionDetailTabs.css"];
 
 const getKeyBindings$e = async () => {
   try {
-    return await invoke$d('ExtensionDetail.getKeyBindings');
+    return await invoke$e('ExtensionDetail.getKeyBindings');
   } catch {
     return [];
   }
@@ -18995,13 +18898,13 @@ const getKeyBindings$e = async () => {
 const menus$d = [];
 const getMenus$a = async () => {
   try {
-    const ids = await invoke$d('ExtensionDetail.getMenuIds');
+    const ids = await invoke$e('ExtensionDetail.getMenuIds');
     const adjusted = ids.map(id => {
       return {
         id,
         async getMenuEntries(...args) {
           // TODO pass menu id also
-          const entries = await invoke$d('ExtensionDetail.getMenuEntries2', ...args);
+          const entries = await invoke$e('ExtensionDetail.getMenuEntries2', ...args);
           return entries;
         }
       };
@@ -19014,40 +18917,40 @@ const getMenus$a = async () => {
 
 const name$p = 'ExtensionDetail';
 
-const hasFunctionalRender$q = true;
-const hasFunctionalRootRender$o = true;
-const hasFunctionalEvents$l = true;
-const renderDom$7 = {
+const hasFunctionalRender$r = true;
+const hasFunctionalRootRender$p = true;
+const hasFunctionalEvents$m = true;
+const renderDom$8 = {
   isEqual(oldState, newState) {
     return false;
   },
   apply: apply,
   multiple: true
 };
-const render$q = [renderDom$7];
-const renderEventListeners$j = async () => {
-  const listeners = await invoke$d('ExtensionDetail.renderEventListeners');
+const render$r = [renderDom$8];
+const renderEventListeners$k = async () => {
+  const listeners = await invoke$e('ExtensionDetail.renderEventListeners');
   return listeners;
 };
 
 const ViewletExtensionDetail_ipc = {
   __proto__: null,
-  Commands: Commands$r,
-  Css: Css$p,
-  create: create$u,
-  getCommands: getCommands$h,
-  getKeyBindings: getKeyBindings$e,
-  getMenus: getMenus$a,
-  hasFunctionalEvents: hasFunctionalEvents$l,
-  hasFunctionalRender: hasFunctionalRender$q,
+  Commands: Commands$s,
+  Css: Css$q,
+  create: create$v,
+  getCommands: getCommands$i,
+  getKeyBindings: getKeyBindings$e,
+  getMenus: getMenus$a,
+  hasFunctionalEvents: hasFunctionalEvents$m,
+  hasFunctionalRender: hasFunctionalRender$r,
   hasFunctionalResize: hasFunctionalResize$h,
-  hasFunctionalRootRender: hasFunctionalRootRender$o,
+  hasFunctionalRootRender: hasFunctionalRootRender$p,
   hotReload: hotReload$e,
-  loadContent: loadContent$u,
+  loadContent: loadContent$v,
   menus: menus$d,
   name: name$p,
-  render: render$q,
-  renderEventListeners: renderEventListeners$j,
+  render: render$r,
+  renderEventListeners: renderEventListeners$k,
   saveState: saveState$e
 };
 
@@ -19155,7 +19058,7 @@ const getActionsDom$1 = async state => {
     type: Button
   })));
 };
-const create$t = (id, uri, x, y, width, height, _args, parentUid) => {
+const create$u = (id, uri, x, y, width, height, _args, parentUid) => {
   return {
     actionsDom: [],
     commands: [],
@@ -19180,7 +19083,7 @@ const create$t = (id, uri, x, y, width, height, _args, parentUid) => {
     y
   };
 };
-const loadContent$t = async (state, savedState) => {
+const loadContent$u = async (state, savedState) => {
   const view = await getExtensionView(state.uri);
   if (!view) {
     throw new Error(`view ${state.uri} not found`);
@@ -19305,7 +19208,7 @@ const handleContextMenu$2 = (state, name, x, y) => {
     y
   });
 };
-const Commands$q = {
+const Commands$r = {
   handleBlur: handleBlur$2,
   handleContextMenu: handleContextMenu$2,
   handleClick,
@@ -19329,9 +19232,9 @@ const saveState$d = async state => {
   return invoke$E('Extensions.saveViewInstanceState', state.uri, state.uid, assetDir, getPlatform$1());
 };
 
-const hasFunctionalRender$p = true;
-const hasFunctionalRootRender$n = true;
-const hasFunctionalEvents$k = true;
+const hasFunctionalRender$q = true;
+const hasFunctionalRootRender$o = true;
+const hasFunctionalEvents$l = true;
 const renderIframe = {
   isEqual(oldState, newState) {
     return oldState.iframeSrc === newState.iframeSrc && oldState.iframeSandbox === newState.iframeSandbox && oldState.csp === newState.csp && oldState.credentialless === newState.credentialless;
@@ -19340,7 +19243,7 @@ const renderIframe = {
     return ['setIframe', newState.iframeSrc, newState.iframeSandbox, '', newState.csp, newState.credentialless, newState.title];
   }
 };
-const renderDom$6 = {
+const renderDom$7 = {
   isEqual(oldState, newState) {
     return newState.kind !== 'virtualDom' || oldState.dom === newState.dom;
   },
@@ -19383,7 +19286,7 @@ const renderCommands = {
   },
   multiple: true
 };
-const render$p = [renderIframe, renderDom$6, renderPatches, renderFocus, renderCss$1, renderCommands];
+const render$q = [renderIframe, renderDom$7, renderPatches, renderFocus, renderCss$1, renderCommands];
 const renderActions$9 = {
   isEqual(oldState, newState) {
     return oldState.actionsDom === newState.actionsDom;
@@ -19438,7 +19341,7 @@ const defaultEventListeners = [{
   params: ['handleViewEvent', 'drop', 'event.target.name'],
   preventDefault: true
 }];
-const renderEventListeners$i = state => {
+const renderEventListeners$j = state => {
   return [...defaultEventListeners, ...(state?.eventListeners || [])];
 };
 
@@ -19457,8 +19360,8 @@ const menus$c = [{
 
 const ViewletExtensionView_ipc = {
   __proto__: null,
-  Commands: Commands$q,
-  create: create$t,
+  Commands: Commands$r,
+  create: create$u,
   dispose: dispose$k,
   handleBlur: handleBlur$2,
   handleClick,
@@ -19468,15 +19371,15 @@ const ViewletExtensionView_ipc = {
   handleInput: handleInput$2,
   handleSubmit,
   handleViewEvent,
-  hasFunctionalEvents: hasFunctionalEvents$k,
-  hasFunctionalRender: hasFunctionalRender$p,
+  hasFunctionalEvents: hasFunctionalEvents$l,
+  hasFunctionalRender: hasFunctionalRender$q,
   hasFunctionalResize: hasFunctionalResize$g,
-  hasFunctionalRootRender: hasFunctionalRootRender$n,
-  loadContent: loadContent$t,
+  hasFunctionalRootRender: hasFunctionalRootRender$o,
+  loadContent: loadContent$u,
   menus: menus$c,
-  render: render$p,
+  render: render$q,
   renderActions: renderActions$9,
-  renderEventListeners: renderEventListeners$i,
+  renderEventListeners: renderEventListeners$j,
   renderTitle: renderTitle$2,
   rerender,
   resize: resize$h,
@@ -19502,17 +19405,17 @@ const launchExtensionSearchViewWorker = async () => {
 };
 
 const {
-  invoke: invoke$c,
+  invoke: invoke$d,
   restart: restart$8
 } = getOrCreateWorker(launchExtensionSearchViewWorker);
 
 // then state can be recycled by Viewlet when there is only a single ViewletExtensions instance
 
 const saveState$c = async state => {
-  const savedState = await invoke$c('SearchExtensions.saveState', state.id);
+  const savedState = await invoke$d('SearchExtensions.saveState', state.id);
   return savedState;
 };
-const create$s = (id, uri, x, y, width, height) => {
+const create$t = (id, uri, x, y, width, height) => {
   return {
     id,
     uid: id,
@@ -19525,11 +19428,11 @@ const create$s = (id, uri, x, y, width, height) => {
     assetDir: assetDir
   };
 };
-const loadContent$s = async (state, savedState) => {
-  await invoke$c('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
-  await invoke$c('SearchExtensions.loadContent', state.id, savedState);
-  const diffResult = await invoke$c('SearchExtensions.diff2', state.id);
-  const commands = await invoke$c('SearchExtensions.render3', state.id, diffResult);
+const loadContent$t = async (state, savedState) => {
+  await invoke$d('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
+  await invoke$d('SearchExtensions.loadContent', state.id, savedState);
+  const diffResult = await invoke$d('SearchExtensions.diff2', state.id);
+  const commands = await invoke$d('SearchExtensions.render3', state.id, diffResult);
   return {
     ...state,
     commands
@@ -19547,16 +19450,16 @@ const hotReload$d = 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$c('SearchExtensions.saveState', state.uid);
+  const savedState = await invoke$d('SearchExtensions.saveState', state.uid);
   await restart$8('SearchExtensions.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$c('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
-  await invoke$c('SearchExtensions.loadContent', state.id, savedState);
-  const diffResult = await invoke$c('SearchExtensions.diff2', state.id);
-  const commands = await invoke$c('SearchExtensions.render3', oldState.id, diffResult);
+  await invoke$d('SearchExtensions.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.assetDir);
+  await invoke$d('SearchExtensions.loadContent', state.id, savedState);
+  const diffResult = await invoke$d('SearchExtensions.diff2', state.id);
+  const commands = await invoke$d('SearchExtensions.render3', oldState.id, diffResult);
   return {
     ...oldState,
     commands,
@@ -19566,9 +19469,9 @@ const hotReload$d = async state => {
 
 const wrapExtensionSearchCommand = key => {
   const wrapped = async (state, ...args) => {
-    await invoke$c(`SearchExtensions.${key}`, state.uid, ...args);
-    const diffResult = await invoke$c(`SearchExtensions.diff2`, state.uid);
-    const commands = await invoke$c('SearchExtensions.render3', state.uid, diffResult);
+    await invoke$d(`SearchExtensions.${key}`, state.uid, ...args);
+    const diffResult = await invoke$d(`SearchExtensions.diff2`, state.uid);
+    const commands = await invoke$d('SearchExtensions.render3', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -19577,32 +19480,32 @@ const wrapExtensionSearchCommand = key => {
   return wrapped;
 };
 
-const Commands$p = {};
-const getCommands$g = async () => {
-  const commands = await invoke$c('SearchExtensions.getCommandIds');
+const Commands$q = {};
+const getCommands$h = async () => {
+  const commands = await invoke$d('SearchExtensions.getCommandIds');
   for (const command of commands) {
-    Commands$p[command] = wrapExtensionSearchCommand(command);
+    Commands$q[command] = wrapExtensionSearchCommand(command);
   }
-  Commands$p['hotReload'] = hotReload$d;
-  return Commands$p;
+  Commands$q['hotReload'] = hotReload$d;
+  return Commands$q;
 };
 
-const Css$o = ["/css/parts/Table.css", "/css/parts/ViewletExtensions.css"];
+const Css$p = ["/css/parts/Table.css", "/css/parts/ViewletExtensions.css"];
 
 const getKeyBindings$d = () => {
-  return invoke$c('SearchExtensions.getKeyBindings');
+  return invoke$d('SearchExtensions.getKeyBindings');
 };
 
 const menus$b = [];
 const getMenus$9 = async () => {
   try {
-    const ids = await invoke$c('SearchExtensions.getMenuIds');
+    const ids = await invoke$d('SearchExtensions.getMenuIds');
     const adjusted = ids.map(id => {
       return {
         id,
         async getMenuEntries(...args) {
           // TODO pass menu id also
-          const entries = await invoke$c('SearchExtensions.getMenuEntries2', ...args);
+          const entries = await invoke$d('SearchExtensions.getMenuEntries2', ...args);
           return entries;
         }
       };
@@ -19615,9 +19518,9 @@ const getMenus$9 = async () => {
 
 const name$o = 'Extensions';
 
-const hasFunctionalRender$o = true;
-const hasFunctionalRootRender$m = true;
-const hasFunctionalEvents$j = true;
+const hasFunctionalRender$p = true;
+const hasFunctionalRootRender$n = true;
+const hasFunctionalEvents$k = true;
 const renderItems$c = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -19625,9 +19528,9 @@ const renderItems$c = {
   apply: apply,
   multiple: true
 };
-const render$o = [renderItems$c];
-const renderEventListeners$h = async () => {
-  const listeners = await invoke$c('SearchExtensions.renderEventListeners');
+const render$p = [renderItems$c];
+const renderEventListeners$i = async () => {
+  const listeners = await invoke$d('SearchExtensions.renderEventListeners');
   return listeners;
 };
 
@@ -19686,24 +19589,24 @@ const resize$g = (state, dimensions) => {
 
 const ViewletExtensions_ipc = {
   __proto__: null,
-  Commands: Commands$p,
-  Css: Css$o,
-  create: create$s,
+  Commands: Commands$q,
+  Css: Css$p,
+  create: create$t,
   dispose: dispose$j,
-  getCommands: getCommands$g,
+  getCommands: getCommands$h,
   getKeyBindings: getKeyBindings$d,
   getMenus: getMenus$9,
-  hasFunctionalEvents: hasFunctionalEvents$j,
-  hasFunctionalRender: hasFunctionalRender$o,
+  hasFunctionalEvents: hasFunctionalEvents$k,
+  hasFunctionalRender: hasFunctionalRender$p,
   hasFunctionalResize: hasFunctionalResize$f,
-  hasFunctionalRootRender: hasFunctionalRootRender$m,
+  hasFunctionalRootRender: hasFunctionalRootRender$n,
   hotReload: hotReload$d,
-  loadContent: loadContent$s,
+  loadContent: loadContent$t,
   menus: menus$b,
   name: name$o,
-  render: render$o,
+  render: render$p,
   renderActions: renderActions$8,
-  renderEventListeners: renderEventListeners$h,
+  renderEventListeners: renderEventListeners$i,
   renderTitle: renderTitle$1,
   resize: resize$g,
   saveState: saveState$c
@@ -19723,11 +19626,11 @@ const launchIframeInspectorWorker = async () => {
 };
 
 const {
-  invoke: invoke$b,
+  invoke: invoke$c,
   restart: restart$7
 } = getOrCreateWorker(launchIframeInspectorWorker);
 
-const create$r = (id, uri, x, y, width, height) => {
+const create$s = (id, uri, x, y, width, height) => {
   return {
     id,
     uid: id,
@@ -19738,11 +19641,11 @@ const create$r = (id, uri, x, y, width, height) => {
     height
   };
 };
-const loadContent$r = async state => {
-  await invoke$b('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
-  await invoke$b('IframeInspector.loadContent', state.id);
-  const diffResult = await invoke$b('IframeInspector.diff2', state.id);
-  const commands = await invoke$b('IframeInspector.render2', state.id, diffResult);
+const loadContent$s = async state => {
+  await invoke$c('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
+  await invoke$c('IframeInspector.loadContent', state.id);
+  const diffResult = await invoke$c('IframeInspector.diff2', state.id);
+  const commands = await invoke$c('IframeInspector.render2', state.id, diffResult);
   return {
     ...state,
     commands
@@ -19756,16 +19659,16 @@ const hotReload$c = 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('IframeInspector.saveState', state.uid);
+  const savedState = await invoke$c('IframeInspector.saveState', state.uid);
   await restart$7('IframeInspector.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$b('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
-  await invoke$b('IframeInspector.loadContent', state.id, savedState);
-  const diffResult = await invoke$b('IframeInspector.diff2', oldState.id);
-  const commands = await invoke$b('IframeInspector.render2', oldState.id, diffResult);
+  await invoke$c('IframeInspector.create', state.id, state.x, state.y, state.width, state.height);
+  await invoke$c('IframeInspector.loadContent', state.id, savedState);
+  const diffResult = await invoke$c('IframeInspector.diff2', oldState.id);
+  const commands = await invoke$c('IframeInspector.render2', oldState.id, diffResult);
   return {
     ...oldState,
     commands,
@@ -19775,9 +19678,9 @@ const hotReload$c = async state => {
 
 const wrapIframeInspectorCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$b(`IframeInspector.${key}`, state.id, ...args);
-    const diffResult = await invoke$b('IframeInspector.diff2', state.id);
-    const commands = await invoke$b('IframeInspector.render2', state.id, diffResult);
+    await invoke$c(`IframeInspector.${key}`, state.id, ...args);
+    const diffResult = await invoke$c('IframeInspector.diff2', state.id);
+    const commands = await invoke$c('IframeInspector.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -19789,27 +19692,27 @@ const wrapIframeInspectorCommand = key => {
   return fn;
 };
 
-const Commands$o = {};
-const getCommands$f = async () => {
-  const commands = await invoke$b('IframeInspector.getCommandIds');
+const Commands$p = {};
+const getCommands$g = async () => {
+  const commands = await invoke$c('IframeInspector.getCommandIds');
   for (const command of commands) {
-    Commands$o[command] = wrapIframeInspectorCommand(command);
+    Commands$p[command] = wrapIframeInspectorCommand(command);
   }
-  Commands$o['hotReload'] = hotReload$c;
-  return Commands$o;
+  Commands$p['hotReload'] = hotReload$c;
+  return Commands$p;
 };
 
-const Css$n = ["/css/parts/Table.css", "/css/parts/ViewletIframeInspector.css"];
+const Css$o = ["/css/parts/Table.css", "/css/parts/ViewletIframeInspector.css"];
 
 const getKeyBindings$c = () => {
-  return invoke$b('IframeInspector.getKeyBindings');
+  return invoke$c('IframeInspector.getKeyBindings');
 };
 
 const name$n = 'IframeInspector';
 
-const hasFunctionalRender$n = true;
-const hasFunctionalRootRender$l = true;
-const hasFunctionalEvents$i = true;
+const hasFunctionalRender$o = true;
+const hasFunctionalRootRender$m = true;
+const hasFunctionalEvents$j = true;
 const renderContent = {
   isEqual(oldState, newState) {
     return false;
@@ -19817,28 +19720,28 @@ const renderContent = {
   apply: apply,
   multiple: true
 };
-const render$n = [renderContent];
-const renderEventListeners$g = async () => {
-  const listeners = await invoke$b('IframeInspector.renderEventListeners');
+const render$o = [renderContent];
+const renderEventListeners$h = async () => {
+  const listeners = await invoke$c('IframeInspector.renderEventListeners');
   return listeners;
 };
 
 const ViewletIframeInspector_ipc = {
   __proto__: null,
-  Commands: Commands$o,
-  Css: Css$n,
-  create: create$r,
-  getCommands: getCommands$f,
+  Commands: Commands$p,
+  Css: Css$o,
+  create: create$s,
+  getCommands: getCommands$g,
   getKeyBindings: getKeyBindings$c,
-  hasFunctionalEvents: hasFunctionalEvents$i,
-  hasFunctionalRender: hasFunctionalRender$n,
-  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  hasFunctionalEvents: hasFunctionalEvents$j,
+  hasFunctionalRender: hasFunctionalRender$o,
+  hasFunctionalRootRender: hasFunctionalRootRender$m,
   hotReload: hotReload$c,
-  loadContent: loadContent$r,
+  loadContent: loadContent$s,
   name: name$n,
-  render: render$n,
+  render: render$o,
   renderContent,
-  renderEventListeners: renderEventListeners$g
+  renderEventListeners: renderEventListeners$h
 };
 
 const first = () => {
@@ -19876,9 +19779,9 @@ const launchReferencesWorker = async () => {
 };
 
 const {
-  invoke: invoke$a} = getOrCreateWorker(launchReferencesWorker);
+  invoke: invoke$b} = getOrCreateWorker(launchReferencesWorker);
 
-const create$q = (id, uri, x, y, width, height, args) => {
+const create$r = (id, uri, x, y, width, height, args) => {
   return {
     references: [],
     message: '',
@@ -19894,12 +19797,12 @@ const create$q = (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$q = async (state, savedState) => {
-  await invoke$a('References.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.assetDir, state.platform);
-  await invoke$a('References.loadContent', state.id, savedState);
-  const diff = await invoke$a('References.diff2', state.id);
-  const commands = await invoke$a('References.render2', state.id, diff);
-  const actionsDom = await invoke$a('References.renderActions', state.id);
+const loadContent$r = async (state, savedState) => {
+  await invoke$b('References.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.assetDir, state.platform);
+  await invoke$b('References.loadContent', state.id, savedState);
+  const diff = await invoke$b('References.diff2', state.id);
+  const commands = await invoke$b('References.render2', state.id, diff);
+  const actionsDom = await invoke$b('References.renderActions', state.id);
   return {
     ...state,
     commands,
@@ -20010,7 +19913,7 @@ const selectCurrent = state => {
   return selectIndex(state, state.focusedIndex);
 };
 const saveState$b = async state => {
-  const savedState = await invoke$a('References.saveState', state.uid);
+  const savedState = await invoke$b('References.saveState', state.uid);
   return savedState;
 };
 const renderActions$7 = {
@@ -20025,7 +19928,7 @@ const renderActions$7 = {
 
 const ViewletLocations = {
   __proto__: null,
-  create: create$q,
+  create: create$r,
   dispose: dispose$i,
   focusFirst,
   focusIndex: focusIndex$2,
@@ -20033,7 +19936,7 @@ const ViewletLocations = {
   focusNext,
   focusPrevious,
   hotReload: hotReload$b,
-  loadContent: loadContent$q,
+  loadContent: loadContent$r,
   renderActions: renderActions$7,
   saveState: saveState$b,
   selectCurrent,
@@ -20047,10 +19950,10 @@ const ViewletLocations = {
 //   return Implementation.getImplementations(editor)
 // }
 
-const create$p = create$q;
-const loadContent$p = async (state, savedState) => {
+const create$q = create$r;
+const loadContent$q = async (state, savedState) => {
   // @ts-ignore
-  return loadContent$q(state, savedState);
+  return loadContent$r(state, savedState);
 };
 const contentLoaded$2 = state => {
   set$9('Locations', {
@@ -20061,9 +19964,9 @@ const contentLoaded$2 = state => {
 };
 const dispose$h = dispose$i;
 
-const hasFunctionalRender$m = true;
-const hasFunctionalRootRender$k = true;
-const hasFunctionalEvents$h = true;
+const hasFunctionalRender$n = true;
+const hasFunctionalRootRender$l = true;
+const hasFunctionalEvents$i = true;
 const renderItems$b = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
@@ -20071,28 +19974,28 @@ const renderItems$b = {
   apply: apply,
   multiple: true
 };
-const render$m = [renderItems$b];
-const renderEventListeners$f = async () => {
-  const listeners = await invoke$a('References.renderEventListeners');
+const render$n = [renderItems$b];
+const renderEventListeners$g = async () => {
+  const listeners = await invoke$b('References.renderEventListeners');
   return listeners;
 };
 
 const name$m = 'Implementations';
-const Commands$n = {};
+const Commands$o = {};
 
 const ViewletImplementations_ipc = {
   __proto__: null,
-  Commands: Commands$n,
+  Commands: Commands$o,
   contentLoaded: contentLoaded$2,
-  create: create$p,
+  create: create$q,
   dispose: dispose$h,
-  hasFunctionalEvents: hasFunctionalEvents$h,
-  hasFunctionalRender: hasFunctionalRender$m,
-  hasFunctionalRootRender: hasFunctionalRootRender$k,
-  loadContent: loadContent$p,
+  hasFunctionalEvents: hasFunctionalEvents$i,
+  hasFunctionalRender: hasFunctionalRender$n,
+  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  loadContent: loadContent$q,
   name: name$m,
-  render: render$m,
-  renderEventListeners: renderEventListeners$f
+  render: render$n,
+  renderEventListeners: renderEventListeners$g
 };
 
 // export * from './ViewletInlineDiffEditor.js'
@@ -20139,7 +20042,7 @@ const launchKeyBindingsViewWorker = async () => {
 };
 
 const {
-  invoke: invoke$9,
+  invoke: invoke$a,
   restart: restart$6
 } = getOrCreateWorker(launchKeyBindingsViewWorker);
 
@@ -20147,7 +20050,7 @@ const {
 // see https://github.com/microsoft/vscode/blob/6a5e3aad96929a7d35e09ed8d22e87a72bd16ff6/src/vs/workbench/services/preferences/browser/keybindingsEditorModel.ts
 // see https://github.com/microsoft/vscode/blob/6a5e3aad96929a7d35e09ed8d22e87a72bd16ff6/src/vs/workbench/contrib/preferences/browser/keybindingsEditor.ts
 
-const create$o = (id, uri, x, y, width, height) => {
+const create$p = (id, uri, x, y, width, height) => {
   return {
     x,
     y,
@@ -20157,13 +20060,13 @@ const create$o = (id, uri, x, y, width, height) => {
   };
 };
 const saveState$a = state => {
-  return invoke$9('KeyBindings.saveState', state.uid);
+  return invoke$a('KeyBindings.saveState', state.uid);
 };
-const loadContent$o = async (state, savedState) => {
-  await invoke$9('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$9('KeyBindings.loadContent', state.uid, savedState);
-  const diffResult = await invoke$9('KeyBindings.diff2', state.uid);
-  const commands = await invoke$9('KeyBindings.render3', state.uid, diffResult);
+const loadContent$p = async (state, savedState) => {
+  await invoke$a('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$a('KeyBindings.loadContent', state.uid, savedState);
+  const diffResult = await invoke$a('KeyBindings.diff2', state.uid);
+  const commands = await invoke$a('KeyBindings.render3', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -20177,16 +20080,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$9('KeyBindings.saveState', state.uid);
+  const savedState = await invoke$a('KeyBindings.saveState', state.uid);
   await restart$6('KeyBindings.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$9('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
-  await invoke$9('KeyBindings.loadContent', state.uid, savedState);
-  const diffResult = await invoke$9('KeyBindings.diff2', state.uid);
-  const commands = await invoke$9('KeyBindings.render3', oldState.uid, diffResult);
+  await invoke$a('KeyBindings.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
+  await invoke$a('KeyBindings.loadContent', state.uid, savedState);
+  const diffResult = await invoke$a('KeyBindings.diff2', state.uid);
+  const commands = await invoke$a('KeyBindings.render3', oldState.uid, diffResult);
   return {
     ...oldState,
     commands,
@@ -20196,9 +20099,9 @@ const hotReload$a = async state => {
 
 const wrapKeyBindingCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$9(`KeyBindings.${key}`, state.uid, ...args);
-    const diffResult = await invoke$9('KeyBindings.diff2', state.uid);
-    const commands = await invoke$9('KeyBindings.render3', state.uid, diffResult);
+    await invoke$a(`KeyBindings.${key}`, state.uid, ...args);
+    const diffResult = await invoke$a('KeyBindings.diff2', state.uid);
+    const commands = await invoke$a('KeyBindings.render3', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -20210,32 +20113,32 @@ const wrapKeyBindingCommand = key => {
   return fn;
 };
 
-const Commands$m = {};
-const getCommands$e = async () => {
-  const commands = await invoke$9('KeyBindings.getCommandIds');
+const Commands$n = {};
+const getCommands$f = async () => {
+  const commands = await invoke$a('KeyBindings.getCommandIds');
   for (const command of commands) {
-    Commands$m[command] = wrapKeyBindingCommand(command);
+    Commands$n[command] = wrapKeyBindingCommand(command);
   }
-  Commands$m['hotReload'] = hotReload$a;
-  return Commands$m;
+  Commands$n['hotReload'] = hotReload$a;
+  return Commands$n;
 };
 
-const Css$m = ["/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 Css$n = ["/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$b = () => {
-  return invoke$9('KeyBindings.getKeyBindings');
+  return invoke$a('KeyBindings.getKeyBindings');
 };
 
 const menus$a = [];
 const getMenus$8 = async () => {
   try {
-    const ids = await invoke$9('KeyBindings.getMenuEntryIds');
+    const ids = await invoke$a('KeyBindings.getMenuEntryIds');
     const adjusted = ids.map(id => {
       return {
         id,
         async getMenuEntries(...args) {
           // TODO pass menu id also
-          const entries = await invoke$9('KeyBindings.getMenuEntries', ...args);
+          const entries = await invoke$a('KeyBindings.getMenuEntries', ...args);
           return entries;
         }
       };
@@ -20248,9 +20151,9 @@ const getMenus$8 = async () => {
 
 const name$l = 'KeyBindings';
 
-const hasFunctionalRender$l = true;
-const hasFunctionalRootRender$j = true;
-const hasFunctionalEvents$g = true;
+const hasFunctionalRender$m = true;
+const hasFunctionalRootRender$k = true;
+const hasFunctionalEvents$h = true;
 const renderKeyBindings = {
   isEqual(oldState, newState) {
     return newState.commands && newState.commands.length === 0;
@@ -20258,9 +20161,9 @@ const renderKeyBindings = {
   apply: apply,
   multiple: true
 };
-const render$l = [renderKeyBindings];
-const renderEventListeners$e = async () => {
-  const listeners = await invoke$9('KeyBindings.renderEventListeners');
+const render$m = [renderKeyBindings];
+const renderEventListeners$f = async () => {
+  const listeners = await invoke$a('KeyBindings.renderEventListeners');
   return listeners;
 };
 
@@ -20287,29 +20190,29 @@ const resize$f = (state, dimensions) => {
 
 const ViewletKeyBindings_ipc = {
   __proto__: null,
-  Commands: Commands$m,
-  Css: Css$m,
-  create: create$o,
-  getCommands: getCommands$e,
+  Commands: Commands$n,
+  Css: Css$n,
+  create: create$p,
+  getCommands: getCommands$f,
   getKeyBindings: getKeyBindings$b,
   getMenus: getMenus$8,
-  hasFunctionalEvents: hasFunctionalEvents$g,
-  hasFunctionalRender: hasFunctionalRender$l,
+  hasFunctionalEvents: hasFunctionalEvents$h,
+  hasFunctionalRender: hasFunctionalRender$m,
   hasFunctionalResize: hasFunctionalResize$e,
-  hasFunctionalRootRender: hasFunctionalRootRender$j,
+  hasFunctionalRootRender: hasFunctionalRootRender$k,
   hotReload: hotReload$a,
-  loadContent: loadContent$o,
+  loadContent: loadContent$p,
   menus: menus$a,
   name: name$l,
-  render: render$l,
-  renderEventListeners: renderEventListeners$e,
+  render: render$m,
+  renderEventListeners: renderEventListeners$f,
   resize: resize$f,
   saveState: saveState$a
 };
 
 const Deb = 'Deb';
 
-const commit = '9f107dc';
+const commit = 'cc29179';
 
 const getAutoUpdateType = () => {
   return invoke$F('AutoUpdater.getAutoUpdateType');
@@ -20469,7 +20372,7 @@ const launchPanelWorker = async () => {
 };
 
 const {
-  invoke: invoke$8,
+  invoke: invoke$9,
   restart: restart$5
 } = getOrCreateWorker(launchPanelWorker);
 
@@ -20910,7 +20813,7 @@ const toActivityBarUserLoginState = userState => {
       return 'logged out';
   }
 };
-const create$n = id => {
+const create$o = id => {
   number(id);
   return {
     sideBarLocation: Right,
@@ -21099,7 +21002,7 @@ const getSavedSecondarySideBarView = savedState => {
   }
   return Chat;
 };
-const loadContent$n = (state, savedState) => {
+const loadContent$o = (state, savedState) => {
   const {
     Layout
   } = savedState;
@@ -21414,12 +21317,12 @@ const getPanelViewChangeCommands = async moduleId => {
     return [];
   }
   const panelUid = instance.state.uid;
-  await invoke$8('Panel.toggleView', panelUid, moduleId);
-  const diffResult = await invoke$8('Panel.diff2', panelUid);
+  await invoke$9('Panel.toggleView', panelUid, moduleId);
+  const diffResult = await invoke$9('Panel.diff2', panelUid);
   if (diffResult.length === 0) {
     return [];
   }
-  return invoke$8('Panel.render2', panelUid, diffResult);
+  return invoke$9('Panel.render2', panelUid, diffResult);
 };
 const showPanel = async (state, moduleId = state.panelView) => {
   if (state.panelVisible) {
@@ -22013,14 +21916,14 @@ const getPanelLayoutChangeCommands = async newState => {
     return [];
   }
   const panelUid = instance.state.uid;
-  await invoke$8('Panel.handlePanelLayoutChanged', panelUid, {
+  await invoke$9('Panel.handlePanelLayoutChanged', panelUid, {
     maximized: newState.panelMaximized
   });
-  const diffResult = await invoke$8('Panel.diff2', panelUid);
+  const diffResult = await invoke$9('Panel.diff2', panelUid);
   if (diffResult.length === 0) {
     return [];
   }
-  const commands = await invoke$8('Panel.render2', panelUid, diffResult);
+  const commands = await invoke$9('Panel.render2', panelUid, diffResult);
   return commands;
 };
 const getFocusChangeCommands = isFocused => {
@@ -22502,7 +22405,7 @@ const getHref = state => {
 };
 
 // prettier-ignore
-const Commands$l = {
+const Commands$m = {
   getAllQuickPickMenuEntries: getAllQuickPickMenuEntries,
   getActiveSideBarView: getActiveSideBarView,
   getActiveSecondarySideBarView: getActiveSecondarySideBarView,
@@ -22593,7 +22496,7 @@ const CommandsWithSideEffects = {
   createPanelViewlet: createPanelViewlet
 };
 
-const Css$l = [];
+const Css$m = [];
 
 const getKeyBindings$a = () => {
   return [{
@@ -23415,22 +23318,22 @@ const getLayoutVirtualDom = state => {
   return dom;
 };
 
-const renderDom$5 = (oldState, newState) => {
+const renderDom$6 = (oldState, newState) => {
   const dom = getLayoutVirtualDom(newState);
   const commands = [['Viewlet.setDom2', newState.uid, dom]];
   // TODO ensure focus commands are last in the commands array
   return commands;
 };
 
-const hasFunctionalRender$k = true;
-const hasFunctionalRootRender$i = true;
-const hasFunctionalEvents$f = true;
-const renderDom$4 = {
+const hasFunctionalRender$l = true;
+const hasFunctionalRootRender$j = true;
+const hasFunctionalEvents$g = true;
+const renderDom$5 = {
   isEqual(oldState, newState) {
     return oldState.mainVisible === newState.mainVisible && oldState.mainId === newState.mainId && oldState.titleBarVisible === newState.titleBarVisible && oldState.titleBarId === newState.titleBarId && oldState.activityBarVisible === newState.activityBarVisible && oldState.activityBarId === newState.activityBarId && oldState.panelVisible === newState.panelVisible && oldState.panelId === newState.panelId && oldState.sideBarLocation === newState.sideBarLocation && oldState.sideBarVisible === newState.sideBarVisible && oldState.sideBarId === newState.sideBarId && oldState.secondarySideBarVisible === newState.secondarySideBarVisible && oldState.secondarySideBarId === newState.secondarySideBarId && oldState.statusBarVisible === newState.statusBarVisible && oldState.statusBarId === newState.statusBarId && oldState.panelSashVisible === newState.panelSashVisible && oldState.sideBarSashVisible === newState.sideBarSashVisible && oldState.previewVisible === newState.previewVisible && oldState.previewSashVisible === newState.previewSashVisible && oldState.previewId === newState.previewId && oldState.secondarySideBarVisible === newState.secondarySideBarVisible;
   },
   apply(oldState, newState) {
-    const commands = renderDom$5(oldState, newState);
+    const commands = renderDom$6(oldState, newState);
     return commands;
   },
   multiple: true
@@ -23499,7 +23402,7 @@ const renderCss = {
   },
   multiple: true
 };
-const renderEventListeners$d = () => {
+const renderEventListeners$e = () => {
   return [{
     name: HandleContextMenu,
     params: ['handleContextMenu']
@@ -23548,17 +23451,17 @@ const renderWindowListeners = {
   },
   multiple: true
 };
-const render$k = [renderDom$4, renderCss, renderWindowListeners];
+const render$l = [renderDom$5, renderCss, renderWindowListeners];
 
 const ViewletLayout_ipc = {
   __proto__: null,
-  Commands: Commands$l,
+  Commands: Commands$m,
   CommandsWithSideEffects,
-  Css: Css$l,
+  Css: Css$m,
   attachViewlet,
   closeChat,
   contentLoadedEffects,
-  create: create$n,
+  create: create$o,
   createPanelViewlet,
   createViewlet: createViewlet$1,
   getActivePanelView,
@@ -23594,9 +23497,9 @@ const ViewletLayout_ipc = {
   handleSashSecondarySideBarPointerDown,
   handleSashSideBarPointerDown,
   handleWorkspaceRefresh,
-  hasFunctionalEvents: hasFunctionalEvents$f,
-  hasFunctionalRender: hasFunctionalRender$k,
-  hasFunctionalRootRender: hasFunctionalRootRender$i,
+  hasFunctionalEvents: hasFunctionalEvents$g,
+  hasFunctionalRender: hasFunctionalRender$l,
+  hasFunctionalRootRender: hasFunctionalRootRender$j,
   hideActivityBar,
   hideMain,
   hidePanel,
@@ -23607,7 +23510,7 @@ const ViewletLayout_ipc = {
   hideTitleBar,
   isSideBarVisible,
   loadActivityBarIfVisible,
-  loadContent: loadContent$n,
+  loadContent: loadContent$o,
   loadMainIfVisible,
   loadPanelIfVisible,
   loadPreviewIfVisible,
@@ -23626,8 +23529,8 @@ const ViewletLayout_ipc = {
   openSecondarySideBarView,
   openSideBarView,
   refreshSourceControlBadgeCount,
-  render: render$k,
-  renderEventListeners: renderEventListeners$d,
+  render: render$l,
+  renderEventListeners: renderEventListeners$e,
   saveState: saveState$9,
   setAuthState,
   setBadgeCount,
@@ -23671,7 +23574,7 @@ const launchMainAreaWorker = async () => {
 };
 
 const {
-  invoke: invoke$7} = getOrCreateWorker(launchMainAreaWorker);
+  invoke: invoke$8} = getOrCreateWorker(launchMainAreaWorker);
 
 const getFontString = (fontWeight, fontSize, fontFamily) => {
   return `${fontWeight} ${fontSize}px ${fontFamily}`;
@@ -23772,6 +23675,9 @@ const getLabel = uri => {
   if (uri.startsWith('process-explorer://')) {
     return 'Process Explorer';
   }
+  if (uri.startsWith('running-extensions://')) {
+    return 'Running Extensions';
+  }
   return pathBaseName(uri);
 };
 
@@ -23994,7 +23900,7 @@ const openUri = async (state, uri, focus = true, {
   };
 };
 
-const create$m = (id, uri, x, y, width, height) => {
+const create$n = (id, uri, x, y, width, height) => {
   return {
     groups: [],
     activeGroupIndex: -1,
@@ -24020,15 +23926,15 @@ const create$m = (id, uri, x, y, width, height) => {
   };
 };
 const saveState$8 = async state => {
-  const saved = await invoke$7('MainArea.saveState', state.uid);
+  const saved = await invoke$8('MainArea.saveState', state.uid);
   return saved;
 };
-const loadContent$m = async (state, savedState) => {
+const loadContent$n = async (state, savedState) => {
   {
-    await invoke$7('MainArea.create', state.uid, '', state.x, state.y, state.width, state.height, null);
-    await invoke$7('MainArea.loadContent', state.uid, savedState);
-    const diffResult = await invoke$7('MainArea.diff2', state.uid);
-    const commands = await invoke$7('MainArea.render2', state.uid, diffResult);
+    await invoke$8('MainArea.create', state.uid, '', state.x, state.y, state.width, state.height, null);
+    await invoke$8('MainArea.loadContent', state.uid, savedState);
+    const diffResult = await invoke$8('MainArea.diff2', state.uid);
+    const commands = await invoke$8('MainArea.render2', state.uid, diffResult);
     return {
       ...state,
       commands
@@ -24036,10 +23942,10 @@ const loadContent$m = async (state, savedState) => {
   }
 };
 const hotReload$9 = async state => {
-  await invoke$7('MainArea.create', state.uid, '', state.x, state.y, state.width, state.height, null);
-  await invoke$7('MainArea.loadContent', state.uid, {});
-  const diffResult = await invoke$7('MainArea.diff2', state.uid);
-  const commands = await invoke$7('MainArea.render2', state.uid, diffResult);
+  await invoke$8('MainArea.create', state.uid, '', state.x, state.y, state.width, state.height, null);
+  await invoke$8('MainArea.loadContent', state.uid, {});
+  const diffResult = await invoke$8('MainArea.diff2', state.uid);
+  const commands = await invoke$8('MainArea.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -24081,19 +23987,19 @@ const openKeyBindings = async state => {
 const wrapMainAreaCommand = key => {
   const fn = async (state, ...args) => {
     if (key === 'resize') {
-      const commands = await invoke$7(`MainArea.${key}`, state.uid, ...args);
+      const commands = await invoke$8(`MainArea.${key}`, state.uid, ...args);
       array(commands);
       return {
         ...state,
         commands
       };
     }
-    await invoke$7(`MainArea.${key}`, state.uid, ...args);
-    const diffResult = await invoke$7('MainArea.diff2', state.uid);
+    await invoke$8(`MainArea.${key}`, state.uid, ...args);
+    const diffResult = await invoke$8('MainArea.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$7('MainArea.render2', state.uid, diffResult);
+    const commands = await invoke$8('MainArea.render2', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -24105,17 +24011,17 @@ const wrapMainAreaCommand = key => {
   return fn;
 };
 
-const Commands$k = {};
-const getCommands$d = async () => {
-  const commands = await invoke$7('MainArea.getCommandIds');
+const Commands$l = {};
+const getCommands$e = async () => {
+  const commands = await invoke$8('MainArea.getCommandIds');
   for (const command of commands) {
-    Commands$k[command] = wrapMainAreaCommand(command);
+    Commands$l[command] = wrapMainAreaCommand(command);
   }
-  Commands$k['hotReload'] = hotReload$9;
-  return Commands$k;
+  Commands$l['hotReload'] = hotReload$9;
+  return Commands$l;
 };
 
-const Css$k = ["/css/parts/ViewletMainDragOverlay.css", "/css/parts/ViewletMainEditorGroup.css", "/css/parts/ViewletMainWaterMark.css"];
+const Css$l = ["/css/parts/ViewletMainDragOverlay.css", "/css/parts/ViewletMainEditorGroup.css", "/css/parts/ViewletMainWaterMark.css"];
 const Variables$5 = ['MainBackground'];
 
 const getKeyBindings$9 = () => {
@@ -24161,12 +24067,12 @@ const getQuickPickMenuEntries = () => {
 const menus$9 = [];
 const getMenus$7 = async () => {
   try {
-    const ids = await invoke$7('MainArea.getMenuIds');
+    const ids = await invoke$8('MainArea.getMenuIds');
     const adjusted = ids.map(id => {
       return {
         id,
         async getMenuEntries(...args) {
-          const entries = await invoke$7('MainArea.getMenuEntries', ...args);
+          const entries = await invoke$8('MainArea.getMenuEntries', ...args);
           return entries;
         }
       };
@@ -24177,10 +24083,10 @@ const getMenus$7 = async () => {
   }
 };
 
-const hasFunctionalRender$j = true;
+const hasFunctionalRender$k = true;
 const hasFunctionalResize$d = true;
-const hasFunctionalRootRender$h = true;
-const hasFunctionalEvents$e = true;
+const hasFunctionalRootRender$i = true;
+const hasFunctionalEvents$f = true;
 const renderItems$a = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -24188,9 +24094,9 @@ const renderItems$a = {
   apply: apply,
   multiple: true
 };
-const render$j = [renderItems$a];
-const renderEventListeners$c = async () => {
-  const listeners = await invoke$7('MainArea.renderEventListeners');
+const render$k = [renderItems$a];
+const renderEventListeners$d = async () => {
+  const listeners = await invoke$8('MainArea.renderEventListeners');
   return listeners;
 };
 
@@ -24259,41 +24165,41 @@ const name$j = 'Main';
 
 const ViewletMain_ipc = {
   __proto__: null,
-  Commands: Commands$k,
-  Css: Css$k,
+  Commands: Commands$l,
+  Css: Css$l,
   Variables: Variables$5,
-  create: create$m,
+  create: create$n,
   dispose: dispose$g,
   focus: focus$3,
-  getCommands: getCommands$d,
+  getCommands: getCommands$e,
   getKeyBindings: getKeyBindings$9,
   getMenus: getMenus$7,
   getQuickPickMenuEntries,
-  hasFunctionalEvents: hasFunctionalEvents$e,
-  hasFunctionalRender: hasFunctionalRender$j,
+  hasFunctionalEvents: hasFunctionalEvents$f,
+  hasFunctionalRender: hasFunctionalRender$k,
   hasFunctionalResize: hasFunctionalResize$d,
-  hasFunctionalRootRender: hasFunctionalRootRender$h,
+  hasFunctionalRootRender: hasFunctionalRootRender$i,
   hotReload: hotReload$9,
-  loadContent: loadContent$m,
+  loadContent: loadContent$n,
   menus: menus$9,
   name: name$j,
   openEditorWithType,
   openKeyBindings,
-  render: render$j,
-  renderEventListeners: renderEventListeners$c,
+  render: render$k,
+  renderEventListeners: renderEventListeners$d,
   resize: resize$e,
   saveState: saveState$8,
   saveWithoutFormatting
 };
 
-const create$l = (id, uri, x, y, width, height) => {
+const create$m = (id, uri, x, y, width, height) => {
   return {
     id,
     interval: -1,
     disposed: false
   };
 };
-const loadContent$l = state => {
+const loadContent$m = state => {
   const update = async () => {
     await invoke$I(/* Viewlet.invoke */'Viewlet.send', /* id */Clock, /* method */'setTime', /* time */Date.now());
   };
@@ -24312,23 +24218,23 @@ const dispose$f = state => {
 };
 
 const name$i = 'MarkDownPreview';
-const Commands$j = {};
+const Commands$k = {};
 
 const ViewletMarkDownPreview_ipc = {
   __proto__: null,
-  Commands: Commands$j,
-  create: create$l,
+  Commands: Commands$k,
+  create: create$m,
   dispose: dispose$f,
-  loadContent: loadContent$l,
+  loadContent: loadContent$m,
   name: name$i
 };
 
-const create$k = id => {
+const create$l = id => {
   return {
     disposed: false
   };
 };
-const loadContent$k = async state => {
+const loadContent$l = async state => {
   console.log('noop');
   return state;
 };
@@ -24339,14 +24245,14 @@ const dispose$e = state => {
   };
 };
 
-const Commands$i = {};
+const Commands$j = {};
 
 const ViewletNoop_ipc = {
   __proto__: null,
-  Commands: Commands$i,
-  create: create$k,
+  Commands: Commands$j,
+  create: create$l,
   dispose: dispose$e,
-  loadContent: loadContent$k
+  loadContent: loadContent$l
 };
 
 const outputViewWorkerUrl = `${assetDir}/packages/output-view/dist/outputViewWorkerMain.js`;
@@ -24364,11 +24270,11 @@ const launchOutputViewWorker = async () => {
 };
 
 const {
-  invoke: invoke$6,
+  invoke: invoke$7,
   restart: restart$4
 } = getOrCreateWorker(launchOutputViewWorker);
 
-const create$j = (uid, uri, x, y, width, height, args, parentUid) => {
+const create$k = (uid, uri, x, y, width, height, args, parentUid) => {
   return {
     id: uid,
     parentUid,
@@ -24381,12 +24287,12 @@ const create$j = (uid, uri, x, y, width, height, args, parentUid) => {
     platform: getPlatform$1()
   };
 };
-const loadContent$j = async (state, savedState) => {
-  await invoke$6('Output.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.parentUid);
-  await invoke$6('Output.loadContent2', state.id, savedState);
-  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);
+const loadContent$k = async (state, savedState) => {
+  await invoke$7('Output.create', state.id, state.uri, state.x, state.y, state.width, state.height, state.platform, state.parentUid);
+  await invoke$7('Output.loadContent2', state.id, savedState);
+  const diffResult = await invoke$7('Output.diff2', state.id);
+  const commands = await invoke$7('Output.render2', state.id, diffResult);
+  const actionsDom = await invoke$7('Output.renderActions', state.uid);
   return {
     ...state,
     commands,
@@ -24399,17 +24305,17 @@ const hotReload$8 = async (state, option) => {
   }
   // TODO avoid mutation
   state.isHotReloading = true;
-  const savedState = await invoke$6('Output.saveState', state.uid);
+  const savedState = await invoke$7('Output.saveState', state.uid);
   await restart$4('Output.terminate');
   const oldState = {
     ...state,
     items: []
   };
-  await invoke$6('Output.create', state.uid, state.uri, state.x, state.y, state.width, state.height, 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);
+  await invoke$7('Output.create', state.uid, state.uri, state.x, state.y, state.width, state.height, state.parentUid, state.platform);
+  await invoke$7('Output.loadContent2', state.uid, savedState);
+  const diffResult = await invoke$7('Output.diff2', state.uid);
+  const commands = await invoke$7('Output.render2', state.uid, diffResult);
+  const actionsDom = await invoke$7('Output.renderActions', state.uid);
   return {
     ...oldState,
     commands,
@@ -24419,14 +24325,14 @@ const hotReload$8 = async (state, option) => {
 };
 const hasFunctionalResize$c = true;
 const saveState$7 = state => {
-  return invoke$6('Output.saveState', state.uid);
+  return invoke$7('Output.saveState', state.uid);
 };
 
 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);
+    await invoke$7(`Output.${key}`, state.id, ...args);
+    const diffResult = await invoke$7(`Output.diff2`, state.id);
+    const commands = await invoke$7('Output.render2', state.id, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -24438,31 +24344,31 @@ const wrapOutputCommand = key => {
   return fn;
 };
 
-const Commands$h = {};
-const getCommands$c = async () => {
-  const commands = await invoke$6('Output.getCommandIds');
+const Commands$i = {};
+const getCommands$d = async () => {
+  const commands = await invoke$7('Output.getCommandIds');
   for (const command of commands) {
-    Commands$h[command] = wrapOutputCommand(command);
+    Commands$i[command] = wrapOutputCommand(command);
   }
-  Commands$h['hotReload'] = hotReload$8;
-  return Commands$h;
+  Commands$i['hotReload'] = hotReload$8;
+  return Commands$i;
 };
 
-const Css$j = ["/css/parts/ViewletOutput.css"];
+const Css$k = ["/css/parts/ViewletOutput.css"];
 
-const hasFunctionalRender$i = true;
-const hasFunctionalRootRender$g = true;
-const hasFunctionalEvents$d = true;
-const renderDialog = {
+const hasFunctionalRender$j = true;
+const hasFunctionalRootRender$h = true;
+const hasFunctionalEvents$e = true;
+const renderDialog = {
   isEqual(oldState, newState) {
     return false;
   },
   apply: apply,
   multiple: true
 };
-const render$i = [renderDialog];
-const renderEventListeners$b = async () => {
-  const listeners = await invoke$6('Output.renderEventListeners');
+const render$j = [renderDialog];
+const renderEventListeners$c = async () => {
+  const listeners = await invoke$7('Output.renderEventListeners');
   return listeners;
 };
 
@@ -24480,25 +24386,25 @@ const name$h = 'Output';
 
 const ViewletOutput_ipc = {
   __proto__: null,
-  Commands: Commands$h,
-  Css: Css$j,
-  create: create$j,
-  getCommands: getCommands$c,
-  hasFunctionalEvents: hasFunctionalEvents$d,
-  hasFunctionalRender: hasFunctionalRender$i,
+  Commands: Commands$i,
+  Css: Css$k,
+  create: create$k,
+  getCommands: getCommands$d,
+  hasFunctionalEvents: hasFunctionalEvents$e,
+  hasFunctionalRender: hasFunctionalRender$j,
   hasFunctionalResize: hasFunctionalResize$c,
-  hasFunctionalRootRender: hasFunctionalRootRender$g,
+  hasFunctionalRootRender: hasFunctionalRootRender$h,
   hotReload: hotReload$8,
-  loadContent: loadContent$j,
+  loadContent: loadContent$k,
   name: name$h,
-  render: render$i,
+  render: render$j,
   renderActions: renderActions$6,
   renderDialog,
-  renderEventListeners: renderEventListeners$b,
+  renderEventListeners: renderEventListeners$c,
   saveState: saveState$7
 };
 
-const create$i = (id, uri, x, y, width, height) => {
+const create$j = (id, uri, x, y, width, height) => {
   return {
     uid: id,
     PanelItems: [],
@@ -24513,12 +24419,12 @@ const create$i = (id, uri, x, y, width, height) => {
     commands: []
   };
 };
-const loadContent$i = async state => {
+const loadContent$j = async state => {
   const savedState = {};
-  await invoke$8('Panel.create', state.uid, '', state.x, state.y, state.width, state.height, null);
-  await invoke$8('Panel.loadContent', state.uid, savedState);
-  const diffResult = await invoke$8('Panel.diff2', state.uid);
-  const commands = await invoke$8('Panel.render2', state.uid, diffResult);
+  await invoke$9('Panel.create', state.uid, '', state.x, state.y, state.width, state.height, null);
+  await invoke$9('Panel.loadContent', state.uid, savedState);
+  const diffResult = await invoke$9('Panel.diff2', state.uid);
+  const commands = await invoke$9('Panel.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -24532,12 +24438,12 @@ 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('Panel.saveState', state.uid);
+  const savedState = await invoke$9('Panel.saveState', state.uid);
   await restart$5('Panel.terminate');
-  await invoke$8('Panel.create', state.uid, '', state.x, state.y, state.width, state.height, null);
-  await invoke$8('Panel.loadContent', state.uid, savedState);
-  const diffResult = await invoke$8('Panel.diff2', state.uid);
-  const commands = await invoke$8('Panel.render2', state.uid, diffResult);
+  await invoke$9('Panel.create', state.uid, '', state.x, state.y, state.width, state.height, null);
+  await invoke$9('Panel.loadContent', state.uid, savedState);
+  const diffResult = await invoke$9('Panel.diff2', state.uid);
+  const commands = await invoke$9('Panel.render2', state.uid, diffResult);
   state.isHotReloading = false;
   return {
     ...state,
@@ -24547,12 +24453,12 @@ const hotReload$7 = async state => {
 
 const wrapPanelCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$8(`Panel.${key}`, state.uid, ...args);
-    const diffResult = await invoke$8('Panel.diff2', state.uid);
+    await invoke$9(`Panel.${key}`, state.uid, ...args);
+    const diffResult = await invoke$9('Panel.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$8('Panel.render2', state.uid, diffResult);
+    const commands = await invoke$9('Panel.render2', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -24564,22 +24470,22 @@ const wrapPanelCommand = key => {
   return fn;
 };
 
-const Commands$g = {};
-const getCommands$b = async () => {
-  const commands = await invoke$8('Panel.getCommandIds');
+const Commands$h = {};
+const getCommands$c = async () => {
+  const commands = await invoke$9('Panel.getCommandIds');
   for (const command of commands) {
-    Commands$g[command] = wrapPanelCommand(command);
+    Commands$h[command] = wrapPanelCommand(command);
   }
-  Commands$g['hotReload'] = hotReload$7;
-  return Commands$g;
+  Commands$h['hotReload'] = hotReload$7;
+  return Commands$h;
 };
 
-const Css$i = ["/css/parts/ViewletPanel.css", "/css/parts/ViewletPanelTabs.css"];
+const Css$j = ["/css/parts/ViewletPanel.css", "/css/parts/ViewletPanelTabs.css"];
 const Variables$4 = ['PanelBackground'];
 
-const hasFunctionalRender$h = true;
-const hasFunctionalRootRender$f = true;
-const hasFunctionalEvents$c = true;
+const hasFunctionalRender$i = true;
+const hasFunctionalRootRender$g = true;
+const hasFunctionalEvents$d = true;
 const renderItems$9 = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
@@ -24587,16 +24493,16 @@ const renderItems$9 = {
   apply: apply,
   multiple: true
 };
-const render$h = [renderItems$9];
-const renderEventListeners$a = async () => {
-  const listeners = await invoke$8('Panel.renderEventListeners');
+const render$i = [renderItems$9];
+const renderEventListeners$b = async () => {
+  const listeners = await invoke$9('Panel.renderEventListeners');
   return listeners;
 };
 const hasFunctionalResize$b = true;
 const resize$d = async (state, dimensions) => {
-  await invoke$8('Panel.resize', state.uid, dimensions);
-  const diffResult = await invoke$8('Panel.diff2', state.uid);
-  const commands = await invoke$8('Panel.render2', state.uid, diffResult);
+  await invoke$9('Panel.resize', state.uid, dimensions);
+  const diffResult = await invoke$9('Panel.diff2', state.uid);
+  const commands = await invoke$9('Panel.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -24607,20 +24513,20 @@ const name$g = 'Panel';
 
 const ViewletPanel_ipc = {
   __proto__: null,
-  Commands: Commands$g,
-  Css: Css$i,
+  Commands: Commands$h,
+  Css: Css$j,
   Variables: Variables$4,
-  create: create$i,
-  getCommands: getCommands$b,
-  hasFunctionalEvents: hasFunctionalEvents$c,
-  hasFunctionalRender: hasFunctionalRender$h,
+  create: create$j,
+  getCommands: getCommands$c,
+  hasFunctionalEvents: hasFunctionalEvents$d,
+  hasFunctionalRender: hasFunctionalRender$i,
   hasFunctionalResize: hasFunctionalResize$b,
-  hasFunctionalRootRender: hasFunctionalRootRender$f,
+  hasFunctionalRootRender: hasFunctionalRootRender$g,
   hotReload: hotReload$7,
-  loadContent: loadContent$i,
+  loadContent: loadContent$j,
   name: name$g,
-  render: render$h,
-  renderEventListeners: renderEventListeners$a,
+  render: render$i,
+  renderEventListeners: renderEventListeners$b,
   resize: resize$d
 };
 
@@ -24639,9 +24545,9 @@ const launchProblemsWorker = async () => {
 };
 
 const {
-  invoke: invoke$5} = getOrCreateWorker(launchProblemsWorker);
+  invoke: invoke$6} = getOrCreateWorker(launchProblemsWorker);
 
-const create$h = (id, uri, x, y, width, height, args, parentUid) => {
+const create$i = (id, uri, x, y, width, height, args, parentUid) => {
   return {
     uid: id,
     parentUid,
@@ -24651,12 +24557,12 @@ const create$h = (id, uri, x, y, width, height, args, parentUid) => {
     height
   };
 };
-const loadContent$h = async (state, savedState) => {
-  await invoke$5('Problems.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getWorkspaceUri());
-  await invoke$5('Problems.loadContent', state.uid, savedState);
-  const diffResult = await invoke$5('Problems.diff2', state.uid);
-  const commands = await invoke$5('Problems.render2', state.uid, diffResult);
-  const actionsDom = await invoke$5('Problems.renderActions', state.uid);
+const loadContent$i = async (state, savedState) => {
+  await invoke$6('Problems.create', state.uid, state.uri, state.x, state.y, state.width, state.height, getWorkspaceUri());
+  await invoke$6('Problems.loadContent', state.uid, savedState);
+  const diffResult = await invoke$6('Problems.diff2', state.uid);
+  const commands = await invoke$6('Problems.render2', state.uid, diffResult);
+  const actionsDom = await invoke$6('Problems.renderActions', state.uid);
   return {
     ...state,
     commands,
@@ -24670,13 +24576,13 @@ const getBadgeCount = state => {
 
 const wrapProblemsCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$5(`Problems.${key}`, state.uid, ...args);
-    const diffResult = await invoke$5('Problems.diff2', state.uid);
+    await invoke$6(`Problems.${key}`, state.uid, ...args);
+    const diffResult = await invoke$6('Problems.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$5('Problems.render2', state.uid, diffResult);
-    const actionsDom = await invoke$5('Problems.renderActions', state.uid);
+    const commands = await invoke$6('Problems.render2', state.uid, diffResult);
+    const actionsDom = await invoke$6('Problems.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -24691,18 +24597,18 @@ const wrapProblemsCommand = key => {
   return fn;
 };
 
-const Commands$f = {};
-const getCommands$a = async () => {
-  const commands = await invoke$5('Problems.getCommandIds');
+const Commands$g = {};
+const getCommands$b = async () => {
+  const commands = await invoke$6('Problems.getCommandIds');
   for (const command of commands) {
-    Commands$f[command] = wrapProblemsCommand(command);
+    Commands$g[command] = wrapProblemsCommand(command);
   }
   // TODO
   // Commands['hotReload'] = ViewletRunAndDebug.hotReload
-  return Commands$f;
+  return Commands$g;
 };
 
-const Css$h = ["/css/parts/Message.css", "/css/parts/ViewletProblems.css"];
+const Css$i = ["/css/parts/Message.css", "/css/parts/ViewletProblems.css"];
 
 const getKeyBindings$8 = () => {
   return [{
@@ -24755,12 +24661,12 @@ const getKeyBindings$8 = () => {
 const menus$8 = [];
 const getMenus$6 = async () => {
   try {
-    const ids = await invoke$5('Problems.getMenuIds');
+    const ids = await invoke$6('Problems.getMenuIds');
     const adjusted = ids.map(id => {
       return {
         id,
         async getMenuEntries(...args) {
-          const entries = await invoke$5('Problems.getMenuEntries2', ...args);
+          const entries = await invoke$6('Problems.getMenuEntries2', ...args);
           return entries;
         }
       };
@@ -24771,9 +24677,9 @@ const getMenus$6 = async () => {
   }
 };
 
-const hasFunctionalRender$g = true;
-const hasFunctionalRootRender$e = true;
-const hasFunctionalEvents$b = true;
+const hasFunctionalRender$h = true;
+const hasFunctionalRootRender$f = true;
+const hasFunctionalEvents$c = true;
 const renderItems$8 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
@@ -24781,9 +24687,9 @@ const renderItems$8 = {
   apply: apply,
   multiple: true
 };
-const render$g = [renderItems$8];
-const renderEventListeners$9 = async () => {
-  const listeners = await invoke$5('Problems.renderEventListeners');
+const render$h = [renderItems$8];
+const renderEventListeners$a = async () => {
+  const listeners = await invoke$6('Problems.renderEventListeners');
   return listeners;
 };
 
@@ -24806,7 +24712,7 @@ const resize$c = (state, dimensions) => {
 };
 
 const saveState$6 = async state => {
-  const savedState = await invoke$5('Problems.saveState', state.uid);
+  const savedState = await invoke$6('Problems.saveState', state.uid);
   return savedState;
 };
 
@@ -24814,23 +24720,23 @@ const name$f = 'Problems';
 
 const ViewletProblems_ipc = {
   __proto__: null,
-  Commands: Commands$f,
-  Css: Css$h,
-  create: create$h,
+  Commands: Commands$g,
+  Css: Css$i,
+  create: create$i,
   getBadgeCount,
-  getCommands: getCommands$a,
+  getCommands: getCommands$b,
   getKeyBindings: getKeyBindings$8,
   getMenus: getMenus$6,
-  hasFunctionalEvents: hasFunctionalEvents$b,
-  hasFunctionalRender: hasFunctionalRender$g,
+  hasFunctionalEvents: hasFunctionalEvents$c,
+  hasFunctionalRender: hasFunctionalRender$h,
   hasFunctionalResize: hasFunctionalResize$a,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
-  loadContent: loadContent$h,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
+  loadContent: loadContent$i,
   menus: menus$8,
   name: name$f,
-  render: render$g,
+  render: render$h,
   renderActions: renderActions$5,
-  renderEventListeners: renderEventListeners$9,
+  renderEventListeners: renderEventListeners$a,
   resize: resize$c,
   saveState: saveState$6
 };
@@ -24849,11 +24755,11 @@ const launchProcessExplorerWorker = async () => {
 };
 
 const {
-  invoke: invoke$4,
+  invoke: invoke$5,
   restart: restart$3
 } = getOrCreateWorker(launchProcessExplorerWorker);
 
-const create$g = (id, uri, x, y, width, height, args, parentUid) => {
+const create$h = (id, uri, x, y, width, height, args, parentUid) => {
   return {
     uid: id,
     parentUid,
@@ -24866,11 +24772,11 @@ const create$g = (id, uri, x, y, width, height, args, parentUid) => {
     commands: []
   };
 };
-const loadContent$g = async (state, savedState) => {
-  await invoke$4('ProcessExplorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
-  await invoke$4('ProcessExplorer.loadContent', state.uid, savedState);
-  const diffResult = await invoke$4('ProcessExplorer.diff2', state.uid);
-  const commands = await invoke$4('ProcessExplorer.render2', state.uid, diffResult);
+const loadContent$h = async (state, savedState) => {
+  await invoke$5('ProcessExplorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
+  await invoke$5('ProcessExplorer.loadContent', state.uid, savedState);
+  const diffResult = await invoke$5('ProcessExplorer.diff2', state.uid);
+  const commands = await invoke$5('ProcessExplorer.render2', state.uid, diffResult);
   return {
     ...state,
     commands
@@ -24883,10 +24789,10 @@ const hotReload$6 = async state => {
   }
   state.isHotReloading = true;
   await restart$3('ProcessExplorer.terminate');
-  await invoke$4('ProcessExplorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
-  await invoke$4('ProcessExplorer.loadContent', state.uid);
-  const diffResult = await invoke$4('ProcessExplorer.diff2', state.uid);
-  const commands = await invoke$4('ProcessExplorer.render2', state.uid, diffResult);
+  await invoke$5('ProcessExplorer.create', state.uid, state.uri, state.x, state.y, state.width, state.height, null, state.parentUid, state.platform, state.assetDir);
+  await invoke$5('ProcessExplorer.loadContent', state.uid);
+  const diffResult = await invoke$5('ProcessExplorer.diff2', state.uid);
+  const commands = await invoke$5('ProcessExplorer.render2', state.uid, diffResult);
   return {
     ...state,
     commands,
@@ -24896,12 +24802,12 @@ const hotReload$6 = async state => {
 
 const wrapProcessExplorerCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$4(`ProcessExplorer.${key}`, state.uid, ...args);
-    const diffResult = await invoke$4('ProcessExplorer.diff2', state.uid);
+    await invoke$5(`ProcessExplorer.${key}`, state.uid, ...args);
+    const diffResult = await invoke$5('ProcessExplorer.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$4('ProcessExplorer.render2', state.uid, diffResult);
+    const commands = await invoke$5('ProcessExplorer.render2', state.uid, diffResult);
     if (commands.length === 0) {
       return state;
     }
@@ -24915,26 +24821,26 @@ const wrapProcessExplorerCommand = key => {
   return fn;
 };
 
-const Commands$e = {};
-const getCommands$9 = async () => {
-  const commands = await invoke$4('ProcessExplorer.getCommandIds');
+const Commands$f = {};
+const getCommands$a = async () => {
+  const commands = await invoke$5('ProcessExplorer.getCommandIds');
   for (const command of commands) {
-    Commands$e[command] = wrapProcessExplorerCommand(command);
+    Commands$f[command] = wrapProcessExplorerCommand(command);
   }
-  Commands$e['hotReload'] = hotReload$6;
-  return Commands$e;
+  Commands$f['hotReload'] = hotReload$6;
+  return Commands$f;
 };
 
-const Css$g = ["/css/parts/ViewletProcessExplorer.css"];
+const Css$h = ["/css/parts/ViewletProcessExplorer.css"];
 
 const getKeyBindings$7 = () => {
-  return invoke$4('ProcessExplorer.getKeyBindings');
+  return invoke$5('ProcessExplorer.getKeyBindings');
 };
 
 const id$1 = ProcessExplorer;
 const getMenuEntries$1 = async () => {
   const processExplorerState = getState('ProcessExplorer');
-  const r = await invoke$4('ProcessExplorer.getMenuEntries', processExplorerState.uid);
+  const r = await invoke$5('ProcessExplorer.getMenuEntries', processExplorerState.uid);
   return r;
 };
 
@@ -24948,9 +24854,9 @@ const menus$7 = [MenuEntriesProcessExplorer];
 
 const name$e = 'ProcessExplorer';
 
-const hasFunctionalRender$f = true;
-const hasFunctionalRootRender$d = true;
-const hasFunctionalEvents$a = true;
+const hasFunctionalRender$g = true;
+const hasFunctionalRootRender$e = true;
+const hasFunctionalEvents$b = true;
 const renderItems$7 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
@@ -24958,28 +24864,28 @@ const renderItems$7 = {
   apply: apply,
   multiple: true
 };
-const render$f = [renderItems$7];
-const renderEventListeners$8 = async () => {
-  return invoke$4('ProcessExplorer.renderEventListeners');
+const render$g = [renderItems$7];
+const renderEventListeners$9 = async () => {
+  return invoke$5('ProcessExplorer.renderEventListeners');
 };
 
 const ViewletProcessExplorer_ipc = {
   __proto__: null,
-  Commands: Commands$e,
-  Css: Css$g,
-  create: create$g,
+  Commands: Commands$f,
+  Css: Css$h,
+  create: create$h,
   dispose: dispose$d,
-  getCommands: getCommands$9,
+  getCommands: getCommands$a,
   getKeyBindings: getKeyBindings$7,
-  hasFunctionalEvents: hasFunctionalEvents$a,
-  hasFunctionalRender: hasFunctionalRender$f,
-  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  hasFunctionalEvents: hasFunctionalEvents$b,
+  hasFunctionalRender: hasFunctionalRender$g,
+  hasFunctionalRootRender: hasFunctionalRootRender$e,
   hotReload: hotReload$6,
-  loadContent: loadContent$g,
+  loadContent: loadContent$h,
   menus: menus$7,
   name: name$e,
-  render: render$f,
-  renderEventListeners: renderEventListeners$8
+  render: render$g,
+  renderEventListeners: renderEventListeners$9
 };
 
 const User = 1;
@@ -24998,7 +24904,7 @@ const User = 1;
 
 const QuickPickState = {
   Default: 0};
-const create$f = (id, uri, x, y, width, height, args) => {
+const create$g = (id, uri, x, y, width, height, args) => {
   return {
     uid: id,
     state: QuickPickState.Default,
@@ -25023,7 +24929,7 @@ const create$f = (id, uri, x, y, width, height, args) => {
     platform: getPlatform$1()
   };
 };
-const loadContent$f = async state => {
+const loadContent$g = async state => {
   const {
     uri,
     args,
@@ -25061,28 +24967,28 @@ const wrapQuickPickCommand = key => {
   return fn;
 };
 
-const Commands$d = {};
-const getCommands$8 = async () => {
+const Commands$e = {};
+const getCommands$9 = async () => {
   const commands = await invoke$C('QuickPick.getCommandIds');
   for (const command of commands) {
-    Commands$d[command] = wrapQuickPickCommand(command);
+    Commands$e[command] = wrapQuickPickCommand(command);
   }
-  return Commands$d;
+  return Commands$e;
 };
 const saveState$5 = state => {
   return {};
 };
 
-const Css$f = [];
+const Css$g = [];
 const Variables$3 = ['QuickPickBackground', 'ListForeground', 'ListHoverBackground', 'ListHoverForeground', 'ListActiveSelectionBackground'];
 
 const getKeyBindings$6 = () => {
   return invoke$C('QuickPick.getKeyBindings');
 };
 
-const hasFunctionalRender$e = true;
-const hasFunctionalRootRender$c = true;
-const hasFunctionalEvents$9 = true;
+const hasFunctionalRender$f = true;
+const hasFunctionalRootRender$d = true;
+const hasFunctionalEvents$a = true;
 const renderItems$6 = {
   isEqual(oldState, newState) {
     return false;
@@ -25090,8 +24996,8 @@ const renderItems$6 = {
   apply: apply,
   multiple: true
 };
-const render$e = [renderItems$6];
-const renderEventListeners$7 = async () => {
+const render$f = [renderItems$6];
+const renderEventListeners$8 = async () => {
   const listeners = await invoke$C('QuickPick.renderEventListeners');
   return listeners;
 };
@@ -25100,32 +25006,32 @@ const name$d = 'QuickPick';
 
 const ViewletQuickPick_ipc = {
   __proto__: null,
-  Commands: Commands$d,
-  Css: Css$f,
+  Commands: Commands$e,
+  Css: Css$g,
   Variables: Variables$3,
-  create: create$f,
+  create: create$g,
   dispose: dispose$c,
-  getCommands: getCommands$8,
+  getCommands: getCommands$9,
   getKeyBindings: getKeyBindings$6,
-  hasFunctionalEvents: hasFunctionalEvents$9,
-  hasFunctionalRender: hasFunctionalRender$e,
-  hasFunctionalRootRender: hasFunctionalRootRender$c,
-  loadContent: loadContent$f,
+  hasFunctionalEvents: hasFunctionalEvents$a,
+  hasFunctionalRender: hasFunctionalRender$f,
+  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  loadContent: loadContent$g,
   name: name$d,
-  render: render$e,
-  renderEventListeners: renderEventListeners$7,
+  render: render$f,
+  renderEventListeners: renderEventListeners$8,
   renderItems: renderItems$6,
   saveState: saveState$5
 };
 
-const create$e = create$q;
+const create$f = create$r;
 const saveState$4 = saveState$b;
 
 // 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$e = async (state, savedState) => {
+const loadContent$f = async (state, savedState) => {
   // @ts-ignore
-  return loadContent$q(state, savedState);
+  return loadContent$r(state, savedState);
 };
 
 // TODO side effect is not good here, find a way to call ViewletLocations
@@ -25179,13 +25085,13 @@ const getActions$1 = () => {
 
 const wrapReferencesCommand = key => {
   const fn = async (state, ...args) => {
-    await invoke$a(`References.${key}`, state.uid, ...args);
-    const diffResult = await invoke$a('References.diff2', state.uid);
+    await invoke$b(`References.${key}`, state.uid, ...args);
+    const diffResult = await invoke$b('References.diff2', state.uid);
     if (diffResult.length === 0) {
       return state;
     }
-    const commands = await invoke$a('References.render2', state.uid, diffResult);
-    const actionsDom = await invoke$a('References.renderActions', state.uid);
+    const commands = await invoke$b('References.render2', state.uid, diffResult);
+    const actionsDom = await invoke$b('References.renderActions', state.uid);
     if (commands.length === 0) {
       return state;
     }
@@ -25200,17 +25106,17 @@ const wrapReferencesCommand = key => {
   return fn;
 };
 
-const Commands$c = {};
-const getCommands$7 = async () => {
-  const commands = await invoke$a('References.getCommandIds');
+const Commands$d = {};
+const getCommands$8 = async () => {
+  const commands = await invoke$b('References.getCommandIds');
   for (const command of commands) {
-    Commands$c[command] = wrapReferencesCommand(command);
+    Commands$d[command] = wrapReferencesCommand(command);
   }
-  Commands$c['hotReload'] = hotReload$b;
-  return Commands$c;
+  Commands$d['hotReload'] = hotReload$b;
+  return Commands$d;
 };
 
-const Css$e = ["/css/parts/ViewletReferences.css"];
+const Css$f = ["/css/parts/ViewletReferences.css"];
 
 /**
  * @enum {string}
@@ -25226,22 +25132,22 @@ const name$c = 'References';
 
 const ViewletReferences_ipc = {
   __proto__: null,
-  Commands: Commands$c,
-  Css: Css$e,
+  Commands: Commands$d,
+  Css: Css$f,
   contentLoaded: contentLoaded$1,
-  create: create$e,
+  create: create$f,
   dispose: dispose$b,
   getActions: getActions$1,
-  getCommands: getCommands$7,
+  getCommands: getCommands$8,
   getDisplayName,
-  hasFunctionalEvents: hasFunctionalEvents$h,
-  hasFunctionalRender: hasFunctionalRender$m,
-  hasFunctionalRootRender: hasFunctionalRootRender$k,
-  loadContent: loadContent$e,
+  hasFunctionalEvents: hasFunctionalEvents$i,
+  hasFunctionalRender: hasFunctionalRender$n,
+  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  loadContent: loadContent$f,
   name: name$c,
-  render: render$m,
+  render: render$n,
   renderActions: renderActions$4,
-  renderEventListeners: renderEventListeners$f,
+  renderEventListeners: renderEventListeners$g,
   saveState: saveState$4
 };
 
@@ -25254,7 +25160,7 @@ const None$1 = 0;
 
 const None = 'none';
 
-const create$d = (id, uri, x, y, width, height, args, parentUid) => {
+const create$e = (id, uri, x, y, width, height, args, parentUid) => {
   return {
     id,
     parentUid,
@@ -25282,7 +25188,7 @@ const create$d = (id, uri, x, y, width, height, args, parentUid) => {
     exceptionBreakPoints: None$1
   };
 };
-const loadContent$d = async (state, savedState) => {
+const loadContent$e = async (state, savedState) => {
   const isTest$1 = isTest();
   await invoke$y('RunAndDebug.create', state.uid, state.uri, state.x, state.y, state.width, state.height);
   await invoke$y('RunAndDebug.loadContent', state.uid, isTest$1, savedState);
@@ -25401,17 +25307,17 @@ const wrapRunAndDebugCommand = key => {
   return fn;
 };
 
-const Commands$b = {};
-const getCommands$6 = async () => {
+const Commands$c = {};
+const getCommands$7 = async () => {
   const commands = await invoke$y('RunAndDebug.getCommandIds');
   for (const command of commands) {
-    Commands$b[command] = wrapRunAndDebugCommand(command);
+    Commands$c[command] = wrapRunAndDebugCommand(command);
   }
-  Commands$b['hotReload'] = hotReload$5;
-  return Commands$b;
+  Commands$c['hotReload'] = hotReload$5;
+  return Commands$c;
 };
 
-const Css$d = ["/css/parts/DebugButtons.css", "/css/parts/DebugValue.css", "/css/parts/ViewletRunAndDebug.css"];
+const Css$e = ["/css/parts/DebugButtons.css", "/css/parts/DebugValue.css", "/css/parts/ViewletRunAndDebug.css"];
 const Variables$2 = ['TitleBarForeground', 'DebugSectionHeaderBackground', 'SideBarBackground'];
 
 const Events$2 = {};
@@ -25438,9 +25344,9 @@ const getMenus$5 = async () => {
   }
 };
 
-const hasFunctionalRender$d = true;
-const hasFunctionalRootRender$b = true;
-const hasFunctionalEvents$8 = true;
+const hasFunctionalRender$e = true;
+const hasFunctionalRootRender$c = true;
+const hasFunctionalEvents$9 = true;
 const renderItems$5 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
@@ -25448,8 +25354,8 @@ const renderItems$5 = {
   apply: apply,
   multiple: true
 };
-const render$d = [renderItems$5];
-const renderEventListeners$6 = async () => {
+const render$e = [renderItems$5];
+const renderEventListeners$7 = async () => {
   const listeners = await invoke$y('RunAndDebug.renderEventListeners');
   return listeners;
 };
@@ -25468,33 +25374,130 @@ const name$b = 'Run And Debug';
 
 const ViewletRunAndDebug_ipc = {
   __proto__: null,
-  Commands: Commands$b,
-  Css: Css$d,
+  Commands: Commands$c,
+  Css: Css$e,
   Events: Events$2,
   Variables: Variables$2,
   contentLoaded,
-  create: create$d,
+  create: create$e,
   dispose: dispose$a,
-  getCommands: getCommands$6,
+  getCommands: getCommands$7,
   getKeyBindings: getKeyBindings$5,
   getMenus: getMenus$5,
   handleDebugInput,
   handleEvaluate,
-  hasFunctionalEvents: hasFunctionalEvents$8,
-  hasFunctionalRender: hasFunctionalRender$d,
+  hasFunctionalEvents: hasFunctionalEvents$9,
+  hasFunctionalRender: hasFunctionalRender$e,
   hasFunctionalResize: hasFunctionalResize$9,
-  hasFunctionalRootRender: hasFunctionalRootRender$b,
+  hasFunctionalRootRender: hasFunctionalRootRender$c,
   hotReload: hotReload$5,
-  loadContent: loadContent$d,
+  loadContent: loadContent$e,
   menus: menus$6,
   name: name$b,
-  render: render$d,
+  render: render$e,
   renderActions: renderActions$3,
-  renderEventListeners: renderEventListeners$6,
+  renderEventListeners: renderEventListeners$7,
   resize: resize$b,
   saveState: saveState$3
 };
 
+const runningExtensionsViewWorkerUrl = `${assetDir}/packages/running-extensions-view/dist/runningExtensionsViewMain.js`;
+
+const launchRunningExtensionsViewWorker = async () => {
+  const ipc = await create$19({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name: 'Running Extensions View Worker',
+    url: getConfiguredWorkerUrl$1('develop.runningExtensionsViewPath', runningExtensionsViewWorkerUrl)
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$4} = getOrCreateWorker(launchRunningExtensionsViewWorker);
+
+const create$d = (uid, uri, x, y, width, height) => {
+  return {
+    commands: [],
+    height,
+    uid,
+    uri,
+    width,
+    x,
+    y
+  };
+};
+const loadContent$d = async state => {
+  const {
+    height,
+    uid,
+    uri,
+    width,
+    x,
+    y
+  } = state;
+  await invoke$4('RunningExtensions.create', uid, uri, x, y, width, height, getPlatform$1(), assetDir);
+  await invoke$4('RunningExtensions.loadContent', uid);
+  const diffResult = await invoke$4('RunningExtensions.diff2', uid);
+  const commands = await invoke$4('RunningExtensions.render2', uid, diffResult);
+  return {
+    ...state,
+    commands
+  };
+};
+
+const wrapRunningExtensionsCommand = key => {
+  return async (state, ...args) => {
+    await invoke$4(`RunningExtensions.${key}`, state.uid, ...args);
+    const diffResult = await invoke$4('RunningExtensions.diff2', state.uid);
+    const commands = await invoke$4('RunningExtensions.render2', state.uid, diffResult);
+    return {
+      ...state,
+      commands
+    };
+  };
+};
+
+const Commands$b = {};
+const getCommands$6 = async () => {
+  const commands = await invoke$4('RunningExtensions.getCommandIds');
+  for (const command of commands) {
+    Commands$b[command] = wrapRunningExtensionsCommand(command);
+  }
+  return Commands$b;
+};
+
+const Css$d = ["/css/parts/ViewletRunningExtensions.css"];
+
+const hasFunctionalEvents$8 = true;
+const hasFunctionalRender$d = true;
+const hasFunctionalRootRender$b = true;
+const renderDom$4 = {
+  apply: apply,
+  isEqual(oldState, newState) {
+    return newState.commands.length === 0;
+  },
+  multiple: true
+};
+const render$d = [renderDom$4];
+const renderEventListeners$6 = async () => {
+  return invoke$4('RunningExtensions.renderEventListeners');
+};
+
+const ViewletRunningExtensions_ipc = {
+  __proto__: null,
+  Commands: Commands$b,
+  Css: Css$d,
+  create: create$d,
+  getCommands: getCommands$6,
+  hasFunctionalEvents: hasFunctionalEvents$8,
+  hasFunctionalRender: hasFunctionalRender$d,
+  hasFunctionalRootRender: hasFunctionalRootRender$b,
+  loadContent: loadContent$d,
+  render: render$d,
+  renderEventListeners: renderEventListeners$6
+};
+
 const getSources = async options => {
   const sources = await invoke$F('DesktopCapturer.getSources', options);
   return sources;