@lvce-editor/static-server 0.71.5 → 0.71.6

package/static/{08d6cdd → 6bc57fb}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -81,7 +81,7 @@ const get$j = id => {
 const has$2 = id => {
   return id in state$E.pending;
 };
-const set$j = (id, value) => {
+const set$i = (id, value) => {
   state$E.pending[id] = value;
 };
 
@@ -108,7 +108,7 @@ const getAssetDir$1 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/08d6cdd';
+    return '/6bc57fb';
   }
 };
 const assetDir = getAssetDir$1();
@@ -843,7 +843,7 @@ const actuallyLoadCssStyleSheet = async css => {
 };
 const loadCssStyleSheet = id => {
   if (!has$2(id)) {
-    set$j(id, actuallyLoadCssStyleSheet(id));
+    set$i(id, actuallyLoadCssStyleSheet(id));
   }
   return get$j(id);
 };
@@ -859,7 +859,7 @@ const actuallyAddDynamicCss = async (id, getCss, preferences) => {
 };
 const addDynamicCss = (id, getCss, preferences) => {
   if (!has$2(id)) {
-    set$j(id, actuallyAddDynamicCss(id, getCss, preferences));
+    set$i(id, actuallyAddDynamicCss(id, getCss, preferences));
   }
   return get$j(id);
 };
