npm - @lvce-editor/iframe-worker - Versions diffs - 1.5.0 → 2.1.0 - Mend

@lvce-editor/iframe-worker 1.5.0 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/iframeWorkerMain.js +828 -696
package/package.json +1 -1

package/dist/iframeWorkerMain.js CHANGED Viewed

@@ -1,438 +1,194 @@
-const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
-const register = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
-};
-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 createUrl = (protocol, host) => {
-  return protocol + '//' + host;
+const Two = '2.0';
+const state = {
+  callbacks: Object.create(null)
 };
-const createLocalHostUrl = (locationProtocol, locationHost, isGitpod, webViewPort) => {
-  if (isGitpod) {
-    return createUrl(locationProtocol, locationHost.replace('3000', `${webViewPort}`));
-  }
-  return `http://localhost:${webViewPort}`;
+const set = (id, fn) => {
+  state.callbacks[id] = fn;
 };
-const Web = 1;
-const Electron = 2;
-const Remote = 3;
-const Test = 4;
-/* istanbul ignore file */
-// TODO this should always be completely tree shaken out during build, maybe need to be marked as @__Pure for terser to work
-// TODO treeshake this function out when targeting electron
-/**
- * @returns {number}
- */
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM;
-  }
-  // @ts-ignore
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return Test;
-  }
-  // TODO find a better way to pass runtime environment
-  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
-    return Electron;
-  }
-  if (typeof name !== 'undefined' && name.endsWith('(Web)')) {
-    return Web;
-  }
-  return Remote;
-};
-const platform = getPlatform();
-const getAssetDir = () => {
-  // @ts-ignore
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-ignore
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '';
-  }
-  return '';
+const get = id => {
+  return state.callbacks[id];
 };
