@lvce-editor/static-server 0.107.4 → 0.108.2

package/static/{31117c9 → 00cccba}/packages/renderer-process/dist/rendererProcessMain.js

@@ -118,25 +118,25 @@ const confirm = message => {
   return window.confirm(message);
 };
 
-const state$e = {
+const state$f = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
 };
 const set$b = (id, sheet) => {
-  state$e.styleSheets[id] = sheet;
+  state$f.styleSheets[id] = sheet;
 };
 const get$b = id => {
-  return state$e.styleSheets[id];
+  return state$f.styleSheets[id];
 };
 const setText$2 = (id, text) => {
-  state$e.texts[id] = text;
+  state$f.texts[id] = text;
 };
 const getText = id => {
-  return state$e.texts[id];
+  return state$f.texts[id];
 };
 const remove$5 = id => {
-  delete state$e.styleSheets[id];
-  delete state$e.texts[id];
+  delete state$f.styleSheets[id];
+  delete state$f.texts[id];
 };
 
 const addCssStyleSheet = (id, text) => {
@@ -331,7 +331,7 @@ const createIdGenerator = () => {
 };
 const create$J = createIdGenerator();
 
-const state$d = Object.create(null);
+const state$e = Object.create(null);
 const retainString = (item, index) => {
   const value = new Promise(resolve => {
     item.getAsString(resolve);
@@ -382,22 +382,22 @@ const retainItems = dataTransfer => {
 };
 const add$2 = dataTransfer => {
   const id = create$J();
-  state$d[id] = retainItems(dataTransfer);
+  state$e[id] = retainItems(dataTransfer);
   return id;
 };
 const acquire$2 = id => {
-  const items = state$d[id];
+  const items = state$e[id];
   if (!items) {
     throw new Error(`Drop data not found: ${id}`);
   }
-  delete state$d[id];
+  delete state$e[id];
   return items;
 };
 
-const state$c = Object.create(null);
+const state$d = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$c[id];
-  delete state$c[id];
+  const promise = state$d[id];
+  delete state$d[id];
   return promise;
 };
 const getFileHandles$1 = async ids => {
@@ -407,7 +407,7 @@ const getFileHandles$1 = async ids => {
 };
 const add$1 = promise => {
   const id = create$J();
-  state$c[id] = promise;
+  state$d[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -609,14 +609,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$b = {
+const state$c = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$b.ipc;
+  return state$c.ipc;
 };
 const setIpc = value => {
-  state$b.ipc = value;
+  state$c.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -2039,830 +2039,428 @@ const unregisterView = uid => {
   viewRpcIds.delete(uid);
 };
 
-const downloadFile = (fileName, url) => {
-  const a = document.createElement('a');
-  a.href = url;
-  a.download = fileName;
-  a.click();
-};
+const Web = 1;
+const Electron$1 = 2;
+const Remote = 3;
 
-const isFile = value => {
-  return value instanceof File;
+/**
+ * @returns {number}
+ */
+const getPlatform = () => {
+  // @ts-expect-error
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-expect-error
+    return PLATFORM;
+  }
+  // @ts-ignore
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Remote;
+  }
+  if (globalThis.isElectron) {
+    return Electron$1;
+  }
+  if (typeof location !== 'undefined' && location.search === '?web') {
+    return Web;
+  }
+  return Remote;
 };
+const platform = Remote;
 
-const getFilePathElectron = async file => {
-  if (!isFile(file)) {
-    throw new TypeError(`file must be of type File`);
+const getAssetDir = () => {
+  // @ts-expect-error
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-expect-error
+    return ASSET_DIR;
   }
-  if (!globalThis.electronGlobals) {
-    throw new Error(`electron globals are not available`);
+  if (platform === Electron$1) {
+    return '../../../../..';
   }
-  const filePath = globalThis.electronGlobals.getPathForFile(file);
-  return filePath;
+  return '';
 };
+const assetDir = '/00cccba';
 
-const validFormats = new Set(['file', 'fileSystemHandle', 'string']);
-const validateOptions = options => {
-  if (!options || !Array.isArray(options.formats) || typeof options.includeElectronFilePaths !== 'boolean') {
-    throw new TypeError('Invalid drop data options');
+const getConfiguredWorkerUrl = key => {
+  if (typeof location === 'undefined' || typeof document === 'undefined') {
+    return '';
   }
-  for (const format of options.formats) {
-    if (!validFormats.has(format)) {
-      throw new TypeError(`Invalid drop data format: ${format}`);
-    }
+  const configElement = document.getElementById('Config');
+  if (!configElement) {
+    return '';
+  }
+  const text = configElement.textContent;
+  if (!text) {
+    return '';
   }
+  const config = JSON.parse(text);
+  return config[key] || '';
 };
-const resolveString = async item => {
-  return {
-    index: item.index,
-    kind: 'string',
-    type: item.type,
-    value: await item.value
-  };
+
+const getConfiguredDragAndDropWorkerUrl = () => {
+  const workerUrls = getConfiguredWorkerUrl('workerUrls');
+  return workerUrls?.['develop.dragAndDropWorkerPath'] || '';
 };
-const resolveFile = async (item, formats, includeElectronFilePaths) => {
-  const includeFile = formats.has('file');
-  const includeFileSystemHandle = formats.has('fileSystemHandle');
-  const fileSystemHandle = includeFileSystemHandle ? await item.fileSystemHandle : undefined;
-  const electronFilePath = includeElectronFilePaths && globalThis.electronGlobals && item.file ? await getFilePathElectron(item.file) : undefined;
-  if ((!includeFile || !item.file) && !fileSystemHandle && electronFilePath === undefined) {
-    return undefined;
+
+const dragAndDropWorkerUrl = getConfiguredDragAndDropWorkerUrl() || `${assetDir}/packages/drag-and-drop-worker/dist/dragAndDropWorkerMain.js`;
+
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
   }
-  return {
-    ...(electronFilePath !== undefined && {
-      electronFilePath
-    }),
-    ...(includeFile && item.file && {
-      file: item.file
-    }),
-    ...(fileSystemHandle && {
-      fileSystemHandle
-    }),
-    index: item.index,
-    kind: 'file',
-    name: fileSystemHandle?.name || item.file?.name || '',
-    type: item.type
-  };
-};
-const get$6 = async (dropId, options) => {
-  validateOptions(options);
-  const retainedItems = acquire$2(dropId);
-  const formats = new Set(options.formats);
-  const items = [];
-  for (const retainedItem of retainedItems) {
-    if (retainedItem.kind === 'string') {
-      if (formats.has('string')) {
-        items.push(await resolveString(retainedItem));
-      }
-      continue;
-    }
-    const item = await resolveFile(retainedItem, formats, options.includeElectronFilePaths);
-    if (item) {
-      items.push(item);
-    }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
   }
-  return items;
+  return line;
 };
-
-const isFileSystemFileHandle = value => {
-  if (!value || typeof value !== 'object') {
-    return false;
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
   }
-  const candidate = value;
-  return candidate.kind === 'file' && typeof candidate.getFile === 'function';
+  return stringifiedError;
 };
-const getNativeFile = async item => {
-  if (item.kind === 'file-legacy') {
-    return item.value instanceof File ? item.value : undefined;
+const NewLine$3 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
+};
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
   }
-  if (item.file instanceof File) {
-    return item.file;
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
   }
-  if (isFileSystemFileHandle(item.value)) {
-    return item.value.getFile();
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
   }
-  return undefined;
+  return child;
 };
-const addElectronPath = async item => {
-  if (!globalThis.electronGlobals) {
-    return item;
-  }
-  const file = await getNativeFile(item);
-  if (!file) {
-    return item;
+let VError$1 = class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(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 path = await getFilePathElectron(file);
-  return {
-    ...item,
-    path
-  };
-};
-const get$5 = async ids => {
-  const items = await getFileHandles$1(ids);
-  return Promise.all(items.map(addElectronPath));
 };
 
-const showDirectoryPicker = options => {
-  // @ts-expect-error
-  return window.showDirectoryPicker(options);
-};
-const showFilePicker = options => {
-  // @ts-expect-error
-  return window.showOpenFilePicker(options);
+const isMessagePort$1 = value => {
+  return value && value instanceof MessagePort;
 };
-const showSaveFilePicker = options => {
-  // @ts-expect-error
-  return window.showSaveFilePicker(options);
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
-
-const requestPermission = (handle, options) => {
-  return handle.requestPermission(options);
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
-const getFileHandles = ids => {
-  return getFileHandles$1(ids);
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
 };
-const addFileHandle = fileHandle => {
-  return addFileHandle$1(fileHandle);
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
 };
-
-const getTitleBarHeight = () => {
-  if (
-  // @ts-expect-error
-  globalThis.navigator.windowControlsOverlay?.getTitlebarAreaRect) {
-    // @ts-expect-error
-    const titleBarRect = globalThis.navigator.windowControlsOverlay.getTitlebarAreaRect();
-    return titleBarRect.height;
+const transferrables$1 = [isMessagePort$1, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable$1 = value => {
+  for (const fn of transferrables$1) {
+    if (fn(value)) {
+      return true;
+    }
   }
-  return 0;
-};
-const getBounds = () => {
-  return {
-    titleBarHeight: getTitleBarHeight(),
-    windowHeight: window.innerHeight,
-    windowWidth: window.innerWidth
-  };
-};
-
-const getPathName = () => {
-  return location.pathname;
-};
-const getHref = () => {
-  return location.href;
-};
-const matchesPathName = (currentPathName, pathName) => {
-  const resolvedPathName = new URL(pathName, getHref()).pathname;
-  return currentPathName === resolvedPathName;
+  return false;
 };
-const setPathName = pathName => {
-  const currentPathName = getPathName();
-  if (matchesPathName(currentPathName, pathName)) {
+const walkValue$1 = (value, transferrables, isTransferrable) => {
+  if (!value) {
     return;
   }
-  history.pushState(null, '', pathName);
-};
-const hydrate$3 = () => {
-  // addEventListener('popstate', handlePopState)
-};
-
-const shouldLaunchMultipleWorkers = true;
-
-const getConfig = () => {
-  const configElement = document.getElementById('Config');
-  if (!configElement?.textContent) {
-    return {};
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
   }
-  return JSON.parse(configElement.textContent);
-};
-const getInitData = () => {
-  const initData = {
-    Config: {
-      ...getConfig(),
-      shouldLaunchMultipleWorkers: shouldLaunchMultipleWorkers
-    },
-    Layout: {
-      bounds: getBounds()
-    },
-    Location: {
-      href: getHref()
-    }
-  };
-  return initData;
-};
-
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerWithMessagePort = 4;
-const Electron$1 = 5;
-
-const Message$2 = 'message';
-const Error$3 = 'error';
-
-const withResolvers = () => {
-  return Promise.withResolvers();
-};
-
-const getFirstEvent$1 = (eventTarget, eventMap) => {
-  const {
-    promise,
-    resolve
-  } = withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      eventTarget.removeEventListener(event, listenerMap[event]);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue$1(item, transferrables, isTransferrable);
     }
-    resolve(value);
-  };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        event,
-        type
-      });
-    };
-    eventTarget.addEventListener(event, listener);
-    listenerMap[event] = listener;
+    return;
   }
-  return promise;
-};
-
-/**
- *
- * @param {Worker} worker
- * @returns
- */
-const getFirstWorkerEvent$1 = worker => {
-  return getFirstEvent$1(worker, {
-    error: Error$3,
-    message: Message$2
-  });
-};
-
-const transferrables$1 = [];
-if (typeof MessagePort !== 'undefined') {
-  transferrables$1.push(MessagePort);
-}
-if (typeof OffscreenCanvas !== 'undefined') {
-  transferrables$1.push(OffscreenCanvas);
-}
-
-const isTransferrable$1 = value => {
-  for (const fn of transferrables$1) {
-    if (value instanceof fn) {
-      return true;
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue$1(property, transferrables, isTransferrable);
     }
   }
-  return false;
 };
-
-const walkValue$1 = (value, transferrables) => {
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue$1(value, transferrables, isTransferrable$1);
+  return transferrables;
+};
+const removeValues = (value, toRemove) => {
   if (!value) {
-    return;
-  }
-  if (isTransferrable$1(value)) {
-    transferrables.push(value);
+    return value;
   }
   if (Array.isArray(value)) {
+    const newItems = [];
     for (const item of value) {
-      walkValue$1(item, transferrables);
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
     }
-    return;
+    return newItems;
   }
   if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue$1(property, transferrables);
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
     }
+    return newObject;
   }
+  return value;
 };
 
-const getTransfer = value => {
-  const transferrables = [];
-  walkValue$1(value, transferrables);
-  return transferrables;
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
 };
-
-let IpcError$1 = class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
+const attachEvents$8 = 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$8(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$2 = '\n';
+const joinLines$2 = lines => {
+  return lines.join(NewLine$2);
 };
-
-const isErrorEvent$1 = event => {
-  return event instanceof ErrorEvent;
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
 };
-
-const NewLine$3 = '\n';
-
-const joinLines$2 = lines => {
-  return lines.join(NewLine$3);
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$2(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine$1(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
 };
-
 const splitLines$2 = lines => {
-  string(lines);
-  return lines.split(NewLine$3);
+  return lines.split(NewLine$2);
 };
-
-let WorkerError$1 = class WorkerError extends Error {
-  constructor(event) {
-    super(event.message);
-    const stackLines = splitLines$2(this.stack);
-    const relevantLines = stackLines.slice(1);
-    const relevant = joinLines$2(relevantLines);
-    this.stack = `${event.message}
-    at Module (${event.filename}:${event.lineno}:${event.colno})
-${relevant}`;
-  }
+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 Module$1 = 'module';
-
-const getWorkerDisplayName$1 = name => {
-  if (name && name.endsWith('Worker')) {
-    return name;
-  }
-  return `${name} worker`;
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
-const create$I = async ({
-  name,
-  url
-}) => {
-  const worker = new Worker(url, {
-    name,
-    type: Module$1
-  });
-  // @ts-expect-error
-  const {
-    event,
-    type
-  } = await getFirstWorkerEvent$1(worker);
-  switch (type) {
-    case Message$2:
-      if (event.data !== 'ready') {
-        throw new IpcError$1('unexpected first message from worker');
-      }
-      break;
-    case Error$3:
-      if (isErrorEvent$1(event)) {
-        throw new WorkerError$1(event);
-      }
-      const displayName = getWorkerDisplayName$1(name);
-      throw new IpcError$1(`Failed to start ${displayName}`);
-  }
-  return worker;
+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 getData$1 = event => {
-  // TODO why are some events not instance of message event?
-  if (event instanceof MessageEvent) {
-    return event.data;
-  }
-  return event;
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
-const wrap = worker => {
-  let handleMessage;
-  const wrapped = {
-    get onmessage() {
-      return handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        handleMessage = event => {
-          const data = getData$1(event);
-          listener({
-            data,
-            target: wrapped
-          });
-        };
-      } else {
-        handleMessage = null;
-      }
-      worker.onmessage = handleMessage;
-    },
-    send(message) {
-      worker.postMessage(message);
-    },
-    sendAndTransfer(message) {
-      const transfer = getTransfer(message);
-      worker.postMessage(message, transfer);
-    }
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$2(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
-  return wrapped;
-};
-
-const IpcParentWithModuleWorker$2 = {
-  __proto__: null,
-  create: create$I,
-  wrap
-};
-
-const isMessagePort$1 = value => {
-  return value instanceof MessagePort;
 };
-
-const create$H = async ({
-  url
-}) => {
-  string(url);
-  const portPromise = await new Promise(resolve => {
-    Object.defineProperty(globalThis, 'acceptPort', {
-      configurable: true,
-      value: resolve
-    });
-  });
-  await import(url);
-  const port = await portPromise;
-  delete globalThis.acceptPort;
-  if (!port) {
-    throw new IpcError$1('port must be defined');
-  }
-  if (!isMessagePort$1(port)) {
-    throw new IpcError$1('port must be of type MessagePort');
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  return port;
-};
-
-const IpcParentWithMessagePort$2 = {
-  __proto__: null,
-  create: create$H
-};
-
-const create$G = async url => {
-  const referencePort = await new Promise(resolve => {
-    Object.defineProperty(globalThis, 'acceptReferencePort', {
-      configurable: true,
-      value: resolve
-    });
-    import(url);
-  });
-  delete globalThis.acceptReferencePort;
-  return referencePort;
-};
-
-const IpcParentWithReferencePort = {
-  __proto__: null,
-  create: create$G
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
   }
-  return line;
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
+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 NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
 };
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
+const getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
   }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
   }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
   }
-  return child;
+  const lines = splitLines$2(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails$1(lines);
+  return {
+    code: '',
+    message: actualMessage,
+    stack: rest
+  };
 };
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
+let IpcError$1 = class IpcError extends VError$1 {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
       // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
       // @ts-ignore
-      this.code = error.code;
+      cause.code = code;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
     }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
   }
 };
-
-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 readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
 };
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
+const listen$9 = () => {
+  return globalThis;
 };
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
+const signal$a = global => {
+  global.postMessage(readyMessage);
 };
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
-    }
+class IpcChildWithElectronWindow extends Ipc {
+  getData(event) {
+    return getData$2(event);
   }
-  return false;
-};
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
+  send(message) {
+    this._rawIpc.postMessage(message);
   }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, location.origin, transfer);
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
+  dispose() {
+    // ignore
   }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    const wrapped = event => {
+      const {
+        ports
+      } = event;
+      if (ports.length > 0) {
+        return;
+      }
+      callback(event);
+      this._rawIpc.removeEventListener('message', wrapped);
+    };
+    this._rawIpc.addEventListener('message', wrapped);
   }
+}
+const wrap$h = window => {
+  return new IpcChildWithElectronWindow(window);
 };
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const removeValues = (value, toRemove) => {
-  if (!value) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    const newItems = [];
-    for (const item of value) {
-      if (!toRemove.includes(item)) {
-        newItems.push(removeValues(item, toRemove));
-      }
-    }
-    return newItems;
-  }
-  if (typeof value === 'object') {
-    const newObject = Object.create(null);
-    for (const [key, property] of Object.entries(value)) {
-      if (!toRemove.includes(property)) {
-        newObject[key] = removeValues(property, toRemove);
-      }
-    }
-    return newObject;
-  }
-  return value;
-};
-
-// workaround for electron not supporting transferrable objects
-// as parameters. If the transferrable object is a parameter, in electron
-// only an empty objected is received in the main process
-const fixElectronParameters = value => {
-  const transfer = getTransferrables(value);
-  const newValue = removeValues(value, transfer);
-  return {
-    newValue,
-    transfer
-  };
-};
-const attachEvents$8 = 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$8(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$1 = '\n';
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
-};
-const RE_AT$1 = /^\s+at/;
-const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
-const isNormalStackLine$1 = line => {
-  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
-};
-const getDetails$1 = lines => {
-  const index = lines.findIndex(isNormalStackLine$1);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines$1(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine$1(lines[lastIndex])) {
-      break;
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
-};
-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 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 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 {
-    code: ERR_MODULE_NOT_FOUND,
-    message
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-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 getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    code: E_INCOMPATIBLE_NATIVE_MODULE,
-    message: `Incompatible native node module: ${message}`
-  };
-};
-const getModuleSyntaxError = () => {
-  return {
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
-    message: `ES Modules are not supported in electron`
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails$1(lines);
-  return {
-    code: '',
-    message: actualMessage,
-    stack: rest
-  };
-};
-class IpcError extends VError$1 {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        code,
-        message,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      if (stack) {
-        Object.defineProperty(cause, 'stack', {
-          configurable: true,
-          enumerable: false,
-          value: stack,
-          writable: true
-        });
-      }
-      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 listen$9 = () => {
-  return globalThis;
-};
-const signal$a = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithElectronWindow extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const {
-      newValue,
-      transfer
-    } = fixElectronParameters(message);
-    this._rawIpc.postMessage(newValue, location.origin, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    const wrapped = event => {
-      const {
-        ports
-      } = event;
-      if (ports.length > 0) {
-        return;
-      }
-      callback(event);
-      this._rawIpc.removeEventListener('message', wrapped);
-    };
-    this._rawIpc.addEventListener('message', wrapped);
-  }
-}
-const wrap$h = window => {
-  return new IpcChildWithElectronWindow(window);
-};
-const IpcChildWithElectronWindow$1 = {
-  __proto__: null,
-  listen: listen$9,
-  signal: signal$a,
-  wrap: wrap$h
+const IpcChildWithElectronWindow$1 = {
+  __proto__: null,
+  listen: listen$9,
+  signal: signal$a,
+  wrap: wrap$h
 };
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
@@ -2878,7 +2476,7 @@ const removeListener = (emitter, type, callback) => {
     emitter.off(type, callback);
   }
 };
-const getFirstEvent = (eventEmitter, eventMap) => {
+const getFirstEvent$1 = (eventEmitter, eventMap) => {
   const {
     promise,
     resolve
@@ -2907,13 +2505,13 @@ const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
-  if (!isMessagePort(messagePort)) {
-    throw new IpcError('port must be of type MessagePort');
+  if (!isMessagePort$1(messagePort)) {
+    throw new IpcError$1('port must be of type MessagePort');
   }
   if (isMessagePortOpen) {
     return messagePort;
   }
-  const eventPromise = getFirstEvent(messagePort, {
+  const eventPromise = getFirstEvent$1(messagePort, {
     message: Message$1
   });
   messagePort.start();
@@ -2922,17 +2520,17 @@ const create$5$1 = async ({
     type
   } = await eventPromise;
   if (type !== Message$1) {
-    throw new IpcError('Failed to wait for ipc message');
+    throw new IpcError$1('Failed to wait for ipc message');
   }
   if (event.data !== readyMessage) {
-    throw new IpcError('unexpected first message');
+    throw new IpcError$1('unexpected first message');
   }
   return messagePort;
 };
 const signal$1 = messagePort => {
   messagePort.start();
 };
-class IpcParentWithMessagePort extends Ipc {
+let IpcParentWithMessagePort$1 = class IpcParentWithMessagePort extends Ipc {
   getData = getData$2;
   send(message) {
     this._rawIpc.postMessage(message);
@@ -2948,28 +2546,28 @@ class IpcParentWithMessagePort extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
   onClose(callback) {}
-}
+};
 const wrap$5 = messagePort => {
-  return new IpcParentWithMessagePort(messagePort);
+  return new IpcParentWithMessagePort$1(messagePort);
 };
-const IpcParentWithMessagePort$1 = {
+const IpcParentWithMessagePort$1$1 = {
   __proto__: null,
   create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
-const Message = 'message';
+const Message$2 = 'message';
 const Error$1$1 = 'error';
-const getFirstWorkerEvent = worker => {
-  return getFirstEvent(worker, {
+const getFirstWorkerEvent$1 = worker => {
+  return getFirstEvent$1(worker, {
     error: Error$1$1,
-    message: Message
+    message: Message$2
   });
 };
-const isErrorEvent = event => {
+const isErrorEvent$1 = event => {
   return event instanceof ErrorEvent;
 };
-const getWorkerDisplayName = name => {
+const getWorkerDisplayName$1 = name => {
   if (!name) {
     return '<unknown> worker';
   }
@@ -2981,42 +2579,42 @@ const getWorkerDisplayName = name => {
 const tryToGetActualErrorMessage = async ({
   name
 }) => {
-  const displayName = getWorkerDisplayName(name);
+  const displayName = getWorkerDisplayName$1(name);
   return `Failed to start ${displayName}: Worker Launch Error`;
 };
-class WorkerError extends Error {
+let WorkerError$1 = class WorkerError extends Error {
   constructor(event) {
     super(event.message);
-    const stackLines = splitLines$1(this.stack || '');
+    const stackLines = splitLines$2(this.stack || '');
     const relevantLines = stackLines.slice(1);
-    const relevant = joinLines$1(relevantLines);
+    const relevant = joinLines$2(relevantLines);
     this.stack = `${event.message}
     at Module (${event.filename}:${event.lineno}:${event.colno})
 ${relevant}`;
   }
-}
-const Module = 'module';
+};
+const Module$1 = 'module';
 const create$4$1 = async ({
   name,
   url
 }) => {
   const worker = new Worker(url, {
     name,
-    type: Module
+    type: Module$1
   });
   const {
     event,
     type
-  } = await getFirstWorkerEvent(worker);
+  } = await getFirstWorkerEvent$1(worker);
   switch (type) {
-    case Message:
+    case Message$2:
       if (event.data !== readyMessage) {
-        throw new IpcError('unexpected first message from worker');
+        throw new IpcError$1('unexpected first message from worker');
       }
       break;
     case Error$1$1:
-      if (isErrorEvent(event)) {
-        throw new WorkerError(event);
+      if (isErrorEvent$1(event)) {
+        throw new WorkerError$1(event);
       }
       const actualErrorMessage = await tryToGetActualErrorMessage({
         name
@@ -3025,16 +2623,16 @@ const create$4$1 = async ({
   }
   return worker;
 };
-const getData = event => {
+const getData$1 = event => {
   // TODO why are some events not instance of message event?
   if (event instanceof MessageEvent) {
     return event.data;
   }
   return event;
 };
-class IpcParentWithModuleWorker extends Ipc {
+let IpcParentWithModuleWorker$1 = class IpcParentWithModuleWorker extends Ipc {
   getData(event) {
-    return getData(event);
+    return getData$1(event);
   }
   send(message) {
     this._rawIpc.postMessage(message);
@@ -3052,11 +2650,11 @@ class IpcParentWithModuleWorker extends Ipc {
   onMessage(callback) {
     this._rawIpc.addEventListener('message', callback);
   }
-}
+};
 const wrap$4 = worker => {
-  return new IpcParentWithModuleWorker(worker);
+  return new IpcParentWithModuleWorker$1(worker);
 };
-const IpcParentWithModuleWorker$1 = {
+const IpcParentWithModuleWorker$1$1 = {
   __proto__: null,
   create: create$4$1,
   wrap: wrap$4
@@ -3085,7 +2683,7 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get$4 = id => {
+const get$6 = id => {
   return callbacks[id];
 };
 const remove$4 = id => {
@@ -3097,7 +2695,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine = '\n';
+const NewLine$1 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -3145,26 +2743,26 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-const splitLines = lines => {
-  return lines.split(NewLine);
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
 };
 const getCurrentStack = () => {
   const stackLinesToSkip = 3;
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex) => {
   {
-    return string.indexOf(NewLine);
+    return string.indexOf(NewLine$1);
   }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+    parentStack = error.message + NewLine$1 + parentStack;
   }
   return parentStack;
 };
@@ -3189,19 +2787,19 @@ const setStack = (error, stack) => {
 };
 const restoreExistingError = (error, currentStack) => {
   if (typeof error.stack === 'string') {
-    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+    setStack(error, `${error.stack}${NewLine$1}${currentStack}`);
   }
   return error;
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
   const parentStack = getParentStack(error);
-  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  setStack(restoredError, `${parentStack}${NewLine$1}${currentStack}`);
   return restoredError;
 };
 const restoreStackFromData = (restoredError, error, currentStack) => {
   if (error.data.stack && error.data.type && error.message) {
-    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine$1}${error.data.stack}${NewLine$1}${currentStack}`);
     return;
   }
   if (error.data.stack) {
@@ -3275,7 +2873,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$4(id);
+  const fn = get$6(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -3338,7 +2936,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$F = (message, result) => {
+const create$I = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -3347,7 +2945,7 @@ const create$F = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$F(message, resultProperty);
+  return create$I(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -3436,212 +3034,737 @@ const handleJsonRpcMessage = async (...args) => {
     await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
     return;
   }
-  throw new JsonRpcError('unexpected message');
-};
-
-const Two = '2.0';
-
-const create$E = (method, params) => {
+  throw new JsonRpcError('unexpected message');
+};
+
+const Two = '2.0';
+
+const create$H = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$G = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$F = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$F();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$G(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$H(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError$1 = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage);
+  } else {
+    // deprecated
+    ipc.onmessage = null;
+  }
+};
+
+const create$E = async ({
+  commandMap,
+  window
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = IpcChildWithElectronWindow$1.wrap(window);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+const create$D = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const isWorker = value => {
+  return value instanceof Worker;
+};
+
+const create$C = async ({
+  commandMap,
+  name,
+  url
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const worker = await IpcParentWithModuleWorker$1$1.create({
+    name,
+    url
+  });
+  if (!isWorker(worker)) {
+    throw new Error(`worker must be of type Worker`);
+  }
+  const ipc = IpcParentWithModuleWorker$1$1.wrap(worker);
+  handleIpc(ipc);
+  const workerRpc = createRpc(ipc);
+  return workerRpc;
+};
+
+const create$B = async ({
+  commandMap,
+  name,
+  port,
+  url
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const worker = await IpcParentWithModuleWorker$1$1.create({
+    name,
+    url
+  });
+  if (!isWorker(worker)) {
+    throw new Error(`worker must be of type Worker`);
+  }
+  const ipc = IpcParentWithModuleWorker$1$1.wrap(worker);
+  handleIpc(ipc);
+  const workerRpc = createRpc(ipc);
+  await workerRpc.invokeAndTransfer('initialize', 'message-port', port);
+  unhandleIpc(ipc);
+  return workerRpc;
+};
+
+const create$A = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$D({
+    commandMap,
+    messagePort
+  });
+};
+
+const commandMapRef = {};
+
+const success = value => {
+  return {
+    ok: true,
+    value
+  };
+};
+const error = error => {
+  return {
+    error,
+    ok: false
+  };
+};
+const isError = result => {
+  return !result.ok;
+};
+
+const launchWorker = async ({
+  name,
+  url
+}) => {
+  try {
+    const rpc = await create$C({
+      commandMap: commandMapRef,
+      name,
+      url
+    });
+    return success(rpc);
+  } catch (error$1) {
+    return error(error$1);
+  }
+};
+
+const launchDragAndDropWorker = async () => {
+  return launchWorker({
+    name: 'Drag And Drop Worker',
+    url: dragAndDropWorkerUrl
+  });
+};
+
+const state$b = {
+  rpc: undefined
+};
+const hydrate$4 = async () => {
+  const result = await launchDragAndDropWorker();
+  if (isError(result)) {
+    state$b.rpc = undefined;
+    return result;
+  }
+  state$b.rpc = result.value;
+  return success(undefined);
+};
+const handleMessagePort$1 = async port => {
+  if (!state$b.rpc) {
+    throw new Error('Drag And Drop Worker is not initialized');
+  }
+  await state$b.rpc.invokeAndTransfer('DragAndDrop.handleMessagePort', port);
+};
+
+const downloadFile = (fileName, url) => {
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = fileName;
+  a.click();
+};
+
+const isFile = value => {
+  return value instanceof File;
+};
+
+const getFilePathElectron = async file => {
+  if (!isFile(file)) {
+    throw new TypeError(`file must be of type File`);
+  }
+  if (!globalThis.electronGlobals) {
+    throw new Error(`electron globals are not available`);
+  }
+  const filePath = globalThis.electronGlobals.getPathForFile(file);
+  return filePath;
+};
+
+const validFormats = new Set(['file', 'fileSystemHandle', 'string']);
+const validateOptions = options => {
+  if (!options || !Array.isArray(options.formats) || typeof options.includeElectronFilePaths !== 'boolean') {
+    throw new TypeError('Invalid drop data options');
+  }
+  for (const format of options.formats) {
+    if (!validFormats.has(format)) {
+      throw new TypeError(`Invalid drop data format: ${format}`);
+    }
+  }
+};
+const resolveString = async item => {
+  return {
+    index: item.index,
+    kind: 'string',
+    type: item.type,
+    value: await item.value
+  };
+};
+const resolveFile = async (item, formats, includeElectronFilePaths) => {
+  const includeFile = formats.has('file');
+  const includeFileSystemHandle = formats.has('fileSystemHandle');
+  const fileSystemHandle = includeFileSystemHandle ? await item.fileSystemHandle : undefined;
+  const electronFilePath = includeElectronFilePaths && globalThis.electronGlobals && item.file ? await getFilePathElectron(item.file) : undefined;
+  if ((!includeFile || !item.file) && !fileSystemHandle && electronFilePath === undefined) {
+    return undefined;
+  }
+  return {
+    ...(electronFilePath !== undefined && {
+      electronFilePath
+    }),
+    ...(includeFile && item.file && {
+      file: item.file
+    }),
+    ...(fileSystemHandle && {
+      fileSystemHandle
+    }),
+    index: item.index,
+    kind: 'file',
+    name: fileSystemHandle?.name || item.file?.name || '',
+    type: item.type
+  };
+};
+const get$5 = async (dropId, options) => {
+  validateOptions(options);
+  const retainedItems = acquire$2(dropId);
+  const formats = new Set(options.formats);
+  const items = [];
+  for (const retainedItem of retainedItems) {
+    if (retainedItem.kind === 'string') {
+      if (formats.has('string')) {
+        items.push(await resolveString(retainedItem));
+      }
+      continue;
+    }
+    const item = await resolveFile(retainedItem, formats, options.includeElectronFilePaths);
+    if (item) {
+      items.push(item);
+    }
+  }
+  return items;
+};
+
+const isFileSystemFileHandle = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const candidate = value;
+  return candidate.kind === 'file' && typeof candidate.getFile === 'function';
+};
+const getNativeFile = async item => {
+  if (item.kind === 'file-legacy') {
+    return item.value instanceof File ? item.value : undefined;
+  }
+  if (item.file instanceof File) {
+    return item.file;
+  }
+  if (isFileSystemFileHandle(item.value)) {
+    return item.value.getFile();
+  }
+  return undefined;
+};
+const addElectronPath = async item => {
+  if (!globalThis.electronGlobals) {
+    return item;
+  }
+  const file = await getNativeFile(item);
+  if (!file) {
+    return item;
+  }
+  const path = await getFilePathElectron(file);
   return {
-    jsonrpc: Two,
-    method,
-    params
+    ...item,
+    path
   };
 };
+const get$4 = async ids => {
+  const items = await getFileHandles$1(ids);
+  return Promise.all(items.map(addElectronPath));
+};
 
-const create$D = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
-  };
-  return message;
+const showDirectoryPicker = options => {
+  // @ts-expect-error
+  return window.showDirectoryPicker(options);
+};
+const showFilePicker = options => {
+  // @ts-expect-error
+  return window.showOpenFilePicker(options);
+};
+const showSaveFilePicker = options => {
+  // @ts-expect-error
+  return window.showSaveFilePicker(options);
 };
 
-let id = 0;
-const create$C = () => {
-  return ++id;
+const requestPermission = (handle, options) => {
+  return handle.requestPermission(options);
+};
+const getFileHandles = ids => {
+  return getFileHandles$1(ids);
+};
+const addFileHandle = fileHandle => {
+  return addFileHandle$1(fileHandle);
 };
 
-const registerPromise = map => {
-  const id = create$C();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
+const getTitleBarHeight = () => {
+  if (
+  // @ts-expect-error
+  globalThis.navigator.windowControlsOverlay?.getTitlebarAreaRect) {
+    // @ts-expect-error
+    const titleBarRect = globalThis.navigator.windowControlsOverlay.getTitlebarAreaRect();
+    return titleBarRect.height;
+  }
+  return 0;
+};
+const getBounds = () => {
   return {
-    id,
-    promise
+    titleBarHeight: getTitleBarHeight(),
+    windowHeight: window.innerHeight,
+    windowWidth: window.innerWidth
   };
 };
 
-const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-  const {
-    id,
-    promise
-  } = registerPromise(callbacks);
-  const message = create$D(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
+const getPathName = () => {
+  return location.pathname;
+};
+const getHref = () => {
+  return location.href;
+};
+const matchesPathName = (currentPathName, pathName) => {
+  const resolvedPathName = new URL(pathName, getHref()).pathname;
+  return currentPathName === resolvedPathName;
+};
+const setPathName = pathName => {
+  const currentPathName = getPathName();
+  if (matchesPathName(currentPathName, pathName)) {
+    return;
   }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
+  history.pushState(null, '', pathName);
 };
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
-    async dispose() {
-      await ipc?.dispose();
-    },
-    invoke(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, false);
+const hydrate$3 = () => {
+  // addEventListener('popstate', handlePopState)
+};
+
+const shouldLaunchMultipleWorkers = true;
+
+const getConfig = () => {
+  const configElement = document.getElementById('Config');
+  if (!configElement?.textContent) {
+    return {};
+  }
+  return JSON.parse(configElement.textContent);
+};
+const getInitData = () => {
+  const initData = {
+    Config: {
+      ...getConfig(),
+      shouldLaunchMultipleWorkers: shouldLaunchMultipleWorkers
     },
-    invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, true);
+    Layout: {
+      bounds: getBounds()
     },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$E(method, params);
-      ipc.send(message);
+    Location: {
+      href: getHref()
     }
   };
-  return rpc;
+  return initData;
 };
 
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ReferencePort = 3;
+const ModuleWorkerWithMessagePort = 4;
+const Electron = 5;
+
+const Message = 'message';
+const Error$3 = 'error';
+
+const withResolvers = () => {
+  return Promise.withResolvers();
 };
-const logError$1 = () => {
-  // handled by renderer worker
+
+const getFirstEvent = (eventTarget, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = 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({
+        event,
+        type
+      });
+    };
+    eventTarget.addEventListener(event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
 };
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError$1, actualRequiresSocket);
+
+/**
+ *
+ * @param {Worker} worker
+ * @returns
+ */
+const getFirstWorkerEvent = worker => {
+  return getFirstEvent(worker, {
+    error: Error$3,
+    message: Message
+  });
 };
 
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
+const transferrables = [];
+if (typeof MessagePort !== 'undefined') {
+  transferrables.push(MessagePort);
+}
+if (typeof OffscreenCanvas !== 'undefined') {
+  transferrables.push(OffscreenCanvas);
+}
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (value instanceof fn) {
+      return true;
+    }
   }
+  return false;
 };
-const unhandleIpc = ipc => {
-  if ('removeEventListener' in ipc) {
-    ipc.removeEventListener('message', handleMessage);
-  } else {
-    // deprecated
-    ipc.onmessage = null;
+
+const walkValue = (value, transferrables) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables);
+    }
   }
 };
 
-const create$B = async ({
-  commandMap,
-  window
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = IpcChildWithElectronWindow$1.wrap(window);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
+const getTransfer = value => {
+  const transferrables = [];
+  walkValue(value, transferrables);
+  return transferrables;
+};
+
+class IpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'IpcError';
+  }
+}
+
+const isErrorEvent = event => {
+  return event instanceof ErrorEvent;
 };
 
-const create$A = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
+const NewLine = '\n';
+
+const joinLines = lines => {
+  return lines.join(NewLine);
 };
 
-const isWorker = value => {
-  return value instanceof Worker;
+const splitLines = lines => {
+  string(lines);
+  return lines.split(NewLine);
 };
 
+class WorkerError extends Error {
+  constructor(event) {
+    super(event.message);
+    const stackLines = splitLines(this.stack);
+    const relevantLines = stackLines.slice(1);
+    const relevant = joinLines(relevantLines);
+    this.stack = `${event.message}
+    at Module (${event.filename}:${event.lineno}:${event.colno})
+${relevant}`;
+  }
+}
+
+const Module = 'module';
+
+const getWorkerDisplayName = name => {
+  if (name && name.endsWith('Worker')) {
+    return name;
+  }
+  return `${name} worker`;
+};
 const create$z = async ({
-  commandMap,
   name,
   url
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const worker = await IpcParentWithModuleWorker$1.create({
+  const worker = new Worker(url, {
     name,
-    url
+    type: Module
   });
-  if (!isWorker(worker)) {
-    throw new Error(`worker must be of type Worker`);
+  // @ts-expect-error
+  const {
+    event,
+    type
+  } = await getFirstWorkerEvent(worker);
+  switch (type) {
+    case Message:
+      if (event.data !== 'ready') {
+        throw new IpcError('unexpected first message from worker');
+      }
+      break;
+    case Error$3:
+      if (isErrorEvent(event)) {
+        throw new WorkerError(event);
+      }
+      const displayName = getWorkerDisplayName(name);
+      throw new IpcError(`Failed to start ${displayName}`);
   }
-  const ipc = IpcParentWithModuleWorker$1.wrap(worker);
-  handleIpc(ipc);
-  const workerRpc = createRpc(ipc);
-  return workerRpc;
+  return worker;
+};
+const getData = event => {
+  // TODO why are some events not instance of message event?
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+const wrap = worker => {
+  let handleMessage;
+  const wrapped = {
+    get onmessage() {
+      return handleMessage;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        handleMessage = event => {
+          const data = getData(event);
+          listener({
+            data,
+            target: wrapped
+          });
+        };
+      } else {
+        handleMessage = null;
+      }
+      worker.onmessage = handleMessage;
+    },
+    send(message) {
+      worker.postMessage(message);
+    },
+    sendAndTransfer(message) {
+      const transfer = getTransfer(message);
+      worker.postMessage(message, transfer);
+    }
+  };
+  return wrapped;
+};
+
+const IpcParentWithModuleWorker = {
+  __proto__: null,
+  create: create$z,
+  wrap
+};
+
+const isMessagePort = value => {
+  return value instanceof MessagePort;
 };
 
 const create$y = async ({
-  commandMap,
-  name,
-  port,
   url
 }) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const worker = await IpcParentWithModuleWorker$1.create({
-    name,
-    url
+  string(url);
+  const portPromise = await new Promise(resolve => {
+    Object.defineProperty(globalThis, 'acceptPort', {
+      configurable: true,
+      value: resolve
+    });
   });
-  if (!isWorker(worker)) {
-    throw new Error(`worker must be of type Worker`);
+  await import(url);
+  const port = await portPromise;
+  delete globalThis.acceptPort;
+  if (!port) {
+    throw new IpcError('port must be defined');
   }
-  const ipc = IpcParentWithModuleWorker$1.wrap(worker);
-  handleIpc(ipc);
-  const workerRpc = createRpc(ipc);
-  await workerRpc.invokeAndTransfer('initialize', 'message-port', port);
-  unhandleIpc(ipc);
-  return workerRpc;
+  if (!isMessagePort(port)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  return port;
 };
 
-const create$x = async ({
-  commandMap,
-  messagePort
-}) => {
-  return create$A({
-    commandMap,
-    messagePort
+const IpcParentWithMessagePort = {
+  __proto__: null,
+  create: create$y
+};
+
+const create$x = async url => {
+  const referencePort = await new Promise(resolve => {
+    Object.defineProperty(globalThis, 'acceptReferencePort', {
+      configurable: true,
+      value: resolve
+    });
+    import(url);
   });
+  delete globalThis.acceptReferencePort;
+  return referencePort;
+};
+
+const IpcParentWithReferencePort = {
+  __proto__: null,
+  create: create$x
 };
 
 const workers = Object.create(null);
@@ -3661,7 +3784,7 @@ const create$w = async ({
   raw,
   rpcId,
   url
-}, createTransferredRpc = create$y, createNativeRpc = create$z) => {
+}, createTransferredRpc = create$B, createNativeRpc = create$C) => {
   const rpc = await (rpcId === undefined ? createTransferredRpc({
     commandMap: {},
     name,
@@ -3688,34 +3811,7 @@ const IpcParentWithModuleWorkerWithMessagePort = {
   create: create$w
 };
 
-const Web = 1;
-const Electron = 2;
-const Remote = 3;
-
-/**
- * @returns {number}
- */
-const getPlatform = () => {
-  // @ts-expect-error
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-expect-error
-    return PLATFORM;
-  }
-  // @ts-ignore
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return Remote;
-  }
-  if (globalThis.isElectron) {
-    return Electron;
-  }
-  if (typeof location !== 'undefined' && location.search === '?web') {
-    return Web;
-  }
-  return Remote;
-};
-const platform = Remote;
-
-const isElectron = platform === Electron;
+const isElectron = platform === Electron$1;
 
 // TODO use handleIncomingIpc function
 const create$v = async ({
@@ -3726,7 +3822,7 @@ const create$v = async ({
   if (!isElectron) {
     throw new Error('Electron api was requested but is not available');
   }
-  const rpc = await create$B({
+  const rpc = await create$E({
     commandMap: {},
     window
   });
@@ -3741,12 +3837,12 @@ const IpcParentWithElectron = {
 
 const getModule = method => {
   switch (method) {
-    case Electron$1:
+    case Electron:
       return IpcParentWithElectron;
     case MessagePort$1:
-      return IpcParentWithMessagePort$2;
+      return IpcParentWithMessagePort;
     case ModuleWorker:
-      return IpcParentWithModuleWorker$2;
+      return IpcParentWithModuleWorker;
     case ModuleWorkerWithMessagePort:
       return IpcParentWithModuleWorkerWithMessagePort;
     case ReferencePort:
@@ -3770,69 +3866,6 @@ const has = name => {
   return ipcs[name];
 };
 
-const commandMapRef = {};
-
-const success = value => {
-  return {
-    ok: true,
-    value
-  };
-};
-const error = error => {
-  return {
-    error,
-    ok: false
-  };
-};
-const isError = result => {
-  return !result.ok;
-};
-
-const launchWorker = async ({
-  name,
-  url
-}) => {
-  try {
-    const rpc = await create$z({
-      commandMap: commandMapRef,
-      name,
-      url
-    });
-    return success(rpc);
-  } catch (error$1) {
-    return error(error$1);
-  }
-};
-
-const getAssetDir = () => {
-  // @ts-expect-error
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-expect-error
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
-  }
-  return '';
-};
-const assetDir = '/31117c9';
-
-const getConfiguredWorkerUrl = key => {
-  if (typeof location === 'undefined' || typeof document === 'undefined') {
-    return '';
-  }
-  const configElement = document.getElementById('Config');
-  if (!configElement) {
-    return '';
-  }
-  const text = configElement.textContent;
-  if (!text) {
-    return '';
-  }
-  const config = JSON.parse(text);
-  return config[key] || '';
-};
-
 const getConfiguredRendererWorkerUrl = () => {
   return getConfiguredWorkerUrl('rendererWorkerUrl');
 };
@@ -3841,7 +3874,7 @@ const rendererWorkerUrl = getConfiguredRendererWorkerUrl() || `${assetDir}/packa
 
 const getName = platform => {
   switch (platform) {
-    case Electron:
+    case Electron$1:
       return 'Renderer Worker (Electron)';
     case Web:
       return 'Renderer Worker (Web)';
@@ -4684,7 +4717,7 @@ const openUrl = (url, useRedirect = false) => {
 };
 
 const isElectronUserAgentSpecificMemoryError = error => {
-  if (platform !== Electron) {
+  if (platform !== Electron$1) {
     return;
   }
   return error.message === `Failed to execute 'measureUserAgentSpecificMemory' on 'Performance': performance.measureUserAgentSpecificMemory is not available.`;
@@ -9877,7 +9910,7 @@ const forwardRendererWorkerCommand = (method, ...params) => {
   send$1(method, ...params);
 };
 const handleMessagePort = async (port, rpcId) => {
-  const rpc = await create$x({
+  const rpc = await create$A({
     commandMap: {
       'Viewlet.forwardRendererWorkerCommand': forwardRendererWorkerCommand,
       'Viewlet.queueCommands': queueCommands
@@ -10157,8 +10190,9 @@ const commandMap = {
   'DirectView.getFocusedUid': getFocusedViewUid,
   'DirectView.getUid': getViewUid,
   'Download.downloadFile': downloadFile,
-  'DropData.get': get$6,
-  'FileHandles.get': get$5,
+  'DragAndDrop.handleMessagePort': handleMessagePort$1,
+  'DropData.get': get$5,
+  'FileHandles.get': get$4,
   'FilePicker.showDirectoryPicker': showDirectoryPicker,
   'FilePicker.showFilePicker': showFilePicker,
   'FilePicker.showSaveFilePicker': showSaveFilePicker,
@@ -10330,7 +10364,7 @@ const mergeCustom = (custom, relevantStack) => {
 };
 const cleanStack = stack => {
   string(stack);
-  const lines = splitLines$2(stack);
+  const lines = splitLines(stack);
   const {
     actualStack,
     custom
@@ -10380,7 +10414,7 @@ const prepareErrorMessageWithCodeFrame = error => {
   }
   const message = getErrorMessage(error);
   const lines = cleanStack(error.stack);
-  const relevantStack = joinLines$2(lines);
+  const relevantStack = joinLines(lines);
   if (error.codeFrame) {
     return {
       _error: error,
@@ -10599,19 +10633,19 @@ const hydrate = async () => {
   return success(undefined);
 };
 
-const workerFns = [hydrate$2, hydrate$1, hydrate];
+const requiredWorkerFns = [hydrate$2, hydrate$4];
+const additionalWorkerFns = [hydrate$1, hydrate];
 const call = fn => {
   return fn();
 };
 const launchWorkers = async () => {
-  {
-    const results = await Promise.all(workerFns.map(call));
-    const firstError = results.find(isError);
-    if (firstError) {
-      return firstError;
-    }
-    return success(undefined);
+  const workerFns = [...requiredWorkerFns, ...additionalWorkerFns] ;
+  const results = await Promise.all(workerFns.map(call));
+  const firstError = results.find(isError);
+  if (firstError) {
+    return firstError;
   }
+  return success(undefined);
 };
 
 const handleFocusIn = event => {