@lvce-editor/static-server 0.42.2 → 0.42.3

package/static/{5b44eb6 → 22c7835}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -89,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$a = {
+const state$b = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -101,19 +101,19 @@ const state$a = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$a.textDocuments[textDocumentId] = textDocument;
+  state$b.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$a.onDidSaveTextDocumentListeners;
+  return state$b.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$a.onWillChangeEditorListeners;
+  return state$b.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$a.onDidChangeTextDocumentListeners;
+  return state$b.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$a.textDocuments[textDocumentId];
+  return state$b.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -303,7 +303,7 @@ const syncIncremental = (textDocumentId, changes) => {
   textDocument.text = before + syntheticChange.inserted + after;
   runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
 };
-const get$5 = textDocumentId => {
+const get$6 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
@@ -535,7 +535,7 @@ const registerMethod = ({
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
-      const textDocument = get$5(textDocumentId);
+      const textDocument = get$6(textDocumentId);
       if (!textDocument) {
         throw new Error(`textDocument with id ${textDocumentId} not found`);
       }
@@ -670,12 +670,12 @@ const executeOrganizeImports = async uid => {
   if (!organizeImportsAction) {
     return [];
   }
-  const textDocument = get$5(uid);
+  const textDocument = get$6(uid);
   const edits = await organizeImportsAction.execute(textDocument);
   return edits;
 };
 
-const state$9 = {
+const state$a = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -698,10 +698,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$9.commands) {
+    if (command.id in state$a.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$9.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}`);
@@ -709,7 +709,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$9.commands[id];
+    const command = state$a.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -748,40 +748,40 @@ const {
   }]
 });
 
-const state$8 = {
+const state$9 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$8.configuration[key] ?? '';
+  return state$9.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$8.configuration = preferences;
+  state$9.configuration = preferences;
 };
 
-const state$7 = {
+const state$8 = {
   rpc: undefined
 };
 const invoke$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+  const rpc = state$8.rpc;
   return rpc.invoke(method, ...params);
 };
 const send$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+  const rpc = state$8.rpc;
   return rpc.send(method, ...params);
 };
 const invokeAndTransfer$1 = (method, ...params) => {
-  const rpc = state$7.rpc;
+  const rpc = state$8.rpc;
   return rpc.invokeAndTransfer(method, ...params);
 };
 const setRpc = rpc => {
-  state$7.rpc = rpc;
+  state$8.rpc = rpc;
 };
 
-const state$6 = {
+const state$7 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$6.debugProviderMap[id];
+  const provider = state$7.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError(`no debug provider "${id}" found`);
@@ -792,7 +792,7 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$6.debugProviderMap[debugProvider.id] = debugProvider;
+  state$7.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -948,7 +948,7 @@ const exec = async (command, args, options) => {
 };
 
 const fileSystemProviderMap = Object.create(null);
-const get$4 = protocol => {
+const get$5 = protocol => {
   const provider = fileSystemProviderMap[protocol];
   if (!provider) {
     // @ts-ignore
@@ -971,7 +971,7 @@ const registerFileSystemProvider = fileSystemProvider => {
 };
 const readDirWithFileTypes = async (protocol, path) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.readDirWithFileTypes(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -979,7 +979,7 @@ const readDirWithFileTypes = async (protocol, path) => {
 };
 const readFile = async (protocol, path) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.readFile(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1007,7 +1007,7 @@ const readDirWithFileTypesExternal = async path => {
 };
 const writeFile = async (protocol, uri, content) => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return await provider.writeFile(uri, content);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1015,7 +1015,7 @@ const writeFile = async (protocol, uri, content) => {
 };
 const getPathSeparator = protocol => {
   try {
-    const provider = get$4(protocol);
+    const provider = get$5(protocol);
     return provider.pathSeparator;
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1115,478 +1115,525 @@ const WebSocket$1 = 5;
 const ElectronMessagePort = 6;
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1 = 7;
 
-const getModule$3 = method => {
-  switch (method) {
-    case WebSocket$1:
-      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
-    case ElectronMessagePort:
-      return Promise.resolve().then(function () { return IpcParentWithNode; });
-    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
-      return Promise.resolve().then(function () { return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug; });
-    default:
-      throw new Error('unexpected ipc type');
-  }
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
 };
-
-const create$9 = async ({
-  method,
-  ...options
-}) => {
-  try {
-    const module = await getModule$3(method);
-    // @ts-ignore
-    const rawIpc = await module.create(options);
-    // @ts-ignore
-    const ipc = module.wrap(rawIpc);
-    return ipc;
-  } catch (error) {
-    throw new VError(error, `Failed to create ipc`);
-  }
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-
-const JsonRpc = 1;
-
-const getModule$2 = method => {
-  switch (method) {
-    case JsonRpc:
-      return Promise.resolve().then(function () { return RpcParentWithJsonRpc; });
-    default:
-      throw new Error('unexpected rpc type');
-  }
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-
-const create$8 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$2(method);
-  // @ts-ignore
-  const rpc = module.create(options);
-  return rpc;
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
 };
-
-const defaultExecute$1 = () => {
-  throw new Error('not implemented');
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-const createNodeRpc = async ({
-  path,
-  execute = defaultExecute$1,
-  name = ''
-}) => {
-  try {
-    string(path);
-    fn(execute);
-    const ipc = await create$9({
-      method: ElectronMessagePort,
-      type: 'extension-host-helper-process',
-      name
-    });
-    const rpc = await create$8({
-      ipc,
-      method: JsonRpc,
-      execute
-    });
-    await rpc.invoke('LoadFile.loadFile', path);
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create node rpc`);
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
   }
+  return false;
 };
-
-const confirm = message => {
-  string(message);
-  const result = invoke$1('ConfirmPrompt.prompt', message);
-  return result;
-};
-
-const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
-
-const showQuickPick = async ({
-  getPicks,
-  toPick
-}) => {
-  const rawPicks = await getPicks();
-  const picks = rawPicks.map(toPick);
-  return invoke$1(ExtensionHostQuickPickShow, picks);
-};
-
-const {
-  registerReferenceProvider,
-  executeReferenceProvider,
-  executefileReferenceProvider,
-  reset: reset$4
-} = create$a({
-  name: 'Reference',
-  resultShape: {
-    type: Array$1,
-    items: {
-      type: Object$1
-    }
-  },
-  additionalMethodNames: [
-  // @ts-ignore
-  {
-    name: 'fileReference',
-    methodName: 'provideFileReferences',
-    resultShape: {
-      type: Array$1,
-      items: {
-        type: Object$1
-      }
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
     }
-  }]
-});
-
-const {
-  registerRenameProvider,
-  executeRenameProvider,
-  executeprepareRenameProvider,
-  reset: reset$3
-} = create$a({
-  name: 'Rename',
-  resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  },
-  additionalMethodNames: [
-  // @ts-ignore
-  {
-    name: 'prepareRename',
-    methodName: 'prepareRename',
-    resultShape: {
-      type: Object$1,
-      allowUndefined: true
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
     }
-  }]
-});
-
-const getExtensionHostSubWorkerUrl = () => {
-  return '/5b44eb6/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
-};
-const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
-
-const set$3 = async (url, contentSecurityPolicy) => {
-  const pathName = new URL(url).pathname;
-  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
-};
-
-const rpcs$1 = Object.create(null);
-const add$1 = (id, rpc) => {
-  rpcs$1[id] = rpc;
-};
-const get$3 = id => {
-  return rpcs$1[id];
-};
-
-const registry = Object.create(null);
-const rpcs = Object.create(null);
-const register$1 = (id, execute) => {
-  registry[id] = execute;
-};
-const acquire = id => {
-  const fn = registry[id];
-  delete registry[id];
-  return fn;
+    return;
+  }
 };
-const get$2 = id => {
-  return rpcs[id];
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
 };
-const set$2 = (id, rpc) => {
-  rpcs[id] = rpc;
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
 };
