@lvce-editor/static-server 0.82.7 → 0.83.0

package/static/{0f18beb → 6d88bc8}/packages/extension-management-worker/dist/extensionManagementWorkerMain.js

@@ -1,7 +1,3 @@
-const activateByEvent = async () => {
-  // TODO
-};
-
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -608,7 +604,7 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get$4 = id => {
+const get$5 = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
@@ -757,7 +753,7 @@ const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$4(id);
+  const fn = get$5(id);
   if (!fn) {
     console.log(response);
     warn$1(`callback ${id} may already be disposed`);
@@ -1215,33 +1211,33 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const rpcs$1 = Object.create(null);
-const set$6 = (id, rpc) => {
-  rpcs$1[id] = rpc;
+const rpcs$2 = Object.create(null);
+const set$8 = (id, rpc) => {
+  rpcs$2[id] = rpc;
 };
-const get$3 = id => {
-  return rpcs$1[id];
+const get$4 = id => {
+  return rpcs$2[id];
 };
 const remove = id => {
-  delete rpcs$1[id];
+  delete rpcs$2[id];
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
 const create$1 = rpcId => {
   return {
     async dispose() {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1249,7 +1245,7 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$6(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$6(rpcId, rpc);
+      set$8(rpcId, rpc);
     }
   };
 };
@@ -1274,28 +1270,60 @@ const RendererWorker = 1;
 const SharedProcess = 1492;
 
 const {
-  invoke: invoke$4,
-  set: set$5
+  dispose,
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$2,
+  registerMockRpc,
+  set: set$7
 } = create$1(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$5('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$5('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus$2 = async extensionId => {
+  // @ts-ignore
+  return invoke$5('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const getEnabledOutputProviderIds = async () => {
+  const channels = await invoke$5('Output.getEnabledProviders');
+  return channels;
+};
+
+const ExtensionHost = {
+  __proto__: null,
+  dispose,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getEnabledOutputProviderIds,
+  getRuntimeStatus: getRuntimeStatus$2,
+  invoke: invoke$5,
+  invokeAndTransfer: invokeAndTransfer$2,
+  registerMockRpc,
+  set: set$7
+};
 
 const {
-  invoke: invoke$3,
-  set: set$4
+  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$3
+  set: set$5
 } = create$1(RendererWorker);
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
@@ -1315,8 +1343,8 @@ const sendMessagePortToSharedProcess = async port => {
 };
 
 const {
-  invoke: invoke$1,
-  set: set$2
+  invoke: invoke$2,
+  set: set$4
 } = create$1(SharedProcess);
 
 const create = () => {
@@ -1364,14 +1392,14 @@ const createEmptyRuntimeStatus = id => {
   };
 };
 let extensionsState = createInitialState();
-const get$2 = () => {
+const get$3 = () => {
   return extensionsState;
 };
-const set$1 = newState => {
+const set$3 = newState => {
   extensionsState = newState;
 };
 const update = newState => {
-  set$1({
+  set$3({
     ...extensionsState,
     ...newState
   });
@@ -1420,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;
   }
@@ -1485,10 +1513,10 @@ const rejectAfterTimeout = async (timeout, token) => {
   }
   throw new Error(`Activation timeout of ${timeout}ms exceeded`);
 };
-const activate = async (extensionId, extension) => {
-  await invoke$4('ExtensionHost.activateExtension3', extensionId, extension);
+const activate = async (extensionId, extension, extensionHost) => {
+  await extensionHost.invoke('ExtensionHost.activateExtension3', extensionId, extension);
 };
-const activateExtension2 = async (extensionId, extension, absolutePath) => {
+const activateExtension2 = async (extensionId, extension, absolutePath, extensionHost = ExtensionHost) => {
   string(extensionId);
   object(extension);
   string(absolutePath);
@@ -1499,7 +1527,7 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
       activationStartTime: startTime,
       status: Activating
     });
-    await Promise.race([activate(extensionId, extension), rejectAfterTimeout(activationTimeout, token)]);
+    await Promise.race([activate(extensionId, extension, extensionHost), rejectAfterTimeout(activationTimeout, token)]);
     const endTime = performance.now();
     const time = endTime - startTime;
     updateRuntimeStatus(extensionId, {
@@ -1508,7 +1536,7 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
       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}`, {
@@ -1524,6 +1552,46 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
   }
 };
 
+const commandMapRef = {};
+
+const rpcs$1 = Object.create(null);
+const get$2 = extensionId => {
+  return rpcs$1[extensionId];
+};
+const getAll = () => {
+  return Object.values(rpcs$1);
+};
+const set$2 = (extensionId, rpc) => {
+  rpcs$1[extensionId] = rpc;
+};
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const invoke$1 = (method, ...params) => {
+  return invoke$3(method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  return invokeAndTransfer$1(method, ...params);
+};
+
+const createIsolatedExtensionHostWorker = async (extensionId, absolutePath, createRpc, invokeAndTransfer) => {
+  return createRpc({
+    commandMap: commandMapRef,
+    isMessagePortOpen: true,
+    send(port) {
+      return invokeAndTransfer('LaunchIsolatedExtensionHostWorker.launchIsolatedExtensionHostWorker', port, extensionId, absolutePath);
+    }
+  });
+};
+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;
+};
+
 const rpcs = Object.create(null);
 const add = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1567,7 +1635,7 @@ const handleRpcInfos = (extension, platform) => {
   }
 };
 
-const importExtension = async (extensionId, absolutePath, activationEvent) => {
+const importExtension = async (extensionId, absolutePath, activationEvent, extensionHost = ExtensionHost) => {
   try {
     string(absolutePath);
     const startTime = performance.now();
@@ -1583,7 +1651,7 @@ const importExtension = async (extensionId, absolutePath, activationEvent) => {
       status: Importing
     });
     try {
-      await invoke$4('ExtensionHost.importExtension2', extensionId, absolutePath);
+      await extensionHost.invoke('ExtensionHost.importExtension2', extensionId, absolutePath);
       const endTime = performance.now();
       const time = endTime - startTime;
       updateRuntimeStatus(extensionId, {
@@ -1615,13 +1683,47 @@ const interExtensionId = path => {
   return path.slice(slashIndex + 1);
 };
 
+const isExtensionIsolated = extension => {
+  return extension?.isolated === true;
+};
+
 const activateExtension3 = async (extension, absolutePath, activationEvent, platform) => {
   handleRpcInfos(extension, platform);
   const extensionId = extension.id || interExtensionId(extension.uri);
+  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 => {
   try {
     const response = await fetch(url);
@@ -1635,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);
@@ -1654,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;
@@ -1662,19 +1850,14 @@ const addWebExtension = async path => {
   const manifest = await getWebExtensionManifest(path, manifestPath);
   addWebExtension$1(manifest);
   clearCachedExtensions();
+  if (hasStatusBarItems(manifest)) {
+    await handleChange(manifest.id || path);
+  }
   return manifest;
 };
 
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-const invoke = (method, ...params) => {
-  return invoke$2(method, ...params);
-};
-const invokeAndTransfer = (method, ...params) => {
-  return invokeAndTransfer$1(method, ...params);
-};
-
 const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
   // TODO this function is called from the iframe worker to create a direct
   // connection between a webview/iframe and it's webworker. For this to work
@@ -1764,13 +1947,13 @@ const disabledExtensionsCacheKey = '/cache/disabledExtensions.json';
 const disableExtension2$1 = async (id, platform) => {
   const isTest = platform === Test;
   const isWeb = platform === Web;
-  const oldState = get$2(); // TODO maybe pass in an application id? Would allow multiple editors with different extensions.
+  const oldState = get$3(); // TODO maybe pass in an application id? Would allow multiple editors with different extensions.
   if (isTest) {
     const newState = {
       ...oldState,
       disabledIds: [...oldState.disabledIds, id]
     };
-    set$1(newState);
+    set$3(newState);
   } else if (isWeb) {
     const cached = await getJson(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
@@ -1780,19 +1963,19 @@ 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) => {
   const isTest = platform === Test;
   const isWeb = platform === Web;
-  const oldState = get$2();
+  const oldState = get$3();
   if (isTest) {
     const newState = {
       ...oldState,
       disabledIds: oldState.disabledIds.filter(existing => existing !== id)
     };
-    set$1(newState);
+    set$3(newState);
   } else if (isWeb) {
     const cached = await getJson(disabledExtensionsCacheKey);
     const oldDisabled = cached?.disabledExtensions || [];
@@ -1805,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) => {
@@ -1821,7 +2004,7 @@ const disableExtension2 = async (id, platform) => {
 };
 
 const disableExtension = async (id, isTest) => {
-  const oldState = get$2();
+  const oldState = get$3();
   return disableExtension2(id, oldState.platform);
 };
 
@@ -1829,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;
@@ -1848,10 +2031,138 @@ const enableExtension2 = async (id, platform) => {
 };
 
 const enableExtension = async (id, isTest) => {
-  const oldState = get$2();
+  const oldState = get$3();
   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);
@@ -1993,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) => {
@@ -2016,40 +2327,6 @@ const getColorThemeUri = (extensions, colorThemeId) => {
   return '';
 };
 
-const getDynamicWebExtensions = () => {
-  return get$2().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);
@@ -2173,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;
 };
@@ -2201,13 +2478,25 @@ const getRuntimeStatus = extensionId => {
   return getRuntimeStatus$1(extensionId) || emptyStatus;
 };
 
-const commandMapRef = {};
+const getItems = async rpc => {
+  return rpc.invoke('ExtensionApi.getStatusBarItems');
+};
+const getStatusBarItems = async () => {
+  const rpcs = getAll();
+  const results = await Promise.all(rpcs.map(getItems));
+  return results.flat();
+};
+
+const StatusBarWorker = 200;
 
-const handleMessagePort = async port => {
-  await create$8({
+const handleMessagePort = async (port, rpcId) => {
+  const rpc = await create$8({
     commandMap: commandMapRef,
     messagePort: port
   });
+  if (rpcId === StatusBarWorker) {
+    set$1(rpc);
+  }
 };
 
 const getRpcRemote = async () => {
@@ -2239,7 +2528,7 @@ const getRpc = async platform => {
 const initializeSharedProcess = async platform => {
   const rpc = await getRpc(platform);
   if (rpc) {
-    set$2(rpc);
+    set$4(rpc);
   }
 };
 
@@ -2320,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,
@@ -2331,12 +2624,14 @@ const commandMap = {
   'Extensions.getRemoteUrlForWebView': getRemoteUrlForWebView,
   'Extensions.getRpcInfo': getRpcInfo,
   'Extensions.getRuntimeStatus': getRuntimeStatus,
+  'Extensions.getStatusBarItems': getStatusBarItems,
   'Extensions.handleMessagePort': handleMessagePort,
   'Extensions.importExtension': importExtension,
   'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
-  'Extensions.uninstall': uninstallExtension
+  'Extensions.uninstall': uninstallExtension,
+  'StatusBar.handleChange': handleChange
 };
 
 const initializeExtensionHostWorker = async () => {
@@ -2346,7 +2641,7 @@ const initializeExtensionHostWorker = async () => {
       await sendMessagePortToExtensionHostWorker(port, 0);
     }
   });
-  set$5(rpc);
+  set$7(rpc);
 };
 
 const initializeFileSystemWorker = async () => {
@@ -2356,7 +2651,7 @@ const initializeFileSystemWorker = async () => {
       await sendMessagePortToFileSystemWorker(port, 0);
     }
   });
-  set$4(rpc);
+  set$6(rpc);
 };
 
 const initializeIframeWorker = async () => {
@@ -2373,7 +2668,7 @@ const initializeRendererWorker = async () => {
   const rpc = await create$2({
     commandMap: commandMap
   });
-  set$3(rpc);
+  set$5(rpc);
 };
 
 const listen = async () => {