@lvce-editor/static-server 0.85.2 → 0.86.0

package/static/3b0fc97/packages/title-bar-worker/dist/titleBarWorkerMain.js

@@ -0,0 +1,4750 @@
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown$1 = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown$1;
+  }
+};
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const array = value => {
+  const type = getType(value);
+  if (type !== Array$1) {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
+
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$1 = '\n';
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    code: ERR_MODULE_NOT_FOUND,
+    message
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    code: '',
+    message: actualMessage,
+    stack: rest
+  };
+};
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const waitForFirstMessage = async port => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      id: firstMessage.id,
+      jsonrpc: '2.0',
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$e = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
+};
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const get$2 = id => {
+  return callbacks[id];
+};
+const remove$1 = id => {
+  delete callbacks[id];
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$2(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$1(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
+  }
+  return {
+    code: Custom,
+    data: {
+      code: prettyError.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    error,
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$9 = (message, result) => {
+  return {
+    id: message.id,
+    jsonrpc: Two$1,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$9(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
+      // @ts-ignore
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
+    };
+  }
+  return {
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute,
+    ipc,
+    logError,
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+
+const Two = '2.0';
+
+const create$8 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$7 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$6 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$6();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$7(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$8(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+
+const create$3 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$2 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$2 = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$2(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$2(rpcId, rpc);
+    }
+  };
+};
+
+const ContentInfo = 'contentinfo';
+const Menu$1 = 'menu';
+const MenuBar$1 = 'menubar';
+const MenuItem$1 = 'menuitem';
+const MenuItemCheckBox = 'menuitemcheckbox';
+const None$1 = 'none';
+const Separator$2 = 'separator';
+
+const Button$1 = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const I = 16;
+const Img = 17;
+
+const Button = 'event.button';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const TargetName = 'event.target.name';
+
+const Backspace$1 = 1;
+const Tab$1 = 2;
+const Enter$1 = 3;
+const Escape$1 = 8;
+const Space$1 = 9;
+const PageUp$1 = 10;
+const PageDown$1 = 11;
+const End$1 = 255;
+const Home$1 = 12;
+const LeftArrow$1 = 13;
+const UpArrow$1 = 14;
+const RightArrow$1 = 15;
+const DownArrow$1 = 16;
+const Insert$1 = 17;
+const Delete$1 = 18;
+const Digit0$1 = 19;
+const Digit1$1 = 20;
+const Digit2$1 = 21;
+const Digit3$1 = 22;
+const Digit4$1 = 23;
+const Digit5$1 = 24;
+const Digit6$1 = 25;
+const Digit7$1 = 26;
+const Digit8$1 = 27;
+const Digit9$1 = 28;
+const KeyA$1 = 29;
+const KeyB$1 = 30;
+const KeyC$1 = 31;
+const KeyD$1 = 32;
+const KeyE$1 = 33;
+const KeyF$1 = 34;
+const KeyG$1 = 35;
+const KeyH$1 = 36;
+const KeyI$1 = 37;
+const KeyJ$1 = 38;
+const KeyK$1 = 39;
+const KeyL$1 = 40;
+const KeyM$1 = 41;
+const KeyN$1 = 42;
+const KeyO$1 = 43;
+const KeyP$1 = 44;
+const KeyQ$1 = 45;
+const KeyR$1 = 46;
+const KeyS$1 = 47;
+const KeyT$1 = 48;
+const KeyU$1 = 49;
+const KeyV$1 = 50;
+const KeyW$1 = 51;
+const KeyX$1 = 52;
+const KeyY$1 = 53;
+const KeyZ$1 = 54;
+const F1$1 = 57;
+const F2$1 = 58;
+const F3$1 = 59;
+const F4$1 = 60;
+const F5$1 = 61;
+const F6$1 = 62;
+const Equal$1 = 84;
+const Comma$1 = 85;
+const Minus$1 = 86;
+const Backquote$1 = 89;
+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 keyCodeStringMap = {
+  [Backquote$1]: Backquote,
+  [Backslash$1]: Backslash,
+  [Backspace$1]: Backspace,
+  [Comma$1]: Comma,
+  [Delete$1]: Delete,
+  [Digit0$1]: Digit0,
+  [Digit1$1]: Digit1,
+  [Digit2$1]: Digit2,
+  [Digit3$1]: Digit3,
+  [Digit4$1]: Digit4,
+  [Digit5$1]: Digit5,
+  [Digit6$1]: Digit6,
+  [Digit7$1]: Digit7,
+  [Digit8$1]: Digit8,
+  [Digit9$1]: Digit9,
+  [DownArrow$1]: DownArrow,
+  [End$1]: End,
+  [Enter$1]: Enter,
+  [Equal$1]: Equal,
+  [Escape$1]: Escape,
+  [F1$1]: F1,
+  [F2$1]: F2,
+  [F3$1]: F3,
+  [F4$1]: F4,
+  [F5$1]: F5,
+  [F6$1]: F6,
+  [Home$1]: Home,
+  [Insert$1]: Insert,
+  [KeyA$1]: KeyA,
+  [KeyB$1]: KeyB,
+  [KeyC$1]: KeyC,
+  [KeyD$1]: KeyD,
+  [KeyE$1]: KeyE,
+  [KeyF$1]: KeyF,
+  [KeyG$1]: KeyG,
+  [KeyH$1]: KeyH,
+  [KeyI$1]: KeyI,
+  [KeyJ$1]: KeyJ,
+  [KeyK$1]: KeyK,
+  [KeyL$1]: KeyL,
+  [KeyM$1]: KeyM,
+  [KeyN$1]: KeyN,
+  [KeyO$1]: KeyO,
+  [KeyP$1]: KeyP,
+  [KeyQ$1]: KeyQ,
+  [KeyR$1]: KeyR,
+  [KeyS$1]: KeyS,
+  [KeyT$1]: KeyT,
+  [KeyU$1]: KeyU,
+  [KeyV$1]: KeyV,
+  [KeyW$1]: KeyW,
+  [KeyX$1]: KeyX,
+  [KeyY$1]: KeyY,
+  [KeyZ$1]: KeyZ,
+  [LeftArrow$1]: LeftArrow,
+  [Minus$1]: Minus,
+  [PageDown$1]: PageDown,
+  [PageUp$1]: PageUp,
+  [Plus$1]: Plus,
+  [RightArrow$1]: RightArrow,
+  [Space$1]: Space,
+  [Star$1]: Star,
+  [Tab$1]: Tab,
+  [UpArrow$1]: UpArrow
+};
+const getKeyCodeString = keyCode => {
+  return keyCodeStringMap[keyCode] || Unknown;
+};
+
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
+
+const Edit$2 = 2;
+const File$3 = 5;
+const Go$2 = 6;
+const Help$3 = 7;
+const OpenRecent$1 = 9;
+const Run$2 = 10;
+const Selection$2 = 11;
+const Terminal$2 = 14;
+const TitleBar$3 = 15;
+const View$2 = 16;
+const TitleBarContextMenu = 90;
+
+const SubMenu$2 = 4;
+
+const parseKey = rawKey => {
+  const isCtrl = Boolean(rawKey & CtrlCmd);
+  const isShift = Boolean(rawKey & Shift);
+  const keyCode = rawKey & 0x00_00_00_ff;
+  const key = getKeyCodeString(keyCode);
+  return {
+    isCtrl,
+    isShift,
+    key
+  };
+};
+
+const Electron$1 = 2;
+
+const RendererWorker = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+
+const FocusTitleBarMenuBar = 26;
+
+const {
+  invoke,
+  invokeAndTransfer,
+  set: set$1
+} = create$2(RendererWorker);
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const getWindowId$1 = async () => {
+  return invoke('GetWindowId.getWindowId');
+};
+const minimizeWindow = async () => {
+  return invoke('ElectronWindow.minimize');
+};
+const maximizeWindow = async () => {
+  return invoke('ElectronWindow.maximize');
+};
+const closeWindow = async () => {
+  return invoke('ElectronWindow.close');
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$1 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        scheduledState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, scheduledState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(Number);
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState, scheduledState) {
+      states[uid] = {
+        newState,
+        oldState,
+        scheduledState: scheduledState ?? newState
+      };
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
+};
+
+const Web = 1;
+const Electron = 2;
+const Remote = 3;
+
+const DEFAULT_UID = 1;
+const DEFAULT_APP_NAME = 'Lvce Editor';
+const DEFAULT_MAIN_AREA_UID$1 = 2;
+const createDefaultState = (uid = DEFAULT_UID) => ({
+  appName: DEFAULT_APP_NAME,
+  assetDir: '',
+  buttons: [],
+  commandCenterEnabled: false,
+  commandMap: {},
+  controlsOverlayEnabled: false,
+  focused: false,
+  focusedIndex: -1,
+  height: 30,
+  iconWidth: 30,
+  isMenuOpen: false,
+  labelFontFamily: 'system-ui, Ubuntu, Droid Sans, sans-serif',
+  labelFontSize: 13,
+  labelFontWeight: 400,
+  labelLetterSpacing: 0,
+  labelPadding: 8,
+  layoutControlsEnabled: false,
+  mainAreaUid: DEFAULT_MAIN_AREA_UID$1,
+  menus: [],
+  platform: Electron,
+  title: '',
+  titleBarButtons: [],
+  titleBarButtonsEnabled: true,
+  titleBarButtonsWidth: 90,
+  titleBarEntries: [],
+  titleBarHeight: 30,
+  titleBarIconEnabled: true,
+  titleBarIconWidth: 30,
+  titleBarMenuBarEnabled: true,
+  titleBarStyleCustom: true,
+  titleBarTitleEnabled: true,
+  titleTemplate: '${folderName}',
+  titleWidth: 0,
+  uid,
+  width: 800,
+  workspaceUri: '',
+  x: 0,
+  y: 0
+});
+
+const HandleClick = 1;
+const HandleClickMinimize = 2;
+const HandleClickClose = 3;
+const HandleClickToggleMaximize = 4;
+const HandleFocusIn = 5;
+const HandleFocusOut = 6;
+const HandlePointerOut = 7;
+const HandlePointerOver = 8;
+const HandleMenuClick = 9;
+const HandleMenuMouseOver = 10;
+const HandleContextMenu = 11;
+const HandleTitleBarContextMenu = 12;
+
+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 Appearance = 'Appearance';
+const Chat = 'Chat';
+const ClearRecentlyOpened = 'Clear Recently Opened';
+const Close = 'Close';
+const Exit = 'Exit';
+const TitleBar$2 = 'Title Bar';
+const MenuBar = 'Menu Bar';
+const CommandCenter = 'Command Center';
+const CommandPalette = 'Command Palette';
+const Edit$1 = 'Edit';
+const EditorLayout = 'Editor Layout';
+const FlipLayout = 'Flip Layout';
+const GridTwoByTwo = 'Grid (2x2)';
+const Explorer = 'Explorer';
+const File$2 = 'File';
+const Go$1 = 'Go';
+const Help$2 = 'Help';
+const Maximize = 'Maximize';
+const Minimize = 'Minimize';
+const MoreDot = 'More ...';
+const NewTerminal = 'New Terminal';
+const OpenView = 'Open View';
+const OpenProcessExplorer = 'Open Process Explorer';
+const Output = 'Output';
+const Problems = 'Problems';
+const Run$1 = 'Run';
+const Search = 'Search';
+const Selection$1 = 'Selection';
+const SourceControl = 'Source Control';
+const Terminal$1 = 'Terminal';
+const ToggleDeveloperTools = 'Toggle Developer Tools';
+const View$1 = 'View';
+const WordWrap = 'Word Wrap';
+const Extensions = 'Extensions';
+const AddCursorAbove = 'Add Cursor Above';
+const AddCursorBelow = 'Add Cursor Below';
+const AddCursorsToLineEnds = 'Add Cursors to Line ends';
+const AddNextOccurrence = 'Add Next Occurrence';
+const AddPreviousOccurrence = 'Add Previous Occurrence';
+const Copy$1 = 'Copy';
+const CopyEditorIntoNewWindow = 'Copy Editor into New Window';
+const CopyLineDown = 'Copy Line Down';
+const CopyLineUp = 'Copy Line Up';
+const Cut$1 = 'Cut';
+const DuplicateSelection = 'Duplicate Selection';
+const ExpandSelection = 'Expand Selection';
+const MoveLineDown = 'Move Line Down';
+const MoveLineUp = 'Move Line Up';
+const MoveEditorIntoNewWindow = 'Move Editor into New Window';
+const Paste$1 = 'Paste';
+const Redo$1 = 'Redo';
+const SelectAll$1 = 'Select All';
+const SelectAllOccurrences = 'Select All Occurrences';
+const ShrinkSelection = 'Shrink Selection';
+const Single = 'Single';
+const SplitDown = 'Split Down';
+const SplitLeft = 'Split Left';
+const SplitRight = 'Split Right';
+const SplitUp = 'Split Up';
+const ThreeColumns = 'Three Columns';
+const ThreeRows = 'Three Rows';
+const ToggleBlockComment = 'Toggle Block Comment';
+const ToggleLineComment = 'Toggle Line Comment';
+const TwoColumns = 'Two Columns';
+const TwoColumnsBottom = 'Two Columns Bottom';
+const TwoRows = 'Two Rows';
+const TwoRowsRight = 'Two Rows Right';
+const Undo$1 = 'Undo';
+
+const file = () => {
+  return i18nString(File$2);
+};
+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$2);
+};
+const minimize$1 = () => {
+  return i18nString(Minimize);
+};
+const maximize$1 = () => {
+  return i18nString(Maximize);
+};
+const close$1 = () => {
+  return i18nString(Close);
+};
+const titleBar = () => {
+  return i18nString(TitleBar$2);
+};
+const menuBar = () => {
+  return i18nString(MenuBar);
+};
+const commandCenter = () => {
+  return i18nString(CommandCenter);
+};
+const copy$1 = () => {
+  return i18nString(Copy$1);
+};
+const cut$1 = () => {
+  return i18nString(Cut$1);
+};
+const exit$1 = () => {
+  return i18nString(Exit);
+};
+const paste$1 = () => {
+  return i18nString(Paste$1);
+};
+const redo$1 = () => {
+  return i18nString(Redo$1);
+};
+const selectAll$1 = () => {
+  return i18nString(SelectAll$1);
+};
+const toggleDeveloperTools$1 = () => {
+  return i18nString(ToggleDeveloperTools);
+};
+const undo$1 = () => {
+  return i18nString(Undo$1);
+};
+
+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 [{
+      icon: 'Minimize',
+      id: 'Minimize',
+      label: minimize$1(),
+      onClick: HandleClickMinimize
+    }, {
+      icon: 'Maximize',
+      id: 'ToggleMaximize',
+      label: maximize$1(),
+      onClick: HandleClickToggleMaximize
+    }, {
+      icon: 'ChromeClose',
+      id: 'Close',
+      label: close$1(),
+      onClick: HandleClickClose
+    }];
+  }
+  return [];
+};
+
+const getTitleBarButtonsRemote = () => {
+  return [];
+};
+
+const getTitleBarButtonsWeb = () => {
+  return [];
+};
+
+const getTitleBarButtons = (platform, controlsOverlayEnabled, titleBarStyleCustom) => {
+  switch (platform) {
+    case Electron:
+      return getTitleBarButtonsElectron(controlsOverlayEnabled, titleBarStyleCustom);
+    case Remote:
+      return getTitleBarButtonsRemote();
+    case Web:
+      return getTitleBarButtonsWeb();
+    default:
+      return [];
+  }
+};
+
+const {
+  get,
+  getCommandIds,
+  registerCommands,
+  set,
+  wrapCommand,
+  wrapGetter
+} = create$1();
+
+const create3 = (id, uri, x, y, width, height, platform, controlsOverlayEnabled, titleBarStyleCustom, assetDir) => {
+  const titleBarButtons = getTitleBarButtons(platform, controlsOverlayEnabled, titleBarStyleCustom);
+  const state = {
+    ...createDefaultState(),
+    assetDir,
+    commandCenterEnabled: false,
+    commandMap: {},
+    controlsOverlayEnabled,
+    focused: false,
+    focusedIndex: -1,
+    height,
+    iconWidth: 30,
+    isMenuOpen: false,
+    labelFontFamily: 'system-ui, Ubuntu, Droid Sans, sans-serif',
+    labelFontSize: 13,
+    labelFontWeight: 400,
+    labelLetterSpacing: 0,
+    labelPadding: 8,
+    layoutControlsEnabled: false,
+    menus: [],
+    platform,
+    titleBarButtons,
+    titleBarEntries: [],
+    titleBarHeight: height,
+    titleBarStyleCustom,
+    uid: id,
+    width,
+    workspaceUri: '',
+    x,
+    y
+  };
+  set(id, state, state);
+};
+
+const isEqual$3 = (oldState, newState) => {
+  return oldState.titleBarEntries === newState.titleBarEntries && oldState.width === newState.width && oldState.focusedIndex === newState.focusedIndex && oldState.isMenuOpen === newState.isMenuOpen && oldState.title === newState.title && oldState.workspaceUri === newState.workspaceUri;
+};
+
+const isEqual$2 = (oldState, newState) => {
+  return oldState.focused || !newState.focused;
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focusedIndex === newState.focusedIndex && oldState.isMenuOpen === newState.isMenuOpen;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.menus === newState.menus;
+};
+
+const RenderEntries = 1;
+const RenderFocusedIndex = 2;
+const RenderMenus = 3;
+const RenderFocusContext = 4;
+
+const modules = [isEqual$3, isEqual$1, isEqual, isEqual$2];
+const numbers = [RenderEntries, RenderFocusedIndex, RenderMenus, RenderFocusContext];
+
+const diff3 = uid => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const Separator$1 = 1;
+const None = 0;
+const SubMenu$1 = 4;
+const Checked = 2;
+const Unchecked = 3;
+const Disabled = 5;
+const RestoreFocus = 6;
+const Ignore = 7;
+
+const getMenuEntriesTitleBarContextMenu = async state => {
+  const {
+    commandCenterEnabled,
+    titleBarMenuBarEnabled
+  } = state;
+  // TODO checked state should be depending on whether or not that feature is currently visible or not
+  return [{
+    command: titleBarMenuBarEnabled ? 'TitleBar.hideMenuBar' : 'TitleBar.showMenuBar',
+    flags: titleBarMenuBarEnabled ? Checked : Unchecked,
+    id: 'MenuBar',
+    label: menuBar()
+  }, {
+    command: commandCenterEnabled ? 'TitleBar.hideCommandCenter' : 'TitleBar.showCommandCenter',
+    flags: commandCenterEnabled ? Checked : Unchecked,
+    id: 'Command center',
+    label: commandCenter()
+  }, {
+    command: '',
+    flags: Checked,
+    id: 'layout controls',
+    label: 'layout controls'
+  }];
+};
+
+const MenuIdTitleBarContextMenu = 50;
+const MenuIdAppearance = 'appearance';
+const MenuIdEditorLayout = 'editorLayout';
+const MenuIdSwitchEditor = 'switchEditor';
+const MenuIdSwitchGroup = 'switchGroup';
+const getMenuIds = () => {
+  return [Edit$2, File$3, Go$2, Help$3, OpenRecent$1, Run$2, Selection$2, Terminal$2, TitleBar$3, View$2, MenuIdAppearance, MenuIdEditorLayout, MenuIdSwitchEditor, MenuIdSwitchGroup, MenuIdTitleBarContextMenu, TitleBarContextMenu];
+};
+
+const hasActiveTextEditor = async mainAreaUid => {
+  try {
+    return await invoke('Main.hasActiveTextEditor', mainAreaUid);
+  } catch {
+    return false;
+  }
+};
+
+const menuEntrySeparator = {
+  command: '',
+  flags: Separator$1,
+  id: 'separator',
+  label: ''
+};
+
+const notImplementedArgs$1 = [{
+  message: 'not implemented'
+}];
+const entry = (id, label, keyboardShortCut = '') => {
+  return {
+    args: notImplementedArgs$1,
+    command: 'Dialog.showMessage',
+    flags: None,
+    id,
+    keyboardShortCut,
+    label
+  };
+};
+const checkedEntry = (id, label, keyboardShortCut = '') => {
+  return {
+    args: notImplementedArgs$1,
+    command: 'Dialog.showMessage',
+    flags: Checked,
+    id,
+    keyboardShortCut,
+    label
+  };
+};
+const getMenuEntries$e = () => {
+  return [entry('fullScreen', 'Full Screen', 'F11'), entry('zenMode', 'Zen Mode', 'Ctrl+K Z'), entry('centeredLayout', 'Centered Layout'), menuEntrySeparator, checkedEntry('menuBar', 'Menu Bar'), entry('primarySideBar', 'Primary Side Bar', 'Ctrl+B'), entry('secondarySideBar', 'Secondary Side Bar', 'Ctrl+Alt+B'), checkedEntry('statusBar', 'Status Bar'), checkedEntry('panel', 'Panel', 'Ctrl+J'), menuEntrySeparator, entry('movePrimarySideBarLeft', 'Move Primary Side Bar Left'), entry('activityBarPosition', 'Activity Bar Position'), entry('panelPosition', 'Panel Position'), entry('alignPanel', 'Align Panel'), entry('tabBar', 'Tab Bar'), entry('editorActionsPosition', 'Editor Actions Position'), menuEntrySeparator, entry('minimap', 'Minimap'), entry('breadcrumbs', 'Breadcrumbs'), entry('stickyScroll', 'Sticky Scroll'), entry('renderWhitespace', 'Render Whitespace'), checkedEntry('renderControlCharacters', 'Render Control Characters'), menuEntrySeparator, entry('zoomIn', 'Zoom In', 'Ctrl+='), entry('zoomOut', 'Zoom Out', 'Ctrl+-'), entry('resetZoom', 'Reset Zoom', 'Ctrl+NumPad0')];
+};
+
+const cut = () => {
+  return i18nString(Cut$1);
+};
+const copy = () => {
+  return i18nString(Copy$1);
+};
+const paste = () => {
+  return i18nString(Paste$1);
+};
+const undo = () => {
+  return i18nString(Undo$1);
+};
+const redo = () => {
+  return i18nString(Redo$1);
+};
+const toggleLineComment = () => {
+  return i18nString(ToggleLineComment);
+};
+const toggleBlockComment = () => {
+  return i18nString(ToggleBlockComment);
+};
+const selectAll = () => {
+  return i18nString(SelectAll$1);
+};
+const expandSelection = () => {
+  return i18nString(ExpandSelection);
+};
+const shrinkSelection = () => {
+  return i18nString(ShrinkSelection);
+};
+const copyLineUp = () => {
+  return i18nString(CopyLineUp);
+};
+const copyLineDown = () => {
+  return i18nString(CopyLineDown);
+};
+const moveLineUp = () => {
+  return i18nString(MoveLineUp);
+};
+const moveLineDown = () => {
+  return i18nString(MoveLineDown);
+};
+const duplicateSelection = () => {
+  return i18nString(DuplicateSelection);
+};
+const addCursorAbove = () => {
+  return i18nString(AddCursorAbove);
+};
+const addCursorBelow = () => {
+  return i18nString(AddCursorBelow);
+};
+const addCursorsToLineEnds = () => {
+  return i18nString(AddCursorsToLineEnds);
+};
+const addNextOccurrence = () => {
+  return i18nString(AddNextOccurrence);
+};
+const addPreviousOccurrence = () => {
+  return i18nString(AddPreviousOccurrence);
+};
+const selectAllOccurrences = () => {
+  return i18nString(SelectAllOccurrences);
+};
+
+const getMenuEntries$d = () => {
+  return [{
+    command: /* TODO */'-1',
+    flags: None,
+    id: 'undo',
+    label: undo()
+  }, {
+    command: /* TODO */'-1',
+    flags: None,
+    id: 'redo',
+    label: redo()
+  }, menuEntrySeparator, {
+    command: /* Editor.cut */'Editor.cut',
+    flags: None,
+    id: 'cut',
+    label: cut()
+  }, {
+    command: /* Editor.copy */'Editor.copy',
+    flags: None,
+    id: 'copy',
+    label: copy()
+  }, {
+    command: /* Editor.paste */'Editor.paste',
+    flags: None,
+    id: 'paste',
+    label: paste()
+  }, menuEntrySeparator, {
+    command: /* Editor.toggleLineComment */'Editor.toggleLineComment',
+    flags: None,
+    id: 'toggle-line-comment',
+    label: toggleLineComment()
+  }, {
+    command: /* Editor.toggleBlockComment */'Editor.toggleBlockComment',
+    flags: None,
+    id: 'toggle-block-comment',
+    label: toggleBlockComment()
+  }];
+};
+
+const getMenuEntries$c = () => {
+  return [{
+    command: 'MainArea.splitUp',
+    flags: None,
+    id: 'splitUp',
+    keyboardShortCut: 'Ctrl+K Ctrl+\\',
+    label: i18nString(SplitUp)
+  }, {
+    command: 'MainArea.splitDown',
+    flags: None,
+    id: 'splitDown',
+    label: i18nString(SplitDown)
+  }, {
+    command: 'MainArea.splitLeft',
+    flags: None,
+    id: 'splitLeft',
+    label: i18nString(SplitLeft)
+  }, {
+    command: 'MainArea.splitRight',
+    flags: None,
+    id: 'splitRight',
+    label: i18nString(SplitRight)
+  }, menuEntrySeparator, {
+    command: 'MainArea.moveIntoNewWindow',
+    flags: None,
+    id: 'moveEditorIntoNewWindow',
+    label: i18nString(MoveEditorIntoNewWindow)
+  }, {
+    command: 'MainArea.copyIntoNewWindow',
+    flags: None,
+    id: 'copyEditorIntoNewWindow',
+    keyboardShortCut: 'Ctrl+K O',
+    label: i18nString(CopyEditorIntoNewWindow)
+  }, menuEntrySeparator, {
+    command: 'MainArea.setEditorLayoutSingle',
+    flags: None,
+    id: 'single',
+    label: i18nString(Single)
+  }, {
+    command: 'MainArea.setEditorLayoutTwoColumns',
+    flags: None,
+    id: 'twoColumns',
+    label: i18nString(TwoColumns)
+  }, {
+    command: 'MainArea.setEditorLayoutThreeColumns',
+    flags: None,
+    id: 'threeColumns',
+    label: i18nString(ThreeColumns)
+  }, {
+    command: 'MainArea.setEditorLayoutTwoRows',
+    flags: None,
+    id: 'twoRows',
+    label: i18nString(TwoRows)
+  }, {
+    command: 'MainArea.setEditorLayoutThreeRows',
+    flags: None,
+    id: 'threeRows',
+    label: i18nString(ThreeRows)
+  }, {
+    command: 'MainArea.setEditorLayoutGrid',
+    flags: None,
+    id: 'gridTwoByTwo',
+    label: i18nString(GridTwoByTwo)
+  }, {
+    command: 'MainArea.setEditorLayoutTwoRowsRight',
+    flags: None,
+    id: 'twoRowsRight',
+    label: i18nString(TwoRowsRight)
+  }, {
+    command: 'MainArea.setEditorLayoutTwoColumnsBottom',
+    flags: None,
+    id: 'twoColumnsBottom',
+    label: i18nString(TwoColumnsBottom)
+  }, menuEntrySeparator, {
+    command: 'MainArea.flipEditorLayout',
+    flags: None,
+    id: 'flipLayout',
+    keyboardShortCut: 'Shift+Alt+8',
+    label: i18nString(FlipLayout)
+  }];
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  AutoSave: 'Auto Save',
+  Exit: 'Exit',
+  NewFile: 'New File',
+  NewWindow: 'New Window',
+  OpenFile: 'Open File',
+  OpenFolder: 'Open Folder',
+  OpenRecent: 'Open Recent',
+  Save: 'Save',
+  SaveAll: 'Save All'};
+const autoSave = () => {
+  return i18nString(UiStrings.AutoSave);
+};
+const newFile = () => {
+  return i18nString(UiStrings.NewFile);
+};
+const newWindow = () => {
+  return i18nString(UiStrings.NewWindow);
+};
+const openFile = () => {
+  return i18nString(UiStrings.OpenFile);
+};
+const openFolder = () => {
+  return i18nString(UiStrings.OpenFolder);
+};
+const openRecent = () => {
+  return i18nString(UiStrings.OpenRecent);
+};
+const save = () => {
+  return i18nString(UiStrings.Save);
+};
+const saveAll = () => {
+  return i18nString(UiStrings.SaveAll);
+};
+const exit = () => {
+  return i18nString(UiStrings.Exit);
+};
+
+const Edit = 2;
+const File$1 = 5;
+const Go = 6;
+const Help$1 = 7;
+const OpenRecent = 9;
+const Run = 10;
+const Selection = 11;
+const Terminal = 14;
+const TitleBar$1 = 15;
+const View = 16;
+
+const getAutoSave = async () => {
+  try {
+    return await invoke('Preferences.get', 'files.autoSave');
+  } catch {
+    return 'off';
+  }
+};
+const isAutoSaveEnabled = autoSave => {
+  return autoSave !== 'off';
+};
+const getSaveFlags = hasActiveTextEditor => {
+  if (hasActiveTextEditor) {
+    return None;
+  }
+  return Disabled;
+};
+const getMenuEntries$b = async (platform, autoSave$1, hasActiveTextEditor = false) => {
+  const autoSaveValue = autoSave$1 ?? (await getAutoSave());
+  const saveFlags = getSaveFlags(hasActiveTextEditor);
+  const entries = [{
+    command: 'Main.newFile',
+    flags: None,
+    id: 'newFile',
+    label: newFile()
+  }, {
+    command: 'Window.openNew',
+    flags: None,
+    id: 'newWindow',
+    label: newWindow()
+  }, menuEntrySeparator, {
+    command: 'Dialog.openFile',
+    flags: None,
+    id: 'openFile',
+    label: openFile()
+  }, {
+    command: 'Dialog.openFolder',
+    flags: RestoreFocus,
+    id: 'openFolder',
+    label: openFolder()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: OpenRecent,
+    label: openRecent()
+  }, menuEntrySeparator, {
+    command: 'Main.save',
+    flags: saveFlags,
+    id: 'save',
+    label: save()
+  }, {
+    command: 'Main.saveAll',
+    flags: saveFlags,
+    id: 'saveAll',
+    label: saveAll()
+  }, menuEntrySeparator, {
+    command: 'Preferences.toggleAutoSave',
+    flags: isAutoSaveEnabled(autoSaveValue) ? Checked : Unchecked,
+    id: 'autoSave',
+    label: autoSave()
+  }];
+  if (platform === Electron) {
+    entries.push(menuEntrySeparator, {
+      command: 'Chrome.exit',
+      flags: Ignore,
+      id: 'exit',
+      label: exit()
+    });
+  }
+  return entries;
+};
+
+const notImplementedMessage = {
+  message: 'Not implemented'
+};
+const notImplementedArgs = [notImplementedMessage, ['OK']];
+const notImplementedEntry = (id, label) => {
+  return {
+    args: notImplementedArgs,
+    command: 'Dialog.showMessage',
+    flags: None,
+    id,
+    label
+  };
+};
+const getMenuEntries$a = () => {
+  return [notImplementedEntry('back', 'Back'), notImplementedEntry('forward', 'Forward'), notImplementedEntry('lastEditLocation', 'Last Edit Location'), menuEntrySeparator, {
+    command: '',
+    flags: SubMenu$1,
+    id: MenuIdSwitchEditor,
+    label: 'Switch Editor'
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: MenuIdSwitchGroup,
+    label: 'Switch Group'
+  }, menuEntrySeparator, notImplementedEntry('goToFile', 'Go to File...'), notImplementedEntry('goToSymbolInWorkspace', 'Go to Symbol in Workspace...'), menuEntrySeparator, notImplementedEntry('goToSymbolInEditor', 'Go to Symbol in Editor...'), notImplementedEntry('goToDefinition', 'Go to Definition'), notImplementedEntry('goToDeclaration', 'Go to Declaration'), notImplementedEntry('goToTypeDefinition', 'Go to Type Definition'), notImplementedEntry('goToImplementations', 'Go to Implementations'), notImplementedEntry('goToReferences', 'Go to References'), menuEntrySeparator, notImplementedEntry('goToLineColumn', 'Go to Line/Column...'), notImplementedEntry('goToBracket', 'Go to Bracket'), menuEntrySeparator, notImplementedEntry('nextProblem', 'Next Problem'), notImplementedEntry('previousProblem', 'Previous Problem'), menuEntrySeparator, notImplementedEntry('nextChange', 'Next Change'), notImplementedEntry('previousChange', 'Previous Change')];
+};
+const getMenuEntriesSwitchEditor = () => {
+  return [notImplementedEntry('firstSideInEditor', 'First Side in Editor'), notImplementedEntry('secondSideInEditor', 'Second Side in Editor'), menuEntrySeparator, notImplementedEntry('nextEditor', 'Next Editor'), notImplementedEntry('previousEditor', 'Previous Editor'), menuEntrySeparator, notImplementedEntry('nextUsedEditor', 'Next Used Editor'), notImplementedEntry('previousUsedEditor', 'Previous Used Editor'), menuEntrySeparator, notImplementedEntry('nextEditorInGroup', 'Next Editor in Group'), notImplementedEntry('previousEditorInGroup', 'Previous Editor in Group'), menuEntrySeparator, notImplementedEntry('nextUsedEditorInGroup', 'Next Used Editor in Group'), notImplementedEntry('previousUsedEditorInGroup', 'Previous Used Editor in Group')];
+};
+const getMenuEntriesSwitchGroup = () => {
+  return [notImplementedEntry('nextGroup', 'Next Group'), notImplementedEntry('previousGroup', 'Previous Group'), menuEntrySeparator, notImplementedEntry('groupOne', 'Group 1'), notImplementedEntry('groupTwo', 'Group 2'), notImplementedEntry('groupThree', 'Group 3'), notImplementedEntry('groupFour', 'Group 4'), notImplementedEntry('groupFive', 'Group 5'), notImplementedEntry('lastGroup', 'Last Group')];
+};
+
+const toggleDeveloperTools = () => {
+  return i18nString(ToggleDeveloperTools);
+};
+const openProcessExplorer = () => {
+  return i18nString(OpenProcessExplorer);
+};
+const about = () => {
+  return i18nString(About);
+};
+
+const getMenuEntries$9 = async platform => {
+  const entries = [];
+  if (platform !== Web) {
+    entries.push({
+      command: 'Developer.toggleDeveloperTools',
+      flags: None,
+      id: 'toggleDeveloperTools',
+      label: toggleDeveloperTools()
+    }, {
+      command: 'Developer.openProcessExplorer',
+      flags: RestoreFocus,
+      id: 'openProcessExplorer',
+      label: openProcessExplorer()
+    });
+  }
+  if (entries.length > 0) {
+    entries.push(menuEntrySeparator);
+  }
+  entries.push({
+    command: 'About.showAbout',
+    flags: None,
+    id: 'about',
+    label: about()
+  });
+  return entries;
+};
+
+const DriveLetterProtocolRegex = /^[a-zA-Z]:$/;
+const normalizeUri = value => {
+  try {
+    const url = new URL(value);
+    if (DriveLetterProtocolRegex.test(url.protocol)) {
+      return '';
+    }
+    return url.href;
+  } catch {
+    return '';
+  }
+};
+const getRecentlyOpened = async () => {
+  const recentlyOpened = await invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  if (!Array.isArray(recentlyOpened)) {
+    return [];
+  }
+  const seen = new Set();
+  const uniqueUris = [];
+  for (const item of recentlyOpened) {
+    if (typeof item !== 'string') {
+      continue;
+    }
+    const uri = normalizeUri(item);
+    if (!uri || seen.has(uri)) {
+      continue;
+    }
+    seen.add(uri);
+    uniqueUris.push(uri);
+  }
+  return uniqueUris;
+};
+
+const moreDot = () => {
+  return i18nString(MoreDot);
+};
+const clearRecentlyOpened = () => {
+  return i18nString(ClearRecentlyOpened);
+};
+
+const File = 'file://';
+
+const HomeDirRegex = /^\/(?:home|Users)\/[^/]+/;
+const startsWithHomeDir = (homeDir, path) => {
+  return path === homeDir || path.startsWith(`${homeDir}/`);
+};
+const getPath = uri => {
+  if (uri.startsWith(File)) {
+    return uri.slice(File.length);
+  }
+  return uri;
+};
+const getHomeDir = uri => {
+  const path = getPath(uri);
+  const match = HomeDirRegex.exec(path);
+  return match?.[0] || '';
+};
+const getTitle$1 = (homeDir, uri) => {
+  if (!uri) {
+    return '';
+  }
+  const path = getPath(uri);
+  if (path !== uri) {
+    if (homeDir && startsWithHomeDir(homeDir, path)) {
+      return `~${path.slice(homeDir.length)}`;
+    }
+    return path;
+  }
+  // TODO tree shake this out in web
+  if (homeDir && startsWithHomeDir(homeDir, uri)) {
+    return `~${uri.slice(homeDir.length)}`;
+  }
+  return uri;
+};
+
+const toMenuItem = folder => {
+  const homeDir = getHomeDir(folder);
+  const label = getTitle$1(homeDir, folder);
+  return {
+    args: [folder],
+    command: 'Workspace.setPath',
+    flags: None,
+    label
+  };
+};
+
+const MAX_MENU_RECENT_ENTRIES = 10;
+const getMenuEntries$8 = 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);
+  }
+  items.push({
+    command: 'QuickPick.showRecent',
+    flags: None,
+    id: 'more',
+    label: moreDot()
+  }, menuEntrySeparator, {
+    command: 'RecentlyOpened.clearRecentlyOpened',
+    flags: None,
+    id: 'clearRecentlyOpened',
+    label: clearRecentlyOpened()
+  });
+  return items;
+};
+
+const getMenuEntries$7 = () => {
+  return [];
+};
+
+const getMenuEntries$6 = () => {
+  return [{
+    command: 'Editor.selectAll',
+    flags: None,
+    id: 'selectAll',
+    label: selectAll()
+  }, {
+    command: 'Editor.expandSelection',
+    flags: None,
+    id: 'expandSelection',
+    label: expandSelection()
+  }, {
+    command: 'Editor.shrinkSelection',
+    flags: None,
+    id: 'shrinkSelection',
+    label: shrinkSelection()
+  }, menuEntrySeparator, {
+    command: 'Editor.copyLineUp',
+    flags: None,
+    id: 'copyLineUp',
+    label: copyLineUp()
+  }, {
+    command: 'Editor.copyLineDown',
+    flags: None,
+    id: 'copyLineDown',
+    label: copyLineDown()
+  }, {
+    command: 'Editor.moveLineUp',
+    flags: None,
+    id: 'moveLineUp',
+    label: moveLineUp()
+  }, {
+    command: 'Editor.moveLineDown',
+    flags: None,
+    id: 'moveLineDown',
+    label: moveLineDown()
+  }, {
+    command: 'Editor.duplicateSelection',
+    flags: None,
+    id: 'duplicateSelection',
+    label: duplicateSelection()
+  }, menuEntrySeparator, {
+    command: 'Editor.addCursorAbove',
+    flags: None,
+    id: 'addCursorAbove',
+    label: addCursorAbove()
+  }, {
+    command: 'Editor.addCursorBelow',
+    flags: None,
+    id: 'addCursorBelow',
+    label: addCursorBelow()
+  }, {
+    command: 'Editor.addCursorsToLineEnds',
+    flags: None,
+    id: 'addCursorsToLineEnds',
+    label: addCursorsToLineEnds()
+  }, {
+    command: 'Editor.addNextOccurrence',
+    flags: None,
+    id: 'addNextOccurrence',
+    label: addNextOccurrence()
+  }, {
+    command: 'Editor.addPreviousOccurrence',
+    flags: None,
+    id: 'addPreviousOccurrence',
+    label: addPreviousOccurrence()
+  }, {
+    command: 'Editor.selectAllOccurrences',
+    flags: None,
+    id: 'selectAllOccurrences',
+    label: selectAllOccurrences()
+  }];
+};
+
+const getMenuEntries$5 = () => {
+  return [{
+    args: ['Terminal'],
+    command: 'Layout.togglePanel',
+    flags: None,
+    id: 'newTerminal',
+    label: i18nString(NewTerminal)
+  }];
+};
+
+const getMenuEntries$4 = () => {
+  return [{
+    command: '',
+    flags: SubMenu$1,
+    id: File$1,
+    label: file()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Edit,
+    label: edit()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Selection,
+    label: selection()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: View,
+    label: view()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Go,
+    label: go()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Run,
+    keyboardShortCut: 'Alt+r',
+    label: run()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Terminal,
+    keyboardShortCut: 'Alt+t',
+    label: terminal()
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: Help$1,
+    keyboardShortCut: 'Alt+h',
+    label: help()
+  }];
+};
+
+const getMenuEntries$3 = () => {
+  return [{
+    command: '',
+    flags: None,
+    id: File$1,
+    label: file()
+  }, {
+    command: '',
+    flags: None,
+    id: Edit,
+    label: edit()
+  }, {
+    command: '',
+    flags: None,
+    id: Selection,
+    label: selection()
+  }, {
+    command: '',
+    flags: None,
+    id: View,
+    label: view()
+  }, {
+    command: '',
+    flags: None,
+    id: Go,
+    label: go()
+  }, {
+    command: '',
+    flags: None,
+    id: Help$1,
+    label: help()
+  }];
+};
+
+const getFn$1 = platform => {
+  switch (platform) {
+    case Web:
+      return getMenuEntries$3;
+    default:
+      return getMenuEntries$4;
+  }
+};
+const getMenuEntries$2 = async platform => {
+  const fn = getFn$1(platform);
+  return fn();
+};
+
+const getMenuEntries$1 = () => {
+  return [{
+    command: 'Command.openCommandPalette',
+    flags: None,
+    id: 'commandPalette',
+    label: i18nString(CommandPalette)
+  }, {
+    command: 'View.openView',
+    flags: None,
+    id: 'openView',
+    label: i18nString(OpenView)
+  }, menuEntrySeparator, {
+    command: '',
+    flags: SubMenu$1,
+    id: 'appearance',
+    label: i18nString(Appearance)
+  }, {
+    command: '',
+    flags: SubMenu$1,
+    id: 'editorLayout',
+    label: i18nString(EditorLayout)
+  }, menuEntrySeparator, {
+    command: 'Explorer.focus',
+    flags: None,
+    id: 'explorer',
+    label: i18nString(Explorer)
+  }, {
+    command: 'Search.focus',
+    flags: None,
+    id: 'search',
+    label: i18nString(Search)
+  }, {
+    command: 'SourceControl.focus',
+    flags: None,
+    id: 'sourceControl',
+    label: i18nString(SourceControl)
+  }, {
+    command: 'Run.focus',
+    flags: None,
+    id: 'run',
+    label: i18nString(Run$1)
+  }, {
+    command: 'Extensions.focus',
+    flags: None,
+    id: 'extensions',
+    label: i18nString(Extensions)
+  }, menuEntrySeparator, {
+    command: 'Chat.focus',
+    flags: None,
+    id: 'chat',
+    label: i18nString(Chat)
+  }, menuEntrySeparator, {
+    command: 'Problems.toggle',
+    flags: None,
+    id: 'problems',
+    label: i18nString(Problems)
+  }, {
+    command: 'Output.toggle',
+    flags: None,
+    id: 'output',
+    label: i18nString(Output)
+  }, {
+    args: ['Terminal'],
+    command: 'Layout.togglePanel',
+    flags: None,
+    id: 'terminal',
+    label: i18nString(Terminal$1)
+  }, {
+    command: 'Editor.toggleWordWrap',
+    flags: None,
+    id: 'wordWrap',
+    label: i18nString(WordWrap)
+  }];
+};
+
+const DEFAULT_MAIN_AREA_UID = 2;
+const getMenuEntries2 = async (state, props) => {
+  switch (props.menuId) {
+    case Edit$2:
+      return getMenuEntries$d();
+    case File$3:
+      return getMenuEntries$b(props.platform, undefined, await hasActiveTextEditor(state.mainAreaUid ?? DEFAULT_MAIN_AREA_UID));
+    case Go$2:
+      return getMenuEntries$a();
+    case Help$3:
+      return getMenuEntries$9(props.platform);
+    case OpenRecent$1:
+      return getMenuEntries$8();
+    case Run$2:
+      return getMenuEntries$7();
+    case Selection$2:
+      return getMenuEntries$6();
+    case Terminal$2:
+      return getMenuEntries$5();
+    case TitleBar$3:
+      return getMenuEntries$2(props.platform);
+    case TitleBarContextMenu:
+    case MenuIdTitleBarContextMenu:
+      return getMenuEntriesTitleBarContextMenu(state);
+    case View$2:
+      return getMenuEntries$1();
+    // @ts-ignore
+    case MenuIdAppearance:
+      return getMenuEntries$e();
+    // @ts-ignore
+    case MenuIdEditorLayout:
+      return getMenuEntries$c();
+    // @ts-ignore
+    case MenuIdSwitchEditor:
+      return getMenuEntriesSwitchEditor();
+    // @ts-ignore
+    case MenuIdSwitchGroup:
+      return getMenuEntriesSwitchGroup();
+    default:
+      return [];
+  }
+};
+
+const getEntryMap = async (state, menuIds, platform) => {
+  const map = Object.create(null);
+  for (const id of menuIds) {
+    const entries = await getMenuEntries2(state, {
+      // @ts-ignore
+      menuId: id,
+      platform
+    });
+    map[id] = entries;
+  }
+  return map;
+};
+
+// TODO cache window id
+
+const getWindowId = async () => {
+  const windowId = await getWindowId$1();
+  return windowId;
+};
+
+// based on https://www.electronjs.org/docs/latest/api/menu-item#new-menuitemoptions
+
+const Undo = 'undo';
+const Redo = 'redo';
+const Cut = 'cut';
+const Copy = 'copy';
+const Paste = 'paste';
+const SelectAll = 'selectAll';
+const ToggleDevTools = 'toggleDevTools';
+const Help = 'help';
+const Quit = 'quit';
+const FileMenu = 'fileMenu';
+const EditMenu = 'editMenu';
+
+// based on https://www.electronjs.org/docs/latest/api/menu-item#new-menuitemoptions
+const Separator = 'separator';
+const SubMenu = 'submenu';
+
+const toElectronMenuItem = entry => {
+  switch (entry.label) {
+    case copy$1():
+      return {
+        label: entry.label,
+        role: Copy
+      };
+    case cut$1():
+      return {
+        label: entry.label,
+        role: Cut
+      };
+    case edit():
+      return {
+        label: entry.label,
+        role: EditMenu,
+        submenu: []
+      };
+    case exit$1():
+      return {
+        label: entry.label,
+        role: Quit
+      };
+    case file():
+      return {
+        label: entry.label,
+        role: FileMenu,
+        submenu: []
+      };
+    case help():
+      return {
+        label: entry.label,
+        role: Help,
+        submenu: []
+      };
+    case paste$1():
+      return {
+        label: entry.label,
+        role: Paste
+      };
+    case redo$1():
+      return {
+        label: entry.label,
+        role: Redo
+      };
+    case selectAll$1():
+      return {
+        label: entry.label,
+        role: SelectAll
+      };
+    case toggleDeveloperTools$1():
+      return {
+        label: entry.label,
+        role: ToggleDevTools
+      };
+    case undo$1():
+      return {
+        label: entry.label,
+        role: Undo
+      };
+  }
+  switch (entry.flags) {
+    case Separator$1:
+      return {
+        type: Separator
+      };
+    case SubMenu$1:
+      return {
+        label: entry.label,
+        submenu: [],
+        type: SubMenu
+      };
+    default:
+      return {
+        label: entry.label
+      };
+  }
+};
+
+const toElectronMenuInternal = (commandMap, map, id, electronMenu) => {
+  object(commandMap);
+  object(map);
+  array(electronMenu);
+  const entries = map[id];
+  array(entries);
+  for (const entry of entries) {
+    if (entry.command) {
+      commandMap[entry.label] = {
+        args: entry.args,
+        command: entry.command
+      };
+    }
+    const electronEntry = toElectronMenuItem(entry);
+    if (entry.flags === SubMenu$2 && entry.id !== undefined && map[entry.id]) {
+      toElectronMenuInternal(commandMap, map, entry.id, electronEntry.submenu);
+    }
+    electronMenu.push(electronEntry);
+  }
+  return {
+    commandMap,
+    electronMenu
+  };
+};
+
+const toElectronMenu = (map, rootId) => {
+  const electronMenu = [];
+  const commandMap = Object.create(null);
+  toElectronMenuInternal(commandMap, map, rootId, electronMenu);
+  return {
+    commandMap,
+    electronMenu
+  };
+};
+
+const setItems = async items => {
+  const windowId = await getWindowId();
+  return invoke('WebView.compatSharedProcessInvoke', 'ElectronApplicationMenu.setItems', windowId, items);
+};
+const hydrate = async state => {
+  const {
+    platform
+  } = state;
+  const ids = getMenuIds();
+  const map = await getEntryMap(state, ids, platform);
+  const {
+    commandMap,
+    electronMenu
+  } = toElectronMenu(map, TitleBar$1);
+  await setItems(electronMenu);
+  // TODO get all menu items
+  // TODO send menu items to electron
+  // TODO add listener for when menu items change
+  return {
+    ...state,
+    commandMap
+  };
+};
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
+};
+
+const getKeyBindings = () => {
+  return [{
+    command: 'TitleBar.handleKeyArrowDown',
+    key: DownArrow$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyArrowUp',
+    key: UpArrow$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyArrowRight',
+    key: RightArrow$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyArrowLeft',
+    key: LeftArrow$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeySpace',
+    key: Space$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyHome',
+    key: Home$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyEnd',
+    key: End$1,
+    when: FocusTitleBarMenuBar
+  }, {
+    command: 'TitleBar.handleKeyEscape',
+    key: Escape$1,
+    when: FocusTitleBarMenuBar
+  }];
+};
+
+const maximize = async () => {
+  await maximizeWindow();
+};
+const minimize = async () => {
+  await minimizeWindow();
+};
+const close = async () => {
+  await closeWindow();
+};
+
+const handleClickClose = async state => {
+  await close();
+  return state;
+};
+
+const handleClickMinimize = async state => {
+  await minimize();
+  return state;
+};
+
+const handleClickToggleMaximize = async state => {
+  const fn = maximize;
+  await fn();
+  return state;
+};
+
+const handleClick$1 = async (state, buttonName) => {
+  if (buttonName === 'Minimize') {
+    return handleClickMinimize(state);
+  }
+  if (buttonName === 'ToggleMaximize') {
+    return handleClickToggleMaximize(state);
+  }
+  if (buttonName === 'Close') {
+    return handleClickClose(state);
+  }
+  return state;
+};
+
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
+};
+
+const handleContextMenu = async (state, button, eventX, eventY) => {
+  const {
+    uid
+  } = state;
+  await show2(uid, MenuIdTitleBarContextMenu, eventX, eventY, {
+    menuId: MenuIdTitleBarContextMenu
+  });
+  return state;
+};
+
+const handleElectronMenuClick = async (state, label) => {
+  const {
+    commandMap
+  } = state;
+  const commandPair = commandMap[label];
+  if (!commandPair) {
+    throw new Error(`no command found for ${label}`);
+  }
+  const {
+    args = [],
+    command
+  } = commandPair;
+  await invoke(command, ...args);
+  return state;
+};
+
+const getMenuOffset = (x, clientX, iconWidth) => {
+  return clientX - x - iconWidth;
+};
+
+const Ellipsis = 'Ellipsis';
+
+const MoreEntryWidth = 38;
+const OverflowMenuId = 'title-bar-overflow';
+const getTotalWidth$1 = entries => {
+  let total = 0;
+  for (const entry of entries) {
+    total += entry.width;
+  }
+  return total;
+};
+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];
+    const nextTotal = total + entry.width;
+    if (nextTotal >= width) {
+      break;
+    }
+    total = nextTotal;
+    const visibleIndex = visible.length;
+    const isOpen = visibleIndex === focusedIndex && isMenuOpen;
+    const isFocused = visibleIndex === focusedIndex;
+    visible.push({
+      ...entry,
+      isFocused,
+      isOpen
+    });
+  }
+  const hasOverflow = visible.length < entries.length;
+  if (hasOverflow) {
+    while (visible.length > 0 && getTotalWidth$1(visible) + MoreEntryWidth > width) {
+      visible.pop();
+    }
+    const hiddenEntries = entries.slice(visible.length);
+    const overflowIndex = visible.length;
+    visible.push({
+      ariaLabel: moreDot(),
+      hiddenEntries,
+      icon: Ellipsis,
+      id: OverflowMenuId,
+      isFocused: overflowIndex === focusedIndex,
+      isOpen: overflowIndex === focusedIndex && isMenuOpen,
+      label: '...',
+      width: MoreEntryWidth
+    });
+  }
+  return visible;
+};
+
+const hasOverflowEntry = entries => {
+  return entries.some(entry => entry?.id === OverflowMenuId);
+};
+const getNavigableTitleBarEntries = state => {
+  const {
+    focusedIndex,
+    isMenuOpen,
+    titleBarEntries,
+    width
+  } = state;
+  if (hasOverflowEntry(titleBarEntries)) {
+    return titleBarEntries;
+  }
+  return getVisibleTitleBarEntries(titleBarEntries, width, focusedIndex, isMenuOpen);
+};
+
+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 getTotalWidth = entries => {
+  let total = 0;
+  for (const entry of entries) {
+    total += entry.width;
+  }
+  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) {
+    height += item.flags === Separator$1 ? CONTEXT_MENU_SEPARATOR_HEIGHT : CONTEXT_MENU_ITEM_HEIGHT;
+  }
+  return height;
+};
+
+// TODO lazyload menuEntries and use Command.execute (maybe)
+const MENU_WIDTH = 150;
+const CONTEXT_MENU_WIDTH = 250;
+const getMenuWidth = () => {
+  return CONTEXT_MENU_WIDTH;
+};
+
+// 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 getIndexToFocusFirst = items => {
+  return getIndexToFocusNextStartingAt(items, 0);
+};
+const getIndexToFocusLast = items => {
+  return getIndexToFocusPreviousStartingAt(items, items.length - 1);
+};
+
+// 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 -1;
+};
+const getIndexToFocusPrevious = menu => {
+  const startIndex = (menu.focusedIndex === -1 ? menu.items.length : menu.focusedIndex) - 1;
+  return getIndexToFocusPreviousStartingAt(menu.items, startIndex);
+};
+const canBeFocused = item => {
+  switch (item.flags) {
+    case Disabled:
+    case Separator$1:
+      return false;
+    default:
+      return true;
+  }
+};
+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 getOverflowMenuItems = hiddenEntries => {
+  return hiddenEntries.map(entry => ({
+    command: '',
+    flags: SubMenu$1,
+    id: entry.id,
+    label: entry.label
+  }));
+};
+const openMenuAtIndex = async (state, index, shouldBeFocused) => {
+  const {
+    iconWidth,
+    platform,
+    titleBarHeight,
+    x
+  } = state;
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  // TODO race conditions
+  // TODO send renderer process
+  // 1. open menu, items to show
+  // 2. focus menu
+  const titleBarEntry = titleBarEntries[index];
+  if (!titleBarEntry) {
+    return state;
+  }
+  const {
+    id
+  } = titleBarEntry;
+  const items = id === OverflowMenuId ? getOverflowMenuItems(titleBarEntry.hiddenEntries || []) : await getMenuEntries2(state, {
+    menuId: id,
+    platform
+  });
+  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 + iconWidth;
+  const menuY = titleBarHeight;
+  const width = getMenuWidth();
+  const height = getMenuHeight(items);
+  const menuFocusedIndex = shouldBeFocused ? getIndexToFocusNextStartingAt(items, 0) : -1;
+  const menu = {
+    focusedIndex: menuFocusedIndex,
+    height,
+    id: id === OverflowMenuId ? undefined : id,
+    items,
+    level: 0,
+    width,
+    x: menuX,
+    y: menuY
+  };
+  const menus = [menu];
+  return {
+    ...state,
+    focusedIndex: index,
+    isMenuOpen: true,
+    menus
+  };
+};
+
+const focusIndex = async (state, index) => {
+  object(state);
+  number(index);
+  const {
+    focusedIndex,
+    isMenuOpen
+  } = state;
+  if (index === focusedIndex) {
+    return state;
+  }
+  if (isMenuOpen) {
+    return openMenuAtIndex(state, index, /* focus */false);
+  }
+  return {
+    ...state,
+    focusedIndex: index
+  };
+};
+
+const handleMouseOutMenuClosed = state => {
+  return focusIndex(state, -1);
+};
+
+const handleMouseOutMenuOpen = state => {
+  return state;
+};
+
+const ifElse = (menuOpenFunction, menuClosedFunction) => {
+  const ifElseFunction = (state, ...args) => {
+    const {
+      isMenuOpen
+    } = state;
+    if (isMenuOpen) {
+      return menuOpenFunction(state, ...args);
+    }
+    return menuClosedFunction(state, ...args);
+  };
+  return ifElseFunction;
+};
+
+const handleMouseOut = ifElse(handleMouseOutMenuOpen, handleMouseOutMenuClosed);
+
+const handlePointerOut = (state, clientX, clientY) => {
+  const {
+    iconWidth,
+    x
+  } = state;
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const menuX = getMenuOffset(x, clientX, iconWidth);
+  const index = getTitleBarIndexFromPosition(titleBarEntries, menuX);
+  if (index === -1) {
+    return state;
+  }
+  return handleMouseOut(state);
+};
+
+const handleMouseOverMenuClosed = (state, index) => {
+  return focusIndex(state, index);
+};
+
+const handleMouseOverMenuOpen = async (state, index) => {
+  if (index === -1) {
+    return state;
+  }
+  return focusIndex(state, index);
+};
+
+const handleMouseOver = ifElse(handleMouseOverMenuOpen, handleMouseOverMenuClosed);
+
+const handlePointerOver = (state, name) => {
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const index = titleBarEntries.findIndex(item => item.label === name);
+  if (index === -1) {
+    return state;
+  }
+  return handleMouseOver(state, index);
+};
+
+const handleTitleBarContextMenu = async state => {
+  return state;
+};
+
+/**
+ * Parses a title template string and replaces special variables with their values.
+ * Supported variables:
+ * - ${folderName} - The name of the workspace folder
+ * - ${appName} - The name of the application
+ *
+ * @param template - The template string to parse
+ * @param folderName - The name of the workspace folder
+ * @param appName - The name of the application
+ * @returns The parsed title string
+ */
+const parseTitleTemplate = (template, folderName, appName) => {
+  return template.replaceAll('${folderName}', () => folderName).replaceAll('${appName}', () => appName);
+};
+
+const getTitle = (workspaceUri, titleTemplate, appName) => {
+  if (!workspaceUri) {
+    return '';
+  }
+  const slashIndex = workspaceUri.lastIndexOf('/');
+  if (slashIndex === -1) {
+    return '';
+  }
+  const folderName = workspaceUri.slice(slashIndex + 1);
+
+  // If titleTemplate is empty, return folderName directly
+  if (!titleTemplate) {
+    return folderName;
+  }
+
+  // If titleTemplate doesn't contain variables, return the template itself
+  if (!titleTemplate.includes('${')) {
+    return titleTemplate;
+  }
+  return parseTitleTemplate(titleTemplate, folderName, appName);
+};
+
+const launchTextMeasurementWorker = async () => {
+  const rpc = await create$4({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToTextMeasurementWorker(port);
+    }
+  });
+  return {
+    invoke: rpc.invoke.bind(rpc),
+    async [Symbol.asyncDispose]() {
+      await rpc.dispose();
+    }
+  };
+};
+
+const measureTextWidths2 = async (texts, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  if (typeof letterSpacing !== 'number') {
+    throw new TypeError('letterSpacing must be of type number');
+  }
+  await using rpc = await launchTextMeasurementWorker();
+  const isMonospaceFont = false;
+  const charWidth = 0;
+  const result = await rpc.invoke('TextMeasurement.measureTextWidths', texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  return result;
+};
+
+const measureTextWidths = async (texts, fontWeight, fontSize, fontFamily, letterSpacing) => measureTextWidths2(texts, fontWeight, fontSize, fontFamily, letterSpacing);
+
+const measureTitleWidth = async (title, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const [titleWidth = 0] = await measureTextWidths([title], fontWeight, fontSize, fontFamily, letterSpacing);
+  return titleWidth;
+};
+
+// TODO in the future, it could also be a multi-root workspace
+const handleWorkspaceChange = async (state, uri) => {
+  const {
+    appName,
+    labelFontFamily,
+    labelFontSize,
+    labelFontWeight,
+    labelLetterSpacing,
+    titleTemplate
+  } = state;
+  const title = getTitle(uri, titleTemplate, appName);
+  const titleWidth = await measureTitleWidth(title, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
+  return {
+    ...state,
+    title,
+    titleWidth,
+    workspaceUri: uri
+  };
+};
+
+const hideCommandCenter = async state => {
+  return {
+    ...state,
+    commandCenterEnabled: false
+  };
+};
+
+const hideMenuBar = async state => {
+  return {
+    ...state,
+    titleBarMenuBarEnabled: false
+  };
+};
+
+const getLabel = entry => {
+  return entry.label;
+};
+const getWithWidths = (entries, widths, labelPadding) => {
+  const withWidths = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const textWidth = widths[i];
+    const width = textWidth + labelPadding * 2;
+    withWidths.push({
+      ...entry,
+      width
+    });
+  }
+  return withWidths;
+};
+const addWidths = async (entries, labelPadding, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const labels = entries.map(getLabel);
+  const widths = await measureTextWidths(labels, fontWeight, fontSize, fontFamily, letterSpacing);
+  const withWidths = getWithWidths(entries, widths, labelPadding);
+  return withWidths;
+};
+
+const getTitleBarMenuBarWidth = (windowWidth, menuBarX, iconWidth, titleWidth) => {
+  return windowWidth / 2 - titleWidth / 2 - menuBarX - iconWidth;
+};
+
+const getWorkspaceUri = () => {
+  return invoke('Workspace.getUri');
+};
+
+const loadContent2 = async state => {
+  const {
+    controlsOverlayEnabled,
+    labelFontFamily,
+    labelFontSize,
+    labelFontWeight,
+    labelLetterSpacing,
+    labelPadding,
+    platform,
+    titleBarStyleCustom
+  } = state;
+  const titleBarEntries = await getMenuEntries$2(platform);
+  const withWidths = await addWidths(titleBarEntries, labelPadding, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
+  const buttons = getTitleBarButtons(platform, controlsOverlayEnabled, titleBarStyleCustom);
+  const workspaceUri = await getWorkspaceUri();
+  const title = getTitle(workspaceUri, state.titleTemplate, state.appName);
+  const titleWidth = await measureTitleWidth(title, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
+  const iconWidth = 30;
+  const width = getTitleBarMenuBarWidth(state.width, state.x, iconWidth, titleWidth);
+
+  // TODO load preferences here
+
+  if (!titleBarStyleCustom && platform === Electron$1) {
+    return hydrate(state);
+  }
+  return {
+    ...state,
+    buttons,
+    iconWidth,
+    title,
+    titleBarButtons: buttons,
+    titleBarEntries: withWidths,
+    titleWidth,
+    width
+  };
+};
+
+const loadContent2Command = async uid => {
+  const {
+    newState
+  } = get(uid);
+  const loadedState = await loadContent2(newState);
+  const latest = get(uid);
+  const nextState = latest.newState.workspaceUri === newState.workspaceUri ? {
+    ...latest.newState,
+    ...loadedState
+  } : {
+    ...latest.newState,
+    ...loadedState,
+    title: latest.newState.title,
+    titleWidth: latest.newState.titleWidth,
+    workspaceUri: latest.newState.workspaceUri
+  };
+  set(uid, latest.oldState, nextState, nextState);
+};
+
+const renderFocusContext = (oldState, newState) => {
+  const {
+    uid
+  } = newState;
+  return [SetFocusContext, uid, FocusTitleBarMenuBar];
+};
+
+const renderFocusedIndex = (oldState, newState) => {
+  if (newState.focusedIndex === -1) {
+    return [];
+  }
+  return [FocusSelector, '.ViewletTitleBarMenuBar'];
+};
+
+const MaskIconCheck = 'MaskIconCheck';
+const Menu = 'Menu';
+const MenuItem = '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 TitleBar = 'TitleBar';
+const TitleBarButtons = 'TitleBarButtons';
+const TitleBarEntryActive = 'TitleBarEntryActive';
+const TitleBarIcon = 'TitleBarIcon';
+const TitleBarIconIcon = 'TitleBarIconIcon';
+const TitleBarMenuBar = 'TitleBarMenuBar';
+const TitleBarTopLevelEntry = 'TitleBarTopLevelEntry';
+const TitleBarTopLevelEntryLabel = 'TitleBarTopLevelEntryLabel';
+const Viewlet = 'Viewlet';
+
+const checkboxChecked = {
+  ariaChecked: true,
+  childCount: 2,
+  className: mergeClassNames(MenuItem, MenuItemCheckMark),
+  role: MenuItemCheckBox,
+  tabIndex: -1,
+  type: Div
+};
+const checkMark = {
+  className: mergeClassNames(MenuItemCheckmarkIcon, MaskIconCheck),
+  type: Div
+};
+const getMenuItemCheckedDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [checkboxChecked, checkMark, text(label)];
+};
+
+const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
+  let string = '';
+  if (ctrlKey) {
+    string += 'Ctrl+';
+  }
+  if (shiftKey) {
+    string += 'Shift+';
+  }
+  string += key.toUpperCase();
+  return string;
+};
+
+const getKeyDom = key => {
+  const parsedKey = parseKey(key);
+  const keyBindingsString = getKeyBindingString(parsedKey.key, false, parsedKey.isCtrl, parsedKey.isShift);
+  return [{
+    childCount: 1,
+    className: MenuItemKeyBinding,
+    type: Span
+  }, text(keyBindingsString)];
+};
+
+const classNameFocused = mergeClassNames(MenuItem, MenuItemFocused);
+const getMenuItemClassName = isFocused => {
+  if (isFocused) {
+    return classNameFocused;
+  }
+  return MenuItem;
+};
+const getMenuItemDefaultDom = menuItem => {
+  const {
+    isFocused,
+    key,
+    label
+  } = menuItem;
+  const className = getMenuItemClassName(isFocused);
+  const keyDom = key ? getKeyDom(key) : [];
+  const childCount = key ? 2 : 1;
+  return [{
+    childCount,
+    className,
+    role: MenuItem$1,
+    tabIndex: -1,
+    type: Div
+  }, text(label), ...keyDom];
+};
+
+const disabled = {
+  childCount: 1,
+  className: MenuItem,
+  disabled: true,
+  role: MenuItem$1,
+  tabIndex: -1,
+  type: Div
+};
+const getMenuItemDisabledDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [disabled, text(label)];
+};
+
+const getMenuItemsNoopDom = () => {
+  return [];
+};
+
+const separator = {
+  childCount: 1,
+  className: MenuItemSeparator,
+  role: Separator$2,
+  type: Div
+};
+const separatorLine = {
+  childCount: 0,
+  className: MenuItemSeparatorLine,
+  type: Div
+};
+const getMenuItemSeparatorDom = menuItem => {
+  return [separator, separatorLine];
+};
+
+const arrowRight = {
+  childCount: 0,
+  className: MenuItemSubMenuArrowRight,
+  type: Div
+};
+const getMenuItemSubMenuDom = menuItem => {
+  const {
+    isExpanded,
+    isFocused,
+    label,
+    level
+  } = menuItem;
+  const baseClassName = mergeClassNames(MenuItem, MenuItemSubMenu);
+  const className = isFocused ? mergeClassNames(baseClassName, MenuItemFocused) : baseClassName;
+  return [{
+    ariaExpanded: isExpanded,
+    ariaHasPopup: true,
+    ariaOwns: isExpanded ? `Menu-${level + 1}` : undefined,
+    childCount: 2,
+    className,
+    role: MenuItem$1,
+    tabIndex: -1,
+    type: Div
+  }, text(label), arrowRight];
+};
+
+const checkboxUnchecked = {
+  ariaChecked: false,
+  childCount: 1,
+  className: MenuItem,
+  role: MenuItemCheckBox,
+  tabIndex: -1,
+  type: Div
+};
+const getMenuItemUncheckedDom = menuItem => {
+  const {
+    label
+  } = menuItem;
+  return [checkboxUnchecked, text(label)];
+};
+
+const getMenuItemRenderer = flags => {
+  switch (flags) {
+    case Checked:
+      return getMenuItemCheckedDom;
+    case Disabled:
+      return getMenuItemDisabledDom;
+    case Ignore:
+    case None:
+    case RestoreFocus:
+      return getMenuItemDefaultDom;
+    case Separator$1:
+      return getMenuItemSeparatorDom;
+    case SubMenu$1:
+      return getMenuItemSubMenuDom;
+    case Unchecked:
+      return getMenuItemUncheckedDom;
+    default:
+      return getMenuItemsNoopDom;
+  }
+};
+
+const getMenuItemVirtualDom = menuItem => {
+  const {
+    flags
+  } = menuItem;
+  const fn = getMenuItemRenderer(flags);
+  return fn(menuItem);
+};
+
+const getMenuVirtualDom = menuItems => {
+  const dom = [{
+    childCount: menuItems.length,
+    className: Menu,
+    role: Menu$1,
+    tabIndex: -1,
+    type: Div
+  }, ...menuItems.flatMap(getMenuItemVirtualDom)];
+  return dom;
+};
+
+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({
+      flags,
+      isExpanded: i === focusedIndex && expanded,
+      isFocused: i === focusedIndex,
+      key: item.key,
+      label,
+      level
+    });
+  }
+  return visibleItems;
+};
+
+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 expanded = newMenu.expanded ?? false;
+      const visible = getVisible(newMenu.items, newMenu.focusedIndex, 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);
+    if (newMenu) {
+      const expanded = newMenu.expanded ?? false;
+      const visible = getVisible(newMenu.items, newMenu.focusedIndex, expanded, newMenu.level);
+      const dom = getMenuVirtualDom(visible).slice(1);
+      changes.push(['addMenu', newMenu, dom]);
+    }
+  } else if (difference < 0) {
+    changes.push(['closeMenus', newLength]);
+  }
+  const {
+    uid
+  } = newState;
+  return ['Viewlet.send', uid, /* method */SetMenus, /* changes */changes, uid];
+};
+
+const getIcon = assetDir => {
+  return `${assetDir}/icons/icon.svg`;
+};
+
+const getIconVirtualDom = (icon, type = Div) => {
+  return {
+    childCount: 0,
+    className: `MaskIcon MaskIcon${icon}`,
+    role: None$1,
+    type
+  };
+};
+
+const createTitleBarButton = button => {
+  const {
+    icon,
+    id,
+    label,
+    onClick
+  } = button;
+  const dom = [{
+    ariaLabel: label,
+    childCount: 1,
+    className: `TitleBarButton TitleBarButton${id}`,
+    name: id,
+    onClick,
+    type: Button$1
+  }, getIconVirtualDom(icon, I)];
+  return dom;
+};
+
+const getTitleBarButtonsVirtualDom = (buttonsEnabled, buttons) => {
+  if (!buttonsEnabled) {
+    return [];
+  }
+  return [{
+    childCount: buttons.length,
+    className: mergeClassNames(Viewlet, TitleBarButtons),
+    type: Div
+  }, ...buttons.flatMap(createTitleBarButton)];
+};
+
+const parentNode$1 = {
+  childCount: 1,
+  className: mergeClassNames(Viewlet, TitleBarIcon),
+  type: Div
+};
+const getTitleBarIconVirtualDom = (titleBarIconEnabled, iconSrc) => {
+  if (!titleBarIconEnabled) {
+    return [];
+  }
+  return [parentNode$1, {
+    alt: '',
+    childCount: 0,
+    className: TitleBarIconIcon,
+    src: iconSrc,
+    type: Img
+  }];
+};
+
+const getItemVirtualDom = item => {
+  // @ts-ignore
+  const {
+    ariaLabel,
+    isFocused,
+    isOpen,
+    keyboardShortCut,
+    label
+  } = item;
+  let className = TitleBarTopLevelEntry;
+  if (isFocused) {
+    className += ' ' + TitleBarEntryActive;
+  }
+  return [{
+    ariaExpanded: isOpen,
+    ariaHasPopup: true,
+    ariaKeyShortcuts: keyboardShortCut,
+    ariaLabel: ariaLabel || label,
+    ariaOwns: isOpen ? 'Menu-0' : undefined,
+    childCount: 1,
+    className,
+    id: isFocused ? 'TitleBarEntryActive' : undefined,
+    name: label,
+    // TODO have separate name attribute
+    role: MenuItem$1,
+    type: Button$1
+  }, ...(isFocused ? [{
+    childCount: 1,
+    className: TitleBarTopLevelEntryLabel,
+    type: Div
+  }] : []), text(label)];
+};
+const getTitleBarMenuBarItemsVirtualDom = visibleItems => {
+  const dom = visibleItems.flatMap(getItemVirtualDom);
+  return dom;
+};
+
+const activeId = 'TitleBarEntryActive';
+const getTitleBarMenuBarVirtualDom = (menuBarEnabled, visibleItems, focusedIndex) => {
+  if (!menuBarEnabled) {
+    return [];
+  }
+  return [{
+    ariaActivedescendant: focusedIndex === -1 ? '' : activeId,
+    childCount: visibleItems.length,
+    className: mergeClassNames(Viewlet, TitleBarMenuBar),
+    onFocusIn: HandleFocusIn,
+    onFocusOut: HandleFocusOut,
+    onMouseDown: HandleClick,
+    onPointerOut: HandlePointerOut,
+    onPointerOver: HandlePointerOver,
+    role: MenuBar$1,
+    tabIndex: 0,
+    type: Div
+  }, ...getTitleBarMenuBarItemsVirtualDom(visibleItems)];
+};
+
+const parentNode = {
+  childCount: 1,
+  className: 'TitleBarTitle',
+  type: Div
+};
+const getTitleVirtualDom = (titleBarTitleEnabled, title) => {
+  if (!titleBarTitleEnabled) {
+    return [];
+  }
+  return [parentNode, text(title)];
+};
+
+const getTitleBarVirtualDom = state => {
+  const {
+    assetDir,
+    focusedIndex,
+    isMenuOpen,
+    platform,
+    title,
+    titleBarButtons,
+    titleBarButtonsEnabled,
+    titleBarEntries,
+    titleBarIconEnabled,
+    titleBarMenuBarEnabled,
+    titleBarStyleCustom,
+    titleBarTitleEnabled,
+    width
+  } = state;
+  if (platform === Electron$1 && !titleBarStyleCustom) {
+    return [{
+      childCount: 0,
+      type: Div
+    }];
+  }
+  const iconSrc = getIcon(assetDir);
+  const visibleEntries = getVisibleTitleBarEntries(titleBarEntries, width, focusedIndex, isMenuOpen);
+  return [{
+    ariaLabel: titleBar(),
+    childCount: 4,
+    className: mergeClassNames(Viewlet, TitleBar),
+    id: 'TitleBar',
+    onContextMenu: HandleTitleBarContextMenu,
+    role: ContentInfo,
+    type: Div
+  }, ...getTitleBarIconVirtualDom(titleBarIconEnabled, iconSrc), ...getTitleBarMenuBarVirtualDom(titleBarMenuBarEnabled, visibleEntries, focusedIndex), ...getTitleVirtualDom(titleBarTitleEnabled, title), ...getTitleBarButtonsVirtualDom(titleBarButtonsEnabled, titleBarButtons)];
+};
+
+const renderTitleBar = (oldState, newState) => {
+  const dom = getTitleBarVirtualDom(newState);
+  return [SetDom2, newState.uid, dom];
+};
+
+const getRenderer3 = diffType => {
+  switch (diffType) {
+    case RenderEntries:
+      return renderTitleBar;
+    case RenderFocusContext:
+      return renderFocusContext;
+    case RenderFocusedIndex:
+      return renderFocusedIndex;
+    case RenderMenus:
+      return renderMenus;
+    default:
+      throw new Error('unknown renderer');
+  }
+};
+
+const render3 = async (uid, diffResult) => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  set(uid, newState, newState);
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer3(item);
+    const result = fn(oldState, newState);
+    if (result.length > 0) {
+      commands.push(result);
+    }
+  }
+  return commands;
+};
+
+const renderEventListeners = () => {
+  return [{
+    name: HandleClickMinimize,
+    params: ['handleClickMinimize']
+  }, {
+    name: HandleContextMenu,
+    params: ['handleContextMenu', Button, ClientX, ClientY]
+  }, {
+    name: HandleTitleBarContextMenu,
+    params: ['handleTitleBarContextMenu'],
+    preventDefault: true
+  }, {
+    name: HandleClickClose,
+    params: ['handleClickClose']
+  }, {
+    name: HandleClickToggleMaximize,
+    params: ['handleClickToggleMaximize']
+  }, {
+    name: HandleFocusIn,
+    params: ['handleFocus']
+  }, {
+    name: HandleMenuClick,
+    params: ['handleMenuClick', ClientX, ClientY]
+  }, {
+    name: HandleMenuMouseOver,
+    params: ['handleMenuMouseOver', ClientX, ClientY]
+  }, {
+    name: HandleClick,
+    params: ['handleClickAt', Button, ClientX, ClientY]
+  }, {
+    name: HandlePointerOut,
+    params: ['handlePointerOut', ClientX, ClientY]
+  }, {
+    name: HandlePointerOver,
+    params: ['handlePointerOver', TargetName]
+  }, {
+    name: HandleFocusOut,
+    params: ['handleFocusOut', ClientX, ClientY] // TODO maybe check relatedTarget
+  }];
+};
+
+const resize = async (state, dimensions) => {
+  const {
+    iconWidth,
+    titleWidth
+  } = state;
+  const menuBarX = dimensions.x;
+  const menuBarY = dimensions.y;
+  const menuBarWidth = getTitleBarMenuBarWidth(dimensions.width, menuBarX, iconWidth, titleWidth);
+  const menuBarHeight = dimensions.height;
+  return {
+    ...state,
+    ...dimensions,
+    height: menuBarHeight,
+    width: menuBarWidth,
+    x: menuBarX,
+    y: menuBarY
+  };
+};
+
+const saveState = state => {
+  const {
+    focusedIndex
+  } = state;
+  return {
+    focusedIndex
+  };
+};
+
+const setPlatform = (state, platform) => {
+  return {
+    ...state,
+    platform
+  };
+};
+
+const setTitleTemplate = async (state, titleTemplate) => {
+  const {
+    appName,
+    labelFontFamily,
+    labelFontSize,
+    labelFontWeight,
+    labelLetterSpacing,
+    workspaceUri
+  } = state;
+  const title = getTitle(workspaceUri, titleTemplate, appName);
+  const titleWidth = await measureTitleWidth(title, labelFontWeight, labelFontSize, labelFontFamily, labelLetterSpacing);
+  return {
+    ...state,
+    title,
+    titleTemplate,
+    titleWidth
+  };
+};
+
+const setWidth = (state, width) => {
+  const {
+    iconWidth,
+    titleWidth,
+    x
+  } = state;
+  return {
+    ...state,
+    width: getTitleBarMenuBarWidth(width, x, iconWidth, titleWidth)
+  };
+};
+
+const showCommandCenter = async state => {
+  return {
+    ...state,
+    commandCenterEnabled: true
+  };
+};
+
+const showMenuBar = async state => {
+  return {
+    ...state,
+    titleBarMenuBarEnabled: true
+  };
+};
+
+const create = (id, uri, x, y, width, height) => {
+  const state = {
+    ...createDefaultState(),
+    focusedIndex: -1,
+    height,
+    iconWidth: 30,
+    isMenuOpen: false,
+    labelFontFamily: 'system-ui, Ubuntu, Droid Sans, sans-serif',
+    labelFontSize: 13,
+    labelFontWeight: 400,
+    labelLetterSpacing: 0,
+    labelPadding: 8,
+    menus: [],
+    titleBarEntries: [],
+    titleBarHeight: height,
+    uid: id,
+    width,
+    x,
+    y
+  };
+  set(id, state, state);
+  return state;
+};
+
+const closeMenu = (state, keepFocus) => {
+  const {
+    focusedIndex
+  } = state;
+  // TODO send to renderer process
+  // 1. close menu
+  // 2. focus top level entry
+  const newFocusedIndex = keepFocus ? focusedIndex : -1;
+  return {
+    ...state,
+    focusedIndex: newFocusedIndex,
+    isMenuOpen: false,
+    menus: []
+  };
+};
+
+const first = () => {
+  return 0;
+};
+const last = items => {
+  return items.length - 1;
+};
+const next = (items, index) => {
+  return (index + 1) % items.length;
+};
+const previous = (items, index) => {
+  return (index === 0 ? items.length : index) - 1;
+};
+
+const focusFirst = state => {
+  const indexToFocus = first();
+  return focusIndex(state, indexToFocus);
+};
+
+const focus = state => {
+  return focusFirst(state);
+};
+
+const focusLast = state => {
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const indexToFocus = last(titleBarEntries);
+  return focusIndex(state, indexToFocus);
+};
+
+const focusNext = state => {
+  const {
+    focusedIndex
+  } = state;
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const indexToFocus = next(titleBarEntries, focusedIndex);
+  return focusIndex(state, indexToFocus);
+};
+
+const focusPrevious = state => {
+  const {
+    focusedIndex
+  } = state;
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const indexToFocus = previous(titleBarEntries, focusedIndex);
+  return focusIndex(state, indexToFocus);
+};
+
+const LeftClick = 0;
+
+const toggleIndex = async (state, index) => {
+  const {
+    focusedIndex,
+    isMenuOpen
+  } = state;
+  if (isMenuOpen && focusedIndex === index) {
+    return closeMenu(state, /* keepFocus */true);
+  }
+  return openMenuAtIndex(state, index, /* focus */false);
+};
+
+const handleClick = async (state, button, index) => {
+  if (button !== LeftClick) {
+    return state;
+  }
+  if (index === -1) {
+    return state;
+  }
+  return toggleIndex(state, index);
+};
+
+const handleClickAt = async (state, button, eventX, eventY) => {
+  const {
+    iconWidth,
+    x
+  } = state;
+  const titleBarEntries = getNavigableTitleBarEntries(state);
+  const menuOffset = getMenuOffset(x, eventX, iconWidth);
+  const index = getTitleBarIndexFromPosition(titleBarEntries, menuOffset);
+  if (index === -1) {
+    return state;
+  }
+  return handleClick(state, button, index);
+};
+
+const handleFocus = async state => {
+  return {
+    ...state,
+    focused: true
+  };
+};
+
+const handleFocusOut = async state => {
+  return state;
+};
+
+const openMenu = async (state, focus) => {
+  const {
+    focusedIndex
+  } = state;
+  if (focusedIndex === -1) {
+    return state;
+  }
+  return openMenuAtIndex(state, focusedIndex, focus);
+};
+
+const handleKeyArrowDownMenuClosed = state => {
+  return openMenu(state, /* focus */true);
+};
+
+const handleKeyArrowDownMenuOpen = state => {
+  const {
+    menus
+  } = state;
+  const menu = menus.at(-1);
+  if (!menu) {
+    return state;
+  }
+  const newFocusedIndex = getIndexToFocusNext(menu);
+  const newMenus = [...menus.slice(0, -1), {
+    ...menu,
+    focusedIndex: newFocusedIndex
+  }];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const handleKeyArrowDown = ifElse(handleKeyArrowDownMenuOpen, handleKeyArrowDownMenuClosed);
+
+const handleKeyArrowLeftMenuClosed = state => {
+  // TODO menu collapse
+  return focusPrevious(state);
+};
+
+const closeOneMenu = state => {
+  const {
+    menus
+  } = state;
+  const parentMenu = menus.at(-2);
+  if (!parentMenu) {
+    return state;
+  }
+  const newParentMenu = {
+    ...parentMenu,
+    expanded: false
+  };
+  const newMenus = [...menus.slice(0, -2), newParentMenu];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const handleKeyArrowLeftMenuOpen = async state => {
+  const {
+    menus
+  } = state;
+  if (menus.length > 1) {
+    return closeOneMenu(state);
+  }
+  return focusPrevious(state);
+};
+
+const handleKeyArrowLeft = ifElse(handleKeyArrowLeftMenuOpen, handleKeyArrowLeftMenuClosed);
+
+const getFn = id => {
+  switch (id) {
+    case Edit$2:
+      return getMenuEntries$d;
+    case File$3:
+      return getMenuEntries$b;
+    case Go$2:
+      return getMenuEntries$a;
+    case Help$3:
+      return getMenuEntries$9;
+    case OpenRecent$1:
+      return getMenuEntries$8;
+    case Run$2:
+      return getMenuEntries$7;
+    case Selection$2:
+      return getMenuEntries$6;
+    case Terminal$2:
+      return getMenuEntries$5;
+    case TitleBar$3:
+      return getMenuEntries$2;
+    case View$2:
+      return getMenuEntries$1;
+    case MenuIdAppearance:
+      return getMenuEntries$e;
+    case MenuIdEditorLayout:
+      return getMenuEntries$c;
+    default:
+      return undefined;
+  }
+};
+const getMenuEntries = async (id, ...args) => {
+  try {
+    const fn = getFn(id);
+    // @ts-ignore
+    return fn(...args);
+  } catch (error) {
+    throw new VError(error, `Failed to load menu entries for id ${id}`);
+  }
+};
+
+// TODO menu should not be needed initially, only when item is selected and menu is opened
+const handleKeyArrowRightMenuOpen = async state => {
+  const {
+    menus
+  } = state;
+  // if menu can open sub menu to the right -> do that
+  const menu = menus.at(-1);
+  if (!menu) {
+    return state;
+  }
+  const {
+    focusedIndex,
+    items,
+    x,
+    y
+  } = menu;
+  if (focusedIndex === -1) {
+    return focusNext(state);
+  }
+  const item = items[focusedIndex];
+  if (item.flags === SubMenu$1 && item.id !== undefined) {
+    const subMenuEntries = await getMenuEntries(item.id);
+    const subMenu = {
+      focusedIndex: 0,
+      items: subMenuEntries,
+      level: menus.length,
+      x: x + MENU_WIDTH,
+      y: y + focusedIndex * 25
+    };
+    const newParentMenu = {
+      ...menu,
+      expanded: true
+    };
+    const newMenus = [...menus.slice(0, -1), newParentMenu, subMenu];
+    return {
+      ...state,
+      menus: newMenus
+    };
+  }
+  return focusNext(state);
+};
+
+const handleKeyArrowRight = ifElse(handleKeyArrowRightMenuOpen, focusNext);
+
+const noop = state => {
+  return state;
+};
+
+const handleKeyArrowUpMenuOpen = state => {
+  const {
+    menus
+  } = state;
+  const menu = menus.at(-1);
+  if (!menu) {
+    return state;
+  }
+  const previousIndex = getIndexToFocusPrevious(menu);
+  const newMenus = [...menus.slice(0, -1), {
+    ...menu,
+    focusedIndex: previousIndex
+  }];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const handleKeyArrowUp = ifElse(handleKeyArrowUpMenuOpen, noop);
+
+const handleKeyEndMenuOpen = state => {
+  const {
+    menus
+  } = state;
+  const menu = menus[0];
+  const newFocusedIndex = getIndexToFocusLast(menu.items);
+  const newMenus = [{
+    ...menu,
+    focusedIndex: newFocusedIndex
+  }];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+// TODO this is also use for pagedown -> maybe find a better name for this function
+const handleKeyEnd = ifElse(handleKeyEndMenuOpen, focusLast);
+
+const handleKeyEnterMenuClosed = state => {
+  return openMenu(state, /* focus */true);
+};
+
+const handleKeyEnterMenuOpen = state => {
+  // TODO
+  // await Menu.selectCurrent()
+  return state;
+};
+
+const handleKeyEnter = ifElse(handleKeyEnterMenuOpen, handleKeyEnterMenuClosed);
+
+const handleKeyEscapeMenuOpen = state => {
+  const {
+    menus
+  } = state;
+  if (menus.length > 1) {
+    return closeOneMenu(state);
+  }
+  return closeMenu(state, /* keepFocus */true);
+};
+
+const handleKeyEscape = ifElse(handleKeyEscapeMenuOpen, noop);
+
+const handleKeyHomeMenuOpen = state => {
+  const {
+    menus
+  } = state;
+  const menu = menus[0];
+  const newFocusedIndex = getIndexToFocusFirst(menu.items);
+  const newMenus = [{
+    ...menu,
+    focusedIndex: newFocusedIndex
+  }];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const handleKeyHome = ifElse(handleKeyHomeMenuOpen, focusFirst);
+
+const handleKeySpaceMenuClosed = state => {
+  return openMenu(state, /* focus */true);
+};
+
+const handleKeySpaceMenuOpen = state => {
+  // TODO
+  // await Menu.selectCurrent()
+  return state;
+};
+
+// TODO this is same as handle key enter -> merge the functions
+const handleKeySpace = ifElse(handleKeySpaceMenuOpen, handleKeySpaceMenuClosed);
+
+const executeMenuItemCommand = async item => {
+  await invoke(item.command, ...(item.args || []));
+};
+
+const selectIndexIgnore = async (state, item) => {
+  await executeMenuItemCommand(item);
+  return state;
+};
+
+const selectIndexNone = async (state, item) => {
+  await executeMenuItemCommand(item);
+  return {
+    ...state,
+    focusedIndex: -1,
+    isMenuOpen: false,
+    menus: []
+  };
+};
+
+const selectIndexRestoreFocus = async (state, item) => {
+  await executeMenuItemCommand(item);
+  return {
+    ...state,
+    isMenuOpen: false,
+    menus: []
+  };
+};
+
+const selectIndexSubMenu = async (state, menu, index) => {
+  const {
+    menus
+  } = state;
+  const {
+    items,
+    level,
+    x,
+    y
+  } = menu;
+  const item = items[index];
+  if (!item.id) {
+    return state;
+  }
+  const subMenuEntries = await getMenuEntries(item.id);
+  const subMenu = {
+    focusedIndex: -1,
+    items: subMenuEntries,
+    level: menus.length,
+    x: x + MENU_WIDTH,
+    y: y + index * 25
+  };
+  const newParentMenu = {
+    ...menu,
+    focusedIndex: index
+  };
+  const newMenus = [...menus.slice(0, level - 1), newParentMenu, subMenu];
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const handleMenuClick = async (state, level, index) => {
+  const {
+    menus
+  } = state;
+  const menu = menus[level];
+  const item = menu.items[index];
+  if (!item) {
+    return state;
+  }
+  switch (item.flags) {
+    case Checked:
+      return selectIndexNone(state, item);
+    case Ignore:
+      return selectIndexIgnore(state, item);
+    case None:
+      return selectIndexNone(state, item);
+    case RestoreFocus:
+      return selectIndexRestoreFocus(state, item);
+    case SubMenu$1:
+      return selectIndexSubMenu(state, menu, index);
+    case Unchecked:
+      return selectIndexNone(state, item);
+    default:
+      return state;
+  }
+};
+
+const getNewMenus = async (menus, level, index, flags) => {
+  const menu = menus[level];
+  if (!menu) {
+    return menus;
+  }
+  const {
+    focusedIndex,
+    items,
+    x,
+    y
+  } = menu;
+  const item = items[index];
+  if (focusedIndex === index) {
+    if (index === -1) {
+      return menus;
+    }
+    if (item.flags === SubMenu$1 && level === menus.length - 2) {
+      const subMenu = menus[level + 1];
+      if (subMenu.focusedIndex !== -1) {
+        const newSubMenu = {
+          ...subMenu,
+          focusedIndex: -1
+        };
+        const newMenus = [...menus.slice(0, -1), newSubMenu];
+        return newMenus;
+      }
+    }
+    return menus;
+  }
+  if (index === -1) {
+    const newMenus = [...menus.slice(0, level), {
+      ...menu,
+      focusedIndex: -1
+    }];
+    return newMenus;
+  }
+  if (item.flags === SubMenu$1) {
+    const item = items[index];
+    if (!item.id) {
+      return menus;
+    }
+    const subMenuEntries = await getMenuEntries(item.id);
+    const subMenu = {
+      focusedIndex: -1,
+      items: subMenuEntries,
+      level: menus.length,
+      x: x + MENU_WIDTH,
+      y: y + index * 25
+    };
+    const newParentMenu = {
+      ...menu,
+      focusedIndex: index
+    };
+    const newMenus = [...menus.slice(0, level - 1), newParentMenu, subMenu];
+    return newMenus;
+  }
+  const newMenus = [...menus.slice(0, level), {
+    ...menu,
+    focusedIndex: index
+  }];
+  return newMenus;
+};
+const handleMenuMouseOver = async (state, level, index) => {
+  object(state);
+  number(level);
+  number(index);
+  const {
+    menus
+  } = state;
+  const menu = menus[level];
+  if (!menu) {
+    return state;
+  }
+  const {
+    items
+  } = menu;
+  const item = items[index];
+  if (!item) {
+    return state;
+  }
+  const newMenus = await getNewMenus(menus, level, index);
+  if (menus === newMenus) {
+    return state;
+  }
+  return {
+    ...state,
+    menus: newMenus
+  };
+};
+
+const toggleMenu = async state => {
+  const {
+    isMenuOpen
+  } = state;
+  if (isMenuOpen) {
+    return closeMenu(state, /* keepFocus */true);
+  }
+  return openMenu(state, /* focus */false);
+};
+
+const commandMap = {
+  'TitleBar.closeMenu': closeMenu,
+  'TitleBar.create': create,
+  'TitleBar.create3': create3,
+  'TitleBar.diff3': diff3,
+  'TitleBar.focus': wrapCommand(focus),
+  'TitleBar.focusFirst': wrapCommand(focusFirst),
+  'TitleBar.focusIndex': wrapCommand(focusLast),
+  'TitleBar.focusLast': wrapCommand(focusIndex),
+  'TitleBar.focusMenuBar': wrapCommand(focus),
+  'TitleBar.focusNext': wrapCommand(focusNext),
+  'TitleBar.focusPrevious': wrapCommand(focusPrevious),
+  'TitleBar.getCommandIds': getCommandIds,
+  'TitleBar.getCommands': getCommandIds,
+  'TitleBar.getKeyBindings': getKeyBindings,
+  'TitleBar.getMenuEntries2': getMenuEntries2,
+  'TitleBar.getMenuIds': getMenuIds,
+  'TitleBar.handleButtonsClick': handleClick$1,
+  'TitleBar.handleClick': wrapCommand(handleClick),
+  'TitleBar.handleClickAt': wrapCommand(handleClickAt),
+  'TitleBar.handleClickClose': wrapCommand(handleClickClose),
+  'TitleBar.handleClickMinimize': wrapCommand(handleClickMinimize),
+  'TitleBar.handleClickToggleMaximize': wrapCommand(handleClickToggleMaximize),
+  'TitleBar.handleContextMenu': wrapCommand(handleContextMenu),
+  'TitleBar.handleElectronMenuClick': wrapCommand(handleElectronMenuClick),
+  'TitleBar.handleFocus': wrapCommand(handleFocus),
+  'TitleBar.handleFocusOut': wrapCommand(handleFocusOut),
+  'TitleBar.handleKeyArrowDown': wrapCommand(handleKeyArrowDown),
+  'TitleBar.handleKeyArrowLeft': wrapCommand(handleKeyArrowLeft),
+  'TitleBar.handleKeyArrowRight': wrapCommand(handleKeyArrowRight),
+  'TitleBar.handleKeyArrowUp': wrapCommand(handleKeyArrowUp),
+  'TitleBar.handleKeyEnd': wrapCommand(handleKeyEnd),
+  'TitleBar.handleKeyEnter': wrapCommand(handleKeyEnter),
+  'TitleBar.handleKeyEscape': wrapCommand(handleKeyEscape),
+  'TitleBar.handleKeyHome': wrapCommand(handleKeyHome),
+  'TitleBar.handleKeySpace': wrapCommand(handleKeySpace),
+  'TitleBar.handleMenuClick': wrapCommand(handleMenuClick),
+  'TitleBar.handleMenuMouseOver': wrapCommand(handleMenuMouseOver),
+  'TitleBar.handleMouseOut': wrapCommand(handleMouseOut),
+  'TitleBar.handleMouseOver': wrapCommand(handleMouseOver),
+  'TitleBar.handlePointerOut': wrapCommand(handlePointerOut),
+  'TitleBar.handlePointerOver': wrapCommand(handlePointerOver),
+  'TitleBar.handleTitleBarContextMenu': wrapCommand(handleTitleBarContextMenu),
+  'TitleBar.handleWorkspaceChange': wrapCommand(handleWorkspaceChange),
+  'TitleBar.hideCommandCenter': wrapCommand(hideCommandCenter),
+  'TitleBar.hideMenuBar': wrapCommand(hideMenuBar),
+  'TitleBar.hydrateElectronApplicationMenu': wrapCommand(hydrate),
+  'TitleBar.loadContent2': loadContent2Command,
+  'TitleBar.render3': render3,
+  'TitleBar.renderEventListeners': renderEventListeners,
+  'TitleBar.resize': wrapCommand(resize),
+  'TitleBar.saveState': wrapGetter(saveState),
+  'TitleBar.setPlatform': wrapCommand(setPlatform),
+  'TitleBar.setTitleTemplate': wrapCommand(setTitleTemplate),
+  'TitleBar.setWidth': wrapCommand(setWidth),
+  'TitleBar.showCommandCenter': wrapCommand(showCommandCenter),
+  'TitleBar.showMenuBar': wrapCommand(showMenuBar),
+  'TitleBar.terminate': terminate,
+  'TitleBar.toggleIndex': wrapCommand(toggleIndex),
+  'TitleBar.toggleMenu': wrapCommand(toggleMenu)
+};
+
+const listen = async () => {
+  registerCommands(commandMap);
+  const rpc = await create$3({
+    commandMap: commandMap
+  });
+  set$1(rpc);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();