@lvce-editor/test-worker 10.14.0 → 11.0.0

package/dist/testWorkerMain.js

@@ -1,46 +1,3 @@
-const Directory = 3;
-
-const Script$1 = 2;
-
-const Web = 1;
-const Remote = 3;
-
-const EditorWorker = 99;
-const RendererWorker = 1;
-const TestWorker = 9001;
-
-const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
-};
-
-const create$4 = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get$2(rpcId);
-      await rpc.dispose();
-    },
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$2(rpcId, rpc);
-    }
-  };
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -499,7 +456,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$1 = async ({
+const create$5 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -550,14 +507,14 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
 
 const Two$1 = '2.0';
 const callbacks$1 = Object.create(null);
-const get$1 = id => {
+const get$2 = id => {
   return callbacks$1[id];
 };
 const remove$1 = id => {
@@ -706,7 +663,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve$1 = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -756,7 +713,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
     jsonrpc: Two$1,
     id,
@@ -767,7 +724,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
 const create$3 = (message, result) => {
   return {
@@ -892,14 +849,14 @@ const execute$2 = (command, ...args) => {
 };
 
 const Two = '2.0';
-const create$p = (method, params) => {
+const create$s = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$o = (id, method, params) => {
+const create$r = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -909,14 +866,14 @@ const create$o = (id, method, params) => {
   return message;
 };
 let id = 0;
-const create$n = () => {
+const create$q = () => {
   return ++id;
 };
 
 /* eslint-disable n/no-unsupported-features/es-syntax */
 
 const registerPromise = map => {
-  const id = create$n();
+  const id = create$q();
   const {
     promise,
     resolve
@@ -934,7 +891,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$o(id, method, params);
+  const message = create$r(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -970,7 +927,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$p(method, params);
+      const message = create$s(method, params);
       ipc.send(message);
     }
   };
@@ -1006,7 +963,54 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$g = async ({
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+const create$i = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$2({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+const LazyTransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$i
+};
+const create$d = async ({
   commandMap,
   isMessagePortOpen,
   messagePort
@@ -1024,9 +1028,9 @@ const create$g = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$g
+  create: create$d
 };
-const create$7 = async ({
+const create$4 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1043,7 +1047,7 @@ const create$7 = async ({
   messagePort.start();
   return rpc;
 };
-const create$5 = async ({
+const create$2 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1053,17 +1057,13 @@ const create$5 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$7({
+  return create$4({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$5
-};
-const create$2 = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1075,73 +1075,80 @@ const create$2 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$2
+  create: create$1$1
 };
 
-const {
-  invoke: invoke$1,
-  invokeAndTransfer,
-  set: set$1
-} = create$4(RendererWorker);
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+const Directory = 3;
+
+const Script$1 = 2;
+
+const Web = 1;
+const Remote = 3;
+
+const EditorWorker = 99;
+const RendererWorker = 1;
+const TestWorker = 9001;
+
+const rpcs = Object.create(null);
+const set$3 = (id, rpc) => {
+  rpcs[id] = rpc;
 };
-const getPreference = async key => {
-  return await invoke$1('Preferences.get', key);
+const get$1 = id => {
+  return rpcs[id];
 };
 
-const createLazyRpc = rpcId => {
-  let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$2(rpcId, rpc);
-  };
-  const ensureRpc = async () => {
-    if (!rpcPromise) {
-      rpcPromise = createRpc();
-    }
-    await rpcPromise;
-  };
+const create$1 = rpcId => {
   return {
-    async invoke(method, ...params) {
-      await ensureRpc();
-      const rpc = get$2(rpcId);
+    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);
     },
-    async invokeAndTransfer(method, ...params) {
-      await ensureRpc();
-      const rpc = get$2(rpcId);
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
-    setFactory(value) {
-      factory = value;
+    set(rpc) {
+      set$3(rpcId, rpc);
     }
   };
 };
 
-const lazyRpc = createLazyRpc(EditorWorker);
+const {
+  invoke: invoke$1,
+  set: set$2
+} = create$1(EditorWorker);
+
 const {
   invoke,
-  setFactory
-} = lazyRpc;
+  invokeAndTransfer,
+  set: set$1
+} = create$1(RendererWorker);
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const getPreference = async key => {
+  return await invoke('Preferences.get', key);
+};
 
 const send = async port => {
   await sendMessagePortToEditorWorker(port, TestWorker);
 };
-const launchEditorWorkerRpc = async () => {
-  const rpc = await TransferMessagePortRpcParent.create({
+const initializeEditorWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent.create({
     commandMap: {},
     send
   });
-  return rpc;
-};
-
-const initializeEditorWorker = async () => {
-  // TODO use lazyrpc
-  setFactory(launchEditorWorkerRpc);
+  set$2(rpc);
 };
 
 /* eslint-disable no-console */
@@ -1177,7 +1184,7 @@ const getLocatorInvoke = locator => {
     return module.invoke;
   }
   // @ts-ignore
-  return invoke$1;
+  return invoke;
 };
 
 const locatorInvoke = async (locator, method, ...params) => {
@@ -1468,8 +1475,8 @@ class Expect {
 }
 
 const Expect$1 = {
-    __proto__: null,
-    expect: expect$1
+  __proto__: null,
+  expect: expect$1
 };
 
 const nameAnonymousFunction = (fn, name) => {
@@ -1593,92 +1600,92 @@ test.skip = async id => {
   const background = 'yellow';
   const text = `test skipped ${id}`;
   // @ts-ignore
-  await invoke$1('TestFrameWork.showOverlay', state, background, text);
+  await invoke('TestFrameWork.showOverlay', state, background, text);
 };
 const {
   expect
 } = Expect$1;
 
 const show$6 = async () => {
-  return invoke$1('About.showAbout');
+  return invoke('About.showAbout');
 };
 const handleClickOk = async () => {
-  return invoke$1('About.handleClickOk');
+  return invoke('About.handleClickOk');
 };
 const handleClickClose = async () => {
-  return invoke$1('About.handleClickClose');
+  return invoke('About.handleClickClose');
 };
 const handleClickCopy = async () => {
-  return invoke$1('About.handleClickCopy');
+  return invoke('About.handleClickCopy');
 };
 const focusNext$9 = async () => {
-  return invoke$1('About.focusNext');
+  return invoke('About.focusNext');
 };
 const focusPrevious$8 = async () => {
-  return invoke$1('About.focusPrevious');
+  return invoke('About.focusPrevious');
 };
 
 const About = {
-    __proto__: null,
-    focusNext: focusNext$9,
-    focusPrevious: focusPrevious$8,
-    handleClickClose,
-    handleClickCopy,
-    handleClickOk,
-    show: show$6
+  __proto__: null,
+  focusNext: focusNext$9,
+  focusPrevious: focusPrevious$8,
+  handleClickClose,
+  handleClickCopy,
+  handleClickOk,
+  show: show$6
 };
 
 const focus$2 = async () => {
-  await invoke$1('ActivityBar.focus');
+  await invoke('ActivityBar.focus');
 };
 const focusFirst$7 = async () => {
-  await invoke$1('ActivityBar.focusFirst');
+  await invoke('ActivityBar.focusFirst');
 };
 const focusLast$6 = async () => {
-  await invoke$1('ActivityBar.focusLast');
+  await invoke('ActivityBar.focusLast');
 };
 const focusNext$8 = async () => {
-  await invoke$1('ActivityBar.focusNext');
+  await invoke('ActivityBar.focusNext');
 };
 const focusPrevious$7 = async () => {
-  await invoke$1('ActivityBar.focusPrevious');
+  await invoke('ActivityBar.focusPrevious');
 };
 const handleClick$3 = async index => {
-  await invoke$1('ActivityBar.handleClick', index);
+  await invoke('ActivityBar.handleClick', index);
 };
 const handleContextMenu$5 = async () => {
-  await invoke$1('ActivityBar.handleContextMenu');
+  await invoke('ActivityBar.handleContextMenu');
 };
 const selectCurrent = async () => {
-  await invoke$1('ActivityBar.selectCurrent');
+  await invoke('ActivityBar.selectCurrent');
 };
 
 const ActivityBar = {
-    __proto__: null,
-    focus: focus$2,
-    focusFirst: focusFirst$7,
-    focusLast: focusLast$6,
-    focusNext: focusNext$8,
-    focusPrevious: focusPrevious$7,
-    handleClick: handleClick$3,
-    handleContextMenu: handleContextMenu$5,
-    selectCurrent
+  __proto__: null,
+  focus: focus$2,
+  focusFirst: focusFirst$7,
+  focusLast: focusLast$6,
+  focusNext: focusNext$8,
+  focusPrevious: focusPrevious$7,
+  handleClick: handleClick$3,
+  handleContextMenu: handleContextMenu$5,
+  selectCurrent
 };
 
 const readNativeFiles = async () => {
-  await invoke$1('ClipBoard.readNativeFiles');
+  await invoke('ClipBoard.readNativeFiles');
 };
 const writeNativeFiles = async uris => {
   // @ts-ignore
-  await invoke$1('ClipBoard.writeNativeFiles', uris);
+  await invoke('ClipBoard.writeNativeFiles', uris);
 };
 const enableMemoryClipBoard = async () => {
   // @ts-ignore
-  await invoke$1('ClipBoard.enableMemoryClipBoard');
+  await invoke('ClipBoard.enableMemoryClipBoard');
 };
 const disableMemoryClipBoard = async () => {
   // @ts-ignore
-  await invoke$1('ClipBoard.disableMemoryClipBoard');
+  await invoke('ClipBoard.disableMemoryClipBoard');
 };
 const matchesExpectedText = (actualText, expectedText) => {
   if (typeof expectedText === 'string') {
@@ -1688,97 +1695,97 @@ const matchesExpectedText = (actualText, expectedText) => {
 };
 const shouldHaveText$1 = async expectedText => {
   // @ts-ignore
-  const actualText = await invoke$1('ClipBoard.readMemoryText');
+  const actualText = await invoke('ClipBoard.readMemoryText');
   if (!matchesExpectedText(actualText, expectedText)) {
     throw new AssertionError(`expected clipboard to have text "${expectedText}" but was "${actualText}"`);
   }
 };
 const writeText = async text => {
   // @ts-ignore
-  await invoke$1('ClipBoard.writeText', text);
+  await invoke('ClipBoard.writeText', text);
 };
 
 const ClipBoard = {
-    __proto__: null,
-    disableMemoryClipBoard,
-    enableMemoryClipBoard,
-    readNativeFiles,
-    shouldHaveText: shouldHaveText$1,
-    writeNativeFiles,
-    writeText
+  __proto__: null,
+  disableMemoryClipBoard,
+  enableMemoryClipBoard,
+  readNativeFiles,
+  shouldHaveText: shouldHaveText$1,
+  writeNativeFiles,
+  writeText
 };
 
 const setRelativeX = async x => {
-  await invoke$1('ColorPicker.setRelativeX', x);
+  await invoke('ColorPicker.setRelativeX', x);
 };
 
 const ColorPicker = {
-    __proto__: null,
-    setRelativeX
+  __proto__: null,
+  setRelativeX
 };
 
 const execute$1 = async (id, ...args) => {
   // @ts-ignore
-  return invoke$1(id, ...args);
+  return invoke(id, ...args);
 };
 
 const Command = {
-    __proto__: null,
-    execute: execute$1
+  __proto__: null,
+  execute: execute$1
 };
 
 const selectItem$1 = async text => {
-  await invoke$1('Menu.selectItem', text);
+  await invoke('Menu.selectItem', text);
 };
 
 const ContextMenu = {
-    __proto__: null,
-    selectItem: selectItem$1
+  __proto__: null,
+  selectItem: selectItem$1
 };
 
 const openIframeInspector = async () => {
   // @ts-ignore
-  return invoke$1('Developer.openIframeInspector');
+  return invoke('Developer.openIframeInspector');
 };
 const openCacheFolder = async () => {
   // @ts-ignore
-  return invoke$1('Developer.openCacheFolder');
+  return invoke('Developer.openCacheFolder');
 };
 const openConfigFolder = async () => {
   // @ts-ignore
-  return invoke$1('Developer.openConfigFolder');
+  return invoke('Developer.openConfigFolder');
 };
 const openLogsFolder = async () => {
   // @ts-ignore
-  return invoke$1('Developer.openLogsFolder');
+  return invoke('Developer.openLogsFolder');
 };
 const openProcessExplorer = async () => {
   // @ts-ignore
-  return invoke$1('Developer.openProcessExplorer');
+  return invoke('Developer.openProcessExplorer');
 };
 const reloadColorTheme = async () => {
   // @ts-ignore
-  return invoke$1('Developer.reloadColorTheme');
+  return invoke('Developer.reloadColorTheme');
 };
 const reloadIconTheme = async () => {
   // @ts-ignore
-  return invoke$1('Developer.reloadIconTheme');
+  return invoke('Developer.reloadIconTheme');
 };
 const toggleDeveloperTools = async () => {
   // @ts-ignore
-  return invoke$1('Developer.toggleDeveloperTools');
+  return invoke('Developer.toggleDeveloperTools');
 };
 
 const Developer = {
-    __proto__: null,
-    openCacheFolder,
-    openConfigFolder,
-    openIframeInspector,
-    openLogsFolder,
-    openProcessExplorer,
-    reloadColorTheme,
-    reloadIconTheme,
-    toggleDeveloperTools
+  __proto__: null,
+  openCacheFolder,
+  openConfigFolder,
+  openIframeInspector,
+  openLogsFolder,
+  openProcessExplorer,
+  reloadColorTheme,
+  reloadIconTheme,
+  toggleDeveloperTools
 };
 
 const createId = () => {
@@ -1798,28 +1805,28 @@ const executeMock$1 = (id, ...args) => {
 
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  await invoke$1('FilePicker.showSaveFilePicker');
+  await invoke('FilePicker.showSaveFilePicker');
 };
 const mockSaveFilePicker = async fn => {
   const id = registerMock(fn);
   // @ts-ignore
-  await invoke$1('FilePicker.mockSaveFilePicker', id);
+  await invoke('FilePicker.mockSaveFilePicker', id);
 };
 const mockConfirm = async fn => {
   const id = registerMock(fn);
   // @ts-ignore
-  await invoke$1('ConfirmPrompt.mock', id);
+  await invoke('ConfirmPrompt.mock', id);
 };
 const executeMock = (id, ...args) => {
   return executeMock$1(id, ...args);
 };
 
 const Dialog = {
-    __proto__: null,
-    executeMock,
-    mockConfirm,
-    mockSaveFilePicker,
-    showSaveFilePicker
+  __proto__: null,
+  executeMock,
+  mockConfirm,
+  mockSaveFilePicker,
+  showSaveFilePicker
 };
 
 const isDiagnosticEqual = (actual, expected) => {
@@ -1851,7 +1858,7 @@ const areSelectionsEqual = (a, b) => {
 };
 
 const getEditorKey = async () => {
-  const keys = await invoke('Editor.getKeys');
+  const keys = await invoke$1('Editor.getKeys');
   if (keys.length === 0) {
     throw new Error(`no editor found`);
   }
@@ -1864,234 +1871,234 @@ const Script = 2;
 
 const update$1 = settings => {
   // @ts-ignore
-  return invoke$1('Preferences.update', settings);
+  return invoke('Preferences.update', settings);
 };
 const enableDiagnostics$1 = () => {
   // @ts-ignore
-  return invoke$1('Preferences.update', {
+  return invoke('Preferences.update', {
     'editor.diagnostics': true
   });
 };
 const disableDiagnostics$1 = () => {
   // @ts-ignore
-  return invoke$1('Preferences.update', {
+  return invoke('Preferences.update', {
     'editor.diagnostics': false
   });
 };
 
 const Settings = {
-    __proto__: null,
-    disableDiagnostics: disableDiagnostics$1,
-    enableDiagnostics: enableDiagnostics$1,
-    update: update$1
+  __proto__: null,
+  disableDiagnostics: disableDiagnostics$1,
+  enableDiagnostics: enableDiagnostics$1,
+  update: update$1
 };
 
 const setCursor = async (rowIndex, columnIndex) => {
-  await invoke$1('Editor.cursorSet', rowIndex, columnIndex);
+  await invoke('Editor.cursorSet', rowIndex, columnIndex);
 };
 const openCompletion = async () => {
-  await invoke$1('Editor.openCompletion');
+  await invoke('Editor.openCompletion');
 };
 const closeCompletion = async () => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.close');
+  await invoke('EditorCompletion.close');
 };
 const openEditorContextMenu = async () => {
-  await invoke$1('Editor.handleContextMenu', 0, 0);
+  await invoke('Editor.handleContextMenu', 0, 0);
 };
 const invokeTabCompletion = async () => {
-  await invoke$1('Editor.tabCompletion');
+  await invoke('Editor.tabCompletion');
 };
 const executeTabCompletion = async () => {
-  await invoke$1('Editor.tabCompletion');
+  await invoke('Editor.tabCompletion');
 };
 const invokeBraceCompletion = async text => {
-  await invoke$1('Editor.braceCompletion', text);
+  await invoke('Editor.braceCompletion', text);
 };
 const cursorCharacterRight = async () => {
-  await invoke$1('Editor.cursorCharacterRight');
+  await invoke('Editor.cursorCharacterRight');
 };
 const cursorCharacterLeft = async () => {
-  await invoke$1('Editor.cursorCharacterLeft');
+  await invoke('Editor.cursorCharacterLeft');
 };
 const copyLineDown = async () => {
-  await invoke$1('Editor.copyLineDown');
+  await invoke('Editor.copyLineDown');
 };
 const cursorDown = async () => {
-  await invoke$1('Editor.cursorDown');
+  await invoke('Editor.cursorDown');
 };
 const cursorUp = async () => {
-  await invoke$1('Editor.cursorUp');
+  await invoke('Editor.cursorUp');
 };
 const cursorWordLeft = async () => {
-  await invoke$1('Editor.cursorWordLeft');
+  await invoke('Editor.cursorWordLeft');
 };
 const cursorWordRight = async () => {
-  await invoke$1('Editor.cursorWordRight');
+  await invoke('Editor.cursorWordRight');
 };
 const goToDefinition = async () => {
-  await invoke$1('Editor.goToDefinition');
+  await invoke('Editor.goToDefinition');
 };
 const openHover = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const goToTypeDefinition = async () => {
-  await invoke$1('Editor.goToTypeDefinition');
+  await invoke('Editor.goToTypeDefinition');
 };
 const type = async text => {
-  await invoke$1('Editor.type', text);
+  await invoke('Editor.type', text);
 };
 const findAllReferences = async () => {
   // @ts-ignore
-  await invoke$1('SideBar.show', 'References', /* focus */true);
+  await invoke('SideBar.show', 'References', /* focus */true);
 };
 const findAllImplementations = async () => {
   // @ts-ignore
-  await invoke$1('SideBar.show', 'Implementations', /* focus */true);
+  await invoke('SideBar.show', 'Implementations', /* focus */true);
 };
 const setSelections = async selections => {
-  await invoke$1('Editor.setSelections', selections);
+  await invoke('Editor.setSelections', selections);
 };
 const openFindWidget = async () => {
-  await invoke$1('Editor.openFind');
+  await invoke('Editor.openFind');
 };
 const setDeltaY = async deltaY => {
-  await invoke$1('Editor.setDeltaY', deltaY);
+  await invoke('Editor.setDeltaY', deltaY);
 };
 const format = async () => {
-  await invoke$1('Editor.format');
+  await invoke('Editor.format');
 };
 const insertLineBreak = async () => {
-  await invoke$1('Editor.insertLineBreak');
+  await invoke('Editor.insertLineBreak');
 };
 const openSourceActions = async () => {
-  await invoke$1('Editor.showSourceActions2');
+  await invoke('Editor.showSourceActions2');
 };
 const sourceActionsSelectCurrent = async () => {
-  await invoke$1('EditorSourceActions.selectCurrent');
+  await invoke('EditorSourceActions.selectCurrent');
 };
 const openCompletionDetails = async () => {
-  await invoke$1('EditorCompletion.openDetails');
+  await invoke('EditorCompletion.openDetails');
 };
 const closeCompletionDetails = async () => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.closeDetails');
+  await invoke('EditorCompletion.closeDetails');
 };
 const toggleCompletionDetails = async () => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.toggleDetails');
+  await invoke('EditorCompletion.toggleDetails');
 };
 const organizeImports = async () => {
-  await invoke$1('Editor.organizeImports');
+  await invoke('Editor.organizeImports');
 };
 const addAllMissingImports = async () => {
-  await invoke$1('Editor.addAllMissingImports');
+  await invoke('Editor.addAllMissingImports');
 };
 const sortImports = async () => {
-  await invoke$1('Editor.sortImports');
+  await invoke('Editor.sortImports');
 };
 const toggleLineComment = async () => {
-  await invoke$1('Editor.toggleLineComment');
+  await invoke('Editor.toggleLineComment');
 };
 const toggleBlockComment = async () => {
-  await invoke$1('Editor.toggleBlockComment');
+  await invoke('Editor.toggleBlockComment');
 };
 const selectAll$1 = async () => {
-  await invoke$1('Editor.toggleBlockComment');
+  await invoke('Editor.toggleBlockComment');
 };
 const openColorPicker = async () => {
-  await invoke$1('Editor.openColorPicker');
+  await invoke('Editor.openColorPicker');
 };
 const openFind = async () => {
   // @ts-ignore
-  await invoke$1('Editor.openFind2');
+  await invoke('Editor.openFind2');
 };
 const deleteAllLeft = async () => {
-  await invoke$1('Editor.deleteAllLeft');
+  await invoke('Editor.deleteAllLeft');
 };
 const deleteAllRight = async () => {
-  await invoke$1('Editor.deleteAllRight');
+  await invoke('Editor.deleteAllRight');
 };
 const cursorWordPartLeft = async () => {
-  await invoke$1('Editor.cursorWordPartLeft');
+  await invoke('Editor.cursorWordPartLeft');
 };
 const cursorWordPartRight = async () => {
-  await invoke$1('Editor.cursorWordPartRight');
+  await invoke('Editor.cursorWordPartRight');
 };
 const cursorEnd = async () => {
-  await invoke$1('Editor.cursorEnd');
+  await invoke('Editor.cursorEnd');
 };
 const cursorHome = async () => {
-  await invoke$1('Editor.cursorHome');
+  await invoke('Editor.cursorHome');
 };
 const copyLineUp = async () => {
-  await invoke$1('Editor.copyLineUp');
+  await invoke('Editor.copyLineUp');
 };
 const copy$1 = async () => {
-  await invoke$1('Editor.copy');
+  await invoke('Editor.copy');
 };
 const closeColorPicker = async () => {
-  await invoke$1('Editor.closeColorPicker');
+  await invoke('Editor.closeColorPicker');
 };
 const openContextMenu$1 = async () => {
   const button = 0;
   const x = 0;
   const y = 0;
-  await invoke$1('Editor.contextMenu', button, x, y);
+  await invoke('Editor.contextMenu', button, x, y);
 };
 const getText = async () => {
-  return invoke$1('Editor.getText');
+  return invoke('Editor.getText');
 };
 const rename$1 = async () => {
-  await invoke$1('Editor.rename');
+  await invoke('Editor.rename');
 };
 const showHover = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const openRename = async () => {
-  await invoke$1('Editor.openRename');
+  await invoke('Editor.openRename');
 };
 const rename2 = async newName => {
   await openRename();
   // @ts-ignore
-  await invoke$1('EditorRename.handleInput', newName, Script);
+  await invoke('EditorRename.handleInput', newName, Script);
   // @ts-ignore
-  await invoke$1('EditorRename.accept');
+  await invoke('EditorRename.accept');
 };
 const growSelection = async () => {
   // @ts-ignore
-  await invoke$1('Editor.selectionGrow');
+  await invoke('Editor.selectionGrow');
 };
 const getSelections = async () => {
   const key = await getEditorKey();
   // @ts-ignore
-  return invoke('Editor.getSelections', key);
+  return invoke$1('Editor.getSelections', key);
 };
 const shouldHaveText = async expectedText => {
   const key = await getEditorKey();
-  const text = await invoke('Editor.getText', key);
+  const text = await invoke$1('Editor.getText', key);
   if (text !== expectedText) {
     throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
   }
 };
 const shouldHaveSelections = async expectedSelections => {
   const key = await getEditorKey();
-  const selections = await invoke('Editor.getSelections', key);
+  const selections = await invoke$1('Editor.getSelections', key);
   if (!areSelectionsEqual(selections, expectedSelections)) {
     throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
   }
 };
 const undo = async () => {
   // @ts-ignore
-  await invoke('Editor.undo');
+  await invoke$1('Editor.undo');
 };
 const redo = async () => {
   // @ts-ignore
-  await invoke('Editor.redo');
+  await invoke$1('Editor.redo');
 };
 const shouldHaveDiagnostics = async expectedDiagnostics => {
   const key = await getEditorKey();
-  const diagnostics = await invoke('Editor.getDiagnostics', key);
+  const diagnostics = await invoke$1('Editor.getDiagnostics', key);
   if (!areDiagnosticsEqual(diagnostics, expectedDiagnostics)) {
     const stringifiedActual = JSON.stringify(diagnostics);
     const stringifiedExpected = JSON.stringify(expectedDiagnostics);
@@ -2120,370 +2127,370 @@ const disableDiagnostics = async () => {
 };
 
 const Editor = {
-    __proto__: null,
-    addAllMissingImports,
-    closeColorPicker,
-    closeCompletion,
-    closeCompletionDetails,
-    copy: copy$1,
-    copyLineDown,
-    copyLineUp,
-    cursorCharacterLeft,
-    cursorCharacterRight,
-    cursorDown,
-    cursorEnd,
-    cursorHome,
-    cursorUp,
-    cursorWordLeft,
-    cursorWordPartLeft,
-    cursorWordPartRight,
-    cursorWordRight,
-    deleteAllLeft,
-    deleteAllRight,
-    disableCompletionsOnType,
-    disableDiagnostics,
-    enableCompletionsOnType,
-    enableDiagnostics,
-    executeTabCompletion,
-    findAllImplementations,
-    findAllReferences,
-    format,
-    getSelections,
-    getText,
-    goToDefinition,
-    goToTypeDefinition,
-    growSelection,
-    insertLineBreak,
-    invokeBraceCompletion,
-    invokeTabCompletion,
-    openColorPicker,
-    openCompletion,
-    openCompletionDetails,
-    openContextMenu: openContextMenu$1,
-    openEditorContextMenu,
-    openFind,
-    openFindWidget,
-    openHover,
-    openRename,
-    openSourceActions,
-    organizeImports,
-    redo,
-    rename: rename$1,
-    rename2,
-    selectAll: selectAll$1,
-    setCursor,
-    setDeltaY,
-    setSelections,
-    shouldHaveDiagnostics,
-    shouldHaveSelections,
-    shouldHaveText,
-    showHover,
-    sortImports,
-    sourceActionsSelectCurrent,
-    toggleBlockComment,
-    toggleCompletionDetails,
-    toggleLineComment,
-    type,
-    undo
+  __proto__: null,
+  addAllMissingImports,
+  closeColorPicker,
+  closeCompletion,
+  closeCompletionDetails,
+  copy: copy$1,
+  copyLineDown,
+  copyLineUp,
+  cursorCharacterLeft,
+  cursorCharacterRight,
+  cursorDown,
+  cursorEnd,
+  cursorHome,
+  cursorUp,
+  cursorWordLeft,
+  cursorWordPartLeft,
+  cursorWordPartRight,
+  cursorWordRight,
+  deleteAllLeft,
+  deleteAllRight,
+  disableCompletionsOnType,
+  disableDiagnostics,
+  enableCompletionsOnType,
+  enableDiagnostics,
+  executeTabCompletion,
+  findAllImplementations,
+  findAllReferences,
+  format,
+  getSelections,
+  getText,
+  goToDefinition,
+  goToTypeDefinition,
+  growSelection,
+  insertLineBreak,
+  invokeBraceCompletion,
+  invokeTabCompletion,
+  openColorPicker,
+  openCompletion,
+  openCompletionDetails,
+  openContextMenu: openContextMenu$1,
+  openEditorContextMenu,
+  openFind,
+  openFindWidget,
+  openHover,
+  openRename,
+  openSourceActions,
+  organizeImports,
+  redo,
+  rename: rename$1,
+  rename2,
+  selectAll: selectAll$1,
+  setCursor,
+  setDeltaY,
+  setSelections,
+  shouldHaveDiagnostics,
+  shouldHaveSelections,
+  shouldHaveText,
+  showHover,
+  sortImports,
+  sourceActionsSelectCurrent,
+  toggleBlockComment,
+  toggleCompletionDetails,
+  toggleLineComment,
+  type,
+  undo
 };
 
 const selectIndex$6 = async index => {
-  await invoke$1('EditorCompletion.selectIndex', index);
+  await invoke('EditorCompletion.selectIndex', index);
 };
 const selectCurrentIndex$2 = async () => {
-  await invoke$1('EditorCompletion.selectCurrentIndex');
+  await invoke('EditorCompletion.selectCurrentIndex');
 };
 const close$2 = async () => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.close');
+  await invoke('EditorCompletion.close');
 };
 const handleWheel$2 = async (deltaMode, deltaY) => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.handleWheel', deltaMode, deltaY);
+  await invoke('EditorCompletion.handleWheel', deltaMode, deltaY);
 };
 const handlePointerdown = async (clientX, clientY) => {
   // @ts-ignore
-  await invoke$1('EditorCompletion.handlePointerdown', clientX, clientY);
+  await invoke('EditorCompletion.handlePointerdown', clientX, clientY);
 };
 
 const EditorCompletion = {
-    __proto__: null,
-    close: close$2,
-    handlePointerdown,
-    handleWheel: handleWheel$2,
-    selectCurrentIndex: selectCurrentIndex$2,
-    selectIndex: selectIndex$6
+  __proto__: null,
+  close: close$2,
+  handlePointerdown,
+  handleWheel: handleWheel$2,
+  selectCurrentIndex: selectCurrentIndex$2,
+  selectIndex: selectIndex$6
 };
 
 const show$5 = async () => {
-  await invoke$1('Editor.showHover2');
+  await invoke('Editor.showHover2');
 };
 const close$1 = async () => {
   // @ts-ignore
-  await invoke$1('EditorHover.close');
+  await invoke('EditorHover.close');
 };
 
 const EditorHover = {
-    __proto__: null,
-    close: close$1,
-    show: show$5
+  __proto__: null,
+  close: close$1,
+  show: show$5
 };
 
 const handleInput$5 = async value => {
   // @ts-ignore
-  await invoke$1('EditorRename.handleInput', value, Script);
+  await invoke('EditorRename.handleInput', value, Script);
 };
 const accept = async () => {
   // @ts-ignore
-  await invoke$1('EditorRename.accept');
+  await invoke('EditorRename.accept');
 };
 const cancel = async () => {
   // @ts-ignore
-  await invoke$1('EditorRename.cancel');
+  await invoke('EditorRename.cancel');
 };
 
 const EditorRename = {
-    __proto__: null,
-    accept,
-    cancel,
-    handleInput: handleInput$5
+  __proto__: null,
+  accept,
+  cancel,
+  handleInput: handleInput$5
 };
 
 const selectIndex$5 = async index => {
   // @ts-ignore
-  await invoke$1('EditorSourceAction.selectIndex', index);
+  await invoke('EditorSourceAction.selectIndex', index);
 };
 const selectCurrentIndex$1 = async () => {
   // @ts-ignore
-  await invoke$1('EditorSourceAction.selectCurrentIndex');
+  await invoke('EditorSourceAction.selectCurrentIndex');
 };
 
 const EditorSourceAction = {
-    __proto__: null,
-    selectCurrentIndex: selectCurrentIndex$1,
-    selectIndex: selectIndex$5
+  __proto__: null,
+  selectCurrentIndex: selectCurrentIndex$1,
+  selectIndex: selectIndex$5
 };
 
 const openContextMenu = async index => {
   // @ts-ignore
-  await invoke$1('Explorer.handleContextMenuKeyboard', index);
+  await invoke('Explorer.handleContextMenuKeyboard', index);
 };
 const handleDragLeave = async () => {
-  await invoke$1('Explorer.handleDragLeave');
+  await invoke('Explorer.handleDragLeave');
 };
 const handleBlur = async () => {
-  await invoke$1('Explorer.handleBlur');
+  await invoke('Explorer.handleBlur');
 };
 const handleEscape = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.handleEscape');
+  await invoke('Explorer.handleEscape');
 };
 const handleInputBlur = async () => {
-  await invoke$1('Explorer.handleInputBlur');
+  await invoke('Explorer.handleInputBlur');
 };
 const focus$1 = async () => {
-  await invoke$1('Explorer.focusIndex', -1);
+  await invoke('Explorer.focusIndex', -1);
 };
 const focusNext$7 = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.focusNext');
+  await invoke('Explorer.focusNext');
 };
 const selectUp = async () => {
-  await invoke$1('Explorer.selectUp');
+  await invoke('Explorer.selectUp');
 };
 const handleDragOverIndex = async index => {
   // @ts-ignore
-  await invoke$1('Explorer.handleDragOverIndex', index);
+  await invoke('Explorer.handleDragOverIndex', index);
 };
 const selectDown = async () => {
-  await invoke$1('Explorer.selectDown');
+  await invoke('Explorer.selectDown');
 };
 const collapseAll$2 = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.collapseAll');
+  await invoke('Explorer.collapseAll');
 };
 const refresh$1 = async () => {
-  await invoke$1('Explorer.refresh');
+  await invoke('Explorer.refresh');
 };
 const focusIndex$5 = async index => {
-  await invoke$1('Explorer.focusIndex', index);
+  await invoke('Explorer.focusIndex', index);
 };
 const clickCurrent = async () => {
-  await invoke$1('Explorer.handleClickCurrent');
+  await invoke('Explorer.handleClickCurrent');
 };
 const handleArrowLeft$1 = async () => {
-  await invoke$1('Explorer.handleArrowLeft');
+  await invoke('Explorer.handleArrowLeft');
 };
 const focusLast$5 = async () => {
-  await invoke$1('Explorer.focusLast');
+  await invoke('Explorer.focusLast');
 };
 const focusFirst$6 = async () => {
-  await invoke$1('Explorer.focusFirst');
+  await invoke('Explorer.focusFirst');
 };
 const removeDirent = async () => {
-  await invoke$1('Explorer.removeDirent');
+  await invoke('Explorer.removeDirent');
 };
 const expandRecursively = async () => {
-  await invoke$1('Explorer.expandRecursively');
+  await invoke('Explorer.expandRecursively');
 };
 const newFile = async () => {
-  await invoke$1('Explorer.newFile');
+  await invoke('Explorer.newFile');
 };
 const newFolder = async () => {
-  await invoke$1('Explorer.newFolder');
+  await invoke('Explorer.newFolder');
 };
 const copyPath$1 = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.copyPath');
+  await invoke('Explorer.copyPath');
 };
 const copyRelativePath = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.copyRelativePath');
+  await invoke('Explorer.copyRelativePath');
 };
 const handleClick$2 = async index => {
-  await invoke$1('Explorer.handleClick', index);
+  await invoke('Explorer.handleClick', index);
 };
 const handleClickAt$2 = async (preventDefault, button, ctrlKey, shiftKey, x, y) => {
   // @ts-ignore
-  await invoke$1('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
+  await invoke('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
 };
 const handleDrop = async (x, y, fileIds, fileList) => {
   // @ts-ignore
-  await invoke$1('Explorer.handleDrop', x, y, fileIds, fileIds);
+  await invoke('Explorer.handleDrop', x, y, fileIds, fileIds);
 };
 const rename = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke('Explorer.renameDirent');
 };
 const selectAll = async () => {
-  await invoke$1('Explorer.selectAll');
+  await invoke('Explorer.selectAll');
 };
 const renameDirent = async () => {
-  await invoke$1('Explorer.renameDirent');
+  await invoke('Explorer.renameDirent');
 };
 const cancelEdit = async () => {
-  await invoke$1('Explorer.cancelEdit');
+  await invoke('Explorer.cancelEdit');
 };
 const acceptEdit = async () => {
-  await invoke$1('Explorer.acceptEdit');
+  await invoke('Explorer.acceptEdit');
 };
 const updateEditingValue = async value => {
-  await invoke$1('Explorer.updateEditingValue', value);
+  await invoke('Explorer.updateEditingValue', value);
 };
 const expandAll = async () => {
-  await invoke$1('Explorer.expandAll');
+  await invoke('Explorer.expandAll');
 };
 const handleDragOver = async (x, y) => {
-  await invoke$1('Explorer.handleDragOver', x, y);
+  await invoke('Explorer.handleDragOver', x, y);
 };
 const handleCut = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.handleCut');
+  await invoke('Explorer.handleCut');
 };
 const handleCopy = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.handleCopy');
+  await invoke('Explorer.handleCopy');
 };
 const handlePaste = async () => {
   // @ts-ignore
-  await invoke$1('Explorer.handlePaste');
+  await invoke('Explorer.handlePaste');
 };
 const selectIndices = async indices => {
-  await invoke$1('Explorer.selectIndices', indices);
+  await invoke('Explorer.selectIndices', indices);
 };
 const toggleIndividualSelection = async index => {
   // @ts-ignore
-  await invoke$1('Explorer.toggleIndividualSelection', index);
+  await invoke('Explorer.toggleIndividualSelection', index);
 };
 
 const Explorer = {
-    __proto__: null,
-    acceptEdit,
-    cancelEdit,
-    clickCurrent,
-    collapseAll: collapseAll$2,
-    copyPath: copyPath$1,
-    copyRelativePath,
-    expandAll,
-    expandRecursively,
-    focus: focus$1,
-    focusFirst: focusFirst$6,
-    focusIndex: focusIndex$5,
-    focusLast: focusLast$5,
-    focusNext: focusNext$7,
-    handleArrowLeft: handleArrowLeft$1,
-    handleBlur,
-    handleClick: handleClick$2,
-    handleClickAt: handleClickAt$2,
-    handleCopy,
-    handleCut,
-    handleDragLeave,
-    handleDragOver,
-    handleDragOverIndex,
-    handleDrop,
-    handleEscape,
-    handleInputBlur,
-    handlePaste,
-    newFile,
-    newFolder,
-    openContextMenu,
-    refresh: refresh$1,
-    removeDirent,
-    rename,
-    renameDirent,
-    selectAll,
-    selectDown,
-    selectIndices,
-    selectUp,
-    toggleIndividualSelection,
-    updateEditingValue
+  __proto__: null,
+  acceptEdit,
+  cancelEdit,
+  clickCurrent,
+  collapseAll: collapseAll$2,
+  copyPath: copyPath$1,
+  copyRelativePath,
+  expandAll,
+  expandRecursively,
+  focus: focus$1,
+  focusFirst: focusFirst$6,
+  focusIndex: focusIndex$5,
+  focusLast: focusLast$5,
+  focusNext: focusNext$7,
+  handleArrowLeft: handleArrowLeft$1,
+  handleBlur,
+  handleClick: handleClick$2,
+  handleClickAt: handleClickAt$2,
+  handleCopy,
+  handleCut,
+  handleDragLeave,
+  handleDragOver,
+  handleDragOverIndex,
+  handleDrop,
+  handleEscape,
+  handleInputBlur,
+  handlePaste,
+  newFile,
+  newFolder,
+  openContextMenu,
+  refresh: refresh$1,
+  removeDirent,
+  rename,
+  renameDirent,
+  selectAll,
+  selectDown,
+  selectIndices,
+  selectUp,
+  toggleIndividualSelection,
+  updateEditingValue
 };
 
 const addWebExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$1('ExtensionMeta.addWebExtension', absolutePath);
+  await invoke('ExtensionMeta.addWebExtension', absolutePath);
 };
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke$1('ExtensionMeta.addNodeExtension', absolutePath);
+  await invoke('ExtensionMeta.addNodeExtension', absolutePath);
 };
 
 const Extension = {
-    __proto__: null,
-    addNodeExtension,
-    addWebExtension
+  __proto__: null,
+  addNodeExtension,
+  addWebExtension
 };
 
 const handleClickCategory = async categoryId => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.handleClickCategory', categoryId);
+  await invoke('ExtensionDetail.handleClickCategory', categoryId);
 };
 const handleReadmeContextMenu = async (x, y, nodeName, href) => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
+  await invoke('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
 };
 const copyReadmeLink = async href => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.copyReadmeLink', href);
+  await invoke('ExtensionDetail.copyReadmeLink', href);
 };
 const handleClickEnable = async () => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.handleClickEnable');
+  await invoke('ExtensionDetail.handleClickEnable');
 };
 const handleClickDisable = async () => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.handleClickDisable');
+  await invoke('ExtensionDetail.handleClickDisable');
 };
 const handleClickSetColorTheme = async () => {
   // @ts-ignore
-  await invoke$1('ExtensionDetail.handleClickSetColorTheme');
+  await invoke('ExtensionDetail.handleClickSetColorTheme');
 };
 const selectFeature = name => {
-  return invoke$1('ExtensionDetail.selectFeature', name);
+  return invoke('ExtensionDetail.selectFeature', name);
 };
 const selectTab$1 = name => {
-  return invoke$1('ExtensionDetail.selectTab', name);
+  return invoke('ExtensionDetail.selectTab', name);
 };
 const selectDetails = async () => {
   await selectTab$1('Details');
@@ -2495,24 +2502,24 @@ const selectChangelog = async () => {
   await selectTab$1('Changelog');
 };
 const focusNextTab = async () => {
-  await invoke$1('ExtensionDetail.focusNextTab');
+  await invoke('ExtensionDetail.focusNextTab');
 };
 const focusPreviousTab = async () => {
-  await invoke$1('ExtensionDetail.focusPreviousTab');
+  await invoke('ExtensionDetail.focusPreviousTab');
 };
 const open$6 = extensionId => {
   const uri = `extension-detail://${extensionId}`;
-  return invoke$1('Main.openUri', uri);
+  return invoke('Main.openUri', uri);
 };
 const handleClickUninstall = () => {
-  return invoke$1('ExtensionDetail.handleClickUninstall');
+  return invoke('ExtensionDetail.handleClickUninstall');
 };
 const handleImageContextMenu = () => {
-  return invoke$1('ExtensionDetail.handleImageContextMenu');
+  return invoke('ExtensionDetail.handleImageContextMenu');
 };
 const openFeature = featureName => {
   // @ts-ignore
-  return invoke$1('ExtensionDetail.handleFeaturesClick', featureName);
+  return invoke('ExtensionDetail.handleFeaturesClick', featureName);
 };
 const openThemes = async () => {
   await openFeature('Theme');
@@ -2534,56 +2541,56 @@ const openSettings = async () => {
 };
 const handleScroll$1 = async scrollTop => {
   // @ts-ignore
-  return invoke$1('ExtensionDetail.handleScroll', scrollTop);
+  return invoke('ExtensionDetail.handleScroll', scrollTop);
 };
 const hideSizeLink = async () => {
-  return invoke$1('ExtensionDetail.hideSizeLink');
+  return invoke('ExtensionDetail.hideSizeLink');
 };
 const handleTabFocus = async tabName => {
-  return invoke$1('ExtensionDetail.handleTabFocus', tabName);
+  return invoke('ExtensionDetail.handleTabFocus', tabName);
 };
 
 const ExtensionDetail = {
-    __proto__: null,
-    copyReadmeLink,
-    focusNextTab,
-    focusPreviousTab,
-    handleClickCategory,
-    handleClickDisable,
-    handleClickEnable,
-    handleClickSetColorTheme,
-    handleClickUninstall,
-    handleImageContextMenu,
-    handleReadmeContextMenu,
-    handleScroll: handleScroll$1,
-    handleTabFocus,
-    hideSizeLink,
-    open: open$6,
-    openCommands,
-    openFeature,
-    openJsonValidation,
-    openRuntimeStatus,
-    openSettings,
-    openThemes,
-    openWebViews,
-    selectChangelog,
-    selectDetails,
-    selectFeature,
-    selectFeatures,
-    selectTab: selectTab$1
+  __proto__: null,
+  copyReadmeLink,
+  focusNextTab,
+  focusPreviousTab,
+  handleClickCategory,
+  handleClickDisable,
+  handleClickEnable,
+  handleClickSetColorTheme,
+  handleClickUninstall,
+  handleImageContextMenu,
+  handleReadmeContextMenu,
+  handleScroll: handleScroll$1,
+  handleTabFocus,
+  hideSizeLink,
+  open: open$6,
+  openCommands,
+  openFeature,
+  openJsonValidation,
+  openRuntimeStatus,
+  openSettings,
+  openThemes,
+  openWebViews,
+  selectChangelog,
+  selectDetails,
+  selectFeature,
+  selectFeatures,
+  selectTab: selectTab$1
 };
 
 const open$5 = async id => {
-  await invoke$1('SideBar.openViewlet', id);
+  await invoke('SideBar.openViewlet', id);
 };
 const hide = async () => {
-  await invoke$1('Layout.hideSideBar');
+  await invoke('Layout.hideSideBar');
 };
 
 const SideBar = {
-    __proto__: null,
-    hide,
-    open: open$5
+  __proto__: null,
+  hide,
+  open: open$5
 };
 
 const open$4 = async () => {
@@ -2591,38 +2598,38 @@ const open$4 = async () => {
 };
 const handleInput$4 = async value => {
   // @ts-ignore
-  await invoke$1('Extensions.handleInput', value, Script$1);
+  await invoke('Extensions.handleInput', value, Script$1);
 };
 const handleClick$1 = async index => {
   // @ts-ignore
-  await invoke$1('Extensions.handleClick', index);
+  await invoke('Extensions.handleClick', index);
 };
 const handleContextMenu$4 = async (button, x, y) => {
   // @ts-ignore
-  await invoke$1('Extensions.handleContextMenu', button, x, y);
+  await invoke('Extensions.handleContextMenu', button, x, y);
 };
 const copyExtensionInfo = async () => {
   // @ts-ignore
-  await invoke$1('Extensions.copyExtensionInfo');
+  await invoke('Extensions.copyExtensionInfo');
 };
 const copyExtensionId = async () => {
   // @ts-ignore
-  await invoke$1('Extensions.copyExtensionId');
+  await invoke('Extensions.copyExtensionId');
 };
 const clearSearchResults$1 = async () => {
   // @ts-ignore
-  await invoke$1('Extensions.clearSearchResults');
+  await invoke('Extensions.clearSearchResults');
 };
 
 const ExtensionSearch = {
-    __proto__: null,
-    clearSearchResults: clearSearchResults$1,
-    copyExtensionId,
-    copyExtensionInfo,
-    handleClick: handleClick$1,
-    handleContextMenu: handleContextMenu$4,
-    handleInput: handleInput$4,
-    open: open$4
+  __proto__: null,
+  clearSearchResults: clearSearchResults$1,
+  copyExtensionId,
+  copyExtensionInfo,
+  handleClick: handleClick$1,
+  handleContextMenu: handleContextMenu$4,
+  handleInput: handleInput$4,
+  open: open$4
 };
 
 const Memfs = 'memfs';
@@ -2639,7 +2646,7 @@ const toFileUrl = url => {
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const getDirents = async (allDirents, fileUrl) => {
-  const dirents = await invoke$1('FileSystem.readDirWithFileTypes', fileUrl);
+  const dirents = await invoke('FileSystem.readDirWithFileTypes', fileUrl);
   for (const dirent of dirents) {
     if (dirent.type === Directory) {
       await getDirents(allDirents, `${fileUrl}/${dirent.name}`);
@@ -2654,7 +2661,7 @@ const getFileMapNode = async url => {
   await getDirents(allFiles, fileUrl);
   const fileMap = Object.create(null);
   for (const filePath of allFiles) {
-    const content = await invoke$1(`FileSystem.readFile`, filePath);
+    const content = await invoke(`FileSystem.readFile`, filePath);
     const relativePaths = filePath.slice(fileUrl.length + 1);
     fileMap[relativePaths] = content;
   }
@@ -2701,7 +2708,7 @@ const getFileMapWeb = async url => {
 const loadFixtureToMemFs = async fileMap => {
   for (const [path, content] of Object.entries(fileMap)) {
     const memfsPath = `memfs:///fixture/${path}`;
-    await invoke$1('FileSystem.writeFile', memfsPath, content);
+    await invoke('FileSystem.writeFile', memfsPath, content);
   }
   return `memfs:///fixture`;
 };
@@ -2710,9 +2717,9 @@ const Backslash = '\\';
 const Slash$1 = '/';
 
 const Character = {
-    __proto__: null,
-    Backslash,
-    Slash: Slash$1
+  __proto__: null,
+  Backslash,
+  Slash: Slash$1
 };
 
 const {
@@ -2724,28 +2731,28 @@ const stringifyJson = data => {
 };
 
 const writeFile = async (uri, content) => {
-  await invoke$1('FileSystem.writeFile', uri, content);
+  await invoke('FileSystem.writeFile', uri, content);
 };
 const writeJson = async (uri, data) => {
   const content = stringifyJson(data);
   await writeFile(uri, content);
 };
 const readFile = async uri => {
-  return invoke$1('FileSystem.readFile', uri);
+  return invoke('FileSystem.readFile', uri);
 };
 const addFileHandle = async file => {
   // @ts-ignore
-  await invoke$1('FileSystem.addFileHandle', file);
+  await invoke('FileSystem.addFileHandle', file);
 };
 const mkdir = async uri => {
-  await invoke$1('FileSystem.mkdir', uri);
+  await invoke('FileSystem.mkdir', uri);
 };
 const readDir = async uri => {
   // @ts-ignore
-  return invoke$1('FileSystem.readDirWithFileTypes', uri);
+  return invoke('FileSystem.readDirWithFileTypes', uri);
 };
 const remove = async uri => {
-  await invoke$1('FileSystem.remove', uri);
+  await invoke('FileSystem.remove', uri);
 };
 const getTmpDir = async ({
   scheme = Memfs
@@ -2755,19 +2762,19 @@ const getTmpDir = async ({
       return 'memfs:///workspace';
     default:
       // @ts-ignore
-      return invoke$1('PlatformPaths.getTmpDir');
+      return invoke('PlatformPaths.getTmpDir');
   }
 };
 const chmod = async (uri, permissions) => {
   // @ts-ignore
-  await invoke$1('FileSystem.chmod', uri, permissions);
+  await invoke('FileSystem.chmod', uri, permissions);
 };
 const createExecutable = async content => {
   const tmpDir = await getTmpDir({
     scheme: 'file'
   });
   // @ts-ignore
-  const nodePath = await invoke$1('PlatformPaths.getNodePath');
+  const nodePath = await invoke('PlatformPaths.getNodePath');
   const gitPath = `${tmpDir}/git`;
   await writeFile(gitPath, `#!${nodePath}
   ${content}`);
@@ -2776,10 +2783,10 @@ const createExecutable = async content => {
 };
 const createExecutableFrom = async uri => {
   // @ts-ignore
-  const testPath = await invoke$1('PlatformPaths.getTestPath');
+  const testPath = await invoke('PlatformPaths.getTestPath');
   const absolutePath = testPath + Slash + uri;
   // @ts-ignore
-  const content = await invoke$1('Ajax.getText', absolutePath);
+  const content = await invoke('Ajax.getText', absolutePath);
   return createExecutable(content);
 };
 const createDroppedFileHandle = async () => {
@@ -2789,7 +2796,7 @@ const createDroppedFileHandle = async () => {
   });
   const file = await fileHandle.getFile();
   // @ts-ignore
-  const id = await invoke$1('FileSystemHandle.addFileHandle', fileHandle);
+  const id = await invoke('FileSystemHandle.addFileHandle', fileHandle);
   return {
     file,
     id
@@ -2806,231 +2813,231 @@ const loadFixture = async (platform, url) => {
 };
 
 const FileSystem = {
-    __proto__: null,
-    addFileHandle,
-    chmod,
-    createDroppedFileHandle,
-    createExecutable,
-    createExecutableFrom,
-    getTmpDir,
-    loadFixture,
-    mkdir,
-    readDir,
-    readFile,
-    remove,
-    writeFile,
-    writeJson
+  __proto__: null,
+  addFileHandle,
+  chmod,
+  createDroppedFileHandle,
+  createExecutable,
+  createExecutableFrom,
+  getTmpDir,
+  loadFixture,
+  mkdir,
+  readDir,
+  readFile,
+  remove,
+  writeFile,
+  writeJson
 };
 
 const focusNext$6 = async () => {
-  await invoke$1('FindWidget.focusNext');
+  await invoke('FindWidget.focusNext');
 };
 const focusPrevious$6 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.focusPrevious');
+  await invoke('FindWidget.focusPrevious');
 };
 const close = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.close');
+  await invoke('FindWidget.close');
 };
 const setReplaceValue$1 = async value => {
   // @ts-ignore
-  await invoke$1('FindWidget.handleReplaceInput', value, Script);
+  await invoke('FindWidget.handleReplaceInput', value, Script);
 };
 const setValue$2 = async value => {
   // @ts-ignore
-  await invoke$1('FindWidget.handleInput', value, Script);
+  await invoke('FindWidget.handleInput', value, Script);
 };
 const toggleReplace$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.toggleReplace');
+  await invoke('FindWidget.toggleReplace');
 };
 const toggleMatchCase$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.toggleMatchCase');
+  await invoke('FindWidget.toggleMatchCase');
 };
 const toggleMatchWholeWord$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.toggleMatchWholeWord');
+  await invoke('FindWidget.toggleMatchWholeWord');
 };
 const togglePreserveCase$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.togglePreserveCase');
+  await invoke('FindWidget.togglePreserveCase');
 };
 const toggleUseRegularExpression$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.toggleUseRegularExpression');
+  await invoke('FindWidget.toggleUseRegularExpression');
 };
 const replace = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.replace');
+  await invoke('FindWidget.replace');
 };
 const replaceAll$1 = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.replaceAll');
+  await invoke('FindWidget.replaceAll');
 };
 const focusElement = async whenExpression => {
   // @ts-ignore
-  await invoke$1('FindWidget.focusElement', whenExpression);
+  await invoke('FindWidget.focusElement', whenExpression);
 };
 const focusNextElement = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.focusNextElement');
+  await invoke('FindWidget.focusNextElement');
 };
 const focusPreviousElement = async () => {
   // @ts-ignore
-  await invoke$1('FindWidget.focusPreviousElement');
+  await invoke('FindWidget.focusPreviousElement');
 };
 
 const FindWidget = {
-    __proto__: null,
-    close,
-    focusElement,
-    focusNext: focusNext$6,
-    focusNextElement,
-    focusPrevious: focusPrevious$6,
-    focusPreviousElement,
-    replace,
-    replaceAll: replaceAll$1,
-    setReplaceValue: setReplaceValue$1,
-    setValue: setValue$2,
-    toggleMatchCase: toggleMatchCase$1,
-    toggleMatchWholeWord: toggleMatchWholeWord$1,
-    togglePreserveCase: togglePreserveCase$1,
-    toggleReplace: toggleReplace$1,
-    toggleUseRegularExpression: toggleUseRegularExpression$1
+  __proto__: null,
+  close,
+  focusElement,
+  focusNext: focusNext$6,
+  focusNextElement,
+  focusPrevious: focusPrevious$6,
+  focusPreviousElement,
+  replace,
+  replaceAll: replaceAll$1,
+  setReplaceValue: setReplaceValue$1,
+  setValue: setValue$2,
+  toggleMatchCase: toggleMatchCase$1,
+  toggleMatchWholeWord: toggleMatchWholeWord$1,
+  togglePreserveCase: togglePreserveCase$1,
+  toggleReplace: toggleReplace$1,
+  toggleUseRegularExpression: toggleUseRegularExpression$1
 };
 
 const setIconTheme = async id => {
-  await invoke$1('IconTheme.setIconTheme', id);
+  await invoke('IconTheme.setIconTheme', id);
 };
 
 const IconTheme = {
-    __proto__: null,
-    setIconTheme
+  __proto__: null,
+  setIconTheme
 };
 
 const selectIndex$4 = async index => {
-  return invoke$1('IframeInspector.selectIndex', index);
+  return invoke('IframeInspector.selectIndex', index);
 };
 const focusNext$5 = async () => {
-  return invoke$1('IframeInspector.focusNext');
+  return invoke('IframeInspector.focusNext');
 };
 const focusPrevious$5 = async () => {
-  return invoke$1('IframeInspector.focusPrevious');
+  return invoke('IframeInspector.focusPrevious');
 };
 const focusFirst$5 = async () => {
-  return invoke$1('IframeInspector.focusFirst');
+  return invoke('IframeInspector.focusFirst');
 };
 const focusLast$4 = async () => {
-  return invoke$1('IframeInspector.focusLast');
+  return invoke('IframeInspector.focusLast');
 };
 
 const IframeInspector = {
-    __proto__: null,
-    focusFirst: focusFirst$5,
-    focusLast: focusLast$4,
-    focusNext: focusNext$5,
-    focusPrevious: focusPrevious$5,
-    selectIndex: selectIndex$4
+  __proto__: null,
+  focusFirst: focusFirst$5,
+  focusLast: focusLast$4,
+  focusNext: focusNext$5,
+  focusPrevious: focusPrevious$5,
+  selectIndex: selectIndex$4
 };
 
 const open$3 = async () => {
-  await invoke$1('Main.openUri', 'app://keybindings');
+  await invoke('Main.openUri', 'app://keybindings');
 };
 const handleInput$3 = value => {
-  return invoke$1('KeyBindings.handleInput', value);
+  return invoke('KeyBindings.handleInput', value);
 };
 const handleClick = (x, y) => {
-  return invoke$1('KeyBindings.handleClick', x, y);
+  return invoke('KeyBindings.handleClick', x, y);
 };
 const handleWheel$1 = (deltaMode, deltaY) => {
-  return invoke$1('KeyBindings.handleWheel', deltaMode, deltaY);
+  return invoke('KeyBindings.handleWheel', deltaMode, deltaY);
 };
 const handleDoubleClick = (x, y) => {
-  return invoke$1('KeyBindings.handleDoubleClick', x, y);
+  return invoke('KeyBindings.handleDoubleClick', x, y);
 };
 const focusNext$4 = () => {
-  return invoke$1('KeyBindings.focusNext');
+  return invoke('KeyBindings.focusNext');
 };
 const focusPrevious$4 = () => {
-  return invoke$1('KeyBindings.focusPrevious');
+  return invoke('KeyBindings.focusPrevious');
 };
 const focusFirst$4 = () => {
-  return invoke$1('KeyBindings.focusFirst');
+  return invoke('KeyBindings.focusFirst');
 };
 const focusIndex$4 = index => {
   // @ts-ignore
-  return invoke$1('KeyBindings.focusIndex', index);
+  return invoke('KeyBindings.focusIndex', index);
 };
 const focusLast$3 = () => {
-  return invoke$1('KeyBindings.focusLast');
+  return invoke('KeyBindings.focusLast');
 };
 const toggleRecordingKeys = () => {
-  return invoke$1('KeyBindings.toggleRecordingKeys');
+  return invoke('KeyBindings.toggleRecordingKeys');
 };
 const startRecordingKeys = () => {
-  return invoke$1('KeyBindings.startRecordingKeys');
+  return invoke('KeyBindings.startRecordingKeys');
 };
 const clearInput = () => {
-  return invoke$1('KeyBindings.clearInput');
+  return invoke('KeyBindings.clearInput');
 };
 const sortByPrecedence = () => {
-  return invoke$1('KeyBindings.sortByPrecedence');
+  return invoke('KeyBindings.sortByPrecedence');
 };
 const stopRecordingKeys = () => {
-  return invoke$1('KeyBindings.stopRecordingKeys');
+  return invoke('KeyBindings.stopRecordingKeys');
 };
 const handleContextMenu$3 = (button, x, y) => {
-  return invoke$1('KeyBindings.handleContextMenu', button, x, y);
+  return invoke('KeyBindings.handleContextMenu', button, x, y);
 };
 const copyCommandId = () => {
-  return invoke$1('KeyBindings.copyCommandId');
+  return invoke('KeyBindings.copyCommandId');
 };
 const copyCommandTitle = () => {
-  return invoke$1('KeyBindings.copyCommandTitle');
+  return invoke('KeyBindings.copyCommandTitle');
 };
 const addKeyBinding = () => {
-  return invoke$1('KeyBindings.addKeyBinding');
+  return invoke('KeyBindings.addKeyBinding');
 };
 const removeKeyBinding = () => {
-  return invoke$1('KeyBindings.removeKeyBinding');
+  return invoke('KeyBindings.removeKeyBinding');
 };
 const changeWhenExpression = () => {
-  return invoke$1('KeyBindings.changeWhenExpression');
+  return invoke('KeyBindings.changeWhenExpression');
 };
 const showSameKeyBindings = () => {
-  return invoke$1('KeyBindings.showSameKeyBindings');
+  return invoke('KeyBindings.showSameKeyBindings');
 };
 const resetKeyBinding = () => {
-  return invoke$1('KeyBindings.resetKeyBinding');
+  return invoke('KeyBindings.resetKeyBinding');
 };
 
 const KeyBindingsEditor = {
-    __proto__: null,
-    addKeyBinding,
-    changeWhenExpression,
-    clearInput,
-    copyCommandId,
-    copyCommandTitle,
-    focusFirst: focusFirst$4,
-    focusIndex: focusIndex$4,
-    focusLast: focusLast$3,
-    focusNext: focusNext$4,
-    focusPrevious: focusPrevious$4,
-    handleClick,
-    handleContextMenu: handleContextMenu$3,
-    handleDoubleClick,
-    handleInput: handleInput$3,
-    handleWheel: handleWheel$1,
-    open: open$3,
-    removeKeyBinding,
-    resetKeyBinding,
-    showSameKeyBindings,
-    sortByPrecedence,
-    startRecordingKeys,
-    stopRecordingKeys,
-    toggleRecordingKeys
+  __proto__: null,
+  addKeyBinding,
+  changeWhenExpression,
+  clearInput,
+  copyCommandId,
+  copyCommandTitle,
+  focusFirst: focusFirst$4,
+  focusIndex: focusIndex$4,
+  focusLast: focusLast$3,
+  focusNext: focusNext$4,
+  focusPrevious: focusPrevious$4,
+  handleClick,
+  handleContextMenu: handleContextMenu$3,
+  handleDoubleClick,
+  handleInput: handleInput$3,
+  handleWheel: handleWheel$1,
+  open: open$3,
+  removeKeyBinding,
+  resetKeyBinding,
+  showSameKeyBindings,
+  sortByPrecedence,
+  startRecordingKeys,
+  stopRecordingKeys,
+  toggleRecordingKeys
 };
 
 const Control = 'Control';
@@ -3080,105 +3087,105 @@ const press = async key => {
     ...keyOptions
   };
   // @ts-ignore
-  await invoke$1('TestFrameWork.performKeyBoardAction', 'press', options);
+  await invoke('TestFrameWork.performKeyBoardAction', 'press', options);
 };
 
 const KeyBoard = {
-    __proto__: null,
-    press
+  __proto__: null,
+  press
 };
 
 const openUri = async uri => {
-  await invoke$1('Main.openUri', uri);
+  await invoke('Main.openUri', uri);
 };
 const splitRight = async () => {
-  await invoke$1('Main.splitRight');
+  await invoke('Main.splitRight');
 };
 const openKeyBindings = async () => {
-  await invoke$1('Main.openKeyBindings');
+  await invoke('Main.openKeyBindings');
 };
 const closeAllEditors = async () => {
-  await invoke$1('Main.closeAllEditors');
+  await invoke('Main.closeAllEditors');
 };
 const closeTabsLeft = async () => {
-  await invoke$1('Main.closeTabsLeft');
+  await invoke('Main.closeTabsLeft');
 };
 const closeTabsRight = async () => {
-  await invoke$1('Main.closeTabsRight');
+  await invoke('Main.closeTabsRight');
 };
 const closeOthers = async () => {
-  await invoke$1('Main.closeOthers');
+  await invoke('Main.closeOthers');
 };
 const closeActiveEditor = async () => {
-  await invoke$1('Main.closeActiveEditor');
+  await invoke('Main.closeActiveEditor');
 };
 const focusFirst$3 = async () => {
-  await invoke$1('Main.focusFirst');
+  await invoke('Main.focusFirst');
 };
 const focusNext$3 = async () => {
-  await invoke$1('Main.focusNext');
+  await invoke('Main.focusNext');
 };
 const focusPrevious$3 = async () => {
-  await invoke$1('Main.focusPrevious');
+  await invoke('Main.focusPrevious');
 };
 const focusLast$2 = async () => {
-  await invoke$1('Main.focusLast');
+  await invoke('Main.focusLast');
 };
 
 const Main = {
-    __proto__: null,
-    closeActiveEditor,
-    closeAllEditors,
-    closeOthers,
-    closeTabsLeft,
-    closeTabsRight,
-    focusFirst: focusFirst$3,
-    focusLast: focusLast$2,
-    focusNext: focusNext$3,
-    focusPrevious: focusPrevious$3,
-    openKeyBindings,
-    openUri,
-    splitRight
+  __proto__: null,
+  closeActiveEditor,
+  closeAllEditors,
+  closeOthers,
+  closeTabsLeft,
+  closeTabsRight,
+  focusFirst: focusFirst$3,
+  focusLast: focusLast$2,
+  focusNext: focusNext$3,
+  focusPrevious: focusPrevious$3,
+  openKeyBindings,
+  openUri,
+  splitRight
 };
 
 const show$4 = async () => {
   // @ts-ignore
-  await invoke$1('Panel.selectIndex', 1);
+  await invoke('Panel.selectIndex', 1);
 };
 const handleFilterInput$1 = async text => {
   // @ts-ignore
-  await invoke$1('Output.handleFilterInput', text, Script);
+  await invoke('Output.handleFilterInput', text, Script);
 };
 const selectChannel = async channelId => {
   // @ts-ignore
-  await invoke$1('Output.selectChannel', channelId);
+  await invoke('Output.selectChannel', channelId);
 };
 const clear$2 = async () => {
   // @ts-ignore
-  await invoke$1('Output.clear');
+  await invoke('Output.clear');
 };
 
 const Output = {
-    __proto__: null,
-    clear: clear$2,
-    handleFilterInput: handleFilterInput$1,
-    selectChannel,
-    show: show$4
+  __proto__: null,
+  clear: clear$2,
+  handleFilterInput: handleFilterInput$1,
+  selectChannel,
+  show: show$4
 };
 
 const open$2 = async id => {
-  await invoke$1('Layout.showPanel', id);
+  await invoke('Layout.showPanel', id);
 };
 const openProblems = async () => {
   await open$2('Problems');
   // @ts-ignore
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke('Panel.selectIndex', 0);
 };
 
 const Panel = {
-    __proto__: null,
-    open: open$2,
-    openProblems
+  __proto__: null,
+  open: open$2,
+  openProblems
 };
 
 const getIsFirefox = () => {
@@ -3196,7 +3203,7 @@ const getIsFirefox = () => {
 
 const getNodePath$1 = () => {
   // @ts-ignore
-  return invoke$1(/* Platform.getNodePath */'Platform.getNodePath');
+  return invoke(/* Platform.getNodePath */'Platform.getNodePath');
 };
 
 const getNodePath = () => {
@@ -3207,64 +3214,64 @@ const isFirefox = () => {
 };
 
 const Platform = {
-    __proto__: null,
-    getNodePath,
-    isFirefox
+  __proto__: null,
+  getNodePath,
+  isFirefox
 };
 
 const show$3 = async () => {
   // @ts-ignore
-  await invoke$1('Panel.selectIndex', 0);
+  await invoke('Panel.selectIndex', 0);
 };
 const handleFilterInput = async text => {
   // @ts-ignore
-  await invoke$1('Problems.handleFilterInput', text, Script);
+  await invoke('Problems.handleFilterInput', text, Script);
 };
 const copyMessage = async () => {
   // @ts-ignore
-  await invoke$1('Problems.copyMessage');
+  await invoke('Problems.copyMessage');
 };
 const focusIndex$3 = async index => {
   // @ts-ignore
-  await invoke$1('Problems.focusIndex', index);
+  await invoke('Problems.focusIndex', index);
 };
 const handleArrowLeft = async () => {
   // @ts-ignore
-  await invoke$1('Problems.handleArrowLeft');
+  await invoke('Problems.handleArrowLeft');
 };
 const handleArrowRight = async () => {
   // @ts-ignore
-  await invoke$1('Problems.handleArrowRight');
+  await invoke('Problems.handleArrowRight');
 };
 const handleClickAt$1 = async (x, y) => {
   // @ts-ignore
-  await invoke$1('Problems.handleClickAt', x, y);
+  await invoke('Problems.handleClickAt', x, y);
 };
 const handleIconThemeChange = async () => {
   // @ts-ignore
-  await invoke$1('Problems.handleIconThemeChange');
+  await invoke('Problems.handleIconThemeChange');
 };
 const viewAsList = async () => {
   // @ts-ignore
-  await invoke$1('Problems.viewAsList');
+  await invoke('Problems.viewAsList');
 };
 const viewAsTable = async () => {
   // @ts-ignore
-  await invoke$1('Problems.viewAsTable');
+  await invoke('Problems.viewAsTable');
 };
 
 const Problems = {
-    __proto__: null,
-    copyMessage,
-    focusIndex: focusIndex$3,
-    handleArrowLeft,
-    handleArrowRight,
-    handleClickAt: handleClickAt$1,
-    handleFilterInput,
-    handleIconThemeChange,
-    show: show$3,
-    viewAsList,
-    viewAsTable
+  __proto__: null,
+  copyMessage,
+  focusIndex: focusIndex$3,
+  handleArrowLeft,
+  handleArrowRight,
+  handleClickAt: handleClickAt$1,
+  handleFilterInput,
+  handleIconThemeChange,
+  show: show$3,
+  viewAsList,
+  viewAsTable
 };
 
 const callbacks = Object.create(null);
@@ -3276,7 +3283,7 @@ const registerCallbackCommand = async commandId => {
   } = Promise.withResolvers();
   callbacks[id] = resolve;
   // @ts-ignore
-  await invoke$1(`Test.registerTestCommand`, commandId);
+  await invoke(`Test.registerTestCommand`, commandId);
   return {
     promise
   };
@@ -3286,59 +3293,59 @@ const QuickPick$1 = 'QuickPick';
 
 const open$1 = async () => {
   // @ts-ignore
-  await invoke$1('Viewlet.openWidget', QuickPick$1, 'everything');
+  await invoke('Viewlet.openWidget', QuickPick$1, 'everything');
 };
 const handleInput$2 = async value => {
   // @ts-ignore
-  await invoke$1('QuickPick.handleInput', value, 0);
+  await invoke('QuickPick.handleInput', value, 0);
 };
 const handleClickAt = async (x, y) => {
   // @ts-ignore
-  await invoke$1('QuickPick.handleClickAt', x, y);
+  await invoke('QuickPick.handleClickAt', x, y);
 };
 const setValue$1 = async value => {
   // @ts-ignore
-  await invoke$1('QuickPick.setValue', value);
+  await invoke('QuickPick.setValue', value);
 };
 const focusNext$2 = async () => {
   // @ts-ignore
-  await invoke$1('QuickPick.focusNext');
+  await invoke('QuickPick.focusNext');
 };
 const focusFirst$2 = async () => {
   // @ts-ignore
-  await invoke$1('QuickPick.focusFirst');
+  await invoke('QuickPick.focusFirst');
 };
 const focusLast$1 = async () => {
   // @ts-ignore
-  await invoke$1('QuickPick.focusLast');
+  await invoke('QuickPick.focusLast');
 };
 const focusIndex$2 = async index => {
   // @ts-ignore
-  await invoke$1('QuickPick.focusIndex', index);
+  await invoke('QuickPick.focusIndex', index);
 };
 const focusPrevious$2 = async () => {
   // @ts-ignore
-  await invoke$1('QuickPick.focusPrevious');
+  await invoke('QuickPick.focusPrevious');
 };
 const selectItem = async label => {
   // @ts-ignore
-  await invoke$1('QuickPick.selectItem', label);
+  await invoke('QuickPick.selectItem', label);
 };
 const selectIndex$3 = async index => {
   // @ts-ignore
-  await invoke$1('QuickPick.selectIndex', index);
+  await invoke('QuickPick.selectIndex', index);
 };
 const selectCurrentIndex = async () => {
   // @ts-ignore
-  await invoke$1('QuickPick.selectCurrentIndex');
+  await invoke('QuickPick.selectCurrentIndex');
 };
 const executeCommand = async label => {
   // @ts-ignore
-  await invoke$1('QuickPick.showCommands');
+  await invoke('QuickPick.showCommands');
   // @ts-ignore
-  await invoke$1('QuickPick.handleInput', label, 0);
+  await invoke('QuickPick.handleInput', label, 0);
   // @ts-ignore
-  await invoke$1('QuickPick.selectItem', label);
+  await invoke('QuickPick.selectItem', label);
 };
 const selectItem2 = async ({
   callbackCommand,
@@ -3348,46 +3355,46 @@ const selectItem2 = async ({
     promise
   } = await registerCallbackCommand(callbackCommand);
   // @ts-ignore
-  invoke$1('QuickPick.selectItem', label);
+  invoke('QuickPick.selectItem', label);
   await promise;
 };
 
 const QuickPick = {
-    __proto__: null,
-    executeCommand,
-    focusFirst: focusFirst$2,
-    focusIndex: focusIndex$2,
-    focusLast: focusLast$1,
-    focusNext: focusNext$2,
-    focusPrevious: focusPrevious$2,
-    handleClickAt,
-    handleInput: handleInput$2,
-    open: open$1,
-    selectCurrentIndex,
-    selectIndex: selectIndex$3,
-    selectItem,
-    selectItem2,
-    setValue: setValue$1
+  __proto__: null,
+  executeCommand,
+  focusFirst: focusFirst$2,
+  focusIndex: focusIndex$2,
+  focusLast: focusLast$1,
+  focusNext: focusNext$2,
+  focusPrevious: focusPrevious$2,
+  handleClickAt,
+  handleInput: handleInput$2,
+  open: open$1,
+  selectCurrentIndex,
+  selectIndex: selectIndex$3,
+  selectItem,
+  selectItem2,
+  setValue: setValue$1
 };
 
 const clear$1 = async () => {
   // @ts-ignore
-  return invoke$1('References.clear');
+  return invoke('References.clear');
 };
 const collapseAll$1 = async () => {
   // @ts-ignore
-  return invoke$1('References.collapseAll');
+  return invoke('References.collapseAll');
 };
 const refresh = async () => {
   // @ts-ignore
-  return invoke$1('References.refresh');
+  return invoke('References.refresh');
 };
 
 const References = {
-    __proto__: null,
-    clear: clear$1,
-    collapseAll: collapseAll$1,
-    refresh
+  __proto__: null,
+  clear: clear$1,
+  collapseAll: collapseAll$1,
+  refresh
 };
 
 const show$2 = async () => {
@@ -3395,242 +3402,242 @@ const show$2 = async () => {
 };
 const handleClickSectionBreakPoints = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.handleClickSectionBreakPoints');
+  await invoke('Run And Debug.handleClickSectionBreakPoints');
 };
 const handleClickSectionWatch = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.handleClickSectionWatch');
+  await invoke('Run And Debug.handleClickSectionWatch');
 };
 const addWatchExpression = async expression => {
   // @ts-ignore
-  await invoke$1('Run And Debug.addWatchExpression', expression);
+  await invoke('Run And Debug.addWatchExpression', expression);
 };
 const handleWatchValueChange = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.handleWatchValueChange');
+  await invoke('Run And Debug.handleWatchValueChange');
 };
 const acceptWatchExpressionEdit = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.acceptWatchExpressionEdit');
+  await invoke('Run And Debug.acceptWatchExpressionEdit');
 };
 const selectIndex$2 = async index => {
   // @ts-ignore
-  await invoke$1('Run And Debug.selectIndex', index);
+  await invoke('Run And Debug.selectIndex', index);
 };
 const setPauseOnExceptions = async value => {
   // @ts-ignore
-  await invoke$1('Run And Debug.setPauseOnExceptions', value);
+  await invoke('Run And Debug.setPauseOnExceptions', value);
 };
 const handleRename = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.handleRename');
+  await invoke('Run And Debug.handleRename');
 };
 const handleSpace = async () => {
   // @ts-ignore
-  await invoke$1('Run And Debug.handleSpace');
+  await invoke('Run And Debug.handleSpace');
 };
 
 const RunAndDebug = {
-    __proto__: null,
-    acceptWatchExpressionEdit,
-    addWatchExpression,
-    handleClickSectionBreakPoints,
-    handleClickSectionWatch,
-    handleRename,
-    handleSpace,
-    handleWatchValueChange,
-    selectIndex: selectIndex$2,
-    setPauseOnExceptions,
-    show: show$2
+  __proto__: null,
+  acceptWatchExpressionEdit,
+  addWatchExpression,
+  handleClickSectionBreakPoints,
+  handleClickSectionWatch,
+  handleRename,
+  handleSpace,
+  handleWatchValueChange,
+  selectIndex: selectIndex$2,
+  setPauseOnExceptions,
+  show: show$2
 };
 
 const setValue = async value => {
   // @ts-ignore
-  await invoke$1('Search.handleInput', value, Script);
+  await invoke('Search.handleInput', value, Script);
 };
 const setReplaceValue = async value => {
   // @ts-ignore
-  await invoke$1('Search.handleReplaceInput', value, Script);
+  await invoke('Search.handleReplaceInput', value, Script);
 };
 const setExcludeValue = async value => {
   // @ts-ignore
-  await invoke$1('Search.handleExcludeInput', value, Script);
+  await invoke('Search.handleExcludeInput', value, Script);
 };
 const replaceAll = async () => {
-  await invoke$1('Search.replaceAll');
+  await invoke('Search.replaceAll');
 };
 const setIncludeValue = async value => {
   // @ts-ignore
-  await invoke$1('Search.handleIncludeInput', value, Script);
+  await invoke('Search.handleIncludeInput', value, Script);
 };
 const clearSearchResults = async () => {
-  await invoke$1('Search.clearSearchResults');
+  await invoke('Search.clearSearchResults');
 };
 const openDetails = async () => {
-  await invoke$1('Search.openDetails');
+  await invoke('Search.openDetails');
 };
 const collapseDetails = async () => {
-  await invoke$1('Search.collapseDetails');
+  await invoke('Search.collapseDetails');
 };
 const dismissItem = async () => {
-  await invoke$1('Search.dismissItem');
+  await invoke('Search.dismissItem');
 };
 const focusFirst$1 = async () => {
-  await invoke$1('Search.focusFirst');
+  await invoke('Search.focusFirst');
 };
 const focusIndex$1 = async index => {
-  await invoke$1('Search.focusIndex', index);
+  await invoke('Search.focusIndex', index);
 };
 const selectIndex$1 = async index => {
-  await invoke$1('Search.selectIndex', index);
+  await invoke('Search.selectIndex', index);
 };
 const focusNext$1 = async () => {
-  await invoke$1('Search.focusNext');
+  await invoke('Search.focusNext');
 };
 const handleWheel = async (deltaMode, deltaY) => {
-  await invoke$1('Search.handleWheel', deltaMode, deltaY);
+  await invoke('Search.handleWheel', deltaMode, deltaY);
 };
 const focusNextPage = async () => {
   // @ts-ignore
-  await invoke$1('Search.focusPage');
+  await invoke('Search.focusPage');
 };
 const focusPreviousPage = async () => {
-  await invoke$1('Search.focusPreviousPage');
+  await invoke('Search.focusPreviousPage');
 };
 const focusPrevious$1 = async () => {
-  await invoke$1('Search.focusPrevious');
+  await invoke('Search.focusPrevious');
 };
 const toggleSearchDetails = async () => {
-  await invoke$1('Search.toggleSearchDetails');
+  await invoke('Search.toggleSearchDetails');
 };
 const toggleMatchCase = async () => {
-  await invoke$1('Search.toggleMatchCase');
+  await invoke('Search.toggleMatchCase');
 };
 const toggleMatchWholeWord = async () => {
-  await invoke$1('Search.toggleMatchWholeWord');
+  await invoke('Search.toggleMatchWholeWord');
 };
 const togglePreserveCase = async () => {
-  await invoke$1('Search.togglePreserveCase');
+  await invoke('Search.togglePreserveCase');
 };
 const toggleUseRegularExpression = async () => {
-  await invoke$1('Search.toggleUseRegularExpression');
+  await invoke('Search.toggleUseRegularExpression');
 };
 const toggleReplace = async () => {
-  await invoke$1('Search.toggleReplace');
+  await invoke('Search.toggleReplace');
 };
 const open = async () => {
-  await invoke$1('SideBar.openViewlet', 'Search');
+  await invoke('SideBar.openViewlet', 'Search');
 };
 const setLimit = async limit => {
   // @ts-ignore
-  await invoke$1('Search.setLimit', limit);
+  await invoke('Search.setLimit', limit);
 };
 const handleListBlur = async () => {
   // @ts-ignore
-  await invoke$1('Search.handleListBlur');
+  await invoke('Search.handleListBlur');
 };
 const collapseAll = async () => {
   // @ts-ignore
-  await invoke$1('Search.collapseAll');
+  await invoke('Search.collapseAll');
 };
 const copy = async () => {
   // @ts-ignore
-  await invoke$1('Search.copy');
+  await invoke('Search.copy');
 };
 const copyPath = async () => {
   // @ts-ignore
-  await invoke$1('Search.copyPath');
+  await invoke('Search.copyPath');
 };
 const handleInputCut = async name => {
   // @ts-ignore
-  await invoke$1('Search.handleInputCut', name);
+  await invoke('Search.handleInputCut', name);
 };
 const handleInputPaste = async name => {
   // @ts-ignore
-  await invoke$1('Search.handleInputPaste', name);
+  await invoke('Search.handleInputPaste', name);
 };
 const handleInputCopy = async name => {
   // @ts-ignore
-  await invoke$1('Search.handleInputCopy', name);
+  await invoke('Search.handleInputCopy', name);
 };
 const handleInputSelectionChange = async (name, start, end) => {
   // @ts-ignore
-  await invoke$1('Search.handleInputSelectionChange', name, start, end);
+  await invoke('Search.handleInputSelectionChange', name, start, end);
 };
 const handleInputContextMenu = async (name, button, x, y) => {
   // @ts-ignore
-  await invoke$1('Search.handleInputConextMenu', name, button, x, y);
+  await invoke('Search.handleInputConextMenu', name, button, x, y);
 };
 const handleContextMenu$2 = async (button, x, y) => {
   // @ts-ignore
-  await invoke$1('Search.handleContextMenu', name, button, x, y);
+  await invoke('Search.handleContextMenu', name, button, x, y);
 };
 
 const Search = {
-    __proto__: null,
-    clearSearchResults,
-    collapseAll,
-    collapseDetails,
-    copy,
-    copyPath,
-    dismissItem,
-    focusFirst: focusFirst$1,
-    focusIndex: focusIndex$1,
-    focusNext: focusNext$1,
-    focusNextPage,
-    focusPrevious: focusPrevious$1,
-    focusPreviousPage,
-    handleContextMenu: handleContextMenu$2,
-    handleInputContextMenu,
-    handleInputCopy,
-    handleInputCut,
-    handleInputPaste,
-    handleInputSelectionChange,
-    handleListBlur,
-    handleWheel,
-    open,
-    openDetails,
-    replaceAll,
-    selectIndex: selectIndex$1,
-    setExcludeValue,
-    setIncludeValue,
-    setLimit,
-    setReplaceValue,
-    setValue,
-    toggleMatchCase,
-    toggleMatchWholeWord,
-    togglePreserveCase,
-    toggleReplace,
-    toggleSearchDetails,
-    toggleUseRegularExpression
+  __proto__: null,
+  clearSearchResults,
+  collapseAll,
+  collapseDetails,
+  copy,
+  copyPath,
+  dismissItem,
+  focusFirst: focusFirst$1,
+  focusIndex: focusIndex$1,
+  focusNext: focusNext$1,
+  focusNextPage,
+  focusPrevious: focusPrevious$1,
+  focusPreviousPage,
+  handleContextMenu: handleContextMenu$2,
+  handleInputContextMenu,
+  handleInputCopy,
+  handleInputCut,
+  handleInputPaste,
+  handleInputSelectionChange,
+  handleListBlur,
+  handleWheel,
+  open,
+  openDetails,
+  replaceAll,
+  selectIndex: selectIndex$1,
+  setExcludeValue,
+  setIncludeValue,
+  setLimit,
+  setReplaceValue,
+  setValue,
+  toggleMatchCase,
+  toggleMatchWholeWord,
+  togglePreserveCase,
+  toggleReplace,
+  toggleSearchDetails,
+  toggleUseRegularExpression
 };
 
 const show$1 = async () => {
-  return invoke$1('Main.openUri', 'settings://');
+  return invoke('Main.openUri', 'settings://');
 };
 const handleInput$1 = async searchValue => {
   // @ts-ignore
-  return invoke$1('Settings.handleInput', searchValue, Script);
+  return invoke('Settings.handleInput', searchValue, Script);
 };
 const usePreviousSearchValue = async () => {
   // @ts-ignore
-  return invoke$1('Settings.usePreviousSearchValue');
+  return invoke('Settings.usePreviousSearchValue');
 };
 const useNextSearchValue = async () => {
   // @ts-ignore
-  return invoke$1('Settings.useNextSearchValue');
+  return invoke('Settings.useNextSearchValue');
 };
 const clear = async searchValue => {
   // @ts-ignore
-  return invoke$1('Settings.clear', searchValue, Script);
+  return invoke('Settings.clear', searchValue, Script);
 };
 const clearHistory = async () => {
   // @ts-ignore
-  return invoke$1('Settings.clearHistory', searchValue, Script);
+  return invoke('Settings.clearHistory', searchValue, Script);
 };
 const selectTab = async tabId => {
   // @ts-ignore
-  return invoke$1('Settings.handleClickTab', tabId);
+  return invoke('Settings.handleClickTab', tabId);
 };
 const selectWorkspace = async () => {
   await selectTab('workspace');
@@ -3646,46 +3653,46 @@ const selectWindow = async () => {
 };
 const handleScroll = async scrollTop => {
   // @ts-ignore
-  await invoke$1('Settings.handleScroll', scrollTop, Script);
+  await invoke('Settings.handleScroll', scrollTop, Script);
 };
 const handleClickFilterButton = async (x, y) => {
   // @ts-ignore
-  await invoke$1('Settings.handleClickFilterButton', x, y);
+  await invoke('Settings.handleClickFilterButton', x, y);
 };
 
 const SettingsView = {
-    __proto__: null,
-    clear,
-    clearHistory,
-    handleClickFilterButton,
-    handleInput: handleInput$1,
-    handleScroll,
-    selectExtensions,
-    selectTab,
-    selectTextEditor,
-    selectWindow,
-    selectWorkspace,
-    show: show$1,
-    useNextSearchValue,
-    usePreviousSearchValue
+  __proto__: null,
+  clear,
+  clearHistory,
+  handleClickFilterButton,
+  handleInput: handleInput$1,
+  handleScroll,
+  selectExtensions,
+  selectTab,
+  selectTextEditor,
+  selectWindow,
+  selectWorkspace,
+  show: show$1,
+  useNextSearchValue,
+  usePreviousSearchValue
 };
 
 const selectIndex = async index => {
   // @ts-ignore
-  await invoke$1('Source Control.selectIndex', index);
+  await invoke('Source Control.selectIndex', index);
 };
 const acceptInput = async () => {
-  await invoke$1('Source Control.acceptInput');
+  await invoke('Source Control.acceptInput');
 };
 const handleInput = async text => {
   // @ts-ignore
-  await invoke$1('Source Control.handleInput', text, Script$1);
+  await invoke('Source Control.handleInput', text, Script$1);
 };
 const handleClickSourceControlButtons = async (index, name) => {
-  await invoke$1('Source Control.handleClickSourceControlButtons', index, name);
+  await invoke('Source Control.handleClickSourceControlButtons', index, name);
 };
 const handleContextMenu$1 = async (button, x, y) => {
-  await invoke$1('Source Control.handleContextMenu', button, x, y);
+  await invoke('Source Control.handleContextMenu', button, x, y);
 };
 const show = async () => {
   // @ts-ignore
@@ -3693,117 +3700,117 @@ const show = async () => {
 };
 
 const SourceControl = {
-    __proto__: null,
-    acceptInput,
-    handleClickSourceControlButtons,
-    handleContextMenu: handleContextMenu$1,
-    handleInput,
-    selectIndex,
-    show
+  __proto__: null,
+  acceptInput,
+  handleClickSourceControlButtons,
+  handleContextMenu: handleContextMenu$1,
+  handleInput,
+  selectIndex,
+  show
 };
 
 const update = async () => {
-  await invoke$1('StatusBar.updateStatusBarItems');
+  await invoke('StatusBar.updateStatusBarItems');
 };
 
 const StatusBar = {
-    __proto__: null,
-    update
+  __proto__: null,
+  update
 };
 
 const closeMenu = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.closeMenu');
+  await invoke('TitleBar.closeMenu');
 };
 const focus = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.focus');
+  await invoke('TitleBar.focus');
 };
 const focusFirst = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.focusFirst');
+  await invoke('TitleBar.focusFirst');
 };
 const focusIndex = async index => {
   // @ts-ignore
-  await invoke$1('TitleBar.focusIndex', index);
+  await invoke('TitleBar.focusIndex', index);
 };
 const focusLast = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.focusLast');
+  await invoke('TitleBar.focusLast');
 };
 const focusNext = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.focusNext');
+  await invoke('TitleBar.focusNext');
 };
 const focusPrevious = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.focusPrevious');
+  await invoke('TitleBar.focusPrevious');
 };
 const handleKeyArrowDown = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyArrowDown');
+  await invoke('TitleBar.handleKeyArrowDown');
 };
 const handleKeyArrowLeft = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyArrowLeft');
+  await invoke('TitleBar.handleKeyArrowLeft');
 };
 const handleKeyArrowRight = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyArrowRight');
+  await invoke('TitleBar.handleKeyArrowRight');
 };
 const handleKeyArrowUp = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyArrowUp');
+  await invoke('TitleBar.handleKeyArrowUp');
 };
 const handleKeyEnd = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyEnd');
+  await invoke('TitleBar.handleKeyEnd');
 };
 const handleKeyHome = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyHome');
+  await invoke('TitleBar.handleKeyHome');
 };
 const handleKeySpace = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeySpace');
+  await invoke('TitleBar.handleKeySpace');
 };
 const handleKeyEscape = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleKeyEscape');
+  await invoke('TitleBar.handleKeyEscape');
 };
 const toggleIndex = async index => {
   // @ts-ignore
-  await invoke$1('TitleBar.toggleIndex', index);
+  await invoke('TitleBar.toggleIndex', index);
 };
 const toggleMenu = async () => {
   // @ts-ignore
-  await invoke$1('TitleBar.toggleMenu');
+  await invoke('TitleBar.toggleMenu');
 };
 const handleContextMenu = async (button, x, y) => {
   // @ts-ignore
-  await invoke$1('TitleBar.handleContextMenu', button, x, y);
+  await invoke('TitleBar.handleContextMenu', button, x, y);
 };
 
 const TitleBarMenuBar = {
-    __proto__: null,
-    closeMenu,
-    focus,
-    focusFirst,
-    focusIndex,
-    focusLast,
-    focusNext,
-    focusPrevious,
-    handleContextMenu,
-    handleKeyArrowDown,
-    handleKeyArrowLeft,
-    handleKeyArrowRight,
-    handleKeyArrowUp,
-    handleKeyEnd,
-    handleKeyEscape,
-    handleKeyHome,
-    handleKeySpace,
-    toggleIndex,
-    toggleMenu
+  __proto__: null,
+  closeMenu,
+  focus,
+  focusFirst,
+  focusIndex,
+  focusLast,
+  focusNext,
+  focusPrevious,
+  handleContextMenu,
+  handleKeyArrowDown,
+  handleKeyArrowLeft,
+  handleKeyArrowRight,
+  handleKeyArrowUp,
+  handleKeyEnd,
+  handleKeyEscape,
+  handleKeyHome,
+  handleKeySpace,
+  toggleIndex,
+  toggleMenu
 };
 
 let url = '';
@@ -3815,9 +3822,9 @@ const resolve = relativePath => {
 };
 
 const Url = {
-    __proto__: null,
-    resolve,
-    setUrl
+  __proto__: null,
+  resolve,
+  setUrl
 };
 
 const getPortTuple = () => {
@@ -3833,7 +3840,7 @@ const getPortTuple = () => {
 
 // TODO ask webview worker directly
 const getWebViewInfo = async webViewId => {
-  const info = await invoke$1('WebView.getWebViewInfo2', webViewId);
+  const info = await invoke('WebView.getWebViewInfo2', webViewId);
   return info;
 };
 
@@ -3892,12 +3899,12 @@ const fromId = async webViewId => {
 };
 
 const WebView = {
-    __proto__: null,
-    fromId
+  __proto__: null,
+  fromId
 };
 
 const setPath = async path => {
-  await invoke$1('Workspace.setPath', path);
+  await invoke('Workspace.setPath', path);
 };
 const openTmpDir = async () => {
   const tmpDir = await getTmpDir();
@@ -3906,9 +3913,9 @@ const openTmpDir = async () => {
 };
 
 const Workspace = {
-    __proto__: null,
-    openTmpDir,
-    setPath
+  __proto__: null,
+  openTmpDir,
+  setPath
 };
 
 const createApi = (platform, assetDir) => {
@@ -4053,7 +4060,7 @@ const executeTest = async (name, fn, globals = {}) => {
     console.info(`PASS ${name} in ${formattedDuration}`);
   }
   // @ts-ignore
-  await invoke$1('TestFrameWork.showOverlay', type, background, text);
+  await invoke('TestFrameWork.showOverlay', type, background, text);
 };
 
 const hotReloadEnabled = async () => {
@@ -4111,7 +4118,7 @@ const watchForHotReload = async (platform, href) => {
   const fileUrl = getFileUri(href);
   const callbackCommand = 'FileWatcher.handleEvent';
   // @ts-ignore
-  await invoke$1('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
+  await invoke('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
 };
 
 // TODO move this into three steps: