@lvce-editor/hover-worker 2.13.0 → 2.15.0

package/dist/hoverWorkerMain.js

@@ -139,7 +139,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -293,7 +292,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -450,7 +456,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -501,11 +507,32 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand$1 = key => {
+  return commands[key];
+};
+const execute$1 = (command, ...args) => {
+  const fn = getCommand$1(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$2 = id => {
@@ -530,12 +557,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -559,7 +586,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -576,8 +606,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -588,55 +620,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -691,56 +759,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$3 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$3(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -770,35 +838,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -821,36 +889,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand$1 = key => {
-  return commands[key];
-};
-const execute$1 = (command, ...args) => {
-  const fn = getCommand$1(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -859,15 +908,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$6 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -879,13 +927,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -921,12 +968,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -941,6 +989,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute$1;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -949,6 +998,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -957,7 +1007,8 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$4 = async ({
+
+const create$5 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -974,7 +1025,8 @@ const create$4 = async ({
   messagePort.start();
   return rpc;
 };
-const create$2$1 = async ({
+
+const create$4 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -984,17 +1036,14 @@ const create$2$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$4({
+  return create$5({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$2$1
-};
-const create$1$1 = async ({
+
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1004,9 +1053,25 @@ const create$1$1 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1$1
+
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
 };
 
 const toCommandId = key => {
@@ -1017,42 +1082,68 @@ const create$2 = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
-    get(uid) {
-      return states[uid];
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
     },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
     },
     dispose(uid) {
       delete states[uid];
     },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
     getKeys() {
       return Object.keys(states).map(key => {
-        return Number.parseInt(key);
+        return Number.parseFloat(key);
       });
     },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
     },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
-          oldState,
-          newState
+          newState,
+          oldState
         } = states[uid];
         const newerState = await fn(newState, ...args);
         if (oldState === newerState || newState === newerState) {
           return;
         }
-        const latest = states[uid];
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
         states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
+          newState: latestNew,
+          oldState: latestOld.oldState
         };
       };
       return wrapped;
@@ -1066,27 +1157,36 @@ const create$2 = () => {
       };
       return wrapped;
     },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
         }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
     }
   };
 };
@@ -1094,29 +1194,6 @@ const terminate = () => {
   globalThis.close();
 };
 
-const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
-
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
-
 const rpcs = Object.create(null);
 const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1165,147 +1242,46 @@ const create$1 = rpcId => {
   };
 };
 
+const Text = 12;
+
+const EditorWorker$1 = 99;
+const ExtensionHostWorker = 44;
+
+const SetFocusContext = 'Viewlet.setFocusContext';
+
 const {
-  dispose: dispose$3,
   invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc: registerMockRpc$1,
+  invokeAndTransfer,
   set: set$4
 } = create$1(EditorWorker$1);
-const sendMessagePortToExtensionHostWorker$2 = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$1(
-  // @ts-ignore
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
-};
-// TODO add tests for this
-const activateByEvent$1 = async event => {
-  // @ts-ignore
-  await invoke$3('ActivateByEvent.activateByEvent', event);
-};
-const applyEdit = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$3('Editor.applyEdit2', editorUid, changes);
-};
-const applyDocumentEdits = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$3('Editor.applyDocumentEdits', editorUid, changes);
-};
-const applyWorkspaceEdit = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$3('Editor.applyWorkspaceEdit', editorUid, changes);
-};
-const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
-  // @ts-ignore
-  await invoke$3('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
-};
-const getWordAt = async (uid, rowIndex, columnIndex) => {
-  // @ts-ignore
-  const word = await invoke$3('Editor.getWordAt2', uid, rowIndex, columnIndex);
-  return word;
-};
-const getLines = async editorUid => {
-  const lines = await invoke$3('Editor.getLines2', editorUid);
-  return lines;
-};
-const getPositionAtCursor$1 = async parentUid => {
-  const position = await invoke$3('Editor.getPositionAtCursor', parentUid);
-  return position;
-};
-const getOffsetAtCursor$1 = async editorId => {
-  // @ts-ignore
-  return await invoke$3('Editor.getOffsetAtCursor', editorId);
-};
-const getSelections = async editorUid => {
-  const selections = await invoke$3('Editor.getSelections2', editorUid);
-  return selections;
+const sendMessagePortToExtensionManagementWorker$1 = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker', port, 0);
 };
 const getWordAtOffset2$1 = async editorUid => {
   return invoke$3('Editor.getWordAtOffset2', editorUid);
 };
-const closeFind2 = async editorUid => {
-  return invoke$3('Editor.closeFind2', editorUid);
-};
 const getWordBefore$1 = async (editorUid, rowIndex, columnIndex) => {
   return invoke$3('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
-const updateDebugInfo = async info => {
-  await invoke$3('Editor.updateDebugInfo', info);
-};
-const getUri = async editorUid => {
-  // @ts-ignore
-  return invoke$3('Editor.getUri', editorUid);
-};
-const getLanguageId = async editorUid => {
-  // @ts-ignore
-  return invoke$3('Editor.getLanguageId', editorUid);
-};
-const getProblems = async () => {
-  // @ts-ignore
-  return invoke$3('Editor.getProblems');
-};
 
 const EditorWorker = {
   __proto__: null,
-  activateByEvent: activateByEvent$1,
-  applyDocumentEdits,
-  applyEdit,
-  applyWorkspaceEdit,
-  closeFind2,
-  closeWidget,
-  dispose: dispose$3,
-  getLanguageId,
-  getLines,
-  getOffsetAtCursor: getOffsetAtCursor$1,
-  getPositionAtCursor: getPositionAtCursor$1,
-  getProblems,
-  getSelections,
-  getUri,
-  getWordAt,
   getWordAtOffset2: getWordAtOffset2$1,
   getWordBefore: getWordBefore$1,
   invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc: registerMockRpc$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$2,
-  set: set$4,
-  updateDebugInfo
+  invokeAndTransfer,
+  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
+  set: set$4
 };
 
 const {
-  dispose: dispose$2,
   invoke: invoke$2,
-  invokeAndTransfer,
-  registerMockRpc,
   set: set$3
 } = create$1(ExtensionHostWorker);
-const executeReferenceProvider = async (id, offset) => {
-  // @ts-ignore
-  return invoke$2('ExtensionHostReference.executeReferenceProvider', id, offset);
-};
-const executeFileReferenceProvider = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionHostReference.executeFileReferenceProvider', id);
-};
-const getRuntimeStatus = async extensionId => {
-  // @ts-ignore
-  return invoke$2('ExtensionHost.getRuntimeStatus', extensionId);
-};
-const getEnabledOutputProviderIds = async () => {
-  const channels = await invoke$2('Output.getEnabledProviders');
-  return channels;
-};
 
 const ExtensionHost = {
   __proto__: null,
-  dispose: dispose$2,
-  executeFileReferenceProvider,
-  executeReferenceProvider,
-  getEnabledOutputProviderIds,
-  getRuntimeStatus,
   invoke: invoke$2,
-  invokeAndTransfer,
-  registerMockRpc,
   set: set$3
 };
 
@@ -1313,7 +1289,7 @@ const {
   getWordAtOffset2,
   getWordBefore,
   invoke: invoke$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  sendMessagePortToExtensionManagementWorker,
   set: set$2
 } = EditorWorker;
 
@@ -1489,13 +1465,12 @@ const handleSashPointerUp = (state, eventX, eventY) => {
 };
 
 const sendMessagePortToExtensionHostWorker = async port => {
-  // @ts-ignore
-  await sendMessagePortToExtensionHostWorker$1(port);
+  await sendMessagePortToExtensionManagementWorker(port);
 };
 
 const createExtensionHostRpc = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -1778,10 +1753,6 @@ const renderEventListeners = state => {
   return [SetEventListeners, uid, eventListeners];
 };
 
-const Text = 12;
-
-const SetFocusContext = 'Viewlet.setFocusContext';
-
 const renderFocusContext = (oldState, newState) => {
   return [SetFocusContext, FocusEditorRename];
 };
@@ -1965,7 +1936,7 @@ const commandMap = {
 };
 
 const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$3({
     commandMap: commandMap
   });
   set$2(rpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/hover-worker",
-  "version": "2.13.0",
+  "version": "2.15.0",
   "description": "Web Worker for the find widget in Lvce Editor",
   "repository": {
     "type": "git",