@lvce-editor/test-worker 4.37.0 → 4.39.0

package/dist/testWorkerMain.js

@@ -531,11 +531,11 @@ const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
@@ -768,7 +768,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$6 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -777,7 +777,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$6(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -881,11 +881,11 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
+const send$1 = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -921,10 +921,10 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -985,6 +985,40 @@ const MessagePortRpcParent = {
   __proto__: null,
   create: create$e
 };
+const create$5 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3
+};
 const create$2 = async ({
   commandMap
 }) => {
@@ -1055,16 +1089,23 @@ const {
   invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$3,
   set: set$3} = create$1(RendererWorker$1);
+const sendMessagePortToEditorWorker$1 = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
 const RendererWorker = {
   __proto__: null,
   invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$3,
+  sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$1,
   set: set$3};
 
 const {
   set: set$1,
-  invoke,
-  invokeAndTransfer
+  invoke: invoke$1,
+  invokeAndTransfer,
+  sendMessagePortToEditorWorker
 } = RendererWorker;
 
 const stringifyError = error => {
@@ -1124,7 +1165,7 @@ const executeTest = async (name, fn, globals = {}) => {
     state = Pass;
   }
   // @ts-ignore
-  await invoke('TestFrameWork.showOverlay', state, background, text);
+  await invoke$1('TestFrameWork.showOverlay', state, background, text);
 };
 
 const importScript = async url => {
@@ -1166,7 +1207,7 @@ const getLocatorInvoke = locator => {
     const module = get(locator.webViewId);
     return module.invoke;
   }
-  return invoke;
+  return invoke$1;
 };
 
 const locatorInvoke = (locator, method, ...params) => {
@@ -1564,7 +1605,7 @@ test.skip = async id => {
   const background = 'yellow';
   const text = `test skipped ${id}`;
   // @ts-ignore
-  await invoke('TestFrameWork.showOverlay', state, background, text);
+  await invoke$1('TestFrameWork.showOverlay', state, background, text);
 };
 const {
   expect
@@ -1579,22 +1620,22 @@ const TestFrameWork = {
 };
 
 const show$3 = async () => {
-  return invoke('About.showAbout');
+  return invoke$1('About.showAbout');
 };
 const handleClickOk = async () => {
-  return invoke('About.handleClickOk');
+  return invoke$1('About.handleClickOk');
 };
 const handleClickClose = async () => {
-  return invoke('About.handleClickClose');
+  return invoke$1('About.handleClickClose');
 };
 const handleClickCopy = async () => {
-  return invoke('About.handleClickCopy');
+  return invoke$1('About.handleClickCopy');
 };
 const focusNext$9 = async () => {
-  return invoke('About.focusNext');
+  return invoke$1('About.focusNext');
 };
 const focusPrevious$7 = async () => {
-  return invoke('About.focusPrevious');
+  return invoke$1('About.focusPrevious');
 };
 
 const TestFrameWorkComponentAbout = {
@@ -1608,28 +1649,28 @@ const TestFrameWorkComponentAbout = {
 };
 
 const focus$2 = async () => {
-  await invoke('ActivityBar.focus');
+  await invoke$1('ActivityBar.focus');
 };
 const focusFirst$7 = async () => {
-  await invoke('ActivityBar.focusFirst');
+  await invoke$1('ActivityBar.focusFirst');
 };
 const focusLast$6 = async () => {
-  await invoke('ActivityBar.focusLast');
+  await invoke$1('ActivityBar.focusLast');
 };
 const focusNext$8 = async () => {
-  await invoke('ActivityBar.focusNext');
+  await invoke$1('ActivityBar.focusNext');
 };
 const focusPrevious$6 = async () => {
-  await invoke('ActivityBar.focusPrevious');
+  await invoke$1('ActivityBar.focusPrevious');
 };
 const handleClick$2 = async index => {
-  await invoke('ActivityBar.handleClick', index);
+  await invoke$1('ActivityBar.handleClick', index);
 };
 const handleContextMenu$1 = async () => {
-  await invoke('ActivityBar.handleContextMenu');
+  await invoke$1('ActivityBar.handleContextMenu');
 };
 const selectCurrent = async () => {
-  await invoke('ActivityBar.selectCurrent');
+  await invoke$1('ActivityBar.selectCurrent');
 };
 
 const TestFrameworkComponentActivityBar = {
@@ -1689,19 +1730,19 @@ const TestFrameWorkComponentBaseUrl = {
 };
 
 const readNativeFiles = async () => {
-  await invoke('ClipBoard.readNativeFiles');
+  await invoke$1('ClipBoard.readNativeFiles');
 };
 const writeNativeFiles = async uris => {
   // @ts-ignore
-  await invoke('ClipBoard.writeNativeFiles', uris);
+  await invoke$1('ClipBoard.writeNativeFiles', uris);
 };
 const enableMemoryClipBoard = async () => {
   // @ts-ignore
-  await invoke('ClipBoard.enableMemoryClipBoard');
+  await invoke$1('ClipBoard.enableMemoryClipBoard');
 };
 const disableMemoryClipBoard = async () => {
   // @ts-ignore
-  await invoke('ClipBoard.disableMemoryClipBoard');
+  await invoke$1('ClipBoard.disableMemoryClipBoard');
 };
 
 const TestFrameworkComponentClipBoard = {
@@ -1714,7 +1755,7 @@ const TestFrameworkComponentClipBoard = {
 
 const execute$1 = async (id, ...args) => {
   // @ts-ignore
-  return invoke(id, ...args);
+  return invoke$1(id, ...args);
 };
 
 const TestFrameWorkComponentCommand = {
@@ -1723,7 +1764,7 @@ const TestFrameWorkComponentCommand = {
 };
 
 const selectItem$1 = async text => {
-  await invoke('Menu.selectItem', text);
+  await invoke$1('Menu.selectItem', text);
 };
 
 const TestFrameWorkComponentContextMenu = {
@@ -1733,35 +1774,35 @@ const TestFrameWorkComponentContextMenu = {
 
 const openIframeInspector = async () => {
   // @ts-ignore
-  return invoke('Developer.openIframeInspector');
+  return invoke$1('Developer.openIframeInspector');
 };
 const openCacheFolder = async () => {
   // @ts-ignore
-  return invoke('Developer.openCacheFolder');
+  return invoke$1('Developer.openCacheFolder');
 };
 const openConfigFolder = async () => {
   // @ts-ignore
-  return invoke('Developer.openConfigFolder');
+  return invoke$1('Developer.openConfigFolder');
 };
 const openLogsFolder = async () => {
   // @ts-ignore
-  return invoke('Developer.openLogsFolder');
+  return invoke$1('Developer.openLogsFolder');
 };
 const openProcessExplorer = async () => {
   // @ts-ignore
-  return invoke('Developer.openProcessExplorer');
+  return invoke$1('Developer.openProcessExplorer');
 };
 const reloadColorTheme = async () => {
   // @ts-ignore
-  return invoke('Developer.reloadColorTheme');
+  return invoke$1('Developer.reloadColorTheme');
 };
 const reloadIconTheme = async () => {
   // @ts-ignore
-  return invoke('Developer.reloadIconTheme');
+  return invoke$1('Developer.reloadIconTheme');
 };
 const toggleDeveloperTools = async () => {
   // @ts-ignore
-  return invoke('Developer.toggleDeveloperTools');
+  return invoke$1('Developer.toggleDeveloperTools');
 };
 
 const TestFrameWorkComponentDeveloper = {
@@ -1793,12 +1834,12 @@ const executeMock$1 = id => {
 
 const showSaveFilePicker = async () => {
   // @ts-ignore
-  await invoke('FilePicker.showSaveFilePicker');
+  await invoke$1('FilePicker.showSaveFilePicker');
 };
 const mockSaveFilePicker = async fn => {
   const id = registerMock(fn);
   // @ts-ignore
-  await invoke('FilePicker.mockSaveFilePicker', id);
+  await invoke$1('FilePicker.mockSaveFilePicker', id);
 };
 const executeMock = id => {
   return executeMock$1(id);
@@ -1811,177 +1852,234 @@ const TestFrameWorkComponentDialog = {
   showSaveFilePicker
 };
 
+const areSelectionsEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const send = async port => {
+  const rpcId = 9001;
+  await sendMessagePortToEditorWorker(port, rpcId);
+};
+const launchEditorWorkerRpc = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    send
+  });
+  return rpc;
+};
+
+let rpcPromise;
+const getRpc = () => {
+  if (!rpcPromise) {
+    rpcPromise = launchEditorWorkerRpc();
+  }
+  return rpcPromise;
+};
+const invoke = async (method, ...params) => {
+  const rpc = await getRpc();
+  return rpc.invoke(method, ...params);
+};
+
 const setCursor = async (rowIndex, columnIndex) => {
-  await invoke('Editor.cursorSet', rowIndex, columnIndex);
+  await invoke$1('Editor.cursorSet', rowIndex, columnIndex);
 };
 const openCompletion = async () => {
-  await invoke('Editor.openCompletion');
+  await invoke$1('Editor.openCompletion');
 };
 const closeCompletion = async () => {
   // @ts-ignore
-  await invoke('EditorCompletion.close');
+  await invoke$1('EditorCompletion.close');
 };
 const openEditorContextMenu = async () => {
-  await invoke('Editor.handleContextMenu', 0, 0);
+  await invoke$1('Editor.handleContextMenu', 0, 0);
 };
 const invokeTabCompletion = async () => {
-  await invoke('Editor.tabCompletion');
+  await invoke$1('Editor.tabCompletion');
 };
 const executeTabCompletion = async () => {
-  await invoke('Editor.tabCompletion');
+  await invoke$1('Editor.tabCompletion');
 };
 const invokeBraceCompletion = async text => {
-  await invoke('Editor.braceCompletion', text);
+  await invoke$1('Editor.braceCompletion', text);
 };
 const cursorCharacterRight = async () => {
-  await invoke('Editor.cursorCharacterRight');
+  await invoke$1('Editor.cursorCharacterRight');
 };
 const cursorCharacterLeft = async () => {
-  await invoke('Editor.cursorCharacterLeft');
+  await invoke$1('Editor.cursorCharacterLeft');
 };
 const copyLineDown = async () => {
-  await invoke('Editor.copyLineDown');
+  await invoke$1('Editor.copyLineDown');
 };
 const cursorDown = async () => {
-  await invoke('Editor.cursorDown');
+  await invoke$1('Editor.cursorDown');
 };
 const cursorUp = async () => {
-  await invoke('Editor.cursorUp');
+  await invoke$1('Editor.cursorUp');
 };
 const cursorWordLeft = async () => {
-  await invoke('Editor.cursorWordLeft');
+  await invoke$1('Editor.cursorWordLeft');
 };
 const cursorWordRight = async () => {
-  await invoke('Editor.cursorWordRight');
+  await invoke$1('Editor.cursorWordRight');
 };
 const goToDefinition = async () => {
-  await invoke('Editor.goToDefinition');
+  await invoke$1('Editor.goToDefinition');
 };
 const openHover = async () => {
-  await invoke('Editor.showHover2');
+  await invoke$1('Editor.showHover2');
 };
 const goToTypeDefinition = async () => {
-  await invoke('Editor.goToTypeDefinition');
+  await invoke$1('Editor.goToTypeDefinition');
 };
 const type = async text => {
-  await invoke('Editor.type', text);
+  await invoke$1('Editor.type', text);
 };
 const findAllReferences = async () => {
   // @ts-ignore
-  await invoke('SideBar.show', 'References', /* focus */true);
+  await invoke$1('SideBar.show', 'References', /* focus */true);
 };
 const findAllImplementations = async () => {
   // @ts-ignore
-  await invoke('SideBar.show', 'Implementations', /* focus */true);
+  await invoke$1('SideBar.show', 'Implementations', /* focus */true);
 };
 const setSelections = async selections => {
-  await invoke('Editor.setSelections', selections);
+  await invoke$1('Editor.setSelections', selections);
 };
 const openFindWidget = async () => {
-  await invoke('Editor.openFind');
+  await invoke$1('Editor.openFind');
 };
 const setDeltaY = async deltaY => {
-  await invoke('Editor.setDeltaY', deltaY);
+  await invoke$1('Editor.setDeltaY', deltaY);
 };
 const format = async () => {
-  await invoke('Editor.format');
+  await invoke$1('Editor.format');
 };
 const insertLineBreak = async () => {
-  await invoke('Editor.insertLineBreak');
+  await invoke$1('Editor.insertLineBreak');
 };
 const openSourceActions = async () => {
-  await invoke('Editor.showSourceActions2');
+  await invoke$1('Editor.showSourceActions2');
 };
 const sourceActionsSelectCurrent = async () => {
-  await invoke('EditorSourceActions.selectCurrent');
+  await invoke$1('EditorSourceActions.selectCurrent');
 };
 const openCompletionDetails = async () => {
-  await invoke('EditorCompletion.openDetails');
+  await invoke$1('EditorCompletion.openDetails');
 };
 const closeCompletionDetails = async () => {
   // @ts-ignore
-  await invoke('EditorCompletion.closeDetails');
+  await invoke$1('EditorCompletion.closeDetails');
 };
 const toggleCompletionDetails = async () => {
   // @ts-ignore
-  await invoke('EditorCompletion.toggleDetails');
+  await invoke$1('EditorCompletion.toggleDetails');
 };
 const organizeImports = async () => {
-  await invoke('Editor.organizeImports');
+  await invoke$1('Editor.organizeImports');
 };
 const addAllMissingImports = async () => {
-  await invoke('Editor.addAllMissingImports');
+  await invoke$1('Editor.addAllMissingImports');
 };
 const sortImports = async () => {
-  await invoke('Editor.sortImports');
+  await invoke$1('Editor.sortImports');
 };
 const toggleLineComment = async () => {
-  await invoke('Editor.toggleLineComment');
+  await invoke$1('Editor.toggleLineComment');
 };
 const toggleBlockComment = async () => {
-  await invoke('Editor.toggleBlockComment');
+  await invoke$1('Editor.toggleBlockComment');
 };
 const selectAll$1 = async () => {
-  await invoke('Editor.toggleBlockComment');
+  await invoke$1('Editor.toggleBlockComment');
 };
 const openColorPicker = async () => {
-  await invoke('Editor.openColorPicker');
+  await invoke$1('Editor.openColorPicker');
 };
 const openFind = async () => {
   // @ts-ignore
-  await invoke('Editor.openFind2');
+  await invoke$1('Editor.openFind2');
 };
 const deleteAllLeft = async () => {
-  await invoke('Editor.deleteAllLeft');
+  await invoke$1('Editor.deleteAllLeft');
 };
 const deleteAllRight = async () => {
-  await invoke('Editor.deleteAllRight');
+  await invoke$1('Editor.deleteAllRight');
 };
 const cursorWordPartLeft = async () => {
-  await invoke('Editor.cursorWordPartLeft');
+  await invoke$1('Editor.cursorWordPartLeft');
 };
 const cursorWordPartRight = async () => {
-  await invoke('Editor.cursorWordPartRight');
+  await invoke$1('Editor.cursorWordPartRight');
 };
 const cursorEnd = async () => {
-  await invoke('Editor.cursorEnd');
+  await invoke$1('Editor.cursorEnd');
 };
 const cursorHome = async () => {
-  await invoke('Editor.cursorHome');
+  await invoke$1('Editor.cursorHome');
 };
 const copyLineUp = async () => {
-  await invoke('Editor.copyLineUp');
+  await invoke$1('Editor.copyLineUp');
 };
 const copy = async () => {
-  await invoke('Editor.copy');
+  await invoke$1('Editor.copy');
 };
 const closeColorPicker = async () => {
-  await invoke('Editor.closeColorPicker');
+  await invoke$1('Editor.closeColorPicker');
 };
 const openContextMenu$1 = async () => {
   const button = 0;
   const x = 0;
   const y = 0;
-  await invoke('Editor.contextMenu', button, x, y);
+  await invoke$1('Editor.contextMenu', button, x, y);
 };
 const getText = async () => {
-  return invoke('Editor.getText');
+  return invoke$1('Editor.getText');
 };
 const rename$1 = async () => {
-  await invoke('Editor.rename');
+  await invoke$1('Editor.rename');
 };
 const showHover = async () => {
-  await invoke('Editor.showHover2');
+  await invoke$1('Editor.showHover2');
 };
 const openRename = async () => {
-  await invoke('Editor.openRename');
+  await invoke$1('Editor.openRename');
+};
+const growSelection = async () => {
+  // @ts-ignore
+  await invoke$1('Editor.selectionGrow');
+};
+const getSelections = async () => {
+  const keys = await invoke('Editor.getKeys');
+  const key = keys.at(-1);
+  const numeric = Number.parseInt(key);
+  // @ts-ignore
+  return invoke('Editor.getSelections', numeric);
 };
 const shouldHaveText = async expectedText => {
-  const text = await invoke('Editor.getText');
+  const text = await invoke$1('Editor.getText');
   if (text !== expectedText) {
     throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
   }
 };
+const shouldHaveSelections = async expectedSelections => {
+  const keys = await invoke('Editor.getKeys');
+  const key = keys.at(-1);
+  const numeric = Number.parseInt(key);
+  // @ts-ignore
+  const selections = await invoke('Editor.getSelections', numeric);
+  if (!areSelectionsEqual(selections, expectedSelections)) {
+    throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
+  }
+};
 
 const TestFrameWorkComponentEditor = {
   __proto__: null,
@@ -2008,9 +2106,11 @@ const TestFrameWorkComponentEditor = {
   findAllImplementations,
   findAllReferences,
   format,
+  getSelections,
   getText,
   goToDefinition,
   goToTypeDefinition,
+  growSelection,
   insertLineBreak,
   invokeBraceCompletion,
   invokeTabCompletion,
@@ -2030,6 +2130,7 @@ const TestFrameWorkComponentEditor = {
   setCursor,
   setDeltaY,
   setSelections,
+  shouldHaveSelections,
   shouldHaveText,
   showHover,
   sortImports,
@@ -2041,10 +2142,10 @@ const TestFrameWorkComponentEditor = {
 };
 
 const selectIndex$5 = async index => {
-  await invoke('EditorCompletion.selectIndex', index);
+  await invoke$1('EditorCompletion.selectIndex', index);
 };
 const selectCurrentIndex$1 = async () => {
-  await invoke('EditorCompletion.selectCurrentIndex');
+  await invoke$1('EditorCompletion.selectCurrentIndex');
 };
 
 const TestFrameWorkComponentEditorCompletion = {
@@ -2056,117 +2157,117 @@ const TestFrameWorkComponentEditorCompletion = {
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const openContextMenu = async index => {
   // @ts-ignore
-  await invoke('Explorer.handleContextMenuKeyboard', index);
+  await invoke$1('Explorer.handleContextMenuKeyboard', index);
 };
 const handleDragLeave = async () => {
-  await invoke('Explorer.handleDragLeave');
+  await invoke$1('Explorer.handleDragLeave');
 };
 const handleBlur = async () => {
-  await invoke('Explorer.handleBlur');
+  await invoke$1('Explorer.handleBlur');
 };
 const handleInputBlur = async () => {
-  await invoke('Explorer.handleInputBlur');
+  await invoke$1('Explorer.handleInputBlur');
 };
 const focus$1 = async () => {
-  await invoke('Explorer.focusIndex', -1);
+  await invoke$1('Explorer.focusIndex', -1);
 };
 const focusNext$7 = async () => {
   // @ts-ignore
-  await invoke('Explorer.focusNext');
+  await invoke$1('Explorer.focusNext');
 };
 const selectUp = async () => {
-  await invoke('Explorer.selectUp');
+  await invoke$1('Explorer.selectUp');
 };
 const handleDragOverIndex = async index => {
   // @ts-ignore
-  await invoke('Explorer.handleDragOverIndex', index);
+  await invoke$1('Explorer.handleDragOverIndex', index);
 };
 const selectDown = async () => {
-  await invoke('Explorer.selectDown');
+  await invoke$1('Explorer.selectDown');
 };
 const refresh = async () => {
-  await invoke('Explorer.refresh');
+  await invoke$1('Explorer.refresh');
 };
 const focusIndex$4 = async index => {
-  await invoke('Explorer.focusIndex', index);
+  await invoke$1('Explorer.focusIndex', index);
 };
 const clickCurrent = async () => {
-  await invoke('Explorer.handleClickCurrent');
+  await invoke$1('Explorer.handleClickCurrent');
 };
 const handleArrowLeft$1 = async () => {
-  await invoke('Explorer.handleArrowLeft');
+  await invoke$1('Explorer.handleArrowLeft');
 };
 const focusLast$5 = async () => {
-  await invoke('Explorer.focusLast');
+  await invoke$1('Explorer.focusLast');
 };
 const focusFirst$6 = async () => {
-  await invoke('Explorer.focusFirst');
+  await invoke$1('Explorer.focusFirst');
 };
 const removeDirent = async () => {
-  await invoke('Explorer.removeDirent');
+  await invoke$1('Explorer.removeDirent');
 };
 const expandRecursively = async () => {
-  await invoke('Explorer.expandRecursively');
+  await invoke$1('Explorer.expandRecursively');
 };
 const newFile = async () => {
-  await invoke('Explorer.newFile');
+  await invoke$1('Explorer.newFile');
 };
 const newFolder = async () => {
-  await invoke('Explorer.newFolder');
+  await invoke$1('Explorer.newFolder');
 };
 const handleClick$1 = async index => {
-  await invoke('Explorer.handleClick', index);
+  await invoke$1('Explorer.handleClick', index);
 };
 const handleClickAt$2 = async (preventDefault, button, ctrlKey, shiftKey, x, y) => {
   // @ts-ignore
-  await invoke('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
+  await invoke$1('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
 };
 const handleDrop = async (x, y, fileIds, fileList) => {
   // @ts-ignore
-  await invoke('Explorer.handleDrop', x, y, fileIds, fileIds);
+  await invoke$1('Explorer.handleDrop', x, y, fileIds, fileIds);
 };
 const rename = async () => {
-  await invoke('Explorer.renameDirent');
+  await invoke$1('Explorer.renameDirent');
 };
 const selectAll = async () => {
-  await invoke('Explorer.selectAll');
+  await invoke$1('Explorer.selectAll');
 };
 const renameDirent = async () => {
-  await invoke('Explorer.renameDirent');
+  await invoke$1('Explorer.renameDirent');
 };
 const cancelEdit = async () => {
-  await invoke('Explorer.cancelEdit');
+  await invoke$1('Explorer.cancelEdit');
 };
 const acceptEdit = async () => {
-  await invoke('Explorer.acceptEdit');
+  await invoke$1('Explorer.acceptEdit');
 };
 const updateEditingValue = async value => {
-  await invoke('Explorer.updateEditingValue', value);
+  await invoke$1('Explorer.updateEditingValue', value);
 };
 const expandAll = async () => {
-  await invoke('Explorer.expandAll');
+  await invoke$1('Explorer.expandAll');
 };
 const handleDragOver = async (x, y) => {
-  await invoke('Explorer.handleDragOver', x, y);
+  await invoke$1('Explorer.handleDragOver', x, y);
 };
 const handleCut = async () => {
   // @ts-ignore
-  await invoke('Explorer.handleCut');
+  await invoke$1('Explorer.handleCut');
 };
 const handleCopy = async () => {
   // @ts-ignore
-  await invoke('Explorer.handleCopy');
+  await invoke$1('Explorer.handleCopy');
 };
 const handlePaste = async () => {
   // @ts-ignore
-  await invoke('Explorer.handlePaste');
+  await invoke$1('Explorer.handlePaste');
 };
 const selectIndices = async indices => {
-  await invoke('Explorer.selectIndices', indices);
+  await invoke$1('Explorer.selectIndices', indices);
 };
 const toggleIndividualSelection = async index => {
   // @ts-ignore
-  await invoke('Explorer.toggleIndividualSelection', index);
+  await invoke$1('Explorer.toggleIndividualSelection', index);
 };
 
 const TestFrameWorkComponentExplorer = {
@@ -2211,12 +2312,12 @@ const TestFrameWorkComponentExplorer = {
 const addWebExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke('ExtensionMeta.addWebExtension', absolutePath);
+  await invoke$1('ExtensionMeta.addWebExtension', absolutePath);
 };
 const addNodeExtension = async relativePath => {
   // TODO compute absolutePath
   const absolutePath = relativePath;
-  await invoke('ExtensionMeta.addNodeExtension', absolutePath);
+  await invoke$1('ExtensionMeta.addNodeExtension', absolutePath);
 };
 
 const TestFrameWorkComponentExtension = {
@@ -2226,10 +2327,10 @@ const TestFrameWorkComponentExtension = {
 };
 
 const selectFeature = name => {
-  return invoke('ExtensionDetail.selectFeature', name);
+  return invoke$1('ExtensionDetail.selectFeature', name);
 };
 const selectTab$1 = name => {
-  return invoke('ExtensionDetail.selectTab', name);
+  return invoke$1('ExtensionDetail.selectTab', name);
 };
 const selectDetails = async () => {
   await selectTab$1('Details');
@@ -2242,11 +2343,11 @@ const selectChangelog = async () => {
 };
 const open$4 = extensionId => {
   const uri = `extension-detail://${extensionId}`;
-  return invoke('Main.openUri', uri);
+  return invoke$1('Main.openUri', uri);
 };
 const openFeature = featureName => {
   // @ts-ignore
-  return invoke('ExtensionDetail.handleFeaturesClick', featureName);
+  return invoke$1('ExtensionDetail.handleFeaturesClick', featureName);
 };
 const openThemes = async () => {
   await openFeature('Theme');
@@ -2268,7 +2369,7 @@ const openSettings = async () => {
 };
 const handleScroll$1 = async scrollTop => {
   // @ts-ignore
-  return invoke('ExtensionDetail.handleScroll', scrollTop);
+  return invoke$1('ExtensionDetail.handleScroll', scrollTop);
 };
 
 const TestFrameWorkComponentExtensionDetail = {
@@ -2305,16 +2406,16 @@ const {
 } = Character;
 
 const writeFile = async (uri, content) => {
-  await invoke('FileSystem.writeFile', uri, content);
+  await invoke$1('FileSystem.writeFile', uri, content);
 };
 const readFile = async uri => {
-  await invoke('FileSystem.readFile', uri);
+  return invoke$1('FileSystem.readFile', uri);
 };
 const mkdir = async uri => {
-  await invoke('FileSystem.mkdir', uri);
+  await invoke$1('FileSystem.mkdir', uri);
 };
 const remove = async uri => {
-  await invoke('FileSystem.remove', uri);
+  await invoke$1('FileSystem.remove', uri);
 };
 const getTmpDir = async ({
   scheme = Memfs
@@ -2324,19 +2425,19 @@ const getTmpDir = async ({
       return 'memfs:///workspace';
     default:
       // @ts-ignore
-      return invoke('PlatformPaths.getTmpDir');
+      return invoke$1('PlatformPaths.getTmpDir');
   }
 };
 const chmod = async (uri, permissions) => {
   // @ts-ignore
-  await invoke('FileSystem.chmod', uri, permissions);
+  await invoke$1('FileSystem.chmod', uri, permissions);
 };
 const createExecutable = async content => {
   const tmpDir = await getTmpDir({
     scheme: 'file'
   });
   // @ts-ignore
-  const nodePath = await invoke('PlatformPaths.getNodePath');
+  const nodePath = await invoke$1('PlatformPaths.getNodePath');
   const gitPath = `${tmpDir}/git`;
   await writeFile(gitPath, `#!${nodePath}
   ${content}`);
@@ -2345,10 +2446,10 @@ const createExecutable = async content => {
 };
 const createExecutableFrom = async uri => {
   // @ts-ignore
-  const testPath = await invoke('PlatformPaths.getTestPath');
+  const testPath = await invoke$1('PlatformPaths.getTestPath');
   const absolutePath = testPath + Slash + uri;
   // @ts-ignore
-  const content = await invoke('Ajax.getText', absolutePath);
+  const content = await invoke$1('Ajax.getText', absolutePath);
   return createExecutable(content);
 };
 
@@ -2365,10 +2466,10 @@ const TestFrameWorkComponentFileSystem = {
 };
 
 const focusNext$6 = async () => {
-  await invoke('FindWidget.focusNext');
+  await invoke$1('FindWidget.focusNext');
 };
 const setValue$2 = async value => {
-  await invoke('FindWidget.handleInput', value);
+  await invoke$1('FindWidget.handleInput', value);
 };
 
 const TestFrameWorkComponentFindWidget = {
@@ -2378,7 +2479,7 @@ const TestFrameWorkComponentFindWidget = {
 };
 
 const setIconTheme = async id => {
-  await invoke('IconTheme.setIconTheme', id);
+  await invoke$1('IconTheme.setIconTheme', id);
 };
 
 const TestFrameWorkComponentIconTheme = {
@@ -2387,19 +2488,19 @@ const TestFrameWorkComponentIconTheme = {
 };
 
 const selectIndex$4 = async index => {
-  return invoke('IframeInspector.selectIndex', index);
+  return invoke$1('IframeInspector.selectIndex', index);
 };
 const focusNext$5 = async () => {
-  return invoke('IframeInspector.focusNext');
+  return invoke$1('IframeInspector.focusNext');
 };
 const focusPrevious$5 = async () => {
-  return invoke('IframeInspector.focusPrevious');
+  return invoke$1('IframeInspector.focusPrevious');
 };
 const focusFirst$5 = async () => {
-  return invoke('IframeInspector.focusFirst');
+  return invoke$1('IframeInspector.focusFirst');
 };
 const focusLast$4 = async () => {
-  return invoke('IframeInspector.focusLast');
+  return invoke$1('IframeInspector.focusLast');
 };
 
 const TestFrameWorkComponentIframeInspector = {
@@ -2412,70 +2513,70 @@ const TestFrameWorkComponentIframeInspector = {
 };
 
 const open$3 = async () => {
-  await invoke('Main.openUri', 'app://keybindings');
+  await invoke$1('Main.openUri', 'app://keybindings');
 };
 const handleInput$3 = value => {
-  return invoke('KeyBindings.handleInput', value);
+  return invoke$1('KeyBindings.handleInput', value);
 };
 const handleClick = (x, y) => {
-  return invoke('KeyBindings.handleClick', x, y);
+  return invoke$1('KeyBindings.handleClick', x, y);
 };
 const handleWheel$1 = (deltaMode, deltaY) => {
-  return invoke('KeyBindings.handleWheel', deltaMode, deltaY);
+  return invoke$1('KeyBindings.handleWheel', deltaMode, deltaY);
 };
 const handleDoubleClick = (x, y) => {
-  return invoke('KeyBindings.handleDoubleClick', x, y);
+  return invoke$1('KeyBindings.handleDoubleClick', x, y);
 };
 const focusNext$4 = () => {
-  return invoke('KeyBindings.focusNext');
+  return invoke$1('KeyBindings.focusNext');
 };
 const focusPrevious$4 = () => {
-  return invoke('KeyBindings.focusPrevious');
+  return invoke$1('KeyBindings.focusPrevious');
 };
 const focusFirst$4 = () => {
-  return invoke('KeyBindings.focusFirst');
+  return invoke$1('KeyBindings.focusFirst');
 };
 const focusLast$3 = () => {
-  return invoke('KeyBindings.focusLast');
+  return invoke$1('KeyBindings.focusLast');
 };
 const toggleRecordingKeys = () => {
-  return invoke('KeyBindings.toggleRecordingKeys');
+  return invoke$1('KeyBindings.toggleRecordingKeys');
 };
 const startRecordingKeys = () => {
-  return invoke('KeyBindings.startRecordingKeys');
+  return invoke$1('KeyBindings.startRecordingKeys');
 };
 const clearInput = () => {
-  return invoke('KeyBindings.clearInput');
+  return invoke$1('KeyBindings.clearInput');
 };
 const sortByPrecedence = () => {
-  return invoke('KeyBindings.sortByPrecedence');
+  return invoke$1('KeyBindings.sortByPrecedence');
 };
 const stopRecordingKeys = () => {
-  return invoke('KeyBindings.stopRecordingKeys');
+  return invoke$1('KeyBindings.stopRecordingKeys');
 };
 const handleContextMenu = (button, x, y) => {
-  return invoke('KeyBindings.handleContextMenu', button, x, y);
+  return invoke$1('KeyBindings.handleContextMenu', button, x, y);
 };
 const copyCommandId = () => {
-  return invoke('KeyBindings.copyCommandId');
+  return invoke$1('KeyBindings.copyCommandId');
 };
 const copyCommandTitle = () => {
-  return invoke('KeyBindings.copyCommandTitle');
+  return invoke$1('KeyBindings.copyCommandTitle');
 };
 const addKeyBinding = () => {
-  return invoke('KeyBindings.addKeyBinding');
+  return invoke$1('KeyBindings.addKeyBinding');
 };
 const removeKeyBinding = () => {
-  return invoke('KeyBindings.removeKeyBinding');
+  return invoke$1('KeyBindings.removeKeyBinding');
 };
 const changeWhenExpression = () => {
-  return invoke('KeyBindings.changeWhenExpression');
+  return invoke$1('KeyBindings.changeWhenExpression');
 };
 const showSameKeyBindings = () => {
-  return invoke('KeyBindings.showSameKeyBindings');
+  return invoke$1('KeyBindings.showSameKeyBindings');
 };
 const resetKeyBinding = () => {
-  return invoke('KeyBindings.resetKeyBinding');
+  return invoke$1('KeyBindings.resetKeyBinding');
 };
 
 const TestFrameWorkComponentKeyBindingsEditor = {
@@ -2551,7 +2652,7 @@ const press = async key => {
     ...keyOptions
   };
   // @ts-ignore
-  await invoke('TestFrameWork.performKeyBoardAction', 'press', options);
+  await invoke$1('TestFrameWork.performKeyBoardAction', 'press', options);
 };
 
 const TestFrameWorkComponentKeyBoard = {
@@ -2560,40 +2661,40 @@ const TestFrameWorkComponentKeyBoard = {
 };
 
 const openUri = async uri => {
-  await invoke('Main.openUri', uri);
+  await invoke$1('Main.openUri', uri);
 };
 const splitRight = async () => {
-  await invoke('Main.splitRight');
+  await invoke$1('Main.splitRight');
 };
 const openKeyBindings = async () => {
-  await invoke('Main.openKeyBindings');
+  await invoke$1('Main.openKeyBindings');
 };
 const closeAllEditors = async () => {
-  await invoke('Main.closeAllEditors');
+  await invoke$1('Main.closeAllEditors');
 };
 const closeTabsLeft = async () => {
-  await invoke('Main.closeTabsLeft');
+  await invoke$1('Main.closeTabsLeft');
 };
 const closeTabsRight = async () => {
-  await invoke('Main.closeTabsRight');
+  await invoke$1('Main.closeTabsRight');
 };
 const closeOthers = async () => {
-  await invoke('Main.closeOthers');
+  await invoke$1('Main.closeOthers');
 };
 const closeActiveEditor = async () => {
-  await invoke('Main.closeActiveEditor');
+  await invoke$1('Main.closeActiveEditor');
 };
 const focusFirst$3 = async () => {
-  await invoke('Main.focusFirst');
+  await invoke$1('Main.focusFirst');
 };
 const focusNext$3 = async () => {
-  await invoke('Main.focusNext');
+  await invoke$1('Main.focusNext');
 };
 const focusPrevious$3 = async () => {
-  await invoke('Main.focusPrevious');
+  await invoke$1('Main.focusPrevious');
 };
 const focusLast$2 = async () => {
-  await invoke('Main.focusLast');
+  await invoke$1('Main.focusLast');
 };
 
 const TestFrameWorkComponentMain = {
@@ -2616,19 +2717,19 @@ const Script = 2;
 
 const show$2 = async () => {
   // @ts-ignore
-  await invoke('Panel.selectIndex', 1);
+  await invoke$1('Panel.selectIndex', 1);
 };
 const handleFilterInput$1 = async text => {
   // @ts-ignore
-  await invoke('Output.handleFilterInput', text, Script);
+  await invoke$1('Output.handleFilterInput', text, Script);
 };
 const selectChannel = async channelId => {
   // @ts-ignore
-  await invoke('Output.selectChannel', channelId);
+  await invoke$1('Output.selectChannel', channelId);
 };
 const clear$1 = async () => {
   // @ts-ignore
-  await invoke('Output.clear');
+  await invoke$1('Output.clear');
 };
 
 const TestFrameWorkComponentOutput = {
@@ -2640,7 +2741,7 @@ const TestFrameWorkComponentOutput = {
 };
 
 const open$2 = async id => {
-  await invoke('Layout.showPanel', id);
+  await invoke$1('Layout.showPanel', id);
 };
 
 const TestFrameWorkComponentPanel = {
@@ -2668,7 +2769,7 @@ const isFirefox$1 = getIsFirefox();
 
 const getNodePath$1 = () => {
   // @ts-ignore
-  return invoke(/* Platform.getNodePath */'Platform.getNodePath');
+  return invoke$1(/* Platform.getNodePath */'Platform.getNodePath');
 };
 
 const getNodePath = () => {
@@ -2686,43 +2787,43 @@ const TestFrameWorkComponentPlatform = {
 
 const show$1 = async () => {
   // @ts-ignore
-  await invoke('Panel.selectIndex', 0);
+  await invoke$1('Panel.selectIndex', 0);
 };
 const handleFilterInput = async text => {
   // @ts-ignore
-  await invoke('Problems.handleFilterInput', text);
+  await invoke$1('Problems.handleFilterInput', text);
 };
 const copyMessage = async () => {
   // @ts-ignore
-  await invoke('Problems.copyMessage');
+  await invoke$1('Problems.copyMessage');
 };
 const focusIndex$3 = async index => {
   // @ts-ignore
-  await invoke('Problems.focusIndex', index);
+  await invoke$1('Problems.focusIndex', index);
 };
 const handleArrowLeft = async () => {
   // @ts-ignore
-  await invoke('Problems.handleArrowLeft');
+  await invoke$1('Problems.handleArrowLeft');
 };
 const handleArrowRight = async () => {
   // @ts-ignore
-  await invoke('Problems.handleArrowRight');
+  await invoke$1('Problems.handleArrowRight');
 };
 const handleClickAt$1 = async (x, y) => {
   // @ts-ignore
-  await invoke('Problems.handleClickAt', x, y);
+  await invoke$1('Problems.handleClickAt', x, y);
 };
 const handleIconThemeChange = async () => {
   // @ts-ignore
-  await invoke('Problems.handleIconThemeChange');
+  await invoke$1('Problems.handleIconThemeChange');
 };
 const viewAsList = async () => {
   // @ts-ignore
-  await invoke('Problems.viewAsList');
+  await invoke$1('Problems.viewAsList');
 };
 const viewAsTable = async () => {
   // @ts-ignore
-  await invoke('Problems.viewAsTable');
+  await invoke$1('Problems.viewAsTable');
 };
 
 const TestFrameWorkComponentProblems = {
@@ -2743,59 +2844,59 @@ const QuickPick = 'QuickPick';
 
 const open$1 = async () => {
   // @ts-ignore
-  await invoke('Viewlet.openWidget', QuickPick, 'everything');
+  await invoke$1('Viewlet.openWidget', QuickPick, 'everything');
 };
 const handleInput$2 = async value => {
   // @ts-ignore
-  await invoke('QuickPick.handleInput', value, 0);
+  await invoke$1('QuickPick.handleInput', value, 0);
 };
 const handleClickAt = async (x, y) => {
   // @ts-ignore
-  await invoke('QuickPick.handleClickAt', x, y);
+  await invoke$1('QuickPick.handleClickAt', x, y);
 };
 const setValue$1 = async value => {
   // @ts-ignore
-  await invoke('QuickPick.setValue', value);
+  await invoke$1('QuickPick.setValue', value);
 };
 const focusNext$2 = async () => {
   // @ts-ignore
-  await invoke('QuickPick.focusNext');
+  await invoke$1('QuickPick.focusNext');
 };
 const focusFirst$2 = async () => {
   // @ts-ignore
-  await invoke('QuickPick.focusFirst');
+  await invoke$1('QuickPick.focusFirst');
 };
 const focusLast$1 = async () => {
   // @ts-ignore
-  await invoke('QuickPick.focusLast');
+  await invoke$1('QuickPick.focusLast');
 };
 const focusIndex$2 = async index => {
   // @ts-ignore
-  await invoke('QuickPick.focusIndex', index);
+  await invoke$1('QuickPick.focusIndex', index);
 };
 const focusPrevious$2 = async () => {
   // @ts-ignore
-  await invoke('QuickPick.focusPrevious');
+  await invoke$1('QuickPick.focusPrevious');
 };
 const selectItem = async label => {
   // @ts-ignore
-  await invoke('QuickPick.selectItem', label);
+  await invoke$1('QuickPick.selectItem', label);
 };
 const selectIndex$3 = async index => {
   // @ts-ignore
-  await invoke('QuickPick.selectIndex', index);
+  await invoke$1('QuickPick.selectIndex', index);
 };
 const selectCurrentIndex = async () => {
   // @ts-ignore
-  await invoke('QuickPick.selectCurrentIndex');
+  await invoke$1('QuickPick.selectCurrentIndex');
 };
 const executeCommand = async label => {
   // @ts-ignore
-  await invoke('QuickPick.showCommands');
+  await invoke$1('QuickPick.showCommands');
   // @ts-ignore
-  await invoke('QuickPick.handleInput', label, 0);
+  await invoke$1('QuickPick.handleInput', label, 0);
   // @ts-ignore
-  await invoke('QuickPick.selectItem', label);
+  await invoke$1('QuickPick.selectItem', label);
 };
 
 const TestFrameWorkComponentQuickPick = {
@@ -2817,35 +2918,35 @@ const TestFrameWorkComponentQuickPick = {
 
 const handleClickSectionWatch = async () => {
   // @ts-ignore
-  await invoke('Run And Debug.handleClickSectionWatch');
+  await invoke$1('Run And Debug.handleClickSectionWatch');
 };
 const addWatchExpression = async expression => {
   // @ts-ignore
-  await invoke('Run And Debug.addWatchExpression', expression);
+  await invoke$1('Run And Debug.addWatchExpression', expression);
 };
 const handleWatchValueChange = async () => {
   // @ts-ignore
-  await invoke('Run And Debug.handleWatchValueChange');
+  await invoke$1('Run And Debug.handleWatchValueChange');
 };
 const acceptWatchExpressionEdit = async () => {
   // @ts-ignore
-  await invoke('Run And Debug.acceptWatchExpressionEdit');
+  await invoke$1('Run And Debug.acceptWatchExpressionEdit');
 };
 const selectIndex$2 = async index => {
   // @ts-ignore
-  await invoke('Run And Debug.selectIndex', index);
+  await invoke$1('Run And Debug.selectIndex', index);
 };
 const setPauseOnExceptions = async value => {
   // @ts-ignore
-  await invoke('Run And Debug.setPauseOnExceptions', value);
+  await invoke$1('Run And Debug.setPauseOnExceptions', value);
 };
 const handleRename = async () => {
   // @ts-ignore
-  await invoke('Run And Debug.handleRename');
+  await invoke$1('Run And Debug.handleRename');
 };
 const handleSpace = async () => {
   // @ts-ignore
-  await invoke('Run And Debug.handleSpace');
+  await invoke$1('Run And Debug.handleSpace');
 };
 
 const TestFrameWorkComponentRunAndDebug = {
@@ -2862,77 +2963,77 @@ const TestFrameWorkComponentRunAndDebug = {
 
 const setValue = async value => {
   // @ts-ignore
-  await invoke('Search.handleInput', value, Script);
+  await invoke$1('Search.handleInput', value, Script);
 };
 const setReplaceValue = async value => {
   // @ts-ignore
-  await invoke('Search.handleReplaceInput', value, Script);
+  await invoke$1('Search.handleReplaceInput', value, Script);
 };
 const setExcludeValue = async value => {
   // @ts-ignore
-  await invoke('Search.handleExcludeInput', value, Script);
+  await invoke$1('Search.handleExcludeInput', value, Script);
 };
 const replaceAll = async () => {
-  await invoke('Search.replaceAll');
+  await invoke$1('Search.replaceAll');
 };
 const setIncludeValue = async value => {
   // @ts-ignore
-  await invoke('Search.handleIncludeInput', value, Script);
+  await invoke$1('Search.handleIncludeInput', value, Script);
 };
 const clearSearchResults = async () => {
-  await invoke('Search.clearSearchResults');
+  await invoke$1('Search.clearSearchResults');
 };
 const openDetails = async () => {
-  await invoke('Search.openDetails');
+  await invoke$1('Search.openDetails');
 };
 const collapseDetails = async () => {
-  await invoke('Search.collapseDetails');
+  await invoke$1('Search.collapseDetails');
 };
 const dismissItem = async () => {
-  await invoke('Search.dismissItem');
+  await invoke$1('Search.dismissItem');
 };
 const focusFirst$1 = async () => {
-  await invoke('Search.focusFirst');
+  await invoke$1('Search.focusFirst');
 };
 const focusIndex$1 = async index => {
-  await invoke('Search.focusIndex', index);
+  await invoke$1('Search.focusIndex', index);
 };
 const selectIndex$1 = async index => {
-  await invoke('Search.selectIndex', index);
+  await invoke$1('Search.selectIndex', index);
 };
 const focusNext$1 = async () => {
-  await invoke('Search.focusNext');
+  await invoke$1('Search.focusNext');
 };
 const handleWheel = async (deltaMode, deltaY) => {
-  await invoke('Search.handleWheel', deltaMode, deltaY);
+  await invoke$1('Search.handleWheel', deltaMode, deltaY);
 };
 const focusNextPage = async () => {
   // @ts-ignore
-  await invoke('Search.focusPage');
+  await invoke$1('Search.focusPage');
 };
 const focusPreviousPage = async () => {
-  await invoke('Search.focusPreviousPage');
+  await invoke$1('Search.focusPreviousPage');
 };
 const focusPrevious$1 = async () => {
-  await invoke('Search.focusPrevious');
+  await invoke$1('Search.focusPrevious');
 };
 const toggleSearchDetails = async () => {
-  await invoke('Search.toggleSearchDetails');
+  await invoke$1('Search.toggleSearchDetails');
 };
 const toggleMatchCase = async () => {
-  await invoke('Search.toggleMatchCase');
+  await invoke$1('Search.toggleMatchCase');
 };
 const toggleMatchWholeWord = async () => {
-  await invoke('Search.toggleMatchWholeWord');
+  await invoke$1('Search.toggleMatchWholeWord');
 };
 const togglePreserveCase = async () => {
-  await invoke('Search.togglePreserveCase');
+  await invoke$1('Search.togglePreserveCase');
 };
 const toggleUseRegularExpression = async () => {
-  await invoke('Search.toggleUseRegularExpression');
+  await invoke$1('Search.toggleUseRegularExpression');
 };
 const toggleReplace = async () => {
-  await invoke('Search.toggleReplace');
+  await invoke$1('Search.toggleReplace');
 };
 
 const TestFrameWorkComponentSearch = {
@@ -2964,7 +3065,7 @@ const TestFrameWorkComponentSearch = {
 
 const update$1 = settings => {
   // @ts-ignore
-  return invoke('Preferences.update', settings);
+  return invoke$1('Preferences.update', settings);
 };
 
 const TestFrameWorkComponentSettings = {
@@ -2973,27 +3074,27 @@ const TestFrameWorkComponentSettings = {
 };
 
 const show = async () => {
-  return invoke('Main.openUri', 'settings://');
+  return invoke$1('Main.openUri', 'settings://');
 };
 const handleInput$1 = async searchValue => {
   // @ts-ignore
-  return invoke('Settings.handleInput', searchValue, Script);
+  return invoke$1('Settings.handleInput', searchValue, Script);
 };
 const usePreviousSearchValue = async () => {
   // @ts-ignore
-  return invoke('Settings.usePreviousSearchValue');
+  return invoke$1('Settings.usePreviousSearchValue');
 };
 const useNextSearchValue = async () => {
   // @ts-ignore
-  return invoke('Settings.useNextSearchValue');
+  return invoke$1('Settings.useNextSearchValue');
 };
 const clear = async searchValue => {
   // @ts-ignore
-  return invoke('Settings.clear', searchValue, Script);
+  return invoke$1('Settings.clear', searchValue, Script);
 };
 const selectTab = async tabId => {
   // @ts-ignore
-  return invoke('Settings.handleClickTab', tabId);
+  return invoke$1('Settings.handleClickTab', tabId);
 };
 const selectWorkspace = async () => {
   await selectTab('workspace');
@@ -3006,7 +3107,7 @@ const selectExtensions = async () => {
 };
 const handleScroll = async scrollTop => {
   // @ts-ignore
-  await invoke('Settings.handleScroll', scrollTop, Script);
+  await invoke$1('Settings.handleScroll', scrollTop, Script);
 };
 
 const TestFrameWorkComponentSettingsView = {
@@ -3024,10 +3125,10 @@ const TestFrameWorkComponentSettingsView = {
 };
 
 const open = async id => {
-  await invoke('SideBar.openViewlet', id);
+  await invoke$1('SideBar.openViewlet', id);
 };
 const hide = async () => {
-  await invoke('Layout.hideSideBar');
+  await invoke$1('Layout.hideSideBar');
 };
 
 const TestFrameWorkComponentSideBar = {
@@ -3038,16 +3139,16 @@ const TestFrameWorkComponentSideBar = {
 
 const selectIndex = async index => {
   // @ts-ignore
-  await invoke('Source Control.selectIndex');
+  await invoke$1('Source Control.selectIndex');
 };
 const acceptInput = async () => {
-  await invoke('Source Control.acceptInput');
+  await invoke$1('Source Control.acceptInput');
 };
 const handleInput = async text => {
-  await invoke('Source Control.handleInput', text);
+  await invoke$1('Source Control.handleInput', text);
 };
 const handleClickSourceControlButtons = async (index, name) => {
-  await invoke('Source Control.handleClickSourceControlButtons', index, name);
+  await invoke$1('Source Control.handleClickSourceControlButtons', index, name);
 };
 
 const TestFrameWorkComponentSourceControl = {
@@ -3059,7 +3160,7 @@ const TestFrameWorkComponentSourceControl = {
 };
 
 const update = async () => {
-  await invoke('StatusBar.updateStatusBarItems');
+  await invoke$1('StatusBar.updateStatusBarItems');
 };
 
 const TestFrameWorkComponentStatusBar = {
@@ -3068,56 +3169,56 @@ const TestFrameWorkComponentStatusBar = {
 };
 
 const closeMenu = async () => {
-  await invoke('TitleBarMenuBar.closeMenu');
+  await invoke$1('TitleBarMenuBar.closeMenu');
 };
 const focus = async () => {
-  await invoke('TitleBarMenuBar.focus');
+  await invoke$1('TitleBarMenuBar.focus');
 };
 const focusFirst = async () => {
-  await invoke('TitleBarMenuBar.focusFirst');
+  await invoke$1('TitleBarMenuBar.focusFirst');
 };
 const focusIndex = async index => {
   // @ts-ignore
-  await invoke('TitleBarMenuBar.focusIndex', index);
+  await invoke$1('TitleBarMenuBar.focusIndex', index);
 };
 const focusLast = async () => {
-  await invoke('TitleBarMenuBar.focusLast');
+  await invoke$1('TitleBarMenuBar.focusLast');
 };
 const focusNext = async () => {
-  await invoke('TitleBarMenuBar.focusNext');
+  await invoke$1('TitleBarMenuBar.focusNext');
 };
 const focusPrevious = async () => {
-  await invoke('TitleBarMenuBar.focusPrevious');
+  await invoke$1('TitleBarMenuBar.focusPrevious');
 };
 const handleKeyArrowDown = async () => {
-  await invoke('TitleBarMenuBar.handleKeyArrowDown');
+  await invoke$1('TitleBarMenuBar.handleKeyArrowDown');
 };
 const handleKeyArrowLeft = async () => {
-  await invoke('TitleBarMenuBar.handleKeyArrowLeft');
+  await invoke$1('TitleBarMenuBar.handleKeyArrowLeft');
 };
 const handleKeyArrowRight = async () => {
-  await invoke('TitleBarMenuBar.handleKeyArrowRight');
+  await invoke$1('TitleBarMenuBar.handleKeyArrowRight');
 };
 const handleKeyArrowUp = async () => {
-  await invoke('TitleBarMenuBar.handleKeyArrowUp');
+  await invoke$1('TitleBarMenuBar.handleKeyArrowUp');
 };
 const handleKeyEnd = async () => {
-  await invoke('TitleBarMenuBar.handleKeyEnd');
+  await invoke$1('TitleBarMenuBar.handleKeyEnd');
 };
 const handleKeyHome = async () => {
-  await invoke('TitleBarMenuBar.handleKeyHome');
+  await invoke$1('TitleBarMenuBar.handleKeyHome');
 };
 const handleKeySpace = async () => {
-  await invoke('TitleBarMenuBar.handleKeySpace');
+  await invoke$1('TitleBarMenuBar.handleKeySpace');
 };
 const handleKeyEscape = async () => {
-  await invoke('TitleBarMenuBar.handleKeyEscape');
+  await invoke$1('TitleBarMenuBar.handleKeyEscape');
 };
 const toggleIndex = async index => {
-  await invoke('TitleBarMenuBar.toggleIndex', index);
+  await invoke$1('TitleBarMenuBar.toggleIndex', index);
 };
 const toggleMenu = async () => {
-  await invoke('TitleBarMenuBar.toggleMenu');
+  await invoke$1('TitleBarMenuBar.toggleMenu');
 };
 
 const TestFrameWorkComponentTitleBarMenuBar = {
@@ -3167,7 +3268,7 @@ const getPortTuple = () => {
 };
 
 const getWebViewInfo = async webViewId => {
-  const info = await invoke('WebView.getWebViewInfo2', webViewId);
+  const info = await invoke$1('WebView.getWebViewInfo2', webViewId);
   return info;
 };
 
@@ -3227,7 +3328,7 @@ const TestFrameWorkComponentWebView = {
 };
 
 const setPath = async path => {
-  await invoke('Workspace.setPath', path);
+  await invoke$1('Workspace.setPath', path);
 };
 const openTmpDir = async () => {
   const tmpDir = await getTmpDir();