@@ -1301,7 +1301,7 @@ const setLoad = load => {
 // @ts-nocheck
 const Two = '2.0';
 const callbacks = Object.create(null);
-const set$i = (id, fn) => {
+const set$h = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$h = id => {
@@ -1320,7 +1320,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$i(id, resolve);
+  set$h(id, resolve);
   return {
     id,
     promise
@@ -1662,7 +1662,7 @@ const get$g = key => {
 const getAll$3 = () => {
   return state$B;
 };
-const set$h = (key, value) => {
+const set$g = (key, value) => {
   state$B[key] = value;
 };
 
@@ -1939,7 +1939,7 @@ const exists$3 = async uri => {
   const fileSystem = await getFileSystem(protocol);
   return fileSystem.exists(path);
 };
-const canBeRestored$6 = async uri => {
+const canBeRestored$5 = async uri => {
   const protocol = getProtocol(uri);
   if (protocol === 'storage-overview') {
     return true;
@@ -2107,8 +2107,8 @@ const getMany = keys => {
 const getAll$2 = () => {
   return getAll$3();
 };
-const set$g = async (key, value) => {
-  set$h(key, value);
+const set$f = async (key, value) => {
+  set$g(key, value);
   if (getPlatform$1() === Web$1) {
     const preferences = {
       ...getAll$3(),
@@ -2253,7 +2253,7 @@ const setColorTheme = async colorThemeId => {
     return error;
   }
   // TODO should preferences throw errors or should it call handleError directly?
-  await set$g('workbench.colorTheme', colorThemeId);
+  await set$f('workbench.colorTheme', colorThemeId);
   return undefined;
 };
 const watch$1 = async id => {
@@ -2306,7 +2306,7 @@ const state$v = {
 const get$d = () => {
   return state$v.ipc;
 };
-const set$f = ipc => {
+const set$e = ipc => {
   state$v.ipc = ipc;
 };
 
@@ -2345,7 +2345,7 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
 const state$u = {
   id: 0
 };
-const set$e = value => {
+const set$d = value => {
   state$u.id = value;
 };
 const get$c = () => {
@@ -2368,13 +2368,13 @@ const reload$3 = forward$2('ElectronWindow.reload');
 const minimize$1 = forward$2('ElectronWindow.minimize');
 const unmaximize$1 = forward$2('ElectronWindow.unmaximize');
 const maximize$1 = forward$2('ElectronWindow.maximize');
-const close$4 = forward$2('ElectronWindow.close');
+const close$3 = forward$2('ElectronWindow.close');
 const openNew$1 = forward$2('ElectronWindow.openNew');
 const toggleDevtools = forward$2('ElectronWindow.toggleDevtools');
 const zoomIn$1 = forward$2('ElectronWindow.zoomIn');
 const zoomOut$1 = forward$2('ElectronWindow.zoomOut');
 const zoomReset$1 = forward$2('ElectronWindow.zoomReset');
-const focus$6 = forward$2('ElectronWindow.focus');
+const focus$5 = forward$2('ElectronWindow.focus');
 
 const reloadElectron = () => {
   return reload$3();
@@ -2523,7 +2523,7 @@ const launchTestWorker = async () => {
     name: 'Test Worker'
   });
   handleIpc(ipc);
-  set$f(ipc);
+  set$e(ipc);
   return ipc;
 };
 
@@ -2590,7 +2590,7 @@ const contexts = Object.create(null);
 const get$b = key => {
   return contexts[key];
 };
-const set$d = (key, value) => {
+const set$c = (key, value) => {
   contexts[key] = value;
 };
 const remove$9 = key => {
@@ -2604,7 +2604,7 @@ const state$t = {
 const get$a = () => {
   return state$t.currentFocus;
 };
-const set$c = value => {
+const set$b = value => {
   state$t.currentFocus = value;
 };
 
@@ -2704,10 +2704,10 @@ const setFocus = (focusKey, additionalFocusKey) => {
   if (get$a()) {
     remove$9(get$a());
   }
-  set$c(focusKey);
-  set$d(get$a(), true);
+  set$b(focusKey);
+  set$c(get$a(), true);
   if (additionalFocusKey) {
-    set$d(additionalFocusKey, true);
+    set$c(additionalFocusKey, true);
   }
   update();
 };
@@ -2716,7 +2716,7 @@ const setFocus = (focusKey, additionalFocusKey) => {
  * @param {number} key
  */
 const setAdditionalFocus = key => {
-  set$d(key, true);
+  set$c(key, true);
   update();
 };
 
@@ -2744,7 +2744,7 @@ const hydrate$7 = async () => {
   // maybe in env file / env service
   const browser = getBrowser();
   const key = getBrowserContextString(browser);
-  set$d(key, true);
+  set$c(key, true);
   update();
 };
 
@@ -2752,7 +2752,7 @@ const dispatch = key => (...args) => {
   emitEvent(key, ...args);
 };
 const handleDidNavigate$1 = dispatch('browser-view-did-navigate');
-const handleTitleUpdated$2 = dispatch('browser-view-title-updated');
+const handleTitleUpdated$1 = dispatch('browser-view-title-updated');
 const handleWillNavigate$1 = dispatch('browser-view-will-navigate');
 const isOpen = () => {
   return false;
@@ -2917,7 +2917,7 @@ const serializeInstances = async instances => {
 
 const state$q = {
   instances: Object.create(null)};
-const set$b = (key, value) => {
+const set$a = (key, value) => {
   // TODO separate factories from state
   object(value);
   object(value.factory);
@@ -3078,7 +3078,7 @@ const getHost = () => {
   return location.host;
 };
 
-const set$a = title => {
+const set$9 = title => {
   return invoke$y('WindowTitle.set', title);
 };
 
@@ -3115,7 +3115,7 @@ const getPath = () => {
 const getUri$1 = () => {
   return state$p.workspaceUri;
 };
-const close$3 = () => {
+const close$2 = () => {
   return setPath('');
 };
 const getTitle$1 = workspacePath => {
@@ -3136,7 +3136,7 @@ const getPathName = workspacePath => {
 };
 const onWorkspaceChange = async () => {
   const title = getTitle$1(state$p.workspacePath);
-  await set$a(title);
+  await set$9(title);
   if (getPlatform$1() === Web$1 || getPlatform$1() === Remote) {
     const pathName = getPathName(state$p.workspacePath);
     await setPathName(pathName);
@@ -3157,7 +3157,7 @@ const hydrate$5 = async ({
   if (state$p.homeDir !== resolvedRoot.homeDir) {
     state$p.homeDir = resolvedRoot.homeDir;
   }
-  if (!canBeRestored$6(resolvedRoot.path)) {
+  if (!canBeRestored$5(resolvedRoot.path)) {
     return;
   }
   // TODO how to check that path from renderer process is valid?
@@ -3605,7 +3605,7 @@ const KeyBindings = 'KeyBindings';
 const Layout = 'Layout';
 const List$1 = 'List';
 const Locations = 'Locations';
-const Main$3 = 'Main';
+const Main$2 = 'Main';
 const MainTabs = 'MainTabs';
 const None$a = '';
 const Noop = 'Noop';
@@ -3675,7 +3675,7 @@ const ViewletModuleId = {
   Layout,
   List: List$1,
   Locations,
-  Main: Main$3,
+  Main: Main$2,
   MainTabs,
   MarkDownPreview,
   None: None$a,
@@ -4195,7 +4195,7 @@ const load$5 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     // TODO race condition: viewlet state may have been updated again in the mean time
     state = ViewletState.RendererProcessViewletLoaded;
-    set$b(viewletUid, {
+    set$a(viewletUid, {
       state: newState,
       renderedState: viewletState,
       factory: module,
@@ -4390,10 +4390,10 @@ const closeWidgetElectronQuickPick = async () => {
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
-  await focus$6();
+  await focus$5();
 };
 
-const focus$5 = async id => {
+const focus$4 = async id => {
   const instance = getInstance(id);
   if (!instance) {
     return;
@@ -5352,15 +5352,6 @@ const state$i = {
   listenerMap: Object.create(null),
   phase: Zero
 };
-const once = (event, listener) => {
-  if (state$i.phase >= event) {
-    listener();
-  } else {
-    // TODO could also statically allocate listenermap at start as array[13]
-    state$i.listenerMap[event] ||= [];
-    state$i.listenerMap[event].push(listener);
-  }
-};
 const mark$1 = event => {
   const listeners = state$i.listenerMap[event] || [];
   for (const listener of listeners) {
@@ -6009,7 +6000,7 @@ const map = {
   [InlineDiffEditor$1]: () => Promise.resolve().then(function () { return ViewletInlineDiffEditor_ipc; }),
   [KeyBindings]: () => Promise.resolve().then(function () { return ViewletKeyBindings_ipc; }),
   [Layout]: () => Promise.resolve().then(function () { return ViewletLayout_ipc; }),
-  [Main$3]: () => Promise.resolve().then(function () { return ViewletMain_ipc; }),
+  [Main$2]: () => Promise.resolve().then(function () { return ViewletMain_ipc; }),
   [MarkDownPreview]: () => Promise.resolve().then(function () { return ViewletMarkDownPreview_ipc; }),
   [Noop]: () => Promise.resolve().then(function () { return ViewletNoop_ipc; }),
   [Output]: () => Promise.resolve().then(function () { return ViewletOutput_ipc; }),
@@ -6858,7 +6849,7 @@ const getPort = async ipcId => {
     ipcId
   });
   // TODO avoid side effect?
-  set$e(webContentsId);
+  set$d(webContentsId);
   return port2;
 };
 const create$X = async options => {
@@ -7406,7 +7397,7 @@ const get$7 = colorThemeId => {
   const cacheKey = getCacheKey$1(colorThemeId);
   return getText$1(cacheKey);
 };
-const set$9 = (colorThemeId, data) => {
+const set$8 = (colorThemeId, data) => {
   const cacheKey = getCacheKey$1(colorThemeId);
   return setText(cacheKey, data);
 };
@@ -7414,12 +7405,12 @@ const set$9 = (colorThemeId, data) => {
 const GetColorThemeCssCachedLocalStorage = {
   __proto__: null,
   get: get$7,
-  set: set$9
+  set: set$8
 };
 
 // TODO high memory usage in idb because of transactionDoneMap
 
-const set$8 = async (key, value) => {
+const set$7 = async (key, value) => {
   await invoke$t('IndexedDb.set', key, value);
 };
 const get$6 = async key => {
@@ -7433,28 +7424,28 @@ const get$5 = colorThemeId => {
   const cacheKey = getCacheKey(colorThemeId);
   return get$6(cacheKey);
 };
-const set$7 = (colorThemeId, data) => {
+const set$6 = (colorThemeId, data) => {
   const cacheKey = getCacheKey(colorThemeId);
-  return set$8(cacheKey, data);
+  return set$7(cacheKey, data);
 };
 
 const GetColorThemeCssCachedIndexedDb = {
   __proto__: null,
   get: get$5,
-  set: set$7
+  set: set$6
 };
 
 const get$4 = colorThemeId => {
   return '';
 };
-const set$6 = (colorThemeId, data) => {
+const set$5 = (colorThemeId, data) => {
   //  noop
 };
 
 const GetColorThemeCssCachedNoop = {
   __proto__: null,
   get: get$4,
-  set: set$6
+  set: set$5
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -7877,11 +7868,11 @@ const mkdir$6 = async path => {
 const getPathSeparator$7 = () => {
   return Slash;
 };
-const canBeRestored$5 = true;
+const canBeRestored$4 = true;
 
 const FileSystemApp = {
   __proto__: null,
-  canBeRestored: canBeRestored$5,
+  canBeRestored: canBeRestored$4,
   getPathSeparator: getPathSeparator$7,
   mkdir: mkdir$6,
   name: name$2j,
@@ -8277,11 +8268,11 @@ const onDidSave = listener => {
 const getPathSeparator$4 = () => {
   return Slash;
 };
-const canBeRestored$4 = true;
+const canBeRestored$3 = true;
 
 const FileSystemWeb = {
   __proto__: null,
-  canBeRestored: canBeRestored$4,
+  canBeRestored: canBeRestored$3,
   createFile,
   createFolder,
   getPathSeparator: getPathSeparator$4,
@@ -8319,7 +8310,7 @@ const {
 
 // TODO move all of this to an extension
 
-const canBeRestored$3 = true;
+const canBeRestored$2 = true;
 const name$2f = 'Fetch';
 const state$d = {
   files: Object.create(null)
@@ -8374,7 +8365,7 @@ const getBlob$4 = async (uri, type) => {
 
 const FileSystemFetch = {
   __proto__: null,
-  canBeRestored: canBeRestored$3,
+  canBeRestored: canBeRestored$2,
   chmod: chmod$2,
   exists: exists$1,
   getBlob: getBlob$4,
@@ -8479,11 +8470,11 @@ const chmod$1 = (path, permissions) => {
   path = toUri(path);
   return invoke$q('FileSystem.chmod', /* path */path, /* permissions */permissions);
 };
-const canBeRestored$2 = true;
+const canBeRestored$1 = true;
 
 const FileSystemDisk = {
   __proto__: null,
-  canBeRestored: canBeRestored$2,
+  canBeRestored: canBeRestored$1,
   chmod: chmod$1,
   copy: copy$1,
   ensureFile,
@@ -8827,11 +8818,11 @@ const getBlob$2 = async (uri, type) => {
   // TODO convert handle to blob mime type?
   return file;
 };
-const canBeRestored$1 = true;
+const canBeRestored = true;
 
 const FileSystemHtml = {
   __proto__: null,
-  canBeRestored: canBeRestored$1,
+  canBeRestored,
   getBlob: getBlob$2,
   getBlobSrc,
   getChildHandles,
@@ -9168,13 +9159,13 @@ const get$2 = () => {
 const has$1 = () => {
   return id$3 in cache;
 };
-const set$5 = value => {
+const set$4 = value => {
   cache[id$3] = value;
 };
 
 const getExtensions = () => {
   if (!has$1()) {
-    set$5(getExtensions$1());
+    set$4(getExtensions$1());
   }
   return get$2();
 };
@@ -9497,7 +9488,7 @@ const unmaximize = () => {
       throw new Error('not implemented');
   }
 };
-const close$2 = () => {
+const close$1 = () => {
   switch (getPlatform$1()) {
     case Electron$1:
       return execute$3('ElectronWindow.close');
@@ -9548,7 +9539,7 @@ const zoomReset = () => {
 
 const name$1_ = 'Chrome';
 const Commands$21 = {
-  close: close$2,
+  close: close$1,
   exit: exit$1,
   maximize: maximize,
   minimize: minimize,
@@ -9727,15 +9718,15 @@ const i18nString = (key, placeholders = emptyObject) => {
 /**
  * @enum {string}
  */
-const UiStrings$9 = {
+const UiStrings$8 = {
   Cancel: 'Cancel',
   Ok: 'Ok'
 };
 const cancel = () => {
-  return i18nString(UiStrings$9.Cancel);
+  return i18nString(UiStrings$8.Cancel);
 };
 const ok = () => {
-  return i18nString(UiStrings$9.Ok);
+  return i18nString(UiStrings$8.Ok);
 };
 
 let _mockId$1 = 0;
@@ -9939,8 +9930,8 @@ const attachDebugger = async pid => {
   await invoke$v('AttachDebugger.attachDebugger', pid);
 };
 
-const version = '0.71.5';
-const commit$1 = '08d6cdd';
+const version = '0.71.6';
+const commit$1 = '6bc57fb';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$v('Process.getPid');
@@ -10520,7 +10511,7 @@ const openFileElectron = async () => {
   const [file] = await showOpenDialog('Open File', ['openFile', 'dontAddToRecent', 'showHiddenFiles']);
   await openUri$1(file);
 };
-const openFile$1 = () => {
+const openFile = () => {
   switch (getPlatform$1()) {
     case Web$1:
       return openFileWeb();
@@ -10578,7 +10569,7 @@ const Commands$1U = {
   // @ts-ignore
   close: undefined,
   handleClick: handleClick$2,
-  openFile: openFile$1,
+  openFile: openFile,
   openFolder: openFolder$3,
   showMessage: showMessage
 };
@@ -10713,7 +10704,7 @@ const EditorError_ipc = {
 const name$1O = 'ElectronBrowserView';
 const Commands$1Q = {
   handleDidNavigate: handleDidNavigate$1,
-  handleTitleUpdated: handleTitleUpdated$2,
+  handleTitleUpdated: handleTitleUpdated$1,
   handleWillNavigate: handleWillNavigate$1
 };
 
@@ -10753,7 +10744,7 @@ const ElectronContextMenu_ipc = {
 
 const name$1L = 'ElectronWindow';
 const Commands$1N = {
-  close: close$4,
+  close: close$3,
   maximize: maximize$1,
   minimize: minimize$1,
   openNew: openNew$1,
@@ -10806,7 +10797,7 @@ const getCommandsFromExtension = extension => {
 const getCommandsFromExtensions = extensions => {
   return extensions.flatMap(getCommandsFromExtension);
 };
-const getCommands$h = async (assetDir, platform) => {
+const getCommands$i = async (assetDir, platform) => {
   const extensions = await getExtensions$1(assetDir, platform);
   const commands = getCommandsFromExtensions(extensions);
   return commands;
@@ -10871,7 +10862,7 @@ const name$1I = 'ExtensionHost';
 // prettier-ignore
 const Commands$1K = {
   loadWebExtension: loadWebExtension,
-  getCommands: getCommands$h,
+  getCommands: getCommands$i,
   executeCommand: executeCommand,
   searchFileWithFetch: searchFileWithFetch,
   searchFileWithHtml: searchFileWithHtml,
@@ -11314,7 +11305,7 @@ const getModule = id => {
   }
   throw new Error(`menu entries for ${id} not found`);
 };
-const getMenuEntries$5 = async (id, ...args) => {
+const getMenuEntries$3 = async (id, ...args) => {
   try {
     const module = await getModule(id);
     // @ts-ignore
@@ -11381,16 +11372,16 @@ const handleMouseLeave = async () => {
 const focusIndex$3 = async (menu, index) => {
   await invoke$l('Menu.focusIndex', menu, index);
 };
-const focusFirst$2 = async () => {
+const focusFirst$1 = async () => {
   await invoke$l('Menu.focusFirst');
 };
-const focusLast$2 = async () => {
+const focusLast$1 = async () => {
   await invoke$l('Menu.focusLast');
 };
-const focusPrevious$2 = async () => {
+const focusPrevious$1 = async () => {
   await invoke$l('Menu.focusPrevious');
 };
-const focusNext$2 = async () => {
+const focusNext$1 = async () => {
   await invoke$l('Menu.focusNext');
 };
 
@@ -11402,18 +11393,18 @@ const focusNext$2 = async () => {
 
 const name$1v = 'Menu';
 const Commands$1w = {
-  focusFirst: focusFirst$2,
+  focusFirst: focusFirst$1,
   focusIndex: focusIndex$3,
-  focusLast: focusLast$2,
-  focusNext: focusNext$2,
-  focusPrevious: focusPrevious$2,
+  focusLast: focusLast$1,
+  focusNext: focusNext$1,
+  focusPrevious: focusPrevious$1,
   handleMouseEnter: handleMouseEnter,
   handleMouseLeave: handleMouseLeave,
   hide: hide$3,
   selectIndex: selectIndex$2,
   selectItem: selectItem,
   show: show$7,
-  getMenuEntries: getMenuEntries$5,
+  getMenuEntries: getMenuEntries$3,
   getMenuEntries2
 };
 
@@ -11995,7 +11986,7 @@ const Commands$1c = {
   2133: send,
   closeWidget: closeWidget,
   executeViewletCommand: executeViewletCommand,
-  focus: focus$5,
+  focus: focus$4,
   getAllStates: getAllStates,
   openWidget: openWidget,
   send: send,
@@ -12010,7 +12001,7 @@ const Viewlet_ipc = {
 
 const name$1a = 'Window';
 const Commands$1b = {
-  close: close$2,
+  close: close$1,
   exit: exit$1,
   maximize: maximize,
   minimize: minimize,
@@ -12029,7 +12020,7 @@ const Window_ipc = {
 
 const name$19 = 'Workspace';
 const Commands$1a = {
-  close: close$3,
+  close: close$2,
   getPath: getPath,
   getUri: getUri$1,
   hydrate: hydrate$5,
@@ -12045,7 +12036,7 @@ const Workspace_ipc = {
 
 const name$18 = 'WindowTitle';
 const Commands$19 = {
-  set: set$a
+  set: set$9
 };
 
 const WindowTitle_ipc = {
@@ -12196,7 +12187,7 @@ const ExtensionHostDialog_ipc = {
   name: name$14
 };
 
-const set$4 = async (url, contentSecurityPolicy) => {
+const set$3 = async (url, contentSecurityPolicy) => {
   string(url);
   string(contentSecurityPolicy);
   if (getPlatform$1() === Web$1) {
@@ -12205,13 +12196,13 @@ const set$4 = async (url, contentSecurityPolicy) => {
   await invoke$v('ContentSecurityPolicy.set', url, contentSecurityPolicy);
 };
 
-const set$3 = async (url, contentSecurityPolicy) => {
-  await set$4(url, contentSecurityPolicy);
+const set$2 = async (url, contentSecurityPolicy) => {
+  await set$3(url, contentSecurityPolicy);
 };
 
 const name$13 = 'ExtensionHostWorkerContentSecurityPolicy';
 const Commands$14 = {
-  set: set$3
+  set: set$2
 };
 
 const ExtensionHostWorkerContentSecurityPolicy_ipc = {
@@ -13238,7 +13229,7 @@ const wrapAboutCommand = key => {
 };
 
 const Commands$D = {};
-const getCommands$g = async () => {
+const getCommands$h = async () => {
   const commands = await invoke$o('About.getCommandIds');
   for (const command of commands) {
     if (command === 'showAbout' || command === 'showAboutElectron') {
@@ -13303,8 +13294,8 @@ const apply = (oldState, newState) => {
 };
 
 const hasFunctionalRender$B = true;
-const hasFunctionalRootRender$q = true;
-const hasFunctionalEvents$g = true;
+const hasFunctionalRootRender$r = true;
+const hasFunctionalEvents$h = true;
 const renderDialog$2 = {
   isEqual(oldState, newState) {
     return false;
@@ -13313,7 +13304,7 @@ const renderDialog$2 = {
   multiple: true
 };
 const render$E = [renderDialog$2];
-const renderEventListeners$g = async () => {
+const renderEventListeners$h = async () => {
   const listeners = await invoke$o('About.renderEventListeners');
   return listeners;
 };
@@ -13323,16 +13314,16 @@ const ViewletAbout_ipc = {
   Commands: Commands$D,
   Css: Css$D,
   create: create$N,
-  getCommands: getCommands$g,
+  getCommands: getCommands$h,
   getKeyBindings: getKeyBindings$l,
-  hasFunctionalEvents: hasFunctionalEvents$g,
+  hasFunctionalEvents: hasFunctionalEvents$h,
   hasFunctionalRender: hasFunctionalRender$B,
-  hasFunctionalRootRender: hasFunctionalRootRender$q,
+  hasFunctionalRootRender: hasFunctionalRootRender$r,
   loadContent: loadContent$I,
   name: name$C,
   render: render$E,
   renderDialog: renderDialog$2,
-  renderEventListeners: renderEventListeners$g
+  renderEventListeners: renderEventListeners$h
 };
 
 const activityBarWorkerUrl = `${assetDir}/packages/activity-bar-worker/dist/activityBarWorkerMain.js`;
@@ -13440,7 +13431,7 @@ const wrapActivityBarCommand = key => {
 };
 
 const Commands$C = {};
-const getCommands$f = async () => {
+const getCommands$g = async () => {
   const commands = await invoke$f('ActivityBar.getCommandIds');
   for (const command of commands) {
     Commands$C[command] = wrapActivityBarCommand(command);
@@ -13547,14 +13538,14 @@ const getMenus$b = async () => {
 /**
  * @enum {string}
  */
-const UiStrings$8 = {
+const UiStrings$7 = {
   AdditionalViews: 'Additional Views',
   ActivityBar: 'Activity Bar'};
 const additionalViews = () => {
-  return i18nString(UiStrings$8.AdditionalViews);
+  return i18nString(UiStrings$7.AdditionalViews);
 };
 const activityBar = () => {
-  return i18nString(UiStrings$8.ActivityBar);
+  return i18nString(UiStrings$7.ActivityBar);
 };
 
 const name$B = 'ActivityBar';
@@ -13579,17 +13570,17 @@ const getQuickPickMenuEntries$4 = () => {
 };
 
 const hasFunctionalRender$A = true;
-const hasFunctionalRootRender$p = true;
-const hasFunctionalEvents$f = true;
-const renderItems$a = {
+const hasFunctionalRootRender$q = true;
+const hasFunctionalEvents$g = true;
+const renderItems$b = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
   apply: apply,
   multiple: true
 };
-const render$D = [renderItems$a];
-const renderEventListeners$f = async () => {
+const render$D = [renderItems$b];
+const renderEventListeners$g = async () => {
   const listeners = await invoke$f('ActivityBar.renderEventListeners');
   return listeners;
 };
@@ -13644,32 +13635,32 @@ const ViewletActivityBar_ipc = {
   Events: Events$5,
   Variables: Variables$6,
   create: create$M,
-  getCommands: getCommands$f,
+  getCommands: getCommands$g,
   getDisplayName: getDisplayName$2,
   getKeyBindings: getKeyBindings$k,
   getMenus: getMenus$b,
   getQuickPickMenuEntries: getQuickPickMenuEntries$4,
-  hasFunctionalEvents: hasFunctionalEvents$f,
+  hasFunctionalEvents: hasFunctionalEvents$g,
   hasFunctionalRender: hasFunctionalRender$A,
   hasFunctionalResize: hasFunctionalResize$h,
-  hasFunctionalRootRender: hasFunctionalRootRender$p,
+  hasFunctionalRootRender: hasFunctionalRootRender$q,
   hotReload: hotReload$e,
   loadContent: loadContent$H,
   menus: menus$f,
   name: name$B,
   render: render$D,
-  renderEventListeners: renderEventListeners$f,
+  renderEventListeners: renderEventListeners$g,
   resize: resize$j
 };
 
 /**
  * @enum {string}
  */
-const UiStrings$7 = {
+const UiStrings$6 = {
   FailedToLoadAudio: 'Failed to load audio: {PH1}'
 };
 const getImprovedErrorMessage = message => {
-  return i18nString(UiStrings$7.FailedToLoadAudio, {
+  return i18nString(UiStrings$6.FailedToLoadAudio, {
     PH1: message
   });
 };
@@ -13732,8 +13723,6 @@ const EditorRow = 'EditorRow';
 const EditorRowDeletion = 'EditorRow Deletion';
 const EditorRowInsertion = 'EditorRow Insertion';
 const EditorRows = 'EditorRows';
-const EditorTabCloseButton = 'EditorTabCloseButton';
-const FileIcon = 'FileIcon';
 const Filter$2 = 'Filter';
 const FilterBadge = 'FilterBadge';
 const IconButton = 'IconButton';
@@ -13742,8 +13731,6 @@ const InlineDiffEditorContent = 'InlineDiffEditorContent';
 const InputBox = 'InputBox';
 const Insertion$1 = 'Insertion';
 const Label = 'Label';
-const MainTab = 'MainTab';
-const MainTabSelected = 'MainTabSelected';
 const MaskIcon = 'MaskIcon';
 const MediaContent = 'MediaContent';
 const MediaElement = 'MediaElement';
@@ -13758,7 +13745,6 @@ const ScrollBarLarge = 'ScrollBarLarge';
 const ScrollBarThumb = 'ScrollBarThumb';
 const Select$2 = 'Select';
 const SimpleBrowserHeader = 'SimpleBrowserHeader';
-const TabLabel = 'TabLabel';
 const TerminalTab = 'TerminalTab';
 const TerminalTabIcon = 'TerminalTabIcon';
 const TerminalTabs = 'TerminalTabs';
@@ -13780,7 +13766,6 @@ const Th = 13;
 const THead = 14;
 const Tr = 15;
 const I = 16;
-const Img = 17;
 const Select$1 = 63;
 const Option = 64;
 
@@ -13851,7 +13836,7 @@ const getAudioVirtualDom = (src, errorMessage) => {
 };
 
 const hasFunctionalRender$z = true;
-const hasFunctionalRootRender$o = true;
+const hasFunctionalRootRender$p = true;
 const renderAudio = {
   isEqual(oldState, newState) {
     return oldState.src === newState.src && oldState.audioErrorMessage === newState.audioErrorMessage;
@@ -13873,7 +13858,7 @@ const ViewletAudio_ipc = {
   dispose: dispose$p,
   handleAudioError,
   hasFunctionalRender: hasFunctionalRender$z,
-  hasFunctionalRootRender: hasFunctionalRootRender$o,
+  hasFunctionalRootRender: hasFunctionalRootRender$p,
   loadContent: loadContent$G,
   name: name$A,
   render: render$C
@@ -14010,7 +13995,7 @@ const getKeyBindings$j = () => {
 };
 
 const hasFunctionalRender$x = true;
-const hasFunctionalRootRender$n = true;
+const hasFunctionalRootRender$o = true;
 const renderDialog$1 = {
   isEqual(oldState, newState) {
     return oldState.productName === newState.productName && oldState.lines === newState.lines;
@@ -14043,7 +14028,7 @@ const ViewletConfirm_ipc = {
   handleClickOk,
   handleFocusIn,
   hasFunctionalRender: hasFunctionalRender$x,
-  hasFunctionalRootRender: hasFunctionalRootRender$n,
+  hasFunctionalRootRender: hasFunctionalRootRender$o,
   loadContent: loadContent$D,
   name: name$y,
   render: render$A,
@@ -14353,10 +14338,10 @@ const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
 /**
  * @enum {string}
  */
-const UiStrings$6 = {
+const UiStrings$5 = {
   PressDesiredKeyCombinationThenPressEnter: 'Press Desired Key Combination, Then Press Enter'};
 const pressDesiredKeyCombinationThenPressEnter = () => {
-  return i18nString(UiStrings$6.PressDesiredKeyCombinationThenPressEnter);
+  return i18nString(UiStrings$5.PressDesiredKeyCombinationThenPressEnter);
 };
 
 const create$G = (id, uri, x, y, width, height) => {
@@ -14433,7 +14418,7 @@ const getDefineKeyBindingsVirtualDom = message => {
 };
 
 const hasFunctionalRender$v = true;
-const hasFunctionalRootRender$m = true;
+const hasFunctionalRootRender$n = true;
 const renderValue = {
   isEqual(oldState, newState) {
     return oldState.value === newState.value;
@@ -14469,7 +14454,7 @@ const ViewletDefineKeyBinding_ipc = {
   handleBlur: handleBlur$2,
   handleKeyDown: handleKeyDown$1,
   hasFunctionalRender: hasFunctionalRender$v,
-  hasFunctionalRootRender: hasFunctionalRootRender$m,
+  hasFunctionalRootRender: hasFunctionalRootRender$n,
   loadContent: loadContent$B,
   render: render$y
 };
@@ -14688,7 +14673,7 @@ const state$5 = {
 const has = languageId => {
   return languageId in state$5.tokenizers;
 };
-const set$2 = (languageId, tokenizer) => {
+const set$1 = (languageId, tokenizer) => {
   state$5.tokenizers[languageId] = tokenizer;
 };
 const get$1 = languageId => {
@@ -14709,7 +14694,7 @@ const isConnectedEditor = id => {
 };
 
 const tokenizers = Object.create(null);
-const set$1 = (id, value) => {
+const set = (id, value) => {
   tokenizers[id] = value;
 };
 const get = id => {
@@ -14726,7 +14711,7 @@ const handleTokenizeChange$1 = async () => {
       }
       const tokenizerId = create$$();
       const tokenizer = getTokenizer(state.languageId);
-      set$1(tokenizerId, tokenizer);
+      set(tokenizerId, tokenizer);
       const newState = {
         ...instance.state,
         tokenizerId,
@@ -14759,7 +14744,7 @@ const loadTokenizer = async languageId => {
       console.warn(`tokenizer.TokenMap should be an object in "${tokenizePath}"`);
       return;
     }
-    set$2(languageId, tokenizer);
+    set$1(languageId, tokenizer);
   } catch (error) {
     // TODO better error handling
     console.error(error);
@@ -14900,7 +14885,7 @@ const loadContent$z = async (state, savedState) => {
 const Commands$v = {};
 
 // prettier-ignore
-const LazyCommands$3 = {
+const LazyCommands$2 = {
   setDeltaY: () => Promise.resolve().then(function () { return VirtualListSetDeltaY; }),
   handleWheel: () => Promise.resolve().then(function () { return VirtualListHandleWheel; })
 };
@@ -15297,7 +15282,7 @@ const SetScrollBar = 'setScrollBar';
 const SetTitle = 'setTitle';
 
 const hasFunctionalRender$t = true;
-const hasFunctionalRootRender$l = true;
+const hasFunctionalRootRender$m = true;
 const renderChanges$1 = {
   isEqual(oldState, newState) {
     return oldState.changes === newState.changes && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY;
@@ -15331,11 +15316,11 @@ const ViewletDiffEditor_ipc = {
   __proto__: null,
   Commands: Commands$v,
   Css: Css$u,
-  LazyCommands: LazyCommands$3,
+  LazyCommands: LazyCommands$2,
   create: create$D,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$t,
-  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  hasFunctionalRootRender: hasFunctionalRootRender$m,
   loadContent: loadContent$z,
   name: name$v,
   render: render$w,
@@ -15467,14 +15452,13 @@ const getKeyBindings$h = () => {
 const Explorer = 4;
 const Tab = 13;
 const SimpleBrowser = 21;
-const Main$2 = 24;
 const E2eTests = 27;
 
 const Separator$1 = 1;
 const None$6 = 0;
 
 const id$2 = E2eTests;
-const getMenuEntries$4 = () => {
+const getMenuEntries$2 = () => {
   return [{
     id: 'openInNewTab',
     label: 'Open in New Tab',
@@ -15485,7 +15469,7 @@ const getMenuEntries$4 = () => {
 
 const MenuEntriesE2eTests = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$4,
+  getMenuEntries: getMenuEntries$2,
   id: id$2
 };
 
@@ -15515,7 +15499,7 @@ const getE2eTestVirtualDom = content => {
 };
 
 const hasFunctionalRender$s = true;
-const hasFunctionalRootRender$k = true;
+const hasFunctionalRootRender$l = true;
 const renderElements = {
   isEqual(oldState, newState) {
     return oldState.name === newState.name && oldState.content === newState.content;
@@ -15572,7 +15556,7 @@ const ViewletE2eTest_ipc = {
   handleSashCornerPointerUp,
   hasFunctionalRender: hasFunctionalRender$s,
   hasFunctionalResize: hasFunctionalResize$g,
-  hasFunctionalRootRender: hasFunctionalRootRender$k,
+  hasFunctionalRootRender: hasFunctionalRootRender$l,
   loadContent: loadContent$y,
   menus: menus$e,
   name: name$u,
@@ -15665,7 +15649,7 @@ const runAll = state => {
   console.log('run all');
   return state;
 };
-const handleContextMenu$2 = async (state, button, x, y) => {
+const handleContextMenu$1 = async (state, button, x, y) => {
   const index = getIndex(state.y, y);
   // @ts-ignore
   state.index = index;
@@ -15687,7 +15671,7 @@ const Commands$t = {
   handleClickAt: handleClickAt,
   handleLoad: handleLoad,
   runAll: runAll,
-  handleContextMenu: handleContextMenu$2,
+  handleContextMenu: handleContextMenu$1,
   openInNewTab: openInNewTab
 };
 
@@ -15767,7 +15751,7 @@ const getVisibleE2eTests = (tests, index) => {
 };
 
 const hasFunctionalRender$r = true;
-const hasFunctionalRootRender$j = true;
+const hasFunctionalRootRender$k = true;
 const renderTests = {
   isEqual(oldState, newState) {
     return oldState.tests === newState.tests && oldState.index === newState.index;
@@ -15824,10 +15808,10 @@ const ViewletE2eTests_ipc = {
   executeTest,
   getKeyBindings: getKeyBindings$g,
   handleClickAt,
-  handleContextMenu: handleContextMenu$2,
+  handleContextMenu: handleContextMenu$1,
   handleLoad,
   hasFunctionalRender: hasFunctionalRender$r,
-  hasFunctionalRootRender: hasFunctionalRootRender$j,
+  hasFunctionalRootRender: hasFunctionalRootRender$k,
   loadContent: loadContent$x,
   menus: menus$d,
   name: name$t,
@@ -16105,7 +16089,7 @@ const handleTokenizeChange = () => {
   const state = instance.state;
   const tokenizer = getTokenizer(state.languageId);
   const tokenizerId = create$$();
-  set$1(tokenizerId, tokenizer);
+  set(tokenizerId, tokenizer);
   const newState = {
     ...instance.state,
     tokenizerId
@@ -16186,7 +16170,7 @@ const loadContent$w = async (state, savedState, context) => {
   const languageId = context?.languageId || getLanguageId(state);
   const tokenizer = getTokenizer(languageId);
   const tokenizerId = create$$();
-  set$1(tokenizerId, tokenizer);
+  set(tokenizerId, tokenizer);
   let savedSelections = getSavedSelections(savedState);
   const savedDeltaY = getSavedDeltaY(savedState);
   state.languageId = languageId;
@@ -16284,7 +16268,7 @@ const updateDiagnostics = async state => {
   //   // ignore
   // }
 };
-const handleEditorChange$1 = async (editor, changes) => {
+const handleEditorChange = async (editor, changes) => {
   // await ExtensionHostTextDocument.handleEditorChange(editor, changes)
   // TODO check if semantic highlighting is enabled in settings
   await updateSemanticTokens(editor);
@@ -16326,7 +16310,7 @@ const dispose$l = state => {
 };
 const hasFunctionalRender$q = true;
 const render$s = render$t;
-const focus$4 = state => {
+const focus$3 = state => {
   return {
     ...state,
     focused: true
@@ -16376,7 +16360,7 @@ const Commands$s = {
     return state;
   }
 };
-const CommandsWithSideEffectsLazy$1 = {
+const CommandsWithSideEffectsLazy = {
   typeWithAutoClosing: () => {
     return {
       typeWithAutoClosing: wrapEditorCommand('typeWithAutoClosing')
@@ -16441,7 +16425,7 @@ const Events$4 = {
 const ViewletEditorText_ipc = {
   __proto__: null,
   Commands: Commands$s,
-  CommandsWithSideEffectsLazy: CommandsWithSideEffectsLazy$1,
+  CommandsWithSideEffectsLazy,
   Css: Css$v,
   Events: Events$4,
   contentLoaded: contentLoaded$6,
@@ -16449,12 +16433,12 @@ const ViewletEditorText_ipc = {
   create: create$x,
   customErrorRenderer,
   dispose: dispose$l,
-  focus: focus$4,
+  focus: focus$3,
   getDynamicCss,
   getKeyBindings: getKeyBindings$f,
   getMenus: getMenus$a,
   getQuickPickMenuEntries: getQuickPickMenuEntries$2,
-  handleEditorChange: handleEditorChange$1,
+  handleEditorChange,
   handleLanguagesChanged,
   handleTokenizeChange,
   hasFunctionalRender: hasFunctionalRender$q,
@@ -16753,7 +16737,7 @@ const wrapExplorerCommand = key => {
 };
 
 const Commands$q = {};
-const getCommands$e = async () => {
+const getCommands$f = async () => {
   const commands = await invoke$d('Explorer.getCommandIds');
   for (const command of commands) {
     Commands$q[command] = wrapExplorerCommand(command);
@@ -16770,14 +16754,14 @@ const getKeyBindings$e = () => {
 };
 
 const id$1 = Explorer;
-const getMenuEntries$3 = () => {
+const getMenuEntries$1 = () => {
   const explorerState = getState('Explorer');
   return invoke$d('Explorer.getMenuEntries2', explorerState.uid);
 };
 
 const MenuEntriesExplorer = {
   __proto__: null,
-  getMenuEntries: getMenuEntries$3,
+  getMenuEntries: getMenuEntries$1,
   id: id$1
 };
 
@@ -16786,15 +16770,15 @@ const menus$b = [MenuEntriesExplorer];
 /**
  * @enum {string}
  */
-const UiStrings$5 = {
+const UiStrings$4 = {
   Explorer: 'Explorer',
   NoFolderOpen: 'No Folder Open'
 };
 const explorer = () => {
-  return i18nString(UiStrings$5.Explorer);
+  return i18nString(UiStrings$4.Explorer);
 };
 const noFolderOpen = () => {
-  return i18nString(UiStrings$5.NoFolderOpen);
+  return i18nString(UiStrings$4.NoFolderOpen);
 };
 
 const name$p = 'Explorer';
@@ -16803,17 +16787,17 @@ const getDisplayName$1 = () => {
 };
 
 const hasFunctionalRender$p = true;
-const hasFunctionalRootRender$i = true;
-const hasFunctionalEvents$e = true;
-const renderItems$9 = {
+const hasFunctionalRootRender$j = true;
+const hasFunctionalEvents$f = true;
+const renderItems$a = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
   apply: apply,
   multiple: true
 };
-const render$p = [renderItems$9];
-const renderEventListeners$e = async () => {
+const render$p = [renderItems$a];
+const renderEventListeners$f = async () => {
   const listeners = await invoke$d('Explorer.renderEventListeners');
   return listeners;
 };
@@ -16863,21 +16847,21 @@ const ViewletExplorer_ipc = {
   Events: Events$3,
   create: create$t,
   dispose: dispose$j,
-  getCommands: getCommands$e,
+  getCommands: getCommands$f,
   getDisplayName: getDisplayName$1,
   getKeyBindings: getKeyBindings$e,
   getMouseActions,
-  hasFunctionalEvents: hasFunctionalEvents$e,
+  hasFunctionalEvents: hasFunctionalEvents$f,
   hasFunctionalRender: hasFunctionalRender$p,
   hasFunctionalResize: hasFunctionalResize$e,
-  hasFunctionalRootRender: hasFunctionalRootRender$i,
+  hasFunctionalRootRender: hasFunctionalRootRender$j,
   hotReload: hotReload$d,
   loadContent: loadContent$t,
   menus: menus$b,
   name: name$p,
   render: render$p,
   renderActions: renderActions$9,
-  renderEventListeners: renderEventListeners$e,
+  renderEventListeners: renderEventListeners$f,
   renderTitle: renderTitle$3,
   resize: resize$g,
   restoreState,
@@ -16977,7 +16961,7 @@ const wrapExtensionDetailCommand = key => {
 };
 
 const Commands$p = {};
-const getCommands$d = async () => {
+const getCommands$e = async () => {
   const commands = await invoke$c('ExtensionDetail.getCommandIds');
   for (const command of commands) {
     Commands$p[command] = wrapExtensionDetailCommand(command);
@@ -17019,8 +17003,8 @@ const getMenus$9 = async () => {
 const name$o = 'ExtensionDetail';
 
 const hasFunctionalRender$o = true;
-const hasFunctionalRootRender$h = true;
-const hasFunctionalEvents$d = true;
+const hasFunctionalRootRender$i = true;
+const hasFunctionalEvents$e = true;
 const renderDom$3 = {
   isEqual(oldState, newState) {
     return false;
@@ -17029,7 +17013,7 @@ const renderDom$3 = {
   multiple: true
 };
 const render$o = [renderDom$3];
-const renderEventListeners$d = async () => {
+const renderEventListeners$e = async () => {
   const listeners = await invoke$c('ExtensionDetail.renderEventListeners');
   return listeners;
 };
@@ -17039,19 +17023,19 @@ const ViewletExtensionDetail_ipc = {
   Commands: Commands$p,
   Css: Css$o,
   create: create$s,
-  getCommands: getCommands$d,
+  getCommands: getCommands$e,
   getKeyBindings: getKeyBindings$d,
   getMenus: getMenus$9,
-  hasFunctionalEvents: hasFunctionalEvents$d,
+  hasFunctionalEvents: hasFunctionalEvents$e,
   hasFunctionalRender: hasFunctionalRender$o,
   hasFunctionalResize: hasFunctionalResize$d,
-  hasFunctionalRootRender: hasFunctionalRootRender$h,
+  hasFunctionalRootRender: hasFunctionalRootRender$i,
   hotReload: hotReload$c,
   loadContent: loadContent$s,
   menus: menus$a,
   name: name$o,
   render: render$o,
-  renderEventListeners: renderEventListeners$d,
+  renderEventListeners: renderEventListeners$e,
   saveState: saveState$f
 };
 
@@ -17150,7 +17134,7 @@ const wrapExtensionSearchCommand = key => {
 };
 
 const Commands$o = {};
-const getCommands$c = async () => {
+const getCommands$d = async () => {
   const commands = await invoke$b('SearchExtensions.getCommandIds');
   for (const command of commands) {
     Commands$o[command] = wrapExtensionSearchCommand(command);
@@ -17188,17 +17172,17 @@ const getMenus$8 = async () => {
 const name$n = 'Extensions';
 
 const hasFunctionalRender$n = true;
-const hasFunctionalRootRender$g = true;
-const hasFunctionalEvents$c = true;
-const renderItems$8 = {
+const hasFunctionalRootRender$h = true;
+const hasFunctionalEvents$d = true;
+const renderItems$9 = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
   apply: apply,
   multiple: true
 };
-const render$n = [renderItems$8];
-const renderEventListeners$c = async () => {
+const render$n = [renderItems$9];
+const renderEventListeners$d = async () => {
   const listeners = await invoke$b('SearchExtensions.renderEventListeners');
   return listeners;
 };
@@ -17262,20 +17246,20 @@ const ViewletExtensions_ipc = {
   Css: Css$n,
   create: create$r,
   dispose: dispose$i,
-  getCommands: getCommands$c,
+  getCommands: getCommands$d,
   getKeyBindings: getKeyBindings$c,
   getMenus: getMenus$8,
-  hasFunctionalEvents: hasFunctionalEvents$c,
+  hasFunctionalEvents: hasFunctionalEvents$d,
   hasFunctionalRender: hasFunctionalRender$n,
   hasFunctionalResize: hasFunctionalResize$c,
-  hasFunctionalRootRender: hasFunctionalRootRender$g,
+  hasFunctionalRootRender: hasFunctionalRootRender$h,
   hotReload: hotReload$b,
   loadContent: loadContent$r,
   menus: menus$9,
   name: name$n,
   render: render$n,
   renderActions: renderActions$8,
-  renderEventListeners: renderEventListeners$c,
+  renderEventListeners: renderEventListeners$d,
   renderTitle: renderTitle$2,
   resize: resize$f,
   saveState: saveState$e
@@ -17362,7 +17346,7 @@ const wrapIframeInspectorCommand = key => {
 };
 
 const Commands$n = {};
-const getCommands$b = async () => {
+const getCommands$c = async () => {
   const commands = await invoke$a('IframeInspector.getCommandIds');
   for (const command of commands) {
     Commands$n[command] = wrapIframeInspectorCommand(command);
@@ -17380,8 +17364,8 @@ const getKeyBindings$b = () => {
 const name$m = 'IframeInspector';
 
 const hasFunctionalRender$m = true;
-const hasFunctionalRootRender$f = true;
-const hasFunctionalEvents$b = true;
+const hasFunctionalRootRender$g = true;
+const hasFunctionalEvents$c = true;
 const renderContent = {
   isEqual(oldState, newState) {
     return false;
@@ -17390,7 +17374,7 @@ const renderContent = {
   multiple: true
 };
 const render$m = [renderContent];
-const renderEventListeners$b = async () => {
+const renderEventListeners$c = async () => {
   const listeners = await invoke$a('IframeInspector.renderEventListeners');
   return listeners;
 };
@@ -17400,17 +17384,17 @@ const ViewletIframeInspector_ipc = {
   Commands: Commands$n,
   Css: Css$m,
   create: create$q,
-  getCommands: getCommands$b,
+  getCommands: getCommands$c,
   getKeyBindings: getKeyBindings$b,
-  hasFunctionalEvents: hasFunctionalEvents$b,
+  hasFunctionalEvents: hasFunctionalEvents$c,
   hasFunctionalRender: hasFunctionalRender$m,
-  hasFunctionalRootRender: hasFunctionalRootRender$f,
+  hasFunctionalRootRender: hasFunctionalRootRender$g,
   hotReload: hotReload$a,
   loadContent: loadContent$q,
   name: name$m,
   render: render$m,
   renderContent,
-  renderEventListeners: renderEventListeners$b
+  renderEventListeners: renderEventListeners$c
 };
 
 const first = () => {
@@ -17542,7 +17526,7 @@ const hotReload$9 = state => {
     ...state
   };
 };
-const focusFirst$1 = state => {
+const focusFirst = state => {
   const {
     displayReferences
   } = state;
@@ -17552,7 +17536,7 @@ const focusFirst$1 = state => {
   const firstIndex = first();
   return focusIndex$2(state, firstIndex);
 };
-const focusPrevious$1 = state => {
+const focusPrevious = state => {
   const {
     displayReferences,
     focusedIndex
@@ -17560,7 +17544,7 @@ const focusPrevious$1 = state => {
   const previousIndex = previousNoCycle(displayReferences, focusedIndex);
   return focusIndex$2(state, previousIndex);
 };
-const focusNext$1 = state => {
+const focusNext = state => {
   const {
     displayReferences,
     focusedIndex
@@ -17568,7 +17552,7 @@ const focusNext$1 = state => {
   const nextIndex = nextNoCycle(displayReferences, focusedIndex);
   return focusIndex$2(state, nextIndex);
 };
-const focusLast$1 = state => {
+const focusLast = state => {
   const {
     displayReferences
   } = state;
@@ -17599,11 +17583,11 @@ const ViewletLocations = {
   __proto__: null,
   create: create$p,
   dispose: dispose$h,
-  focusFirst: focusFirst$1,
+  focusFirst,
   focusIndex: focusIndex$2,
-  focusLast: focusLast$1,
-  focusNext: focusNext$1,
-  focusPrevious: focusPrevious$1,
+  focusLast,
+  focusNext,
+  focusPrevious,
   hotReload: hotReload$9,
   loadContent: loadContent$p,
   renderActions: renderActions$7,
@@ -17625,7 +17609,7 @@ const loadContent$o = async (state, savedState) => {
   return loadContent$p(state, savedState);
 };
 const contentLoaded$5 = state => {
-  set$b('Locations', {
+  set$a('Locations', {
     factory: ViewletLocations,
     state
   });
@@ -17634,17 +17618,17 @@ const contentLoaded$5 = state => {
 const dispose$g = dispose$h;
 
 const hasFunctionalRender$l = true;
-const hasFunctionalRootRender$e = true;
-const hasFunctionalEvents$a = true;
-const renderItems$7 = {
+const hasFunctionalRootRender$f = true;
+const hasFunctionalEvents$b = true;
+const renderItems$8 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$l = [renderItems$7];
-const renderEventListeners$a = async () => {
+const render$l = [renderItems$8];
+const renderEventListeners$b = async () => {
   const listeners = await invoke$9('References.renderEventListeners');
   return listeners;
 };
@@ -17658,13 +17642,13 @@ const ViewletImplementations_ipc = {
   contentLoaded: contentLoaded$5,
   create: create$o,
   dispose: dispose$g,
-  hasFunctionalEvents: hasFunctionalEvents$a,
+  hasFunctionalEvents: hasFunctionalEvents$b,
   hasFunctionalRender: hasFunctionalRender$l,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
   loadContent: loadContent$o,
   name: name$l,
   render: render$l,
-  renderEventListeners: renderEventListeners$a
+  renderEventListeners: renderEventListeners$b
 };
 
 const getInlineDiffChanges = (linesLeft, linesRight) => {
@@ -17746,7 +17730,7 @@ const loadContent$n = async (state, savedState) => {
 const Commands$l = {};
 
 // prettier-ignore
-const LazyCommands$2 = {
+const LazyCommands$1 = {
   setDeltaY: () => Promise.resolve().then(function () { return VirtualListSetDeltaY; }),
   handleWheel: () => Promise.resolve().then(function () { return VirtualListHandleWheel; })
 };
@@ -17880,7 +17864,7 @@ const getVisibleInlineDiffEditorLines = (inlineDiffLines, minLineY, maxLineY) =>
 };
 
 const hasFunctionalRender$k = true;
-const hasFunctionalRootRender$d = true;
+const hasFunctionalRootRender$e = true;
 const renderChanges = {
   isEqual(oldState, newState) {
     return oldState.inlineChanges === newState.inlineChanges && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.deltaY === newState.deltaY && oldState.height === newState.height && oldState.finalDeltaY === newState.finalDeltaY && oldState.lineNumbers === newState.lineNumbers;
@@ -17909,11 +17893,11 @@ const ViewletInlineDiffEditor_ipc = {
   __proto__: null,
   Commands: Commands$l,
   Css: Css$l,
-  LazyCommands: LazyCommands$2,
+  LazyCommands: LazyCommands$1,
   create: create$n,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$k,
-  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  hasFunctionalRootRender: hasFunctionalRootRender$e,
   loadContent: loadContent$n,
   name: name$k,
   render: render$k,
@@ -18006,7 +17990,7 @@ const wrapKeyBindingCommand = key => {
 };
 
 const Commands$k = {};
-const getCommands$a = async () => {
+const getCommands$b = async () => {
   const commands = await invoke$8('KeyBindings.getCommandIds');
   for (const command of commands) {
     Commands$k[command] = wrapKeyBindingCommand(command);
@@ -18044,8 +18028,8 @@ const getMenus$7 = async () => {
 const name$j = 'KeyBindings';
 
 const hasFunctionalRender$j = true;
-const hasFunctionalRootRender$c = true;
-const hasFunctionalEvents$9 = true;
+const hasFunctionalRootRender$d = true;
+const hasFunctionalEvents$a = true;
 const renderKeyBindings = {
   isEqual(oldState, newState) {
     return newState.commands && newState.commands.length === 0;
@@ -18054,7 +18038,7 @@ const renderKeyBindings = {
   multiple: true
 };
 const render$j = [renderKeyBindings];
-const renderEventListeners$9 = async () => {
+const renderEventListeners$a = async () => {
   const listeners = await invoke$8('KeyBindings.renderEventListeners');
   return listeners;
 };
@@ -18085,24 +18069,24 @@ const ViewletKeyBindings_ipc = {
   Commands: Commands$k,
   Css: Css$k,
   create: create$m,
-  getCommands: getCommands$a,
+  getCommands: getCommands$b,
   getKeyBindings: getKeyBindings$a,
   getMenus: getMenus$7,
-  hasFunctionalEvents: hasFunctionalEvents$9,
+  hasFunctionalEvents: hasFunctionalEvents$a,
   hasFunctionalRender: hasFunctionalRender$j,
   hasFunctionalResize: hasFunctionalResize$b,
-  hasFunctionalRootRender: hasFunctionalRootRender$c,
+  hasFunctionalRootRender: hasFunctionalRootRender$d,
   hotReload: hotReload$8,
   loadContent: loadContent$m,
   menus: menus$8,
   name: name$j,
   render: render$j,
-  renderEventListeners: renderEventListeners$9,
+  renderEventListeners: renderEventListeners$a,
   resize: resize$e,
   saveState: saveState$b
 };
 
-const commit = '08d6cdd';
+const commit = '6bc57fb';
 
 const getDefaultTitleBarHeight = () => {
   switch (getPlatform$1()) {
@@ -18163,7 +18147,7 @@ const Total = 46;
 const SashId = 'sashId';
 
 const Main$1 = {
-  moduleId: Main$3,
+  moduleId: Main$2,
   kVisible: MainVisible,
   kTop: MainTop,
   kLeft: MainLeft,
@@ -18861,9 +18845,9 @@ const toggleMain = state => {
 };
 const getReferenceNodes = sideBarLocation => {
   if (sideBarLocation === Left$1) {
-    return [TitleBar$1, ActivityBar$1, 'SashSideBar', SideBar$2, Main$3, 'SashPanel', Panel$2, StatusBar$1];
+    return [TitleBar$1, ActivityBar$1, 'SashSideBar', SideBar$2, Main$2, 'SashPanel', Panel$2, StatusBar$1];
   }
-  return [TitleBar$1, Main$3, SideBar$2, 'SashSideBar', ActivityBar$1, 'SashPanel', Panel$2, StatusBar$1];
+  return [TitleBar$1, Main$2, SideBar$2, 'SashSideBar', ActivityBar$1, 'SashPanel', Panel$2, StatusBar$1];
 };
 const loadIfVisible = async (state, module) => {
   try {
@@ -19462,7 +19446,7 @@ const Commands$j = {
   getBadgeCounts: getBadgeCounts,
   getModuleId: getModuleId
 };
-const CommandsWithSideEffects$1 = {
+const CommandsWithSideEffects = {
   handleBadgeCountChange: handleBadgeCountChange,
   handleExtensionsChanged: handleExtensionsChanged,
   handleBlur: handleBlur$1,
@@ -19506,7 +19490,9 @@ const CommandsWithSideEffects$1 = {
   toggleSideBar: toggleSideBar,
   toggleSideBarPosition: toggleSideBarPosition,
   toggleStatusBar: toggleStatusBar,
-  toggleTitleBar: toggleTitleBar
+  toggleTitleBar: toggleTitleBar,
+  createViewlet: createViewlet,
+  attachViewlet: attachViewlet
 };
 
 const Css$j = [];
@@ -19978,8 +19964,8 @@ const getQuickPickMenuEntries$1 = () => {
 
 const name$i = 'Layout';
 
-const Horizontal$1 = 'horizontal';
-const Vertical$1 = 'vertical';
+const Horizontal = 'horizontal';
+const Vertical = 'vertical';
 
 const getDom = id => {
   const instance = getByUid(id);
@@ -20200,7 +20186,7 @@ const renderSashes = {
       y: sideBarTop,
       width: 4,
       height: sideBarHeight,
-      direction: Horizontal$1,
+      direction: Horizontal,
       active: sideBarActive
     }, {
       id: 'SashPanel',
@@ -20208,7 +20194,7 @@ const renderSashes = {
       y: panelTop,
       width: panelWidth,
       height: 4,
-      direction: Vertical$1,
+      direction: Vertical,
       active: panelActive
     }];
   }
@@ -20229,7 +20215,7 @@ const render$i = [renderDom$1, renderSashes];
 const ViewletLayout_ipc = {
   __proto__: null,
   Commands: Commands$j,
-  CommandsWithSideEffects: CommandsWithSideEffects$1,
+  CommandsWithSideEffects,
   Css: Css$j,
   attachViewlet,
   create: create$l,
@@ -20384,46 +20370,6 @@ const measureTabWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing)
   return tabWidthInt;
 };
 
-const canBeRestored = editor => {
-  return typeof editor.uri === 'string' && typeof editor.uid === 'number' && canBeRestored$6(editor.uri);
-};
-const deserializeEditorGroups = (savedState, state) => {
-  if (!savedState) {
-    return [];
-  }
-  // @ts-ignore
-  const {
-    groups} = savedState;
-  const {
-    tabFontWeight,
-    tabFontSize,
-    tabFontFamily,
-    tabLetterSpacing
-  } = state;
-  if (!groups || !Array.isArray(groups)) {
-    return [];
-  }
-  const restoredGroups = [];
-  for (const group of groups) {
-    if (!group || !group.editors) {
-      continue;
-    }
-    const restoredEditors = group.editors.filter(canBeRestored);
-    for (const editor of restoredEditors) {
-      editor.uid = create$$();
-      const label = editor.label;
-      editor.tabWidth = measureTabWidth(label, tabFontWeight, tabFontSize, tabFontFamily, tabLetterSpacing);
-    }
-    const restoredGroup = {
-      ...group,
-      tabsUid: create$$()
-    };
-    restoredGroups.push(restoredGroup);
-  }
-  // TODO check that type is string (else runtime error occurs and page is blank)
-  return restoredGroups;
-};
-
 const None$4 = 0;
 const Up = 1;
 const Down = 2;
@@ -20499,20 +20445,6 @@ const getSplitOverlayDimensions = (x, y, width, height, splitDirection) => {
   }
 };
 
-const launchMainAreaBarWorker = async () => {
-  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.mainAreaWorkerPath', activityBarWorkerUrl);
-  const ipc = await create$10({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: configuredWorkerUrl,
-    name: 'Main Area Worker'
-  });
-  handleIpc(ipc);
-  return ipc;
-};
-
-const {
-  invoke: invoke$7} = getOrCreateWorker(launchMainAreaBarWorker);
-
 const getIndices = (eventX, eventY, tabs) => {
   let width = 0;
   for (let i = 0; i < tabs.length; i++) {
@@ -20561,8 +20493,21 @@ const getTabIndex = (tabs, x, eventX) => {
   return -1;
 };
 
+const launchMainAreaBarWorker = async () => {
+  const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.mainAreaWorkerPath', activityBarWorkerUrl);
+  const ipc = await create$10({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url: configuredWorkerUrl,
+    name: 'Main Area Worker'
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke: invoke$7} = getOrCreateWorker(launchMainAreaBarWorker);
+
 const LeftClick = 0;
-const MiddleClick = 1;
 
 const getTitle = uri => {
   if (!uri) {
@@ -20604,57 +20549,9 @@ const getFileIcon = uri => {
   return icon;
 };
 
-const serializeEditor = editor => {
-  const {
-    preview,
-    tabWidth,
-    uri,
-    uid,
-    label,
-    icon
-  } = editor;
-  return {
-    preview,
-    tabWidth,
-    uri,
-    uid,
-    label,
-    icon
-  };
-};
-const serializeEditors = editors => {
-  return editors.map(serializeEditor);
-};
-
-const serializeEditorGroup = group => {
-  const {
-    editors,
-    activeIndex,
-    tabsDeltaX,
-    x,
-    y,
-    width,
-    height
-  } = group;
-  return {
-    editors: serializeEditors(editors),
-    activeIndex,
-    tabsDeltaX,
-    x,
-    y,
-    width,
-    height
-  };
-};
-const serializeEditorGroups = groups => {
-  return groups.map(serializeEditorGroup);
-};
-
-const Dirty = 1;
 const Preview = 1 << 4;
-const Hovered = 1 << 5;
 
-const getUid$1 = editor => {
+const getUid = editor => {
   return editor.uid;
 };
 const getEditors = group => {
@@ -20667,7 +20564,7 @@ const closeAllEditors = state => {
     uid
   } = state;
   const editors = groups.flatMap(getEditors);
-  const ids = editors.map(getUid$1);
+  const ids = editors.map(getUid);
   const commands = [['Viewlet.send', uid, 'dispose'], ...ids.flatMap(disposeFunctional)];
   return {
     newState: {
@@ -20679,11 +20576,6 @@ const closeAllEditors = state => {
   };
 };
 
-const ViewletMainCloseAllEditors = {
-  __proto__: null,
-  closeAllEditors
-};
-
 const closeEditor = (state, index) => {
   object(state);
   number(index);
@@ -20760,11 +20652,6 @@ const closeEditor = (state, index) => {
   };
 };
 
-const ViewletMainCloseEditor = {
-  __proto__: null,
-  closeEditor
-};
-
 const focusIndex$1 = async (state, index) => {
   const {
     groups,
@@ -20833,94 +20720,6 @@ const focusIndex$1 = async (state, index) => {
     commands
   };
 };
-const focus$3 = (state, getIndex) => {
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  const group = groups[activeGroupIndex];
-  const {
-    editors,
-    activeIndex
-  } = group;
-  const index = getIndex(editors, activeIndex);
-  return focusIndex$1(state, index);
-};
-const getFirstindex = () => {
-  return 0;
-};
-const focusFirst = state => {
-  return focus$3(state, getFirstindex);
-};
-const getLastIndex = editors => {
-  return editors.length - 1;
-};
-const focusLast = state => {
-  return focus$3(state, getLastIndex);
-};
-const getPreviousIndex = (editors, activeIndex) => {
-  return activeIndex === 0 ? editors.length - 1 : activeIndex - 1;
-};
-const focusPrevious = state => {
-  return focus$3(state, getPreviousIndex);
-};
-const getNextIndex = (editors, activeIndex) => {
-  return activeIndex === editors.length - 1 ? 0 : activeIndex + 1;
-};
-const focusNext = state => {
-  return focus$3(state, getNextIndex);
-};
-
-// TODO make computation more efficient
-const getIsCloseButton = (tabs, index, eventX, x) => {
-  let total = 0;
-  for (let i = 0; i <= index; i++) {
-    total += tabs[index].tabWidth;
-  }
-  const offset = eventX - x - total;
-  const closeButtonWidth = 23;
-  return -offset < closeButtonWidth;
-};
-const handleTabClick = (state, button, eventX, eventY) => {
-  number(button);
-  number(eventX);
-  number(eventY);
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  const group = groups[activeGroupIndex];
-  // @ts-ignore
-  const {
-    editors,
-    x} = group;
-  const index = getTabIndex(editors, x, eventX);
-  if (index === -1) {
-    return state;
-  }
-  const isCloseButton = getIsCloseButton(editors, index, eventX, x);
-  if (isCloseButton) {
-    return closeEditor(state, index);
-  }
-  switch (button) {
-    case LeftClick:
-      return focusIndex$1(state, index);
-    case MiddleClick:
-      return closeEditor(state, index);
-    default:
-      return state;
-  }
-};
-
-const ViewletMainFocusIndex = {
-  __proto__: null,
-  focusFirst,
-  focusIndex: focusIndex$1,
-  focusLast,
-  focusNext,
-  focusPrevious,
-  handleTabClick
-};
 
 const openUri = async (state, uri, focus = true, {
   preview = false,
@@ -21059,39 +20858,6 @@ const openUri = async (state, uri, focus = true, {
   };
 };
 
-// interface Editor {
-//  readonly uri: string
-//  readonly type: string
-// }
-
-// interface EditorLazy {
-//  readonly type: 'lazy'
-// }
-
-// interface EditorText extends Editor {
-//   readonly textDocument: TextDocument
-//   readonly type: 'text'
-// }
-
-// interface EditorIframe extends Editor {
-//  readonly srcdoc: string
-//  readonly type: 'iframe'
-// }
-
-// interface EditorImage extends Editor {
-//   readonly src: string
-//   readonly type: 'image'
-// }
-
-// interface EditorVideo extends Editor {
-//   readonly src: string
-//   readonly type: 'video'
-// }
-
-const hydrateLazy = async () => {
-  // TODO this should be in extension host
-  await execute$3(/* EditorDiagnostics.hydrate */'EditorDiagnostics.hydrate');
-};
 const create$k = (id, uri, x, y, width, height) => {
   return {
     groups: [],
@@ -21101,7 +20867,7 @@ const create$k = (id, uri, x, y, width, height) => {
     width,
     height,
     uid: id,
-    moduleId: Main$3,
+    moduleId: Main$2,
     tabHeight: 35,
     dragOverlayX: 0,
     dragOverlayY: 0,
@@ -21117,183 +20883,21 @@ const create$k = (id, uri, x, y, width, height) => {
     tabScrollBarVisible: false
   };
 };
-const getSavedActiveIndex = (savedState, restoredGroups) => {
-  if (!savedState) {
-    return -1;
-  }
-  const savedActiveIndex = savedState.activeGroupIndex;
-  if (typeof savedActiveIndex !== 'number' || savedActiveIndex < 0 || savedActiveIndex > restoredGroups.length) {
-    return -1;
-  }
-  return savedActiveIndex;
+const saveState$9 = async state => {
+  const saved = await invoke$7('MainArea.saveState', state.uid);
+  return saved;
 };
-const getRestoredGroups = (savedState, state) => {
-  // @ts-ignore
-  const {
-    x,
-    width,
-    height
-  } = state;
-  if (isTest()) {
-    return {
-      groups: [{
-        x,
-        y: 0,
-        width,
-        height,
-        editors: [],
-        tabsUid: 0,
-        uid: create$$()
-      }],
-      activeGroupIndex: 0
-    };
-  }
-  const restoredGroups = deserializeEditorGroups(savedState, state);
-  if (restoredGroups.length === 0) {
-    return {
-      groups: [{
-        x,
-        y: 0,
-        width,
-        height,
-        editors: [],
-        tabsUid: 0,
-        uid: create$$()
-      }],
-      activeGroupIndex: 0
-    };
-  }
-  const savedActiveIndex = getSavedActiveIndex(savedState, restoredGroups);
-  if (savedActiveIndex === -1) {
+const loadContent$k = 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);
     return {
-      groups: [{
-        x,
-        y: 0,
-        width,
-        height,
-        editors: [],
-        tabsUid: 0,
-        uid: create$$()
-      }],
-      activeGroupIndex: 0
+      ...state,
+      commands
     };
   }
-  return {
-    groups: restoredGroups,
-    activeGroupIndex: 0
-  };
-};
-const saveState$9 = state => {
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  return {
-    groups: serializeEditorGroups(groups),
-    activeGroupIndex
-  };
-};
-const handleEditorChange = async editor => {
-  const state = getState$1(Main$3);
-  const {
-    activeGroupIndex,
-    groups
-  } = state;
-  if (activeGroupIndex === -1) {
-    return state;
-  }
-  const group = groups[activeGroupIndex];
-  // @ts-ignore
-  const {
-    editors,
-    activeIndex} = group;
-  if (activeIndex === -1) {
-    return state;
-  }
-  const tab = editors[activeIndex];
-  if (tab.uid !== editor.uid) {
-    return state;
-  }
-  if (tab.flags & Dirty) {
-    return state;
-  }
-  const newEditors = [...editors.slice(0, activeIndex), {
-    ...tab,
-    flags: Dirty
-  }, ...editors.slice(activeIndex + 1)];
-  const newGroups = [...groups.slice(0, activeGroupIndex), {
-    ...group,
-    editors: newEditors
-  }, ...groups.slice(activeGroupIndex + 1)];
-  const newState = {
-    ...state,
-    groups: newGroups
-  };
-  await setState(state.uid, newState);
-};
-const handleTitleUpdated$1 = async (uid, title) => {
-  const state = getState$1(Main$3);
-  const {
-    activeGroupIndex,
-    groups,
-    tabFontWeight,
-    tabFontSize,
-    tabFontFamily,
-    tabLetterSpacing
-  } = state;
-  if (activeGroupIndex === -1) {
-    return state;
-  }
-  const group = groups[activeGroupIndex];
-  // @ts-ignore
-  const {
-    editors,
-    activeIndex} = group;
-  if (activeIndex === -1) {
-    return state;
-  }
-  const editor = editors[activeIndex];
-  if (editor.uid !== uid) {
-    return state;
-  }
-  const tabWidth = measureTabWidth(title, tabFontWeight, tabFontSize, tabFontFamily, tabLetterSpacing);
-  const newEditors = [...editors.slice(0, activeIndex), {
-    ...editor,
-    title,
-    label: title,
-    tabWidth
-  }, ...editors.slice(activeIndex + 1)];
-  const newGroups = [...groups.slice(0, activeGroupIndex), {
-    ...group,
-    editors: newEditors
-  }, ...groups.slice(activeGroupIndex + 1)];
-  const newState = {
-    ...state,
-    groups: newGroups
-  };
-  await setState(state.uid, newState);
-};
-const loadContent$k = async (state, savedState) => {
-  // return {
-  //   ...state,
-  //   // commands,
-  // }
-
-  // TODO get restored editors from saved state
-  const {
-    activeGroupIndex,
-    groups
-  } = getRestoredGroups(savedState, state);
-  // @ts-ignore
-  once(Twelve, hydrateLazy);
-  addListener('editor.change', handleEditorChange);
-  addListener('titleUpdated', handleTitleUpdated$1);
-  await invoke$y('Viewlet.loadModule', MainTabs);
-  return {
-    ...state,
-    groups,
-    activeGroupIndex
-  };
 };
 const hotReload$7 = async state => {
   await invoke$7('MainArea.create', state.uid, '', state.x, state.y, state.width, state.height, null);
@@ -21387,7 +20991,7 @@ const openBackgroundTab$1 = async (state, initialUri, props) => {
   const id = getModuleId$1(initialUri);
   const tabLabel = 'Loading';
   const tabTitle = 'Loading';
-  await invoke$y(/* Viewlet.send */'Viewlet.send', /* id */Main$3, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
+  await invoke$y(/* Viewlet.send */'Viewlet.send', /* id */Main$2, /* method */'openViewlet', /* tabLabel */tabLabel, /* tabTitle */tabTitle, /* oldActiveIndex */-1, /* background */true);
   const y = state.y + state.tabHeight;
   const x = state.x;
   const width = state.width;
@@ -21739,53 +21343,39 @@ const openKeyBindings = async state => {
   return openUri(state, keyBindingsUri);
 };
 
-const Commands$i = {
-  focus: focus$2,
-  handleDragEnd: handleDragEnd,
-  handleDragOver: handleDragOver,
-  handleDragLeave: handleDragLeave,
-  handleTabContextMenu: handleTabContextMenu,
-  openBackgroundTab: openBackgroundTab$1,
-  save: save,
-  handleClickClose: handleClickClose,
-  reopenEditorWith: reopenEditorWith,
-  openKeyBindings: openKeyBindings,
-  hotReload: hotReload$7
-};
-const CommandsWithSideEffects = {
-  openUri: openUri,
-  handleDrop: handleDrop,
-  handleTabDrop: handleTabDrop,
-  handleTabsDragOver: handleTabsDragOver
-};
-const CommandsWithSideEffectsLazy = {
-  closeTabsLeft: () => Promise.resolve().then(function () { return ViewletMainCloseTabsLeft; }),
-  closeTabsRight: () => Promise.resolve().then(function () { return ViewletMainCloseTabsRight; }),
-  closeOthers: () => Promise.resolve().then(function () { return ViewletMainCloseOthers; }),
-  closeAllEditors: () => Promise.resolve().then(function () { return ViewletMainCloseAllEditors; }),
-  closeActiveEditor: () => Promise.resolve().then(function () { return ViewletMainCloseActiveEditor; }),
-  closeFocusedTab: () => Promise.resolve().then(function () { return ViewletMainCloseActiveEditor; }),
-  closeEditor: () => Promise.resolve().then(function () { return ViewletMainCloseEditor; }),
-  focusFirst: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
-  focusLast: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
-  focusNext: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
-  focusPrevious: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
-  handleDropFilePath: () => Promise.resolve().then(function () { return ViewletMainHandleDropFilePath; }),
-  splitRight: () => Promise.resolve().then(function () { return ViewletMainSplitRight; })
-};
-const LazyCommands$1 = {
-  handleTabsWheel: () => Promise.resolve().then(function () { return ViewletMainHandleTabsWheel; }),
-  handleTabClick: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
-  handleTabsPointerOver: () => Promise.resolve().then(function () { return ViewletMainHandleTabsPointerOver; }),
-  handleTabsPointerOut: () => Promise.resolve().then(function () { return ViewletMainHandleTabsPointerOut; }),
-  handleContextMenu: () => Promise.resolve().then(function () { return ViewletMainHandleContextMenu; }),
-  findFileReferences: () => Promise.resolve().then(function () { return ViewletMainFindFileReferences; })
-};
-
-const Css$i = [];
-const Variables$5 = ['MainBackground'];
-
-const getKeyBindings$8 = () => {
+const wrapMainAreaCommand = key => {
+  const fn = async (state, ...args) => {
+    await invoke$7(`MainArea.${key}`, state.uid, ...args);
+    const diffResult = await invoke$7('MainArea.diff2', state.uid);
+    if (diffResult.length === 0) {
+      return state;
+    }
+    const commands = await invoke$7('MainArea.render2', state.uid, diffResult);
+    if (commands.length === 0) {
+      return state;
+    }
+    return {
+      ...state,
+      commands
+    };
+  };
+  return fn;
+};
+
+const Commands$i = {};
+const getCommands$a = async () => {
+  const commands = await invoke$7('MainArea.getCommandIds');
+  for (const command of commands) {
+    Commands$i[command] = wrapMainAreaCommand(command);
+  }
+  Commands$i['hotReload'] = hotReload$7;
+  return Commands$i;
+};
+
+const Css$i = [];
+const Variables$5 = ['MainBackground'];
+
+const getKeyBindings$8 = () => {
   return [{
     key: CtrlCmd | KeyW,
     command: 'Main.closeActiveEditor'
@@ -21807,147 +21397,6 @@ const getKeyBindings$8 = () => {
   }];
 };
 
-const menuEntrySeparator = {
-  id: 'separator',
-  label: '',
-  flags: Separator$1,
-  command: ''
-};
-
-/**
- * @enum {string}
- */
-const UiStrings$4 = {
-  OpenFile: 'Open File',
-  SplitUp: 'Split Up',
-  SplitDown: 'Split Down',
-  SplitLeft: 'Split Left',
-  SplitRight: 'Split Right',
-  NewWindow: 'New Window',
-  Close: 'Close',
-  CloseOthers: 'Close Others',
-  CloseToTheRight: 'Close To The Right',
-  CloseAll: 'Close All',
-  RevealInExplorer: 'Reveal in Explorer',
-  FindFileReferences: 'Find File References'
-};
-const openFile = () => {
-  return i18nString(UiStrings$4.OpenFile);
-};
-const splitUp = () => {
-  return i18nString(UiStrings$4.SplitUp);
-};
-const splitDown = () => {
-  return i18nString(UiStrings$4.SplitDown);
-};
-const splitLeft = () => {
-  return i18nString(UiStrings$4.SplitLeft);
-};
-const splitRight$1 = () => {
-  return i18nString(UiStrings$4.SplitRight);
-};
-const newWindow = () => {
-  return i18nString(UiStrings$4.NewWindow);
-};
-const close$1 = () => {
-  return i18nString(UiStrings$4.Close);
-};
-const closeOthers$1 = () => {
-  return i18nString(UiStrings$4.CloseOthers);
-};
-const closeAll = () => {
-  return i18nString(UiStrings$4.CloseAll);
-};
-const revealInExplorer = () => {
-  return i18nString(UiStrings$4.RevealInExplorer);
-};
-const closeToTheRight = () => {
-  return i18nString(UiStrings$4.CloseToTheRight);
-};
-const findFileReferences$1 = () => {
-  return i18nString(UiStrings$4.FindFileReferences);
-};
-
-// TODO should pass tab uri as argument or tab index
-const getMenuEntries$2 = () => {
-  const mainState = getState$1(Main$3);
-  const activeGroupIndex = mainState.activeGroupIndex;
-  const groups = mainState.groups;
-  const group = groups[activeGroupIndex];
-  const editors = group.editors;
-  const editor = editors[group.focusedIndex];
-  object(editor);
-  const uri = editor.uri;
-  return [{
-    id: 'tabClose',
-    label: close$1(),
-    flags: None$6,
-    command: 'Main.closeFocusedTab'
-  }, {
-    id: 'tabCloseOthers',
-    label: closeOthers$1(),
-    flags: None$6,
-    command: 'Main.closeOthers'
-  }, {
-    id: 'tabCloseToTheRight',
-    label: closeToTheRight(),
-    flags: None$6,
-    command: 'Main.closeTabsRight'
-  }, {
-    id: 'tabCloseAll',
-    label: closeAll(),
-    flags: None$6,
-    command: 'Main.closeAllEditors'
-  }, menuEntrySeparator, {
-    id: 'revealInExplorer',
-    label: revealInExplorer(),
-    flags: None$6,
-    command: 'Explorer.revealItem',
-    args: [uri]
-  }, menuEntrySeparator, {
-    id: 'findFileReferences',
-    label: findFileReferences$1(),
-    flags: None$6,
-    command: 'SideBar.show',
-    args: [/* id */'References', /* focus */true, uri]
-  }];
-};
-
-const getMenuEntries$1 = () => {
-  return [{
-    id: 'openFile',
-    label: openFile(),
-    flags: None$6,
-    command: 'Viewlet.openWidget',
-    args: [QuickPick, 'file']
-  }, menuEntrySeparator, {
-    id: 'splitUp',
-    label: splitUp(),
-    flags: None$6,
-    command: 'Main.splitUp'
-  }, {
-    id: 'splitDown',
-    label: splitDown(),
-    flags: None$6,
-    command: 'Main.splitDown'
-  }, {
-    id: 'splitLeft',
-    label: splitLeft(),
-    flags: None$6,
-    command: 'Main.splitLeft'
-  }, {
-    id: 'splitRight',
-    label: splitRight$1(),
-    flags: None$6,
-    command: 'Main.splitRight'
-  }, menuEntrySeparator, {
-    id: 'newWindow',
-    label: newWindow(),
-    flags: None$6,
-    command: 'Main.newWindow'
-  }];
-};
-
 const getQuickPickMenuEntries = () => {
   return [{
     id: 'Main.splitRight',
@@ -21968,308 +21417,39 @@ const getQuickPickMenuEntries = () => {
 };
 const menus$7 = [];
 const getMenus$6 = async () => {
-  const ids = [Main$2, Tab];
-  const adjusted = ids.map(id => {
-    return {
-      id,
-      async getMenuEntries(...args) {
-        switch (id) {
-          case Tab:
-            return getMenuEntries$2();
-          case Main$2:
-            return getMenuEntries$1();
-          default:
-            return [];
+  try {
+    const ids = await invoke$7('MainArea.getMenuIds');
+    const adjusted = ids.map(id => {
+      return {
+        id,
+        async getMenuEntries(...args) {
+          const entries = await invoke$7('MainArea.getMenuEntries', ...args);
+          return entries;
         }
-      }
-    };
-  });
-  return adjusted;
-};
-
-const data = Object.create(null);
-const set = (uid, value) => {
-  data[uid] = value;
-};
-
-const getFileIconVirtualDom = icon => {
-  return {
-    type: Img,
-    className: FileIcon,
-    src: icon,
-    role: None$9,
-    childCount: 0
-  };
-};
-
-const getIconDom = icon => {
-  if (icon.startsWith('MaskIcon')) {
-    return {
-      type: Div,
-      className: `TabIcon ${icon}`,
-      childCount: 0
-    };
-  }
-  return getFileIconVirtualDom(icon);
-};
-const getTabDom = tab => {
-  const {
-    icon,
-    tabWidth,
-    uri,
-    flags,
-    uid,
-    isActive,
-    fixedWidth,
-    label
-  } = tab;
-  let tabClassName = MainTab;
-  if (isActive) {
-    tabClassName += ' ' + MainTabSelected;
-  }
-  const isDirty = flags & Dirty;
-  const actualTabWidth = fixedWidth || tabWidth;
-  const tabElement = {
-    type: Div,
-    className: tabClassName,
-    role: Tab$1,
-    draggable: true,
-    width: actualTabWidth,
-    ariaSelected: isActive,
-    title: uri,
-    childCount: 2,
-    'data-dragUid': uid
-  };
-  set(uid, {
-    type: 'file',
-    uri
-  });
-  const dom = [];
-  dom.push(tabElement, getIconDom(icon), {
-    type: Div,
-    className: TabLabel,
-    childCount: 1
-  }, text(label));
-  if (isDirty) {
-    tabElement.childCount++;
-    dom.push({
-      type: Div,
-      className: EditorTabCloseButton,
-      childCount: 1
-    }, {
-      type: Div,
-      className: 'MaskIcon MaskIconCircleFilled',
-      childCount: 0
-    });
-  } else {
-    tabElement.childCount++;
-    dom.push({
-      type: Button$1,
-      className: EditorTabCloseButton,
-      title: 'Close',
-      childCount: 1
-    }, {
-      type: Div,
-      className: 'MaskIcon MaskIconClose',
-      childCount: 0
-    });
-  }
-  return dom;
-};
-
-const getTabsDom = visibleTabs => {
-  const tabsDom = visibleTabs.flatMap(getTabDom);
-  return tabsDom;
-};
-
-const getUid = object => {
-  return object.uid;
-};
-const filterGroup = (ids, groups) => {
-  const filtered = [];
-  for (const group of groups) {
-    if (!ids.includes(group.uid)) {
-      filtered.push(group);
-    }
-  }
-  return filtered;
-};
-const getUpdatedGroups = (oldGroups, newGroups, oldIds, newIds) => {
-  const updated = [];
-  for (const oldGroup of oldGroups) {
-    if (!newIds.includes(oldGroup.uid)) {
-      continue;
-    }
-    for (const newGroup of newGroups) {
-      if (newGroup.uid === oldGroup.uid && oldGroup !== newGroup) {
-        updated.push({
-          oldGroup,
-          newGroup
-        });
-      }
-    }
-  }
-  return updated;
-};
-const partitionEditorGroups = (oldGroups, newGroups) => {
-  const oldUids = oldGroups.map(getUid);
-  const newUids = newGroups.map(getUid);
-  const insertedGroups = filterGroup(oldUids, newGroups);
-  const deletedGroups = filterGroup(newUids, oldGroups);
-  const updatedGroups = getUpdatedGroups(oldGroups, newGroups, oldUids, newUids);
-  return {
-    insertedGroups,
-    deletedGroups,
-    updatedGroups
-  };
-};
-
-const getTotalTabWidth$1 = tabs => {
-  let total = 0;
-  for (const tab of tabs) {
-    total += tab.tabWidth;
-  }
-  return total;
-};
-
-const getFixedWidth = (width, tabsLength, hasOverflow) => {
-  if (!hasOverflow) {
-    return 0;
-  }
-  return Math.max(width / tabsLength, 80);
-};
-const getVisibleTabs = (tabs, width, activeIndex, deltaX) => {
-  const totalTabWidth = getTotalTabWidth$1(tabs);
-  const hasOverflow = totalTabWidth > width;
-  const fixedWidth = getFixedWidth(width, tabs.length, hasOverflow);
-  const visibleTabs = [];
-  for (let i = 0; i < tabs.length; i++) {
-    const tab = tabs[i];
-    const isActive = i === activeIndex;
-    visibleTabs.push({
-      ...tab,
-      isActive,
-      fixedWidth
+      };
     });
+    return adjusted;
+  } catch {
+    return [];
   }
-  return visibleTabs;
 };
 
 const hasFunctionalRender$h = true;
-const renderDragOverlay = {
-  isEqual(oldState, newState) {
-    return oldState.dragOverlayVisible === newState.dragOverlayVisible && oldState.dragOverlayX === newState.dragOverlayX && oldState.dragOverlayY === newState.dragOverlayY && oldState.dragOverlayWidth === newState.dragOverlayWidth && oldState.dragOverlayHeight === newState.dragOverlayHeight;
-  },
-  apply(oldState, newState) {
-    return ['setDragOverlay', newState.dragOverlayVisible, newState.dragOverlayX, newState.dragOverlayY, newState.dragOverlayWidth, newState.dragOverlayHeight];
-  }
-};
-const renderGroupTabs = {
+const hasFunctionalRootRender$c = true;
+const hasFunctionalEvents$9 = true;
+const renderItems$7 = {
   isEqual(oldState, newState) {
-    return oldState.groups === newState.groups;
-  },
-  apply(oldState, newState) {
-    const commands = [];
-    const oldGroups = oldState.groups;
-    const newGroups = newState.groups;
-    const {
-      insertedGroups,
-      deletedGroups,
-      updatedGroups
-    } = partitionEditorGroups(oldGroups, newGroups);
-    for (const {
-      oldGroup,
-      newGroup
-    } of updatedGroups) {
-      const {
-        tabsUid,
-        editors,
-        x,
-        y,
-        width,
-        activeIndex,
-        tabsDeltaX
-      } = newGroup;
-      if (oldGroup.editors.length === 0) {
-        insertedGroups.push(newGroup);
-      }
-      if (editors !== oldGroup.editors || activeIndex !== oldGroup.activeIndex) {
-        const visibleTabs = getVisibleTabs(editors, newState.width, activeIndex);
-        const tabsDom = getTabsDom(visibleTabs);
-        commands.push(['Viewlet.send', tabsUid, 'setTabsDom', tabsDom]);
-      }
-      if (width !== oldGroup.width) {
-        commands.push(['Viewlet.setBounds', tabsUid, x, y, width, newState.tabHeight]);
-      }
-      if (tabsDeltaX !== oldGroup.tabsDeltaX) {
-        commands.push(['Viewlet.send', tabsUid, 'setScrollLeft', tabsDeltaX]);
-      }
-      if (oldGroup.highlight !== newGroup.highlight || oldGroup.highlightLeft !== newGroup.highlightLeft) {
-        commands.push(['Viewlet.send', tabsUid, 'setHighlight', newGroup.highlightLeft]);
-      }
-    }
-    for (const insertedGroup of insertedGroups) {
-      const {
-        tabsUid,
-        editors,
-        x,
-        y,
-        width,
-        activeIndex,
-        tabsDeltaX
-      } = insertedGroup;
-      if (editors.length > 0) {
-        commands.push(['Viewlet.create', MainTabs, tabsUid]);
-        commands.push(['Viewlet.setBounds', tabsUid, x, y, width, newState.tabHeight]);
-        const visibleTabs = getVisibleTabs(editors, newState.width, activeIndex);
-        const tabsDom = getTabsDom(visibleTabs);
-        commands.push(['Viewlet.send', tabsUid, 'setTabsDom', tabsDom]);
-        commands.push(['Viewlet.send', tabsUid, 'setScrollLeft', tabsDeltaX]);
-        commands.push(['Viewlet.append', newState.uid, tabsUid]);
-      }
-    }
-    for (const group of deletedGroups) {
-      commands.push(['Viewlet.dispose', group.tabsUid]);
-    }
-    return commands;
+    return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
+  apply: apply,
   multiple: true
 };
-const renderTabsActiveIndex = {
-  isEqual(oldState, newState) {
-    return oldState.editors === newState.editors && oldState.activeIndex === newState.activeIndex;
-  },
-  apply(oldState, newState) {
-    const unFocusIndex = oldState.activeIndex < newState.editors.length ? oldState.activeIndex : -1;
-    if (newState.activeIndex === -1) {
-      return [];
-    }
-    return [['Viewlet.send', newState.tabsUid, 'setFocusedIndex', unFocusIndex, newState.activeIndex]];
-  },
-  multiple: true
+const render$h = [renderItems$7];
+const renderEventListeners$9 = async () => {
+  const listeners = await invoke$7('MainArea.renderEventListeners');
+  return listeners;
 };
 
-// const renderDragInfo = {
-//   isEqual(oldState, newState) {
-//     return oldState.groups === newState.groups
-//   },
-//   apply(oldState, newState) {
-//     const dragInfo = Object.create(null)
-//     for (const group of newState.groups) {
-//       // TODO
-//     }
-//     // TODO send drag infos to renderer process
-//     const unFocusIndex = oldState.activeIndex < newState.editors.length ? oldState.activeIndex : -1
-//     if (newState.activeIndex === -1) {
-//       return []
-//     }
-//     return [['Viewlet.send', newState.tabsUid, 'setFocusedIndex', unFocusIndex, newState.activeIndex]]
-//   },
-//   multiple: true,
-// }
-
-const render$h = [renderDragOverlay, renderGroupTabs, renderTabsActiveIndex];
-
 const resizeGroups = (groups, dimensions, y) => {
   const newGroups = [];
   const width = dimensions.width;
@@ -22336,16 +21516,14 @@ const name$h = 'Main';
 const ViewletMain_ipc = {
   __proto__: null,
   Commands: Commands$i,
-  CommandsWithSideEffects,
-  CommandsWithSideEffectsLazy,
   Css: Css$i,
-  LazyCommands: LazyCommands$1,
   Variables: Variables$5,
   contentLoaded: contentLoaded$4,
   create: create$k,
   dispose: dispose$f,
   focus: focus$2,
   getChildren: getChildren$3,
+  getCommands: getCommands$a,
   getKeyBindings: getKeyBindings$8,
   getMenus: getMenus$6,
   getQuickPickMenuEntries,
@@ -22358,7 +21536,9 @@ const ViewletMain_ipc = {
   handleTabContextMenu,
   handleTabDrop,
   handleTabsDragOver,
+  hasFunctionalEvents: hasFunctionalEvents$9,
   hasFunctionalRender: hasFunctionalRender$h,
+  hasFunctionalRootRender: hasFunctionalRootRender$c,
   hotReload: hotReload$7,
   loadContent: loadContent$k,
   menus: menus$7,
@@ -22367,6 +21547,7 @@ const ViewletMain_ipc = {
   openEditorWithType,
   openKeyBindings,
   render: render$h,
+  renderEventListeners: renderEventListeners$9,
   reopenEditorWith,
   resize: resize$d,
   save,
@@ -23242,7 +22423,7 @@ const loadContent$d = async (state, savedState) => {
 
 // TODO side effect is not good here, find a way to call ViewletLocations
 const contentLoaded$2 = state => {
-  set$b('Locations', {
+  set$a('Locations', {
     factory: ViewletLocations,
     state,
     renderedState: state
@@ -23346,14 +22527,14 @@ const ViewletReferences_ipc = {
   getActions: getActions$1,
   getCommands: getCommands$6,
   getDisplayName,
-  hasFunctionalEvents: hasFunctionalEvents$a,
+  hasFunctionalEvents: hasFunctionalEvents$b,
   hasFunctionalRender: hasFunctionalRender$l,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
   loadContent: loadContent$d,
   name: name$b,
   render: render$l,
   renderActions: renderActions$4,
-  renderEventListeners: renderEventListeners$a,
+  renderEventListeners: renderEventListeners$b,
   saveState: saveState$4
 };
 
@@ -25045,7 +24226,7 @@ const renderTitle = {
     return oldState.title === newState.title;
   },
   apply(oldState, newState) {
-    return ['Viewlet.send', Main$3, 'updateTab', 0, newState.title];
+    return ['Viewlet.send', Main$2, 'updateTab', 0, newState.title];
   }
 };
 const render$7 = [renderDom, renderTitle];
@@ -26623,7 +25804,7 @@ const getItem = (items, label) => {
  * @deprecated
  */
 const openContextMenu = async (x, y, id, ...args) => {
-  const entries = await getMenuEntries$5(id, ...args);
+  const entries = await getMenuEntries$3(id, ...args);
   const electronMenuItems = convertMenuItems(entries);
   const event = await invoke$v('ElectronContextMenu.openContextMenu', electronMenuItems, x, y);
   if (event.type === 'close') {
@@ -26812,768 +25993,6 @@ const VirtualListHandleWheel = {
   handleWheel
 };
 
-const closeTabsLeft = state => {
-  const commands = [];
-  // @ts-ignore
-  if (state.focusedIndex <= state.activeIndex) {
-    // view is kept the same, only tabs are closed
-    // @ts-ignore
-    commands.push(['Viewlet.send', /* id */state.uid, /* method */'closeTabsLeft', /* index */state.focusedIndex]);
-  } else {
-    // view needs to be switched to focused index
-    // @ts-ignore
-    commands.push([/* Viewlet.send */'Viewlet.send', /* id */state.uid, /* method */'closeTabsLeft', /* index */state.focusedIndex]);
-  }
-  return {
-    newState: {
-      ...state,
-      // @ts-ignore
-      editors: state.editors.slice(state.focusedIndex),
-      activeIndex: state.focusedIndex
-    },
-    commands
-  };
-};
-
-const ViewletMainCloseTabsLeft = {
-  __proto__: null,
-  closeTabsLeft
-};
-
-// @ts-nocheck
-const closeTabsRight = async state => {
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  if (activeGroupIndex === -1) {
-    return {
-      newState: state,
-      commands: []
-    };
-  }
-  const group = groups[activeGroupIndex];
-  const {
-    editors,
-    activeIndex,
-    focusedIndex
-  } = group;
-  const commands = [];
-  const newEditors = editors.slice(0, focusedIndex + 1);
-  if (focusedIndex >= activeIndex) ; else {
-    // view needs to be switched to focused index
-    const previousEditor = editors[activeIndex];
-    let disposeCommands = [];
-    if (previousEditor) {
-      const previousUid = previousEditor.uid;
-      disposeCommands = disposeFunctional(previousUid);
-    }
-    commands.push(...disposeCommands);
-    const newActiveEditor = newEditors[focusedIndex];
-    const x = state.x;
-    const y = state.y + state.tabHeight;
-    const width = state.width;
-    const contentHeight = state.height - state.tabHeight;
-    const uri = newActiveEditor.uri;
-    const moduleId = await getModuleId$1(uri);
-    const uid = newActiveEditor.uid;
-    const instance = create$Z(load$3, moduleId, state.uid, uri, x, y, width, contentHeight);
-    // @ts-ignore
-    instance.show = false;
-    instance.setBounds = false;
-    instance.uid = uid;
-    const focus = true;
-    // @ts-ignore
-    const instanceCommands = await load$5(instance, focus, false, {});
-    commands.push(...instanceCommands);
-    commands.push(['Viewlet.setBounds', uid, x, state.tabHeight, width, contentHeight]);
-    commands.push(['Viewlet.append', state.uid, uid]);
-  }
-  const newGroups = [...groups.slice(0, activeGroupIndex), {
-    ...group,
-    editors: newEditors,
-    activeIndex: focusedIndex
-  }, ...groups.slice(activeGroupIndex + 1)];
-  return {
-    newState: {
-      ...state,
-      groups: newGroups
-    },
-    commands
-  };
-};
-
-const ViewletMainCloseTabsRight = {
-  __proto__: null,
-  closeTabsRight
-};
-
-const closeOthers = async state => {
-  const commands = [];
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  const group = groups[activeGroupIndex];
-  const {
-    editors,
-    focusedIndex,
-    activeIndex
-  } = group;
-  let newEditors = editors;
-  let newFocusedIndex = focusedIndex;
-  let newActiveIndex = activeIndex;
-  if (focusedIndex === activeIndex) {
-    // view is kept the same, only tabs are closed
-    newEditors = [editors[focusedIndex]];
-    newFocusedIndex = 0;
-    newActiveIndex = 0;
-  } else {
-    // view needs to be switched to focused index
-    const activeEditor = editors[activeIndex];
-    // @ts-ignore
-    const focusedEditor = editors[focusedIndex];
-    newEditors = [focusedEditor];
-    newFocusedIndex = 0;
-    newActiveIndex = 0;
-    const disposeCommands = disposeFunctional(activeEditor.uid);
-    commands.push(...disposeCommands);
-    const instanceUid = create$$();
-    const moduleId = await getModuleId$1(activeEditor.uri);
-    // @ts-ignore
-    const x = state.x;
-    // @ts-ignore
-    const y = state.y + state.tabHeight;
-    // @ts-ignore
-    const width = state.width;
-    // @ts-ignore
-    const contentHeight = state.height - state.tabHeight;
-    // @ts-ignore
-    const instance = create$Z(load$3, moduleId, state.uid, focusedEditor.uri, x, y, width, contentHeight);
-    instance.uid = instanceUid;
-    instance.show = false;
-    instance.setBounds = false;
-    // @ts-ignore
-    const instanceCommands = await load$5(instance, false, false, {});
-    commands.push(...instanceCommands);
-    // @ts-ignore
-    commands.push(['Viewlet.setBounds', instanceUid, x, state.tabHeight, width, contentHeight]);
-    // @ts-ignore
-    commands.push(['Viewlet.append', state.uid, instanceUid]);
-  }
-  const newGroup = {
-    ...group,
-    editors: newEditors,
-    focusedIndex: newFocusedIndex,
-    activeIndex: newActiveIndex
-  };
-  const newGroups = [...groups.slice(0, activeGroupIndex), newGroup, ...groups.slice(activeGroupIndex + 1)];
-  return {
-    newState: {
-      ...state,
-      groups: newGroups
-    },
-    commands
-  };
-};
-
-const ViewletMainCloseOthers = {
-  __proto__: null,
-  closeOthers
-};
-
-const closeActiveEditor = state => {
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  if (activeGroupIndex === -1) {
-    return state;
-  }
-  const group = groups[activeGroupIndex];
-  const {
-    activeIndex
-  } = group;
-  return closeEditor(state, activeIndex);
-};
-const closeFocusedTab = closeActiveEditor;
-
-const ViewletMainCloseActiveEditor = {
-  __proto__: null,
-  closeActiveEditor,
-  closeFocusedTab
-};
-
-const Horizontal = 1;
-const Vertical = 2;
-
-const getSplitDimensionsDown = (x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight) => {
-  return {
-    originalX: 0,
-    originalY: tabHeight,
-    originalWidth: width,
-    originalHeight: halfHeight - tabHeight,
-    originalTabs: 0,
-    originalTabsY: 0,
-    originalTabsWidth: width,
-    originalTabsHeight: tabHeight,
-    overlayX: 0,
-    overlayY: 0 + halfHeight + tabHeight,
-    overlayWidth: width,
-    overlayHeight: halfHeight - tabHeight,
-    overlayTabsX: 0,
-    overlayTabsY: 0 + halfHeight,
-    overlayTabsWidth: width,
-    overlayTabsHeight: tabHeight,
-    sashX: 0,
-    sashY: 0 + halfHeight,
-    sashWidth: width,
-    sashHeight: sashSize,
-    sashOrientation: Horizontal
-  };
-};
-
-const getSplitDimensionsLeft = (x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight) => {
-  return {
-    originalX: halfWidth,
-    originalY: tabHeight,
-    originalWidth: halfWidth,
-    orignalHeight: height - tabHeight,
-    originalTabsX: 0 + halfWidth,
-    originalTabsY: 0,
-    originalTabsWidth: halfWidth,
-    originalTabsHeight: tabHeight,
-    overlayX: 0,
-    overlayY: tabHeight,
-    overlayWidth: halfWidth - sashVisibleSize,
-    overlayHeight: height - tabHeight,
-    overlayTabsX: 0,
-    overlayTabsY: 0,
-    overlayTabsWidth: halfWidth,
-    overlayTabsHeight: tabHeight,
-    sashX: halfWidth,
-    sashY: 0,
-    sashWidth: sashSize,
-    sashHeight: height,
-    sashOrientation: Vertical
-  };
-};
-
-const getSplitDimensionsRight = (x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight) => {
-  return {
-    originalX: 0,
-    originalY: tabHeight,
-    originalWidth: halfWidth,
-    originalHeight: height - tabHeight,
-    originalTabsX: 0,
-    originalTabsY: 0,
-    originalTabsWidth: halfWidth,
-    originalTabsHeight: tabHeight,
-    overlayX: 0 + halfWidth + sashVisibleSize,
-    overlayY: 0 + tabHeight,
-    overlayWidth: halfWidth - sashVisibleSize,
-    overlayHeight: height - tabHeight,
-    overlayTabsX: 0 + halfWidth,
-    overlayTabsY: 0,
-    overlayTabsWidth: halfWidth,
-    overlayTabsHeight: tabHeight,
-    sashX: 0 + halfWidth - sashSize / 2 + sashVisibleSize / 2,
-    sashY: 0,
-    sashWidth: sashSize,
-    sashHeight: height,
-    sashOrientation: Vertical,
-    leafSize: halfWidth,
-    branchSize: width
-  };
-};
-
-const getSplitDimensionsUp = (x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight) => {
-  return {
-    originalX: 0,
-    originalY: halfHeight + tabHeight,
-    originalWidth: width,
-    originalHeight: halfHeight - tabHeight,
-    originalTabsX: 0,
-    originalTabsY: 0 + halfHeight,
-    originalTabsWidth: width,
-    originalTabsHeight: tabHeight,
-    overlayX: 0,
-    overlayY: tabHeight,
-    overlayWidth: width,
-    overlayHeight: halfHeight - tabHeight,
-    overlayTabsX: 0,
-    overlayTabsY: 0,
-    overlayTabsWidth: width,
-    overlayTabsHeight: tabHeight,
-    sashX: 0,
-    sashY: 0 + halfHeight,
-    sashWidth: width,
-    sashHeight: sashSize,
-    sashOrientation: Horizontal
-  };
-};
-
-const getSplitDimensions = (x, y, width, height, splitDirection, sashSize, sashVisibleSize, tabHeight) => {
-  const halfHeight = height / 2;
-  const halfWidth = width / 2;
-  switch (splitDirection) {
-    case Up:
-      return getSplitDimensionsUp(x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight);
-    case Down:
-      return getSplitDimensionsDown(x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight);
-    case Left:
-      return getSplitDimensionsLeft(x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight);
-    case Right:
-      return getSplitDimensionsRight(x, y, width, height, halfWidth, halfHeight, sashSize, sashVisibleSize, tabHeight);
-    case None$4:
-      return {
-        overlayX: x,
-        overlayY: y,
-        overlayWidth: width,
-        overlayHeight: height
-      };
-    default:
-      return {
-        overlayX: 0,
-        overlayY: 0,
-        overlayWidth: 0,
-        overlayHeight: 0
-      };
-  }
-};
-
-const handleDropFilePathNoSplit = async (state, filePath) => {
-  const {
-    newState,
-    commands
-  } = await openUri(state, filePath);
-  return {
-    newState: {
-      ...newState,
-      dragOverlayX: 0,
-      dragOverlayY: 0,
-      dragOverlayWidth: 0,
-      dragOverlayHeight: 0,
-      dragOverlayVisible: false
-    },
-    commands
-  };
-};
-const handleDropFilePathSplit = async (state, eventX, eventY, filePath, splitDirection) => {
-  // @ts-ignore
-  const {
-    x,
-    y,
-    width,
-    height,
-    tabHeight,
-    groups} = state;
-  const sashVisibleSize = 1;
-  const sashSize = 4;
-  const {
-    overlayX,
-    overlayY,
-    overlayWidth,
-    overlayHeight} = getSplitDimensions(x, y, width, height, splitDirection, sashSize, sashVisibleSize, tabHeight);
-  // @ts-ignore
-  [{
-    label: getLabel(filePath),
-    title: filePath
-  }];
-  const uri = filePath;
-  const id = EditorText;
-  create$$();
-  // @ts-ignore
-  create$$();
-  create$Z(load$3, id, state.uid, uri, overlayX, overlayY, overlayWidth, overlayHeight);
-  // const sashGridItem = {
-  //   x: sashX,
-  //   y: sashY,
-  //   width: sashWidth,
-  //   height: sashHeight,
-  //   uid: sashUid,
-  //   childCount: 0,
-  // }
-  // const tabsGridItem = {
-  //   x: overlayTabsX,
-  //   y: overlayTabsY,
-  //   width: overlayTabsWidth,
-  //   height: overlayTabsHeight,
-  //   uri,
-  //   uid: tabsUid,
-  //   childCount: 1,
-
-  if (splitDirection === Down || splitDirection === Right) {
-    const oldGroup = groups[0];
-    const newOldGroup = {
-      ...oldGroup,
-      width: oldGroup.width / 2
-    };
-    const newGroup = {
-      activeIndex: 0,
-      editors: [{
-        icon: '',
-        label: pathBaseName(filePath),
-        tabWidth: 100,
-        title: pathBaseName(filePath),
-        uid: create$$(),
-        uri: filePath
-      }],
-      height: 530,
-      tabsUid: create$$(),
-      uid: create$$(),
-      width: oldGroup.width / 2,
-      x: oldGroup.width / 2,
-      y: 0
-    };
-    const newGroups = [newOldGroup, newGroup];
-    return {
-      ...state,
-      groups: newGroups
-    };
-  }
-  // TODO
-
-  // state.grid.unshift(branchItem)
-  // console.log(state.grid)
-
-  // state.activeIndex = state.grid.length - 1
-  // const tabLabel = Workspace.pathBaseName(uri)
-  // const tabTitle = PathDisplay.getTitle(uri)
-  // const allCommands = []
-
-  // const firstItem = grid[1]
-  // // resize content
-  // const resizeCommands = Viewlet.resize(firstItem.instanceUid, { x: 0, y: 0, width: width - overlayWidth, height })
-  // allCommands.push(...resizeCommands)
-  // allCommands.push(['Viewlet.setBounds', firstItem.instanceUid, originalX, originalY, originalWidth, originalHeight])
-  // // resize tabs
-  // allCommands.push(['Viewlet.setBounds', firstItem.tabdUid, originalTabsX, originalTabsY, originalTabsWidth, originalTabsHeight])
-  // // TODO
-  // // allCommands.push(Viewlet.resize())
-  // allCommands.push([/* Viewlet.send */ 'Viewlet.send', /* id */ ViewletModuleId.Main, /* method */ 'stopHighlightDragOver'])
-  // allCommands.push([/* Viewlet.send */ 'Viewlet.send', /* id */ ViewletModuleId.Main, /* method */ 'hideDragOverlay'])
-  // allCommands.push(['Viewlet.create', ViewletModuleId.MainTabs, tabsUid])
-  // allCommands.push(['Viewlet.send', tabsUid, 'setTabs', [{ label: tabLabel, title: tabTitle }]])
-  // allCommands.push(['Viewlet.setBounds', tabsUid, overlayTabsX, overlayTabsY, overlayTabsWidth, overlayTabsHeight])
-  // // @ts-ignore
-  // const commands = await ViewletManager.load(instance, false)
-  // allCommands.push(...commands)
-  // // TODO when dropping up/left, prepend instead if append
-  // allCommands.push([/* Viewlet.append */ 'Viewlet.appendCustom', /* parentId */ ViewletModuleId.Main, /* method */ 'appendTabs', /* id  */ tabsUid])
-  // allCommands.push([
-  //   /* Viewlet.append */ 'Viewlet.appendCustom',
-  //   /* parentId */ ViewletModuleId.Main,
-  //   /* method */ 'appendContent',
-  //   /* id  */ instanceUid,
-  // ])
-  // // const sashOrientation = splitDirection===
-  // // TODO sash could be horizontal or vertical
-  // const sashModuleId = GetSashModuleId.getSashModuleId(sashOrientation)
-  // await RendererProcess.invoke('Viewlet.loadModule', sashModuleId)
-  // allCommands.push([/* Viewlet.create */ 'Viewlet.create', /* id */ sashModuleId, sashUid])
-  // allCommands.push(['Viewlet.setBounds', sashUid, sashX, sashY, sashWidth, sashHeight])
-  // allCommands.push(['Viewlet.append', ViewletModuleId.Main, sashUid])
-  // await RendererProcess.invoke(/* Viewlet.sendMultiple */ 'Viewlet.sendMultiple', /* commands */ allCommands)
-  return state;
-};
-const handleDropFilePath = async (state, eventX, eventY, filePath) => {
-  object(state);
-  number(eventX);
-  number(eventY);
-  string(filePath);
-  const {
-    x,
-    y,
-    width,
-    height,
-    tabHeight
-  } = state;
-  const splitDirection = getEditorSplitDirectionType(x, y + tabHeight, width, height - tabHeight, eventX, eventY);
-  if (splitDirection === None$4) {
-    return handleDropFilePathNoSplit(state, filePath);
-  }
-  return handleDropFilePathSplit(state, eventX, eventY, filePath, splitDirection);
-};
-
-const ViewletMainHandleDropFilePath = {
-  __proto__: null,
-  handleDropFilePath
-};
-
-const getNewGroups = (groups, x, y, width, height, newUid) => {
-  if (groups.length === 0) {
-    return [{
-      x: x,
-      y: y,
-      width: width / 2,
-      height: height,
-      editors: [],
-      tabsUid: 0,
-      activeIndex: -1
-    }, {
-      x: x + width / 2,
-      y: y,
-      width: width / 2,
-      height: height,
-      editors: [],
-      tabsUid: 0,
-      activeIndex: -1
-    }];
-  }
-  const lastGroup = groups.at(-1);
-  if (!lastGroup) {
-    throw new Error('missing last group');
-  }
-  const lastEditor = lastGroup.editors.at(-1);
-  return [...groups.slice(0, -1), {
-    ...lastGroup,
-    x: lastGroup.x,
-    y: lastGroup.y,
-    width: lastGroup.width / 2,
-    height: lastGroup.height,
-    activeIndex: -1
-  }, {
-    x: lastGroup.x + lastGroup.width / 2,
-    y: lastGroup.y,
-    width: lastGroup.width / 2,
-    height: lastGroup.height,
-    editors: [{
-      ...lastEditor,
-      uid: newUid
-    }],
-    tabsUid: 0,
-    activeIndex: 0
-  }];
-};
-const splitRight = async state => {
-  const {
-    groups,
-    x,
-    y,
-    width,
-    height,
-    tabHeight
-  } = state;
-  const instanceUid = create$$();
-  const newGroups = getNewGroups(groups, x, y, width, height, instanceUid);
-  const commands = [];
-  const lastGroup = newGroups.at(-2);
-  if (!lastGroup) {
-    throw new Error('group not found');
-  }
-  const {
-    activeIndex,
-    editors,
-    tabsUid
-  } = lastGroup;
-  let editor = editors[activeIndex];
-  if (activeIndex === -1 && editors.length > 0) {
-    editor = editors[0];
-  }
-  const contentHeight = height - tabHeight;
-  const dimensions = {
-    x: lastGroup.x,
-    y: y + lastGroup.y + tabHeight,
-    width: lastGroup.width,
-    height: contentHeight
-  };
-  if (editor) {
-    const editorUid = editor.uid;
-    number(editorUid);
-    const resizeCommands = await resize$k(editorUid, dimensions);
-    commands.push(...resizeCommands);
-    commands.push(['Viewlet.setBounds', editorUid, dimensions.x, tabHeight, dimensions.width, contentHeight]);
-  }
-  if (tabsUid !== -1) {
-    commands.push(['Viewlet.setBounds', tabsUid, dimensions.x, 0, dimensions.width, tabHeight]);
-  }
-  if (groups.length === 0) {
-    return state;
-  }
-  const realEditor = lastGroup.editors.at(-1);
-  const moduleId = await getModuleId$1(realEditor.uri);
-  // TODO resize the editor in first group
-  // TODO use half width for editor in second group
-  const instance = create$Z(load$3, moduleId, state.uid, realEditor.uri, x + width / 2, y + tabHeight, width / 2, contentHeight);
-  // @ts-ignore
-  instance.show = false;
-  instance.setBounds = false;
-  instance.uid = instanceUid;
-  // @ts-ignore
-  const instanceCommands = await load$5(instance, true);
-  const newGroup = newGroups.at(-1);
-  if (!newGroup) {
-    throw new Error('new group not found');
-  }
-  instanceCommands.push(['Viewlet.setBounds', instanceUid, newGroup.x, state.tabHeight, newGroup.width, contentHeight]);
-  instanceCommands.push(['Viewlet.append', state.uid, instanceUid]);
-  {
-    instanceCommands.push(['Viewlet.focus', instanceUid]);
-  }
-  const allCommands = [...commands, ...instanceCommands];
-  return {
-    newState: {
-      ...state,
-      groups: newGroups,
-      activeGroupIndex: newGroups.length - 1
-    },
-    commands: allCommands
-  };
-};
-
-const ViewletMainSplitRight = {
-  __proto__: null,
-  splitRight
-};
-
-const getTotalTabWidth = tabs => {
-  let total = 0;
-  for (const tab of tabs) {
-    total += tab.tabWidth;
-  }
-  return total;
-};
-const getNewTabsDeltaX = (width, tabs, tabsDeltaX, deltaX) => {
-  const totalTabWidth = getTotalTabWidth(tabs);
-  const hasOverflow = totalTabWidth > width;
-  if (!hasOverflow) {
-    return 0;
-  }
-  const averageWidth = width / tabs.length;
-  const hasSecondaryOverflow = averageWidth < 80;
-  if (!hasSecondaryOverflow) {
-    return 0;
-  }
-  const fixedWidth = 80;
-  const totalWidth = tabs.length * fixedWidth;
-  const maxDeltaX = totalWidth - width;
-  const newDeltaX = clamp(tabsDeltaX + deltaX, 0, maxDeltaX);
-  return newDeltaX;
-};
-const handleTabsWheel = (state, deltaX, deltaY) => {
-  number(deltaX);
-  number(deltaY);
-  const {
-    groups,
-    activeGroupIndex,
-    width
-  } = state;
-  const group = groups[activeGroupIndex];
-  const {
-    tabsDeltaX,
-    editors
-  } = group;
-  const newDeltaX = getNewTabsDeltaX(width, editors, tabsDeltaX, deltaY);
-  if (newDeltaX === tabsDeltaX) {
-    return state;
-  }
-  const newGroup = {
-    ...group,
-    tabsDeltaX: newDeltaX
-  };
-  const newGroups = [...groups.slice(0, activeGroupIndex), newGroup, ...groups.slice(activeGroupIndex + 1)];
-  return {
-    ...state,
-    groups: newGroups
-  };
-};
-
-const ViewletMainHandleTabsWheel = {
-  __proto__: null,
-  handleTabsWheel
-};
-
-const handleTabsPointerOver = (state, eventX, eventY) => {
-  number(eventX);
-  number(eventY);
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  const group = groups[activeGroupIndex];
-  const {
-    editors,
-    x
-  } = group;
-  const index = getTabIndex(editors, x, eventX);
-  if (index === -1) {
-    return state;
-  }
-  const editor = editors[index];
-  if (editor.flags & Hovered) {
-    return state;
-  }
-  const newEditor = {
-    ...editor,
-    flags: editor.flags | Hovered
-  };
-  const newEditors = [...editors.slice(0, index), newEditor, ...editors.slice(index + 1)];
-  const newGroup = {
-    ...group,
-    editors: newEditors
-  };
-  const newGroups = [...groups.slice(0, activeGroupIndex), newGroup, ...groups.slice(activeGroupIndex + 1)];
-  return {
-    ...state,
-    groups: newGroups
-  };
-};
-
-const ViewletMainHandleTabsPointerOver = {
-  __proto__: null,
-  handleTabsPointerOver
-};
-
-const handleTabsPointerOut = (state, eventX, eventY) => {
-  number(eventX);
-  number(eventY);
-  return {
-    ...state
-  };
-};
-
-const ViewletMainHandleTabsPointerOut = {
-  __proto__: null,
-  handleTabsPointerOut
-};
-
-const handleContextMenu$1 = async (state, x, y) => {
-  number(x);
-  number(y);
-  await show$a();
-  return state;
-};
-
-const ViewletMainHandleContextMenu = {
-  __proto__: null,
-  handleContextMenu: handleContextMenu$1
-};
-
-const findFileReferences = state => {
-  const {
-    groups,
-    activeGroupIndex
-  } = state;
-  if (activeGroupIndex === -1) {
-    return state;
-  }
-  const group = groups[activeGroupIndex];
-  const {
-    activeIndex
-  } = group;
-  const editor = group.editors[activeIndex];
-  const uri = editor.uri;
-  // TODO show references view
-  console.log('show refrences', uri);
-  return state;
-};
-
-const ViewletMainFindFileReferences = {
-  __proto__: null,
-  findFileReferences
-};
-
 const openExternal = async state => {
   const {
     iframeSrc