@lvce-editor/server 0.34.2 → 0.34.3

package/static/{8fe40a3 → 5143a5a}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -1,15 +1,15 @@
-const state$Q = {
+const state$R = {
   width: 0,
   height: 0
 };
 const get$h = () => {
   return {
-    width: state$Q.width,
-    height: state$Q.height
+    width: state$R.width,
+    height: state$R.height
   };
 };
 const set$h = (width, height) => {
-  state$Q.width = width, state$Q.height = height;
+  state$R.width = width, state$R.height = height;
 };
 
 let AssertionError$1 = class AssertionError extends Error {
@@ -86,17 +86,17 @@ const fn = value => {
   }
 };
 
-const state$P = {
+const state$Q = {
   pending: Object.create(null)
 };
 const get$g = id => {
-  return state$P.pending[id];
+  return state$Q.pending[id];
 };
 const has$1 = id => {
-  return id in state$P.pending;
+  return id in state$Q.pending;
 };
 const set$g = (id, value) => {
-  state$P.pending[id] = value;
+  state$Q.pending[id] = value;
 };
 
 const Web$1 = 1;
@@ -110,7 +110,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/8fe40a3';
+    return '/5143a5a';
   }
 };
 const assetDir = getAssetDir();
@@ -279,11 +279,11 @@ const get$f = id => {
 const remove$b = id => {
   delete state$1$1.callbacks[id];
 };
-const state$O = {
+const state$P = {
   id: 0
 };
 const create$3$1 = () => {
-  return ++state$O.id;
+  return ++state$P.id;
 };
 const warn$2 = (...args) => {
   console.warn(...args);
@@ -815,7 +815,7 @@ const getModuleId$1 = commandId => {
   }
 };
 
-const state$N = {
+const state$O = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -838,26 +838,26 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$N.load(moduleId);
+    const module = await state$O.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$N.pendingModules[moduleId]) {
-    state$N.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$O.pendingModules[moduleId]) {
+    state$O.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$N.pendingModules[moduleId];
+  return state$O.pendingModules[moduleId];
 };
 const loadCommand = command => getOrLoadModule(getModuleId$1(command));
 const register$2 = (commandId, listener) => {
-  state$N.commands[commandId] = listener;
+  state$O.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$N.commands) {
-    const fn = state$N.commands[command];
+  if (command in state$O.commands) {
+    const fn = state$O.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -866,7 +866,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$N.commands)) {
+    if (!(command in state$O.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -877,7 +877,7 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$N.load = load;
+  state$O.load = load;
 };
 
 const handleJsonRpcMessage = async (ipc, message, execute, resolve, source) => {
@@ -1079,7 +1079,7 @@ const listen$2 = async ({
 };
 
 /* istanbul ignore file */
-const state$M = {
+const state$N = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1092,16 +1092,16 @@ const getIpc = () => {
   });
 };
 const listen$1 = async () => {
-  console.assert(state$M.pendingMessages.length === 0);
+  console.assert(state$N.pendingMessages.length === 0);
   const ipc = await getIpc();
   handleIpc(ipc);
-  state$M.ipc = ipc;
+  state$N.ipc = ipc;
 };
 const invoke$8 = (method, ...params) => {
-  return invoke$9(state$M.ipc, method, ...params);
+  return invoke$9(state$N.ipc, method, ...params);
 };
 const invokeAndTransfer$7 = (method, ...params) => {
-  return invokeAndTransfer$8(state$M.ipc, method, ...params);
+  return invokeAndTransfer$8(state$N.ipc, method, ...params);
 };
 
 const actuallyLoadCssStyleSheet = async css => {
@@ -1768,7 +1768,7 @@ const getMessage$5 = error => {
   return `Error: ${error}`;
 };
 
-const state$L = {
+const state$M = {
   /**
    * @type {string[]}
    */
@@ -1801,14 +1801,14 @@ const showErrorDialog = async error => {
 };
 const warn = (...args) => {
   const stringified = JSON.stringify(args);
-  if (state$L.seenWarnings.includes(stringified)) {
+  if (state$M.seenWarnings.includes(stringified)) {
     return;
   }
-  state$L.seenWarnings.push(stringified);
+  state$M.seenWarnings.push(stringified);
   console.warn(...args);
 };
 
-const state$K = {
+const state$L = {
   /**
    * @type {any}
    */
@@ -1819,14 +1819,14 @@ const state$K = {
 const invoke$7 = async (method, ...params) => {
   const {
     ipc
-  } = state$K;
+  } = state$L;
   const result = await invoke$9(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$6 = async (method, ...params) => {
   const {
     ipc
-  } = state$K;
+  } = state$L;
   const result = await invokeAndTransfer$8(ipc, method, ...params);
   return result;
 };
@@ -2005,24 +2005,24 @@ const canBeRestored$6 = async uri => {
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$J = {
+const state$K = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$J.listenerMap[event] || [];
+  const listeners = state$K.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$J.listenerMap[event] ||= [];
-  if (state$J.listenerMap[event].includes(fn)) {
+  state$K.listenerMap[event] ||= [];
+  if (state$K.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$J.listenerMap[event].unshift(fn);
+    state$K.listenerMap[event].unshift(fn);
   } else {
-    state$J.listenerMap[event].push(fn);
+    state$K.listenerMap[event].push(fn);
   }
 };
 
@@ -2072,7 +2072,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$I = Object.create(null);
+const state$J = Object.create(null);
 const openSettingsJson = async () => {
   await openUri$1('app://settings.json');
 };
@@ -2103,25 +2103,25 @@ const hydrate$b = async () => {
     // TODO should configuration be together with all other preferences (e.g. selecting color theme code is not needed on startup)
     // TODO probably not all preferences need to be kept in memory
     const preferences = await getPreferences();
-    Object.assign(state$I, preferences);
+    Object.assign(state$J, preferences);
   } catch (error) {
     logError(error);
   }
 };
 const get$d = key => {
-  return state$I[key];
+  return state$J[key];
 };
 const set$e = async (key, value) => {
-  state$I[key] = value;
+  state$J[key] = value;
   if (platform === Web$1) {
     const preferences = {
-      ...state$I,
+      ...state$J,
       [key]: value
     };
     await execute$4(/* LocalStorage.setJson */'LocalStorage.setJson', /* key */'preferences', /* value */preferences);
     return;
   }
-  const content = stringify(state$I);
+  const content = stringify(state$J);
   await writeFile$e('app://settings.json', content);
 };
 
@@ -2175,7 +2175,7 @@ const setThemeColor = async themeColor => {
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$H = {
+const state$I = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2186,7 +2186,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$H.colorTheme = colorThemeId;
+    state$I.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
     if (platform === Web$1) {
@@ -2206,10 +2206,10 @@ const setColorTheme$1 = async colorThemeId => {
   await set$e('workbench.colorTheme', colorThemeId);
 };
 const watch$2 = async id => {
-  if (state$H.watchedTheme === id) {
+  if (state$I.watchedTheme === id) {
     return;
   }
-  state$H.watchedTheme = id;
+  state$I.watchedTheme = id;
   await invoke$7('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
@@ -2303,18 +2303,18 @@ const remove$9 = key => {
   delete contexts[key];
 };
 
-const state$G = {
+const state$H = {
   // TODO use numeric focus key
   currentFocus: ''
 };
 const get$b = () => {
-  return state$G.currentFocus;
+  return state$H.currentFocus;
 };
 const set$c = value => {
-  state$G.currentFocus = value;
+  state$H.currentFocus = value;
 };
 
-const state$F = {
+const state$G = {
   keyBindings: [],
   keyBindingSets: Object.create(null),
   /**
@@ -2327,7 +2327,7 @@ const state$F = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$F.matchingKeyBindings) {
+  for (const keyBinding of state$G.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -2350,26 +2350,26 @@ const getAvailableKeyBindings = keyBindings => {
   return new Uint32Array(keyBindings.map(getKey$1));
 };
 const update = () => {
-  const matchingKeyBindings = getMatchingKeyBindings(state$F.keyBindingSets);
+  const matchingKeyBindings = getMatchingKeyBindings(state$G.keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
   invoke$8('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$F.matchingKeyBindings = matchingKeyBindings;
-  state$F.keyBindingIdentifiers = keyBindingIdentifiers;
+  state$G.matchingKeyBindings = matchingKeyBindings;
+  state$G.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings$1 = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$F.keyBindingSets) {
+  if (id in state$G.keyBindingSets) {
     warn$1(`cannot add keybindings multiple times: ${id}`);
     return;
   }
-  state$F.keyBindingSets[id] = keyBindings;
+  state$G.keyBindingSets[id] = keyBindings;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets
-  } = state$F;
+  } = state$G;
   if (!(id in keyBindingSets)) {
     warn$1(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -2466,7 +2466,7 @@ const hydrate$9 = async () => {
   update();
 };
 
-const state$E = {
+const state$F = {
   /**
    * @type {any[]}
    */
@@ -2485,7 +2485,7 @@ const getIconThemeJson = async iconThemeId => {
       extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
     };
   }
-  for (const webExtension of state$E.webExtensions) {
+  for (const webExtension of state$F.webExtensions) {
     if (webExtension.iconThemes) {
       for (const iconTheme of webExtension.iconThemes) {
         // TODO handle error when icon theme path is not of type string
@@ -2503,7 +2503,7 @@ const getIconThemeJson = async iconThemeId => {
 
 const initialIconTheme = undefined;
 
-const state$D = {
+const state$E = {
   seenFiles: [],
   seenFolders: [],
   hasWarned: [],
@@ -2523,11 +2523,11 @@ const isOpen = () => {
   return false;
 };
 
-const state$C = {
+const state$D = {
   id: 0
 };
 const create$1a = () => {
-  return ++state$C.id;
+  return ++state$D.id;
 };
 
 class CancelationError extends Error {
@@ -2640,7 +2640,7 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value);
 };
 
-const state$B = {
+const state$C = {
   instances: Object.create(null),
   /**
    * @type {any}
@@ -2653,10 +2653,10 @@ const set$b = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$B.instances[key] = value;
+  state$C.instances[key] = value;
 };
 const getInstance = key => {
-  const fast = state$B.instances[key];
+  const fast = state$C.instances[key];
   if (fast) {
     return fast;
   }
@@ -2669,7 +2669,7 @@ const getInstance = key => {
   if (key === 'EditorCompletion') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$B.instances)) {
+  for (const value of Object.values(state$C.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -2677,16 +2677,16 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$B.instances;
+  return key in state$C.instances;
 };
 const remove$8 = key => {
-  delete state$B.instances[key];
+  delete state$C.instances[key];
 };
 const getAllInstances = () => {
-  return state$B.instances;
+  return state$C.instances;
 };
 const getValues = () => {
-  return Object.values(state$B.instances);
+  return Object.values(state$C.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -2738,7 +2738,7 @@ const set$a = title => {
   return invoke$8('WindowTitle.set', title);
 };
 
-const state$A = {
+const state$B = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -2756,16 +2756,16 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$A.workspacePath = path;
+  state$B.workspacePath = path;
   // @ts-ignore
-  state$A.workspaceUri = path;
-  state$A.pathSeparator = pathSeparator;
+  state$B.workspaceUri = path;
+  state$B.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async uri => {
   const path = uri.slice('file://'.length);
-  state$A.workspacePath = path;
-  state$A.workspaceUri = uri;
+  state$B.workspacePath = path;
+  state$B.workspaceUri = uri;
   await onWorkspaceChange();
 };
 const close$9 = () => {
@@ -2786,12 +2786,12 @@ const getResolveRootFromSessionStorage = async () => {
   return resolvedRoot;
 };
 const isTest = () => {
-  return state$A.isTest;
+  return state$B.isTest;
 };
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$A.isTest = true;
+    state$B.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -2840,7 +2840,7 @@ const getResolvedRoot = async href => {
   }
 };
 const getTitle$1 = workspacePath => {
-  const pathSeparator = state$A.pathSeparator;
+  const pathSeparator = state$B.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
 };
 const getPathName = workspacePath => {
@@ -2850,41 +2850,41 @@ const getPathName = workspacePath => {
   return '';
 };
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$A.workspacePath);
+  const title = getTitle$1(state$B.workspacePath);
   await set$a(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$A.workspacePath);
+    const pathName = getPathName(state$B.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$A.workspacePath);
+  await emitEvent('workspace.change', state$B.workspacePath);
 };
 const hydrate$7 = async ({
   href
 }) => {
-  if (state$A.workspacePath) {
+  if (state$B.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$A.isTest) {
+  if (state$B.isTest) {
     return;
   }
-  if (state$A.workspacePath) {
+  if (state$B.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$A.homeDir !== resolvedRoot.homeDir) {
-    state$A.homeDir = resolvedRoot.homeDir;
+  if (state$B.homeDir !== resolvedRoot.homeDir) {
+    state$B.homeDir = resolvedRoot.homeDir;
   }
   if (!canBeRestored$6(resolvedRoot.path)) {
     return;
   }
   // TODO how to check that path from renderer process is valid?
   // TODO also need to check whether it is a folder or file
-  state$A.workspacePath = resolvedRoot.path;
-  state$A.homeDir = resolvedRoot.homeDir;
-  state$A.pathSeparator = resolvedRoot.pathSeparator;
-  state$A.workspaceUri = resolvedRoot.uri;
-  state$A.source = resolvedRoot.source;
+  state$B.workspacePath = resolvedRoot.path;
+  state$B.homeDir = resolvedRoot.homeDir;
+  state$B.pathSeparator = resolvedRoot.pathSeparator;
+  state$B.workspaceUri = resolvedRoot.uri;
+  state$B.source = resolvedRoot.source;
   await onWorkspaceChange();
 };
 
@@ -2893,10 +2893,10 @@ const hydrate$7 = async ({
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$A.workspacePath;
+  return state$B.workspacePath;
 };
 const getHomeDir = () => {
-  return state$A.homeDir;
+  return state$B.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -2904,15 +2904,15 @@ const pathBaseName = path => {
   return path.slice(path.lastIndexOf('/') + 1);
 };
 const pathRelative = path => {
-  if (path.startsWith(state$A.workspacePath)) {
-    return path.slice(state$A.workspacePath.length + 1, path.lastIndexOf('/'));
+  if (path.startsWith(state$B.workspacePath)) {
+    return path.slice(state$B.workspacePath.length + 1, path.lastIndexOf('/'));
   }
   return path;
 };
 
 // TODO this should be in FileSystem module
 const pathDirName = path => {
-  const pathSeparator = state$A.pathSeparator || '/';
+  const pathSeparator = state$B.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString;
@@ -2921,9 +2921,9 @@ const pathDirName = path => {
 };
 const getAbsolutePath = relativePath => {
   if (relativePath.startsWith('./')) {
-    return `${state$A.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
+    return `${state$B.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
   }
-  return `${state$A.workspacePath}/${relativePath}`; // TODO support windows paths
+  return `${state$B.workspacePath}/${relativePath}`; // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -2933,10 +2933,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$A.workspacePath,
-      homeDir: state$A.homeDir,
-      pathSeparator: state$A.pathSeparator,
-      uri: state$A.workspaceUri
+      path: state$B.workspacePath,
+      homeDir: state$B.homeDir,
+      pathSeparator: state$B.pathSeparator,
+      uri: state$B.workspaceUri
     }
   };
 };
@@ -2971,14 +2971,14 @@ const getSavedViewletState = viewletId => {
   return getJson$2(viewletId);
 };
 
-const state$z = {
+const state$A = {
   idMap: Object.create(null)
 };
 const register$1 = (id, module) => {
-  state$z.idMap[id] = module;
+  state$A.idMap[id] = module;
 };
 const get$a = id => {
-  return state$z.idMap[id];
+  return state$A.idMap[id];
 };
 
 const loadModule$3 = async (id, module) => {
@@ -2988,7 +2988,7 @@ const loadModule$3 = async (id, module) => {
     await (Array.isArray(module.Css) ? loadCssStyleSheets(module.Css) : loadCssStyleSheet(module.Css));
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$I);
+    await addDynamicCss(id, module.getDynamicCss, state$J);
   }
 };
 
@@ -2997,17 +2997,17 @@ const ViewletManagerVisitorCss = {
   loadModule: loadModule$3
 };
 
-const state$y = {
+const state$z = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$y.menuEntries;
+  return state$z.menuEntries;
 };
 const add$1 = menuEntries => {
-  state$y.menuEntries = [...state$y.menuEntries, ...menuEntries];
+  state$z.menuEntries = [...state$z.menuEntries, ...menuEntries];
 };
 
 const loadModule$2 = (id, module) => {
@@ -3158,7 +3158,7 @@ const ViewletModuleId = {
 };
 
 // @ts-nocheck
-const state$x = {
+const state$y = {
   pendingModules: Object.create(null)
 };
 const ViewletState = {
@@ -3435,10 +3435,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$x.pendingModules)) {
-    state$x.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$y.pendingModules)) {
+    state$y.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$x.pendingModules[id];
+  return state$y.pendingModules[id];
 };
 
 // TODO add lots of unit tests for this
@@ -3710,14 +3710,14 @@ const disposeBrowserViewQuickPick = () => {
   return invoke$7('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
-const state$w = {
+const state$x = {
   id: 0
 };
 const set$9 = value => {
-  state$w.id = value;
+  state$x.id = value;
 };
 const get$9 = () => {
-  return state$w.id;
+  return state$x.id;
 };
 
 // TODO cache window id
@@ -3813,15 +3813,15 @@ const handleKeyBinding$1 = async identifier => {
   // }
 };
 
-const state$v = {
+const state$w = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$v.isQuickPickOpen;
+  return state$w.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$v.isQuickPickOpen = false;
+  state$w.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -4275,7 +4275,7 @@ const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
   return '';
 };
 const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$E.webExtensions, languageId);
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$F.webExtensions, languageId);
   if (!languageConfigurationPath) {
     return undefined;
   }
@@ -4335,7 +4335,7 @@ const getNthFileExtension = (file, startIndex) => {
 
 // TODO merge all of this with extension host languages module
 
-const state$u = {
+const state$v = {
   loadState: false,
   isHydrating: false,
   fileNameMap: Object.create(null),
@@ -4351,53 +4351,53 @@ const state$u = {
   hasWarned: []
 };
 const getFirstLines = () => {
-  return state$u.firstLines;
+  return state$v.firstLines;
 };
 const hasLanguageByExtension = extension => {
-  return extension in state$u.extensionMap;
+  return extension in state$v.extensionMap;
 };
 const getLanguageByExtension = extension => {
-  return state$u.extensionMap[extension];
+  return state$v.extensionMap[extension];
 };
 const hasLanguageByFileName = fileName => {
-  return fileName in state$u.fileNameMap;
+  return fileName in state$v.fileNameMap;
 };
 const getLanguageByFileName = fileName => {
-  return state$u.fileNameMap[fileName];
+  return state$v.fileNameMap[fileName];
 };
 const getTokenizeFunctionPath$1 = languageId => {
   // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return state$u.tokenizerMap[languageId] || '';
+  return state$v.tokenizerMap[languageId] || '';
 };
 const setHydrating = value => {
-  state$u.isHydrating = value;
+  state$v.isHydrating = value;
 };
 const setLoaded = value => {
-  state$u.loaded = true;
+  state$v.loaded = true;
 };
 const addExtension = (extension, languageId) => {
-  state$u.extensionMap[extension] = languageId;
+  state$v.extensionMap[extension] = languageId;
 };
 const addFirstLine = (regex, languageId) => {
-  state$u.firstLines.push({
+  state$v.firstLines.push({
     regex,
     languageId
   });
 };
 const hasWarned = languageId => {
-  return state$u.hasWarned.includes(languageId);
+  return state$v.hasWarned.includes(languageId);
 };
 const addWarned = languageId => {
-  return state$u.hasWarned.push(languageId);
+  return state$v.hasWarned.push(languageId);
 };
 const addFileName = (fileName, languageId) => {
-  state$u.fileNameMap[fileName] = languageId;
+  state$v.fileNameMap[fileName] = languageId;
 };
 const addTokenizer = (languageId, tokenizer) => {
-  state$u.tokenizerMap[languageId] = tokenizer;
+  state$v.tokenizerMap[languageId] = tokenizer;
 };
 const hasLoaded$1 = () => {
-  return state$u.loaded;
+  return state$v.loaded;
 };
 
 // TODO merge all of this with extension host languages module
@@ -4587,7 +4587,7 @@ const getFileNameIcon = file => {
   string(file);
   const {
     iconTheme
-  } = state$D;
+  } = state$E;
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return '';
@@ -4627,7 +4627,7 @@ const getFileIcon$3 = file => {
   return getFileNameIcon(file.name);
 };
 const getFolderNameIcon = folderName => {
-  const iconTheme = state$D.iconTheme;
+  const iconTheme = state$E.iconTheme;
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return '';
@@ -4644,7 +4644,7 @@ const getFolderIcon = folder => {
   return getFolderNameIcon(folder.name);
 };
 const getFolderIconExpanded = folder => {
-  const iconTheme = state$D.iconTheme;
+  const iconTheme = state$E.iconTheme;
   if (!iconTheme) {
     return '';
   }
@@ -4673,7 +4673,7 @@ const getIcon$2 = dirent => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$D.iconTheme, File$7);
+      return getAbsoluteIconPath(state$E.iconTheme, File$7);
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$k;
@@ -4683,8 +4683,8 @@ const getIcon$2 = dirent => {
 const setIconTheme = async iconThemeId => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$D.iconTheme = iconTheme.json;
-    state$D.extensionPath = iconTheme.extensionPath;
+    state$E.iconTheme = iconTheme.json;
+    state$E.extensionPath = iconTheme.extensionPath;
     const instances = getAllInstances();
     // TODO have one recalculate style and one paint
     // @ts-ignore
@@ -4738,7 +4738,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$K.ipc = ipc;
+  state$L.ipc = ipc;
 };
 
 const map$2 = Object.create(null);
@@ -4783,6 +4783,16 @@ const hydrate$3 = async () => {
   }
 };
 
+const state$u = {
+  shouldLaunchMultipleWorkers: false
+};
+const setConfig = shouldLaunchMultipleWorkers => {
+  state$u.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+};
+const getConfig = () => {
+  return state$u.shouldLaunchMultipleWorkers;
+};
+
 const Zero = 0;
 const One = 1;
 const Three = 3;
@@ -5705,7 +5715,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$M.ipc;
+  const originalIpc = state$N.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -5720,33 +5730,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$M.ipc.onmessage = originalAddEventListsner;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalAddEventListsner;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$M.ipc.onmessage = originalAddEventListsner;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalAddEventListsner;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$M.ipc.onmessage = originalAddEventListsner;
-          state$M.ipc.send = originalSend;
+          state$N.ipc.onmessage = originalAddEventListsner;
+          state$N.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$M.ipc.onmessage = wrappedOnMessage;
-          state$M.ipc.send = wrappedSend;
+          state$N.ipc.onmessage = wrappedOnMessage;
+          state$N.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$M.ipc.send = wrappedSend;
-  state$M.ipc.addEventListener('message', wrappedOnMessage);
+  state$N.ipc.send = wrappedSend;
+  state$N.ipc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -5818,8 +5828,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$M.ipc = wrapIpc(state$M.ipc, 'renderer-process', event => event.data);
-  state$K.ipc = wrapIpc(state$K.ipc, 'shared-process', event => event);
+  state$N.ipc = wrapIpc(state$N.ipc, 'renderer-process', event => event.data);
+  state$L.ipc = wrapIpc(state$L.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -5921,6 +5931,7 @@ const startup = async () => {
     return;
   }
   if (initData.Location.href.startsWith('http://localhost:3001/tests/')) ;
+  setConfig(initData.Config?.shouldLaunchMultipleWorkers);
   set$h(initData.Layout.bounds.windowWidth, initData.Layout.bounds.windowHeight);
   mark(WillLoadPreferences);
   await hydrate$b();
@@ -6203,17 +6214,184 @@ const getOrCreateWorker = fn => {
 
 const extensionHostWorkerUrl = getExtensionHostWorkerUrl();
 
+const ModuleWorkerWithMessagePort = 4;
+const Electron = 5;
+
+const getPortTuple = initialPort => {
+  if (initialPort) {
+    return {
+      port1: undefined,
+      port2: initialPort
+    };
+  }
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+
+const transferrables = [];
+if (typeof OffscreenCanvas !== 'undefined') {
+  transferrables.push(OffscreenCanvas);
+}
+if (typeof MessagePort !== 'undefined') {
+  transferrables.push(MessagePort);
+}
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (value instanceof fn) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+
+const create$17 = async ({
+  url,
+  name,
+  port,
+  id
+}) => {
+  // TODO no need to create port if worker
+  // has been prelaunched in renderer process
+  const {
+    port1,
+    port2
+  } = getPortTuple(port);
+  await invokeAndTransfer$7('IpcParent.create', {
+    method: ModuleWorkerWithMessagePort,
+    url,
+    name,
+    raw: true,
+    port: port2,
+    id
+  });
+  return port1;
+};
+
+// TODO why are some events not instance of message event?
+
+const getData$1 = event => {
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+const wrap$7 = port => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      const wrappedListener = event => {
+        const data = getData$1(event);
+        const syntheticEvent = {
+          data,
+          target: this
+        };
+        listener(syntheticEvent);
+      };
+      this.port.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message) {
+      const transfer = getTransferrables(message);
+      this.port.postMessage(message, transfer);
+    },
+    dispose() {
+      this.port.postMessage({
+        jsonrpc: '2.0',
+        method: 'Exit.exit',
+        params: []
+      });
+      this.port.close();
+    }
+  };
+};
+
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$17,
+  wrap: wrap$7
+};
+
+const objects = Object.create(null);
+const transferToRendererProcess = async (objectId, transferable) => {
+  await invokeAndTransfer$7('Transferrable.transfer', transferable, objectId);
+};
+const transfer = (objectId, transferable) => {
+  number$1(objectId);
+  object(transferable);
+  objects[objectId] = transferable;
+};
+const acquire = objectId => {
+  number$1(objectId);
+  const value = objects[objectId];
+  if (!value) {
+    throw new Error(`transferrable object not found`);
+  }
+  delete objects[objectId];
+  return value;
+};
+
 const launchExtensionHostWorker = async () => {
   const name = platform === Electron$1 ? 'Extension Host (Electron)' : 'Extension Host';
-  const ipc = await create$18({
+  const id = create$1a();
+  let ipc = await create$18({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: extensionHostWorkerUrl
+    url: extensionHostWorkerUrl,
+    id
   });
+  if (getConfig()) {
+    // TODO should renderer process send port to renderer worker or vice versa?
+    const port = acquire(id);
+    ipc = wrap$7(port);
+  }
   handleIpc(ipc);
-  await invoke$9(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
+  await invoke$9(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$9(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
+    await invoke$9(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
   });
   return ipc;
 };
@@ -6236,7 +6414,7 @@ const getStaticWebExtensions = () => {
 };
 const getWebExtensionsWeb = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$E.webExtensions];
+  return [...staticWebExtensions, ...state$F.webExtensions];
 };
 const isWebExtension = extension => {
   return extension && typeof extension.browser === 'string';
@@ -6245,7 +6423,7 @@ const getWebExtensionsDefault = async () => {
   const staticWebExtensions = await getStaticWebExtensions();
   const sharedProcessExtensions = await getSharedProcessExtensions$1();
   const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$E.webExtensions];
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$F.webExtensions];
 };
 const getWebExtensions = async () => {
   try {
@@ -6256,7 +6434,7 @@ const getWebExtensions = async () => {
         return getWebExtensionsDefault();
     }
   } catch {
-    return state$E.webExtensions;
+    return state$F.webExtensions;
   }
 };
 
@@ -6300,7 +6478,7 @@ const addWebExtension = async path => {
     }
   }
   manifest.status = Resolved;
-  state$E.webExtensions.push(manifest);
+  state$F.webExtensions.push(manifest);
   if (manifest.languages) {
     // TODO handle case when languages is not of type array
     await addLanguages(manifest.languages);
@@ -6458,7 +6636,7 @@ const actuallyActivateByEvent = async event => {
   for (const extension of extensionsToActivate) {
     await actuallyActivateExtension(extension);
   }
-  const additionalExtensions = state$E.webExtensions;
+  const additionalExtensions = state$F.webExtensions;
   const additionalExtensionsToActivate = filterByMatchingEvent(additionalExtensions, event);
   for (const extension of additionalExtensionsToActivate) {
     await actuallyActivateExtension(extension);
@@ -7985,51 +8163,6 @@ const TryToGetActualImportErrorMessage = {
   tryToGetActualImportErrorMessage
 };
 
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-
-const transferrables = [];
-if (typeof OffscreenCanvas !== 'undefined') {
-  transferrables.push(OffscreenCanvas);
-}
-if (typeof MessagePort !== 'undefined') {
-  transferrables.push(MessagePort);
-}
-
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (value instanceof fn) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-
 const removeValues = (value, toRemove) => {
   if (!value) {
     return value;
@@ -8067,33 +8200,13 @@ const fixElectronParameters = value => {
   };
 };
 
-const getData$1 = event => {
+const getData = event => {
   const {
     data
   } = event;
   return data;
 };
 
-const getPortTuple = initialPort => {
-  if (initialPort) {
-    return {
-      port1: undefined,
-      port2: initialPort
-    };
-  }
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const ModuleWorkerWithMessagePort = 4;
-const Electron = 5;
-
 const getPort = async ipcId => {
   const {
     port1,
@@ -8109,7 +8222,7 @@ const getPort = async ipcId => {
   set$9(webContentsId);
   return port2;
 };
-const create$17 = async options => {
+const create$16 = async options => {
   const type = options.type;
   const name = options.name || 'electron ipc';
   const ipcId = options.ipcId;
@@ -8118,7 +8231,7 @@ const create$17 = async options => {
   const port = await getPort(ipcId);
   return port;
 };
-const wrap$7 = port => {
+const wrap$6 = port => {
   return {
     port,
     /**
@@ -8131,7 +8244,7 @@ const wrap$7 = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const data = getData$1(event);
+        const data = getData(event);
         const syntheticEvent = {
           data,
           target: this
@@ -8155,8 +8268,8 @@ const wrap$7 = port => {
 
 const IpcParentWithElectronMessagePort = {
   __proto__: null,
-  create: create$17,
-  wrap: wrap$7
+  create: create$16,
+  wrap: wrap$6
 };
 
 class IpcError extends Error {
@@ -8170,7 +8283,7 @@ const isMessagePort = value => {
   return value instanceof MessagePort;
 };
 
-const create$16 = async ({
+const create$15 = async ({
   url
 }) => {
   string(url);
@@ -8188,7 +8301,7 @@ const create$16 = async ({
   }
   return port;
 };
-const wrap$6 = port => {
+const wrap$5 = port => {
   return {
     /**
      * @type {any}
@@ -8200,7 +8313,7 @@ const wrap$6 = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const message = getData$1(event);
+        const message = getData(event);
         const syntheticEvent = {
           data: message,
           target: this
@@ -8220,8 +8333,8 @@ const wrap$6 = port => {
 
 const IpcParentWithMessagePort = {
   __proto__: null,
-  create: create$16,
-  wrap: wrap$6
+  create: create$15,
+  wrap: wrap$5
 };
 
 const Message$2 = 'message';
@@ -8296,7 +8409,7 @@ const tryToGetActualErrorMessage = async ({
 
 const Module$1 = 'module';
 
-const create$15 = async ({
+const create$14 = async ({
   url,
   name
 }) => {
@@ -8324,7 +8437,7 @@ const create$15 = async ({
   return worker;
 };
 const getMessage$4 = event => {};
-const wrap$5 = worker => {
+const wrap$4 = worker => {
   return {
     worker,
     /**
@@ -8358,11 +8471,11 @@ const wrap$5 = worker => {
 
 const IpcParentWithModuleWorker = {
   __proto__: null,
-  create: create$15,
-  wrap: wrap$5
+  create: create$14,
+  wrap: wrap$4
 };
 
-const create$14 = async ({
+const create$13 = async ({
   url
 }) => {
   const referencePort = await new Promise(resolve => {
@@ -8375,7 +8488,7 @@ const create$14 = async ({
 const getMessage$3 = message => {
   return message;
 };
-const wrap$4 = referencePort => {
+const wrap$3 = referencePort => {
   return {
     referencePort,
     /**
@@ -8405,8 +8518,8 @@ const wrap$4 = referencePort => {
 
 const IpcParentWithReferencePort = {
   __proto__: null,
-  create: create$14,
-  wrap: wrap$4
+  create: create$13,
+  wrap: wrap$3
 };
 
 const Open = 1;
@@ -8426,7 +8539,7 @@ const getWebSocketUrl = (type, host) => {
   return `${wsProtocol}//${host}/websocket/${type}`;
 };
 
-const create$13 = (url, args) => {
+const create$12 = (url, args) => {
   const webSocket = new WebSocket(url, args);
   const reconnect = () => {
     const originalOnMessage = context.webSocket.onmessage;
@@ -8491,13 +8604,13 @@ const waitForWebSocketToBeOpen = webSocket => {
   });
 };
 
-const create$12 = async ({
+const create$11 = async ({
   type
 }) => {
   string(type);
   const host = getHost();
   const wsUrl = getWebSocketUrl(type, host);
-  const webSocket = create$13(wsUrl);
+  const webSocket = create$12(wsUrl);
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
   if (firstWebSocketEvent.type === Close$1) {
     throw new IpcError('Websocket connection was immediately closed');
@@ -8507,7 +8620,7 @@ const create$12 = async ({
 const getMessage$2 = event => {
   return parse$1(event.data);
 };
-const wrap$3 = webSocket => {
+const wrap$2 = webSocket => {
   return {
     webSocket,
     /**
@@ -8537,78 +8650,6 @@ const wrap$3 = webSocket => {
 };
 
 const IpcParentWithWebSocket = {
-  __proto__: null,
-  create: create$12,
-  wrap: wrap$3
-};
-
-const create$11 = async ({
-  url,
-  name,
-  port
-}) => {
-  const {
-    port1,
-    port2
-  } = getPortTuple(port);
-  await invokeAndTransfer$7('IpcParent.create', {
-    method: ModuleWorkerWithMessagePort,
-    url,
-    name,
-    raw: true,
-    port: port2
-  });
-  return port1;
-};
-
-// TODO why are some events not instance of message event?
-
-const getData = event => {
-  if (event instanceof MessageEvent) {
-    return event.data;
-  }
-  return event;
-};
-const wrap$2 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      const wrappedListener = event => {
-        const data = getData(event);
-        const syntheticEvent = {
-          data,
-          target: this
-        };
-        listener(syntheticEvent);
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message) {
-      const transfer = getTransferrables(message);
-      this.port.postMessage(message, transfer);
-    },
-    dispose() {
-      this.port.postMessage({
-        jsonrpc: '2.0',
-        method: 'Exit.exit',
-        params: []
-      });
-      this.port.close();
-    }
-  };
-};
-
-const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   __proto__: null,
   create: create$11,
   wrap: wrap$2
@@ -8695,7 +8736,7 @@ const wrap = port => {
     set onmessage(listener) {
       this.listener = listener;
       const wrappedListener = event => {
-        const data = getData$1(event);
+        const data = getData(event);
         const syntheticEvent = {
           data,
           target: this
@@ -9126,9 +9167,9 @@ const formatAboutDate = isoDate => {
   return `${isoDate} (${ago})`;
 };
 
-const version = '0.34.2';
-const commit = '8fe40a3';
-const date = '2024-09-14T13:42:44.000Z';
+const version = '0.34.3';
+const commit = '5143a5a';
+const date = '2024-09-14T22:44:46.000Z';
 const getPid = () => {
   return invoke$7('Process.getPid');
 };
@@ -11085,11 +11126,19 @@ const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
 
 const launchEditorWorker = async () => {
   const configuredWorkerUrl = getConfiguredWorkerUrl$1('developer.editorWorkerPath', editorWorkerUrl);
-  const ipc = await create$18({
+  const id = create$1a();
+  let ipc = await create$18({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url: configuredWorkerUrl,
-    name: 'Editor Worker'
+    name: 'Editor Worker',
+    id
   });
+  if (getConfig()) {
+    // TODO should renderer process send port to renderer worker or vice versa?
+    const port = acquire(id);
+    // TODO wrap port to create ipc
+    ipc = wrap$7(port);
+  }
   handleIpc(ipc);
   const syntaxHighlightingWorker = true;
   const syncIncremental = true;
@@ -12742,7 +12791,7 @@ const getMenuEntries$j = async (id, ...args) => {
 };
 
 const addKeyBindings = menuEntries => {
-  const keyBindings = state$F.matchingKeyBindings;
+  const keyBindings = state$G.matchingKeyBindings;
   const newMenuEntries = [];
   for (const menuEntry of menuEntries) {
     const keyBinding = getCommandKeyBinding(keyBindings, menuEntry.command, menuEntry.args);
@@ -14683,25 +14732,6 @@ const {
   invokeAndTransfer: invokeAndTransfer$3
 } = getOrCreateWorker(launchTerminalWorker);
 
-const objects = Object.create(null);
-const transferToRendererProcess = async (objectId, transferable) => {
-  await invokeAndTransfer$7('Transferrable.transfer', transferable, objectId);
-};
-const transfer = (objectId, transferable) => {
-  number$1(objectId);
-  object(transferable);
-  objects[objectId] = transferable;
-};
-const acquire = objectId => {
-  number$1(objectId);
-  const value = objects[objectId];
-  if (!value) {
-    throw new Error(`transferrable object not found`);
-  }
-  delete objects[objectId];
-  return value;
-};
-
 const create$Z = async canvasId => {
   number$1(canvasId);
   const id = create$1a();
@@ -15018,11 +15048,18 @@ const getConfiguredWorkerUrl = () => {
 const launchSyntaxHighlightingWorker = async () => {
   const configuredWorkerUrl = getConfiguredWorkerUrl();
   const name = 'Syntax Highlighting Worker';
-  const ipc = await create$18({
+  const id = create$1a();
+  let ipc = await create$18({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     name,
-    url: configuredWorkerUrl
+    url: configuredWorkerUrl,
+    id
   });
+  if (getConfig()) {
+    // TODO should renderer process send port to renderer worker or vice versa?
+    const port = acquire(id);
+    ipc = wrap$7(port);
+  }
   handleIpc(ipc);
   return ipc;
 };
@@ -17544,7 +17581,7 @@ const create$M = (key, value, unit = '') => {
   return `--${key}: ${value}${unit};`;
 };
 
-const Css$C = ["/css/parts/Symbol.css", "/css/parts/ViewletEditorCompletion.css", "/css/parts/ViewletList.css"];
+const Css$C = [];
 const getDynamicCss$1 = preferences => {
   const styles = [];
   const fontSize = preferences['editor.fontSize'];
@@ -18330,7 +18367,7 @@ const Commands$z = {
   openInNewTab: openInNewTab
 };
 
-const Css$z = ["/css/parts/E2eTests.css", "/css/parts/Welcome.css"];
+const Css$z = ["/css/parts/E2eTests.css"];
 
 const getKeyBindings$f = () => {
   return [];
@@ -18894,7 +18931,7 @@ const LazyCommands$e = {
   ...LazyCommands$f
 };
 
-const Css$y = ["/css/parts/ViewletEditorCompletion.css", "/css/parts/Symbol.css", "/css/parts/ViewletList.css"];
+const Css$y = [];
 const getDynamicCss = preferences => {
   const styles = [];
   const useLayer = preferences['completion.useLayer'];
@@ -21443,7 +21480,7 @@ const getSavedRoot$1 = (savedState, workspacePath) => {
   return workspacePath;
 };
 const loadContent$x = async (state, savedState) => {
-  const root = getSavedRoot$1(savedState, state$A.workspacePath);
+  const root = getSavedRoot$1(savedState, state$B.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -21489,7 +21526,7 @@ const handleLanguagesChanged = state => {
   return updateIcons$1(state);
 };
 const handleWorkspaceChange$1 = async state => {
-  const newRoot = state$A.workspacePath;
+  const newRoot = state$B.workspacePath;
   const state1 = {
     ...state,
     root: newRoot
@@ -22458,7 +22495,7 @@ const LazyCommands$c = {
   handlePointerDown: () => Promise.resolve().then(function () { return ViewletExplorerHandlePointerDown; })
 };
 
-const Css$t = ["/css/parts/Welcome.css"];
+const Css$t = [];
 
 const getKeyBindings$b = () => {
   return [{
@@ -23058,7 +23095,7 @@ const restoreState = savedState => {
       deltaY: 0
     };
   }
-  const root = getSavedRoot(savedState, state$A.workspacePath);
+  const root = getSavedRoot(savedState, state$B.workspacePath);
   let minLineY = 0;
   if (savedState && typeof savedState.minLineY === 'number') {
     minLineY = savedState.minLineY;
@@ -24402,7 +24439,7 @@ const LazyCommands$a = {
   ...LazyCommands$f
 };
 
-const Css$r = ["/css/parts/ViewletExtensions.css", "/css/parts/ViewletList.css"];
+const Css$r = ["/css/parts/ViewletExtensions.css"];
 
 const getKeyBindings$a = () => {
   return [{
@@ -34342,7 +34379,7 @@ const handleUpdate = async (state, update) => {
         loaded: true
       };
     }
-    const root = state$A.workspacePath;
+    const root = state$B.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -34425,7 +34462,7 @@ const create$g = (id, uri, x, y, width, height) => {
     listFocused: false,
     listFocusedIndex: -1,
     inputSource: User,
-    workspacePath: state$A.workspacePath,
+    workspacePath: state$B.workspacePath,
     includeValue: '',
     excludeValue: '',
     detailsExpanded: false,
@@ -34652,7 +34689,7 @@ const LazyCommands$5 = {
   clearSearchResults: () => Promise.resolve().then(function () { return ViewletSearchClearSearchResults; })
 };
 
-const Css$e = ["/css/parts/SearchToggleButton.css", "/css/parts/ViewletList.css", "/css/parts/ViewletSearch.css"];
+const Css$e = ["/css/parts/SearchToggleButton.css", "/css/parts/ViewletSearch.css"];
 
 const getKeyBindings$2 = () => {
   return [{
@@ -36277,7 +36314,7 @@ const loadContent$b = async state => {
     height,
     minimumSliderSize
   } = state;
-  const root = state$A.workspacePath;
+  const root = state$B.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
@@ -37207,7 +37244,7 @@ const loadContent$8 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$1a();
   const canvasCursorId = create$1a();
-  await invoke$4('Terminal.create', canvasTextId, canvasCursorId, uid, state$A.workspacePath, command, args);
+  await invoke$4('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
   const terminal = {
     handleBlur() {
       return invoke$4('Terminal.handleBlur', uid);
@@ -42620,7 +42657,7 @@ const getNoResults = () => {
   };
 };
 const getPicks = async searchValue => {
-  const workspace = state$A.workspacePath;
+  const workspace = state$B.workspacePath;
   if (!workspace) {
     return [];
   }
@@ -42629,7 +42666,7 @@ const getPicks = async searchValue => {
   return files;
 };
 const selectPick = async pick => {
-  const workspace = state$A.workspacePath;
+  const workspace = state$B.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */absolutePath);
   return {
@@ -44885,7 +44922,7 @@ const SearchFileMemfs = {
 };
 
 const removeLeadingSlash = path => {
-  const workspacePath = state$A.workspacePath;
+  const workspacePath = state$B.workspacePath;
   return path.slice(workspacePath.length - Fetch.length - 2);
 };
 const searchFile$2 = async (path, value) => {