-const assetDir = getAssetDir();
-const getWebViewHtml = (baseUrl, locationOrigin, elements) => {
-  if (!elements) {
-    return '';
-  }
-  const middle = [];
-  middle.push('<meta charset="utf-8">');
-  for (const element of elements) {
-    if (element.type === 'title') {
-      middle.push(`<title>${element.value}</title>`);
-    } else if (element.type === 'script') {
-      middle.push(`<script type="module" src="${locationOrigin}${assetDir}/js/preview-injected.js"></script>`);
-      middle.push(`<script type="module" src="${locationOrigin}${baseUrl}/${element.path}"></script>`);
-    } else if (element.type === 'css') {
-      middle.push(`<link rel="stylesheet" href="${locationOrigin}${baseUrl}/${element.path}" />`);
-    }
-  }
-  const middleHtml = middle.join('\n    ');
-  let html = `<!DOCTYPE html>
-<html>
-  <head>
-    ${middleHtml}
-  </head>
-</html>
-`;
-  return html;
+const remove = id => {
+  delete state.callbacks[id];
 };
-const WebView = 'lvce-oss-webview';
-const getWebView$1 = (webViews, webViewId) => {
-  for (const webView of webViews) {
-    if (webView.id === webViewId) {
-      return webView;
-    }
-  }
-  return undefined;
+let id = 0;
+const create$3 = () => {
+  return ++id;
 };
-const getWebViewPath = (webViews, webViewId) => {
-  const webView = getWebView$1(webViews, webViewId);
-  if (!webView) {
-    return '';
-  }
-  return webView.path;
-};
-const getWebViewUri = (webViews, webViewId) => {
-  const webViewPath = getWebViewPath(webViews, webViewId);
-  if (!webViewPath) {
-    return '';
-  }
-  if (webViewPath.startsWith('/')) {
-    // TODO make it work on windows also
-    return `file://${webViewPath}`;
-  }
-  return webViewPath;
+const warn = (...args) => {
+  console.warn(...args);
 };
-const getIframeSrcRemote = (webViews, webViewPort, webViewId, locationProtocol, locationHost, isGitpod, root) => {
-  const webView = getWebView$1(webViews, webViewId);
-  const webViewUri = getWebViewUri(webViews, webViewId);
-  if (!webViewUri) {
-    return undefined;
-  }
-  let iframeSrc = webViewUri;
-  let webViewRoot = webViewUri;
-  if (platform === Electron) {
-    const relativePath = new URL(webViewUri).pathname.replace('/index.html', '');
-    iframeSrc = `${WebView}://-${relativePath}/`;
-    // TODO
-  } else if (platform === Remote) {
-    const relativePath = new URL(webViewUri).pathname.replace('/index.html', '');
-    if (webViewUri.startsWith('file://')) {
-      // ignore
-      webViewRoot = webViewUri.slice('file://'.length).replace('/index.html', '');
-    } else {
-      webViewRoot = root + relativePath;
-    }
-    iframeSrc = createLocalHostUrl(locationProtocol, locationHost, isGitpod, webViewPort);
-  }
-  let iframeContent = getWebViewHtml('', '', webView.elements);
-  // TODO either
-  // - load webviews the same as in web using blob urls
-  // - load webviews from a pattern like /webviews/:id/:fileName
-  iframeContent = iframeContent.replaceAll('/media/', '/').replaceAll('//', '/');
+const registerPromise = () => {
+  const id = create$3();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set(id, resolve);
   return {
-    srcDoc: '',
-    iframeSrc,
-    webViewRoot,
-    iframeContent
+    id,
+    promise
   };
 };
-const getBlobUrl = (content, contentType) => {
-  const blob = new Blob([content], {
-    type: contentType
-  });
-  const url = URL.createObjectURL(blob); // TODO dispose
-  return url;
-};
-const getDefaultBaseUrl = webView => {
-  const {
-    remotePath,
-    path
-  } = webView;
-  if (remotePath) {
-    if (remotePath.endsWith('/index.html')) {
-      return remotePath.slice(0, -'/index.html'.length);
-    }
-    return remotePath;
-  }
-  if (path) {
-    if (path.endsWith('/index.html')) {
-      return path.slice(0, -'/index.html'.length);
-    }
-    return path;
+const resolve = (id, response) => {
+  const fn = get(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
   }
-  return '';
+  fn(response);
+  remove(id);
 };
-const getWebViewBaseUrl = webView => {
-  const defaultBaseUrl = getDefaultBaseUrl(webView);
-  return defaultBaseUrl;
+const create$2 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
 };
-const getIframeSrc$1 = (webView, locationOrigin) => {
-  const baseUrl = getWebViewBaseUrl(webView);
-  const srcHtml = getWebViewHtml(baseUrl, locationOrigin, webView.elements);
-  if (srcHtml) {
-    const blobUrl = getBlobUrl(srcHtml, 'text/html');
-    return {
-      srcDoc: '',
-      iframeSrc: blobUrl,
-      webViewRoot: '',
-      iframeContent: ''
-    };
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-  return undefined;
-};
-const getWebView = (webViews, webViewId) => {
-  for (const webView of webViews) {
-    if (webView.id === webViewId) {
-      return webView;
+}
+const NewLine$3 = '\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;
     }
   }
-  return undefined;
-};
-const normalizeLine$1 = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
-  }
-  return line;
-};
-const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = normalizeLine$1(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
   }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
   }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
   }
-  return child;
+  return Error;
 };
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage$1(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
   }
-};
-const getIframeSrc = (webViews, webViewId, webViewPort, root, isGitpod, locationProtocol, locationHost, locationOrigin) => {
-  try {
-    const webView = getWebView(webViews, webViewId);
-    if (platform === Web) {
-      return getIframeSrc$1(webView, locationOrigin);
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
     }
-    return getIframeSrcRemote(webViews, webViewPort, webViewId, locationProtocol, locationHost, isGitpod, root);
-  } catch (error) {
-    throw new VError$1(error, `Failed to construct webview iframe src`);
-  }
-};
-const SemiColon = ';';
-const Space = ' ';
-const addSemicolon = line => {
-  return line + SemiColon;
-};
-const getContentSecurityPolicy = items => {
-  return items.map(addSemicolon).join(Space);
-};
-const getWebViewCsp = webView => {
-  if (webView && webView.contentSecurityPolicy) {
-    return getContentSecurityPolicy(webView.contentSecurityPolicy);
+    return error;
   }
-  const csp = getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`, `style-src 'self'`, `img-src 'self'`, `media-src 'self'`]);
-  return csp;
-};
-const getWebViewFrameAncestors = (locationProtocol, locationHost) => {
-  const frameAncestors = createUrl(locationProtocol, locationHost);
-  return frameAncestors;
+  return new ErrorConstructor(message);
 };
-const getWebViewOrigin = webViewPort => {
-  // TODO don't hardcode protocol
-  let origin = '';
-  if (platform === Electron) {
-    origin = `${WebView}://-/`;
-  } else if (platform === Remote) {
-    origin = `http://localhost:${webViewPort}`;
-  } else {
-    origin = '*'; // TODO
-  }
-  return origin;
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
 };
-const AllowScripts = 'allow-scripts';
-const AllowSameOrigin = 'allow-same-origin';
-const getIframeSandbox = (webView, platform) => {
-  const extensionSandbox = webView.sandbox || [];
-  if (platform === Remote) {
-    return [AllowScripts, AllowSameOrigin, ...extensionSandbox]; // TODO maybe disallow same origin
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$3 + parentStack;
   }
-  if (platform === Web) {
-    return [AllowScripts, ...extensionSandbox];
-  }
-  return [AllowScripts, AllowSameOrigin, ...extensionSandbox];
+  return parentStack;
 };
-const getOrigin = () => {
-  return location.origin;
-};
-const getHost = () => {
-  return location.host;
-};
-const getProtocol = () => {
-  return location.protocol;
-};
-const commandMap = {
-  'Location.getHost': getHost,
-  'Location.getOrigin': getOrigin,
-  'Location.getProtocol': getProtocol,
-  'WebView.getBaseUrl': getWebViewBaseUrl,
-  'WebView.getFrameAncestors': getWebViewFrameAncestors,
-  'WebView.getHtml': getWebViewHtml,
-  'WebView.getIframeSrc': getIframeSrc,
-  'WebView.getOrigin': getWebViewOrigin,
-  'WebView.getSandbox': getIframeSandbox,
-  'WebView.getWebViewCsp': getWebViewCsp
+const joinLines$1 = lines => {
+  return lines.join(NewLine$3);
 };
-const Two = '2.0';
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType$1 = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
+const MethodNotFound = -32601;
+const Custom = -32001;
+const splitLines$1 = lines => {
+  return lines.split(NewLine$3);
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  const currentStack = joinLines$1(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$3 + 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$3 + error.data.stack + NewLine$3 + 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$2(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
       }
-      if (Array.isArray(value)) {
-        return 'array';
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
       }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
+    }
+    return restoredError;
   }
-};
-const number = value => {
-  const type = getType$1(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
   }
+  return new Error(`JsonRpc Error: ${error}`);
 };
-const state$1 = {
-  callbacks: Object.create(null)
-};
-const get = id => {
-  return state$1.callbacks[id];
-};
-const remove = id => {
-  delete state$1.callbacks[id];
-};
-const warn = (...args) => {
-  console.warn(...args);
-};
-const resolve = (id, args) => {
-  number(id);
-  const fn = get(id);
-  if (!fn) {
-    console.log(args);
-    warn(`callback ${id} may already be disposed`);
-    return;
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
   }
-  fn(args);
-  remove(id);
-};
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
+  if ('result' in responseMessage) {
+    return responseMessage.result;
   }
-}
-const MethodNotFound = -32601;
-const Custom = -32001;
+  throw new JsonRpcError('unexpected response message');
+};
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getType = prettyError => {
+const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
     return prettyError.type;
   }
@@ -455,13 +211,13 @@ const getErrorProperty = (error, prettyError) => {
     data: {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
-      type: getType(prettyError),
+      type: getErrorType(prettyError),
       code: prettyError.code,
       name: prettyError.name
     }
   };
 };
-const create$1 = (message, error) => {
+const create$1$1 = (message, error) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -472,7 +228,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+  return create$1$1(message, errorProperty);
 };
 const create = (message, result) => {
   return {
@@ -503,32 +259,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    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);
@@ -549,43 +315,65 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const logError = error => {
-  console.error(error);
+const invoke = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+const invokeAndTransfer = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
-const handleIpc = ipc => {
-  ipc.addEventListener('message', handleMessage);
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerAndMessagePort = 8;
-const Auto = () => {
-  // @ts-ignore
-  if (globalThis.acceptPort) {
-    return MessagePort$1;
-  }
-  // @ts-ignore
-  if (globalThis.acceptReferencePort) {
-    return ReferencePort;
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
   }
-  return ModuleWorkerAndMessagePort;
+  return fn(...args);
 };
 const getData$1 = event => {
   return event.data;
 };
+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 readyMessage = 'ready';
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -636,188 +424,575 @@ const getTransferrables = value => {
   walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
+const listen$2 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$2 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$1(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$5 = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+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 = lines => {
+  return lines.join(NewLine$1);
+};
+const splitLines = lines => {
+  return lines.split(NewLine$1);
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
   };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
+};
+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(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
   };
-  that.onClose(handleClose);
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+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);
+};
+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 getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: `${actualMessage}`,
+    code: '',
+    stack: rest
+  };
+};
+const normalizeLine$1 = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage$1 = (error, message) => {
+  const stringifiedError = normalizeLine$1(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+let VError$1 = class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage$1(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks$1(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+};
+class IpcError extends VError$1 {
+  // @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 withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$1$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
   }
-}
-const readyMessage = 'ready';
-const listen$4 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
+  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;
 };
-const signal$3 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
   getData(event) {
     return getData$1(event);
   }
   send(message) {
-    // @ts-ignore
     this._rawIpc.postMessage(message);
   }
   sendAndTransfer(message) {
     const transfer = getTransferrables(message);
-    // @ts-ignore
     this._rawIpc.postMessage(message, transfer);
   }
   dispose() {
-    // ignore
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
   }
   onClose(callback) {
     // ignore
   }
   onMessage(callback) {
     this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
   }
 }
