@lvce-editor/static-server 0.49.11 → 0.49.13

package/static/{9c30f35 → df291da}/packages/title-bar-worker/dist/titleBarWorkerMain.js

@@ -815,6 +815,9 @@ const createRpc = ipc => {
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
+    },
+    async dispose() {
+      await ipc?.dispose();
     }
   };
   return rpc;
@@ -873,41 +876,25 @@ const isEqual$2 = (oldState, newState) => {
   return oldState.titleBarEntries === newState.titleBarEntries && oldState.width === newState.width && oldState.focusedIndex === newState.focusedIndex && oldState.isMenuOpen === newState.isMenuOpen;
 };
 
-const DiffEntries = {
-  __proto__: null,
-  diffType: diffType$2,
-  isEqual: isEqual$2
-};
-
 const diffType$1 = RenderFocusedIndex;
 const isEqual$1 = (oldState, newState) => {
   return oldState.focusedIndex === newState.focusedIndex && oldState.isMenuOpen === newState.isMenuOpen;
 };
 
-const DiffFocusedIndex = {
-  __proto__: null,
-  diffType: diffType$1,
-  isEqual: isEqual$1
-};
-
 const diffType = RenderMenus;
 const isEqual = (oldState, newState) => {
   return oldState.menus === newState.menus;
 };
 
-const DiffMenus = {
-  __proto__: null,
-  diffType,
-  isEqual
-};
-
-const modules = [DiffEntries, DiffFocusedIndex, DiffMenus];
+const modules = [isEqual$2, isEqual$1, isEqual];
+const numbers = [diffType$2, diffType$1, diffType];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
-  for (const module of modules) {
-    if (!module.isEqual(oldState, newState)) {
-      diffResult.push(module.diffType);
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
     }
   }
   return diffResult;
@@ -941,215 +928,12 @@ const diff2 = uid => {
   return diff(oldState, newState);
 };
 
-const Menu$1 = 'menu';
-const MenuBar = 'menubar';
-const MenuItem$1 = 'menuitem';
-const MenuItemCheckBox = 'menuitemcheckbox';
-const None$1 = 'none';
-const Separator$1 = 'separator';
-
-const HandleClick = 'handleClick';
-const HandleClickMinimize = 'handleClickMinimize';
-const HandleClickToggleClose = 'handleClickToggleClose';
-const HandleClickToggleMaximize = 'handleClickToggleMaximize';
-const HandleFocusIn = 'handleFocusIn';
-const HandleFocusOut = 'handleFocusOut';
-const HandlePointerOut = 'handlePointerOut';
-const HandlePointerOver = 'handlePointerOver';
-const HandleMenuClick = 'handleMenuClick';
-const HandleMenuMouseOver = 'handleMenuMouseOver';
-
-const Menu = 'Menu';
-const MenuItem = 'MenuItem';
-const MenuItemFocused = 'MenuItemFocused';
-const MenuItemSeparator = 'MenuItemSeparator';
-const MenuItemSeparatorLine = 'MenuItemSeparatorLine';
-const MenuItemSubMenu = 'MenuItemSubMenu';
-const MenuItemSubMenuArrowRight = 'MenuItemSubMenuArrowRight';
-const TitleBarEntryActive = 'TitleBarEntryActive';
-const TitleBarTopLevelEntry = 'TitleBarTopLevelEntry';
-const TitleBarTopLevelEntryLabel = 'TitleBarTopLevelEntryLabel';
-
-const Button = 1;
-const Div = 4;
-const Text = 12;
-const I = 16;
-const Img = 17;
-const Span = 8;
-
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
-const getItemVirtualDom = item => {
-  // @ts-ignore
-  const {
-    keyboardShortCut,
-    label,
-    isOpen,
-    isFocused
-  } = item;
-  const dom = [];
-  dom.push({
-    type: Div,
-    className: TitleBarTopLevelEntry,
-    ariaHasPopup: true,
-    ariaExpanded: isOpen,
-    role: MenuItem$1,
-    childCount: 1,
-    ariaKeyShortcuts: keyboardShortCut
-  });
-  if (isOpen) {
-    // @ts-ignore
-    dom[0].ariaOwns = 'Menu-0';
-  }
-  if (isFocused) {
-    dom[0].className += ' ' + TitleBarEntryActive;
-    // @ts-ignore
-    dom[0].id = 'TitleBarEntryActive';
-    dom.push({
-      type: Div,
-      className: TitleBarTopLevelEntryLabel,
-      childCount: 1
-    });
-  }
-  dom.push(text(label));
-  return dom;
-};
-const getTitleBarMenuBarItemsVirtualDom = visibleItems => {
-  const dom = visibleItems.flatMap(getItemVirtualDom);
-  return dom;
-};
-
-const activeId = 'TitleBarEntryActive';
-const getTitleBarMenuBarVirtualDom = (visibleItems, focusedIndex) => {
-  return [{
-    type: Div,
-    className: 'Viewlet TitleBarMenuBar',
-    role: MenuBar,
-    tabIndex: 0,
-    childCount: visibleItems.length,
-    onMouseDown: HandleClick,
-    onFocusOut: HandleFocusOut,
-    onFocusIn: HandleFocusIn,
-    onPointerOver: HandlePointerOver,
-    onPointerOut: HandlePointerOut,
-    ariaActivedescendant: focusedIndex === -1 ? '' : activeId
-  }, ...getTitleBarMenuBarItemsVirtualDom(visibleItems)];
-};
-
-const Ellipsis = 'Ellipsis';
-
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
-  }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
-};
-
-const About = 'About';
-const CheckForUpdates = 'Check For Updates';
-const ClearRecentlyOpened = 'Clear Recently Opened';
-const Edit$1 = 'Edit';
-const File$1 = 'File';
-const Go$1 = 'Go';
-const Help$1 = 'Help';
-const MoreDot = 'More ...';
-const OpenProcessExplorer = 'Open Process Explorer';
-const Run$1 = 'Run';
-const Selection$1 = 'Selection';
-const Terminal$1 = 'Terminal';
-const ToggleDeveloperTools = 'Toggle Developer Tools';
-const View$1 = 'View';
-
-const moreDot = () => {
-  return i18nString(MoreDot);
-};
-const clearRecentlyOpened = () => {
-  return i18nString(ClearRecentlyOpened);
-};
-
-const getVisibleTitleBarEntries = (entries, width, focusedIndex, isMenuOpen) => {
-  array(entries);
-  number(width);
-  let total = 0;
-  const visible = [];
-  for (let i = 0; i < entries.length; i++) {
-    const entry = entries[i];
-    total += entry.width;
-    if (total >= width) {
-      break;
-    }
-    const isOpen = i === focusedIndex && isMenuOpen;
-    const isFocused = i === focusedIndex;
-    visible.push({
-      ...entry,
-      isOpen,
-      isFocused
-    });
-  }
-  const hasOverflow = visible.length < entries.length;
-  if (hasOverflow) {
-    const padding = 8;
-    const moreIconWidth = 22;
-    const totalPadding = padding * 2;
-    const hasStillOverflow = total + moreIconWidth + totalPadding > width;
-    if (hasStillOverflow) {
-      visible.pop();
-    }
-    visible.push({
-      ariaLabel: moreDot(),
-      icon: Ellipsis,
-      label: '',
-      width: moreIconWidth + totalPadding
-    });
-  }
-  return visible;
-};
-
-const renderEntries = (oldState, newState) => {
-  const visibleEntries = getVisibleTitleBarEntries(newState.titleBarEntries, newState.width, newState.focusedIndex, newState.isMenuOpen);
-  const dom = getTitleBarMenuBarVirtualDom(visibleEntries, newState.focusedIndex);
-  return ['Viewlet.setDom2', newState.uid, dom];
-};
-
-const SetFocusedIndex = 'setFocusedIndex';
-const SetMenus = 'setMenus';
-
-const renderFocusedIndex = (oldState, newState) => {
-  return ['Viewlet.send', newState.uid, /* method */SetFocusedIndex, /* oldFocusedIndex */oldState.focusedIndex, /* newfocusedIndex */newState.focusedIndex, /* oldIsMenuOpen */oldState.isMenuOpen, /* newIsMenuOpen */newState.isMenuOpen];
-};
+const commandsIds = ['closeMenu', 'handleClickAt', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'handleClick', 'handleFocus', 'handleFocusOut', 'handleKeyArrowDown', 'handleKeyArrowLeft', 'handleKeyArrowRight', 'handleKeyArrowUp', 'handleKeyEnd', 'handleKeyEnter', 'handleKeyEscape', 'handleKeyHome', 'handleKeySpace', 'handleMenuClick', 'handleMenuMouseOver', 'handleMouseOut', 'handleMouseOver', 'handlePointerOver', 'handlePointerOut', 'toggleIndex', 'toggleMenu'];
 
-const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
-  let string = '';
-  if (ctrlKey) {
-    string += 'Ctrl+';
-  }
-  if (shiftKey) {
-    string += 'Shift+';
-  }
-  string += key.toUpperCase();
-  return string;
+const getCommandIds = () => {
+  return commandsIds;
 };
 
-const Separator = 1;
-const None = 0;
-const SubMenu = 4;
-const Checked = 2;
-const Unchecked = 3;
-const Disabled = 5;
-const RestoreFocus = 6;
-const Ignore = 7;
-
 const Backspace$1 = 1;
 const Tab$1 = 2;
 const Enter$1 = 3;
@@ -1215,1480 +999,1770 @@ const Backslash$1 = 91;
 const Star$1 = 131;
 const Plus$1 = 132;
 
-const Unknown = 'Unknown';
-const Backspace = 'Backspace';
-const Tab = 'Tab';
-const Enter = 'Enter';
-const Escape = 'Escape';
-const Space = 'Space';
-const PageUp = 'PageUp';
-const PageDown = 'PageDown';
-const End = 'End';
-const Home = 'Home';
-const LeftArrow = 'LeftArrow';
-const UpArrow = 'UpArrow';
-const RightArrow = 'RightArrow';
-const DownArrow = 'DownArrow';
-const Insert = 'Insert';
-const Delete = 'Delete';
-const Digit0 = '0';
-const Digit1 = '1';
-const Digit2 = '2';
-const Digit3 = '3';
-const Digit4 = '4';
-const Digit5 = '5';
-const Digit6 = '6';
-const Digit7 = '7';
-const Digit8 = '8';
-const Digit9 = '9';
-const KeyA = 'a';
-const KeyB = 'b';
-const KeyC = 'c';
-const KeyD = 'd';
-const KeyE = 'e';
-const KeyF = 'f';
-const KeyG = 'g';
-const KeyH = 'h';
-const KeyI = 'i';
-const KeyJ = 'j';
-const KeyK = 'k';
-const KeyL = 'l';
-const KeyM = 'm';
-const KeyN = 'n';
-const KeyO = 'o';
-const KeyP = 'p';
-const KeyQ = 'q';
-const KeyR = 'r';
-const KeyS = 's';
-const KeyT = 't';
-const KeyU = 'u';
-const KeyV = 'v';
-const KeyW = 'w';
-const KeyX = 'x';
-const KeyY = 'y';
-const KeyZ = 'z';
-const F1 = 'F1';
-const F2 = 'F2';
-const F3 = 'F3';
-const F4 = 'F4';
-const F5 = 'F5';
-const F6 = 'F6';
-const Equal = '=';
-const Comma = ',';
-const Minus = 'Minus';
-const Backquote = 'Backquote';
-const Backslash = 'Backslash';
-const Star = '*';
-const Plus = '+';
+const FocusTitleBarMenuBar = 26;
 
