@lvce-editor/static-server 0.70.0 → 0.70.1

package/static/{377d2ba → 6e66e1c}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -112,7 +112,7 @@ const fn = value => {
   }
 };
 
-const state$c = {
+const state$b = {
   /** @type{any[]} */
   onDidChangeTextDocumentListeners: [],
   /** @type{any[]} */
@@ -122,19 +122,19 @@ const state$c = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$c.textDocuments[textDocumentId] = textDocument;
+  state$b.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$c.onDidSaveTextDocumentListeners;
+  return state$b.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$c.onWillChangeEditorListeners;
+  return state$b.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$c.onDidChangeTextDocumentListeners;
+  return state$b.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$c.textDocuments[textDocumentId];
+  return state$b.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -684,7 +684,7 @@ const executeOrganizeImports = async uid => {
   return edits;
 };
 
-const state$b = {
+const state$a = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -707,10 +707,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$b.commands) {
+    if (command.id in state$a.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$b.commands[command.id] = command;
+    state$a.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError(error, `Failed to register command${commandDisplayId}`);
@@ -718,7 +718,7 @@ const registerCommand = command => {
 };
 const executeCommand$1 = async (id, ...args) => {
   try {
-    const command = state$b.commands[id];
+    const command = state$a.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -767,21 +767,25 @@ const {
   }
 });
 
-const state$a = {
+const state$9 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$a.configuration[key] ?? '';
+  return state$9.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$a.configuration = preferences;
+  state$9.configuration = preferences;
 };
 
 const DebugWorker$1 = 55;
+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`);
+  }
   rpcs$2[id] = rpc;
 };
 const get$b = id => {
@@ -814,16 +818,16 @@ const create$9 = rpcId => {
 
 const {
   dispose,
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4,
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$5,
   set: set$b
 } = create$9(DebugWorker$1);
 
 const DebugWorker = {
   __proto__: null,
   dispose,
-  invoke: invoke$5,
-  invokeAndTransfer: invokeAndTransfer$4,
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$5,
   set: set$b
 };
 
@@ -1711,10 +1715,10 @@ const send$1 = (transport, method, ...params) => {
   const message = create$4$2(method, params);
   transport.send(message);
 };
-const invoke$4 = (ipc, method, ...params) => {
+const invoke$6 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
+const invokeAndTransfer$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -1750,10 +1754,10 @@ const createRpc$1 = ipc => {
       send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
+      return invoke$6(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
+      return invokeAndTransfer$4(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1909,22 +1913,59 @@ const WebWorkerRpcClient = {
 };
 
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$2} = create$9(RendererWorker$1);
+  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$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+  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);
+};
+
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$c(rpcId, rpc);
+  };
+  const ensureRpc = async () => {
+    if (!rpcPromise) {
+      rpcPromise = createRpc();
+    }
+    await rpcPromise;
+  };
+  return {
+    async invoke(method, ...params) {
+      await ensureRpc();
+      const rpc = get$b(rpcId);
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      await ensureRpc();
+      const rpc = get$b(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    setFactory(value) {
+      factory = value;
+    }
+  };
 };
 
 const {
-  invoke: invoke$2
+  invoke: invoke$3
 } = DebugWorker;
 
-const state$9 = {
+const state$8 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$9.debugProviderMap[id];
+  const provider = state$8.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError(`no debug provider "${id}" found`);
@@ -1935,24 +1976,24 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$9.debugProviderMap[debugProvider.id] = debugProvider;
+  state$8.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const handlePaused = async params => {
   // @ts-ignore
-  await invoke$2('Debug.paused', params);
+  await invoke$3('Debug.paused', params);
 };
 const handleResumed = async () => {
   // @ts-ignore
-  await invoke$2('Debug.resumed');
+  await invoke$3('Debug.resumed');
 };
 const handleScriptParsed = async parsedScript => {
   // @ts-ignore
-  await invoke$2('Debug.scriptParsed', parsedScript);
+  await invoke$3('Debug.scriptParsed', parsedScript);
 };
 const handleChange = async params => {
   object(params);
   // @ts-ignore
-  await invoke$2('Debug.handleChange', params);
+  await invoke$3('Debug.handleChange', params);
 };
 const start = async (protocol, path) => {
   try {
@@ -2138,18 +2179,18 @@ const {
 
 const RendererWorker = 1;
 
-const invoke$1 = (method, ...params) => {
+const invoke$2 = (method, ...params) => {
   const rpc = get$b(RendererWorker);
   return rpc.invoke(method, ...params);
 };
-const invokeAndTransfer$1 = (method, ...params) => {
+const invokeAndTransfer$2 = (method, ...params) => {
   const rpc = get$b(RendererWorker);
   return rpc.invokeAndTransfer(method, ...params);
 };
 
 const showInformationMessage = message => {
   string(message);
-  const result = invoke$1('ExtensionHostDialog.showInformationMessage', message);
+  const result = invoke$2('ExtensionHostDialog.showInformationMessage', message);
   return result;
 };
 
@@ -2212,24 +2253,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$1('FileSystem.readFile', path);
+  const content = await invoke$2('FileSystem.readFile', path);
   return content;
 };
 const removeExternal = async path => {
-  const content = await invoke$1('FileSystem.remove', path);
+  const content = await invoke$2('FileSystem.remove', path);
   return content;
 };
 const existsExternal = async uri => {
-  return await invoke$1('FileSystem.exists', uri);
+  return await invoke$2('FileSystem.exists', uri);
 };
 const mkdirExternal = async uri => {
-  return await invoke$1('FileSystem.mkdir', uri);
+  return await invoke$2('FileSystem.mkdir', uri);
 };
 const writeFileExternal = async (uri, content) => {
-  return await invoke$1('FileSystem.writeFile', uri, content);
+  return await invoke$2('FileSystem.writeFile', uri, content);
 };
 const statExternal = async uri => {
-  return await invoke$1('FileSystem.stat', uri);
+  return await invoke$2('FileSystem.stat', uri);
 };
 const readDirWithFileTypesExternal = async path => {
   // TODO when file is local,
@@ -2238,7 +2279,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$1('FileSystem.readDirWithFileTypes', path);
+  const content = await invoke$2('FileSystem.readDirWithFileTypes', path);
   return content;
 };
 const remove$3 = async (protocol, path) => {
@@ -2381,7 +2422,7 @@ const sendPort = async ({
   port,
   url
 }) => {
-  await invokeAndTransfer$1('IpcParent.create', {
+  await invokeAndTransfer$2('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
     port,
@@ -2422,7 +2463,7 @@ const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
 };
 
 const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+  await invokeAndTransfer$2('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
 
 const getPort = async type => {
@@ -2582,7 +2623,7 @@ const createNodeRpc = async ({
 
 const send = async port => {
   const initialCommand = 'FileSystem.handleMessagePort';
-  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, initialCommand);
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, initialCommand);
 };
 const launchFileSystemProcess = async () => {
   const rpc = await TransferMessagePortRpcParent.create({
@@ -2663,7 +2704,7 @@ const getEnabledProviders = () => {
 
 const confirm = message => {
   string(message);
-  const result = invoke$1('ConfirmPrompt.prompt', message);
+  const result = invoke$2('ConfirmPrompt.prompt', message);
   return result;
 };
 
@@ -2675,7 +2716,7 @@ const showQuickPick = async ({
 }) => {
   const rawPicks = await getPicks();
   const picks = rawPicks.map(toPick);
-  return invoke$1(ExtensionHostQuickPickShow, picks);
+  return invoke$2(ExtensionHostQuickPickShow, picks);
 };
 
 const {
@@ -2760,13 +2801,13 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/377d2ba/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/6e66e1c/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
 const set$8 = async (url, contentSecurityPolicy) => {
   const pathName = new URL(url).pathname;
-  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+  await invoke$2('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
 
 /**
@@ -2921,62 +2962,16 @@ const getProtocol = uri => {
   return '';
 };
 
-const createWebViewIpc = async webView => {
-  const {
-    origin,
-    uid
-  } = webView;
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  const rpcPromise = MessagePortRpcParent.create({
-    commandMap: {},
-    isMessagePortOpen: false,
-    messagePort: port2
-  });
-  const portType = 'test';
-  await invokeAndTransfer$1('WebView.setPort', uid, port1, origin, portType);
-  // TODO maybe don't send a message port only to get object url?
-  // TODO dispose rpc to avoid memory leak
-  const rpc = await rpcPromise;
-  return rpc;
-};
-
-const webViews = Object.create(null);
-const webViewProviders = Object.create(null);
-const getProvider = providerId => {
-  return webViewProviders[providerId];
-};
-const setProvider = (providerId, provider) => {
-  webViewProviders[providerId] = provider;
-};
-const getWebView = id => {
-  return webViews[id];
-};
-const setWebView = (id, webView) => {
-  webViews[id] = webView;
-};
-const getWebViews$1 = () => {
-  return webViews;
-};
+// @ts-ignore
 
-// TODO if webViewId is provided,
-// 1. read file as blob
-// 2. send blob to webview
-// 3. create objecturl in webview
-// 4. send back objecturl to extension host worker
-// 5. provide objectUrl to extension
+const {
+  invoke: invoke$1,
+  invokeAndTransfer: invokeAndTransfer$1,
+  setFactory
+} = createLazyRpc(ExtensionManagementWorker);
 
 const getRemoteUrlForWebView = async (uri, options = {}) => {
-  // TODO webviews should be stored in iframe worker
-  const webView = getWebView(options.webViewId);
-  if (!webView) {
-    throw new Error(`webview ${options.webViewId} not found`);
-  }
-  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
-  const objectUrl = await rpc.invoke('createObjectUrl', blob);
-  return objectUrl;
+  return await invoke$1('Extensions.getRemoteUrlForWebView', uri, options);
 };
 
 const isFileProtocol = protocol => {
@@ -3013,16 +3008,12 @@ const getRemoteUrl$1 = async (uri, options = {}) => {
     return getRemoteUrlForWebView(uri, options);
   }
   if (uri.startsWith('html://')) {
-    const url = await invoke$1('Blob.getSrc', uri);
+    const url = await invoke$2('Blob.getSrc', uri);
     return url;
   }
   throw new Error(`unsupported platform for remote url`);
 };
 
-const state$8 = {
-  webExtensions: []
-};
-
 const getJson = async url => {
   try {
     const response = await fetch(url);
@@ -3038,9 +3029,9 @@ const getJson = async url => {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/377d2ba' !== 'undefined') {
+  if (typeof '/6e66e1c' !== 'undefined') {
     // @ts-ignore
-    return '/377d2ba';
+    return '/6e66e1c';
   }
   if (platform === Electron) {
     return '../../../../..';
@@ -3056,10 +3047,10 @@ const getWebExtensions = async () => {
 };
 
 const getSharedProcessExtensions = () => {
-  return invoke$1(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+  return invoke$2(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
 };
 const doGetExtensions = async () => {
-  const meta = state$8.webExtensions;
+  const meta = await invoke$1('Extensions.getDynamicWebExtensions');
   if (platform === Web) {
     const webExtensions = await getWebExtensions();
     return [...webExtensions, ...meta];
@@ -3193,7 +3184,8 @@ const getEnabledProviderIds = async (scheme, root) => {
 };
 const getIconDefinitions = async providerId => {
   const extensions = await getExtensions();
-  const allExtensions = [...extensions, ...state$8.webExtensions];
+  const webextensions = await invoke$5(`Extensions.getDynamicWebExtensions`);
+  const allExtensions = [...extensions, ...webextensions];
   for (const extension of allExtensions) {
     const id = extension.id.split('.');
     const shortId = id[1];
@@ -3278,6 +3270,24 @@ const {
   }
 });
 
+const webViews = Object.create(null);
+const webViewProviders = Object.create(null);
+const getProvider = providerId => {
+  return webViewProviders[providerId];
+};
+const setProvider = (providerId, provider) => {
+  webViewProviders[providerId] = provider;
+};
+const getWebView = id => {
+  return webViews[id];
+};
+const setWebView = (id, webView) => {
+  webViews[id] = webView;
+};
+const getWebViews$1 = () => {
+  return webViews;
+};
+
 // TODO pass uuid to allow having multiple webviews open at the same time
 
 /**
@@ -3364,7 +3374,7 @@ const getWorkspaceFolder = path => {
 };
 const handleWorkspaceRefresh = async () => {
   // @ts-ignore
-  await invoke$3('Layout.handleWorkspaceRefresh');
+  await invoke$4('Layout.handleWorkspaceRefresh');
 };
 
 class FormattingError extends Error {
@@ -4137,39 +4147,8 @@ const activateExtension = async (extension, absolutePath, activationEvent) => {
   // console.info('activated', path)
 };
 
-const NewLine = '\n';
-const Slash$1 = '/';
-
-const interExtensionId = path => {
-  const slashIndex = path.lastIndexOf(Slash$1);
-  return path.slice(slashIndex + 1);
-};
-
-const getWebExtensionManifest = async (path, manifestPath) => {
-  try {
-    const manifest = await getJson(manifestPath);
-    return {
-      ...manifest,
-      path,
-      uri: path
-    };
-  } catch (error) {
-    const id = interExtensionId(path);
-    throw new VError(error, `Failed to load extension manifest for ${id}`);
-  }
-};
-
-const getWebManifestPath = path => {
-  const manifestPath = `${path}/extension.json`;
-  return manifestPath;
-};
-
 const addWebExtension = async path => {
-  const manifestPath = getWebManifestPath(path);
-  const manifest = await getWebExtensionManifest(path, manifestPath);
-  // TODO avoid mutation if possible
-  state$8.webExtensions.push(manifest);
-  clear();
+  const manifest = await invoke$1('Extensions.addWebExtension', path);
   return manifest;
 };
 
@@ -4184,9 +4163,11 @@ const applyBulkReplacement = async (files, ranges, replacement) => {
 };
 
 const addCssStyleSheet = (id, css) => {
-  return invoke$1('Css.addCssStyleSheet', id, css);
+  return invoke$2('Css.addCssStyleSheet', id, css);
 };
 
+const NewLine = '\n';
+
 const warn = (...args) => {
   console.warn(...args);
 };
@@ -4617,10 +4598,10 @@ const GetColorThemeCssCachedIndexedDb = {
 };
 
 const getText$1 = key => {
-  return invoke$1('LocalStorage.getText', key);
+  return invoke$2('LocalStorage.getText', key);
 };
 const setText = (key, value) => {
-  return invoke$1('LocalStorage.setText', key, value);
+  return invoke$2('LocalStorage.setText', key, value);
 };
 
 const getCacheKey = colorThemeId => {
@@ -4655,7 +4636,7 @@ const GetColorThemeCssCachedNoop = {
 };
 
 const get = key => {
-  return invoke$1('Preferences.get', key);
+  return invoke$2('Preferences.get', key);
 };
 
 const getCacheFn = config => {
@@ -4681,7 +4662,7 @@ const getColorThemeCssCached = async (colorThemeId, getData) => {
 };
 
 const readJson = url => {
-  return invoke$1('FileSystem.readJson', url);
+  return invoke$2('FileSystem.readJson', url);
 };
 
 const dirname = (pathSeparator, path) => {
@@ -4763,7 +4744,7 @@ const getMetaThemeColor = colorThemeJson => {
 };
 
 const setThemeColor = async themeColor => {
-  await invoke$1(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+  await invoke$2(/* 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
@@ -4799,7 +4780,7 @@ const watch = async id => {
     return;
   }
   state$1.watchedTheme = id;
-  await invoke$1('ExtensionHost.watchColorTheme', id);
+  await invoke$2('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
   const preferredColorTheme = get('workbench.colorTheme');
@@ -4872,46 +4853,18 @@ const createWebView3 = async ({
 };
 
 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
-  // the iframe worker creates a messagechannel and sends one messageport to the webview
-  // and the other messageport to the webworker. This enables direct communication via
-  // the two message ports
-
-  // TODO have a way so that the worker already includes the webview api and the extension
-  // host subworker doesn't need to import the other file
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name: rpcInfo.name,
-    port,
-    raw: true,
-    url: rpcInfo.url
-  });
+  await invokeAndTransfer$1('Extensions.createWebViewWorkerRpc2', rpcInfo, port);
 };
 
 /**
  * @deprecated use createWebViewWorkerRpc2 which passes the worker url as a parameter
  */
 const createWebViewWorkerRpc = 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
-  // the iframe worker creates a messagechannel and sends one messageport to the webview
-  // and the other messageport to the webworker. This enables direct communication via
-  // the two message ports
-
-  // TODO have a way so that the worker already includes the webview api and the extension
-  // host subworker doesn't need to import the other file
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    name: rpcInfo.name,
-    port,
-    raw: true,
-    url: extensionHostSubWorkerUrl
-  });
+  await invokeAndTransfer$1('Extensions.createWebViewWorkerRpc', rpcInfo, port);
 };
 
 const executeExternalCommand = (method, ...params) => {
-  return invoke$1(method, ...params);
+  return invoke$2(method, ...params);
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -4979,7 +4932,7 @@ const mockExec = () => {
   try {
     // @ts-ignore
     api.exec = async (command, args, options) => {
-      const result = await invoke$1('Test.executeMockExecFunction', command, args, options);
+      const result = await invoke$2('Test.executeMockExecFunction', command, args, options);
       const {
         exitCode,
         stderr,
@@ -5005,7 +4958,7 @@ const mockRpc = () => {
     try {
       return {
         async invoke(method, ...params) {
-          const result = await invoke$1('Test.executeMockRpcFunction', options.name, method, ...params);
+          const result = await invoke$2('Test.executeMockRpcFunction', options.name, method, ...params);
           return result;
         }
       };
@@ -5420,71 +5373,16 @@ const getExtension = async id => {
   return undefined;
 };
 
-const findMatchingIconThemeExtension = (extensions, iconThemeId) => {
-  for (const extension of extensions) {
-    if (extension && extension.iconThemes) {
-      for (const iconTheme of extension.iconThemes) {
-        if (iconTheme.id === iconThemeId) {
-          return {
-            ...iconTheme,
-            extensionPath: extension.path
-          };
-        }
-      }
-    }
-  }
-  return undefined;
-};
-
-const getIconThemeUrl = iconThemeId => {
-  return `${assetDir}/extensions/builtin.${iconThemeId}/icon-theme.json`;
-};
-
 const getIconThemeJson$1 = async iconThemeId => {
-  if (platform === Web) {
-    const url = getIconThemeUrl(iconThemeId);
-    const json = await getJson(url);
-    return {
-      extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`,
-      json
-    };
-  }
-  for (const webExtension of state$8.webExtensions) {
-    if (webExtension.iconThemes) {
-      for (const iconTheme of webExtension.iconThemes) {
-        // TODO handle error when icon theme path is not of type string
-        const iconThemeUrl = `${webExtension.path}/${iconTheme.path}`;
-        const json = await getJson(iconThemeUrl);
-        return {
-          extensionPath: webExtension.path,
-          json
-        };
-      }
-    }
-  }
-  const extensions = await getExtensions();
-  const iconTheme = findMatchingIconThemeExtension(extensions, iconThemeId);
-  if (!iconTheme) {
-    return undefined;
-  }
-  const iconThemePath = `${iconTheme.extensionPath}/${iconTheme.path}`;
-  const iconThemeJson = await readJson(iconThemePath);
-  return {
-    extensionPath: iconTheme.extensionPath,
-    json: iconThemeJson
-  };
+  throw new Error(`getIconThemeJson is deprecated. Use icon-theme-worker instead`);
 };
 
 const getIconThemeJson = async iconThemeId => {
-  return getIconThemeJson$1(iconThemeId);
+  return getIconThemeJson$1();
 };
 
-const getRpcInfo = rpcId => {
-  const info = get$8(rpcId);
-  if (!info) {
-    throw new Error(`Rpc not found ${rpcId}`);
-  }
-  return info;
+const getRpcInfo = async rpcId => {
+  return await invoke$1('Extensions.getRpcInfo', rpcId);
 };
 
 const emptyStatus = {
@@ -5571,7 +5469,7 @@ const handleMessagePort = async (port, rpcId) => {
 };
 
 const handleIconThemeChange = async () => {
-  await invoke$1('IconTheme.handleIconThemeChange');
+  await invoke$2('IconTheme.handleIconThemeChange');
 };
 
 const initialIconTheme = undefined;
@@ -6326,7 +6224,18 @@ const commandMap = {
   'WebViews.getWebViews': getWebViews
 };
 
+const launchExtensionManagementWorker = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToExtensionManagementWorker(port, 0);
+    }
+  });
+  return rpc;
+};
+
 const listen = async () => {
+  setFactory(launchExtensionManagementWorker);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });