@lvce-editor/extension-management-worker 4.1.0 → 4.3.0

package/dist/extensionManagementWorkerMain.js

@@ -1,7 +1,3 @@
-const activateByEvent = async () => {
-  // TODO
-};
-
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -1216,7 +1212,7 @@ const createMockRpc = ({
 };
 
 const rpcs$2 = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$8 = (id, rpc) => {
   rpcs$2[id] = rpc;
 };
 const get$4 = id => {
@@ -1249,7 +1245,7 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$7(rpcId, mockRpc);
+      set$8(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1258,7 +1254,7 @@ const create$1 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
@@ -1275,25 +1271,25 @@ const SharedProcess = 1492;
 
 const {
   dispose,
-  invoke: invoke$4,
+  invoke: invoke$5,
   invokeAndTransfer: invokeAndTransfer$2,
   registerMockRpc,
-  set: set$6
+  set: set$7
 } = create$1(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
-  return invoke$4('ExtensionHostReference.executeReferenceProvider', id, offset);
+  return invoke$5('ExtensionHostReference.executeReferenceProvider', id, offset);
 };
 const executeFileReferenceProvider = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionHostReference.executeFileReferenceProvider', id);
+  return invoke$5('ExtensionHostReference.executeFileReferenceProvider', id);
 };
 const getRuntimeStatus$2 = async extensionId => {
   // @ts-ignore
-  return invoke$4('ExtensionHost.getRuntimeStatus', extensionId);
+  return invoke$5('ExtensionHost.getRuntimeStatus', extensionId);
 };
 const getEnabledOutputProviderIds = async () => {
-  const channels = await invoke$4('Output.getEnabledProviders');
+  const channels = await invoke$5('Output.getEnabledProviders');
   return channels;
 };
 
@@ -1304,30 +1300,30 @@ const ExtensionHost = {
   executeReferenceProvider,
   getEnabledOutputProviderIds,
   getRuntimeStatus: getRuntimeStatus$2,
-  invoke: invoke$4,
+  invoke: invoke$5,
   invokeAndTransfer: invokeAndTransfer$2,
   registerMockRpc,
-  set: set$6
+  set: set$7
 };
 
 const {
-  invoke: invoke$3,
-  set: set$5
+  invoke: invoke$4,
+  set: set$6
 } = create$1(FileSystemWorker);
 const readFile = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
+  return invoke$4('FileSystem.readFile', uri);
 };
 const writeFile = async (uri, content) => {
-  return invoke$3('FileSystem.writeFile', uri, content);
+  return invoke$4('FileSystem.writeFile', uri, content);
 };
 const exists = async uri => {
-  return invoke$3('FileSystem.exists', uri);
+  return invoke$4('FileSystem.exists', uri);
 };
 
 const {
-  invoke: invoke$2,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$4
+  set: set$5
 } = create$1(RendererWorker);
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
@@ -1347,8 +1343,8 @@ const sendMessagePortToSharedProcess = async port => {
 };
 
 const {
-  invoke: invoke$1,
-  set: set$3
+  invoke: invoke$2,
+  set: set$4
 } = create$1(SharedProcess);
 
 const create = () => {
@@ -1399,11 +1395,11 @@ let extensionsState = createInitialState();
 const get$3 = () => {
   return extensionsState;
 };
-const set$2 = newState => {
+const set$3 = newState => {
   extensionsState = newState;
 };
 const update = newState => {
-  set$2({
+  set$3({
     ...extensionsState,
     ...newState
   });
@@ -1452,7 +1448,7 @@ const baseName = path => {
   const slashIndex = path.lastIndexOf('/');
   return path.slice(slashIndex + 1);
 };
-const getExtensionId = extension => {
+const getExtensionId$4 = extension => {
   if (extension && extension.id) {
     return extension.id;
   }
@@ -1540,7 +1536,7 @@ const activateExtension2 = async (extensionId, extension, absolutePath, extensio
       status: Activated
     });
   } catch (error) {
-    const id = getExtensionId(extension);
+    const id = getExtensionId$4(extension);
     if (isImportError(error)) {
       const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
       throw new Error(`Failed to activate extension ${id}: ${actualErrorMessage}`, {
@@ -1565,30 +1561,34 @@ const get$2 = extensionId => {
 const getAll = () => {
   return Object.values(rpcs$1);
 };
-const set$1 = (extensionId, rpc) => {
+const set$2 = (extensionId, rpc) => {
   rpcs$1[extensionId] = rpc;
 };
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-const invoke = (method, ...params) => {
-  return invoke$2(method, ...params);
+const invoke$1 = (method, ...params) => {
+  return invoke$3(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
   return invokeAndTransfer$1(method, ...params);
 };
 
-const getOrCreateIsolatedExtensionHostWorker = async extensionId => {
-  const existingRpc = get$2(extensionId);
-  if (existingRpc) {
-    return existingRpc;
-  }
-  const rpc = await create$7({
+const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, createRpc, invokeAndTransfer) => {
+  return createRpc({
     commandMap: commandMapRef,
+    isMessagePortOpen: true,
     send(port) {
-      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, extensionId);
+      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, extensionId, absolutePath);
     }
   });
-  set$1(extensionId, rpc);
+};
+const getOrCreateIsolatedExtensionHostWorker = async (extensionId, absolutePath) => {
+  const existingRpc = get$2(extensionId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  const rpc = await createIsolatedExtensionHostWorker(extensionId, absolutePath, create$7, invokeAndTransfer);
+  set$2(extensionId, rpc);
   return rpc;
 };
 
@@ -1690,9 +1690,38 @@ const isExtensionIsolated = extension => {
 const activateExtension3 = async (extension, absolutePath, activationEvent, platform) => {
   handleRpcInfos(extension, platform);
   const extensionId = extension.id || interExtensionId(extension.uri);
-  const extensionHost = isExtensionIsolated(extension) ? await getOrCreateIsolatedExtensionHostWorker(extensionId) : undefined;
-  await importExtension(extensionId, absolutePath, activationEvent, extensionHost);
-  await activateExtension2(extensionId, extension, absolutePath, extensionHost);
+  if (isExtensionIsolated(extension)) {
+    await getOrCreateIsolatedExtensionHostWorker(extensionId, absolutePath);
+    return;
+  }
+  await importExtension(extensionId, absolutePath, activationEvent);
+  await activateExtension2(extensionId, extension, absolutePath);
+};
+
+const getExtensionAbsolutePath = (id, isWeb, isBuiltin, path, relativePath, origin, platform, assetDir) => {
+  if (path.startsWith('http')) {
+    if (path.endsWith('/')) {
+      return new URL(relativePath, path).toString();
+    }
+    return new URL(relativePath, path + '/').toString();
+  }
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+  if (isWeb) {
+    return path + '/' + relativePath;
+  }
+  if (platform === Web) {
+    return path + '/' + relativePath;
+  }
+  if (isBuiltin) {
+    return `${assetDir}/extensions/${id}/${relativePath}`;
+  }
+  return new URL('/remote' + path + '/' + relativePath, origin).toString();
+};
+
+const getDynamicWebExtensions = () => {
+  return get$3().webExtensions;
 };
 
 const getJson$1 = async url => {
@@ -1708,6 +1737,74 @@ const getJson$1 = async url => {
   }
 };
 
+const getWebExtensionsUrl = assetDir => {
+  return `${assetDir}/config/extensions.json`;
+};
+
+const getWebExtensions = async assetDir => {
+  try {
+    return await getJson$1(getWebExtensionsUrl(assetDir));
+  } catch {
+    return [];
+  }
+};
+
+const getAllExtensions = async (assetDir, platform) => {
+  if (typeof assetDir !== 'string') {
+    assetDir = await invoke$3('Layout.getAssetDir');
+  }
+  if (!platform) {
+    platform = await invoke$3('Layout.getPlatform');
+  }
+  string(assetDir);
+  number(platform);
+  const meta = getDynamicWebExtensions();
+  if (platform === Web) {
+    const webExtensions = await getWebExtensions(assetDir);
+    return [...webExtensions, ...meta];
+  }
+  const local = await invoke$2('ExtensionManagement.getAllExtensions');
+  return [...local, ...meta];
+};
+
+const activatingExtensions = Object.create(null);
+const runningExtensions = Object.create(null);
+const matchesEvent = (extension, event) => {
+  return isExtensionIsolated(extension) && Array.isArray(extension.activation) && extension.activation.includes(event);
+};
+const getExtensionId$3 = extension => {
+  return extension.id;
+};
+const getAbsolutePath$2 = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(extension.id, extension.isWeb, extension.builtin, extension.uri || extension.path, extension.browser, globalThis.location.origin, platform, assetDir);
+};
+const activateExtension = async (extension, event, assetDir, platform) => {
+  const extensionId = getExtensionId$3(extension);
+  if (runningExtensions[extensionId]) {
+    return;
+  }
+  if (!Object.hasOwn(activatingExtensions, extensionId)) {
+    const absolutePath = getAbsolutePath$2(extension, assetDir, platform);
+    activatingExtensions[extensionId] = activateExtension3(extension, absolutePath, event, platform).then(() => {
+      runningExtensions[extensionId] = true;
+    }).finally(() => {
+      delete activatingExtensions[extensionId];
+    });
+  }
+  await activatingExtensions[extensionId];
+};
+const activateByEvent = async (event, assetDir, platform) => {
+  if (event === 'none') {
+    await Promise.all(Object.values(activatingExtensions));
+    return;
+  }
+  const extensions = await getAllExtensions(assetDir, platform);
+  const matchingExtensions = extensions.filter(extension => matchesEvent(extension, event));
+  for (const extension of matchingExtensions) {
+    await activateExtension(extension, event, assetDir, platform);
+  }
+};
+
 const getWebExtensionManifest = async (path, manifestPath) => {
   try {
     const manifest = await getJson$1(manifestPath);
@@ -1727,6 +1824,24 @@ const getWebManifestPath = path => {
   return manifestPath;
 };
 
+let rpc;
+const set$1 = value => {
+  rpc = value;
+};
+const invoke = async (method, ...params) => {
+  if (!rpc) {
+    return undefined;
+  }
+  return rpc.invoke(method, ...params);
+};
+
+const handleChange = async id => {
+  await invoke('StatusBar.handleChange', id);
+};
+
+const hasStatusBarItems = manifest => {
+  return Array.isArray(manifest.statusBarItems) && manifest.statusBarItems.length > 0;
+};
 const addWebExtension = async path => {
   if (hasWebExtensionUri(path)) {
     return undefined;
@@ -1735,6 +1850,9 @@ const addWebExtension = async path => {
   const manifest = await getWebExtensionManifest(path, manifestPath);
   addWebExtension$1(manifest);
   clearCachedExtensions();
+  if (hasStatusBarItems(manifest)) {
+    await handleChange(manifest.id || path);
+  }
   return manifest;
 };
 
@@ -1835,7 +1953,7 @@ const disableExtension2$1 = async (id, platform) => {
       ...oldState,
       disabledIds: [...oldState.disabledIds, id]
     };
-    set$2(newState);
+    set$3(newState);
   } else if (isWeb) {
     const cached = await getJson(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
@@ -1845,7 +1963,7 @@ const disableExtension2$1 = async (id, platform) => {
     };
     await setJson(disabledExtensionsCacheKey, newData);
   } else {
-    await invoke$1('ExtensionManagement.disable', id);
+    await invoke$2('ExtensionManagement.disable', id);
   }
 };
 const enableExtension2$1 = async (id, platform) => {
@@ -1857,7 +1975,7 @@ const enableExtension2$1 = async (id, platform) => {
       ...oldState,
       disabledIds: oldState.disabledIds.filter(existing => existing !== id)
     };
-    set$2(newState);
+    set$3(newState);
   } else if (isWeb) {
     const cached = await getJson(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
@@ -1870,7 +1988,7 @@ const enableExtension2$1 = async (id, platform) => {
 };
 
 const invalidateExtensionsCache = async () => {
-  await invoke$2('ExtensionManagement.invalidateExtensionsCache');
+  await invoke$3('ExtensionManagement.invalidateExtensionsCache');
 };
 
 const disableExtension2 = async (id, platform) => {
@@ -1894,7 +2012,7 @@ const enableExtension2 = async (id, platform) => {
   string(id);
   number(platform);
   if (platform === Remote || platform === Electron) {
-    const disabledExtensionsJsonPath = await invoke$2('WebView.compatSharedProcessInvoke', 'PlatformPaths.getDisabledExtensionsJsonUri');
+    const disabledExtensionsJsonPath = await invoke$3('WebView.compatSharedProcessInvoke', 'PlatformPaths.getDisabledExtensionsJsonUri');
     const exists$1 = await exists(disabledExtensionsJsonPath);
     if (!exists$1) {
       return undefined;
@@ -1917,6 +2035,134 @@ const enableExtension = async (id, isTest) => {
   return enableExtension2(id, oldState.platform);
 };
 
+const getExtensionId$2 = extension => {
+  return extension.id || interExtensionId(extension.uri || extension.path || '');
+};
+const contributesCommand = (extension, id) => {
+  return Array.isArray(extension.commands) && extension.commands.some(command => command.id === id);
+};
+const getContributingExtension = async (id, platform) => {
+  const extensions = await getAllExtensions('', platform);
+  return extensions.find(extension => isExtensionIsolated(extension) && contributesCommand(extension, id));
+};
+const getRpcForCommand = async (id, platform) => {
+  const extension = await getContributingExtension(id, platform);
+  if (!extension) {
+    return undefined;
+  }
+  const extensionId = getExtensionId$2(extension);
+  const existingRpc = get$2(extensionId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  await activateByEvent(`onCommand:${id}`, '', platform);
+  return get$2(extensionId);
+};
+const executeRendererCommand = (id, args) => {
+  return invoke$3(id, ...args);
+};
+const executeCommand = async (id, ...args) => {
+  const {
+    platform
+  } = get$3();
+  const rpc = await getRpcForCommand(id, platform);
+  if (rpc) {
+    return rpc.invoke('ExtensionApi.executeCommand', id, ...args);
+  }
+  return executeRendererCommand(id, args);
+};
+
+const getExtensionId$1 = extension => {
+  return extension.id || interExtensionId(extension.uri || extension.path || '');
+};
+const contributesCompletionProvider = (extension, languageId) => {
+  return Array.isArray(extension.completionProviders) && extension.completionProviders.some(provider => provider.languageId === languageId);
+};
+const getOrigin$1 = () => {
+  return globalThis.location?.origin || 'http://localhost';
+};
+const getAbsolutePath$1 = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(getExtensionId$1(extension), extension.isWeb === true, extension.builtin === true, extension.uri || extension.path || '', extension.browser || '', getOrigin$1(), platform, assetDir);
+};
+const getMatchingExtensions$1 = async (textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensions(assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesCompletionProvider(extension, textDocument.languageId));
+};
+const getRpc$2 = async (extension, assetDir, platform) => {
+  const extensionId = getExtensionId$1(extension);
+  const existingRpc = get$2(extensionId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  const absolutePath = getAbsolutePath$1(extension, assetDir, platform);
+  return getOrCreateIsolatedExtensionHostWorker(extensionId, absolutePath);
+};
+const executeRpcCompletionProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeCompletionProvider', textDocument, ...args);
+};
+const executeRpcResolveCompletionItemProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeResolveCompletionItemProvider', textDocument, ...args);
+};
+const executeCompletionProvider = async (textDocument, ...args) => {
+  const {
+    platform
+  } = get$3();
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$1(textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$2(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcCompletionProvider(rpc, textDocument, args)));
+  return results[0] || [];
+};
+const executeResolveCompletionItemProvider = async (textDocument, ...args) => {
+  const {
+    platform
+  } = get$3();
+  const assetDir = '';
+  const extensions = await getMatchingExtensions$1(textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$2(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcResolveCompletionItemProvider(rpc, textDocument, args)));
+  return results[0];
+};
+
+const getExtensionId = extension => {
+  return extension.id || interExtensionId(extension.uri || extension.path || '');
+};
+const contributesFormattingProvider = (extension, languageId) => {
+  return Array.isArray(extension.formattingProviders) && extension.formattingProviders.some(provider => provider.languageId === languageId);
+};
+const getOrigin = () => {
+  return globalThis.location?.origin || 'http://localhost';
+};
+const getAbsolutePath = (extension, assetDir, platform) => {
+  return getExtensionAbsolutePath(getExtensionId(extension), extension.isWeb === true, extension.builtin === true, extension.uri || extension.path || '', extension.browser || '', getOrigin(), platform, assetDir);
+};
+const getMatchingExtensions = async (textDocument, assetDir, platform) => {
+  const extensions = await getAllExtensions(assetDir, platform);
+  return extensions.filter(extension => isExtensionIsolated(extension) && contributesFormattingProvider(extension, textDocument.languageId));
+};
+const getRpc$1 = async (extension, assetDir, platform) => {
+  const extensionId = getExtensionId(extension);
+  const existingRpc = get$2(extensionId);
+  if (existingRpc) {
+    return existingRpc;
+  }
+  const absolutePath = getAbsolutePath(extension, assetDir, platform);
+  return getOrCreateIsolatedExtensionHostWorker(extensionId, absolutePath);
+};
+const executeRpcFormattingProvider = async (rpc, textDocument, args) => {
+  return rpc.invoke('ExtensionApi.executeFormattingProvider', textDocument, ...args);
+};
+const executeFormattingProvider = async (textDocument, ...args) => {
+  const {
+    platform
+  } = get$3();
+  const assetDir = '';
+  const extensions = await getMatchingExtensions(textDocument, assetDir, platform);
+  const rpcs = await Promise.all(extensions.map(extension => getRpc$1(extension, assetDir, platform)));
+  const results = await Promise.all(rpcs.map(rpc => executeRpcFormattingProvider(rpc, textDocument, args)));
+  return results[0] || [];
+};
+
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 const warn = (...args) => {
   console.warn(...args);
@@ -2058,7 +2304,7 @@ const getColorThemeCssCached = async (colorThemeId, platform, getData) => {
 };
 
 const readJson = url => {
-  return invoke$2('FileSystem.readJson', url);
+  return invoke$3('FileSystem.readJson', url);
 };
 
 const join = (pathSeparator, ...parts) => {
@@ -2081,40 +2327,6 @@ const getColorThemeUri = (extensions, colorThemeId) => {
   return '';
 };
 
-const getDynamicWebExtensions = () => {
-  return get$3().webExtensions;
-};
-
-const getWebExtensionsUrl = assetDir => {
-  return `${assetDir}/config/extensions.json`;
-};
-
-const getWebExtensions = async assetDir => {
-  try {
-    return await getJson$1(getWebExtensionsUrl(assetDir));
-  } catch {
-    return [];
-  }
-};
-
-const getAllExtensions = async (assetDir, platform) => {
-  if (typeof assetDir !== 'string') {
-    assetDir = await invoke$2('Layout.getAssetDir');
-  }
-  if (!platform) {
-    platform = await invoke$2('Layout.getPlatform');
-  }
-  string(assetDir);
-  number(platform);
-  const meta = getDynamicWebExtensions();
-  if (platform === Web) {
-    const webExtensions = await getWebExtensions(assetDir);
-    return [...webExtensions, ...meta];
-  }
-  const local = await invoke$1('ExtensionManagement.getAllExtensions');
-  return [...local, ...meta];
-};
-
 const getColorThemeJson$2 = async (colorThemeId, assetDir, platform) => {
   const extensions = await getAllExtensions(assetDir, platform);
   const colorThemeUri = getColorThemeUri(extensions, colorThemeId);
@@ -2238,7 +2450,7 @@ const getRemoteUrlForWebView = async (uri, options = {}) => {
   if (!webView) {
     throw new Error(`webview ${options.webViewId} not found`);
   }
-  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke('FileSystem.getBlob', uri)]);
+  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
   const objectUrl = await rpc.invoke('createObjectUrl', blob);
   return objectUrl;
 };
@@ -2275,11 +2487,16 @@ const getStatusBarItems = async () => {
   return results.flat();
 };
 
-const handleMessagePort = async port => {
-  await create$8({
+const StatusBarWorker = 200;
+
+const handleMessagePort = async (port, rpcId) => {
+  const rpc = await create$8({
     commandMap: commandMapRef,
     messagePort: port
   });
+  if (rpcId === StatusBarWorker) {
+    set$1(rpc);
+  }
 };
 
 const getRpcRemote = async () => {
@@ -2311,7 +2528,7 @@ const getRpc = async platform => {
 const initializeSharedProcess = async platform => {
   const rpc = await getRpc(platform);
   if (rpc) {
-    set$3(rpc);
+    set$4(rpc);
   }
 };
 
@@ -2392,6 +2609,10 @@ const commandMap = {
   'Extensions.disable2': disableExtension2,
   'Extensions.enable': enableExtension,
   'Extensions.enable2': enableExtension2,
+  'Extensions.executeCommand': executeCommand,
+  'Extensions.executeCompletionProvider': executeCompletionProvider,
+  'Extensions.executeFormattingProvider': executeFormattingProvider,
+  'Extensions.executeResolveCompletionItemProvider': executeResolveCompletionItemProvider,
   'Extensions.getAllExtensions': getAllExtensions,
   'Extensions.getColorThemeCss': getColorThemeCss,
   'Extensions.getColorThemeCssFromJson': getColorThemeCssFromJson,
@@ -2409,7 +2630,8 @@ const commandMap = {
   'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
-  'Extensions.uninstall': uninstallExtension
+  'Extensions.uninstall': uninstallExtension,
+  'StatusBar.handleChange': handleChange
 };
 
 const initializeExtensionHostWorker = async () => {
@@ -2419,7 +2641,7 @@ const initializeExtensionHostWorker = async () => {
       await sendMessagePortToExtensionHostWorker(port, 0);
     }
   });
-  set$6(rpc);
+  set$7(rpc);
 };
 
 const initializeFileSystemWorker = async () => {
@@ -2429,7 +2651,7 @@ const initializeFileSystemWorker = async () => {
       await sendMessagePortToFileSystemWorker(port, 0);
     }
   });
-  set$5(rpc);
+  set$6(rpc);
 };
 
 const initializeIframeWorker = async () => {
@@ -2446,7 +2668,7 @@ const initializeRendererWorker = async () => {
   const rpc = await create$2({
     commandMap: commandMap
   });
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const listen = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-management-worker",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "description": "Webworker for the Extension Management functionality in Lvce Editor.",
   "keywords": [
     "web-worker"