-const getKeyCodeString = keyCode => {
-  switch (keyCode) {
-    case Backspace$1:
-      return Backspace;
-    case Tab$1:
-      return Tab;
-    case Escape$1:
-      return Escape;
-    case Enter$1:
-      return Enter;
-    case Space$1:
-      return Space;
-    case PageUp$1:
-      return PageUp;
-    case PageDown$1:
-      return PageDown;
-    case End$1:
-      return End;
-    case Home$1:
-      return Home;
-    case LeftArrow$1:
-      return LeftArrow;
-    case UpArrow$1:
-      return UpArrow;
-    case RightArrow$1:
-      return RightArrow;
-    case DownArrow$1:
-      return DownArrow;
-    case Insert$1:
-      return Insert;
-    case Delete$1:
-      return Delete;
-    case Digit0$1:
-      return Digit0;
-    case Digit1$1:
-      return Digit1;
-    case Digit2$1:
-      return Digit2;
-    case Digit3$1:
-      return Digit3;
-    case Digit4$1:
-      return Digit4;
-    case Digit5$1:
-      return Digit5;
-    case Digit6$1:
-      return Digit6;
-    case Digit7$1:
-      return Digit7;
-    case Digit8$1:
-      return Digit8;
-    case Digit9$1:
-      return Digit9;
-    case KeyA$1:
-      return KeyA;
-    case KeyB$1:
-      return KeyB;
-    case KeyC$1:
-      return KeyC;
-    case KeyD$1:
-      return KeyD;
-    case KeyE$1:
-      return KeyE;
-    case KeyF$1:
-      return KeyF;
-    case KeyG$1:
-      return KeyG;
-    case KeyH$1:
-      return KeyH;
-    case KeyI$1:
-      return KeyI;
-    case KeyJ$1:
-      return KeyJ;
-    case KeyK$1:
-      return KeyK;
-    case KeyL$1:
-      return KeyL;
-    case KeyM$1:
-      return KeyM;
-    case KeyN$1:
-      return KeyN;
-    case KeyO$1:
-      return KeyO;
-    case KeyP$1:
-      return KeyP;
-    case KeyQ$1:
-      return KeyQ;
-    case KeyR$1:
-      return KeyR;
-    case KeyS$1:
-      return KeyS;
-    case KeyT$1:
-      return KeyT;
-    case KeyU$1:
-      return KeyU;
-    case KeyV$1:
-      return KeyV;
-    case KeyW$1:
-      return KeyW;
-    case KeyX$1:
-      return KeyX;
-    case KeyY$1:
-      return KeyY;
-    case KeyZ$1:
-      return KeyZ;
-    case F1$1:
-      return F1;
-    case F2$1:
-      return F2;
-    case F3$1:
-      return F3;
-    case F4$1:
-      return F4;
-    case F5$1:
-      return F5;
-    case F6$1:
-      return F6;
-    case Backslash$1:
-      return Backslash;
-    case Equal$1:
-      return Equal;
-    case Comma$1:
-      return Comma;
-    case Backquote$1:
-      return Backquote;
-    case Plus$1:
-      return Plus;
-    case Star$1:
-      return Star;
-    case Minus$1:
-      return Minus;
-    default:
-      return Unknown;
+const getKeyBindings = () => {
+  return [{
+    key: DownArrow$1,
+    command: 'TitleBarMenuBar.handleKeyArrowDown',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: UpArrow$1,
+    command: 'TitleBarMenuBar.handleKeyArrowUp',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: RightArrow$1,
+    command: 'TitleBarMenuBar.handleKeyArrowRight',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: LeftArrow$1,
+    command: 'TitleBarMenuBar.handleKeyArrowLeft',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: Space$1,
+    command: 'TitleBarMenuBar.handleKeySpace',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: Home$1,
+    command: 'TitleBarMenuBar.handleKeyHome',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: End$1,
+    command: 'TitleBarMenuBar.handleKeyEnd',
+    when: FocusTitleBarMenuBar
+  }, {
+    key: Escape$1,
+    command: 'TitleBarMenuBar.handleKeyEscape',
+    when: FocusTitleBarMenuBar
+  }];
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings$2 = {
+  Copy: 'Copy',
+  CopyLineDown: 'Copy Line Down',
+  CopyLineUp: 'Copy Line Up',
+  Cut: 'Cut',
+  MoveLineDown: 'Move Line Down',
+  MoveLineUp: 'Move Line Up',
+  Paste: 'Paste',
+  Redo: 'Redo',
+  SelectAll: 'Select All',
+  ToggleBlockComment: 'Toggle Block Comment',
+  ToggleLineComment: 'Toggle Line Comment',
+  Undo: 'Undo'};
+const cut = () => {
+  return i18nString(UiStrings$2.Cut);
+};
+const copy = () => {
+  return i18nString(UiStrings$2.Copy);
+};
+const paste = () => {
+  return i18nString(UiStrings$2.Paste);
+};
+const undo = () => {
+  return i18nString(UiStrings$2.Undo);
+};
+const redo = () => {
+  return i18nString(UiStrings$2.Redo);
+};
+const toggleLineComment = () => {
+  return i18nString(UiStrings$2.ToggleLineComment);
+};
+const toggleBlockComment = () => {
+  return i18nString(UiStrings$2.ToggleBlockComment);
+};
+const selectAll = () => {
+  return i18nString(UiStrings$2.SelectAll);
+};
+const copyLineUp = () => {
+  return i18nString(UiStrings$2.CopyLineUp);
+};
+const copyLineDown = () => {
+  return i18nString(UiStrings$2.CopyLineDown);
+};
+const moveLineUp = () => {
+  return i18nString(UiStrings$2.MoveLineUp);
+};
+const moveLineDown = () => {
+  return i18nString(UiStrings$2.MoveLineDown);
+};
+
+const Edit$1 = 2;
+const File$1 = 5;
+const Go$1 = 6;
+const Help$1 = 7;
+const OpenRecent = 9;
+const Run$1 = 10;
+const Selection$1 = 11;
+const Terminal$1 = 14;
+const TitleBar = 15;
+const View$1 = 16;
+
+const Separator$1 = 1;
+const None$1 = 0;
+const SubMenu = 4;
+const Checked = 2;
+const Unchecked = 3;
+const Disabled = 5;
+const RestoreFocus = 6;
+const Ignore = 7;
+
+const menuEntrySeparator = {
+  id: 'separator',
+  label: '',
+  flags: Separator$1,
+  command: ''
+};
+
+const id$9 = Edit$1;
+const getMenuEntries$d = () => {
+  return [{
+    id: 'undo',
+    label: undo(),
+    flags: Disabled,
+    command: /* TODO */'-1'
+  }, {
+    id: 'redo',
+    label: redo(),
+    flags: Disabled,
+    command: /* TODO */'-1'
+  }, menuEntrySeparator, {
+    id: 'cut',
+    label: cut(),
+    flags: None$1,
+    command: /* Editor.cut */'Editor.cut'
+  }, {
+    id: 'copy',
+    label: copy(),
+    flags: None$1,
+    command: /* Editor.copy */'Editor.copy'
+  }, {
+    id: 'paste',
+    label: paste(),
+    flags: None$1,
+    command: /* Editor.paste */'Editor.paste'
+  }, menuEntrySeparator, {
+    id: 'toggle-line-comment',
+    label: toggleLineComment(),
+    flags: None$1,
+    command: /* Editor.toggleLineComment */'Editor.toggleLineComment'
+  }, {
+    id: 'toggle-block-comment',
+    label: toggleBlockComment(),
+    flags: None$1,
+    command: /* Editor.toggleBlockComment */'Editor.toggleBlockComment'
+  }];
+};
+
+const MenuEntriesEdit = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$d,
+  id: id$9
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings$1 = {
+  NewFile: 'New File',
+  NewWindow: 'New Window',
+  OpenFile: 'Open File',
+  OpenFolder: 'Open Folder',
+  OpenRecent: 'Open Recent',
+  Exit: 'Exit',
+  Save: 'Save',
+  SaveAll: 'Save All'
+};
+const newFile = () => {
+  return i18nString(UiStrings$1.NewFile);
+};
+const newWindow = () => {
+  return i18nString(UiStrings$1.NewWindow);
+};
+const openFile = () => {
+  return i18nString(UiStrings$1.OpenFile);
+};
+const openFolder = () => {
+  return i18nString(UiStrings$1.OpenFolder);
+};
+const openRecent = () => {
+  return i18nString(UiStrings$1.OpenRecent);
+};
+const save = () => {
+  return i18nString(UiStrings$1.Save);
+};
+const saveAll = () => {
+  return i18nString(UiStrings$1.SaveAll);
+};
+const exit = () => {
+  return i18nString(UiStrings$1.Exit);
+};
+
+const Web = 1;
+const Electron = 2;
+const Remote = 3;
+
+const id$8 = File$1;
+const getMenuEntries$c = platform => {
+  const entries = [{
+    id: 'newFile',
+    label: newFile(),
+    flags: None$1,
+    command: '-1'
+  }, {
+    id: 'newWindow',
+    label: newWindow(),
+    flags: None$1,
+    command: /* Window.openNew */'Window.openNew'
+  }, menuEntrySeparator, {
+    id: 'openFile',
+    label: openFile(),
+    flags: None$1,
+    command: 'Dialog.openFile'
+  }, {
+    id: 'openFolder',
+    label: openFolder(),
+    flags: RestoreFocus,
+    command: 'Dialog.openFolder'
+  }, {
+    id: OpenRecent,
+    label: openRecent(),
+    flags: SubMenu,
+    command: ''
+  }, menuEntrySeparator, {
+    id: 'save',
+    label: save(),
+    flags: None$1,
+    command: 'Main.save'
+  }, {
+    id: 'saveAll',
+    label: saveAll(),
+    flags: None$1,
+    command: 'Main.saveAll'
+  }];
+  if (platform === Electron) {
+    entries.push(menuEntrySeparator, {
+      id: 'exit',
+      label: exit(),
+      flags: Ignore,
+      command: 'Chrome.exit'
+    });
+  }
+  return entries;
+};
+
+const MenuEntriesFile = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$c,
+  id: id$8
+};
+
+const id$7 = Go$1;
+const getMenuEntries$b = () => {
+  return [];
+};
+
+const MenuEntriesGo = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$b,
+  id: id$7
+};
+
+const About = 'About';
+const CheckForUpdates = 'Check For Updates';
+const ClearRecentlyOpened = 'Clear Recently Opened';
+const Close = 'Close';
+const Edit = 'Edit';
+const File = 'File';
+const Go = 'Go';
+const Help = 'Help';
+const Maximize = 'Maximize';
+const Minimize = 'Minimize';
+const MoreDot = 'More ...';
+const OpenProcessExplorer = 'Open Process Explorer';
+const Run = 'Run';
+const Selection = 'Selection';
+const Terminal = 'Terminal';
+const ToggleDeveloperTools = 'Toggle Developer Tools';
+const View = 'View';
+
+const toggleDeveloperTools = () => {
+  return i18nString(ToggleDeveloperTools);
+};
+const openProcessExplorer = () => {
+  return i18nString(OpenProcessExplorer);
+};
+const checkForUpdates = () => {
+  return i18nString(CheckForUpdates);
+};
+const about = () => {
+  return i18nString(About);
+};
+
+const isAutoUpdateSupported = platform => {
+  if (platform !== Electron) {
+    return false;
+  }
+  return false;
+};
+
+const id$6 = Help$1;
+const getMenuEntries$a = async platform => {
+  const autoUpdateSupported = isAutoUpdateSupported(platform);
+  const entries = [];
+  if (platform !== Web) {
+    entries.push({
+      id: 'toggleDeveloperTools',
+      label: toggleDeveloperTools(),
+      flags: None$1,
+      command: 'Developer.toggleDeveloperTools'
+    }, {
+      id: 'openProcessExplorer',
+      label: openProcessExplorer(),
+      flags: RestoreFocus,
+      command: 'Developer.openProcessExplorer'
+    });
+  }
+  if (autoUpdateSupported) {
+    entries.push(menuEntrySeparator, {
+      id: 'checkForUpdates',
+      label: checkForUpdates(),
+      flags: RestoreFocus,
+      command: 'AutoUpdater.checkForUpdates'
+    });
+  }
+  if (entries.length > 0) {
+    entries.push(menuEntrySeparator);
   }
+  entries.push({
+    id: 'about',
+    label: about(),
+    flags: RestoreFocus,
+    command: 'About.showAbout'
+  });
+  return entries;
 };
 
-const CtrlCmd = 1 << 11 >>> 0;
-const Shift = 1 << 10 >>> 0;
-
-const parseKey = rawKey => {
-  number(rawKey);
-  const isCtrl = Boolean(rawKey & CtrlCmd);
-  const isShift = Boolean(rawKey & Shift);
-  const keyCode = rawKey & 0x00_00_00_ff;
-  const key = getKeyCodeString(keyCode);
-  return {
-    key,
-    isCtrl,
-    isShift
-  };
+const MenuEntriesHelp = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$a,
+  id: id$6
 };
 
-const separator = {
-  type: Div,
-  className: MenuItemSeparator,
-  role: Separator$1,
-  childCount: 1
-};
-const separatorLine = {
-  type: Div,
-  className: MenuItemSeparatorLine,
-  childCount: 0
-};
-const checkboxUnchecked = {
-  type: Div,
-  className: MenuItem,
-  role: MenuItemCheckBox,
-  ariaChecked: false,
-  tabIndex: -1,
-  childCount: 1
-};
-const checkboxChecked = {
-  type: Div,
-  className: `${MenuItem} MenuItemCheckMark`,
-  role: MenuItemCheckBox,
-  ariaChecked: true,
-  tabIndex: -1,
-  childCount: 2
+const state$1 = {
+  rpc: undefined
 };
-const disabled = {
-  type: Div,
-  className: MenuItem,
-  role: MenuItem$1,
-  tabIndex: -1,
-  disabled: true,
-  childCount: 1
+const invoke = (method, ...params) => {
+  const {
+    rpc
+  } = state$1;
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
 };
-const arrowRight = {
-  type: Div,
-  className: MenuItemSubMenuArrowRight,
-  childCount: 0
+const setRpc = rpc => {
+  state$1.rpc = rpc;
 };
-const getMenuItemSeparatorDom = menuItem => {
-  return [separator, separatorLine];
+
+const getRecentlyOpened = () => {
+  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
-const getMenuItemCheckedDom = menuItem => {
-  const {
-    label
-  } = menuItem;
-  return [checkboxChecked, {
-    type: Div,
-    className: 'MenuItemCheckmarkIcon MaskIconCheck'
-  }, text(label)];
+
+const getTitle = uri => {
+  if (!uri) {
+    return '';
+  }
+  return uri;
 };
-const getMenuItemUncheckedDom = menuItem => {
-  const {
-    label
-  } = menuItem;
-  return [checkboxUnchecked, text(label)];
+
+const moreDot = () => {
+  return i18nString(MoreDot);
 };
-const getMenuItemDisabledDom = menuItem => {
-  const {
-    label
-  } = menuItem;
-  return [disabled, text(label)];
+const clearRecentlyOpened = () => {
+  return i18nString(ClearRecentlyOpened);
 };
-const getMenuItemDefaultDom = menuItem => {
-  const {
+
+const MAX_MENU_RECENT_ENTRIES = 10;
+const toMenuItem = folder => {
+  const label = getTitle(folder);
+  return {
     label,
-    isFocused,
-    key
-  } = menuItem;
-  let className = MenuItem;
-  if (isFocused) {
-    className += ' ' + MenuItemFocused;
-  }
-  const dom = [];
-  dom.push({
-    type: Div,
-    className,
-    role: MenuItem$1,
-    tabIndex: -1,
-    childCount: 1
-  }, text(label));
-  if (key) {
-    dom[0].childCount++;
-    const parsedKey = parseKey(key);
-    const keyBindingsString = getKeyBindingString(parsedKey.key, false, parsedKey.isCtrl, parsedKey.isShift);
-    dom.push({
-      type: Span,
-      className: 'MenuItemKeyBinding',
-      childCount: 1
-    }, text(keyBindingsString));
-  }
-  return dom;
+    flags: None$1,
+    command: 'Workspace.setPath',
+    args: [folder]
+  };
 };
-const getMenuItemSubMenuDom = menuItem => {
-  const {
-    label,
-    isFocused,
-    isExpanded,
-    level
-  } = menuItem;
-  let className = MenuItem;
-  className += ' ' + MenuItemSubMenu;
-  if (isFocused) {
-    className += ' ' + MenuItemFocused;
+const id$5 = OpenRecent;
+const getMenuEntries$9 = async () => {
+  const allItems = await getRecentlyOpened();
+  const itemsToShow = allItems.slice(0, MAX_MENU_RECENT_ENTRIES);
+  const items = [];
+  if (itemsToShow.length > 0) {
+    items.push(...itemsToShow.map(toMenuItem), menuEntrySeparator);
   }
-  return [{
-    type: Div,
-    className,
-    role: MenuItem$1,
-    tabIndex: -1,
-    ariaHasPopup: true,
-    ariaExpanded: isExpanded,
-    ariaOwns: isExpanded ? `Menu-${level + 1}` : undefined,
-    childCount: 2
-  }, text(label), arrowRight];
+  items.push({
+    id: 'more',
+    label: moreDot(),
+    flags: None$1,
+    command: 'QuickPick.showRecent'
+  }, menuEntrySeparator, {
+    id: 'clearRecentlyOpened',
+    label: clearRecentlyOpened(),
+    flags: None$1,
+    command: 'RecentlyOpened.clearRecentlyOpened'
+  });
+  return items;
 };
-const getMenuItemVirtualDom = menuItem => {
-  const {
-    flags
-  } = menuItem;
-  switch (flags) {
-    case None:
-    case RestoreFocus:
-    case Ignore:
-      return getMenuItemDefaultDom(menuItem);
-    case Separator:
-      return getMenuItemSeparatorDom();
-    case Checked:
-      return getMenuItemCheckedDom(menuItem);
-    case Unchecked:
-      return getMenuItemUncheckedDom(menuItem);
-    case Disabled:
-      return getMenuItemDisabledDom(menuItem);
-    case SubMenu:
-      return getMenuItemSubMenuDom(menuItem);
-    default:
-      return [];
-  }
+
+const MenuEntriesOpenRecent = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$9,
+  id: id$5
 };
-const getMenuVirtualDom = menuItems => {
-  const dom = [];
-  dom.push({
-    type: Div,
-    className: Menu,
-    role: Menu$1,
-    tabIndex: -1,
-    childCount: menuItems.length
-  });
-  dom.push(...menuItems.flatMap(getMenuItemVirtualDom));
-  return dom;
+
+const id$4 = Run$1;
+const getMenuEntries$8 = () => {
+  return [];
 };
 
-const getVisible = (items, focusedIndex, expanded, level) => {
-  const visibleItems = [];
-  const {
-    length
-  } = items;
-  for (let i = 0; i < length; i++) {
-    const item = items[i];
-    const {
-      flags,
-      label
-    } = item;
-    visibleItems.push({
-      label,
-      flags,
-      isFocused: i === focusedIndex,
-      isExpanded: i === focusedIndex && expanded,
-      level,
-      key: item.key
-    });
-  }
-  return visibleItems;
+const MenuEntriesRun = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$8,
+  id: id$4
 };
 
-const renderMEnus = (oldState, newState) => {
-  const oldMenus = oldState.menus;
-  const newMenus = newState.menus;
-  const oldLength = oldMenus.length;
-  const newLength = newMenus.length;
-  const commonLength = Math.min(oldLength, newLength);
-  const changes = [];
-  for (let i = 0; i < commonLength; i++) {
-    const oldMenu = oldMenus[i];
-    const newMenu = newMenus[i];
-    if (oldMenu !== newMenu) {
-      const visible = getVisible(newMenu.items, newMenu.focusedIndex, newMenu.expanded, newMenu.level);
-      const dom = getMenuVirtualDom(visible).slice(1);
-      changes.push([/* method */'updateMenu', newMenu, /* newLength */newLength, dom]);
-    }
-  }
-  const difference = newLength - oldLength;
-  if (difference > 0) {
-    const newMenu = newMenus.at(-1);
-    const visible = getVisible(newMenu.items, newMenu.focusedIndex, newMenu.expanded, newMenu.level);
-    const dom = getMenuVirtualDom(visible).slice(1);
-    changes.push(['addMenu', newMenu, dom]);
-  } else if (difference < 0) {
-    changes.push(['closeMenus', newLength]);
-  }
-  return ['Viewlet.send', newState.uid, /* method */SetMenus, /* changes */changes, newState.uid];
+const id$3 = Selection$1;
+const getMenuEntries$7 = () => {
+  return [{
+    id: 'selectAll',
+    label: selectAll(),
+    flags: None$1,
+    command: 'Editor.selectAll'
+  }, {
+    id: 'copyLineUp',
+    label: copyLineUp(),
+    flags: None$1,
+    command: 'Editor.copyLineUp'
+  }, {
+    id: 'copyLineDown',
+    label: copyLineDown(),
+    flags: None$1,
+    command: 'Editor.copyLineDown'
+  }, {
+    id: 'moveLineUp',
+    label: moveLineUp(),
+    flags: Disabled,
+    command: 'Editor.moveLineUp'
+  }, {
+    id: 'moveLineDown',
+    label: moveLineDown(),
+    flags: Disabled,
+    command: 'Editor.moveLineDown'
+  }];
 };
 
-const getRenderer = diffType => {
-  switch (diffType) {
-    case RenderEntries:
-      return renderEntries;
-    case RenderFocusedIndex:
-      return renderFocusedIndex;
-    case RenderMenus:
-      return renderMEnus;
-    default:
-      throw new Error('unknown renderer');
-  }
+const MenuEntriesSelection = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$7,
+  id: id$3
 };
 
-const applyRender = (oldState, newState, diffResult) => {
-  const commands = [];
-  for (const item of diffResult) {
-    const fn = getRenderer(item);
-    commands.push(fn(oldState, newState));
-  }
-  return commands;
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  NewTerminal: 'New Terminal'
 };
-
-const doRender = async uid => {
-  const {
-    oldState,
-    newState
-  } = get(uid);
-  const diffResult = diff(oldState, newState);
-  const commands = applyRender(oldState, newState, diffResult);
-  return commands;
+const newTerminal = () => {
+  return i18nString(UiStrings.NewTerminal);
 };
 
-const commandsIds = ['closeMenu', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'handleClick', 'handleFocus', 'handleKeyArrowDown', 'handleKeyArrowLeft', 'handleKeyArrowRight', 'handleKeyArrowUp', 'handleKeyEnd', 'handleKeyEnter', 'handleKeyEscape', 'handleKeyHome', 'handleKeySpace', 'handleMenuClick', 'handleMenuMouseOver', 'handleMouseOut', 'handleMouseOver', 'handlePointerOver', 'handlePointerOut', 'toggleIndex', 'toggleMenu'];
+const id$2 = Terminal$1;
+const getMenuEntries$6 = () => {
+  return [{
+    id: 'newTerminal',
+    label: newTerminal(),
+    flags: None$1,
+    command: 'Layout.togglePanel',
+    args: ['Terminal']
+  }];
+};
 
-const getCommandIds = () => {
-  return commandsIds;
+const MenuEntriesTerminal = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$6,
+  id: id$2
 };
 
-const FocusTitleBarMenuBar = 26;
+const file = () => {
+  return i18nString(File);
+};
+const edit = () => {
+  return i18nString(Edit);
+};
+const selection = () => {
+  return i18nString(Selection);
+};
+const view = () => {
+  return i18nString(View);
+};
+const go = () => {
+  return i18nString(Go);
+};
+const run = () => {
+  return i18nString(Run);
+};
+const terminal = () => {
+  return i18nString(Terminal);
+};
+const help = () => {
+  return i18nString(Help);
+};
+const minimize$1 = () => {
+  return i18nString(Minimize);
+};
+const maximize$1 = () => {
+  return i18nString(Maximize);
+};
+const close$1 = () => {
+  return i18nString(Close);
+};
 
-const getKeyBindings = () => {
+const getMenuEntries$5 = () => {
   return [{
-    key: DownArrow$1,
-    command: 'TitleBarMenuBar.handleKeyArrowDown',
-    when: FocusTitleBarMenuBar
+    id: File$1,
+    label: file(),
+    flags: SubMenu
   }, {
-    key: UpArrow$1,
-    command: 'TitleBarMenuBar.handleKeyArrowUp',
-    when: FocusTitleBarMenuBar
+    id: Edit$1,
+    label: edit(),
+    flags: SubMenu
   }, {
-    key: RightArrow$1,
-    command: 'TitleBarMenuBar.handleKeyArrowRight',
-    when: FocusTitleBarMenuBar
+    id: Selection$1,
+    label: selection(),
+    flags: SubMenu
   }, {
-    key: LeftArrow$1,
-    command: 'TitleBarMenuBar.handleKeyArrowLeft',
-    when: FocusTitleBarMenuBar
+    id: View$1,
+    label: view(),
+    flags: SubMenu
   }, {
-    key: Space$1,
-    command: 'TitleBarMenuBar.handleKeySpace',
-    when: FocusTitleBarMenuBar
+    id: Go$1,
+    label: go(),
+    flags: SubMenu
   }, {
-    key: Home$1,
-    command: 'TitleBarMenuBar.handleKeyHome',
-    when: FocusTitleBarMenuBar
+    id: Run$1,
+    label: run(),
+    keyboardShortCut: 'Alt+r',
+    flags: SubMenu
   }, {
-    key: End$1,
-    command: 'TitleBarMenuBar.handleKeyEnd',
-    when: FocusTitleBarMenuBar
+    id: Terminal$1,
+    label: terminal(),
+    keyboardShortCut: 'Alt+t',
+    flags: SubMenu
   }, {
-    key: Escape$1,
-    command: 'TitleBarMenuBar.handleKeyEscape',
-    when: FocusTitleBarMenuBar
+    id: Help$1,
+    label: help(),
+    keyboardShortCut: 'Alt+h',
+    flags: SubMenu
   }];
 };
 
-/**
- * @enum {string}
- */
-const UiStrings$2 = {
-  Copy: 'Copy',
-  CopyLineDown: 'Copy Line Down',
-  CopyLineUp: 'Copy Line Up',
-  Cut: 'Cut',
-  MoveLineDown: 'Move Line Down',
-  MoveLineUp: 'Move Line Up',
-  Paste: 'Paste',
-  Redo: 'Redo',
-  SelectAll: 'Select All',
-  ToggleBlockComment: 'Toggle Block Comment',
-  ToggleLineComment: 'Toggle Line Comment',
-  Undo: 'Undo'};
-const cut = () => {
-  return i18nString(UiStrings$2.Cut);
+const getMenuEntries$4 = () => {
+  return [{
+    id: File$1,
+    label: file(),
+    flags: None$1
+  }, {
+    id: Edit$1,
+    label: edit(),
+    flags: None$1
+  }, {
+    id: Selection$1,
+    label: selection(),
+    flags: None$1
+  }, {
+    id: View$1,
+    label: view(),
+    flags: None$1
+  }, {
+    id: Go$1,
+    label: go(),
+    flags: None$1
+  }, {
+    id: Help$1,
+    label: help(),
+    flags: None$1
+  }];
 };
-const copy = () => {
-  return i18nString(UiStrings$2.Copy);
+
+const getFn = platform => {
+  switch (platform) {
+    case Web:
+      return getMenuEntries$4;
+    default:
+      return getMenuEntries$5;
+  }
 };
-const paste = () => {
-  return i18nString(UiStrings$2.Paste);
+const id$1 = TitleBar;
+const getMenuEntries$3 = async platform => {
+  const fn = getFn(platform);
+  return fn();
 };
-const undo = () => {
-  return i18nString(UiStrings$2.Undo);
+
+const MenuEntriesTitleBar = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$3,
+  id: id$1
 };
-const redo = () => {
-  return i18nString(UiStrings$2.Redo);
+
+const id = View$1;
+const getMenuEntries$2 = () => {
+  return [];
 };
-const toggleLineComment = () => {
-  return i18nString(UiStrings$2.ToggleLineComment);
+
+const MenuEntriesView = {
+  __proto__: null,
+  getMenuEntries: getMenuEntries$2,
+  id
 };
-const toggleBlockComment = () => {
-  return i18nString(UiStrings$2.ToggleBlockComment);
+
+const menus$1 = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHelp, MenuEntriesRun, MenuEntriesSelection, MenuEntriesTerminal, MenuEntriesTitleBar, MenuEntriesView, MenuEntriesOpenRecent];
+
+const getMenuIds = () => {
+  return menus$1.map(menu => menu.id);
 };
-const selectAll = () => {
-  return i18nString(UiStrings$2.SelectAll);
+const getMenuEntries$1 = (id, platform) => {
+  const menu = menus$1.find(item => item.id === id);
+  if (!menu) {
+    return [];
+  }
+  return menu.getMenuEntries(platform);
 };
-const copyLineUp = () => {
-  return i18nString(UiStrings$2.CopyLineUp);
+
+const getTitleBarButtonsWeb = () => {
+  return [];
+};
+const getTitleBarButtonsRemote = () => {
+  return [];
+};
+const getTitleBarButtonsElectron = (controlsOverlayEnabled, titleBarStyleCustom) => {
+  if (controlsOverlayEnabled) {
+    return [];
+  }
+  if (titleBarStyleCustom) {
+    // TODO don't render title bar buttons on windows when electron window controls overlay is enabled
+    return [{
+      label: minimize$1(),
+      icon: 'Minimize',
+      id: 'Minimize',
+      onClick: 'handleClickMinimize'
+    }, {
+      label: maximize$1(),
+      icon: 'Maximize',
+      id: 'ToggleMaximize',
+      onClick: 'handleClickToggleMaximize'
+    }, {
+      label: close$1(),
+      icon: 'ChromeClose',
+      id: 'Close',
+      onClick: 'handleClickClose'
+    }];
+  }
+  return [];
+};
+const getTitleBarButtons = (platform, controlsOverlayEnabled, titleBarStyleCustom) => {
+  switch (platform) {
+    case Electron:
+      return getTitleBarButtonsElectron(controlsOverlayEnabled, titleBarStyleCustom);
+    case Web:
+      return getTitleBarButtonsWeb();
+    case Remote:
+      return getTitleBarButtonsRemote();
+    default:
+      return [];
+  }
+};
+
+const MaskIconCheck = 'MaskIconCheck';
+const Menu$1 = 'Menu';
+const MenuItem$1 = 'MenuItem';
+const MenuItemCheckMark = 'MenuItemCheckMark';
+const MenuItemCheckmarkIcon = 'MenuItemCheckmarkIcon';
+const MenuItemFocused = 'MenuItemFocused';
+const MenuItemKeyBinding = 'MenuItemKeyBinding';
+const MenuItemSeparator = 'MenuItemSeparator';
+const MenuItemSeparatorLine = 'MenuItemSeparatorLine';
+const MenuItemSubMenu = 'MenuItemSubMenu';
+const MenuItemSubMenuArrowRight = 'MenuItemSubMenuArrowRight';
+const TitleBarButtons = 'TitleBarButtons';
+const TitleBarEntryActive = 'TitleBarEntryActive';
+const TitleBarIcon = 'TitleBarIcon';
+const TitleBarIconIcon = 'TitleBarIconIcon';
+const TitleBarMenuBar$1 = 'TitleBarMenuBar';
+const TitleBarTopLevelEntry = 'TitleBarTopLevelEntry';
+const TitleBarTopLevelEntryLabel = 'TitleBarTopLevelEntryLabel';
+const Viewlet = 'Viewlet';
+
+const Menu = 'menu';
+const MenuBar = 'menubar';
+const MenuItem = 'menuitem';
+const MenuItemCheckBox = 'menuitemcheckbox';
+const None = 'none';
+const Separator = 'separator';
+
+const Button = 1;
+const Div = 4;
+const I = 16;
+const Img = 17;
+const Span = 8;
+
+const getIconVirtualDom = (icon, type = Div) => {
+  return {
+    type,
+    className: `MaskIcon MaskIcon${icon}`,
+    role: None,
+    childCount: 0
+  };
 };
-const copyLineDown = () => {
-  return i18nString(UiStrings$2.CopyLineDown);
+
+const createTitleBarButton = button => {
+  const {
+    id,
+    icon,
+    label,
+    onClick
+  } = button;
+  const dom = [{
+    type: Button,
+    className: `TitleBarButton TitleBarButton${id}`,
+    ariaLabel: label,
+    childCount: 1,
+    onClick
+  }, getIconVirtualDom(icon, I)];
+  return dom;
 };
-const moveLineUp = () => {
-  return i18nString(UiStrings$2.MoveLineUp);
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
 };
-const moveLineDown = () => {
-  return i18nString(UiStrings$2.MoveLineDown);
+const Text = 12;
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
 };
 
-const Edit = 2;
-const File = 5;
-const Go = 6;
-const Help = 7;
-const OpenRecent = 9;
-const Run = 10;
-const Selection = 11;
-const Terminal = 14;
-const TitleBar = 15;
-const View = 16;
-
-const menuEntrySeparator = {
-  id: 'separator',
-  label: '',
-  flags: Separator,
-  command: ''
+const getTitleBarButtonsVirtualDom = buttons => {
+  const dom = [{
+    type: Div,
+    className: mergeClassNames(Viewlet, TitleBarButtons),
+    childCount: buttons.length
+  }, ...buttons.flatMap(createTitleBarButton)];
+  return dom;
 };
 
-const id$9 = Edit;
-const getMenuEntries$d = () => {
+const getTitleBarIconVirtualDom = iconSrc => {
   return [{
-    id: 'undo',
-    label: undo(),
-    flags: Disabled,
-    command: /* TODO */-1
-  }, {
-    id: 'redo',
-    label: redo(),
-    flags: Disabled,
-    command: /* TODO */-1
-  }, menuEntrySeparator, {
-    id: 'cut',
-    label: cut(),
-    flags: None,
-    command: /* Editor.cut */'Editor.cut'
-  }, {
-    id: 'copy',
-    label: copy(),
-    flags: None,
-    command: /* Editor.copy */'Editor.copy'
-  }, {
-    id: 'paste',
-    label: paste(),
-    flags: None,
-    command: /* Editor.paste */'Editor.paste'
-  }, menuEntrySeparator, {
-    id: 'toggle-line-comment',
-    label: toggleLineComment(),
-    flags: None,
-    command: /* Editor.toggleLineComment */'Editor.toggleLineComment'
+    type: Div,
+    className: mergeClassNames(Viewlet, TitleBarIcon),
+    childCount: 1
   }, {
-    id: 'toggle-block-comment',
-    label: toggleBlockComment(),
-    flags: None,
-    command: /* Editor.toggleBlockComment */'Editor.toggleBlockComment'
+    type: Img,
+    className: TitleBarIconIcon,
+    src: iconSrc,
+    alt: '',
+    childCount: 0
   }];
 };
 
-const MenuEntriesEdit = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$d,
-  id: id$9
-};
+const HandleClick = 'handleClick';
+const HandleClickMinimize = 'handleClickMinimize';
+const HandleClickToggleClose = 'handleClickToggleClose';
+const HandleClickToggleMaximize = 'handleClickToggleMaximize';
+const HandleFocusIn = 'handleFocusIn';
+const HandleFocusOut = 'handleFocusOut';
+const HandlePointerOut = 'handlePointerOut';
+const HandlePointerOver = 'handlePointerOver';
+const HandleMenuClick = 'handleMenuClick';
+const HandleMenuMouseOver = 'handleMenuMouseOver';
 
-/**
- * @enum {string}
- */
-const UiStrings$1 = {
-  NewFile: 'New File',
-  NewWindow: 'New Window',
-  OpenFile: 'Open File',
-  OpenFolder: 'Open Folder',
-  OpenRecent: 'Open Recent',
-  Exit: 'Exit',
-  Save: 'Save',
-  SaveAll: 'Save All'
-};
-const newFile = () => {
-  return i18nString(UiStrings$1.NewFile);
-};
-const newWindow = () => {
-  return i18nString(UiStrings$1.NewWindow);
+const getItemVirtualDom = item => {
+  // @ts-ignore
+  const {
+    keyboardShortCut,
+    label,
+    isOpen,
+    isFocused
+  } = item;
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: TitleBarTopLevelEntry,
+    ariaHasPopup: true,
+    ariaExpanded: isOpen,
+    role: MenuItem,
+    childCount: 1,
+    ariaKeyShortcuts: keyboardShortCut
+  });
+  if (isOpen) {
+    // @ts-ignore
+    dom[0].ariaOwns = 'Menu-0';
+  }
+  if (isFocused) {
+    dom[0].className += ' ' + TitleBarEntryActive;
+    // @ts-ignore
+    dom[0].id = 'TitleBarEntryActive';
+    dom.push({
+      type: Div,
+      className: TitleBarTopLevelEntryLabel,
+      childCount: 1
+    });
+  }
+  dom.push(text(label));
+  return dom;
 };
-const openFile = () => {
-  return i18nString(UiStrings$1.OpenFile);
+const getTitleBarMenuBarItemsVirtualDom = visibleItems => {
+  const dom = visibleItems.flatMap(getItemVirtualDom);
+  return dom;
 };
-const openFolder = () => {
-  return i18nString(UiStrings$1.OpenFolder);
+
+const activeId = 'TitleBarEntryActive';
+const getTitleBarMenuBarVirtualDom = (visibleItems, focusedIndex) => {
+  return [{
+    type: Div,
+    className: mergeClassNames(Viewlet, TitleBarMenuBar$1),
+    role: MenuBar,
+    tabIndex: 0,
+    childCount: visibleItems.length,
+    onMouseDown: HandleClick,
+    onFocusOut: HandleFocusOut,
+    onFocusIn: HandleFocusIn,
+    onPointerOver: HandlePointerOver,
+    onPointerOut: HandlePointerOut,
+    ariaActivedescendant: focusedIndex === -1 ? '' : activeId
+  }, ...getTitleBarMenuBarItemsVirtualDom(visibleItems)];
 };
-const openRecent = () => {
-  return i18nString(UiStrings$1.OpenRecent);
+
+const getTitleVirtualDom = title => {
+  return [text(title)];
 };
-const save = () => {
-  return i18nString(UiStrings$1.Save);
+
+const maximize = async () => {
+  await invoke('ElectronWindow.unmaximize');
 };
-const saveAll = () => {
-  return i18nString(UiStrings$1.SaveAll);
+const minimize = async () => {
+  await invoke('ElectronWindow.minimize');
 };
-const exit = () => {
-  return i18nString(UiStrings$1.Exit);
+const close = async () => {
+  await invoke('ElectronWindow.close');
 };
 
-const Web = 1;
-const Electron = 2;
-
-const id$8 = File;
-const getMenuEntries$c = platform => {
-  const entries = [{
-    id: 'newFile',
-    label: newFile(),
-    flags: None,
-    command: -1
-  }, {
-    id: 'newWindow',
-    label: newWindow(),
-    flags: None,
-    command: /* Window.openNew */'Window.openNew'
-  }, menuEntrySeparator, {
-    id: 'openFile',
-    label: openFile(),
-    flags: None,
-    command: 'Dialog.openFile'
-  }, {
-    id: 'openFolder',
-    label: openFolder(),
-    flags: RestoreFocus,
-    command: 'Dialog.openFolder'
-  }, {
-    id: OpenRecent,
-    label: openRecent(),
-    flags: SubMenu,
-    command: ''
-  }, menuEntrySeparator, {
-    id: 'save',
-    label: save(),
-    flags: None,
-    command: 'Main.save'
-  }, {
-    id: 'saveAll',
-    label: saveAll(),
-    flags: None,
-    command: 'Main.saveAll'
-  }];
-  if (platform === Electron) {
-    entries.push(menuEntrySeparator, {
-      id: 'exit',
-      label: exit(),
-      flags: Ignore,
-      command: 'Chrome.exit'
-    });
-  }
-  return entries;
+const handleClickClose = async state => {
+  await close();
+  return state;
 };
 
-const MenuEntriesFile = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$c,
-  id: id$8
+const handleClickMinimize = async state => {
+  await minimize();
+  return state;
 };
 
-const id$7 = Go;
-const getMenuEntries$b = () => {
-  return [];
+const handleClickToggleMaximize = async state => {
+  const fn = maximize;
+  await fn();
+  return state;
 };
 
-const MenuEntriesGo = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$b,
-  id: id$7
+const handleClick$1 = (state, className) => {
+  if (className.includes('Minimize')) {
+    return handleClickMinimize(state);
+  }
+  if (className.includes('Maximize') || className.includes('Restore')) {
+    return handleClickToggleMaximize(state);
+  }
+  if (className.includes('Close')) {
+    return handleClickClose(state);
+  }
+  return state;
 };
 
-const toggleDeveloperTools = () => {
-  return i18nString(ToggleDeveloperTools);
-};
-const openProcessExplorer = () => {
-  return i18nString(OpenProcessExplorer);
-};
-const checkForUpdates = () => {
-  return i18nString(CheckForUpdates);
-};
-const about = () => {
-  return i18nString(About);
+const handleContextMenu = state => {
+  return state;
 };
 
-const isAutoUpdateSupported = platform => {
-  if (platform !== Electron) {
-    return false;
+const getTitleBarIndexFromPosition = (titleBarEntries, x, y) => {
+  let currentX = 0;
+  for (let i = 0; i < titleBarEntries.length; i++) {
+    const entry = titleBarEntries[i];
+    const entryWidth = entry.width;
+    if (x >= currentX && x < currentX + entryWidth) {
+      return i;
+    }
+    currentX += entryWidth;
   }
-  return false;
+  return -1;
 };
 
-const id$6 = Help;
-const getMenuEntries$a = async platform => {
-  const autoUpdateSupported = isAutoUpdateSupported(platform);
-  const entries = [];
-  if (platform !== Web) {
-    entries.push({
-      id: 'toggleDeveloperTools',
-      label: toggleDeveloperTools(),
-      flags: None,
-      command: 'Developer.toggleDeveloperTools'
-    }, {
-      id: 'openProcessExplorer',
-      label: openProcessExplorer(),
-      flags: RestoreFocus,
-      command: 'Developer.openProcessExplorer'
-    });
-  }
-  if (autoUpdateSupported) {
-    entries.push(menuEntrySeparator, {
-      id: 'checkForUpdates',
-      label: checkForUpdates(),
-      flags: RestoreFocus,
-      command: 'AutoUpdater.checkForUpdates'
-    });
-  }
-  if (entries.length > 0) {
-    entries.push(menuEntrySeparator);
+const getTotalWidth = entries => {
+  let total = 0;
+  for (const entry of entries) {
+    total += entry.width;
   }
-  entries.push({
-    id: 'about',
-    label: about(),
-    flags: RestoreFocus,
-    command: 'About.showAbout'
-  });
-  return entries;
+  return total;
 };
 
-const MenuEntriesHelp = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$a,
-  id: id$6
+// TODO lazyload menuEntries and use Command.execute (maybe)
+const CONTEXT_MENU_ITEM_HEIGHT = 26;
+const CONTEXT_MENU_SEPARATOR_HEIGHT = 11;
+const CONTEXT_MENU_PADDING = 8;
+const getMenuHeight = items => {
+  let height = CONTEXT_MENU_PADDING;
+  for (const item of items) {
+    switch (item.flags) {
+      case Separator$1:
+        height += CONTEXT_MENU_SEPARATOR_HEIGHT;
+        break;
+      default:
+        height += CONTEXT_MENU_ITEM_HEIGHT;
+        break;
+    }
+  }
+  return height;
 };
 
-const state$1 = {
-  rpc: undefined
+// TODO lazyload menuEntries and use Command.execute (maybe)
+const MENU_WIDTH = 150;
+const CONTEXT_MENU_WIDTH = 250;
+const getMenuWidth = () => {
+  return CONTEXT_MENU_WIDTH;
 };
-const invoke = (method, ...params) => {
-  const {
-    rpc
-  } = state$1;
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
+
+// TODO difference between focusing with mouse or keyboard
+// with mouse -> open submenu
+// with keyboard -> don't open submenu, only focus
+
+const getIndexToFocusNextStartingAt = (items, startIndex) => {
+  for (let i = startIndex; i < startIndex + items.length; i++) {
+    const index = i % items.length;
+    const item = items[index];
+    if (canBeFocused(item)) {
+      return index;
+    }
+  }
+  return -1;
 };
-const setRpc = rpc => {
-  state$1.rpc = rpc;
+const getIndexToFocusFirst = items => {
+  return getIndexToFocusNextStartingAt(items, 0);
 };
-
-const getRecentlyOpened = () => {
-  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+const getIndexToFocusLast = items => {
+  return getIndexToFocusPreviousStartingAt(items, items.length - 1);
 };
 
-const getTitle = uri => {
-  if (!uri) {
-    return '';
+// TODO this code seems a bit too complicated, maybe it can be simplified
+const getIndexToFocusPreviousStartingAt = (items, startIndex) => {
+  for (let i = startIndex; i > startIndex - items.length; i--) {
+    const index = (i + items.length) % items.length;
+    const item = items[index];
+    if (canBeFocused(item)) {
+      return index;
+    }
   }
-  return uri;
+  return -1;
 };
-
-const MAX_MENU_RECENT_ENTRIES = 10;
-const toMenuItem = folder => {
-  const label = getTitle(folder);
-  return {
-    label,
-    flags: None,
-    command: 'Workspace.setPath',
-    args: [folder]
-  };
+const getIndexToFocusPrevious = menu => {
+  const startIndex = menu.focusedIndex === -1 ? menu.items.length - 1 : menu.focusedIndex - 1;
+  return getIndexToFocusPreviousStartingAt(menu.items, startIndex);
 };
-const id$5 = OpenRecent;
-const getMenuEntries$9 = async () => {
-  const allItems = await getRecentlyOpened();
-  const itemsToShow = allItems.slice(0, MAX_MENU_RECENT_ENTRIES);
-  const items = [];
-  if (itemsToShow.length > 0) {
-    items.push(...itemsToShow.map(toMenuItem), menuEntrySeparator);
+const canBeFocused = item => {
+  switch (item.flags) {
+    case Separator$1:
+    case Disabled:
+      return false;
+    default:
+      return true;
   }
-  items.push({
-    id: 'more',
-    label: moreDot(),
-    flags: None,
-    command: 'QuickPick.showRecent'
-  }, menuEntrySeparator, {
-    id: 'clearRecentlyOpened',
-    label: clearRecentlyOpened(),
-    flags: None,
-    command: 'RecentlyOpened.clearRecentlyOpened'
-  });
-  return items;
 };
-
-const MenuEntriesOpenRecent = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$9,
-  id: id$5
+const getIndexToFocusNext = menu => {
+  const startIndex = menu.focusedIndex + 1;
+  return getIndexToFocusNextStartingAt(menu.items, startIndex);
 };
 
-const id$4 = Run;
-const getMenuEntries$8 = () => {
-  return [];
-};
+// TODO handle printable letter and focus item that starts with that letter
 
-const MenuEntriesRun = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$8,
-  id: id$4
-};
+// TODO pageup / pagedown keys
 
-const id$3 = Selection;
-const getMenuEntries$7 = () => {
-  return [{
-    id: 'selectAll',
-    label: selectAll(),
-    flags: None,
-    command: 'Editor.selectAll'
-  }, {
-    id: 'copyLineUp',
-    label: copyLineUp(),
-    flags: None,
-    command: 'Editor.copyLineUp'
-  }, {
-    id: 'copyLineDown',
-    label: copyLineDown(),
-    flags: None,
-    command: 'Editor.copyLineDown'
-  }, {
-    id: 'moveLineUp',
-    label: moveLineUp(),
-    flags: Disabled,
-    command: 'Editor.moveLineUp'
-  }, {
-    id: 'moveLineDown',
-    label: moveLineDown(),
-    flags: Disabled,
-    command: 'Editor.moveLineDown'
-  }];
-};
+// TODO more tests
 
-const MenuEntriesSelection = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$7,
-  id: id$3
+const menus = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHelp, MenuEntriesRun, MenuEntriesSelection, MenuEntriesTerminal, MenuEntriesTitleBar, MenuEntriesView, MenuEntriesOpenRecent];
+const getMenus = () => {
+  return menus;
+};
+const getModule = id => {
+  for (const module of menus) {
+    if (module.id === id) {
+      return module;
+    }
+  }
+  return undefined;
+};
+const getMenuEntries = async (id, ...args) => {
+  try {
+    const module = getModule(id);
+    // @ts-ignore
+    const inject = module.inject || [];
+    // @ts-ignore
+    return module.getMenuEntries(...args);
+  } catch (error) {
+    throw new VError(error, `Failed to load menu entries for id ${id}`);
+  }
 };
 
-/**
- * @enum {string}
- */
-const UiStrings = {
-  NewTerminal: 'New Terminal'
-};
-const newTerminal = () => {
-  return i18nString(UiStrings.NewTerminal);
+const openMenuAtIndex = async (state, index, shouldBeFocused) => {
+  const {
+    titleBarEntries,
+    titleBarHeight,
+    x
+  } = state;
+  // TODO race conditions
+  // TODO send renderer process
+  // 1. open menu, items to show
+  // 2. focus menu
+  const titleBarEntry = titleBarEntries[index];
+  const {
+    id
+  } = titleBarEntry;
+  const items = await getMenuEntries(id);
+  const relevantEntries = titleBarEntries.slice(0, index);
+  const totalWidths = getTotalWidth(relevantEntries);
+  const offset = totalWidths;
+  // TODO race condition: another menu might already be open at this point
+
+  const menuX = x + offset;
+  const menuY = titleBarHeight;
+  const width = getMenuWidth();
+  const height = getMenuHeight(items);
+  const menuFocusedIndex = shouldBeFocused ? getIndexToFocusNextStartingAt(items, 0) : -1;
+  const menu = {
+    id,
+    items,
+    focusedIndex: menuFocusedIndex,
+    level: 0,
+    x: menuX,
+    y: menuY,
+    width,
+    height
+  };
+  const menus = [menu];
+  return {
+    ...state,
+    isMenuOpen: true,
+    focusedIndex: index,
+    menus
+  };
 };
 
-const id$2 = Terminal;
-const getMenuEntries$6 = () => {
-  return [{
-    id: 'newTerminal',
-    label: newTerminal(),
-    flags: None,
-    command: 'Layout.togglePanel',
-    args: ['Terminal']
-  }];
+const focusIndex = async (state, index) => {
+  object(state);
+  number(index);
+  const {
+    isMenuOpen,
+    focusedIndex
+  } = state;
+  if (index === focusedIndex) {
+    return state;
+  }
+  if (isMenuOpen) {
+    return openMenuAtIndex(state, index, /* focus */false);
+  }
+  return {
+    ...state,
+    focusedIndex: index
+  };
 };
 
-const MenuEntriesTerminal = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$6,
-  id: id$2
+const handleMouseOutMenuClosed = state => {
+  return focusIndex(state, -1);
 };
 
-const file = () => {
-  return i18nString(File$1);
-};
-const edit = () => {
-  return i18nString(Edit$1);
-};
-const selection = () => {
-  return i18nString(Selection$1);
-};
-const view = () => {
-  return i18nString(View$1);
-};
-const go = () => {
-  return i18nString(Go$1);
-};
-const run = () => {
-  return i18nString(Run$1);
-};
-const terminal = () => {
-  return i18nString(Terminal$1);
-};
-const help = () => {
-  return i18nString(Help$1);
+const handleMouseOutMenuOpen = state => {
+  return state;
 };
 
-const getMenuEntries$5 = () => {
-  return [{
-    id: File,
-    label: file(),
-    flags: SubMenu
-  }, {
-    id: Edit,
-    label: edit(),
-    flags: SubMenu
-  }, {
-    id: Selection,
-    label: selection(),
-    flags: SubMenu
-  }, {
-    id: View,
-    label: view(),
-    flags: SubMenu
-  }, {
-    id: Go,
-    label: go(),
-    flags: SubMenu
-  }, {
-    id: Run,
-    label: run(),
-    keyboardShortCut: 'Alt+r',
-    flags: SubMenu
-  }, {
-    id: Terminal,
-    label: terminal(),
-    keyboardShortCut: 'Alt+t',
-    flags: SubMenu
-  }, {
-    id: Help,
-    label: help(),
-    keyboardShortCut: 'Alt+h',
-    flags: SubMenu
-  }];
+const ifElse = (menuOpenFunction, menuClosedFunction) => {
+  const ifElseFunction = (state, ...args) => {
+    const {
+      isMenuOpen
+    } = state;
+    if (isMenuOpen) {
+      return menuOpenFunction(state, ...args);
+    }
+    return menuClosedFunction(state, ...args);
+  };
+  return ifElseFunction;
 };
 
-const getMenuEntries$4 = () => {
-  return [{
-    id: File,
-    label: file(),
-    flags: None
-  }, {
-    id: Edit,
-    label: edit(),
-    flags: None
-  }, {
-    id: Selection,
-    label: selection(),
-    flags: None
-  }, {
-    id: View,
-    label: view(),
-    flags: None
-  }, {
-    id: Go,
-    label: go(),
-    flags: None
-  }, {
-    id: Help,
-    label: help(),
-    flags: None
-  }];
-};
+const handleMouseOut = ifElse(handleMouseOutMenuOpen, handleMouseOutMenuClosed);
 
-const getFn = platform => {
-  switch (platform) {
-    case Web:
-      return getMenuEntries$4;
-    default:
-      return getMenuEntries$5;
+const handlePointerOut = (state, clientX, clientY) => {
+  const index = getTitleBarIndexFromPosition(state.titleBarEntries, clientX - state.x);
+  if (index === -1) {
+    return state;
   }
-};
-const id$1 = TitleBar;
-const getMenuEntries$3 = async platform => {
-  const fn = getFn(platform);
-  return fn();
-};
-
-const MenuEntriesTitleBar = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$3,
-  id: id$1
+  return handleMouseOut(state, index);
 };
 
-const id = View;
-const getMenuEntries$2 = () => {
-  return [];
+const handleMouseOverMenuClosed = (state, index) => {
+  return focusIndex(state, index);
 };
 
-const MenuEntriesView = {
-  __proto__: null,
-  getMenuEntries: getMenuEntries$2,
-  id
+const handleMouseOverMenuOpen = async (state, index) => {
+  if (index === -1) {
+    return state;
+  }
+  return focusIndex(state, index);
 };
 
-const menus$1 = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHelp, MenuEntriesRun, MenuEntriesSelection, MenuEntriesTerminal, MenuEntriesTitleBar, MenuEntriesView, MenuEntriesOpenRecent];
+const handleMouseOver = ifElse(handleMouseOverMenuOpen, handleMouseOverMenuClosed);
 
-const getMenuIds = () => {
-  return menus$1.map(menu => menu.id);
-};
-const getMenuEntries$1 = (id, platform) => {
-  const menu = menus$1.find(item => item.id === id);
-  if (!menu) {
-    return [];
+const handlePointerOver = (state, clientX, clientY) => {
+  const index = getTitleBarIndexFromPosition(state.titleBarEntries, clientX - state.x);
+  if (index === -1) {
+    return state;
   }
-  return menu.getMenuEntries(platform);
+  return handleMouseOver(state, index);
 };
 
-const getIconVirtualDom = (icon, type = Div) => {
-  return {
-    type,
-    className: `MaskIcon MaskIcon${icon}`,
-    role: None$1,
-    childCount: 0
-  };
+const getFontString = (fontWeight, fontSize, fontFamily) => {
+  return `${fontWeight} ${fontSize}px ${fontFamily}`;
 };
 
-const createTitleBarButton = button => {
-  const {
-    id,
-    icon,
-    label,
-    onClick
-  } = button;
-  const dom = [{
-    type: Button,
-    className: `TitleBarButton TitleBarButton${id}`,
-    ariaLabel: label,
-    childCount: 1,
-    onClick
-  }, getIconVirtualDom(icon, I)];
-  return dom;
+const createTextMeasureContext = () => {
+  const canvas = new OffscreenCanvas(0, 0);
+  const ctx = canvas.getContext('2d');
+  if (!ctx) {
+    throw new Error('Failed to get canvas context 2d');
+  }
+  return ctx;
 };
 
-const getTitleBarButtonsVirtualDom = buttons => {
-  const dom = [{
-    type: Div,
-    className: 'Viewlet TitleBarButtons',
-    childCount: buttons.length
-  }, ...buttons.flatMap(createTitleBarButton)];
-  return dom;
+const state = {
+  ctx: undefined
 };
-
-const getTitleBarIconVirtualDom = iconSrc => {
-  return [{
-    type: Div,
-    className: 'Viewlet TitleBarIcon',
-    childCount: 1
-  }, {
-    type: Img,
-    className: 'TitleBarIconIcon',
-    src: iconSrc,
-    alt: '',
-    childCount: 0
-  }];
+const getOrCreate = createCtx => {
+  if (state.ctx) {
+    return state.ctx;
+  }
+  state.ctx = createCtx();
+  return state.ctx;
 };
 
-const getTitleVirtualDom = title => {
-  return [text(title)];
+const getContext = () => {
+  const ctx = getOrCreate(createTextMeasureContext);
+  return ctx;
 };
 
-const handleClickClose = async state => {
-  await invoke('ElectronWindow.close');
-  return state;
+const px = value => {
+  return `${value}px`;
 };
 
-const handleClickMinimize = async state => {
-  await invoke('ElectronWindow.minimize');
-  return state;
+const getLetterSpacingString = letterSpacing => {
+  return px(letterSpacing);
+};
+const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  string(text);
+  number(fontWeight);
+  number(fontSize);
+  string(fontFamily);
+  boolean(isMonoSpaceFont);
+  number(charWidth);
+  if (typeof letterSpacing !== 'number') {
+    throw new TypeError('letterSpacing must be of type number');
+  }
+  const letterSpacingString = getLetterSpacingString(letterSpacing);
+  const fontString = getFontString(fontWeight, fontSize, fontFamily);
+  const ctx = getContext();
+  ctx.letterSpacing = letterSpacingString;
+  ctx.font = fontString;
+  const metrics = ctx.measureText(text);
+  const {
+    width
+  } = metrics;
+  return width;
 };
 
-const handleClickToggleMaximize = async state => {
-  await (invoke('ElectronWindow.maximize'));
-  return state;
+const measureTitleBarEntryWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const isMonospaceFont = false;
+  const charWidth = 0;
+  return measureTextWidth(label, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
 };
 
-const handleClick$1 = (state, className) => {
-  if (className.includes('Minimize')) {
-    return handleClickMinimize(state);
-  }
-  if (className.includes('Maximize') || className.includes('Restore')) {
-    return handleClickToggleMaximize(state);
-  }
-  if (className.includes('Close')) {
-    return handleClickClose(state);
+const addWidths = (entries, labelPadding, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const withWidths = [];
+  for (const entry of entries) {
+    const textWidth = measureTitleBarEntryWidth(entry.label, fontWeight, fontSize, fontFamily, letterSpacing);
+    const width = textWidth + labelPadding * 2;
+    withWidths.push({
+      ...entry,
+      width
+    });
   }
-  return state;
+  return withWidths;
 };
 
-const handleContextMenu = state => {
-  return state;
+const loadContent = async (state, titleBarEntries) => {
+  const {
+    labelFontFamily,
+    labelFontSize,
+    labelFontWeight,
+    labelLetterSpacing,
+    labelPadding
+  } = state;
+  const withWidths = addWidths(titleBarEntries, labelPadding, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
+  return {
+    ...state,
+    titleBarEntries: withWidths
+  };
 };
 
-const getTitleBarIndexFromPosition = (titleBarEntries, x, y) => {
-  let currentX = 0;
-  for (let i = 0; i < titleBarEntries.length; i++) {
-    const entry = titleBarEntries[i];
-    const entryWidth = entry.width;
-    if (x >= currentX && x < currentX + entryWidth) {
-      return i;
-    }
-    currentX += entryWidth;
-  }
-  return -1;
-};
+const Ellipsis = 'Ellipsis';
 
-const getTotalWidth = entries => {
+const getVisibleTitleBarEntries = (entries, width, focusedIndex, isMenuOpen) => {
+  array(entries);
+  number(width);
   let total = 0;
-  for (const entry of entries) {
+  const visible = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
     total += entry.width;
+    if (total >= width) {
+      break;
+    }
+    const isOpen = i === focusedIndex && isMenuOpen;
+    const isFocused = i === focusedIndex;
+    visible.push({
+      ...entry,
+      isOpen,
+      isFocused
+    });
   }
-  return total;
-};
-
-// TODO lazyload menuEntries and use Command.execute (maybe)
-const CONTEXT_MENU_ITEM_HEIGHT = 26;
-const CONTEXT_MENU_SEPARATOR_HEIGHT = 11;
-const CONTEXT_MENU_PADDING = 8;
-const getMenuHeight = items => {
-  let height = CONTEXT_MENU_PADDING;
-  for (const item of items) {
-    switch (item.flags) {
-      case Separator:
-        height += CONTEXT_MENU_SEPARATOR_HEIGHT;
-        break;
-      default:
-        height += CONTEXT_MENU_ITEM_HEIGHT;
-        break;
+  const hasOverflow = visible.length < entries.length;
+  if (hasOverflow) {
+    const padding = 8;
+    const moreIconWidth = 22;
+    const totalPadding = padding * 2;
+    const hasStillOverflow = total + moreIconWidth + totalPadding > width;
+    if (hasStillOverflow) {
+      visible.pop();
     }
+    visible.push({
+      ariaLabel: moreDot(),
+      icon: Ellipsis,
+      label: '',
+      width: moreIconWidth + totalPadding
+    });
   }
-  return height;
+  return visible;
 };
 
-// TODO lazyload menuEntries and use Command.execute (maybe)
-const MENU_WIDTH = 150;
-const CONTEXT_MENU_WIDTH = 250;
-const getMenuWidth = () => {
-  return CONTEXT_MENU_WIDTH;
+const renderEntries = (oldState, newState) => {
+  const visibleEntries = getVisibleTitleBarEntries(newState.titleBarEntries, newState.width, newState.focusedIndex, newState.isMenuOpen);
+  const dom = getTitleBarMenuBarVirtualDom(visibleEntries, newState.focusedIndex);
+  return ['Viewlet.setDom2', newState.uid, dom];
 };
 
-// TODO difference between focusing with mouse or keyboard
-// with mouse -> open submenu
-// with keyboard -> don't open submenu, only focus
-
-const getIndexToFocusNextStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i < startIndex + items.length; i++) {
-    const index = i % items.length;
-    const item = items[index];
-    if (canBeFocused(item)) {
-      return index;
-    }
+const renderFocusedIndex = (oldState, newState) => {
+  if (newState.focusedIndex === -1) {
+    return [];
   }
-  return -1;
+  return ['Viewlet.focusSelector', '.ViewletTitleBarMenuBar'];
 };
-const getIndexToFocusFirst = items => {
-  return getIndexToFocusNextStartingAt(items, 0);
+
+const checkboxChecked = {
+  type: Div,
+  className: mergeClassNames(MenuItem$1, MenuItemCheckMark),
+  role: MenuItemCheckBox,
+  ariaChecked: true,
+  tabIndex: -1,
+  childCount: 2
 };
-const getIndexToFocusLast = items => {
-  return getIndexToFocusPreviousStartingAt(items, items.length - 1);
+const checkMark = {
+  type: Div,
+  className: mergeClassNames(MenuItemCheckmarkIcon, MaskIconCheck)
+};
+const getMenuItemCheckedDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [checkboxChecked, checkMark, text(label)];
 };
 
-// TODO this code seems a bit too complicated, maybe it can be simplified
-const getIndexToFocusPreviousStartingAt = (items, startIndex) => {
-  for (let i = startIndex; i > startIndex - items.length; i--) {
-    const index = (i + items.length) % items.length;
-    const item = items[index];
-    if (canBeFocused(item)) {
-      return index;
-    }
+const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
+  let string = '';
+  if (ctrlKey) {
+    string += 'Ctrl+';
   }
-  return -1;
-};
-const getIndexToFocusPrevious = menu => {
-  const startIndex = menu.focusedIndex === -1 ? menu.items.length - 1 : menu.focusedIndex - 1;
-  return getIndexToFocusPreviousStartingAt(menu.items, startIndex);
-};
-const canBeFocused = item => {
-  switch (item.flags) {
-    case Separator:
-    case Disabled:
-      return false;
-    default:
-      return true;
+  if (shiftKey) {
+    string += 'Shift+';
   }
+  string += key.toUpperCase();
+  return string;
 };
-const getIndexToFocusNext = menu => {
-  const startIndex = menu.focusedIndex + 1;
-  return getIndexToFocusNextStartingAt(menu.items, startIndex);
-};
-
-// TODO handle printable letter and focus item that starts with that letter
-
-// TODO pageup / pagedown keys
 
-// TODO more tests
+const Unknown = 'Unknown';
+const Backspace = 'Backspace';
+const Tab = 'Tab';
+const Enter = 'Enter';
+const Escape = 'Escape';
+const Space = 'Space';
+const PageUp = 'PageUp';
+const PageDown = 'PageDown';
+const End = 'End';
+const Home = 'Home';
+const LeftArrow = 'LeftArrow';
+const UpArrow = 'UpArrow';
+const RightArrow = 'RightArrow';
+const DownArrow = 'DownArrow';
+const Insert = 'Insert';
+const Delete = 'Delete';
+const Digit0 = '0';
+const Digit1 = '1';
+const Digit2 = '2';
+const Digit3 = '3';
+const Digit4 = '4';
+const Digit5 = '5';
+const Digit6 = '6';
+const Digit7 = '7';
+const Digit8 = '8';
+const Digit9 = '9';
+const KeyA = 'a';
+const KeyB = 'b';
+const KeyC = 'c';
+const KeyD = 'd';
+const KeyE = 'e';
+const KeyF = 'f';
+const KeyG = 'g';
+const KeyH = 'h';
+const KeyI = 'i';
+const KeyJ = 'j';
+const KeyK = 'k';
+const KeyL = 'l';
+const KeyM = 'm';
+const KeyN = 'n';
+const KeyO = 'o';
+const KeyP = 'p';
+const KeyQ = 'q';
+const KeyR = 'r';
+const KeyS = 's';
+const KeyT = 't';
+const KeyU = 'u';
+const KeyV = 'v';
+const KeyW = 'w';
+const KeyX = 'x';
+const KeyY = 'y';
+const KeyZ = 'z';
+const F1 = 'F1';
+const F2 = 'F2';
+const F3 = 'F3';
+const F4 = 'F4';
+const F5 = 'F5';
+const F6 = 'F6';
+const Equal = '=';
+const Comma = ',';
+const Minus = 'Minus';
+const Backquote = 'Backquote';
+const Backslash = 'Backslash';
+const Star = '*';
+const Plus = '+';
 
-const menus = [MenuEntriesEdit, MenuEntriesFile, MenuEntriesGo, MenuEntriesHelp, MenuEntriesRun, MenuEntriesSelection, MenuEntriesTerminal, MenuEntriesTitleBar, MenuEntriesView, MenuEntriesOpenRecent];
-const getMenus = () => {
-  return menus;
-};
-const getModule = id => {
-  for (const module of menus) {
-    if (module.id === id) {
-      return module;
-    }
-  }
-  return undefined;
-};
-const getMenuEntries = async (id, ...args) => {
-  try {
-    const module = getModule(id);
-    // @ts-ignore
-    const inject = module.inject || [];
-    // @ts-ignore
-    return module.getMenuEntries(...args);
-  } catch (error) {
-    throw new VError(error, `Failed to load menu entries for id ${id}`);
+const getKeyCodeString = keyCode => {
+  switch (keyCode) {
+    case Backspace$1:
+      return Backspace;
+    case Tab$1:
+      return Tab;
+    case Escape$1:
+      return Escape;
+    case Enter$1:
+      return Enter;
+    case Space$1:
+      return Space;
+    case PageUp$1:
+      return PageUp;
+    case PageDown$1:
+      return PageDown;
+    case End$1:
+      return End;
+    case Home$1:
+      return Home;
+    case LeftArrow$1:
+      return LeftArrow;
+    case UpArrow$1:
+      return UpArrow;
+    case RightArrow$1:
+      return RightArrow;
+    case DownArrow$1:
+      return DownArrow;
+    case Insert$1:
+      return Insert;
+    case Delete$1:
+      return Delete;
+    case Digit0$1:
+      return Digit0;
+    case Digit1$1:
+      return Digit1;
+    case Digit2$1:
+      return Digit2;
+    case Digit3$1:
+      return Digit3;
+    case Digit4$1:
+      return Digit4;
+    case Digit5$1:
+      return Digit5;
+    case Digit6$1:
+      return Digit6;
+    case Digit7$1:
+      return Digit7;
+    case Digit8$1:
+      return Digit8;
+    case Digit9$1:
+      return Digit9;
+    case KeyA$1:
+      return KeyA;
+    case KeyB$1:
+      return KeyB;
+    case KeyC$1:
+      return KeyC;
+    case KeyD$1:
+      return KeyD;
+    case KeyE$1:
+      return KeyE;
+    case KeyF$1:
+      return KeyF;
+    case KeyG$1:
+      return KeyG;
+    case KeyH$1:
+      return KeyH;
+    case KeyI$1:
+      return KeyI;
+    case KeyJ$1:
+      return KeyJ;
+    case KeyK$1:
+      return KeyK;
+    case KeyL$1:
+      return KeyL;
+    case KeyM$1:
+      return KeyM;
+    case KeyN$1:
+      return KeyN;
+    case KeyO$1:
+      return KeyO;
+    case KeyP$1:
+      return KeyP;
+    case KeyQ$1:
+      return KeyQ;
+    case KeyR$1:
+      return KeyR;
+    case KeyS$1:
+      return KeyS;
+    case KeyT$1:
+      return KeyT;
+    case KeyU$1:
+      return KeyU;
+    case KeyV$1:
+      return KeyV;
+    case KeyW$1:
+      return KeyW;
+    case KeyX$1:
+      return KeyX;
+    case KeyY$1:
+      return KeyY;
+    case KeyZ$1:
+      return KeyZ;
+    case F1$1:
+      return F1;
+    case F2$1:
+      return F2;
+    case F3$1:
+      return F3;
+    case F4$1:
+      return F4;
+    case F5$1:
+      return F5;
+    case F6$1:
+      return F6;
+    case Backslash$1:
+      return Backslash;
+    case Equal$1:
+      return Equal;
+    case Comma$1:
+      return Comma;
+    case Backquote$1:
+      return Backquote;
+    case Plus$1:
+      return Plus;
+    case Star$1:
+      return Star;
+    case Minus$1:
+      return Minus;
+    default:
+      return Unknown;
   }
 };
 
-const openMenuAtIndex = async (state, index, shouldBeFocused) => {
-  const {
-    titleBarEntries,
-    titleBarHeight,
-    x
-  } = state;
-  // TODO race conditions
-  // TODO send renderer process
-  // 1. open menu, items to show
-  // 2. focus menu
-  const titleBarEntry = titleBarEntries[index];
-  const {
-    id
-  } = titleBarEntry;
-  const items = await getMenuEntries(id);
-  const relevantEntries = titleBarEntries.slice(0, index);
-  const totalWidths = getTotalWidth(relevantEntries);
-  const offset = totalWidths;
-  // TODO race condition: another menu might already be open at this point
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
 
-  const menuX = x + offset;
-  const menuY = titleBarHeight;
-  const width = getMenuWidth();
-  const height = getMenuHeight(items);
-  const menuFocusedIndex = shouldBeFocused ? getIndexToFocusNextStartingAt(items, 0) : -1;
-  const menu = {
-    id,
-    items,
-    focusedIndex: menuFocusedIndex,
-    level: 0,
-    x: menuX,
-    y: menuY,
-    width,
-    height
-  };
-  const menus = [menu];
+const parseKey = rawKey => {
+  number(rawKey);
+  const isCtrl = Boolean(rawKey & CtrlCmd);
+  const isShift = Boolean(rawKey & Shift);
+  const keyCode = rawKey & 0x00_00_00_ff;
+  const key = getKeyCodeString(keyCode);
   return {
-    ...state,
-    isMenuOpen: true,
-    focusedIndex: index,
-    menus
+    key,
+    isCtrl,
+    isShift
   };
 };
 
-const focusIndex = async (state, index) => {
-  object(state);
-  number(index);
+const getMenuItemDefaultDom = menuItem => {
   const {
-    isMenuOpen,
-    focusedIndex
-  } = state;
-  if (index === focusedIndex) {
-    return state;
+    label,
+    isFocused,
+    key
+  } = menuItem;
+  let className = MenuItem$1;
+  if (isFocused) {
+    className += ' ' + MenuItemFocused;
   }
-  if (isMenuOpen) {
-    return openMenuAtIndex(state, index, /* focus */false);
+  const dom = [];
+  dom.push({
+    type: Div,
+    className,
+    role: MenuItem,
+    tabIndex: -1,
+    childCount: 1
+  }, text(label));
+  if (key) {
+    dom[0].childCount++;
+    const parsedKey = parseKey(key);
+    const keyBindingsString = getKeyBindingString(parsedKey.key, false, parsedKey.isCtrl, parsedKey.isShift);
+    dom.push({
+      type: Span,
+      className: MenuItemKeyBinding,
+      childCount: 1
+    }, text(keyBindingsString));
   }
-  return {
-    ...state,
-    focusedIndex: index
-  };
+  return dom;
+};
+
+const disabled = {
+  type: Div,
+  className: MenuItem$1,
+  role: MenuItem,
+  tabIndex: -1,
+  disabled: true,
+  childCount: 1
+};
+const getMenuItemDisabledDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [disabled, text(label)];
 };
 
-const handleMouseOutMenuClosed = state => {
-  return focusIndex(state, -1);
+const getMenuItemsNoopDom = () => {
+  return [];
 };
 
-const handleMouseOutMenuOpen = state => {
-  return state;
+const separator = {
+  type: Div,
+  className: MenuItemSeparator,
+  role: Separator,
+  childCount: 1
 };
-
-const ifElse = (menuOpenFunction, menuClosedFunction) => {
-  const ifElseFunction = (state, ...args) => {
-    const {
-      isMenuOpen
-    } = state;
-    if (isMenuOpen) {
-      return menuOpenFunction(state, ...args);
-    }
-    return menuClosedFunction(state, ...args);
-  };
-  return ifElseFunction;
+const separatorLine = {
+  type: Div,
+  className: MenuItemSeparatorLine,
+  childCount: 0
 };
-
-const handleMouseOut = ifElse(handleMouseOutMenuOpen, handleMouseOutMenuClosed);
-
-const handlePointerOut = (state, clientX, clientY) => {
-  const index = getTitleBarIndexFromPosition(state.titleBarEntries, clientX - state.x);
-  if (index === -1) {
-    return state;
-  }
-  return handleMouseOut(state, index);
+const getMenuItemSeparatorDom = menuItem => {
+  return [separator, separatorLine];
 };
 
-const handleMouseOverMenuClosed = (state, index) => {
-  return focusIndex(state, index);
+const arrowRight = {
+  type: Div,
+  className: MenuItemSubMenuArrowRight,
+  childCount: 0
 };
-
-const handleMouseOverMenuOpen = async (state, index) => {
-  if (index === -1) {
-    return state;
+const getMenuItemSubMenuDom = menuItem => {
+  const {
+    label,
+    isFocused,
+    isExpanded,
+    level
+  } = menuItem;
+  let className = MenuItem$1;
+  className += ' ' + MenuItemSubMenu;
+  if (isFocused) {
+    className += ' ' + MenuItemFocused;
   }
-  return focusIndex(state, index);
+  return [{
+    type: Div,
+    className,
+    role: MenuItem,
+    tabIndex: -1,
+    ariaHasPopup: true,
+    ariaExpanded: isExpanded,
+    ariaOwns: isExpanded ? `Menu-${level + 1}` : undefined,
+    childCount: 2
+  }, text(label), arrowRight];
 };
 
-const handleMouseOver = ifElse(handleMouseOverMenuOpen, handleMouseOverMenuClosed);
-
-const handlePointerOver = (state, clientX, clientY) => {
-  const index = getTitleBarIndexFromPosition(state.titleBarEntries, clientX - state.x);
-  if (index === -1) {
-    return state;
-  }
-  return handleMouseOver(state, index);
+const checkboxUnchecked = {
+  type: Div,
+  className: MenuItem$1,
+  role: MenuItemCheckBox,
+  ariaChecked: false,
+  tabIndex: -1,
+  childCount: 1
 };
-
-const getFontString = (fontWeight, fontSize, fontFamily) => {
-  return `${fontWeight} ${fontSize}px ${fontFamily}`;
+const getMenuItemUncheckedDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [checkboxUnchecked, text(label)];
 };
 
-const state = {
-  ctx: undefined
-};
-const getOrCreate = createCtx => {
-  if (state.ctx) {
-    return state.ctx;
+const getMenuItemRenderer = flags => {
+  switch (flags) {
+    case None$1:
+    case RestoreFocus:
+    case Ignore:
+      return getMenuItemDefaultDom;
+    case Separator$1:
+      return getMenuItemSeparatorDom;
+    case Checked:
+      return getMenuItemCheckedDom;
+    case Unchecked:
+      return getMenuItemUncheckedDom;
+    case Disabled:
+      return getMenuItemDisabledDom;
+    case SubMenu:
+      return getMenuItemSubMenuDom;
+    default:
+      return getMenuItemsNoopDom;
   }
-  state.ctx = createCtx();
-  return state.ctx;
 };
 
-const createCtx = () => {
-  const canvas = new OffscreenCanvas(0, 0);
-  const ctx = /** @type {OffscreenCanvasRenderingContext2D} */canvas.getContext('2d');
-  if (!ctx) {
-    throw new Error('Failed to get canvas context 2d');
-  }
-  return ctx;
-};
-const getContext = () => {
-  const ctx = getOrCreate(createCtx);
-  return ctx;
+const getMenuItemVirtualDom = menuItem => {
+  const {
+    flags
+  } = menuItem;
+  const fn = getMenuItemRenderer(flags);
+  return fn(menuItem);
 };
 
-const px = value => {
-  return `${value}px`;
+const getMenuVirtualDom = menuItems => {
+  const dom = [{
+    type: Div,
+    className: Menu$1,
+    role: Menu,
+    tabIndex: -1,
+    childCount: menuItems.length
+  }, ...menuItems.flatMap(getMenuItemVirtualDom)];
+  return dom;
 };
 
-const getLetterSpacingString = letterSpacing => {
-  return px(letterSpacing);
-};
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  string(text);
-  number(fontWeight);
-  number(fontSize);
-  string(fontFamily);
-  boolean(isMonoSpaceFont);
-  number(charWidth);
-  if (typeof letterSpacing !== 'number') {
-    throw new TypeError('letterSpacing must be of type number');
+const getVisible = (items, focusedIndex, expanded, level) => {
+  const visibleItems = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const {
+      flags,
+      label
+    } = item;
+    visibleItems.push({
+      label,
+      flags,
+      isFocused: i === focusedIndex,
+      isExpanded: i === focusedIndex && expanded,
+      level,
+      key: item.key
+    });
   }
-  const letterSpacingString = getLetterSpacingString(letterSpacing);
-  const fontString = getFontString(fontWeight, fontSize, fontFamily);
-  const ctx = getContext();
-  // @ts-ignore
-  ctx.letterSpacing = letterSpacingString;
-  ctx.font = fontString;
-  const metrics = ctx.measureText(text);
-  const {
-    width
-  } = metrics;
-  return width;
+  return visibleItems;
 };
 
-const measureTitleBarEntryWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const isMonospaceFont = false;
-  const charWidth = 0;
-  return measureTextWidth(label, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+const SetMenus = 'setMenus';
+
+const renderMenus = (oldState, newState) => {
+  const oldMenus = oldState.menus;
+  const newMenus = newState.menus;
+  const oldLength = oldMenus.length;
+  const newLength = newMenus.length;
+  const commonLength = Math.min(oldLength, newLength);
+  const changes = [];
+  for (let i = 0; i < commonLength; i++) {
+    const oldMenu = oldMenus[i];
+    const newMenu = newMenus[i];
+    if (oldMenu !== newMenu) {
+      const visible = getVisible(newMenu.items, newMenu.focusedIndex, newMenu.expanded, newMenu.level);
+      const dom = getMenuVirtualDom(visible).slice(1);
+      changes.push([/* method */'updateMenu', newMenu, /* newLength */newLength, dom]);
+    }
+  }
+  const difference = newLength - oldLength;
+  if (difference > 0) {
+    const newMenu = newMenus.at(-1);
+    const visible = getVisible(newMenu.items, newMenu.focusedIndex, newMenu.expanded, newMenu.level);
+    const dom = getMenuVirtualDom(visible).slice(1);
+    changes.push(['addMenu', newMenu, dom]);
+  } else if (difference < 0) {
+    changes.push(['closeMenus', newLength]);
+  }
+  return ['Viewlet.send', newState.uid, /* method */SetMenus, /* changes */changes, newState.uid];
 };
 
-const addWidths = (entries, labelPadding, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const withWidths = [];
-  for (const entry of entries) {
-    const textWidth = measureTitleBarEntryWidth(entry.label, fontWeight, fontSize, fontFamily, letterSpacing);
-    const width = textWidth + labelPadding * 2;
-    withWidths.push({
-      ...entry,
-      width
-    });
+const getRenderer = diffType => {
+  switch (diffType) {
+    case RenderEntries:
+      return renderEntries;
+    case RenderFocusedIndex:
+      return renderFocusedIndex;
+    case RenderMenus:
+      return renderMenus;
+    default:
+      throw new Error('unknown renderer');
   }
-  return withWidths;
 };
 
-const loadContent = async (state, titleBarEntries) => {
-  const {
-    labelFontFamily,
-    labelFontSize,
-    labelFontWeight,
-    labelLetterSpacing,
-    labelPadding
-  } = state;
-  const withWidths = addWidths(titleBarEntries, labelPadding, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
-  return {
-    ...state,
-    titleBarEntries: withWidths
-  };
+const applyRender = (oldState, newState, diffResult) => {
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer(item);
+    const result = fn(oldState, newState);
+    if (result.length > 0) {
+      commands.push(result);
+    }
+  }
+  return commands;
 };
 
 const render2 = async (uid, diffResult) => {
@@ -2696,6 +2770,7 @@ const render2 = async (uid, diffResult) => {
     oldState,
     newState
   } = get(uid);
+  set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2861,11 +2936,19 @@ const handleClickAt = async (state, button, x, y) => {
   return handleClick(state, button, index);
 };
 
+const setFocus = async focusKey => {
+  await invoke('Focus.setFocus', focusKey);
+};
+
 // TODO remove this file and merge with whenExpressions
 const TitleBarMenuBar = FocusTitleBarMenuBar;
 
 const handleFocus = async state => {
-  await invoke('Focus.setFocus', TitleBarMenuBar);
+  await setFocus(TitleBarMenuBar);
+  return state;
+};
+
+const handleFocusOut = async state => {
   return state;
 };
 
@@ -3138,7 +3221,7 @@ const handleMenuClick = (state, level, index) => {
   const menu = menus[level];
   const item = menu.items[index];
   switch (item.flags) {
-    case None:
+    case None$1:
       return selectIndexNone(state, item);
     case SubMenu:
       return selectIndexSubMenu(state, menu, index);
@@ -3242,25 +3325,28 @@ const wrapCommand = fn => {
       newState
     } = get(uid);
     const newerState = await fn(newState, ...args);
-    set(uid, newState, newerState);
+    if (newState === newerState) {
+      return;
+    }
+    const latest = get(uid);
+    set(uid, latest.oldState, newerState);
   };
   return wrapped;
 };
 
 const commandMap = {
   'TitleBar.getButtonsVirtualDom': getTitleBarButtonsVirtualDom,
-  'TitleBar.handleContextMenu': handleContextMenu,
   'TitleBar.getIconVirtualDom': getTitleBarIconVirtualDom,
   'TitleBar.getMenuEntries': getMenuEntries$1,
   'TitleBar.getMenuIds': getMenuIds,
   'TitleBar.getTitleVirtualDom': getTitleVirtualDom,
   'TitleBar.handleButtonsClick': handleClick$1,
+  'TitleBar.handleContextMenu': handleContextMenu,
   'TitleBar.renderEventListeners': renderEventListeners,
   'TitleBarMenuBar.closeMenu': closeMenu,
   'TitleBarMenuBar.create': create,
-  'TitleBarMenuBar.focus': wrapCommand(focus),
   'TitleBarMenuBar.diff2': diff2,
-  'TitleBarMenuBar.render2': render2,
+  'TitleBarMenuBar.focus': wrapCommand(focus),
   'TitleBarMenuBar.focusFirst': wrapCommand(focusFirst),
   'TitleBarMenuBar.focusIndex': wrapCommand(focusLast),
   'TitleBarMenuBar.focusLast': wrapCommand(focusIndex),
@@ -3271,16 +3357,16 @@ const commandMap = {
   'TitleBarMenuBar.getMenus': getMenus,
   'TitleBarMenuBar.getVirtualDom': getTitleBarMenuBarVirtualDom,
   'TitleBarMenuBar.handleClick': wrapCommand(handleClick),
+  'TitleBarMenuBar.getTitleBarButtons': getTitleBarButtons,
+  'TitleBarMenuBar.handleClickAt': wrapCommand(handleClickAt),
   'TitleBarMenuBar.handleFocus': wrapCommand(handleFocus),
+  'TitleBarMenuBar.handleFocusOut': wrapCommand(handleFocusOut),
   'TitleBarMenuBar.handleKeyArrowDown': wrapCommand(handleKeyArrowDown),
   'TitleBarMenuBar.handleKeyArrowLeft': wrapCommand(handleKeyArrowLeft),
   'TitleBarMenuBar.handleKeyArrowRight': wrapCommand(handleKeyArrowRight),
   'TitleBarMenuBar.handleKeyArrowUp': wrapCommand(handleKeyArrowUp),
-  'TitleBarMenuBar.handleClickAt': wrapCommand(handleClickAt),
-  'TitleBarMenuBar.handlePointerOver': wrapCommand(handlePointerOver),
   'TitleBarMenuBar.handleKeyEnd': wrapCommand(handleKeyEnd),
   'TitleBarMenuBar.handleKeyEnter': wrapCommand(handleKeyEnter),
-  'TitleBarMenuBar.handlePointerOut': wrapCommand(handlePointerOut),
   'TitleBarMenuBar.handleKeyEscape': wrapCommand(handleKeyEscape),
   'TitleBarMenuBar.handleKeyHome': wrapCommand(handleKeyHome),
   'TitleBarMenuBar.handleKeySpace': wrapCommand(handleKeySpace),
@@ -3288,14 +3374,14 @@ const commandMap = {
   'TitleBarMenuBar.handleMenuMouseOver': wrapCommand(handleMenuMouseOver),
   'TitleBarMenuBar.handleMouseOut': wrapCommand(handleMouseOut),
   'TitleBarMenuBar.handleMouseOver': wrapCommand(handleMouseOver),
+  'TitleBarMenuBar.handlePointerOut': wrapCommand(handlePointerOut),
+  'TitleBarMenuBar.handlePointerOver': wrapCommand(handlePointerOver),
   'TitleBarMenuBar.loadContent': wrapCommand(loadContent),
+  'TitleBarMenuBar.render2': render2,
   'TitleBarMenuBar.saveState': saveState,
   'TitleBarMenuBar.terminate': terminate,
   'TitleBarMenuBar.toggleIndex': wrapCommand(toggleIndex),
-  'TitleBarMenuBar.toggleMenu': wrapCommand(toggleMenu),
-  // deprecated
-  'TitleBarMenuBar.diff': diff,
-  'TitleBarMenuBar.render': doRender
+  'TitleBarMenuBar.toggleMenu': wrapCommand(toggleMenu)
 };
 
 const listen = async () => {