-const wrap$6 = global => {
-  return new IpcChildWithModuleWorker(global);
+const wrap$4 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
-const IpcChildWithModuleWorker$1 = {
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
+  listen: listen$1$1,
+  wrap: wrap$4
 };
-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 = lines => {
-  return lines.join(NewLine$1);
+const createRpc = ipc => {
+  const rpc = {
+    invoke(method, ...params) {
+      return invoke(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer(ipc, method, ...params);
+    }
+  };
+  return rpc;
 };
-const splitLines = lines => {
-  return lines.split(NewLine$1);
+const requiresSocket = () => {
+  return false;
 };
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
+const preparePrettyError = error => {
+  return error;
 };
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
-  };
+const logError = () => {
+  // handled by renderer worker
 };
-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 handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
 };
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+const handleIpc = ipc => {
+  ipc.addEventListener('message', handleMessage);
 };
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+// @ts-ignore
+const listen$1 = async () => {
+  const module = IpcChildWithModuleWorkerAndMessagePort$1;
+  const rawIpc = await module.listen();
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines(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 create$1 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1();
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
 };
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$1
 };
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
+const createUrl = (protocol, host) => {
+  return protocol + '//' + host;
+};
+const createLocalHostUrl = (locationProtocol, locationHost, isGitpod, webViewPort) => {
+  if (isGitpod) {
+    return createUrl(locationProtocol, locationHost.replace('3000', `${webViewPort}`));
   }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+  return `http://localhost:${webViewPort}`;
 };
-const getModuleSyntaxError = () => {
+const Web = 1;
+const Electron = 2;
+const Remote = 3;
+const Test = 4;
+/* istanbul ignore file */
+// TODO this should always be completely tree shaken out during build, maybe need to be marked as @__Pure for terser to work
+// TODO treeshake this function out when targeting electron
+/**
+ * @returns {number}
+ */
+const getPlatform = () => {
+  // @ts-ignore
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-ignore
+    return PLATFORM;
+  }
+  // @ts-ignore
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Test;
+  }
+  // TODO find a better way to pass runtime environment
+  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
+    return Electron;
+  }
+  if (typeof name !== 'undefined' && name.endsWith('(Web)')) {
+    return Web;
+  }
+  return Remote;
+};
+const platform = getPlatform();
+const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-ignore
+    return ASSET_DIR;
+  }
+  if (platform === Electron) {
+    return '';
+  }
+  return '';
+};
+const assetDir = getAssetDir();
+const getWebViewHtml = (baseUrl, locationOrigin, elements) => {
+  if (!elements) {
+    return '';
+  }
+  const middle = [];
+  middle.push('<meta charset="utf-8">');
+  for (const element of elements) {
+    if (element.type === 'title') {
+      middle.push(`<title>${element.value}</title>`);
+    } else if (element.type === 'script') {
+      middle.push(`<script type="module" src="${locationOrigin}${assetDir}/js/preview-injected.js"></script>`);
+      middle.push(`<script type="module" src="${locationOrigin}${baseUrl}/${element.path}"></script>`);
+    } else if (element.type === 'css') {
+      middle.push(`<link rel="stylesheet" href="${locationOrigin}${baseUrl}/${element.path}" />`);
+    }
+  }
+  const middleHtml = middle.join('\n    ');
+  const html = `<!DOCTYPE html>
+<html>
+  <head>
+    ${middleHtml}
+  </head>
+</html>
+`;
+  return html;
+};
+const WebView = 'lvce-oss-webview';
+const getWebView$1 = (webViews, webViewId) => {
+  for (const webView of webViews) {
+    if (webView.id === webViewId) {
+      return webView;
+    }
+  }
+  return undefined;
+};
+const getWebViewPath = (webViews, webViewId) => {
+  const webView = getWebView$1(webViews, webViewId);
+  if (!webView) {
+    return '';
+  }
+  return webView.path;
+};
+const getWebViewUri = (webViews, webViewId) => {
+  const webViewPath = getWebViewPath(webViews, webViewId);
+  if (!webViewPath) {
+    return '';
+  }
+  if (webViewPath.startsWith('/')) {
+    // TODO make it work on windows also
+    return `file://${webViewPath}`;
+  }
+  return webViewPath;
+};
+const getIframeSrcRemote = (webViews, webViewPort, webViewId, locationProtocol, locationHost, isGitpod, root) => {
+  const webView = getWebView$1(webViews, webViewId);
+  const webViewUri = getWebViewUri(webViews, webViewId);
+  if (!webViewUri) {
+    return undefined;
+  }
+  let iframeSrc = webViewUri;
+  let webViewRoot = webViewUri;
+  if (platform === Electron) {
+    const relativePath = new URL(webViewUri).pathname.replace('/index.html', '');
+    iframeSrc = `${WebView}://-${relativePath}/`;
+    // TODO
+  } else if (platform === Remote) {
+    const relativePath = new URL(webViewUri).pathname.replace('/index.html', '');
+    if (webViewUri.startsWith('file://')) {
+      // ignore
+      webViewRoot = webViewUri.slice('file://'.length).replace('/index.html', '');
+    } else {
+      webViewRoot = root + relativePath;
+    }
+    iframeSrc = createLocalHostUrl(locationProtocol, locationHost, isGitpod, webViewPort);
+  }
+  let iframeContent = getWebViewHtml('', '', webView.elements);
+  // TODO either
+  // - load webviews the same as in web using blob urls
+  // - load webviews from a pattern like /webviews/:id/:fileName
+  iframeContent = iframeContent.replaceAll('/media/', '/').replaceAll('//', '/');
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    srcDoc: '',
+    iframeSrc,
+    webViewRoot,
+    iframeContent
   };
 };
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
+const getBlobUrl = (content, contentType) => {
+  const blob = new Blob([content], {
+    type: contentType
+  });
+  const url = URL.createObjectURL(blob); // TODO dispose
+  return url;
+};
+const getDefaultBaseUrl = webView => {
+  const {
+    remotePath,
+    path
+  } = webView;
+  if (remotePath) {
+    if (remotePath.endsWith('/index.html')) {
+      return remotePath.slice(0, -'/index.html'.length);
+    }
+    return remotePath;
   }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
+  if (path) {
+    if (path.endsWith('/index.html')) {
+      return path.slice(0, -'/index.html'.length);
+    }
+    return path;
+  }
+  return '';
 };
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+const getWebViewBaseUrl = webView => {
+  const defaultBaseUrl = getDefaultBaseUrl(webView);
+  return defaultBaseUrl;
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
+const getIframeSrc$1 = (webView, locationOrigin) => {
+  const baseUrl = getWebViewBaseUrl(webView);
+  const srcHtml = getWebViewHtml(baseUrl, locationOrigin, webView.elements);
+  if (srcHtml) {
+    const blobUrl = getBlobUrl(srcHtml, 'text/html');
     return {
-      actualMessage: joinLines(lines),
-      rest: []
+      srcDoc: '',
+      iframeSrc: blobUrl,
+      webViewRoot: '',
+      iframeContent: ''
     };
   }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
+  return undefined;
 };
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
+const getWebView = (webViews, webViewId) => {
+  for (const webView of webViews) {
+    if (webView.id === webViewId) {
+      return webView;
+    }
   }
-  const lines = splitLines(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
-  };
+  return undefined;
 };
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -867,140 +1042,97 @@ class VError extends Error {
     }
   }
 }
