@lvce-editor/extension-host-worker 8.2.0 → 8.4.0

package/dist/extensionHostWorkerMain.js

@@ -579,7 +579,7 @@ const registerMethod = ({
     }
   };
 };
-const create$a = ({
+const create$c = ({
   additionalMethodNames = [],
   executeKey = '',
   name,
@@ -632,7 +632,7 @@ const String$1 = 'string';
 
 const {
   executeBraceCompletionProvider,
-  registerBraceCompletionProvider} = create$a({
+  registerBraceCompletionProvider} = create$c({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean$1
@@ -642,7 +642,7 @@ const {
 const {
   executeClosingTagProvider,
   registerClosingTagProvider
-} = create$a({
+} = create$c({
   name: 'ClosingTag',
   resultShape: {
     allowUndefined: true,
@@ -654,7 +654,7 @@ const {
 const {
   executeCodeActionProvider,
   registerCodeActionProvider
-} = create$a({
+} = create$c({
   name: 'CodeAction',
   resultShape: {
     items: {
@@ -736,7 +736,7 @@ const executeCommand$1 = async (id, ...args) => {
 const {
   executeCommentProvider,
   registerCommentProvider
-} = create$a({
+} = create$c({
   name: 'Comment',
   resultShape() {
     return '';
@@ -747,7 +747,7 @@ const {
   executeCompletionProvider,
   executeresolveCompletionItemProvider,
   registerCompletionProvider
-} = create$a({
+} = create$c({
   additionalMethodNames: [
   // @ts-ignore
   {
@@ -782,17 +782,14 @@ const ExtensionManagementWorker = 9006;
 const RendererWorker$1 = 1;
 
 const rpcs$2 = Object.create(null);
-const set$c = (id, rpc) => {
-  if (rpcs$2[id]) {
-    throw new Error(`rpc with id ${id} is already registered`);
-  }
+const set$d = (id, rpc) => {
   rpcs$2[id] = rpc;
 };
 const get$b = id => {
   return rpcs$2[id];
 };
 
-const create$9 = rpcId => {
+const create$b = rpcId => {
   return {
     async dispose() {
       const rpc = get$b(rpcId);
@@ -811,24 +808,24 @@ const create$9 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$c(rpcId, rpc);
+      set$d(rpcId, rpc);
     }
   };
 };
 
 const {
   dispose,
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$5,
-  set: set$b
-} = create$9(DebugWorker$1);
+  invoke: invoke$6,
+  invokeAndTransfer: invokeAndTransfer$4,
+  set: set$c
+} = create$b(DebugWorker$1);
 
 const DebugWorker = {
   __proto__: null,
   dispose,
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$5,
-  set: set$b
+  invoke: invoke$6,
+  invokeAndTransfer: invokeAndTransfer$4,
+  set: set$c
 };
 
 const isMessagePort = value => {
@@ -959,8 +956,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -983,14 +980,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -1009,8 +1006,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -1020,8 +1017,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -1121,8 +1118,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -1142,8 +1139,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -1203,8 +1200,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -1216,8 +1213,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -1227,8 +1224,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
 };
 const Message$1 = 3;
 const create$5$2 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -1241,8 +1238,8 @@ const create$5$2 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -1296,12 +1293,12 @@ const parse$1 = content => {
 };
 const waitForWebSocketToBeOpen = webSocket => {
   return getFirstEvent(webSocket, {
-    open: Open,
     close: Close,
-    error: Error$3
+    error: Error$3,
+    open: Open
   });
 };
-const create$8 = async ({
+const create$a = async ({
   webSocket
 }) => {
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
@@ -1338,60 +1335,18 @@ const wrap$1 = webSocket => {
 };
 const IpcParentWithWebSocket$1$1 = {
   __proto__: null,
-  create: create$8,
+  create: create$a,
   wrap: wrap$1
 };
 
-const Two = '2.0';
-const create$4$2 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$a = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$a = id => {
   return callbacks[id];
 };
 const remove$4 = id => {
   delete callbacks[id];
 };
-let id$1 = 0;
-const create$3$2 = () => {
-  return ++id$1;
-};
-const registerPromise = () => {
-  const id = create$3$2();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$a(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -1587,7 +1542,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -1598,20 +1553,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$7 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -1698,29 +1653,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$2(method, params);
-  transport.send(message);
-};
-const invoke$6 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$4 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -1743,24 +1675,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$p = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$o = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id$2 = 0;
+const create$n = () => {
+  return ++id$2;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$n();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$o(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc$1 = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send$1(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$6(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$4(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$p(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -1777,7 +1772,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -1795,7 +1790,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$f = async ({
+const create$h = async ({
   commandMap,
   messagePort
 }) => {
@@ -1810,18 +1805,18 @@ const create$f = async ({
 };
 const MessagePortRpcClient = {
   __proto__: null,
-  create: create$f
+  create: create$h
 };
-const create$e = async ({
+const create$g = async ({
   commandMap,
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register$1(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -1830,17 +1825,18 @@ const create$e = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$e
+  create: create$g
 };
-const create$5$1 = async ({
+const create$7 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register$1(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -1848,21 +1844,22 @@ const create$5$1 = async ({
   messagePort.start();
   return rpc;
 };
-const create$4$1 = async ({
+const create$6$1 = async ({
   commandMap,
   messagePort
 }) => {
-  return create$5$1({
+  return create$7({
     commandMap,
     messagePort
   });
 };
 const PlainMessagePortRpcParent = {
   __proto__: null,
-  create: create$4$1
+  create: create$6$1
 };
-const create$3$1 = async ({
+const create$5$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -1870,16 +1867,17 @@ const create$3$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5$1({
+  return create$7({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3$1
+  create: create$5$1
 };
-const create$2$1 = async ({
+const create$4$1 = async ({
   commandMap,
   webSocket
 }) => {
@@ -1895,9 +1893,9 @@ const create$2$1 = async ({
 };
 const WebSocketRpcParent = {
   __proto__: null,
-  create: create$2$1
+  create: create$4$1
 };
-const create$6 = async ({
+const create$2$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1909,56 +1907,80 @@ const create$6 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$6
+  create: create$2$1
 };
 
-const {
-  invoke: invoke$5} = create$9(ExtensionManagementWorker);
-
-const {
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$3} = create$9(RendererWorker$1);
-const sendMessagePortToIframeWorker = async (port, rpcId) => {
-  const command = 'Iframes.handleMessagePort';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
-};
-const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
-  const command = 'Extensions.handleMessagePort';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
-};
+/* eslint-disable @typescript-eslint/no-misused-promises */
 
-const createLazyRpc = rpcId => {
+const create$8 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
   let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$c(rpcId, rpc);
-  };
-  const ensureRpc = async () => {
+  const getOrCreate = () => {
     if (!rpcPromise) {
-      rpcPromise = createRpc();
+      rpcPromise = create$5$1({
+        commandMap,
+        isMessagePortOpen,
+        send
+      });
     }
-    await rpcPromise;
+    return rpcPromise;
   };
   return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
     async invoke(method, ...params) {
-      await ensureRpc();
-      const rpc = get$b(rpcId);
+      const rpc = await getOrCreate();
       return rpc.invoke(method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
-      await ensureRpc();
-      const rpc = get$b(rpcId);
+      const rpc = await getOrCreate();
       return rpc.invokeAndTransfer(method, ...params);
     },
-    setFactory(value) {
-      factory = value;
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
     }
   };
 };
+const LazyTransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$8
+};
+
+const {
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$b
+} = create$b(ExtensionManagementWorker);
+
+const {
+  invoke: invoke$4,
+  set: set$a
+} = create$b(7013);
+
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2} = create$b(RendererWorker$1);
+const sendMessagePortToFileSearchWorker = async (port, rpcId = 0) => {
+  const command = 'QuickPick.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker', port, command, rpcId);
+};
+const sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = 'Iframes.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
+};
 
 const {
-  invoke: invoke$3
+  invoke: invoke$2
 } = DebugWorker;
 
 const state$8 = {
@@ -1980,20 +2002,20 @@ const registerDebugProvider = debugProvider => {
 };
 const handlePaused = async params => {
   // @ts-ignore
-  await invoke$3('Debug.paused', params);
+  await invoke$2('Debug.paused', params);
 };
 const handleResumed = async () => {
   // @ts-ignore
-  await invoke$3('Debug.resumed');
+  await invoke$2('Debug.resumed');
 };
 const handleScriptParsed = async parsedScript => {
   // @ts-ignore
-  await invoke$3('Debug.scriptParsed', parsedScript);
+  await invoke$2('Debug.scriptParsed', parsedScript);
 };
 const handleChange = async params => {
   object(params);
   // @ts-ignore
-  await invoke$3('Debug.handleChange', params);
+  await invoke$2('Debug.handleChange', params);
 };
 const start = async (protocol, path) => {
   try {
@@ -2145,7 +2167,7 @@ const setPauseOnExceptions = async (protocol, value) => {
 
 const {
   executeDefinitionProvider,
-  registerDefinitionProvider} = create$a({
+  registerDefinitionProvider} = create$c({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -2167,7 +2189,7 @@ const {
 const {
   executeDiagnosticProvider,
   registerDiagnosticProvider
-} = create$a({
+} = create$c({
   name: 'Diagnostic',
   resultShape: {
     items: {
@@ -2179,18 +2201,18 @@ const {
 
 const RendererWorker = 1;
 
-const invoke$2 = (method, ...params) => {
+const invoke$1 = (method, ...params) => {
   const rpc = get$b(RendererWorker);
   return rpc.invoke(method, ...params);
 };
-const invokeAndTransfer$2 = (method, ...params) => {
+const invokeAndTransfer$1 = (method, ...params) => {
   const rpc = get$b(RendererWorker);
   return rpc.invokeAndTransfer(method, ...params);
 };
 
 const showInformationMessage = message => {
   string(message);
-  const result = invoke$2('ExtensionHostDialog.showInformationMessage', message);
+  const result = invoke$1('ExtensionHostDialog.showInformationMessage', message);
   return result;
 };
 
@@ -2253,24 +2275,24 @@ const readFileExternal = async path => {
   // this avoid parsing the potentially large message
   // and improve performance by not blocking the renderer worker
   // when reading / writing large files
-  const content = await invoke$2('FileSystem.readFile', path);
+  const content = await invoke$1('FileSystem.readFile', path);
   return content;
 };
 const removeExternal = async path => {
-  const content = await invoke$2('FileSystem.remove', path);
+  const content = await invoke$1('FileSystem.remove', path);
   return content;
 };
 const existsExternal = async uri => {
-  return await invoke$2('FileSystem.exists', uri);
+  return await invoke$1('FileSystem.exists', uri);
 };
 const mkdirExternal = async uri => {
-  return await invoke$2('FileSystem.mkdir', uri);
+  return await invoke$1('FileSystem.mkdir', uri);
 };
 const writeFileExternal = async (uri, content) => {
-  return await invoke$2('FileSystem.writeFile', uri, content);
+  return await invoke$1('FileSystem.writeFile', uri, content);
 };
 const statExternal = async uri => {
-  return await invoke$2('FileSystem.stat', uri);
+  return await invoke$1('FileSystem.stat', uri);
 };
 const readDirWithFileTypesExternal = async path => {
   // TODO when file is local,
@@ -2279,7 +2301,7 @@ const readDirWithFileTypesExternal = async path => {
   // this avoid parsing the potentially large message
   // and improve performance by not blocking the renderer worker
   // when reading / writing large files
-  const content = await invoke$2('FileSystem.readDirWithFileTypes', path);
+  const content = await invoke$1('FileSystem.readDirWithFileTypes', path);
   return content;
 };
 const remove$3 = async (protocol, path) => {
@@ -2317,7 +2339,7 @@ const getPathSeparator = protocol => {
 
 const {
   executeFormattingProvider,
-  registerFormattingProvider} = create$a({
+  registerFormattingProvider} = create$c({
   executeKey: 'format',
   name: 'Formatting',
   resultShape: {
@@ -2379,7 +2401,7 @@ const getPosition = (textDocument, offset) => {
 
 const {
   executeHoverProvider,
-  registerHoverProvider} = create$a({
+  registerHoverProvider} = create$c({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -2390,7 +2412,7 @@ const {
 
 const {
   executeImplementationProvider,
-  registerImplementationProvider} = create$a({
+  registerImplementationProvider} = create$c({
   name: 'Implementation',
   resultShape: {
     items: {
@@ -2422,7 +2444,7 @@ const sendPort = async ({
   port,
   url
 }) => {
-  await invokeAndTransfer$2('IpcParent.create', {
+  await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
     port,
@@ -2430,7 +2452,7 @@ const sendPort = async ({
     url
   });
 };
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   name,
   url
@@ -2459,11 +2481,11 @@ const create$5 = async ({
 
 const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   __proto__: null,
-  create: create$5
+  create: create$6
 };
 
 const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer$2('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
 
 const getPort = async type => {
@@ -2474,7 +2496,7 @@ const getPort = async type => {
   await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
   return port2;
 };
-const create$4 = async ({
+const create$5 = async ({
   type
 }) => {
   const port = await getPort();
@@ -2490,7 +2512,7 @@ const create$4 = async ({
 
 const IpcParentWithElectronMessagePort = {
   __proto__: null,
-  create: create$4
+  create: create$5
 };
 
 const getWebSocketProtocol = () => {
@@ -2502,7 +2524,7 @@ const getWebSocketUrl = (type, host) => {
   return `${wsProtocol}//${host}/websocket/${type}`;
 };
 
-const create$3 = async ({
+const create$4 = async ({
   type
 }) => {
   string(type);
@@ -2517,7 +2539,7 @@ const create$3 = async ({
 
 const IpcParentWithWebSocket = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 
 const Electron = 'electron';
@@ -2554,7 +2576,7 @@ const getModule$1 = platform => {
       return IpcParentWithElectronMessagePort;
   }
 };
-const create$2 = async ({
+const create$3 = async ({
   raw,
   type
 }) => {
@@ -2567,7 +2589,7 @@ const create$2 = async ({
 
 const IpcParentWithNode = {
   __proto__: null,
-  create: create$2
+  create: create$3
 };
 
 const getModule = method => {
@@ -2583,7 +2605,7 @@ const getModule = method => {
   }
 };
 
-const create$1 = async ({
+const create$2 = async ({
   method,
   ...options
 }) => {
@@ -2608,7 +2630,7 @@ const createNodeRpc = async ({
   try {
     string(path);
     fn(execute);
-    const rpc = await create$1({
+    const rpc = await create$2({
       commandMap: {},
       method: ElectronMessagePort,
       name,
@@ -2623,7 +2645,7 @@ const createNodeRpc = async ({
 
 const send = async port => {
   const initialCommand = 'FileSystem.handleMessagePort';
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, initialCommand);
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, initialCommand);
 };
 const launchFileSystemProcess = async () => {
   const rpc = await TransferMessagePortRpcParent.create({
@@ -2704,10 +2726,15 @@ const getEnabledProviders = () => {
 
 const confirm = message => {
   string(message);
-  const result = invoke$2('ConfirmPrompt.prompt', message);
+  const result = invoke$1('ConfirmPrompt.prompt', message);
   return result;
 };
 
+let id$1 = 0;
+const create$1 = () => {
+  return ++id$1;
+};
+
 const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
 
 const showQuickPick = async ({
@@ -2716,14 +2743,37 @@ const showQuickPick = async ({
 }) => {
   const rawPicks = await getPicks();
   const picks = rawPicks.map(toPick);
-  return invoke$2(ExtensionHostQuickPickShow, picks);
+  return invoke$1(ExtensionHostQuickPickShow, picks);
+};
+const quickInputs = Object.create(null);
+const showQuickInput = async ({
+  ignoreFocusOut,
+  initialValue,
+  render
+}) => {
+  const id = create$1();
+  quickInputs[id] = render;
+  // TODO create direct connection to file search worker
+  const {
+    canceled,
+    inputValue
+  } = await invoke$4('QuickPick.showQuickInput', {
+    ignoreFocusOut,
+    initialValue,
+    render
+  });
+  delete quickInputs[id];
+  return {
+    canceled,
+    inputValue
+  };
 };
 
 const {
   executefileReferenceProvider,
   executeReferenceProvider,
   getProvider: getProvider$1,
-  registerReferenceProvider} = create$a({
+  registerReferenceProvider} = create$c({
   additionalMethodNames: [
   // @ts-ignore
   {
@@ -2785,7 +2835,7 @@ const validateResult = renameResult => {
 const {
   executeprepareRenameProvider,
   executeRenameProvider,
-  registerRenameProvider} = create$a({
+  registerRenameProvider} = create$c({
   additionalMethodNames: [
   // @ts-ignore
   {
@@ -2807,7 +2857,7 @@ const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
 const set$8 = async (url, contentSecurityPolicy) => {
   const pathName = new URL(url).pathname;
-  await invoke$2('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
 
 /**
@@ -2827,7 +2877,7 @@ const createLegacyRpc = async ({
   if (contentSecurityPolicy) {
     await set$8(url, contentSecurityPolicy);
   }
-  const rpc = await create$1({
+  const rpc = await create$2({
     commandMap,
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     name,
@@ -2867,7 +2917,7 @@ const createRpcWithId$1 = async (id, commandMap, execute) => {
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
-  const rpc = await create$1({
+  const rpc = await create$2({
     commandMap,
     isMessagePortOpen: true,
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
@@ -2942,7 +2992,7 @@ const createRpc = ({
 
 const {
   executeSelectionProvider,
-  registerSelectionProvider} = create$a({
+  registerSelectionProvider} = create$c({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -2962,16 +3012,8 @@ const getProtocol = uri => {
   return '';
 };
 
-// @ts-ignore
-
-const {
-  invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
-  setFactory
-} = createLazyRpc(ExtensionManagementWorker);
-
 const getRemoteUrlForWebView = async (uri, options = {}) => {
-  return await invoke$1('Extensions.getRemoteUrlForWebView', uri, options);
+  return await invoke$5('Extensions.getRemoteUrlForWebView', uri, options);
 };
 
 const isFileProtocol = protocol => {
@@ -3008,7 +3050,7 @@ const getRemoteUrl$1 = async (uri, options = {}) => {
     return getRemoteUrlForWebView(uri, options);
   }
   if (uri.startsWith('html://')) {
-    const url = await invoke$2('Blob.getSrc', uri);
+    const url = await invoke$1('Blob.getSrc', uri);
     return url;
   }
   throw new Error(`unsupported platform for remote url`);
@@ -3047,10 +3089,10 @@ const getWebExtensions = async () => {
 };
 
 const getSharedProcessExtensions = () => {
-  return invoke$2(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+  return invoke$1(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
 };
 const doGetExtensions = async () => {
-  const meta = await invoke$1('Extensions.getDynamicWebExtensions');
+  const meta = await invoke$5('Extensions.getDynamicWebExtensions');
   if (platform === Web) {
     const webExtensions = await getWebExtensions();
     return [...webExtensions, ...meta];
@@ -3212,7 +3254,7 @@ const getFileDecorations = async (providerId, uris) => {
 
 const {
   executeTabCompletionProvider,
-  registerTabCompletionProvider} = create$a({
+  registerTabCompletionProvider} = create$c({
   name: 'TabCompletion',
   resultShape: {
     allowUndefined: true,
@@ -3251,7 +3293,7 @@ const executeTextSearchProvider = async (scheme, query) => {
 
 const {
   executeTypeDefinitionProvider,
-  registerTypeDefinitionProvider} = create$a({
+  registerTypeDefinitionProvider} = create$c({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
@@ -3355,7 +3397,7 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const rpc = create$1({
+  const rpc = create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     name,
     url
@@ -3374,7 +3416,7 @@ const getWorkspaceFolder = path => {
 };
 const handleWorkspaceRefresh = async () => {
   // @ts-ignore
-  await invoke$4('Layout.handleWorkspaceRefresh');
+  await invoke$3('Layout.handleWorkspaceRefresh');
 };
 
 class FormattingError extends Error {
@@ -3495,6 +3537,7 @@ const api = {
   // Dialog
   showInformationMessage: showInformationMessage,
   // QuickPick
+  showQuickInput: showQuickInput,
   showQuickPick: showQuickPick,
   stat: statExternal,
   TextSearchResultType,
@@ -3587,6 +3630,30 @@ const setup = ({
   global.vscode = api;
 };
 
+const launchExtensionManagementWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent.create({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToExtensionManagementWorker(port, 0);
+    }
+  });
+  set$b(rpc);
+};
+
+const launchFileSearchWorker = async () => {
+  try {
+    const rpc = await LazyTransferMessagePortRpcParent.create({
+      commandMap: {},
+      async send(port) {
+        await sendMessagePortToFileSearchWorker(port, 0);
+      }
+    });
+    set$a(rpc);
+  } catch {
+    // ignore
+  }
+};
+
 const create = () => {
   return {
     finished: false
@@ -4148,7 +4215,7 @@ const activateExtension = async (extension, absolutePath, activationEvent) => {
 };
 
 const addWebExtension = async path => {
-  const manifest = await invoke$1('Extensions.addWebExtension', path);
+  const manifest = await invoke$5('Extensions.addWebExtension', path);
   return manifest;
 };
 
@@ -4163,7 +4230,7 @@ const applyBulkReplacement = async (files, ranges, replacement) => {
 };
 
 const addCssStyleSheet = (id, css) => {
-  return invoke$2('Css.addCssStyleSheet', id, css);
+  return invoke$1('Css.addCssStyleSheet', id, css);
 };
 
 const NewLine = '\n';
@@ -4598,10 +4665,10 @@ const GetColorThemeCssCachedIndexedDb = {
 };
 
 const getText$1 = key => {
-  return invoke$2('LocalStorage.getText', key);
+  return invoke$1('LocalStorage.getText', key);
 };
 const setText = (key, value) => {
-  return invoke$2('LocalStorage.setText', key, value);
+  return invoke$1('LocalStorage.setText', key, value);
 };
 
 const getCacheKey = colorThemeId => {
@@ -4636,7 +4703,7 @@ const GetColorThemeCssCachedNoop = {
 };
 
 const get = key => {
-  return invoke$2('Preferences.get', key);
+  return invoke$1('Preferences.get', key);
 };
 
 const getCacheFn = config => {
@@ -4662,7 +4729,7 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
 };
 
 const readJson = url => {
-  return invoke$2('FileSystem.readJson', url);
+  return invoke$1('FileSystem.readJson', url);
 };
 
 const dirname = (pathSeparator, path) => {
@@ -4744,7 +4811,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$2(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$1(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
 };
 
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
@@ -4780,7 +4847,7 @@ const watch = async id => {
     return;
   }
   state$1.watchedTheme = id;
-  await invoke$2('ExtensionHost.watchColorTheme', id);
+  await invoke$1('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get('workbench.colorTheme');
@@ -4853,18 +4920,18 @@ const createWebView3 = async ({
 };
 
 const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
-  await invokeAndTransfer$1('Extensions.createWebViewWorkerRpc2', rpcInfo, port);
+  await invokeAndTransfer$3('Extensions.createWebViewWorkerRpc2', rpcInfo, port);
 };
 
 /**
  * @deprecated use createWebViewWorkerRpc2 which passes the worker url as a parameter
  */
 const createWebViewWorkerRpc = async (rpcInfo, port) => {
-  await invokeAndTransfer$1('Extensions.createWebViewWorkerRpc', rpcInfo, port);
+  await invokeAndTransfer$3('Extensions.createWebViewWorkerRpc', rpcInfo, port);
 };
 
 const executeExternalCommand = (method, ...params) => {
-  return invoke$2(method, ...params);
+  return invoke$1(method, ...params);
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -4932,7 +4999,7 @@ const mockExec = () => {
   try {
     // @ts-ignore
     api.exec = async (command, args, options) => {
-      const result = await invoke$2('Test.executeMockExecFunction', command, args, options);
+      const result = await invoke$1('Test.executeMockExecFunction', command, args, options);
       const {
         exitCode,
         stderr,
@@ -4958,7 +5025,7 @@ const mockRpc = () => {
     try {
       return {
         async invoke(method, ...params) {
-          const result = await invoke$2('Test.executeMockRpcFunction', options.name, method, ...params);
+          const result = await invoke$1('Test.executeMockRpcFunction', options.name, method, ...params);
           return result;
         }
       };
@@ -5382,7 +5449,7 @@ const getIconThemeJson = async iconThemeId => {
 };
 
 const getRpcInfo = async rpcId => {
-  return await invoke$1('Extensions.getRpcInfo', rpcId);
+  return await invoke$5('Extensions.getRpcInfo', rpcId);
 };
 
 const emptyStatus = {
@@ -5454,7 +5521,7 @@ const handleMessagePort2 = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$c(rpcId, rpc);
+    set$d(rpcId, rpc);
   }
 };
 
@@ -5464,12 +5531,12 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$c(rpcId, rpc);
+    set$d(rpcId, rpc);
   }
 };
 
 const handleIconThemeChange = async () => {
-  await invoke$2('IconTheme.handleIconThemeChange');
+  await invoke$1('IconTheme.handleIconThemeChange');
 };
 
 const initialIconTheme = undefined;
@@ -6224,22 +6291,15 @@ const commandMap = {
   'WebViews.getWebViews': getWebViews
 };
 
-const launchExtensionManagementWorker = async () => {
-  const rpc = await TransferMessagePortRpcParent.create({
-    commandMap: {},
-    async send(port) {
-      await sendMessagePortToExtensionManagementWorker(port, 0);
-    }
+const launchRendererWorker = async () => {
+  const rpc = await WebWorkerRpcClient.create({
+    commandMap: commandMap
   });
-  return rpc;
+  set$d(RendererWorker, rpc);
 };
 
 const listen = async () => {
-  setFactory(launchExtensionManagementWorker);
-  const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMap
-  });
-  set$c(RendererWorker, rpc);
+  await Promise.all([launchExtensionManagementWorker(), launchFileSearchWorker(), launchRendererWorker()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-worker",
-  "version": "8.2.0",
+  "version": "8.4.0",
   "description": "Webworker for the extension host functionality in Lvce Editor.",
   "keywords": [
     "web-worker"