@lvce-editor/extension-host-worker 2.2.0 → 2.3.0

package/dist/extensionHostWorkerMain.js

@@ -571,7 +571,7 @@ const registerMethod = ({
     }
   };
 };
-const create$a = ({
+const create$c = ({
   name,
   resultShape,
   executeKey = '',
@@ -623,7 +623,7 @@ const {
   registerBraceCompletionProvider,
   executeBraceCompletionProvider,
   reset: reset$9
-} = create$a({
+} = create$c({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -633,7 +633,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$a({
+} = create$c({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -645,7 +645,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$a({
+} = create$c({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -728,7 +728,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$a({
+} = create$c({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -903,7 +903,7 @@ const {
   registerDefinitionProvider,
   executeDefinitionProvider,
   reset: reset$8
-} = create$a({
+} = create$c({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -925,7 +925,7 @@ const {
 const {
   registerDiagnosticProvider,
   executeDiagnosticProvider
-} = create$a({
+} = create$c({
   name: 'Diagnostic',
   resultShape: {
     type: Array$1,
@@ -1026,7 +1026,7 @@ const {
   registerFormattingProvider,
   executeFormattingProvider,
   reset: reset$7
-} = create$a({
+} = create$c({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1088,7 +1088,7 @@ const {
   registerHoverProvider,
   executeHoverProvider,
   reset: reset$6
-} = create$a({
+} = create$c({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1101,7 +1101,7 @@ const {
   registerImplementationProvider,
   executeImplementationProvider,
   reset: reset$5
-} = create$a({
+} = create$c({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1115,933 +1115,630 @@ 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 getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
 };
 
-const create$9 = async ({
-  method,
-  ...options
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+
+const create$b = async ({
+  url,
+  name
 }) => {
-  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`);
-  }
+  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$5 = 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
 
-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');
-  }
+            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 create$8 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$2(method);
-  // @ts-ignore
-  const rpc = module.create(options);
-  return rpc;
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$b,
+  wrap: wrap$5
 };
 
-const defaultExecute$1 = () => {
-  throw new Error('not implemented');
-};
-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 sendMessagePortToElectron = async (port, initialCommand) => {
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
 
-const confirm = message => {
-  string(message);
-  const result = invoke$1('ConfirmPrompt.prompt', message);
-  return result;
+const getPort = async type => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
+  return port2;
 };
-
-const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
-
-const showQuickPick = async ({
-  getPicks,
-  toPick
+const create$a = async ({
+  type
 }) => {
-  const rawPicks = await getPicks();
-  const picks = rawPicks.map(toPick);
-  return invoke$1(ExtensionHostQuickPickShow, picks);
+  const port = await getPort();
+  return port;
 };
-
-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 wrap$4 = 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 {
-  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
-    }
-  }]
-});
-
-const getExtensionHostSubWorkerUrl = () => {
-  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
+  };
 };
-const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
-const set$3 = async (url, contentSecurityPolicy) => {
-  const pathName = new URL(url).pathname;
-  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+const IpcParentWithElectronMessagePort = {
+  __proto__: null,
+  create: create$a,
+  wrap: wrap$4
 };
 
-const rpcs$1 = Object.create(null);
-const add$1 = (id, rpc) => {
-  rpcs$1[id] = rpc;
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
 };
-const get$3 = id => {
-  return rpcs$1[id];
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-
-const registry = Object.create(null);
-const rpcs = Object.create(null);
-const register$1 = (id, execute) => {
-  registry[id] = execute;
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-const acquire = id => {
-  const fn = registry[id];
-  delete registry[id];
-  return fn;
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
 };
-const get$2 = id => {
-  return rpcs[id];
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-const set$2 = (id, rpc) => {
-  rpcs[id] = rpc;
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
 };
-
-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`);
-  }
-  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 getOrCreateRpc = async id => {
-  const rpc = get$2(id);
-  if (!rpc) {
-    set$2(id, createRpcWithId$1(id));
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
   }
-  return get$2(id);
-};
-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);
-    }
-  };
-  return lazyRpc;
-};
-
-const defaultExecute = () => {
-  throw new Error('not implemented');
-};
-
-/**
- *
- * @deprecated
- */
-const createLegacyRpc = async ({
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  string(url);
-  string(name);
-  fn(execute);
-  if (contentSecurityPolicy) {
-    await set$3(url, contentSecurityPolicy);
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
   }
-  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 createRpc$1 = ({
-  id,
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  try {
-    if (id) {
-      string(id);
-      return createRpcWithId({
-        id,
-        execute
-      });
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
     }
-    return createLegacyRpc({
-      url,
-      name,
-      execute,
-      contentSecurityPolicy
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to create webworker rpc`);
+    return;
   }
-};
-
-const {
-  registerSelectionProvider,
-  executeSelectionProvider,
-  reset: reset$2
-} = create$a({
-  name: 'Selection',
-  resultShape: {
-    allowUndefined: true,
-    type: Array$1,
-    items: {
-      type: 'number'
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
     }
+    return;
   }
-});
-
-const state$5 = {
-  providers: Object.create(null)
 };
-const registerSourceControlProvider = provider => {
-  state$5.providers[provider.id] = provider;
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
 };
-const getFilesFromProvider = provider => {
-  return provider.getChangedFiles();
+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 getChangedFiles = async providerId => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
   }
-  const changedFiles = await getFilesFromProvider(provider);
-  const flattenedChangedFiles = changedFiles;
-  return flattenedChangedFiles;
+}
+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 getFileBefore = async (providerId, uri) => {
-  string(providerId);
-  string(uri);
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
-  }
-  return provider.getFileBefore(uri);
+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 getGroupsFromProvider = async (provider, cwd) => {
-  if (provider.getGroups) {
-    return provider.getGroups(cwd);
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(lines),
+      rest: []
+    };
   }
-  if (provider.getChangedFiles) {
-    const files = await provider.getChangedFiles();
-    const groups = [{
-      id: 'changes',
-      label: 'Changes',
-      items: files
-    }];
-    return groups;
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
   }
-  throw new Error('source control provider is missing required function getGroups');
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
 };
-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 splitLines$2 = lines => {
+  return lines.split(NewLine$1);
 };
-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 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 add = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
-    return;
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+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 isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+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 isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  // @ts-ignore
-  await provider.add(path);
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const discard = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
-    return;
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  // @ts-ignore
-  await provider.discard(path);
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-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) {
-      // @ts-ignore
-      enabledIds.push(provider.id);
-    }
-  }
-  return enabledIds;
+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 {
-  registerTabCompletionProvider,
-  executeTabCompletionProvider,
-  reset: reset$1
-} = create$a({
-  name: 'TabCompletion',
-  resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  }
-});
-
-const state$4 = {
-  textSearchProviders: Object.create(null)
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
 };
-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 getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
 };
-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');
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(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
-      }
-    }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
   }
-});
-
-const RE_PROTOCOL = /^([a-z\-]+):\/\//;
-const getProtocol = uri => {
-  const protocolMatch = uri.match(RE_PROTOCOL);
-  if (protocolMatch) {
-    return protocolMatch[1];
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
   }
-  return '';
-};
-
-const getPortTuple = () => {
+  const lines = splitLines$2(stderr);
   const {
-    port1,
-    port2
-  } = new MessageChannel();
+    actualMessage,
+    rest
+  } = getDetails(lines);
   return {
-    port1,
-    port2
+    message: actualMessage,
+    code: '',
+    stack: rest
   };
 };
-
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+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 callbacks = Object.create(null);
-const set$1 = (id, fn) => {
-  callbacks[id] = fn;
+const listen$8 = ({
+  port
+}) => {
+  return port;
 };
-const get$1 = id => {
-  return callbacks[id];
+const signal$9 = port => {
+  port.postMessage(readyMessage);
 };
-const remove = id => {
-  delete callbacks[id];
+class IpcChildWithMessagePort 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() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$g = port => {
+  return new IpcChildWithMessagePort(port);
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$9,
+  wrap: wrap$g
 };
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
+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 IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
   return {
-    id,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    resolve: _resolve,
     promise
   };
 };
-const create$2$1 = (method, params) => {
+const waitForFirstMessage$1 = async port => {
   const {
-    id,
+    resolve,
     promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
+  } = withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
 };
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
-  }
-}
-const NewLine$1 = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage$1(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
   }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
+  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;
   }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(event);
   }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
+  send(message) {
+    this._rawIpc.postMessage(message);
   }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
   }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
     }
-    return error;
   }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + parentStack;
+  onClose(callback) {
+    // ignore
   }
-  return parentStack;
-};
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$e = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines$2 = lines => {
-  return lines.split(NewLine$1);
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
 };
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
+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 currentStack = joinLines$1(splitLines$2(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;
-    return restoredError;
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
   }
-  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;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
     }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
   }
-  return new Error(`JsonRpc Error: ${error}`);
+  return promise;
 };
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse$1 = content => {
+  if (content === 'undefined') {
+    return null;
   }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
   }
-  throw new JsonRpcError('unexpected response message');
 };
-const warn = (...args) => {
-  console.warn(...args);
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close,
+    error: Error$3
+  });
 };
-const resolve = (id, response) => {
-  const fn = get$1(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
+const create$9 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
   }
-  fn(response);
-  remove(id);
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
 };
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
+let IpcParentWithWebSocket$1 = class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse$1(event.data);
   }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
   }
-  return undefined;
-};
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
+  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);
   }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
 };
-const create$1$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
+const wrap$3 = webSocket => {
+  return new IpcParentWithWebSocket$1(webSocket);
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
-};
-const create$7 = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
-};
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
-  }
-};
-const defaultPreparePrettyError = error => {
-  return error;
-};
-const defaultLogError = () => {
-  // ignore
-};
-const defaultRequiresSocket = () => {
-  return false;
-};
-const defaultResolve = resolve;
-
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    const options = args[0];
-    return {
-      ipc: options.ipc,
-      message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
-    };
-  }
-  return {
-    ipc: args[0],
-    message: args[1],
-    execute: args[2],
-    resolve: args[3],
-    preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
-  };
-};
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    message,
-    ipc,
-    execute,
-    resolve,
-    preparePrettyError,
-    logError,
-    requiresSocket
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
-  }
-  throw new JsonRpcError('unexpected message');
-};
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`command not found ${command}`);
-  }
-  return fn(...args);
+const IpcParentWithWebSocket$1$1 = {
+  __proto__: null,
+  create: create$9,
+  wrap: wrap$3
 };
 
-const requiresSocket$2 = () => {
-  return false;
-};
-const preparePrettyError$2 = error => {
-  return error;
-};
-const logError$2 = error => {
-  // handled by renderer worker
-};
-const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$2, logError$2, requiresSocket$2);
+const getWebSocketProtocol = () => {
+  return location.protocol === 'https:' ? 'wss:' : 'ws:';
 };
 
-const handleIpc$1 = ipc => {
-  ipc.addEventListener('message', handleMessage$1);
+const getWebSocketUrl = type => {
+  const wsProtocol = getWebSocketProtocol();
+  return `${wsProtocol}//${location.host}/websocket/${type}`;
 };
 
-const createWebViewIpc = async webView => {
-  const {
-    uid,
-    origin
-  } = webView;
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  const promise = new Promise(resolve => {
-    port2.onmessage = resolve;
+const create$8 = async ({
+  type
+}) => {
+  string(type);
+  const wsUrl = getWebSocketUrl(type);
+  const webSocket = new WebSocket(wsUrl);
+  return IpcParentWithWebSocket$1$1.create({
+    webSocket
   });
-  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;
-};
-
-const webViews = Object.create(null);
-const webViewProviders = Object.create(null);
-const getProvider = providerId => {
-  return webViewProviders[providerId];
-};
-const setProvider = (providerId, provider) => {
-  webViewProviders[providerId] = provider;
-};
-const getWebView = id => {
-  return webViews[id];
-};
-const setWebView = (id, webView) => {
-  webViews[id] = webView;
 };
-const getWebViews = () => {
-  return webViews;
+const wrap$2 = webSocket => {
+  return IpcParentWithWebSocket$1$1.wrap(webSocket);
 };
 
-// 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`);
-  }
-  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
-  const objectUrl = await invoke(ipc, 'createObjectUrl', blob);
-  return objectUrl;
+const IpcParentWithWebSocket = {
+  __proto__: null,
+  create: create$8,
+  wrap: wrap$2
 };
 
 const Electron = 'electron';
@@ -2069,187 +1766,1177 @@ const getPlatform = () => {
 };
 const platform = getPlatform(); // 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);
+const getModule$3 = () => {
+  switch (platform) {
+    case Remote:
+      return IpcParentWithWebSocket;
+    default:
+      return IpcParentWithElectronMessagePort;
   }
-  if (uri.startsWith('html://')) {
-    const url = await invoke$1('Blob.getSrc', uri);
-    return url;
+};
+const create$7 = async ({
+  type,
+  raw
+}) => {
+  const module = getModule$3();
+  const rawIpc = await module.create({
+    type
+  });
+  if (raw) {
+    return rawIpc;
   }
-  throw new Error(`unsupported platform for remote url`);
+  return {
+    module,
+    rawIpc
+  };
 };
-
-const waitForFirstMessage$1 = async port => {
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port.onmessage = resolve;
-  const firstMessage = await promise;
-  return firstMessage;
+const wrap$1 = ({
+  module,
+  rawIpc
+}) => {
+  return module.wrap(rawIpc);
 };
 
-// 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 IpcParentWithNode = {
+  __proto__: null,
+  create: create$7,
+  wrap: wrap$1
+};
+
+const getModule$2 = 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$6 = async ({
+  method,
+  ...options
+}) => {
+  try {
+    const module = getModule$2(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`);
+  }
+};
 
-  // TODO use ipc module
-  const handlePortMessage = async event => {
-    const {
-      data,
-      target
-    } = event;
-    const {
-      method,
-      params,
-      id
-    } = data;
-    if (id && !method) {
-      resolve(id, data);
-      return;
-    }
-    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
-        });
-      }
-    }
-  };
-  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 JsonRpc = 1;
+
+const Two = '2.0';
+const create$4 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
   };
-  // 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 callbacks = Object.create(null);
+const set$3 = (id, fn) => {
+  callbacks[id] = fn;
 };
-const disposeWebView = id => {
-  // TODO race condition
-  // const webView=webViews[id]
+const get$3 = id => {
+  return callbacks[id];
 };
-const registerWebViewProvider = provider => {
-  setProvider(provider.id, provider);
+const remove = id => {
+  delete callbacks[id];
 };
-const getWebViewInfo = providerId => {
-  const webView = getWebView(providerId);
+let id = 0;
+const create$3$1 = () => {
+  return ++id;
+};
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$3(id, resolve);
   return {
-    uid: webView.uid,
-    origin: webView.origin,
-    uri: webView.uri
+    id,
+    promise
   };
 };
-
-const createWorker = async ({
-  method,
-  url,
-  name
-}) => {
-  string(method);
-  string(url);
-  string(name);
-  const ipc = create$9({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url,
-    name
-  });
-  return ipc;
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
 };
-
-const state$3 = {
-  workspacePath: ''
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
 };
-const setWorkspacePath = path => {
-  state$3.workspacePath = path;
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
 };
-const getWorkspaceFolder = path => {
-  return state$3.workspacePath;
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
 };
-
-class FormattingError extends Error {
-  constructor(message, codeFrame) {
-    super(message);
-    // @ts-ignore
-    this.codeFrame = codeFrame;
-    this.name = 'FormattingError';
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
   }
-}
-
-const File$2 = 1;
-const Match = 2;
-
-const TextSearchResultType = {
-  __proto__: null,
-  File: File$2,
-  Match
+  return parentStack;
 };
-
-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
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const splitLines$1 = lines => {
+  return lines.split(NewLine);
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  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 + 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 + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$3(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
+};
+const getErrorResponse = (message, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(message, errorProperty);
+};
+const create$5 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$5(message, resultProperty);
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    return getErrorResponse(message, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const send = (transport, method, ...params) => {
+  const message = create$4(method, params);
+  transport.send(message);
+};
+const invoke = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
+};
+
+const preparePrettyError$2 = error => {
+  return error;
+};
+const logError$2 = error => {
+  // handled by renderer worker
+};
+const requiresSocket$2 = () => {
+  return false;
+};
+const create$3 = ({
+  ipc,
+  execute
+}) => {
+  object(ipc);
+  fn(execute);
+  const handleMessage = async message => {
+    return handleJsonRpcMessage(ipc, message, execute, resolve, preparePrettyError$2, logError$2, requiresSocket$2);
+  };
+  ipc.onmessage = handleMessage;
+  return {
+    ipc,
+    invoke(method, ...params) {
+      return invoke(this.ipc, method, ...params);
+    }
+  };
+};
+
+const RpcParentWithJsonRpc = {
+  __proto__: null,
+  create: create$3
+};
+
+const getModule$1 = method => {
+  switch (method) {
+    case JsonRpc:
+      return RpcParentWithJsonRpc;
+    default:
+      throw new Error('unexpected rpc type');
+  }
+};
+
+const create$2 = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule$1(method);
+  // @ts-ignore
+  const rpc = module.create(options);
+  return rpc;
+};
+
+const defaultExecute$2 = () => {
+  throw new Error('not implemented');
+};
+const createNodeRpc = async ({
+  path,
+  execute = defaultExecute$2,
+  name = ''
+}) => {
+  try {
+    string(path);
+    fn(execute);
+    const ipc = await create$6({
+      method: ElectronMessagePort,
+      type: 'extension-host-helper-process',
+      name
+    });
+    const rpc = await create$2({
+      ipc,
+      method: JsonRpc,
+      execute
+    });
+    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$c({
+  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 {
+  registerRenameProvider,
+  executeRenameProvider,
+  executeprepareRenameProvider,
+  reset: reset$3
+} = create$c({
+  name: 'Rename',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'prepareRename',
+    methodName: 'prepareRename',
+    resultShape: {
+      type: Object$1,
+      allowUndefined: true
+    }
+  }]
+});
+
+const getExtensionHostSubWorkerUrl = () => {
+  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
+};
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+const set$2 = async (url, contentSecurityPolicy) => {
+  const pathName = new URL(url).pathname;
+  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+};
+
+const defaultExecute$1 = () => {
+  throw new Error('not implemented');
+};
+
+/**
+ *
+ * @deprecated
+ */
+const createLegacyRpc = async ({
+  url,
+  name,
+  execute = defaultExecute$1,
+  contentSecurityPolicy
+}) => {
+  string(url);
+  string(name);
+  fn(execute);
+  if (contentSecurityPolicy) {
+    await set$2(url, contentSecurityPolicy);
+  }
+  const ipc = await create$6({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name
+  });
+  const rpc = await create$2({
+    ipc,
+    method: JsonRpc,
+    execute
+  });
+  await rpc.invoke('LoadFile.loadFile', url);
+  return rpc;
+};
+
+const rpcs$1 = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs$1[id] = rpc;
+};
+const get$2 = 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;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+const set$1 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+
+const createRpcWithId$1 = async id => {
+  const fn = acquire(id);
+  const info = get$2(id);
+  if (!info) {
+    throw new Error(`rpc with id ${id} not found`);
+  }
+  const ipc = await create$6({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name: info.name
+  });
+  const newRpc = await create$2({
+    ipc,
+    method: JsonRpc,
+    execute: fn
+  });
+  await newRpc.invoke('LoadFile.loadFile', info.url);
+  set$1(id, newRpc);
+  return newRpc;
+};
+
+const getOrCreateRpc = async id => {
+  const rpc = get$1(id);
+  if (!rpc) {
+    set$1(id, createRpcWithId$1(id));
+  }
+  return get$1(id);
+};
+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);
+    }
+  };
+  return lazyRpc;
+};
+
+const defaultExecute = () => {
+  throw new Error('not implemented');
+};
+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 {
+  registerSelectionProvider,
+  executeSelectionProvider,
+  reset: reset$2
+} = create$c({
+  name: 'Selection',
+  resultShape: {
+    allowUndefined: true,
+    type: Array$1,
+    items: {
+      type: 'number'
+    }
+  }
+});
+
+const state$5 = {
+  providers: Object.create(null)
+};
+const registerSourceControlProvider = provider => {
+  state$5.providers[provider.id] = provider;
+};
+const getFilesFromProvider = provider => {
+  return provider.getChangedFiles();
+};
+const getChangedFiles = async providerId => {
+  const provider = state$5.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  const changedFiles = await getFilesFromProvider(provider);
+  const flattenedChangedFiles = changedFiles;
+  return flattenedChangedFiles;
+};
+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');
+  }
+  return provider.getFileBefore(uri);
+};
+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 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 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 add = async path => {
+  const provider = Object.values(state$5.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.add(path);
+};
+const discard = async path => {
+  const provider = Object.values(state$5.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.discard(path);
+};
+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) {
+      // @ts-ignore
+      enabledIds.push(provider.id);
+    }
+  }
+  return enabledIds;
+};
+
+const {
+  registerTabCompletionProvider,
+  executeTabCompletionProvider,
+  reset: reset$1
+} = create$c({
+  name: 'TabCompletion',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  }
+});
+
+const state$4 = {
+  textSearchProviders: Object.create(null)
+};
+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 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');
+  }
+};
+
+const {
+  registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider,
+  reset
+} = create$c({
+  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 commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
+
+const requiresSocket$1 = () => {
+  return false;
+};
+const preparePrettyError$1 = error => {
+  return error;
+};
+const logError$1 = error => {
+  // handled by renderer worker
+};
+const handleMessage$1 = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, requiresSocket$1);
+};
+
+const handleIpc$1 = ipc => {
+  ipc.addEventListener('message', handleMessage$1);
+};
+
+const createWebViewIpc = async webView => {
+  const {
+    uid,
+    origin
+  } = webView;
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  port2.onmessage = resolve;
+  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;
+};
+
+const webViews = Object.create(null);
+const webViewProviders = Object.create(null);
+const getProvider = providerId => {
+  return webViewProviders[providerId];
+};
+const setProvider = (providerId, provider) => {
+  webViewProviders[providerId] = provider;
+};
+const getWebView = id => {
+  return webViews[id];
+};
+const setWebView = (id, webView) => {
+  webViews[id] = webView;
+};
+const getWebViews = () => {
+  return webViews;
+};
+
+// 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`);
+  }
+  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
+  const objectUrl = await invoke(ipc, 'createObjectUrl', blob);
+  return objectUrl;
+};
+
+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;
+  }
+  throw new Error(`unsupported platform for remote url`);
+};
+
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  port.onmessage = resolve;
+  const firstMessage = await promise;
+  return firstMessage;
+};
+
+// 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`);
+  }
+
+  // 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(port);
+
+  // TODO use ipc module
+  const handlePortMessage = async event => {
+    const {
+      data,
+      target
+    } = event;
+    const {
+      method,
+      params,
+      id
+    } = data;
+    if (id && !method) {
+      resolve(id, data);
+      return;
+    }
+    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
+        });
+      }
+    }
+  };
+  port.onmessage = handlePortMessage;
+  const rpc = {
+    uri,
+    provider,
+    uid,
+    origin,
+    webView,
+    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;
+    }
+  };
+  // TODO allow creating multiple webviews per provider
+  setWebView(providerId, rpc);
+};
+const disposeWebView = id => {
+  // TODO race condition
+  // const webView=webViews[id]
+};
+const registerWebViewProvider = provider => {
+  setProvider(provider.id, provider);
+};
+const getWebViewInfo = providerId => {
+  const webView = getWebView(providerId);
+  return {
+    uid: webView.uid,
+    origin: webView.origin,
+    uri: webView.uri
+  };
+};
+
+const createWorker = async ({
+  method,
+  url,
+  name
+}) => {
+  string(method);
+  string(url);
+  string(name);
+  const ipc = create$6({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url,
+    name
+  });
+  return ipc;
+};
+
+const state$3 = {
+  workspacePath: ''
+};
+const setWorkspacePath = path => {
+  state$3.workspacePath = path;
+};
+const getWorkspaceFolder = path => {
+  return state$3.workspacePath;
+};
+
+class FormattingError extends Error {
+  constructor(message, codeFrame) {
+    super(message);
+    // @ts-ignore
+    this.codeFrame = codeFrame;
+    this.name = 'FormattingError';
+  }
+}
+
+const File$2 = 1;
+const Match = 2;
+
+const TextSearchResultType = {
+  __proto__: null,
+  File: File$2,
+  Match
+};
+
+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,
@@ -2319,479 +3006,103 @@ const api = {
   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 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$2 = {
-  /**
-   * @type {any[]}
-   */
-  errors: []
-};
-const addError = error => {
-  // @ts-ignore
-  state$2.errors.push(error);
-};
-const hasRecentErrors = () => {
-  return state$2.errors.length > 0;
-};
-const getRecentError = () => {
-};
-
-const handleContentSecurityPolicyViolation = event => {
-  const {
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
-  } = event;
-  addError({
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
-  });
-};
-
-const setStackTraceLimit = (errorConstructor, value) => {
-  if (errorConstructor.stackTraceLimit && errorConstructor.stackTraceLimit < value) {
-    errorConstructor.stackTraceLimit = value;
-  }
-};
-
-const setup = ({
-  global,
-  errorConstructor
-}) => {
-  setStackTraceLimit(errorConstructor, 20);
-  global.onerror ||= handleUnhandledError;
-  global.onunhandledrejection ||= handleUnhandledRejection;
-  if ('SecurityPolicyViolationEvent' in self) {
-    global.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
-  }
-  // @ts-ignore
-  global.vscode = api;
-};
-
-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);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-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 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;
-    }
-  }
-  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 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 isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
-};
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
-};
-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 getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
+  // Url
+  getRemoteUrl: getRemoteUrl,
+  // Webview
+  registerWebViewProvider: registerWebViewProvider,
+  // Worker
+  createWorker: createWorker,
+  // Workspace
+  getWorkspaceFolder: getWorkspaceFolder
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(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)
-  };
+
+const handleError = async error => {
+  console.error(error);
 };
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
+
+/**
+ * @param {ErrorEvent} event
+ */
+const handleUnhandledError = async event => {
+  try {
+    event.preventDefault();
+    await handleError(event.error);
+  } catch {
+    console.error(event.error);
   }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
-  };
 };
-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 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 readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
-};
-const listen$8 = ({
-  port
-}) => {
-  return port;
-};
-const signal$8 = port => {
-  port.postMessage(readyMessage);
-};
-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 handleUnhandledRejection = event => {
+  if (event instanceof PromiseRejectionEvent) {
+    event.preventDefault();
+    const output = getOutput(event.reason);
+    console.error(output);
+    return;
   }
-}
-const wrap$f = port => {
-  return new IpcChildWithMessagePort(port);
+  const output = getOutput(event);
+  console.error(output);
 };
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$8,
-  signal: signal$8,
-  wrap: wrap$f
+
+const state$2 = {
+  /**
+   * @type {any[]}
+   */
+  errors: []
 };
-const listen$7 = () => {
+const addError = error => {
   // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$7 = 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$e = global => {
-  return new IpcChildWithModuleWorker(global);
+  state$2.errors.push(error);
 };
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$7,
-  signal: signal$7,
-  wrap: wrap$e
+const hasRecentErrors = () => {
+  return state$2.errors.length > 0;
 };
-const withResolvers$1 = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
+const getRecentError = () => {
 };
-const waitForFirstMessage = async port => {
+
+const handleContentSecurityPolicyViolation = event => {
   const {
-    resolve,
-    promise
-  } = withResolvers$1();
-  port.addEventListener('message', resolve, {
-    once: true
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  } = event;
+  addError({
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
   });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-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;
-  }
-  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 setStackTraceLimit = (errorConstructor, value) => {
+  if (errorConstructor.stackTraceLimit && errorConstructor.stackTraceLimit < value) {
+    errorConstructor.stackTraceLimit = value;
   }
-}
-const wrap$d = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$d
+
+const setup = ({
+  global,
+  errorConstructor
+}) => {
+  setStackTraceLimit(errorConstructor, 20);
+  global.onerror ||= handleUnhandledError;
+  global.onunhandledrejection ||= handleUnhandledRejection;
+  if ('SecurityPolicyViolationEvent' in self) {
+    global.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
+  }
+  // @ts-ignore
+  global.vscode = api;
 };
 
 const createRpc = ipc => {
@@ -2811,18 +3122,18 @@ const createRpc = ipc => {
   };
   return rpc;
 };
-const requiresSocket$1 = () => {
+const requiresSocket = () => {
   return false;
 };
-const preparePrettyError$1 = error => {
+const preparePrettyError = error => {
   return error;
 };
-const logError$1 = () => {
+const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, actualRequiresSocket);
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -2840,7 +3151,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$6 = async ({
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -2852,7 +3163,7 @@ const create$6 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$6
+  create: create$1
 };
 
 const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
@@ -2894,7 +3205,7 @@ const WorkspaceSetPath = 'Workspace.setWorkspacePath';
 const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
 const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
 
-const create$5 = () => {
+const create = () => {
   return {
     finished: false
   };
@@ -3319,7 +3630,7 @@ const activate = async (extension, absolutePath) => {
     string(absolutePath);
     const module = await importScript(absolutePath);
     handleRpcInfos(extension);
-    const token = create$5();
+    const token = create();
     try {
       await Promise.race([module.activate(extension), rejectAfterTimeout(activationTimeout, token)]);
     } catch (error) {
@@ -3417,8 +3728,7 @@ const MessagePort$1 = 1;
 const ModuleWorker = 2;
 const ModuleWorkerWithMessagePort = 4;
 
-// @ts-ignore
-const getModule$1 = method => {
+const getModule = method => {
   switch (method) {
     case ModuleWorker:
       return IpcChildWithModuleWorker$1;
@@ -3432,7 +3742,8 @@ const getModule$1 = method => {
 };
 
 const handleMessagePort = port => {
-  const module = getModule$1(MessagePort$1);
+  const module = getModule(MessagePort$1);
+  // @ts-ignore
   const ipc = module.wrap(port);
   handleIpc$1(ipc);
   ipc.send('ready');
@@ -3459,7 +3770,7 @@ function promisifyRequest(request) {
       request.removeEventListener('error', error);
     };
     const success = () => {
-      resolve(wrap$4(request.result));
+      resolve(wrap(request.result));
       unlisten();
     };
     const error = () => {
@@ -3509,7 +3820,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 +3849,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 +3867,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 +3899,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) {
@@ -3656,894 +3967,580 @@ const cursorIteratorTraps = {
         advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
       };
     }
-    return cachedFunc;
-  }
-};
-async function* iterate(...args) {
-  // tslint:disable-next-line:no-this-assignment
-  let cursor = this;
-  if (!(cursor instanceof IDBCursor)) {
-    cursor = await cursor.openCursor(...args);
-  }
-  if (!cursor) return;
-  cursor = cursor;
-  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-  // Map this double-proxy back to the original, so other cursor methods work.
-  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-  while (cursor) {
-    yield proxiedCursor;
-    // If one of the advancing methods was not called, call continue().
-    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-    advanceResults.delete(proxiedCursor);
-  }
-}
-function isIteratorProp(target, prop) {
-  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get(target, prop, receiver) {
-    if (isIteratorProp(target, prop)) return iterate;
-    return oldTraps.get(target, prop, receiver);
-  },
-  has(target, prop) {
-    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-  }
-}));
-
-const state$1 = {
-  databases: Object.create(null),
-  eventId: 0,
-  dbVersion: 1,
-  /**
-   * @type {any}
-   */
-  cachedDb: undefined
-};
-
-const isDataCloneError = error => {
-  return error && error.name === 'DataCloneError';
-};
-
-// TODO high memory usage in idb because of transactionDoneMap
-
-const getDb$1 = async () => {
-  // @ts-ignore
-  const db = await openDB('session', state$1.dbVersion, {
-    async upgrade(db, oldVersion) {
-      if (!db.objectStoreNames.contains('session')) {
-        const objectStore = await db.createObjectStore('session', {
-          autoIncrement: true
-        });
-        objectStore.createIndex('sessionId', 'sessionId', {
-          unique: false
-        });
-      }
-    }
-  });
-  return db;
-};
-const getDbMemoized$1 = async () => {
-  state$1.cachedDb ||= await getDb$1();
-  return state$1.cachedDb;
-};
-const saveValue = async (storeId, value) => {
-  try {
-    const db = await getDbMemoized$1();
-    await db.add('session', value);
-  } catch (error) {
-    if (isDataCloneError(error)) {
-      // TODO
-      return;
-    }
-    throw new VError(error, 'Failed to save value to indexed db');
-  }
-};
-const getValues = async storeId => {
-  try {
-    const db = await getDbMemoized$1();
-    const tx = db.transaction(storeId, 'readwrite');
-    const [objects] = await Promise.all([tx.store.getAll(), tx.done]);
-    console.log({
-      objects
-    });
-    return objects;
-  } catch (error) {
-    throw new VError(error, 'Failed to get values from indexed db');
-  }
-};
-const getValuesByIndexName = async (storeId, indexName, only) => {
-  const db = await getDbMemoized$1();
-  const transaction = db.transaction(storeId);
-  const index = transaction.store.index(indexName);
-  const iterator = index.iterate(only);
-  const objects = [];
-  for await (const cursor of iterator) {
-    objects.push(cursor.value);
-  }
-  return objects;
-};
-const getHandleDb = async () => {
-  const db = await openDB('handle', state$1.dbVersion, {
-    async upgrade(db, oldVersion) {
-      if (!db.objectStoreNames.contains('file-handles-store')) {
-        // @ts-ignore
-        await db.createObjectStore('file-handles-store', {});
-      }
-    }
-  });
-  return db;
-};
-const addHandle = async (uri, handle) => {
-  const handleDb = await getHandleDb();
-  await handleDb.put('file-handles-store', handle, uri);
-};
-const getHandle$1 = async uri => {
-  const handleDb = await getHandleDb();
-  const handle = await handleDb.get('file-handles-store', uri);
-  return handle;
-};
-
-// TODO high memory usage in idb because of transactionDoneMap
-
-const state = {
-  databases: Object.create(null),
-  dbVersion: 2,
-  cachedDb: undefined
-};
-const storeId = 'lvce-keyvalue';
-const getDb = async () => {
-  const db = await openDB(storeId, state.dbVersion, {
-    async upgrade(db, oldVersion) {
-      if (!db.objectStoreNames.contains(storeId)) {
-        await db.createObjectStore(storeId, {
-          autoIncrement: true
-        });
-      }
-    }
-  });
-  return db;
-};
-const getDbMemoized = async () => {
-  state.cachedDb ||= await getDb();
-  return state.cachedDb;
-};
-const set = async (key, value) => {
-  try {
-    const db = await getDbMemoized();
-    await db.put(storeId, value, key);
-  } catch (error) {
-    throw new VError(error, 'Failed to save value to indexed db');
-  }
-};
-const get = async key => {
-  try {
-    const db = await getDbMemoized();
-    const value = db.get(storeId, key);
-    return value;
-  } catch (error) {
-    throw new VError(error, 'Failed to get value from indexed db');
-  }
-};
-
-const serializeWebView = async webView => {
-  if (webView && webView.provider && webView.provider.saveState) {
-    const saved = await webView.provider.saveState();
-    return {
-      uri: webView.uri,
-      state: saved
-    };
-  }
-  return undefined;
-};
-const serializeWebViews = async webViews => {
-  const serialized = [];
-  for (const [key, value] of Object.entries(webViews)) {
-    const serializedValue = await serializeWebView(value);
-    if (serializedValue) {
-      serialized.push({
-        key,
-        value: serializedValue
-      });
-    }
-  }
-  return serialized;
-};
-const saveState = async () => {
-  const webViews = getWebViews();
-  const serialized = await serializeWebViews(webViews);
-  return serialized;
-};
-
-const fileMapUrl = `${assetDir}/config/fileMap.json`;
-
-const getJson = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const json = await response.json();
-    return json;
-  } catch (error) {
-    throw new VError(error, `Failed to get json`);
-  }
-};
-
-const removeLeadingSlash = path => {
-  if (path.startsWith('/')) {
-    return path.slice(1);
-  }
-  return path;
-};
-
-// TODO simplify code
-// 1. don't have playground prefix in fileMap json
-// 2. remove code here that removes the prefix
-const searchFile$1 = async path => {
-  const fileList = await getJson(fileMapUrl);
-  const result = fileList.map(removeLeadingSlash);
-  const prefixLength = path.length - 'file:///'.length;
-  const final = [];
-  for (const item of result) {
-    final.push(item.slice(prefixLength));
+    return cachedFunc;
   }
-  return final;
 };
-
-const Directory = 'directory';
-const File = 'file';
-
-// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
-
-const insertInto = (array, start, newItems) => {
-  const originalLength = array.length;
-  const newItemsLength = newItems.length;
-  array.length = originalLength + newItemsLength;
-  // Move the items after the start index, start from the end so that we don't overwrite any value.
-  for (let i = originalLength - 1; i >= start; i--) {
-    array[i + newItemsLength] = array[i];
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
   }
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i];
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
   }
-};
-const push = (array, newItems) => {
-  insertInto(array, array.length, newItems);
-};
-const fromAsync = async asyncIterable => {
-  const children = [];
-  for await (const value of asyncIterable) {
-    children.push(value);
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
   }
-  return children;
-};
+}));
 
-const getChildHandles$1 = async handle => {
-  object(handle);
-  // @ts-ignore
-  const childHandles = handle.values();
-  const handles = await fromAsync(childHandles);
-  return handles;
+const state$1 = {
+  databases: Object.create(null),
+  eventId: 0,
+  dbVersion: 1,
+  /**
+   * @type {any}
+   */
+  cachedDb: undefined
 };
 
-const dirname = (pathSeparator, path) => {
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return path;
-  }
-  return path.slice(0, index);
+const isDataCloneError = error => {
+  return error && error.name === 'DataCloneError';
 };
 
-const getHandle = async uri => {
-  try {
-    // TODO retrieve handle from state or from indexeddb
-    // TODO if not found, throw error
-    const handle = await getHandle$1(uri);
-    return handle;
-  } catch (error) {
-    throw new VError(error, 'Failed to get handle');
-  }
-};
+// TODO high memory usage in idb because of transactionDoneMap
 
-const getDirectoryHandle$1 = async uri => {
-  const handle = await getHandle(uri);
-  if (handle) {
-    return handle;
-  }
-  const dirname$1 = dirname('/', uri);
-  if (uri === dirname$1) {
-    return undefined;
-  }
-  return getDirectoryHandle$1(dirname$1);
-};
-const toIgnore = ['.git', 'node_modules', 'dist', 'dist2'];
-const searchFilesRecursively = async (all, parent, handle) => {
-  const childHandles = await getChildHandles$1(handle);
-  const promises = [];
-  for (const childHandle of childHandles) {
-    if (toIgnore.includes(childHandle.name)) {
-      continue;
-    }
-    const absolutePath = parent + '/' + childHandle.name;
-    switch (childHandle.kind) {
-      case Directory:
-        promises.push(searchFilesRecursively(all, absolutePath, childHandle));
-        break;
-      case File:
-        all.push(absolutePath);
-        break;
+const getDb$1 = async () => {
+  // @ts-ignore
+  const db = await openDB('session', state$1.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains('session')) {
+        const objectStore = await db.createObjectStore('session', {
+          autoIncrement: true
+        });
+        objectStore.createIndex('sessionId', 'sessionId', {
+          unique: false
+        });
+      }
     }
-  }
-  await Promise.all(promises);
+  });
+  return db;
 };
-const searchFile = async uri => {
-  const path = uri.slice('html://'.length);
-  const handle = await getDirectoryHandle$1(path);
-  if (!handle) {
-    // @ts-ignore
-    throw new VError(`Folder not found ${uri}`);
-  }
-  const all = [];
-  await searchFilesRecursively(all, '', handle);
-  return all;
+const getDbMemoized$1 = async () => {
+  state$1.cachedDb ||= await getDb$1();
+  return state$1.cachedDb;
 };
-
-const getText = async url => {
+const saveValue = async (storeId, value) => {
   try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const text = await response.text();
-    return text;
+    const db = await getDbMemoized$1();
+    await db.add('session', value);
   } catch (error) {
-    throw new VError(error, `Failed to get text`);
-  }
-};
-
-const splitLines = lines => {
-  return lines.split('\n');
-};
-
-const textSearchInText = (file, content, query) => {
-  const results = [];
-  const lines = splitLines(content);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const index = line.indexOf(query);
-    if (index !== -1) {
-      results.push({
-        type: Match,
-        text: line,
-        start: index,
-        end: index + query.length,
-        lineNumber: i
-      });
+    if (isDataCloneError(error)) {
+      // TODO
+      return;
     }
+    throw new VError(error, 'Failed to save value to indexed db');
   }
-  if (results.length > 0) {
-    results.unshift({
-      type: File$2,
-      text: file,
-      start: 0,
-      end: 0,
-      lineNumber: 0
+};
+const getValues = async storeId => {
+  try {
+    const db = await getDbMemoized$1();
+    const tx = db.transaction(storeId, 'readwrite');
+    const [objects] = await Promise.all([tx.store.getAll(), tx.done]);
+    console.log({
+      objects
     });
+    return objects;
+  } catch (error) {
+    throw new VError(error, 'Failed to get values from indexed db');
   }
-  return results;
 };
-
-const textSearch$1 = async (scheme, root, query, options, assetDir) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const fetchUri = `${assetDir}/config/fileMap.json`;
-  const fileList = await getJson(fetchUri);
-  const allResults = [];
-  const relativeRoot = root.slice('fetch://'.length);
-  for (const uri of fileList) {
-    const fetchUri = `${assetDir}${uri}`;
-    const content = await getText(fetchUri);
-    const relativeUri = uri.slice(relativeRoot.length + 1);
-    const results = textSearchInText(relativeUri, content, query);
-    allResults.push(...results);
+const getValuesByIndexName = async (storeId, indexName, only) => {
+  const db = await getDbMemoized$1();
+  const transaction = db.transaction(storeId);
+  const index = transaction.store.index(indexName);
+  const iterator = index.iterate(only);
+  const objects = [];
+  for await (const cursor of iterator) {
+    objects.push(cursor.value);
   }
-  return allResults;
+  return objects;
 };
-
-class FileNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'FileNotFoundError';
-  }
-}
-
-const getChildHandles = async handle => {
-  try {
-    return await getChildHandles$1(handle);
-  } catch (error) {
-    throw new VError(error, 'failed to get child handles');
-  }
+const getHandleDb = async () => {
+  const db = await openDB('handle', state$1.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains('file-handles-store')) {
+        // @ts-ignore
+        await db.createObjectStore('file-handles-store', {});
+      }
+    }
+  });
+  return db;
+};
+const addHandle = async (uri, handle) => {
+  const handleDb = await getHandleDb();
+  await handleDb.put('file-handles-store', handle, uri);
+};
+const getHandle$1 = async uri => {
+  const handleDb = await getHandleDb();
+  const handle = await handleDb.get('file-handles-store', uri);
+  return handle;
 };
 
-const getDirectoryHandle = async uri => {
-  const handle = await getHandle(uri);
-  if (handle) {
-    return handle;
-  }
-  const dirname$1 = dirname('/', uri);
-  if (uri === dirname$1) {
-    return undefined;
-  }
-  return getDirectoryHandle(dirname$1);
-};
+const storeId = 'lvce-keyvalue';
 
-const NotReadableError = 'NotReadableError';
+// TODO high memory usage in idb because of transactionDoneMap
 
-const isNotReadableError = error => {
-  return error && error.name === NotReadableError;
+const state = {
+  databases: Object.create(null),
+  dbVersion: 2,
+  cachedDb: undefined
 };
-
-const getFile = handle => {
-  return handle.getFile();
+const getDb = async () => {
+  const db = await openDB(storeId, state.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains(storeId)) {
+        await db.createObjectStore(storeId, {
+          autoIncrement: true
+        });
+      }
+    }
+  });
+  return db;
+};
+const getDbMemoized = async () => {
+  state.cachedDb ||= await getDb();
+  return state.cachedDb;
 };
 
-const textSearchInFile = async (all, handle, absolutePath, query) => {
+// TODO high memory usage in idb because of transactionDoneMap
+
+const set = async (key, value) => {
   try {
-    const file = await getFile(handle);
-    const content = await file.text();
-    const results = textSearchInText(absolutePath, content, query);
-    push(all, results);
+    const db = await getDbMemoized();
+    await db.put(storeId, value, key);
   } catch (error) {
-    if (isNotReadableError(error)) {
-      // ignore
-      return;
-    }
-    throw error;
-  }
-};
-
-const textSearchRecursively = async (all, parent, handle, query) => {
-  const childHandles = await getChildHandles(handle);
-  const promises = [];
-  for (const childHandle of childHandles) {
-    const absolutePath = parent + '/' + childHandle.name;
-    switch (childHandle.kind) {
-      case Directory:
-        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
-        break;
-      case File:
-        // @ts-ignore
-        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
-        break;
-    }
+    throw new VError(error, 'Failed to save value to indexed db');
   }
-  await Promise.all(promises);
 };
-const textSearch = async (scheme, root, query) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const relativeRoot = root.slice('html://'.length);
-  const handle = await getDirectoryHandle(relativeRoot);
-  if (!handle) {
-    throw new FileNotFoundError(`Folder not found: ${relativeRoot}`);
+const get = async key => {
+  try {
+    const db = await getDbMemoized();
+    const value = db.get(storeId, key);
+    return value;
+  } catch (error) {
+    throw new VError(error, 'Failed to get value from indexed db');
   }
-  const all = [];
-  await textSearchRecursively(all, '', handle, query);
-  return all;
-};
-
-const commandMap = {
-  'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
-  'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
-  'IndexedDb.addHandle': addHandle,
-  'IndexedDb.get': get,
-  'IndexedDb.getHandle': getHandle$1,
-  'IndexedDb.getValues': getValues,
-  'IndexedDb.getValuesByIndexName': getValuesByIndexName,
-  'IndexedDb.saveValue': saveValue,
-  'IndexedDb.set': set,
-  'SearchFileWithFetch.searchFileWithFetch': searchFile$1,
-  'SearchFileWithHtml.searchFileWithHtml': searchFile,
-  'TextSearchFetch.textSearch': textSearch$1,
-  'TextSearchHtml.textSearch': textSearch,
-  ['ExtensionHostDebug.evaluate']: evaluate,
-  ['ExtensionHostDebug.getProperties']: getProperties,
-  ['ExtensionHostDebug.listProcesses']: listProcesses,
-  ['ExtensionHostDebug.pause']: pause,
-  ['ExtensionHostDebug.resume']: resume,
-  ['ExtensionHostDebug.setPauseOnException']: setPauseOnException,
-  ['ExtensionHostDebug.setPauseOnExceptions']: setPauseOnExceptions,
-  ['ExtensionHostDebug.start']: start,
-  ['ExtensionHostDebug.stepInto']: stepInto,
-  ['ExtensionHostDebug.stepOut']: stepOut,
-  ['ExtensionHostDebug.stepOver']: stepOver,
-  ['ExtensionHostWebView.create']: createWebView,
-  ['ExtensionHostWebView.dispose']: disposeWebView,
-  ['ExtensionHostWebView.load']: load,
-  ['ExtensionHostWebView.getWebViewInfo']: getWebViewInfo,
-  ['HandleBeforeUnload.handleBeforeUnload']: handleBeforeUnload,
-  ['HandleMessagePort.handleMessagePort']: handleMessagePort,
-  ['SaveState.saveState']: saveState,
-  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
-  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
-  [CommandExecute]: executeCommand,
-  [CompletionExecute]: executeCompletionProvider,
-  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
-  [ConfigurationSetConfiguration]: setConfigurations,
-  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
-  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
-  [ExtensionActivate]: activate,
-  [FileSystemGetPathSeparator]: getPathSeparator,
-  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes,
-  [FileSystemReadFile]: readFile,
-  [FileSystemWriteFile]: writeFile,
-  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
-  [HoverExecute]: executeHoverProvider,
-  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
-  [MockExec]: mockExec,
-  [MockRpc]: mockRpc,
-  [OrganizeImportsExecute]: executeOrganizeImports,
-  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
-  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
-  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
-  [SourceControlAcceptInput]: acceptInput,
-  [SourceControlAdd]: add,
-  [SourceControlDiscard]: discard,
-  [SourceControlGetChangedFiles]: getChangedFiles,
-  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
-  [SourceControlGetFileBefore]: getFileBefore,
-  [SourceControlGetGroups]: getGroups,
-  [StatusBarGetStatusBarItems]: getStatusBarItems,
-  [StatusBarRegisterChangeListener]: registerChangeListener,
-  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
-  [TextDocumentSetLanguageId]: setLanguageId,
-  [TextDocumentSyncFull]: syncFull,
-  [TextDocumentSyncIncremental]: syncIncremental,
-  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
-  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
-  [WorkspaceSetPath]: setWorkspacePath
-};
-
-const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMap
-  });
-  setRpc(rpc);
 };
 
-const main = async () => {
-  setup({
-    errorConstructor: Error,
-    global: globalThis
-  });
-  await listen();
+const loadWebView = async (providerId, savedState) => {
+  const rpc = getWebView(providerId);
+  await rpc.provider.create(rpc, rpc.uri, savedState);
 };
 
-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 serializeWebView = async webView => {
+  if (webView && webView.provider && webView.provider.saveState) {
+    const saved = await webView.provider.saveState();
+    return {
+      uri: webView.uri,
+      state: saved
+    };
+  }
+  return undefined;
 };
-
-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
+const serializeWebViews = async webViews => {
+  const serialized = [];
+  for (const [key, value] of Object.entries(webViews)) {
+    const serializedValue = await serializeWebView(value);
+    if (serializedValue) {
+      serialized.push({
+        key,
+        value: serializedValue
       });
-    };
-    eventTarget.addEventListener(event, listener);
-    listenerMap[event] = listener;
+    }
   }
-  return promise;
+  return serialized;
+};
+const saveState = async () => {
+  const webViews = getWebViews();
+  const serialized = await serializeWebViews(webViews);
+  return serialized;
 };
 
-/**
- *
- * @param {WebSocket} webSocket
- * @returns
- */
-const waitForWebSocketToBeOpen = webSocket => {
-  return getFirstEvent(webSocket, {
-    open: Open,
-    close: Close,
-    error: Error$1
-  });
+const fileMapUrl = `${assetDir}/config/fileMap.json`;
+
+const getJson = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    throw new VError(error, `Failed to get json`);
+  }
 };
 
-const getWebSocketProtocol = () => {
-  return location.protocol === 'https:' ? 'wss:' : 'ws:';
+const removeLeadingSlash = path => {
+  if (path.startsWith('/')) {
+    return path.slice(1);
+  }
+  return path;
 };
 
-const getWebSocketUrl = type => {
-  const wsProtocol = getWebSocketProtocol();
-  return `${wsProtocol}//${location.host}/websocket/${type}`;
+// TODO simplify code
+// 1. don't have playground prefix in fileMap json
+// 2. remove code here that removes the prefix
+const searchFile$1 = async path => {
+  const fileList = await getJson(fileMapUrl);
+  const result = fileList.map(removeLeadingSlash);
+  const prefixLength = path.length - 'file:///'.length;
+  const final = [];
+  for (const item of result) {
+    final.push(item.slice(prefixLength));
+  }
+  return final;
 };
 
-class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
-  }
-}
+const Directory = 'directory';
+const File = 'file';
 
-const stringifyCompact = value => {
-  return JSON.stringify(value);
-};
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
 
-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`);
+const insertInto = (array, start, newItems) => {
+  const originalLength = array.length;
+  const newItemsLength = newItems.length;
+  array.length = originalLength + newItemsLength;
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i];
   }
-  // @ts-ignore
-  if (firstWebSocketEvent.type === Close) {
-    throw new IpcError(`Websocket connection was closed`);
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
   }
-  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 push = (array, newItems) => {
+  insertInto(array, array.length, newItems);
+};
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
 };
 
-const IpcParentWithWebSocket = {
-  __proto__: null,
-  create: create$4,
-  wrap: wrap$3
+const getChildHandles$1 = async handle => {
+  object(handle);
+  // @ts-ignore
+  const childHandles = handle.values();
+  const handles = await fromAsync(childHandles);
+  return handles;
 };
 
-const getModule = async () => {
-  switch (platform) {
-    case Remote:
-      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
-    default:
-      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; });
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
   }
+  return path.slice(0, index);
 };
-const create$3 = async ({
-  type,
-  raw
-}) => {
-  const module = await getModule();
-  const rawIpc = await module.create({
-    type
-  });
-  if (raw) {
-    return rawIpc;
+
+const getHandle = async uri => {
+  try {
+    // TODO retrieve handle from state or from indexeddb
+    // TODO if not found, throw error
+    const handle = await getHandle$1(uri);
+    return handle;
+  } catch (error) {
+    throw new VError(error, 'Failed to get handle');
   }
-  return {
-    module,
-    rawIpc
-  };
-};
-const wrap$2 = ({
-  module,
-  rawIpc
-}) => {
-  return module.wrap(rawIpc);
 };
 
-const IpcParentWithNode = {
-  __proto__: null,
-  create: create$3,
-  wrap: wrap$2
+const getDirectoryHandle$1 = async uri => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname('/', uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  return getDirectoryHandle$1(dirname$1);
+};
+const toIgnore = ['.git', 'node_modules', 'dist', 'dist2'];
+const searchFilesRecursively = async (all, parent, handle) => {
+  const childHandles = await getChildHandles$1(handle);
+  const promises = [];
+  for (const childHandle of childHandles) {
+    if (toIgnore.includes(childHandle.name)) {
+      continue;
+    }
+    const absolutePath = parent + '/' + childHandle.name;
+    switch (childHandle.kind) {
+      case Directory:
+        promises.push(searchFilesRecursively(all, absolutePath, childHandle));
+        break;
+      case File:
+        all.push(absolutePath);
+        break;
+    }
+  }
+  await Promise.all(promises);
+};
+const searchFile = async uri => {
+  const path = uri.slice('html://'.length);
+  const handle = await getDirectoryHandle$1(path);
+  if (!handle) {
+    // @ts-ignore
+    throw new VError(`Folder not found ${uri}`);
+  }
+  const all = [];
+  await searchFilesRecursively(all, '', handle);
+  return all;
 };
 
-const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+const getText = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const text = await response.text();
+    return text;
+  } catch (error) {
+    throw new VError(error, `Failed to get text`);
+  }
+};
 
-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 splitLines = lines => {
+  return lines.split('\n');
 };
-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 textSearchInText = (file, content, query) => {
+  const results = [];
+  const lines = splitLines(content);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const index = line.indexOf(query);
+    if (index !== -1) {
+      results.push({
+        type: Match,
+        text: line,
+        start: index,
+        end: index + query.length,
+        lineNumber: i
+      });
     }
-  };
+  }
+  if (results.length > 0) {
+    results.unshift({
+      type: File$2,
+      text: file,
+      start: 0,
+      end: 0,
+      lineNumber: 0
+    });
+  }
+  return results;
 };
 
-const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
-  __proto__: null,
-  create: create$2,
-  wrap: wrap$1
+const textSearch$1 = async (scheme, root, query, options, assetDir) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const fetchUri = `${assetDir}/config/fileMap.json`;
+  const fileList = await getJson(fetchUri);
+  const allResults = [];
+  const relativeRoot = root.slice('fetch://'.length);
+  for (const uri of fileList) {
+    const fetchUri = `${assetDir}${uri}`;
+    const content = await getText(fetchUri);
+    const relativeUri = uri.slice(relativeRoot.length + 1);
+    const results = textSearchInText(relativeUri, content, query);
+    allResults.push(...results);
+  }
+  return allResults;
 };
 
-const preparePrettyError = error => {
-  return error;
-};
-const logError = error => {
-  // handled by renderer worker
+class FileNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+const getChildHandles = async handle => {
+  try {
+    return await getChildHandles$1(handle);
+  } catch (error) {
+    throw new VError(error, 'failed to get child handles');
+  }
 };
-const requiresSocket = () => {
-  return false;
+
+const getDirectoryHandle = async uri => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname('/', uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  return getDirectoryHandle(dirname$1);
 };
-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 NotReadableError = 'NotReadableError';
+
+const isNotReadableError = error => {
+  return error && error.name === NotReadableError;
 };
 
-const RpcParentWithJsonRpc = {
-  __proto__: null,
-  create: create$1
+const getFile = handle => {
+  return handle.getFile();
 };
 
-const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+const textSearchInFile = async (all, handle, absolutePath, query) => {
+  try {
+    const file = await getFile(handle);
+    const content = await file.text();
+    const results = textSearchInText(absolutePath, content, query);
+    push(all, results);
+  } catch (error) {
+    if (isNotReadableError(error)) {
+      // ignore
+      return;
+    }
+    throw error;
+  }
 };
 
-const getPort = async type => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
-  return port2;
+const textSearchRecursively = async (all, parent, handle, query) => {
+  const childHandles = await getChildHandles(handle);
+  const promises = [];
+  for (const childHandle of childHandles) {
+    const absolutePath = parent + '/' + childHandle.name;
+    switch (childHandle.kind) {
+      case Directory:
+        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
+        break;
+      case File:
+        // @ts-ignore
+        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
+        break;
+    }
+  }
+  await Promise.all(promises);
 };
-const create = async ({
-  type
-}) => {
-  const port = await getPort();
-  return port;
+const textSearch = async (scheme, root, query) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const relativeRoot = root.slice('html://'.length);
+  const handle = await getDirectoryHandle(relativeRoot);
+  if (!handle) {
+    throw new FileNotFoundError(`Folder not found: ${relativeRoot}`);
+  }
+  const all = [];
+  await textSearchRecursively(all, '', handle, query);
+  return all;
 };
-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 commandMap = {
+  'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
+  'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
+  'IndexedDb.addHandle': addHandle,
+  'IndexedDb.get': get,
+  'IndexedDb.getHandle': getHandle$1,
+  'IndexedDb.getValues': getValues,
+  'IndexedDb.getValuesByIndexName': getValuesByIndexName,
+  'IndexedDb.saveValue': saveValue,
+  'IndexedDb.set': set,
+  'SearchFileWithFetch.searchFileWithFetch': searchFile$1,
+  'SearchFileWithHtml.searchFileWithHtml': searchFile,
+  'TextSearchFetch.textSearch': textSearch$1,
+  'TextSearchHtml.textSearch': textSearch,
+  ['ExtensionHostDebug.evaluate']: evaluate,
+  ['ExtensionHostDebug.getProperties']: getProperties,
+  ['ExtensionHostDebug.listProcesses']: listProcesses,
+  ['ExtensionHostDebug.pause']: pause,
+  ['ExtensionHostDebug.resume']: resume,
+  ['ExtensionHostDebug.setPauseOnException']: setPauseOnException,
+  ['ExtensionHostDebug.setPauseOnExceptions']: setPauseOnExceptions,
+  ['ExtensionHostDebug.start']: start,
+  ['ExtensionHostDebug.stepInto']: stepInto,
+  ['ExtensionHostDebug.stepOut']: stepOut,
+  ['ExtensionHostDebug.stepOver']: stepOver,
+  ['ExtensionHostWebView.create']: createWebView,
+  ['ExtensionHostWebView.dispose']: disposeWebView,
+  ['ExtensionHostWebView.load']: loadWebView,
+  ['ExtensionHostWebView.getWebViewInfo']: getWebViewInfo,
+  ['HandleBeforeUnload.handleBeforeUnload']: handleBeforeUnload,
+  ['HandleMessagePort.handleMessagePort']: handleMessagePort,
+  ['SaveState.saveState']: saveState,
+  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
+  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
+  [CommandExecute]: executeCommand,
+  [CompletionExecute]: executeCompletionProvider,
+  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
+  [ConfigurationSetConfiguration]: setConfigurations,
+  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
+  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
+  [ExtensionActivate]: activate,
+  [FileSystemGetPathSeparator]: getPathSeparator,
+  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes,
+  [FileSystemReadFile]: readFile,
+  [FileSystemWriteFile]: writeFile,
+  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
+  [HoverExecute]: executeHoverProvider,
+  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
+  [MockExec]: mockExec,
+  [MockRpc]: mockRpc,
+  [OrganizeImportsExecute]: executeOrganizeImports,
+  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
+  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
+  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
+  [SourceControlAcceptInput]: acceptInput,
+  [SourceControlAdd]: add,
+  [SourceControlDiscard]: discard,
+  [SourceControlGetChangedFiles]: getChangedFiles,
+  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
+  [SourceControlGetFileBefore]: getFileBefore,
+  [SourceControlGetGroups]: getGroups,
+  [StatusBarGetStatusBarItems]: getStatusBarItems,
+  [StatusBarRegisterChangeListener]: registerChangeListener,
+  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
+  [TextDocumentSetLanguageId]: setLanguageId,
+  [TextDocumentSyncFull]: syncFull,
+  [TextDocumentSyncIncremental]: syncIncremental,
+  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
+  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
+  [WorkspaceSetPath]: setWorkspacePath
 };
 
-const IpcParentWithElectronMessagePort = {
-  __proto__: null,
-  create,
-  wrap
+const listen = async () => {
+  const rpc = await WebWorkerRpcClient.create({
+    commandMap: commandMap
+  });
+  setRpc(rpc);
+};
+
+const main = async () => {
+  setup({
+    errorConstructor: Error,
+    global: globalThis
+  });
+  await listen();
 };
+
+main();