@lvce-editor/static-server 0.62.0 → 0.62.1

package/static/{2a5a40f → 20b9c92}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -96,7 +96,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/2a5a40f';
+    return '/20b9c92';
   }
 };
 const assetDir = getAssetDir();
@@ -10968,7 +10968,7 @@ const getCommandsFromExtension = extension => {
 const getCommandsFromExtensions = extensions => {
   return extensions.flatMap(getCommandsFromExtension);
 };
-const getCommands$f = async () => {
+const getCommands$g = async () => {
   const extensions = await getExtensions$1();
   const commands = getCommandsFromExtensions(extensions);
   return commands;
@@ -11033,7 +11033,7 @@ const name$1U = 'ExtensionHost';
 // prettier-ignore
 const Commands$1N = {
   loadWebExtension: loadWebExtension,
-  getCommands: getCommands$f,
+  getCommands: getCommands$g,
   executeCommand: executeCommand,
   searchFileWithFetch: searchFileWithFetch,
   searchFileWithHtml: searchFileWithHtml,
@@ -14209,7 +14209,7 @@ const wrapAboutCommand = key => {
 };
 
 const Commands$F = {};
-const getCommands$e = async () => {
+const getCommands$f = async () => {
   const commands = await invoke$j('About.getCommandIds');
   for (const command of commands) {
     Commands$F[command] = wrapAboutCommand(command);
@@ -14268,8 +14268,8 @@ const apply = (oldState, newState) => {
 };
 
 const hasFunctionalRender$F = true;
-const hasFunctionalRootRender$r = true;
-const hasFunctionalEvents$g = true;
+const hasFunctionalRootRender$s = true;
+const hasFunctionalEvents$h = true;
 const renderDialog$2 = {
   isEqual(oldState, newState) {
     return false;
@@ -14278,7 +14278,7 @@ const renderDialog$2 = {
   multiple: true
 };
 const render$I = [renderDialog$2];
-const renderEventListeners$f = async () => {
+const renderEventListeners$g = async () => {
   const listeners = await invoke$j('About.renderEventListeners');
   return listeners;
 };
@@ -14288,16 +14288,16 @@ const ViewletAbout_ipc = {
   Commands: Commands$F,
   Css: Css$H,
   create: create$R,
-  getCommands: getCommands$e,
+  getCommands: getCommands$f,
   getKeyBindings: getKeyBindings$j,
-  hasFunctionalEvents: hasFunctionalEvents$g,
+  hasFunctionalEvents: hasFunctionalEvents$h,
   hasFunctionalRender: hasFunctionalRender$F,
-  hasFunctionalRootRender: hasFunctionalRootRender$r,
+  hasFunctionalRootRender: hasFunctionalRootRender$s,
   loadContent: loadContent$N,
   name: name$N,
   render: render$I,
   renderDialog: renderDialog$2,
-  renderEventListeners: renderEventListeners$f
+  renderEventListeners: renderEventListeners$g
 };
 
 const Tab = 1;
@@ -14597,7 +14597,7 @@ const Commands$E = {
 };
 
 // prettier-ignore
-const LazyCommands$6 = {
+const LazyCommands$5 = {
   focus: () => Promise.resolve().then(function () { return ViewletActivityBarFocus; }),
   focusFirst: () => Promise.resolve().then(function () { return ViewletActivityBarFocusFirst; }),
   focusIndex: () => Promise.resolve().then(function () { return ViewletActivityBarFocusIndex; }),
@@ -14951,8 +14951,8 @@ const getVisibleActivityBarItems = state => {
 };
 
 const hasFunctionalRender$E = true;
-const hasFunctionalRootRender$q = true;
-const renderItems$a = {
+const hasFunctionalRootRender$r = true;
+const renderItems$b = {
   isEqual(oldState, newState) {
     return oldState.filteredItems === newState.filteredItems && oldState.height === newState.height && oldState.selectedIndex === newState.selectedIndex && oldState.focusedIndex === newState.focusedIndex;
   },
@@ -14962,7 +14962,7 @@ const renderItems$a = {
     return ['Viewlet.setDom2', dom];
   }
 };
-const render$H = [renderItems$a];
+const render$H = [renderItems$b];
 
 const getFilteredActivityBarItems = (items, height, itemHeight) => {
   const numberOfVisibleItems = getNumberOfVisibleItems$1({
@@ -15005,7 +15005,7 @@ const ViewletActivityBar_ipc = {
   Commands: Commands$E,
   Css: Css$G,
   Events: Events$6,
-  LazyCommands: LazyCommands$6,
+  LazyCommands: LazyCommands$5,
   Variables: Variables$8,
   create: create$Q,
   focus: focus$6,
@@ -15017,7 +15017,7 @@ const ViewletActivityBar_ipc = {
   handleSideBarViewletChange,
   hasFunctionalRender: hasFunctionalRender$E,
   hasFunctionalResize: hasFunctionalResize$k,
-  hasFunctionalRootRender: hasFunctionalRootRender$q,
+  hasFunctionalRootRender: hasFunctionalRootRender$r,
   loadContent: loadContent$M,
   menus: menus$d,
   name: name$M,
@@ -15115,7 +15115,7 @@ const getAudioVirtualDom = (src, errorMessage) => {
 };
 
 const hasFunctionalRender$D = true;
-const hasFunctionalRootRender$p = true;
+const hasFunctionalRootRender$q = true;
 const renderAudio = {
   isEqual(oldState, newState) {
     return oldState.src === newState.src && oldState.audioErrorMessage === newState.audioErrorMessage;
@@ -15137,7 +15137,7 @@ const ViewletAudio_ipc = {
   dispose: dispose$q,
   handleAudioError,
   hasFunctionalRender: hasFunctionalRender$D,
-  hasFunctionalRootRender: hasFunctionalRootRender$p,
+  hasFunctionalRootRender: hasFunctionalRootRender$q,
   loadContent: loadContent$L,
   name: name$L,
   render: render$G
@@ -15275,7 +15275,7 @@ const getKeyBindings$h = () => {
 };
 
 const hasFunctionalRender$B = true;
-const hasFunctionalRootRender$o = true;
+const hasFunctionalRootRender$p = true;
 const renderDialog$1 = {
   isEqual(oldState, newState) {
     return oldState.productName === newState.productName && oldState.lines === newState.lines;
@@ -15285,7 +15285,7 @@ const renderDialog$1 = {
     return ['Viewlet.setDom2', dom];
   }
 };
-const renderFocus$2 = {
+const renderFocus$1 = {
   isEqual(oldState, newState) {
     return oldState.focused === newState.focused;
   },
@@ -15293,7 +15293,7 @@ const renderFocus$2 = {
     return ['setFocused', newState.focused];
   }
 };
-const render$E = [renderDialog$1, renderFocus$2];
+const render$E = [renderDialog$1, renderFocus$1];
 
 const name$J = 'Confirm';
 
@@ -15308,12 +15308,12 @@ const ViewletConfirm_ipc = {
   handleClickOk,
   handleFocusIn,
   hasFunctionalRender: hasFunctionalRender$B,
-  hasFunctionalRootRender: hasFunctionalRootRender$o,
+  hasFunctionalRootRender: hasFunctionalRootRender$p,
   loadContent: loadContent$I,
   name: name$J,
   render: render$E,
   renderDialog: renderDialog$1,
-  renderFocus: renderFocus$2
+  renderFocus: renderFocus$1
 };
 
 const formatResult = result => {
@@ -15696,7 +15696,7 @@ const getDefineKeyBindingsVirtualDom = message => {
 };
 
 const hasFunctionalRender$z = true;
-const hasFunctionalRootRender$n = true;
+const hasFunctionalRootRender$o = true;
 const renderValue = {
   isEqual(oldState, newState) {
     return oldState.value === newState.value;
@@ -15705,7 +15705,7 @@ const renderValue = {
     return ['setValue', newState.value];
   }
 };
-const renderFocus$1 = {
+const renderFocus = {
   isEqual(oldState, newState) {
     return oldState.focused === newState.focused;
   },
@@ -15722,7 +15722,7 @@ const renderDom$4 = {
     return ['Viewlet.setDom2', dom];
   }
 };
-const render$C = [renderDom$4, renderValue, renderFocus$1];
+const render$C = [renderDom$4, renderValue, renderFocus];
 
 const ViewletDefineKeyBinding_ipc = {
   __proto__: null,
@@ -15732,7 +15732,7 @@ const ViewletDefineKeyBinding_ipc = {
   handleBlur: handleBlur$2,
   handleKeyDown: handleKeyDown$1,
   hasFunctionalRender: hasFunctionalRender$z,
-  hasFunctionalRootRender: hasFunctionalRootRender$n,
+  hasFunctionalRootRender: hasFunctionalRootRender$o,
   loadContent: loadContent$G,
   render: render$C
 };
@@ -16163,7 +16163,7 @@ const loadContent$E = async (state, savedState) => {
 const Commands$x = {};
 
 // prettier-ignore
-const LazyCommands$5 = {
+const LazyCommands$4 = {
   setDeltaY: () => Promise.resolve().then(function () { return VirtualListSetDeltaY; }),
   handleWheel: () => Promise.resolve().then(function () { return VirtualListHandleWheel; })
 };
@@ -16556,12 +16556,11 @@ const getVisibleDiffLinesWithTokens = (lines, changes, minLineY, maxLineY, langu
   return merged;
 };
 
-const SetFocused = 'setFocused';
 const SetScrollBar = 'setScrollBar';
 const SetTitle = 'setTitle';
 
 const hasFunctionalRender$x = true;
-const hasFunctionalRootRender$m = true;
+const hasFunctionalRootRender$n = true;
 const renderChanges$1 = {
   isEqual(oldState, newState) {
     return oldState.changes === newState.changes && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY;
@@ -16595,11 +16594,11 @@ const ViewletDiffEditor_ipc = {
   __proto__: null,
   Commands: Commands$x,
   Css: Css$y,
-  LazyCommands: LazyCommands$5,
+  LazyCommands: LazyCommands$4,
   create: create$H,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$x,
-  hasFunctionalRootRender: hasFunctionalRootRender$m,
+  hasFunctionalRootRender: hasFunctionalRootRender$n,
   loadContent: loadContent$E,
   name: name$G,
   render: render$A,
@@ -16770,7 +16769,7 @@ const getE2eTestVirtualDom = content => {
 };
 
 const hasFunctionalRender$w = true;
-const hasFunctionalRootRender$l = true;
+const hasFunctionalRootRender$m = true;
 const renderElements = {
   isEqual(oldState, newState) {
     return oldState.name === newState.name && oldState.content === newState.content;
@@ -16827,7 +16826,7 @@ const ViewletE2eTest_ipc = {
   handleSashCornerPointerUp,
   hasFunctionalRender: hasFunctionalRender$w,
   hasFunctionalResize: hasFunctionalResize$j,
-  hasFunctionalRootRender: hasFunctionalRootRender$l,
+  hasFunctionalRootRender: hasFunctionalRootRender$m,
   loadContent: loadContent$D,
   menus: menus$c,
   name: name$F,
@@ -16920,7 +16919,7 @@ const runAll = state => {
   console.log('run all');
   return state;
 };
-const handleContextMenu$4 = async (state, button, x, y) => {
+const handleContextMenu$3 = async (state, button, x, y) => {
   const index = getIndex$1(state.y, y);
   // @ts-ignore
   state.index = index;
@@ -16942,7 +16941,7 @@ const Commands$v = {
   handleClickAt: handleClickAt,
   handleLoad: handleLoad,
   runAll: runAll,
-  handleContextMenu: handleContextMenu$4,
+  handleContextMenu: handleContextMenu$3,
   openInNewTab: openInNewTab
 };
 
@@ -17018,7 +17017,7 @@ const getVisibleE2eTests = (tests, index) => {
 };
 
 const hasFunctionalRender$v = true;
-const hasFunctionalRootRender$k = true;
+const hasFunctionalRootRender$l = true;
 const renderTests = {
   isEqual(oldState, newState) {
     return oldState.tests === newState.tests && oldState.index === newState.index;
@@ -17075,10 +17074,10 @@ const ViewletE2eTests_ipc = {
   executeTest,
   getKeyBindings: getKeyBindings$e,
   handleClickAt,
-  handleContextMenu: handleContextMenu$4,
+  handleContextMenu: handleContextMenu$3,
   handleLoad,
   hasFunctionalRender: hasFunctionalRender$v,
-  hasFunctionalRootRender: hasFunctionalRootRender$k,
+  hasFunctionalRootRender: hasFunctionalRootRender$l,
   loadContent: loadContent$C,
   menus: menus$b,
   name: name$E,
@@ -17974,7 +17973,7 @@ const wrapExplorerCommand = key => {
 };
 
 const Commands$s = {};
-const getCommands$d = async () => {
+const getCommands$e = async () => {
   const commands = await invoke$c('Explorer.getCommandIds');
   for (const command of commands) {
     Commands$s[command] = wrapExplorerCommand(command);
@@ -18024,17 +18023,17 @@ const getDisplayName$1 = () => {
 };
 
 const hasFunctionalRender$t = true;
-const hasFunctionalRootRender$j = true;
-const hasFunctionalEvents$f = true;
-const renderItems$9 = {
+const hasFunctionalRootRender$k = true;
+const hasFunctionalEvents$g = true;
+const renderItems$a = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
   apply: apply,
   multiple: true
 };
-const render$t = [renderItems$9];
-const renderEventListeners$e = async () => {
+const render$t = [renderItems$a];
+const renderEventListeners$f = async () => {
   const listeners = await invoke$c('Explorer.renderEventListeners');
   return listeners;
 };
@@ -18084,21 +18083,21 @@ const ViewletExplorer_ipc = {
   Events: Events$4,
   create: create$x,
   dispose: dispose$k,
-  getCommands: getCommands$d,
+  getCommands: getCommands$e,
   getDisplayName: getDisplayName$1,
   getKeyBindings: getKeyBindings$c,
   getMouseActions,
-  hasFunctionalEvents: hasFunctionalEvents$f,
+  hasFunctionalEvents: hasFunctionalEvents$g,
   hasFunctionalRender: hasFunctionalRender$t,
   hasFunctionalResize: hasFunctionalResize$h,
-  hasFunctionalRootRender: hasFunctionalRootRender$j,
+  hasFunctionalRootRender: hasFunctionalRootRender$k,
   hotReload: hotReload$b,
   loadContent: loadContent$y,
   menus: menus$a,
   name: name$A,
   render: render$t,
   renderActions: renderActions$9,
-  renderEventListeners: renderEventListeners$e,
+  renderEventListeners: renderEventListeners$f,
   renderTitle: renderTitle$4,
   resize: resize$k,
   restoreState,
@@ -18209,7 +18208,7 @@ const wrapExtensionDetailCommand = key => {
 };
 
 const Commands$r = {};
-const getCommands$c = async () => {
+const getCommands$d = async () => {
   const commands = await invoke$b('ExtensionDetail.getCommandIds');
   for (const command of commands) {
     Commands$r[command] = wrapExtensionDetailCommand(command);
@@ -18241,8 +18240,8 @@ const getMenus$2 = async () => {
 const name$z = 'ExtensionDetail';
 
 const hasFunctionalRender$s = true;
-const hasFunctionalRootRender$i = true;
-const hasFunctionalEvents$e = true;
+const hasFunctionalRootRender$j = true;
+const hasFunctionalEvents$f = true;
 const renderDom$3 = {
   isEqual(oldState, newState) {
     return false;
@@ -18251,7 +18250,7 @@ const renderDom$3 = {
   multiple: true
 };
 const render$s = [renderDom$3];
-const renderEventListeners$d = async () => {
+const renderEventListeners$e = async () => {
   const listeners = await invoke$b('ExtensionDetail.renderEventListeners');
   return listeners;
 };
@@ -18261,18 +18260,18 @@ const ViewletExtensionDetail_ipc = {
   Commands: Commands$r,
   Css: Css$s,
   create: create$w,
-  getCommands: getCommands$c,
+  getCommands: getCommands$d,
   getMenus: getMenus$2,
-  hasFunctionalEvents: hasFunctionalEvents$e,
+  hasFunctionalEvents: hasFunctionalEvents$f,
   hasFunctionalRender: hasFunctionalRender$s,
   hasFunctionalResize: hasFunctionalResize$g,
-  hasFunctionalRootRender: hasFunctionalRootRender$i,
+  hasFunctionalRootRender: hasFunctionalRootRender$j,
   hotReload: hotReload$a,
   loadContent: loadContent$x,
   menus: menus$9,
   name: name$z,
   render: render$s,
-  renderEventListeners: renderEventListeners$d,
+  renderEventListeners: renderEventListeners$e,
   saveState: saveState$h
 };
 
@@ -18377,7 +18376,7 @@ const wrapExtensionSearchCommand = key => {
 };
 
 const Commands$q = {};
-const getCommands$b = async () => {
+const getCommands$c = async () => {
   const commands = await invoke$a('SearchExtensions.getCommandIds');
   for (const command of commands) {
     Commands$q[command] = wrapExtensionSearchCommand(command);
@@ -18434,17 +18433,17 @@ const menus$8 = [{
 const name$y = 'Extensions';
 
 const hasFunctionalRender$r = true;
-const hasFunctionalRootRender$h = true;
-const hasFunctionalEvents$d = true;
-const renderItems$8 = {
+const hasFunctionalRootRender$i = true;
+const hasFunctionalEvents$e = true;
+const renderItems$9 = {
   isEqual(oldState, newState) {
     return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
   apply: apply,
   multiple: true
 };
-const render$r = [renderItems$8];
-const renderEventListeners$c = async () => {
+const render$r = [renderItems$9];
+const renderEventListeners$d = async () => {
   const listeners = await invoke$a('SearchExtensions.renderEventListeners');
   return listeners;
 };
@@ -18510,19 +18509,19 @@ const ViewletExtensions_ipc = {
   Css: Css$r,
   create: create$v,
   dispose: dispose$j,
-  getCommands: getCommands$b,
+  getCommands: getCommands$c,
   getKeyBindings: getKeyBindings$b,
-  hasFunctionalEvents: hasFunctionalEvents$d,
+  hasFunctionalEvents: hasFunctionalEvents$e,
   hasFunctionalRender: hasFunctionalRender$r,
   hasFunctionalResize: hasFunctionalResize$f,
-  hasFunctionalRootRender: hasFunctionalRootRender$h,
+  hasFunctionalRootRender: hasFunctionalRootRender$i,
   hotReload: hotReload$9,
   loadContent: loadContent$w,
   menus: menus$8,
   name: name$y,
   render: render$r,
   renderActions: renderActions$8,
-  renderEventListeners: renderEventListeners$c,
+  renderEventListeners: renderEventListeners$d,
   renderTitle: renderTitle$3,
   resize: resize$j,
   saveState: saveState$g
@@ -18620,7 +18619,7 @@ const wrapIframeInspectorCommand = key => {
 };
 
 const Commands$p = {};
-const getCommands$a = async () => {
+const getCommands$b = async () => {
   const commands = await invoke$9('IframeInspector.getCommandIds');
   for (const command of commands) {
     Commands$p[command] = wrapIframeInspectorCommand(command);
@@ -18638,8 +18637,8 @@ const getKeyBindings$a = () => {
 const name$x = 'IframeInspector';
 
 const hasFunctionalRender$q = true;
-const hasFunctionalRootRender$g = true;
-const hasFunctionalEvents$c = true;
+const hasFunctionalRootRender$h = true;
+const hasFunctionalEvents$d = true;
 const renderContent = {
   isEqual(oldState, newState) {
     return false;
@@ -18648,7 +18647,7 @@ const renderContent = {
   multiple: true
 };
 const render$q = [renderContent];
-const renderEventListeners$b = async () => {
+const renderEventListeners$c = async () => {
   const listeners = await invoke$9('IframeInspector.renderEventListeners');
   return listeners;
 };
@@ -18658,17 +18657,17 @@ const ViewletIframeInspector_ipc = {
   Commands: Commands$p,
   Css: Css$q,
   create: create$u,
-  getCommands: getCommands$a,
+  getCommands: getCommands$b,
   getKeyBindings: getKeyBindings$a,
-  hasFunctionalEvents: hasFunctionalEvents$c,
+  hasFunctionalEvents: hasFunctionalEvents$d,
   hasFunctionalRender: hasFunctionalRender$q,
-  hasFunctionalRootRender: hasFunctionalRootRender$g,
+  hasFunctionalRootRender: hasFunctionalRootRender$h,
   hotReload: hotReload$8,
   loadContent: loadContent$v,
   name: name$x,
   render: render$q,
   renderContent,
-  renderEventListeners: renderEventListeners$b
+  renderEventListeners: renderEventListeners$c
 };
 
 const first = () => {
@@ -18901,17 +18900,17 @@ const contentLoaded$5 = state => {
 const dispose$h = dispose$i;
 
 const hasFunctionalRender$p = true;
-const hasFunctionalRootRender$f = true;
-const hasFunctionalEvents$b = true;
-const renderItems$7 = {
+const hasFunctionalRootRender$g = true;
+const hasFunctionalEvents$c = true;
+const renderItems$8 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$p = [renderItems$7];
-const renderEventListeners$a = async () => {
+const render$p = [renderItems$8];
+const renderEventListeners$b = async () => {
   const listeners = await invoke$8('References.renderEventListeners');
   return listeners;
 };
@@ -18925,13 +18924,13 @@ const ViewletImplementations_ipc = {
   contentLoaded: contentLoaded$5,
   create: create$s,
   dispose: dispose$h,
-  hasFunctionalEvents: hasFunctionalEvents$b,
+  hasFunctionalEvents: hasFunctionalEvents$c,
   hasFunctionalRender: hasFunctionalRender$p,
-  hasFunctionalRootRender: hasFunctionalRootRender$f,
+  hasFunctionalRootRender: hasFunctionalRootRender$g,
   loadContent: loadContent$t,
   name: name$w,
   render: render$p,
-  renderEventListeners: renderEventListeners$a
+  renderEventListeners: renderEventListeners$b
 };
 
 const getInlineDiffChanges = (linesLeft, linesRight) => {
@@ -19013,7 +19012,7 @@ const loadContent$s = async (state, savedState) => {
 const Commands$n = {};
 
 // prettier-ignore
-const LazyCommands$4 = {
+const LazyCommands$3 = {
   setDeltaY: () => Promise.resolve().then(function () { return VirtualListSetDeltaY; }),
   handleWheel: () => Promise.resolve().then(function () { return VirtualListHandleWheel; })
 };
@@ -19147,7 +19146,7 @@ const getVisibleInlineDiffEditorLines = (inlineDiffLines, minLineY, maxLineY) =>
 };
 
 const hasFunctionalRender$o = true;
-const hasFunctionalRootRender$e = true;
+const hasFunctionalRootRender$f = 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;
@@ -19176,11 +19175,11 @@ const ViewletInlineDiffEditor_ipc = {
   __proto__: null,
   Commands: Commands$n,
   Css: Css$p,
-  LazyCommands: LazyCommands$4,
+  LazyCommands: LazyCommands$3,
   create: create$r,
   getDynamicCss,
   hasFunctionalRender: hasFunctionalRender$o,
-  hasFunctionalRootRender: hasFunctionalRootRender$e,
+  hasFunctionalRootRender: hasFunctionalRootRender$f,
   loadContent: loadContent$s,
   name: name$v,
   render: render$o,
@@ -19287,7 +19286,7 @@ const wrapKeyBindingCommand = key => {
 };
 
 const Commands$m = {};
-const getCommands$9 = async () => {
+const getCommands$a = async () => {
   const commands = await invoke$7('KeyBindings.getCommandIds');
   for (const command of commands) {
     Commands$m[command] = wrapKeyBindingCommand(command);
@@ -19363,8 +19362,8 @@ const menus$7 = [MenuEntriesKeyBindingsTable];
 const name$u = 'KeyBindings';
 
 const hasFunctionalRender$n = true;
-const hasFunctionalRootRender$d = true;
-const hasFunctionalEvents$a = true;
+const hasFunctionalRootRender$e = true;
+const hasFunctionalEvents$b = true;
 const renderKeyBindings = {
   isEqual(oldState, newState) {
     return newState.commands && newState.commands.length === 0;
@@ -19373,7 +19372,7 @@ const renderKeyBindings = {
   multiple: true
 };
 const render$n = [renderKeyBindings];
-const renderEventListeners$9 = async () => {
+const renderEventListeners$a = async () => {
   const listeners = await invoke$7('KeyBindings.renderEventListeners');
   return listeners;
 };
@@ -19404,18 +19403,18 @@ const ViewletKeyBindings_ipc = {
   Commands: Commands$m,
   Css: Css$o,
   create: create$q,
-  getCommands: getCommands$9,
+  getCommands: getCommands$a,
   getKeyBindings: getKeyBindings$9,
-  hasFunctionalEvents: hasFunctionalEvents$a,
+  hasFunctionalEvents: hasFunctionalEvents$b,
   hasFunctionalRender: hasFunctionalRender$n,
   hasFunctionalResize: hasFunctionalResize$e,
-  hasFunctionalRootRender: hasFunctionalRootRender$d,
+  hasFunctionalRootRender: hasFunctionalRootRender$e,
   hotReload: hotReload$6,
   loadContent: loadContent$r,
   menus: menus$7,
   name: name$u,
   render: render$n,
-  renderEventListeners: renderEventListeners$9,
+  renderEventListeners: renderEventListeners$a,
   resize: resize$i,
   saveState: saveState$d
 };
@@ -22383,7 +22382,7 @@ const loadContent$p = async (state, savedState) => {
     activeGroupIndex
   };
 };
-const getChildren$4 = state => {
+const getChildren$3 = state => {
   const {
     groups
   } = state;
@@ -22845,7 +22844,7 @@ const CommandsWithSideEffectsLazy = {
   handleDropFilePath: () => Promise.resolve().then(function () { return ViewletMainHandleDropFilePath; }),
   splitRight: () => Promise.resolve().then(function () { return ViewletMainSplitRight; })
 };
-const LazyCommands$3 = {
+const LazyCommands$2 = {
   handleTabsWheel: () => Promise.resolve().then(function () { return ViewletMainHandleTabsWheel; }),
   handleTabClick: () => Promise.resolve().then(function () { return ViewletMainFocusIndex; }),
   handleTabsPointerOver: () => Promise.resolve().then(function () { return ViewletMainHandleTabsPointerOver; }),
@@ -23249,13 +23248,13 @@ const ViewletMain_ipc = {
   CommandsWithSideEffects,
   CommandsWithSideEffectsLazy,
   Css: Css$m,
-  LazyCommands: LazyCommands$3,
+  LazyCommands: LazyCommands$2,
   Variables: Variables$7,
   contentLoaded: contentLoaded$4,
   create: create$o,
   dispose: dispose$g,
   focus: focus$3,
-  getChildren: getChildren$4,
+  getChildren: getChildren$3,
   getKeyBindings: getKeyBindings$7,
   getQuickPickMenuEntries,
   handleClickClose: handleClickClose$1,
@@ -23445,7 +23444,7 @@ const wrapOutputCommand = key => {
 };
 
 const Commands$h = {};
-const getCommands$8 = async () => {
+const getCommands$9 = async () => {
   const commands = await invoke$6('Output.getCommandIds');
   for (const command of commands) {
     Commands$h[command] = wrapOutputCommand(command);
@@ -23457,8 +23456,8 @@ const getCommands$8 = async () => {
 const Css$l = ["/css/parts/ViewletOutput.css", "/css/parts/Select.css"];
 
 const hasFunctionalRender$k = true;
-const hasFunctionalRootRender$c = true;
-const hasFunctionalEvents$9 = true;
+const hasFunctionalRootRender$d = true;
+const hasFunctionalEvents$a = true;
 const renderDialog = {
   isEqual(oldState, newState) {
     return false;
@@ -23467,7 +23466,7 @@ const renderDialog = {
   multiple: true
 };
 const render$k = [renderDialog];
-const renderEventListeners$8 = async () => {
+const renderEventListeners$9 = async () => {
   const listeners = await invoke$6('Output.renderEventListeners');
   return listeners;
 };
@@ -23489,18 +23488,18 @@ const ViewletOutput_ipc = {
   Commands: Commands$h,
   Css: Css$l,
   create: create$l,
-  getCommands: getCommands$8,
-  hasFunctionalEvents: hasFunctionalEvents$9,
+  getCommands: getCommands$9,
+  hasFunctionalEvents: hasFunctionalEvents$a,
   hasFunctionalRender: hasFunctionalRender$k,
   hasFunctionalResize: hasFunctionalResize$d,
-  hasFunctionalRootRender: hasFunctionalRootRender$c,
+  hasFunctionalRootRender: hasFunctionalRootRender$d,
   hotReload: hotReload$5,
   loadContent: loadContent$m,
   name: name$q,
   render: render$k,
   renderActions: renderActions$6,
   renderDialog,
-  renderEventListeners: renderEventListeners$8,
+  renderEventListeners: renderEventListeners$9,
   saveState: saveState$a
 };
 
@@ -23602,7 +23601,7 @@ const getContentDimensions$1 = dimensions => {
 };
 
 // TODO
-const getChildren$3 = state => {
+const getChildren$2 = state => {
   const {
     currentViewletId
   } = state;
@@ -23764,7 +23763,7 @@ const ViewletPanel_ipc = {
   contentLoaded: contentLoaded$3,
   create: create$k,
   dispose: dispose$d,
-  getChildren: getChildren$3,
+  getChildren: getChildren$2,
   handleClickAction,
   handleFilterInput,
   hasFunctionalRender: hasFunctionalRender$j,
@@ -23858,7 +23857,7 @@ const wrapProblemsCommand = key => {
 };
 
 const Commands$f = {};
-const getCommands$7 = async () => {
+const getCommands$8 = async () => {
   const commands = await invoke$5('Problems.getCommandIds');
   for (const command of commands) {
     Commands$f[command] = wrapProblemsCommand(command);
@@ -23972,17 +23971,17 @@ const MenuEntriesProblemsFilter = {
 const menus$6 = [MenuEntriesProblems, MenuEntriesProblemsFilter];
 
 const hasFunctionalRender$i = true;
-const hasFunctionalRootRender$b = true;
-const hasFunctionalEvents$8 = true;
-const renderItems$6 = {
+const hasFunctionalRootRender$c = true;
+const hasFunctionalEvents$9 = true;
+const renderItems$7 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$i = [renderItems$6];
-const renderEventListeners$7 = async () => {
+const render$i = [renderItems$7];
+const renderEventListeners$8 = async () => {
   const listeners = await invoke$5('Problems.renderEventListeners');
   return listeners;
 };
@@ -24018,18 +24017,18 @@ const ViewletProblems_ipc = {
   Css: Css$j,
   create: create$j,
   getBadgeCount,
-  getCommands: getCommands$7,
+  getCommands: getCommands$8,
   getKeyBindings: getKeyBindings$6,
-  hasFunctionalEvents: hasFunctionalEvents$8,
+  hasFunctionalEvents: hasFunctionalEvents$9,
   hasFunctionalRender: hasFunctionalRender$i,
   hasFunctionalResize: hasFunctionalResize$c,
-  hasFunctionalRootRender: hasFunctionalRootRender$b,
+  hasFunctionalRootRender: hasFunctionalRootRender$c,
   loadContent: loadContent$k,
   menus: menus$6,
   name: name$o,
   render: render$i,
   renderActions: renderActions$5,
-  renderEventListeners: renderEventListeners$7,
+  renderEventListeners: renderEventListeners$8,
   resize: resize$f,
   saveState: saveState$8
 };
@@ -24365,7 +24364,7 @@ const wrapQuickPickCommand = key => {
 };
 
 const Commands$e = {};
-const getCommands$6 = async () => {
+const getCommands$7 = async () => {
   const commands = await invoke$n('QuickPick.getCommandIds');
   for (const command of commands) {
     Commands$e[command] = wrapQuickPickCommand(command);
@@ -24384,17 +24383,17 @@ const getKeyBindings$5 = () => {
 };
 
 const hasFunctionalRender$h = true;
-const hasFunctionalRootRender$a = true;
-const hasFunctionalEvents$7 = true;
-const renderItems$5 = {
+const hasFunctionalRootRender$b = true;
+const hasFunctionalEvents$8 = true;
+const renderItems$6 = {
   isEqual(oldState, newState) {
     return false;
   },
   apply: apply,
   multiple: true
 };
-const render$h = [renderItems$5];
-const renderEventListeners$6 = async () => {
+const render$h = [renderItems$6];
+const renderEventListeners$7 = async () => {
   const listeners = await invoke$n('QuickPick.renderEventListeners');
   return listeners;
 };
@@ -24408,16 +24407,16 @@ const ViewletQuickPick_ipc = {
   Variables: Variables$5,
   create: create$i,
   dispose: dispose$c,
-  getCommands: getCommands$6,
+  getCommands: getCommands$7,
   getKeyBindings: getKeyBindings$5,
-  hasFunctionalEvents: hasFunctionalEvents$7,
+  hasFunctionalEvents: hasFunctionalEvents$8,
   hasFunctionalRender: hasFunctionalRender$h,
-  hasFunctionalRootRender: hasFunctionalRootRender$a,
+  hasFunctionalRootRender: hasFunctionalRootRender$b,
   loadContent: loadContent$j,
   name: name$l,
   render: render$h,
-  renderEventListeners: renderEventListeners$6,
-  renderItems: renderItems$5,
+  renderEventListeners: renderEventListeners$7,
+  renderItems: renderItems$6,
   saveState: saveState$7
 };
 
@@ -24504,7 +24503,7 @@ const wrapReferencesCommand = key => {
 };
 
 const Commands$d = {};
-const getCommands$5 = async () => {
+const getCommands$6 = async () => {
   const commands = await invoke$8('References.getCommandIds');
   for (const command of commands) {
     Commands$d[command] = wrapReferencesCommand(command);
@@ -24535,16 +24534,16 @@ const ViewletReferences_ipc = {
   create: create$h,
   dispose: dispose$b,
   getActions: getActions$2,
-  getCommands: getCommands$5,
+  getCommands: getCommands$6,
   getDisplayName,
-  hasFunctionalEvents: hasFunctionalEvents$b,
+  hasFunctionalEvents: hasFunctionalEvents$c,
   hasFunctionalRender: hasFunctionalRender$p,
-  hasFunctionalRootRender: hasFunctionalRootRender$f,
+  hasFunctionalRootRender: hasFunctionalRootRender$g,
   loadContent: loadContent$i,
   name: name$k,
   render: render$p,
   renderActions: renderActions$4,
-  renderEventListeners: renderEventListeners$a,
+  renderEventListeners: renderEventListeners$b,
   saveState: saveState$6
 };
 
@@ -24705,7 +24704,7 @@ const wrapRunAndDebugCommand = key => {
 };
 
 const Commands$c = {};
-const getCommands$4 = async () => {
+const getCommands$5 = async () => {
   const commands = await invoke$k('RunAndDebug.getCommandIds');
   for (const command of commands) {
     Commands$c[command] = wrapRunAndDebugCommand(command);
@@ -24742,17 +24741,17 @@ const getMenus$1 = async () => {
 };
 
 const hasFunctionalRender$g = true;
-const hasFunctionalRootRender$9 = true;
-const hasFunctionalEvents$6 = true;
-const renderItems$4 = {
+const hasFunctionalRootRender$a = true;
+const hasFunctionalEvents$7 = true;
+const renderItems$5 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$g = [renderItems$4];
-const renderEventListeners$5 = async () => {
+const render$g = [renderItems$5];
+const renderEventListeners$6 = async () => {
   const listeners = await invoke$k('RunAndDebug.renderEventListeners');
   return listeners;
 };
@@ -24778,22 +24777,22 @@ const ViewletRunAndDebug_ipc = {
   contentLoaded: contentLoaded$1,
   create: create$g,
   dispose: dispose$a,
-  getCommands: getCommands$4,
+  getCommands: getCommands$5,
   getKeyBindings: getKeyBindings$4,
   getMenus: getMenus$1,
   handleDebugInput,
   handleEvaluate,
-  hasFunctionalEvents: hasFunctionalEvents$6,
+  hasFunctionalEvents: hasFunctionalEvents$7,
   hasFunctionalRender: hasFunctionalRender$g,
   hasFunctionalResize: hasFunctionalResize$b,
-  hasFunctionalRootRender: hasFunctionalRootRender$9,
+  hasFunctionalRootRender: hasFunctionalRootRender$a,
   hotReload: hotReload$4,
   loadContent: loadContent$h,
   menus: menus$5,
   name: name$j,
   render: render$g,
   renderActions: renderActions$3,
-  renderEventListeners: renderEventListeners$5,
+  renderEventListeners: renderEventListeners$6,
   resize: resize$e,
   saveState: saveState$5
 };
@@ -25004,7 +25003,7 @@ const wrapTextSearchCommand = key => {
 };
 
 const Commands$b = {};
-const getCommands$3 = async () => {
+const getCommands$4 = async () => {
   const commands = await invoke$4('TextSearch.getCommandIds');
   for (const command of commands) {
     Commands$b[command] = wrapTextSearchCommand(command);
@@ -25050,17 +25049,17 @@ const menus$4 = [MenuEntriesSearch];
 const name$i = 'Search';
 
 const hasFunctionalRender$e = true;
-const hasFunctionalRootRender$8 = true;
-const hasFunctionalEvents$5 = true;
-const renderItems$3 = {
+const hasFunctionalRootRender$9 = true;
+const hasFunctionalEvents$6 = true;
+const renderItems$4 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$e = [renderItems$3];
-const renderEventListeners$4 = async () => {
+const render$e = [renderItems$4];
+const renderEventListeners$5 = async () => {
   const listeners = await invoke$4('TextSearch.renderEventListeners');
   return listeners;
 };
@@ -25088,19 +25087,19 @@ const ViewletSearch_ipc = {
   Css: Css$e,
   create: create$e,
   dispose: dispose$7,
-  getCommands: getCommands$3,
+  getCommands: getCommands$4,
   getKeyBindings: getKeyBindings$3,
-  hasFunctionalEvents: hasFunctionalEvents$5,
+  hasFunctionalEvents: hasFunctionalEvents$6,
   hasFunctionalRender: hasFunctionalRender$e,
   hasFunctionalResize: hasFunctionalResize$a,
-  hasFunctionalRootRender: hasFunctionalRootRender$8,
+  hasFunctionalRootRender: hasFunctionalRootRender$9,
   hotReload: hotReload$3,
   loadContent: loadContent$f,
   menus: menus$4,
   name: name$i,
   render: render$e,
   renderActions: renderActions$2,
-  renderEventListeners: renderEventListeners$4,
+  renderEventListeners: renderEventListeners$5,
   resize: resize$d,
   saveState: saveState$4
 };
@@ -25206,7 +25205,7 @@ const wrapSettingsCommand = key => {
 };
 
 const Commands$a = {};
-const getCommands$2 = async () => {
+const getCommands$3 = async () => {
   const commands = await invoke$3('Settings.getCommandIds');
   for (const command of commands) {
     Commands$a[command] = wrapSettingsCommand(command);
@@ -25225,17 +25224,17 @@ const getKeyBindings$2 = () => {
 const menus$3 = [];
 
 const hasFunctionalRender$d = true;
-const hasFunctionalRootRender$7 = true;
-const hasFunctionalEvents$4 = true;
-const renderItems$2 = {
+const hasFunctionalRootRender$8 = true;
+const hasFunctionalEvents$5 = true;
+const renderItems$3 = {
   isEqual(oldState, newState) {
     return newState.commands.length === 0;
   },
   apply: apply,
   multiple: true
 };
-const render$d = [renderItems$2];
-const renderEventListeners$3 = async () => {
+const render$d = [renderItems$3];
+const renderEventListeners$4 = async () => {
   const listeners = await invoke$3('Settings.renderEventListeners');
   return listeners;
 };
@@ -25260,18 +25259,18 @@ const ViewletSettings_ipc = {
   Commands: Commands$a,
   Css: Css$d,
   create: create$d,
-  getCommands: getCommands$2,
+  getCommands: getCommands$3,
   getKeyBindings: getKeyBindings$2,
-  hasFunctionalEvents: hasFunctionalEvents$4,
+  hasFunctionalEvents: hasFunctionalEvents$5,
   hasFunctionalRender: hasFunctionalRender$d,
   hasFunctionalResize: hasFunctionalResize$9,
-  hasFunctionalRootRender: hasFunctionalRootRender$7,
+  hasFunctionalRootRender: hasFunctionalRootRender$8,
   hotReload: hotReload$2,
   loadContent: loadContent$e,
   menus: menus$3,
   name: name$h,
   render: render$d,
-  renderEventListeners: renderEventListeners$3,
+  renderEventListeners: renderEventListeners$4,
   resize: resize$c,
   saveState: saveState$3
 };
@@ -25342,7 +25341,7 @@ const getContentDimensions = (dimensions, titleAreaHeight) => {
 };
 
 // TODO
-const getChildren$2 = state => {
+const getChildren$1 = state => {
   const {
     titleAreaHeight,
     currentViewletId
@@ -25512,7 +25511,7 @@ const ViewletSideBar_ipc = {
   create: create$c,
   dispose: dispose$6,
   focus: focus$2,
-  getChildren: getChildren$2,
+  getChildren: getChildren$1,
   handleClickAction,
   hasFunctionalRender: hasFunctionalRender$c,
   loadContent: loadContent$d,
@@ -26015,7 +26014,7 @@ const Commands$8 = {
   insertJavaScript: insertJavaScript,
   setUrl: setUrl
 };
-const LazyCommands$2 = {
+const LazyCommands$1 = {
   openExternal: () => Promise.resolve().then(function () { return ViewletSimpleBrowserOpenExternal; }),
   openBackgroundTab: () => Promise.resolve().then(function () { return ViewletSimpleBrowserOpenBackgroundTab; }),
   handleContextMenu: () => Promise.resolve().then(function () { return ViewletSimpleBrowserHandleContextMenu; }),
@@ -26219,7 +26218,7 @@ const getSimpleBrowserVirtualDom = (canGoBack, canGoForward, isLoading, value) =
 };
 
 const hasFunctionalRender$b = true;
-const hasFunctionalRootRender$6 = true;
+const hasFunctionalRootRender$7 = true;
 const renderDom = {
   isEqual(oldState, newState) {
     return oldState.iframeSrc === newState.iframeSrc && oldState.canGoBack === newState.canGoBack && oldState.canGoForward === newState.canGoForward && oldState.isLoading === newState.isLoading;
@@ -26267,7 +26266,7 @@ const ViewletSimpleBrowser_ipc = {
   Commands: Commands$8,
   Css: Css$b,
   Events: Events$2,
-  LazyCommands: LazyCommands$2,
+  LazyCommands: LazyCommands$1,
   backgroundLoadContent,
   create: create$b,
   dispose: dispose$4,
@@ -26281,7 +26280,7 @@ const ViewletSimpleBrowser_ipc = {
   handleWillNavigate,
   hasFunctionalRender: hasFunctionalRender$b,
   hasFunctionalResize: hasFunctionalResize$8,
-  hasFunctionalRootRender: hasFunctionalRootRender$6,
+  hasFunctionalRootRender: hasFunctionalRootRender$7,
   hide,
   loadContent: loadContent$c,
   menus: menus$2,
@@ -26686,7 +26685,7 @@ const wrapSourceControlCommand = key => {
 };
 
 const Commands$7 = {};
-const getCommands$1 = async () => {
+const getCommands$2 = async () => {
   const commands = await invoke$1('SourceControl.getCommandIds');
   for (const command of commands) {
     Commands$7[command] = wrapSourceControlCommand(command);
@@ -26797,8 +26796,8 @@ const menus$1 = [MenuEntriesSourceControl];
 const name$e = 'Source Control';
 
 const hasFunctionalRender$a = true;
-const hasFunctionalRootRender$5 = true;
-const hasFunctionalEvents$3 = true;
+const hasFunctionalRootRender$6 = true;
+const hasFunctionalEvents$4 = true;
 const renderSourceControl = {
   isEqual(oldState, newState) {
     return newState.commands && newState.commands.length === 0;
@@ -26807,7 +26806,7 @@ const renderSourceControl = {
   multiple: true
 };
 const render$a = [renderSourceControl];
-const renderEventListeners$2 = async () => {
+const renderEventListeners$3 = async () => {
   const listeners = await invoke$1('SourceControl.renderEventListeners');
   return listeners;
 };
@@ -26861,23 +26860,23 @@ const ViewletSourceControl_ipc = {
   Events: Events$1,
   create: create$a,
   dispose: dispose$3,
-  getCommands: getCommands$1,
+  getCommands: getCommands$2,
   handleIconThemeChange,
   handleInput,
   handleMouseOut,
   handleMouseOver,
   handleWorkspaceChange,
-  hasFunctionalEvents: hasFunctionalEvents$3,
+  hasFunctionalEvents: hasFunctionalEvents$4,
   hasFunctionalRender: hasFunctionalRender$a,
   hasFunctionalResize: hasFunctionalResize$7,
-  hasFunctionalRootRender: hasFunctionalRootRender$5,
+  hasFunctionalRootRender: hasFunctionalRootRender$6,
   hotReload: hotReload$1,
   loadContent: loadContent$a,
   menus: menus$1,
   name: name$e,
   render: render$a,
   renderActions: renderActions$1,
-  renderEventListeners: renderEventListeners$2,
+  renderEventListeners: renderEventListeners$3,
   resize: resize$9,
   updateIcons
 };
@@ -27069,7 +27068,7 @@ const getStatusBarVirtualDom = (statusBarItemsLeft, statusBarItemsRight) => {
 };
 
 const hasFunctionalRender$9 = true;
-const renderItems$1 = {
+const renderItems$2 = {
   isEqual(oldState, newState) {
     return oldState.statusBarItemsLeft === newState.statusBarItemsLeft && oldState.statusBarItemsRight === newState.statusBarItemsRight;
   },
@@ -27078,7 +27077,7 @@ const renderItems$1 = {
     return [/* method */'setDom', dom];
   }
 };
-const render$9 = [renderItems$1];
+const render$9 = [renderItems$2];
 
 const hasFunctionalResize$6 = true;
 const resize$8 = (state, dimensions) => {
@@ -27196,7 +27195,7 @@ const renderStorage = {
   }
 };
 const hasFunctionalRender$8 = true;
-const hasFunctionalRootRender$4 = true;
+const hasFunctionalRootRender$5 = true;
 const render$8 = [renderStorage];
 
 const Css$8 = ["/css/parts/ViewletStorage.css"];
@@ -27206,7 +27205,7 @@ const ViewletStorage_ipc = {
   Css: Css$8,
   create: create$8,
   hasFunctionalRender: hasFunctionalRender$8,
-  hasFunctionalRootRender: hasFunctionalRootRender$4,
+  hasFunctionalRootRender: hasFunctionalRootRender$5,
   loadContent: loadContent$8,
   render: render$8
 };
@@ -27409,7 +27408,7 @@ const create$6 = (id, uri, x, y, width, height) => {
     selectedIndex: -1
   };
 };
-const getChildren$1 = state => {
+const getChildren = state => {
   const {
     x,
     y,
@@ -27634,7 +27633,7 @@ const ViewletTerminals_ipc = {
   addTerminal,
   create: create$6,
   focusIndex,
-  getChildren: getChildren$1,
+  getChildren,
   handleClickTab,
   hasFunctionalRender: hasFunctionalRender$6,
   loadContent: loadContent$6,
@@ -27644,6 +27643,35 @@ const ViewletTerminals_ipc = {
   resize: resize$6
 };
 
+const titleBarWorkerUrl = `${assetDir}/packages/title-bar-worker/dist/titleBarWorkerMain.js`;
+
+const getConfiguredWorkerUrl = () => {
+  let configuredWorkerUrl = get$f('develop.titleBarWorkerPath') || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || titleBarWorkerUrl;
+  {
+    configuredWorkerUrl = titleBarWorkerUrl;
+  }
+  return configuredWorkerUrl;
+};
+const launchTitleBarWorker = async () => {
+  const name = 'Title Bar Worker';
+  const ipc = await create$14({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    name,
+    url: getConfiguredWorkerUrl()
+  });
+  handleIpc(ipc);
+  return ipc;
+};
+
+const {
+  invoke,
+  restart
+} = getOrCreateWorker(launchTitleBarWorker);
+
 const create$5 = (id, uri, x, y, width, height) => {
   return {
     uid: id,
@@ -27658,13 +27686,19 @@ const create$5 = (id, uri, x, y, width, height) => {
     titleBarMenuBarEnabled: true,
     titleBarButtonsEnabled: true,
     titleBarButtonsWidth: 46 * 3,
-    titleBarTitleEnabled: true
+    titleBarTitleEnabled: true,
+    platform: platform
   };
 };
-const loadContent$5 = state => {
+const loadContent$5 = async state => {
+  await invoke('TitleBar.create3', state.uid, state.uri, state.x, state.y, state.width, state.height, state.platform, state.controlsOverlayEnabled, state.titleBarStyleCustom);
+  await invoke(`TitleBar.loadContent2`, state.uid);
+  const diffResult = await invoke(`TitleBar.diff3`, state.uid);
+  const commands = await invoke('TitleBar.render3', state.uid, diffResult);
   const titleBarTitleEnabled = get$f('titleBar.titleEnabled') ?? false;
   return {
     ...state,
+    commands,
     isFocused: true,
     titleBarTitleEnabled
   };
@@ -27675,60 +27709,30 @@ const handleFocusChange = (state, isFocused) => {
     isFocused
   };
 };
-const getTitleBarMenuBarWidth$1 = (width, menuBarX, titleBarButtonsWidth) => {
-  const remainingWidth = width - menuBarX - titleBarButtonsWidth;
-  return remainingWidth;
-};
-const getChildren = state => {
-  const children = [];
-  const {
-    x,
-    y,
-    width,
-    height,
-    titleBarIconWidth,
-    titleBarTitleEnabled,
-    titleBarIconEnabled,
-    titleBarMenuBarEnabled,
-    titleBarButtonsEnabled,
-    titleBarButtonsWidth
-  } = state;
-  let menuBarX = x;
-  if (titleBarIconEnabled) {
-    children.push({
-      id: TitleBarIcon
-    });
-    menuBarX += titleBarIconWidth;
-  }
-  if (titleBarMenuBarEnabled) {
-    const remainingWidth = getTitleBarMenuBarWidth$1(width, menuBarX, titleBarButtonsWidth);
-    children.push({
-      id: TitleBarMenuBar,
-      x: menuBarX,
-      y,
-      height,
-      width: remainingWidth,
-      setBounds: false
-    });
-  }
-  if (titleBarTitleEnabled) {
-    children.push({
-      id: TitleBarTitle
-    });
-  }
-  if (titleBarButtonsEnabled) {
-    children.push({
-      id: TitleBarButtons
-    });
-  }
-  return children;
+
+const wrapTitleBarCommand = key => {
+  const fn = async (state, ...args) => {
+    await invoke(`TitleBar.${key}`, state.uid, ...args);
+    const diffResult = await invoke('TitleBar.diff3', state.uid);
+    if (diffResult.length === 0) {
+      return state;
+    }
+    const commands = await invoke('TitleBar.render3', state.uid, diffResult);
+    return {
+      ...state,
+      commands
+    };
+  };
+  return fn;
 };
 
 const Commands$3 = {};
-
-// prettier-ignore
-const LazyCommands$1 = {
-  handleContextMenu: () => Promise.resolve().then(function () { return ViewletTitleBarHandleContextMenu; })
+const getCommands$1 = async () => {
+  const commands = await invoke('TitleBar.getCommandIds');
+  for (const command of commands) {
+    Commands$3[command] = wrapTitleBarCommand(command);
+  }
+  return Commands$3;
 };
 
 const Css$5 = [];
@@ -27737,15 +27741,23 @@ const Variables$2 = ['TitleBarForeground', 'TitleBarForegroundActive', 'TitleBar
 const name$a = 'TitleBar';
 
 const hasFunctionalRender$5 = true;
-const renderFocus = {
+const hasFunctionalRootRender$4 = true;
+const hasFunctionalEvents$3 = true;
+const renderItems$1 = {
   isEqual(oldState, newState) {
-    return oldState.isFocused === newState.isFocused;
+    console.log({
+      commands: newState.commands
+    });
+    return JSON.stringify(oldState.commands) === JSON.stringify(newState.commands);
   },
-  apply(oldState, newState) {
-    return [SetFocused, newState.isFocused];
-  }
+  apply: apply,
+  multiple: true
+};
+const render$5 = [renderItems$1];
+const renderEventListeners$2 = async () => {
+  const listeners = await invoke('TitleBar.renderEventListeners');
+  return listeners;
 };
-const render$5 = [renderFocus];
 
 const getTitleBarMenuBarWidth = (width, menuBarX, titleBarButtonsWidth) => {
   const remainingWidth = width - menuBarX - titleBarButtonsWidth;
@@ -27778,15 +27790,17 @@ const ViewletTitleBar_ipc = {
   __proto__: null,
   Commands: Commands$3,
   Css: Css$5,
-  LazyCommands: LazyCommands$1,
   Variables: Variables$2,
   create: create$5,
-  getChildren,
+  getCommands: getCommands$1,
   handleFocusChange,
+  hasFunctionalEvents: hasFunctionalEvents$3,
   hasFunctionalRender: hasFunctionalRender$5,
+  hasFunctionalRootRender: hasFunctionalRootRender$4,
   loadContent: loadContent$5,
   name: name$a,
   render: render$5,
+  renderEventListeners: renderEventListeners$2,
   resize: resize$5
 };
 
@@ -28074,35 +28088,6 @@ const getEntries = () => {
   return getMenuEntries$h(TitleBar$1);
 };
 
-const titleBarWorkerUrl = `${assetDir}/packages/title-bar-worker/dist/titleBarWorkerMain.js`;
-
-const getConfiguredWorkerUrl = () => {
-  let configuredWorkerUrl = get$f('develop.titleBarWorkerPath') || '';
-  if (configuredWorkerUrl) {
-    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
-  }
-  configuredWorkerUrl = configuredWorkerUrl || titleBarWorkerUrl;
-  {
-    configuredWorkerUrl = titleBarWorkerUrl;
-  }
-  return configuredWorkerUrl;
-};
-const launchTitleBarWorker = async () => {
-  const name = 'Title Bar Worker';
-  const ipc = await create$14({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name,
-    url: getConfiguredWorkerUrl()
-  });
-  handleIpc(ipc);
-  return ipc;
-};
-
-const {
-  invoke,
-  restart
-} = getOrCreateWorker(launchTitleBarWorker);
-
 const create$2 = (id, uri, x, y, width, height) => {
   return {
     uid: id,
@@ -29273,14 +29258,14 @@ const ViewletActivityBarHandleFocus = {
   handleFocus
 };
 
-const handleContextMenu$3 = async (state, button, x, y) => {
+const handleContextMenu$2 = async (state, button, x, y) => {
   await show$a(x, y, ActivityBar$4);
   return state;
 };
 
 const ViewletActivityBarHandleContextMenu = {
   __proto__: null,
-  handleContextMenu: handleContextMenu$3
+  handleContextMenu: handleContextMenu$2
 };
 
 const setDeltaY = (state, value) => {
@@ -30051,7 +30036,7 @@ const ViewletMainHandleTabsPointerOut = {
   handleTabsPointerOut
 };
 
-const handleContextMenu$2 = async (state, x, y) => {
+const handleContextMenu$1 = async (state, x, y) => {
   number(x);
   number(y);
   await show$a(x, y, Main$2);
@@ -30060,7 +30045,7 @@ const handleContextMenu$2 = async (state, x, y) => {
 
 const ViewletMainHandleContextMenu = {
   __proto__: null,
-  handleContextMenu: handleContextMenu$2
+  handleContextMenu: handleContextMenu$1
 };
 
 const findFileReferences = state => {
@@ -30127,7 +30112,7 @@ const prefixIdWithExt = item => {
 const getExtensionPicks = async () => {
   try {
     // TODO don't call this every time
-    const extensionPicks = await getCommands$f();
+    const extensionPicks = await getCommands$g();
     if (!extensionPicks) {
       return [];
     }
@@ -30505,7 +30490,7 @@ const ViewletSimpleBrowserOpenBackgroundTab = {
   openBackgroundTab
 };
 
-const handleContextMenu$1 = async (state, params) => {
+const handleContextMenu = async (state, params) => {
   object(state);
   object(params);
   const {
@@ -30526,7 +30511,7 @@ const handleContextMenu$1 = async (state, params) => {
 
 const ViewletSimpleBrowserHandleContextMenu = {
   __proto__: null,
-  handleContextMenu: handleContextMenu$1
+  handleContextMenu
 };
 
 const inspectElement = async (state, x, y) => {
@@ -30657,15 +30642,6 @@ const ViewletSimpleBrowserCancelNavigation = {
   cancelNavigation
 };
 
-const handleContextMenu = state => {
-  return state;
-};
-
-const ViewletTitleBarHandleContextMenu = {
-  __proto__: null,
-  handleContextMenu
-};
-
 const handleClickClose = async state => {
   await execute$4('ElectronWindow.close');
   return state;