-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);
+const getIframeSrc = (webViews, webViewId, webViewPort, root, isGitpod, locationProtocol, locationHost, locationOrigin) => {
+  try {
+    const webView = getWebView(webViews, webViewId);
+    if (platform === Web) {
+      return getIframeSrc$1(webView, locationOrigin);
     }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
+    return getIframeSrcRemote(webViews, webViewPort, webViewId, locationProtocol, locationHost, isGitpod, root);
+  } catch (error) {
+    throw new VError(error, `Failed to construct webview iframe src`);
   }
-}
-const withResolvers = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
 };
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
+const SemiColon = ';';
+const Space = ' ';
+const addSemicolon = line => {
+  return line + SemiColon;
 };
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
+const getContentSecurityPolicy = items => {
+  return items.map(addSemicolon).join(Space);
 };
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(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 getWebViewCsp = webView => {
+  if (webView && webView.contentSecurityPolicy) {
+    return getContentSecurityPolicy(webView.contentSecurityPolicy);
   }
-}
-const wrap$5 = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
+  const csp = getContentSecurityPolicy([`default-src 'none'`, `script-src 'self'`, `style-src 'self'`, `img-src 'self'`, `media-src 'self'`]);
+  return csp;
 };
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
+const getWebViewFrameAncestors = (locationProtocol, locationHost) => {
+  const frameAncestors = createUrl(locationProtocol, locationHost);
+  return frameAncestors;
 };
-const getModule = method => {
-  switch (method) {
-    case ModuleWorker:
-      return IpcChildWithModuleWorker$1;
-    case ModuleWorkerAndMessagePort:
-      return IpcChildWithModuleWorkerAndMessagePort$1;
-    default:
-      throw new Error('unexpected ipc type');
+const getWebViewOrigin = webViewPort => {
+  // TODO don't hardcode protocol
+  let origin = '';
+  if (platform === Electron) {
+    origin = `${WebView}://-/`;
+  } else if (platform === Remote) {
+    origin = `http://localhost:${webViewPort}`;
+  } else {
+    origin = '*'; // TODO
   }
+  return origin;
 };
-const listen$1 = async ({
-  method
-}) => {
-  const module = await getModule(method);
-  const rawIpc = await module.listen();
-  if (module.signal) {
-    module.signal(rawIpc);
+const AllowScripts = 'allow-scripts';
+const AllowSameOrigin = 'allow-same-origin';
+const getIframeSandbox = (webView, platform) => {
+  const extensionSandbox = webView.sandbox || [];
+  if (platform === Remote) {
+    return [AllowScripts, AllowSameOrigin, ...extensionSandbox]; // TODO maybe disallow same origin
   }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
+  if (platform === Web) {
+    return [AllowScripts, ...extensionSandbox];
+  }
+  return [AllowScripts, AllowSameOrigin, ...extensionSandbox];
+};
+const getOrigin = () => {
+  return location.origin;
+};
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+const commandMap = {
+  'Location.getHost': getHost,
+  'Location.getOrigin': getOrigin,
+  'Location.getProtocol': getProtocol,
+  'WebView.getBaseUrl': getWebViewBaseUrl,
+  'WebView.getFrameAncestors': getWebViewFrameAncestors,
+  'WebView.getHtml': getWebViewHtml,
+  'WebView.getIframeSrc': getIframeSrc,
+  'WebView.getOrigin': getWebViewOrigin,
+  'WebView.getSandbox': getIframeSandbox,
+  'WebView.getWebViewCsp': getWebViewCsp
 };
 const listen = async () => {
-  register(commandMap);
-  const ipc = await listen$1({
-    method: Auto()
+  await WebWorkerRpcClient.create({
+    commandMap: commandMap
   });
-  handleIpc(ipc);
 };
 const main = async () => {