-
-const createRpcWithId$1 = async id => {
-  const fn = acquire(id);
-  const info = get$3(id);
-  if (!info) {
-    throw new Error(`rpc with id ${id} not found`);
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
   }
-  const ipc = await create$9({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
-    name: info.name
-  });
-  const newRpc = await create$8({
-    ipc,
-    method: JsonRpc,
-    execute: fn
-  });
-  await newRpc.invoke('LoadFile.loadFile', info.url);
-  set$2(id, newRpc);
-  return newRpc;
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$1 = '\n';
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-
-const getOrCreateRpc = async id => {
-  const rpc = get$2(id);
-  if (!rpc) {
-    set$2(id, createRpcWithId$1(id));
-  }
-  return get$2(id);
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
 };
-const createRpcWithId = ({
-  id,
-  execute
-}) => {
-  string(id);
-  register$1(id, execute);
-  const lazyRpc = {
-    async invoke(method, ...params) {
-      const rpc = await getOrCreateRpc(id);
-      return rpc.invoke(method, ...params);
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
     }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
   };
-  return lazyRpc;
 };
-
-const defaultExecute = () => {
-  throw new Error('not implemented');
+const splitLines$2 = lines => {
+  return lines.split(NewLine$1);
 };
-
-/**
- *
- * @deprecated
- */
-const createLegacyRpc = async ({
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  string(url);
-  string(name);
-  fn(execute);
-  if (contentSecurityPolicy) {
-    await set$3(url, contentSecurityPolicy);
-  }
-  const ipc = await create$9({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
-    name
-  });
-  const rpc = await create$8({
-    ipc,
-    method: JsonRpc,
-    execute
-  });
-  await rpc.invoke('LoadFile.loadFile', url);
-  return rpc;
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
 };
-const createRpc$1 = ({
-  id,
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  try {
-    if (id) {
-      string(id);
-      return createRpcWithId({
-        id,
-        execute
-      });
-    }
-    return createLegacyRpc({
-      url,
-      name,
-      execute,
-      contentSecurityPolicy
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to create webworker rpc`);
-  }
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
-
-const {
-  registerSelectionProvider,
-  executeSelectionProvider,
-  reset: reset$2
-} = create$a({
-  name: 'Selection',
-  resultShape: {
-    allowUndefined: true,
-    type: Array$1,
-    items: {
-      type: 'number'
-    }
-  }
-});
-
-const state$5 = {
-  providers: Object.create(null)
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$2(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
 };
-const registerSourceControlProvider = provider => {
-  state$5.providers[provider.id] = provider;
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
-const getFilesFromProvider = provider => {
-  return provider.getChangedFiles();
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$2(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
+  };
 };
-const getChangedFiles = async providerId => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  const changedFiles = await getFilesFromProvider(provider);
-  const flattenedChangedFiles = changedFiles;
-  return flattenedChangedFiles;
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const getFileBefore = async (providerId, uri) => {
-  string(providerId);
-  string(uri);
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  return provider.getFileBefore(uri);
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const getGroupsFromProvider = async (provider, cwd) => {
-  if (provider.getGroups) {
-    return provider.getGroups(cwd);
-  }
-  if (provider.getChangedFiles) {
-    const files = await provider.getChangedFiles();
-    const groups = [{
-      id: 'changes',
-      label: 'Changes',
-      items: files
-    }];
-    return groups;
-  }
-  throw new Error('source control provider is missing required function getGroups');
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
 };
-const getGroups = async (providerId, cwd) => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
-  }
-  const groups = await getGroupsFromProvider(provider, cwd);
-  return groups;
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
 };
-const acceptInput = async (providerId, value) => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
-  }
-  await provider.acceptInput(value);
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
 };
-const add = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
-    return;
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
   }
-  // @ts-ignore
-  await provider.add(path);
-};
-const discard = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
-    return;
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
   }
-  // @ts-ignore
-  await provider.discard(path);
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$2(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: actualMessage,
+    code: '',
+    stack: rest
+  };
 };
-const getEnabledProviderIds = async (scheme, root) => {
-  string(scheme);
-  string(root);
-  const providers = Object.values(state$5.providers);
-  const enabledIds = [];
-  for (const provider of providers) {
-    // @ts-ignore
-    if (typeof provider.isActive !== 'function') {
-      continue;
-    }
-    // @ts-ignore
-    const isActive = await provider.isActive(scheme, root);
-    if (isActive) {
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
       // @ts-ignore
-      enabledIds.push(provider.id);
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
     }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
   }
-  return enabledIds;
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
 };
-
-const {
-  registerTabCompletionProvider,
-  executeTabCompletionProvider,
-  reset: reset$1
-} = create$a({
-  name: 'TabCompletion',
-  resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  }
-});
-
-const state$4 = {
-  textSearchProviders: Object.create(null)
+const listen$8 = ({
+  port
+}) => {
+  return port;
 };
-const registerTextSearchProvider = textSearchProvider => {
-  try {
-    if (!textSearchProvider) {
-      throw new Error('textSearchProvider is not defined');
-    }
-    if (!textSearchProvider.scheme) {
-      throw new Error('textSearchProvider is missing scheme');
-    }
-    state$4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
-  } catch (error) {
-    throw new VError(error, 'Failed to register text search provider');
-  }
+const signal$9 = port => {
+  port.postMessage(readyMessage);
 };
-const executeTextSearchProvider = async (scheme, query) => {
-  try {
-    const textSearchProvider = state$4.textSearchProviders[scheme];
-    if (!textSearchProvider) {
-      throw new Error(`No text search provider for ${scheme} found`);
-    }
-    const results = await textSearchProvider.provideTextSearchResults(query);
-    return results;
-  } catch (error) {
-    throw new VError(error, 'Failed to execute text search provider');
+class IpcChildWithMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
   }
-};
-
-const {
-  registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider,
-  reset
-} = create$a({
-  name: 'TypeDefinition',
-  resultShape: {
-    allowUndefined: true,
-    type: Object$1,
-    properties: {
-      uri: {
-        type: String$1
-      },
-      startOffset: {
-        type: Number
-      },
-      endOffset: {
-        type: Number
-      }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$g = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$9,
+  wrap: wrap$g
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
     }
   }
-});
-
-const RE_PROTOCOL = /^([a-z\-]+):\/\//;
-const getProtocol = uri => {
-  const protocolMatch = uri.match(RE_PROTOCOL);
-  if (protocolMatch) {
-    return protocolMatch[1];
+  onClose(callback) {
+    // ignore
   }
-  return '';
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$e = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
-
-const getPortTuple = () => {
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
+};
+const Error$3 = 1;
+const Open = 2;
+const Close = 3;
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
   };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$2 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$2,
+  signal: signal$1,
+  wrap: wrap$5
+};
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse$1 = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close,
+    error: Error$3
+  });
+};
+const create$9 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+let IpcParentWithWebSocket$1 = class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse$1(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+};
+const wrap$1 = webSocket => {
+  return new IpcParentWithWebSocket$1(webSocket);
+};
+const IpcParentWithWebSocket$1$1 = {
+  __proto__: null,
+  create: create$9,
+  wrap: wrap$1
 };
 
 const Two = '2.0';
@@ -1598,10 +1645,10 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$1 = id => {
+const get$4 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -1617,7 +1664,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
@@ -1645,7 +1692,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine$1 = '\n';
+const NewLine = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -1691,39 +1738,39 @@ const constructError = (message, type, name) => {
   return new ErrorConstructor(message);
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+  return string.indexOf(NewLine, startIndex);
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + parentStack;
+    parentStack = error.message + NewLine + parentStack;
   }
   return parentStack;
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+const joinLines = lines => {
+  return lines.join(NewLine);
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$2 = lines => {
-  return lines.split(NewLine$1);
+const splitLines$1 = lines => {
+  return lines.split(NewLine);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
+  const currentStack = joinLines(splitLines$1(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$1 + currentStack;
+    restoredError.stack = parentStack + NewLine + currentStack;
     return restoredError;
   }
   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$1 + error.data.stack + NewLine$1 + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -1774,7 +1821,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$4(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -1813,7 +1860,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (message, error) => {
+const create$1$2 = (message, error) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -1824,9 +1871,9 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+  return create$1$2(message, errorProperty);
 };
-const create$7 = (message, result) => {
+const create$8 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -1835,7 +1882,7 @@ const create$7 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -1936,7 +1983,7 @@ const invokeAndTransfer = (ipc, method, ...params) => {
 };
 
 const commands = Object.create(null);
-const register = commandMap => {
+const register$1 = commandMap => {
   Object.assign(commands, commandMap);
 };
 const getCommand = key => {
@@ -1950,98 +1997,237 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
-const requiresSocket$2 = () => {
+const createRpc$1 = ipc => {
+  const rpc = {
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer(ipc, method, ...params);
+    }
+  };
+  return rpc;
+};
+const requiresSocket = () => {
   return false;
 };
-const preparePrettyError$2 = error => {
+const preparePrettyError = error => {
   return error;
 };
-const logError$2 = error => {
+const logError = () => {
   // handled by renderer worker
 };
-const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$2, logError$2, requiresSocket$2);
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
-
-const handleIpc$1 = ipc => {
-  ipc.addEventListener('message', handleMessage$1);
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$6$1 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const ipc = await listen$1(IpcChildWithMessagePort$1, {
+    port: messagePort
+  });
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const MessagePortRpcClient = {
+  __proto__: null,
+  create: create$6$1
+};
+const create$5$1 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$5$1
+};
+const create$1$1 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const WebSocketRpcParent = {
+  __proto__: null,
+  create: create$1$1
+};
+const create$7 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc$1(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$7
 };
 
-const createWebViewIpc = async webView => {
+const getPortTuple = () => {
   const {
-    uid,
-    origin
-  } = webView;
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+
+const sendPort = async ({
+  url,
+  name,
+  port
+}) => {
+  await invokeAndTransfer$1('IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url,
+    name,
+    raw: true,
+    port
+  });
+};
+const create$6 = async ({
+  url,
+  name,
+  commandMap
+}) => {
+  string(url);
+  string(name);
   const {
     port1,
     port2
   } = getPortTuple();
-  const promise = new Promise(resolve => {
-    port2.onmessage = resolve;
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    isMessagePortOpen: true,
+    commandMap
   });
-  const portType = 'test';
-  await invokeAndTransfer$1('WebView.setPort', uid, port1, origin, portType);
-  const event = await promise;
-  // @ts-ignore
-  if (event.data !== 'ready') {
-    throw new Error('unexpected first message');
-  }
-  const ipc = {
-    addEventListener(type, listener) {
-      const that = this;
-      const wrapped = event => {
-        const actualEvent = {
-          target: that,
-          data: event.data
-        };
-        listener(actualEvent);
-      };
-      port2.addEventListener(type, wrapped);
-    },
-    dispose() {},
-    send(message) {
-      port2.postMessage(message);
-    }
-  };
-  // TODO maybe don't send a message port only to get object url?
-  // TODO dispose ipc to avoid memory leak
-  handleIpc$1(ipc);
-  return ipc;
+  // TODO rpc module should start port
+  port2.start();
+  await sendPort({
+    url,
+    name,
+    port: port1
+  });
+  const rpc = await rpcPromise;
+  return rpc;
 };
 
-const webViews = Object.create(null);
-const webViewProviders = Object.create(null);
-const getProvider = providerId => {
-  return webViewProviders[providerId];
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$6
 };
-const setProvider = (providerId, provider) => {
-  webViewProviders[providerId] = provider;
+
+const sendMessagePortToElectron = async (port, initialCommand) => {
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
-const getWebView = id => {
-  return webViews[id];
+
+const getPort = async type => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
+  return port2;
 };
-const setWebView = (id, webView) => {
-  webViews[id] = webView;
+const create$5 = async ({
+  type
+}) => {
+  const port = await getPort();
+  const rpc = await MessagePortRpcParent.create({
+    messagePort: port,
+    isMessagePortOpen: true,
+    commandMap: {}
+  });
+  return rpc;
 };
-const getWebViews = () => {
-  return webViews;
+
+const IpcParentWithElectronMessagePort = {
+  __proto__: null,
+  create: create$5
 };
 
-// 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 getWebSocketProtocol = () => {
+  return location.protocol === 'https:' ? 'wss:' : 'ws:';
+};
 
-const getRemoteUrlForWebView = async (uri, options = {}) => {
-  const webView = getWebView(options.webViewId);
-  if (!webView) {
-    throw new Error(`webview ${options.webViewId} not found`);
-  }
-  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
-  const objectUrl = await invoke(ipc, 'createObjectUrl', blob);
-  return objectUrl;
+const getWebSocketUrl = type => {
+  const wsProtocol = getWebSocketProtocol();
+  return `${wsProtocol}//${location.host}/websocket/${type}`;
+};
+
+const create$4 = async ({
+  type
+}) => {
+  string(type);
+  const wsUrl = getWebSocketUrl(type);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await WebSocketRpcParent.create({
+    webSocket,
+    commandMap: {}
+  });
+  return rpc;
+};
+
+const IpcParentWithWebSocket = {
+  __proto__: null,
+  create: create$4
 };
 
 const Electron = 'electron';
@@ -2069,790 +2255,820 @@ const getPlatform = () => {
 };
 const platform = Remote; // TODO tree-shake this out in production
 
-const getRemoteUrl = async (uri, options = {}) => {
-  // TODO uri should always have protocol
-  // then ask file system provider for remote url, for example disk file system provider or html file system provider
-  const protocol = getProtocol(uri);
-  if (platform === Remote && !protocol) {
-    if (uri.startsWith('/')) {
-      return `/remote${uri}`;
-    }
-    return `/remote/${uri}`;
-  }
-  if (platform === Electron && !protocol) {
-    if (uri.startsWith('/')) {
-      return `/remote${uri}`;
-    }
-    return `/remote/${uri}`;
-  }
-  if (options.webViewId) {
-    return getRemoteUrlForWebView(uri, options);
-  }
-  if (uri.startsWith('html://')) {
-    const url = await invoke$1('Blob.getSrc', uri);
-    return url;
+const getModule$1 = platform => {
+  switch (platform) {
+    case Remote:
+      return IpcParentWithWebSocket;
+    default:
+      return IpcParentWithElectronMessagePort;
   }
-  throw new Error(`unsupported platform for remote url`);
+};
+const create$3 = async ({
+  type,
+  raw
+}) => {
+  const module = getModule$1(platform);
+  const rpc = await module.create({
+    type
+  });
+  return rpc;
 };
 
-const waitForFirstMessage$1 = async port => {
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port.onmessage = resolve;
-  const firstMessage = await promise;
-  return firstMessage;
+const IpcParentWithNode = {
+  __proto__: null,
+  create: create$3
 };
 
-// TODO pass uuid to allow having multiple webviews open at the same time
-const createWebView = async (providerId, port, uri, uid, origin) => {
-  const provider = getProvider(providerId);
-  if (!provider) {
-    throw new Error(`webview provider ${providerId} not found`);
+const getModule = method => {
+  switch (method) {
+    case WebSocket$1:
+      return IpcParentWithWebSocket;
+    case ElectronMessagePort:
+      return IpcParentWithNode;
+    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
+      return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug;
+    default:
+      throw new Error('unexpected ipc type');
   }
+};
 
-  // TODO cancel promise when webview is disposed before sending message
-  // TODO handle case when webview doesn't send ready message
-  // TODO handle error
-  await waitForFirstMessage$1(port);
+const create$2 = async ({
+  method,
+  ...options
+}) => {
+  try {
+    const module = getModule(method);
+    // @ts-ignore
+    const rpc = await module.create(options);
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create rpc`);
+  }
+};
 
-  // TODO use ipc module
-  const handlePortMessage = async event => {
-    const {
-      data,
-      target
-    } = event;
-    const {
-      method,
-      params,
-      id
-    } = data;
-    if (id && !method) {
-      resolve(id, data);
-      return;
+const defaultExecute = () => {
+  throw new Error('not implemented');
+};
+const createNodeRpc = async ({
+  path,
+  execute = defaultExecute,
+  name = ''
+}) => {
+  try {
+    string(path);
+    fn(execute);
+    const rpc = await create$2({
+      method: ElectronMessagePort,
+      type: 'extension-host-helper-process',
+      name,
+      commandMap: {}
+    });
+    await rpc.invoke('LoadFile.loadFile', path);
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create node rpc`);
+  }
+};
+
+const confirm = message => {
+  string(message);
+  const result = invoke$1('ConfirmPrompt.prompt', message);
+  return result;
+};
+
+const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
+
+const showQuickPick = async ({
+  getPicks,
+  toPick
+}) => {
+  const rawPicks = await getPicks();
+  const picks = rawPicks.map(toPick);
+  return invoke$1(ExtensionHostQuickPickShow, picks);
+};
+
+const {
+  registerReferenceProvider,
+  executeReferenceProvider,
+  executefileReferenceProvider,
+  reset: reset$4
+} = create$a({
+  name: 'Reference',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
     }
-    if (provider && provider.commands && provider.commands[method]) {
-      const fn = provider.commands[method];
-      const result = await fn(...params);
-      if (id && method) {
-        target.postMessage({
-          jsonrpc: '2.0',
-          id,
-          result
-        });
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'fileReference',
+    methodName: 'provideFileReferences',
+    resultShape: {
+      type: Array$1,
+      items: {
+        type: Object$1
       }
     }
-  };
-  port.onmessage = handlePortMessage;
-  const rpc = {
-    uri,
-    provider,
-    uid,
-    origin,
-    async invoke(method, ...params) {
-      const {
-        id,
-        promise
-      } = registerPromise();
-      port.postMessage({
-        jsonrpc: '2.0',
-        id,
-        method,
-        params
-      });
-      const result = await promise;
-      if (result.error) {
-        throw new Error(`Error: ${result.error.message}`);
-      }
-      return result.result;
+  }]
+});
+
+const {
+  registerRenameProvider,
+  executeRenameProvider,
+  executeprepareRenameProvider,
+  reset: reset$3
+} = create$a({
+  name: 'Rename',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'prepareRename',
+    methodName: 'prepareRename',
+    resultShape: {
+      type: Object$1,
+      allowUndefined: true
     }
-  };
-  // TODO allow creating multiple webviews per provider
-  setWebView(providerId, rpc);
-};
-const load = async (providerId, savedState) => {
-  const rpc = getWebView(providerId);
-  await rpc.provider.create(rpc, rpc.uri, savedState);
-};
-const disposeWebView = id => {
-  // TODO race condition
-  // const webView=webViews[id]
-};
-const registerWebViewProvider = provider => {
-  setProvider(provider.id, provider);
+  }]
+});
+
+const getExtensionHostSubWorkerUrl = () => {
+  return '/22c7835/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
-const getWebViewInfo = providerId => {
-  const webView = getWebView(providerId);
-  return {
-    uid: webView.uid,
-    origin: webView.origin,
-    uri: webView.uri
-  };
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+const set$2 = async (url, contentSecurityPolicy) => {
+  const pathName = new URL(url).pathname;
+  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
 
-const createWorker = async ({
-  method,
+/**
+ *
+ * @deprecated
+ */
+const createLegacyRpc = async ({
   url,
-  name
+  name,
+  execute,
+  commandMap = {},
+  contentSecurityPolicy
 }) => {
-  string(method);
   string(url);
   string(name);
-  const ipc = create$9({
+  object(commandMap);
+  if (contentSecurityPolicy) {
+    await set$2(url, contentSecurityPolicy);
+  }
+  const rpc = await create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url,
-    name
+    url: extensionHostSubWorkerUrl,
+    name,
+    commandMap
   });
-  return ipc;
+  if (execute) {
+    // deprecated
+    // @ts-ignore
+    rpc.ipc.execute = execute;
+  }
+  await rpc.invoke('LoadFile.loadFile', url);
+  return rpc;
 };
 
-const state$3 = {
-  workspacePath: ''
+const rpcs$1 = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs$1[id] = rpc;
 };
-const setWorkspacePath = path => {
-  state$3.workspacePath = path;
+const get$3 = id => {
+  return rpcs$1[id];
 };
-const getWorkspaceFolder = path => {
-  return state$3.workspacePath;
+
+const registry = Object.create(null);
+const rpcs = Object.create(null);
+const register = (id, execute) => {
+  registry[id] = execute;
+};
+const get$2 = id => {
+  return rpcs[id];
+};
+const set$1 = (id, rpc) => {
+  rpcs[id] = rpc;
 };
 
-class FormattingError extends Error {
-  constructor(message, codeFrame) {
-    super(message);
+const createRpcWithId$1 = async (id, commandMap, execute) => {
+  const info = get$3(id);
+  if (!info) {
+    throw new Error(`rpc with id ${id} not found`);
+  }
+  const rpc = await create$2({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name: info.name,
+    commandMap,
+    isMessagePortOpen: true
+  });
+  if (execute) {
     // @ts-ignore
-    this.codeFrame = codeFrame;
-    this.name = 'FormattingError';
+    rpc.ipc.execute = execute;
   }
-}
+  await rpc.invoke('LoadFile.loadFile', info.url);
+  set$1(id, rpc);
+  return rpc;
+};
 
-const File$2 = 1;
-const Match = 2;
+const getOrCreateRpc = async (id, commandMap, execute) => {
+  const rpc = get$2(id);
+  if (!rpc) {
+    set$1(id, createRpcWithId$1(id, commandMap, execute));
+  }
+  return get$2(id);
+};
+const createRpcWithId = ({
+  id,
+  commandMap,
+  execute
+}) => {
+  string(id);
+  register(id, commandMap);
+  const lazyRpc = {
+    async invoke(method, ...params) {
+      const rpc = await getOrCreateRpc(id, commandMap, execute);
+      return rpc.invoke(method, ...params);
+    }
+  };
+  return lazyRpc;
+};
 
-const TextSearchResultType = {
-  __proto__: null,
-  File: File$2,
-  Match
+const createRpc = ({
+  id,
+  url,
+  name,
+  commandMap,
+  contentSecurityPolicy,
+  execute
+}) => {
+  try {
+    if (execute && !commandMap) {
+      console.info(`[extension-host-worker] The rpc execute function is deprecated. Use the commandMap property instead.`);
+    }
+    commandMap ||= {};
+    if (id) {
+      string(id);
+      return createRpcWithId({
+        id,
+        execute,
+        commandMap
+      });
+    }
+    return createLegacyRpc({
+      url,
+      name,
+      execute,
+      commandMap,
+      contentSecurityPolicy
+    });
+  } catch (error) {
+    throw new VError(error, `Failed to create webworker rpc`);
+  }
 };
 
-const api = {
-  // Ajax
-  getJson: getJson$1,
-  // Brace Completion
-  registerBraceCompletionProvider: registerBraceCompletionProvider,
-  executeBraceCompletionProvider: executeBraceCompletionProvider,
-  // Closing Tag
-  registerClosingTagProvider: registerClosingTagProvider,
-  executeClosingTagProvider: executeClosingTagProvider,
-  // Code Action
-  registerCodeActionsProvider: registerCodeActionProvider,
-  // Command
-  registerCommand: registerCommand,
-  executeCommand: executeCommand,
-  // Completion
-  registerCompletionProvider: registerCompletionProvider,
-  executeCompletionProvider: executeCompletionProvider,
-  EditorCompletionType,
-  // Configuration
-  getConfiguration: getConfiguration,
-  // Debug
-  registerDebugProvider: registerDebugProvider,
-  // Definition
-  registerDefinitionProvider: registerDefinitionProvider,
-  executeDefinitionProvider: executeDefinitionProvider,
-  // Diagnostic
-  registerDiagnosticProvider: registerDiagnosticProvider,
-  executeDiagnosticProvider: executeDiagnosticProvider,
-  // Dialog
-  showInformationMessage: showInformationMessage,
-  // Env
-  env: env,
-  // Errors
-  FormattingError,
-  VError,
-  // Exec
-  exec: exec,
-  // File System
-  registerFileSystemProvider: registerFileSystemProvider,
-  readFile: readFileExternal,
-  readDirWithFileTypes: readDirWithFileTypesExternal,
-  // Formatting
-  registerFormattingProvider: registerFormattingProvider,
-  executeFormattingProvider: executeFormattingProvider,
-  // Get Offset
-  getOffset: getOffset,
-  // Get Position
-  getPosition: getPosition,
-  // Hover
-  registerHoverProvider: registerHoverProvider,
-  executeHoverProvider: executeHoverProvider,
-  // Rpc
-  createRpc: createRpc$1,
-  createNodeRpc: createNodeRpc,
-  // Implementation
-  registerImplementationProvider: registerImplementationProvider,
-  executeImplementationProvider: executeImplementationProvider,
-  // Prompt
-  confirm: confirm,
-  // QuickPick
-  showQuickPick: showQuickPick,
-  // Rename
-  registerRenameProvider: registerRenameProvider,
-  executeRenameProvider: executeRenameProvider,
-  executePrepareRenameProvider: executeprepareRenameProvider,
-  // Reference
-  registerReferenceProvider: registerReferenceProvider,
-  executeReferenceProvider: executeReferenceProvider,
-  // Selection
-  registerSelectionProvider: registerSelectionProvider,
-  executeSelectionProvider: executeSelectionProvider,
-  // Source Control
-  registerSourceControlProvider: registerSourceControlProvider,
-  // Tab Completion
-  registerTabCompletionProvider: registerTabCompletionProvider,
-  executeTabCompletionProvider: executeTabCompletionProvider,
-  // Text Document
-  getTextFromTextDocument: getText$1,
-  // Text Search
-  registerTextSearchProvider: registerTextSearchProvider,
-  executeTextSearchProvider: executeTextSearchProvider,
-  TextSearchResultType,
-  // Type Definition
-  registerTypeDefinitionProvider: registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
-  // Url
-  getRemoteUrl: getRemoteUrl,
-  // Webview
-  registerWebViewProvider: registerWebViewProvider,
-  // Worker
-  createWorker: createWorker,
-  // Workspace
-  getWorkspaceFolder: getWorkspaceFolder
-};
-
-const handleError = async error => {
-  console.error(error);
-};
-
-/**
- * @param {ErrorEvent} event
- */
-const handleUnhandledError = async event => {
-  try {
-    event.preventDefault();
-    await handleError(event.error);
-  } catch {
-    console.error(event.error);
+const {
+  registerSelectionProvider,
+  executeSelectionProvider,
+  reset: reset$2
+} = create$a({
+  name: 'Selection',
+  resultShape: {
+    allowUndefined: true,
+    type: Array$1,
+    items: {
+      type: 'number'
+    }
   }
-};
-
-const processName = `extension host worker`;
+});
 
-const getOutput = error => {
-  const errorMessage = error && error.message ? error.message : String(error);
-  const prefix = `[${processName}] Unhandled Rejection: ${errorMessage}`;
-  if (error && error.stack) {
-    return `${prefix}\n${error.stack}`;
-  }
-  return prefix;
-};
-const handleUnhandledRejection = event => {
-  if (event instanceof PromiseRejectionEvent) {
-    event.preventDefault();
-    const output = getOutput(event.reason);
-    console.error(output);
-    return;
-  }
-  const output = getOutput(event);
-  console.error(output);
+const state$6 = {
+  providers: Object.create(null)
 };
-
-const state$2 = {
-  /**
-   * @type {any[]}
-   */
-  errors: []
+const registerSourceControlProvider = provider => {
+  state$6.providers[provider.id] = provider;
 };
-const addError = error => {
-  // @ts-ignore
-  state$2.errors.push(error);
+const getFilesFromProvider = provider => {
+  return provider.getChangedFiles();
 };
-const hasRecentErrors = () => {
-  return state$2.errors.length > 0;
+const getChangedFiles = async providerId => {
+  const provider = state$6.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  const changedFiles = await getFilesFromProvider(provider);
+  const flattenedChangedFiles = changedFiles;
+  return flattenedChangedFiles;
 };
-const getRecentError = () => {
+const getFileBefore = async (providerId, uri) => {
+  string(providerId);
+  string(uri);
+  const provider = state$6.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  return provider.getFileBefore(uri);
 };
-
-const handleContentSecurityPolicyViolation = event => {
-  const {
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
-  } = event;
-  addError({
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
-  });
+const getGroupsFromProvider = async (provider, cwd) => {
+  if (provider.getGroups) {
+    return provider.getGroups(cwd);
+  }
+  if (provider.getChangedFiles) {
+    const files = await provider.getChangedFiles();
+    const groups = [{
+      id: 'changes',
+      label: 'Changes',
+      items: files
+    }];
+    return groups;
+  }
+  throw new Error('source control provider is missing required function getGroups');
 };
-
-const setStackTraceLimit = (errorConstructor, value) => {
-  if (errorConstructor.stackTraceLimit && errorConstructor.stackTraceLimit < value) {
-    errorConstructor.stackTraceLimit = value;
+const getGroups = async (providerId, cwd) => {
+  const provider = state$6.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
   }
+  const groups = await getGroupsFromProvider(provider, cwd);
+  return groups;
 };
-
-const setup = ({
-  global,
-  errorConstructor
-}) => {
-  setStackTraceLimit(errorConstructor, 20);
-  global.onerror ||= handleUnhandledError;
-  global.onunhandledrejection ||= handleUnhandledRejection;
-  if ('SecurityPolicyViolationEvent' in self) {
-    global.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
+const acceptInput = async (providerId, value) => {
+  const provider = state$6.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
   }
-  // @ts-ignore
-  global.vscode = api;
+  await provider.acceptInput(value);
 };
-
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
+const add = async path => {
+  const provider = Object.values(state$6.providers)[0];
+  if (!provider) {
     return;
   }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
+  // @ts-ignore
+  await provider.add(path);
+};
+const discard = async path => {
+  const provider = Object.values(state$6.providers)[0];
+  if (!provider) {
     return;
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
+  // @ts-ignore
+  await provider.discard(path);
+};
+const getEnabledProviderIds = async (scheme, root) => {
+  string(scheme);
+  string(root);
+  const providers = Object.values(state$6.providers);
+  const enabledIds = [];
+  for (const provider of providers) {
+    // @ts-ignore
+    if (typeof provider.isActive !== 'function') {
+      continue;
     }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
+    // @ts-ignore
+    const isActive = await provider.isActive(scheme, root);
+    if (isActive) {
+      // @ts-ignore
+      enabledIds.push(provider.id);
     }
-    return;
   }
+  return enabledIds;
 };
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
-};
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
+
+const {
+  registerTabCompletionProvider,
+  executeTabCompletionProvider,
+  reset: reset$1
+} = create$a({
+  name: 'TabCompletion',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  }
+});
+
+const state$5 = {
+  textSearchProviders: Object.create(null)
 };
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
-};
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
+const registerTextSearchProvider = textSearchProvider => {
+  try {
+    if (!textSearchProvider) {
+      throw new Error('textSearchProvider is not defined');
+    }
+    if (!textSearchProvider.scheme) {
+      throw new Error('textSearchProvider is missing scheme');
     }
+    state$5.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+  } catch (error) {
+    throw new VError(error, 'Failed to register text search provider');
   }
-  return false;
-};
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+const executeTextSearchProvider = async (scheme, query) => {
+  try {
+    const textSearchProvider = state$5.textSearchProviders[scheme];
+    if (!textSearchProvider) {
+      throw new Error(`No text search provider for ${scheme} found`);
+    }
+    const results = await textSearchProvider.provideTextSearchResults(query);
+    return results;
+  } catch (error) {
+    throw new VError(error, 'Failed to execute text search provider');
   }
-}
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine = '\n';
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine);
-};
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
-};
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
-  };
 };
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+
+const {
+  registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider,
+  reset
+} = create$a({
+  name: 'TypeDefinition',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {
+      uri: {
+        type: String$1
+      },
+      startOffset: {
+        type: Number
+      },
+      endOffset: {
+        type: Number
+      }
+    }
+  }
+});
+
+const RE_PROTOCOL = /^([a-z\-]+):\/\//;
+const getProtocol = uri => {
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (protocolMatch) {
+    return protocolMatch[1];
+  }
+  return '';
 };
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+
+const createWebViewIpc = async webView => {
+  const {
+    uid,
+    origin
+  } = webView;
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    isMessagePortOpen: false,
+    commandMap: {}
+  });
+  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 isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+
+const webViews = Object.create(null);
+const webViewProviders = Object.create(null);
+const getProvider = providerId => {
+  return webViewProviders[providerId];
 };
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines$1(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
-  const relevantLines = lines.slice(startIndex, endIndex);
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
-  return relevantMessage;
+const setProvider = (providerId, provider) => {
+  webViewProviders[providerId] = provider;
 };
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
+const getWebView = id => {
+  return webViews[id];
 };
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+const setWebView = (id, webView) => {
+  webViews[id] = webView;
 };
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
+const getWebViews = () => {
+  return webViews;
 };
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
+
+// 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 getRemoteUrlForWebView = async (uri, options = {}) => {
+  const webView = getWebView(options.webViewId);
+  if (!webView) {
+    throw new Error(`webview ${options.webViewId} not found`);
   }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+  const [rpc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
+  const objectUrl = await rpc.invoke('createObjectUrl', blob);
+  return objectUrl;
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(lines),
-      rest: []
-    };
+
+const getRemoteUrl = async (uri, options = {}) => {
+  // TODO uri should always have protocol
+  // then ask file system provider for remote url, for example disk file system provider or html file system provider
+  const protocol = getProtocol(uri);
+  if (platform === Remote && !protocol) {
+    if (uri.startsWith('/')) {
+      return `/remote${uri}`;
+    }
+    return `/remote/${uri}`;
   }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
+  if (platform === Electron && !protocol) {
+    if (uri.startsWith('/')) {
+      return `/remote${uri}`;
     }
+    return `/remote/${uri}`;
   }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
+  if (options.webViewId) {
+    return getRemoteUrlForWebView(uri, options);
   }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
+  if (uri.startsWith('html://')) {
+    const url = await invoke$1('Blob.getSrc', uri);
+    return url;
   }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
+  throw new Error(`unsupported platform for remote url`);
+};
+
+// TODO pass uuid to allow having multiple webviews open at the same time
+const createWebView = async (providerId, port, uri, uid, origin, webView) => {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    throw new Error(`webview provider ${providerId} not found`);
   }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
+
+  // TODO cancel promise when webview is disposed before sending message
+  // TODO handle case when webview doesn't send ready message
+
+  const rpc = await MessagePortRpcParent.create({
+    messagePort: port,
+    isMessagePortOpen: false,
+    commandMap: provider.commands || {}
+  });
+  const outer = {
+    uri,
+    provider,
+    uid,
+    origin,
+    webView,
+    async invoke(method, ...params) {
+      return rpc.invoke(method, ...params);
+    }
   };
+  // TODO allow creating multiple webviews per provider
+  setWebView(providerId, outer);
 };
-let IpcError$1 = class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-  }
-};
-const readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
+const disposeWebView = id => {
+  // TODO race condition
+  // const webView=webViews[id]
 };
-const listen$8 = ({
-  port
-}) => {
-  return port;
+const registerWebViewProvider = provider => {
+  setProvider(provider.id, provider);
 };
-const signal$8 = port => {
-  port.postMessage(readyMessage);
+const getWebViewInfo = providerId => {
+  const webView = getWebView(providerId);
+  return {
+    uid: webView.uid,
+    origin: webView.origin,
+    uri: webView.uri
+  };
 };
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$f = port => {
-  return new IpcChildWithMessagePort(port);
+
+const createWorker = async ({
+  method,
+  url,
+  name
+}) => {
+  string(method);
+  string(url);
+  string(name);
+  const rpc = create$2({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url,
+    name
+  });
+  return rpc;
 };
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$8,
-  signal: signal$8,
-  wrap: wrap$f
+
+const state$4 = {
+  workspacePath: ''
 };
-const listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
+const setWorkspacePath = path => {
+  state$4.workspacePath = path;
 };
-const signal$7 = global => {
-  global.postMessage(readyMessage);
+const getWorkspaceFolder = path => {
+  return state$4.workspacePath;
 };
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
+
+class FormattingError extends Error {
+  constructor(message, codeFrame) {
+    super(message);
     // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
+    this.codeFrame = codeFrame;
+    this.name = 'FormattingError';
   }
 }
-const wrap$e = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
+
+const File$2 = 1;
+const Match = 2;
+
+const TextSearchResultType = {
   __proto__: null,
-  listen: listen$7,
-  signal: signal$7,
-  wrap: wrap$e
+  File: File$2,
+  Match
 };
-const withResolvers$1 = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
+
+const api = {
+  // Ajax
+  getJson: getJson$1,
+  // Brace Completion
+  registerBraceCompletionProvider: registerBraceCompletionProvider,
+  executeBraceCompletionProvider: executeBraceCompletionProvider,
+  // Closing Tag
+  registerClosingTagProvider: registerClosingTagProvider,
+  executeClosingTagProvider: executeClosingTagProvider,
+  // Code Action
+  registerCodeActionsProvider: registerCodeActionProvider,
+  // Command
+  registerCommand: registerCommand,
+  executeCommand: executeCommand,
+  // Completion
+  registerCompletionProvider: registerCompletionProvider,
+  executeCompletionProvider: executeCompletionProvider,
+  EditorCompletionType,
+  // Configuration
+  getConfiguration: getConfiguration,
+  // Debug
+  registerDebugProvider: registerDebugProvider,
+  // Definition
+  registerDefinitionProvider: registerDefinitionProvider,
+  executeDefinitionProvider: executeDefinitionProvider,
+  // Diagnostic
+  registerDiagnosticProvider: registerDiagnosticProvider,
+  executeDiagnosticProvider: executeDiagnosticProvider,
+  // Dialog
+  showInformationMessage: showInformationMessage,
+  // Env
+  env: env,
+  // Errors
+  FormattingError,
+  VError,
+  // Exec
+  exec: exec,
+  // File System
+  registerFileSystemProvider: registerFileSystemProvider,
+  readFile: readFileExternal,
+  readDirWithFileTypes: readDirWithFileTypesExternal,
+  // Formatting
+  registerFormattingProvider: registerFormattingProvider,
+  executeFormattingProvider: executeFormattingProvider,
+  // Get Offset
+  getOffset: getOffset,
+  // Get Position
+  getPosition: getPosition,
+  // Hover
+  registerHoverProvider: registerHoverProvider,
+  executeHoverProvider: executeHoverProvider,
+  // Rpc
+  createRpc: createRpc,
+  createNodeRpc: createNodeRpc,
+  // Implementation
+  registerImplementationProvider: registerImplementationProvider,
+  executeImplementationProvider: executeImplementationProvider,
+  // Prompt
+  confirm: confirm,
+  // QuickPick
+  showQuickPick: showQuickPick,
+  // Rename
+  registerRenameProvider: registerRenameProvider,
+  executeRenameProvider: executeRenameProvider,
+  executePrepareRenameProvider: executeprepareRenameProvider,
+  // Reference
+  registerReferenceProvider: registerReferenceProvider,
+  executeReferenceProvider: executeReferenceProvider,
+  // Selection
+  registerSelectionProvider: registerSelectionProvider,
+  executeSelectionProvider: executeSelectionProvider,
+  // Source Control
+  registerSourceControlProvider: registerSourceControlProvider,
+  // Tab Completion
+  registerTabCompletionProvider: registerTabCompletionProvider,
+  executeTabCompletionProvider: executeTabCompletionProvider,
+  // Text Document
+  getTextFromTextDocument: getText$1,
+  // Text Search
+  registerTextSearchProvider: registerTextSearchProvider,
+  executeTextSearchProvider: executeTextSearchProvider,
+  TextSearchResultType,
+  // Type Definition
+  registerTypeDefinitionProvider: registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
+  // Url
+  getRemoteUrl: getRemoteUrl,
+  // Webview
+  registerWebViewProvider: registerWebViewProvider,
+  // Worker
+  createWorker: createWorker,
+  // Workspace
+  getWorkspaceFolder: getWorkspaceFolder
 };
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers$1();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
+
+const handleError = async error => {
+  console.error(error);
 };
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$7(parentIpcRaw);
-  const parentIpc = wrap$e(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError$1('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
+
+/**
+ * @param {ErrorEvent} event
+ */
+const handleUnhandledError = async event => {
+  try {
+    event.preventDefault();
+    await handleError(event.error);
+  } catch {
+    console.error(event.error);
   }
-  return globalThis;
 };
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
+
+const processName = `extension host worker`;
+
+const getOutput = error => {
+  const errorMessage = error && error.message ? error.message : String(error);
+  const prefix = `[${processName}] Unhandled Rejection: ${errorMessage}`;
+  if (error && error.stack) {
+    return `${prefix}\n${error.stack}`;
   }
-}
-const wrap$d = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
+  return prefix;
 };
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$d
+const handleUnhandledRejection = event => {
+  if (event instanceof PromiseRejectionEvent) {
+    event.preventDefault();
+    const output = getOutput(event.reason);
+    console.error(output);
+    return;
+  }
+  const output = getOutput(event);
+  console.error(output);
 };
 
-const createRpc = ipc => {
-  const rpc = {
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    }
-  };
-  return rpc;
-};
-const requiresSocket$1 = () => {
-  return false;
+const state$3 = {
+  /**
+   * @type {any[]}
+   */
+  errors: []
 };
-const preparePrettyError$1 = error => {
-  return error;
+const addError = error => {
+  // @ts-ignore
+  state$3.errors.push(error);
 };
-const logError$1 = () => {
-  // handled by renderer worker
+const hasRecentErrors = () => {
+  return state$3.errors.length > 0;
 };
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, actualRequiresSocket);
+const getRecentError = () => {
 };
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
+
+const handleContentSecurityPolicyViolation = event => {
+  const {
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  } = event;
+  addError({
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  });
 };
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
+
+const setStackTraceLimit = (errorConstructor, value) => {
+  if (errorConstructor.stackTraceLimit && errorConstructor.stackTraceLimit < value) {
+    errorConstructor.stackTraceLimit = value;
   }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
 };
-const create$6 = async ({
-  commandMap
+
+const setup = ({
+  global,
+  errorConstructor
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$6
+  setStackTraceLimit(errorConstructor, 20);
+  global.onerror ||= handleUnhandledError;
+  global.onunhandledrejection ||= handleUnhandledRejection;
+  if ('SecurityPolicyViolationEvent' in self) {
+    global.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
+  }
+  // @ts-ignore
+  global.vscode = api;
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -2894,7 +3110,7 @@ const WorkspaceSetPath = 'Workspace.setWorkspacePath';
 const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
 const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
 
-const create$5 = () => {
+const create$1 = () => {
   return {
     finished: false
   };
@@ -2920,7 +3136,7 @@ const getExtensionId = extension => {
   return '<unknown>';
 };
 
-const getUrlPrefix = extensionPath => {
+const getUrlPrefix = (platform, extensionPath) => {
   if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
     return extensionPath;
   }
@@ -2939,7 +3155,7 @@ const handleRpcInfos = extension => {
       return;
     }
     const rpcs = extension.rpc;
-    const urlPrefix = getUrlPrefix(extension.path);
+    const urlPrefix = getUrlPrefix(platform, extension.path);
     if (!rpcs) {
       return;
     }
@@ -3018,9 +3234,9 @@ class BabelParseError extends SyntaxError {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/5b44eb6' !== 'undefined') {
+  if (typeof '/22c7835' !== 'undefined') {
     // @ts-ignore
-    return '/5b44eb6';
+    return '/22c7835';
   }
   if (platform === Electron) {
     return '../../../../..';
@@ -3319,7 +3535,7 @@ const activate = async (extension, absolutePath) => {
     string(absolutePath);
     const module = await importScript(absolutePath);
     handleRpcInfos(extension);
-    const token = create$5();
+    const token = create$1();
     try {
       await Promise.race([module.activate(extension), rejectAfterTimeout(activationTimeout, token)]);
     } catch (error) {
@@ -3392,7 +3608,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$5.providers);
+  const providers = Object.values(state$6.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -3413,29 +3629,11 @@ const handleBeforeUnload = () => {
   console.log('before unload');
 };
 
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ModuleWorkerWithMessagePort = 4;
-
-// @ts-ignore
-const getModule$1 = method => {
-  switch (method) {
-    case ModuleWorker:
-      return IpcChildWithModuleWorker$1;
-    case ModuleWorkerWithMessagePort:
-      return IpcChildWithModuleWorkerAndMessagePort$1;
-    case MessagePort$1:
-      return IpcChildWithMessagePort$1;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const handleMessagePort = port => {
-  const module = getModule$1(MessagePort$1);
-  const ipc = module.wrap(port);
-  handleIpc$1(ipc);
-  ipc.send('ready');
+const handleMessagePort = async port => {
+  await MessagePortRpcClient.create({
+    messagePort: port,
+    commandMap: {}
+  });
 };
 
 const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
@@ -3459,7 +3657,7 @@ function promisifyRequest(request) {
       request.removeEventListener('error', error);
     };
     const success = () => {
-      resolve(wrap$4(request.result));
+      resolve(wrap(request.result));
       unlisten();
     };
     const error = () => {
@@ -3509,7 +3707,7 @@ let idbProxyTraps = {
       }
     }
     // Else transform whatever we get back.
-    return wrap$4(target[prop]);
+    return wrap(target[prop]);
   },
   set(target, prop, value) {
     target[prop] = value;
@@ -3538,13 +3736,13 @@ function wrapFunction(func) {
       // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
       // the original object.
       func.apply(unwrap(this), args);
-      return wrap$4(this.request);
+      return wrap(this.request);
     };
   }
   return function (...args) {
     // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
     // the original object.
-    return wrap$4(func.apply(unwrap(this), args));
+    return wrap(func.apply(unwrap(this), args));
   };
 }
 function transformCachableValue(value) {
@@ -3556,7 +3754,7 @@ function transformCachableValue(value) {
   // Return the same value back if we're not going to transform it.
   return value;
 }
-function wrap$4(value) {
+function wrap(value) {
   // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
   // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
   if (value instanceof IDBRequest) return promisifyRequest(value);
@@ -3588,10 +3786,10 @@ function openDB(name, version, {
   terminated
 } = {}) {
   const request = indexedDB.open(name, version);
-  const openPromise = wrap$4(request);
+  const openPromise = wrap(request);
   if (upgrade) {
     request.addEventListener('upgradeneeded', event => {
-      upgrade(wrap$4(request.result), event.oldVersion, event.newVersion, wrap$4(request.transaction), event);
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
     });
   }
   if (blocked) {
@@ -3692,7 +3890,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state$1 = {
+const state$2 = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -3710,7 +3908,7 @@ const isDataCloneError = error => {
 
 const getDb$1 = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$1.dbVersion, {
+  const db = await openDB('session', state$2.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -3725,8 +3923,8 @@ const getDb$1 = async () => {
   return db;
 };
 const getDbMemoized$1 = async () => {
-  state$1.cachedDb ||= await getDb$1();
-  return state$1.cachedDb;
+  state$2.cachedDb ||= await getDb$1();
+  return state$2.cachedDb;
 };
 const saveValue = async (storeId, value) => {
   try {
@@ -3765,7 +3963,7 @@ const getValuesByIndexName = async (storeId, indexName, only) => {
   return objects;
 };
 const getHandleDb = async () => {
-  const db = await openDB('handle', state$1.dbVersion, {
+  const db = await openDB('handle', state$2.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         // @ts-ignore
@@ -3785,16 +3983,17 @@ const getHandle$1 = async uri => {
   return handle;
 };
 
+const storeId = 'lvce-keyvalue';
+
 // TODO high memory usage in idb because of transactionDoneMap
 
-const state = {
+const state$1 = {
   databases: Object.create(null),
   dbVersion: 2,
   cachedDb: undefined
 };
-const storeId = 'lvce-keyvalue';
 const getDb = async () => {
-  const db = await openDB(storeId, state.dbVersion, {
+  const db = await openDB(storeId, state$1.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains(storeId)) {
         await db.createObjectStore(storeId, {
@@ -3806,9 +4005,12 @@ const getDb = async () => {
   return db;
 };
 const getDbMemoized = async () => {
-  state.cachedDb ||= await getDb();
-  return state.cachedDb;
+  state$1.cachedDb ||= await getDb();
+  return state$1.cachedDb;
 };
+
+// TODO high memory usage in idb because of transactionDoneMap
+
 const set = async (key, value) => {
   try {
     const db = await getDbMemoized();
@@ -3817,16 +4019,56 @@ const set = async (key, value) => {
     throw new VError(error, 'Failed to save value to indexed db');
   }
 };
-const get = async key => {
+const get$1 = async key => {
   try {
     const db = await getDbMemoized();
-    const value = db.get(storeId, key);
+    const value = await db.get(storeId, key);
     return value;
   } catch (error) {
     throw new VError(error, 'Failed to get value from indexed db');
   }
 };
 
+const iframeWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/iframe-worker/dist/iframeWorkerMain.js`;
+
+const get = key => {
+  return invoke$1('Preferences.get', key);
+};
+
+const getConfiguredIframeWorkerUrl = async () => {
+  let configuredWorkerUrl = (await get('develop.iframeWorkerPath')) || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || iframeWorkerUrl;
+  return configuredWorkerUrl;
+};
+
+const state = {
+  id: 0
+};
+const create = () => {
+  return ++state.id;
+};
+
+const launchIframeWorker = async () => {
+  const configuredWorkerUrl = getConfiguredIframeWorkerUrl();
+  const name = 'Iframe Worker';
+  const id = create();
+  const rpc = await create$2({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    name,
+    url: configuredWorkerUrl,
+    id
+  });
+  return rpc;
+};
+
+const loadWebView = async (providerId, savedState) => {
+  const rpc = getWebView(providerId);
+  await rpc.provider.create(rpc, rpc.uri, savedState);
+};
+
 const serializeWebView = async webView => {
   if (webView && webView.provider && webView.provider.saveState) {
     const saved = await webView.provider.saveState();
@@ -4137,10 +4379,11 @@ const textSearch = async (scheme, root, query) => {
 };
 
 const commandMap = {
+  'ExtensionHost.launchIframeWorker': launchIframeWorker,
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
   'IndexedDb.addHandle': addHandle,
-  'IndexedDb.get': get,
+  'IndexedDb.get': get$1,
   'IndexedDb.getHandle': getHandle$1,
   'IndexedDb.getValues': getValues,
   'IndexedDb.getValuesByIndexName': getValuesByIndexName,
@@ -4163,7 +4406,7 @@ const commandMap = {
   ['ExtensionHostDebug.stepOver']: stepOver,
   ['ExtensionHostWebView.create']: createWebView,
   ['ExtensionHostWebView.dispose']: disposeWebView,
-  ['ExtensionHostWebView.load']: load,
+  ['ExtensionHostWebView.load']: loadWebView,
   ['ExtensionHostWebView.getWebViewInfo']: getWebViewInfo,
   ['HandleBeforeUnload.handleBeforeUnload']: handleBeforeUnload,
   ['HandleMessagePort.handleMessagePort']: handleMessagePort,
@@ -4224,326 +4467,3 @@ const main = async () => {
 };
 
 main();
-
-const Error$1 = 1;
-const Open = 2;
-const Close = 3;
-
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-
-const getFirstEvent = (eventTarget, eventMap) => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      eventTarget.removeEventListener(event, listenerMap[event]);
-    }
-    resolve(value);
-  };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        type,
-        event
-      });
-    };
-    eventTarget.addEventListener(event, listener);
-    listenerMap[event] = listener;
-  }
-  return promise;
-};
-
-/**
- *
- * @param {WebSocket} webSocket
- * @returns
- */
-const waitForWebSocketToBeOpen = webSocket => {
-  return getFirstEvent(webSocket, {
-    open: Open,
-    close: Close,
-    error: Error$1
-  });
-};
-
-const getWebSocketProtocol = () => {
-  return location.protocol === 'https:' ? 'wss:' : 'ws:';
-};
-
-const getWebSocketUrl = type => {
-  const wsProtocol = getWebSocketProtocol();
-  return `${wsProtocol}//${location.host}/websocket/${type}`;
-};
-
-class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
-  }
-}
-
-const stringifyCompact = value => {
-  return JSON.stringify(value);
-};
-
-const create$4 = async ({
-  type
-}) => {
-  string(type);
-  const wsUrl = getWebSocketUrl(type);
-  const webSocket = new WebSocket(wsUrl);
-  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
-  // @ts-ignore
-  if (firstWebSocketEvent.type === Error$1) {
-    throw new IpcError(`WebSocket connection error`);
-  }
-  // @ts-ignore
-  if (firstWebSocketEvent.type === Close) {
-    throw new IpcError(`Websocket connection was closed`);
-  }
-  return webSocket;
-};
-const wrap$3 = webSocket => {
-  return {
-    /**
-     * @type {any}
-     */
-    handleMessage: undefined,
-    webSocket,
-    get onmessage() {
-      return this.handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-ignore
-        this.handleMessage = event => {
-          // TODO why are some events not instance of message event?
-          if (event instanceof MessageEvent) {
-            const message = JSON.parse(event.data);
-            // @ts-ignore
-            listener(message);
-          } else {
-            // @ts-ignore
-            listener(event);
-          }
-        };
-      } else {
-        // @ts-ignore
-        this.handleMessage = null;
-      }
-      this.webSocket.onmessage = this.handleMessage;
-    },
-    send(message) {
-      if (this.webSocket.readyState !== webSocket.OPEN) {
-        // @ts-ignore
-        throw new VError(`Failed to send message: WebSocket is not open`);
-      }
-      const stringifiedMessage = stringifyCompact(message);
-      this.webSocket.send(stringifiedMessage);
-    }
-  };
-};
-
-const IpcParentWithWebSocket = {
-  __proto__: null,
-  create: create$4,
-  wrap: wrap$3
-};
-
-const getModule = async () => {
-  switch (platform) {
-    case Remote:
-      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
-    default:
-      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; });
-  }
-};
-const create$3 = async ({
-  type,
-  raw
-}) => {
-  const module = await getModule();
-  const rawIpc = await module.create({
-    type
-  });
-  if (raw) {
-    return rawIpc;
-  }
-  return {
-    module,
-    rawIpc
-  };
-};
-const wrap$2 = ({
-  module,
-  rawIpc
-}) => {
-  return module.wrap(rawIpc);
-};
-
-const IpcParentWithNode = {
-  __proto__: null,
-  create: create$3,
-  wrap: wrap$2
-};
-
-const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
-
-const create$2 = async ({
-  url,
-  name
-}) => {
-  string(url);
-  string(name);
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url,
-    name,
-    raw: true,
-    port: port1
-  });
-  return port2;
-};
-const wrap$1 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    handleMessage: undefined,
-    get onmessage() {
-      return this.handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-ignore
-        this.handleMessage = event => {
-          // TODO why are some events not instance of message event?
-          if (event instanceof MessageEvent) {
-            const message = event.data;
-            // @ts-ignore
-            listener(message, event);
-          } else {
-            // @ts-ignore
-
-            listener(event);
-          }
-        };
-      } else {
-        // @ts-ignore
-        this.handleMessage = null;
-      }
-      this.port.onmessage = this.handleMessage;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
-};
-
-const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
-  __proto__: null,
-  create: create$2,
-  wrap: wrap$1
-};
-
-const preparePrettyError = error => {
-  return error;
-};
-const logError = error => {
-  // handled by renderer worker
-};
-const requiresSocket = () => {
-  return false;
-};
-const create$1 = ({
-  ipc,
-  execute
-}) => {
-  object(ipc);
-  fn(execute);
-  const handleMessage = async message => {
-    return handleJsonRpcMessage(ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket);
-  };
-  ipc.onmessage = handleMessage;
-  return {
-    ipc,
-    invoke(method, ...params) {
-      return invoke(this.ipc, method, ...params);
-    }
-  };
-};
-
-const RpcParentWithJsonRpc = {
-  __proto__: null,
-  create: create$1
-};
-
-const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
-};
-
-const getPort = async type => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
-  return port2;
-};
-const create = async ({
-  type
-}) => {
-  const port = await getPort();
-  return port;
-};
-const wrap = port => {
-  let handleMessage;
-  return {
-    get onmessage() {
-      return handleMessage;
-    },
-    set onmessage(listener) {
-      let handleMessage;
-      if (listener) {
-        handleMessage = event => {
-          listener(event.data);
-        };
-      } else {
-        handleMessage = null;
-      }
-      port.onmessage = handleMessage;
-    },
-    send(message) {
-      port.postMessage(message);
-    }
-  };
-};
-
-const IpcParentWithElectronMessagePort = {
-  __proto__: null,
-  create,
-  wrap
-};