@lvce-editor/static-server 0.108.9 → 0.108.11

package/static/{c13c331 → dd9c918}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -95,7 +95,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/c13c331';
+    return '/dd9c918';
   }
 };
 const assetDir = getAssetDir$2();
@@ -563,7 +563,7 @@ class VError extends Error {
   }
 }
 
-const state$H = {
+const state$I = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -586,20 +586,20 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$H.load(moduleId);
+    const module = await state$I.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$H.pendingModules[moduleId]) {
-    state$H.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$I.pendingModules[moduleId]) {
+    state$I.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$H.pendingModules[moduleId];
+  return state$I.pendingModules[moduleId];
 };
 const loadCommand = async command => {
-  if (command in state$H.commands) {
+  if (command in state$I.commands) {
     return;
   }
   await getOrLoadModule(getModuleId$3(command));
@@ -608,12 +608,12 @@ const register$2 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$H.commands[commandId] = listener;
+  state$I.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$H.commands) {
-    const fn = state$H.commands[command];
+  if (command in state$I.commands) {
+    const fn = state$I.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -622,7 +622,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$H.commands)) {
+    if (!(command in state$I.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -633,20 +633,20 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$H.load = load;
+  state$I.load = load;
 };
 
-const state$G = {
+const state$H = {
   pending: Object.create(null)
 };
 const get$k = id => {
-  return state$G.pending[id];
+  return state$H.pending[id];
 };
 const has$2 = id => {
-  return id in state$G.pending;
+  return id in state$H.pending;
 };
 const set$j = (id, value) => {
-  state$G.pending[id] = value;
+  state$H.pending[id] = value;
 };
 
 const NotFound = 404;
@@ -1265,17 +1265,17 @@ const WebWorkerRpcClient2 = {
 
 const commandMapRef = {};
 
-const state$F = {
+const state$G = {
   isTest: false
 };
 const isTest = () => {
-  return state$F.isTest;
+  return state$G.isTest;
 };
 
 const kDispose$1 = 'Viewlet.dispose';
 const kSetCss$1 = 'Viewlet.setCss';
 const kSetPatches$1 = 'Viewlet.setPatches';
-const state$E = {
+const state$F = {
   /** @type {Map<string | number, string>} */
   cssTexts: new Map()
 };
@@ -1285,11 +1285,11 @@ const normalizeSetCss = command => {
   if (typeof id !== 'string' && typeof id !== 'number' || typeof newText !== 'string') {
     return command;
   }
-  const oldText = state$E.cssTexts.get(id);
+  const oldText = state$F.cssTexts.get(id);
   if (oldText === newText) {
     return undefined;
   }
-  state$E.cssTexts.set(id, newText);
+  state$F.cssTexts.set(id, newText);
   return command;
 };
 const normalizeCommand = command => {
@@ -1303,7 +1303,7 @@ const normalizeCommand = command => {
     return normalizeSetCss(command);
   }
   if (command[0] === kDispose$1) {
-    state$E.cssTexts.delete(command[1]);
+    state$F.cssTexts.delete(command[1]);
   }
   return command;
 };
@@ -1318,13 +1318,13 @@ const normalizeCommands = commands => {
   return normalized;
 };
 const getCssText = id => {
-  return state$E.cssTexts.get(id);
+  return state$F.cssTexts.get(id);
 };
 const setCssText = (id, text) => {
-  state$E.cssTexts.set(id, text);
+  state$F.cssTexts.set(id, text);
 };
 const reset$4 = () => {
-  state$E.cssTexts.clear();
+  state$F.cssTexts.clear();
 };
 
 const requestAnimationFrame = fn => {
@@ -1341,7 +1341,7 @@ const kSendMultiple$1 = 'Viewlet.sendMultiple';
 const kSetCss = 'Viewlet.setCss';
 const kSetPatches = 'Viewlet.setPatches';
 const minimumFrameDuration = 16;
-const state$D = {
+const state$E = {
   frameCount: 0,
   lastFrameTime: Number.NEGATIVE_INFINITY,
   /** @type {{commands: any[], promise: Promise<any>} | undefined} */
@@ -1351,8 +1351,8 @@ const state$D = {
   tail: Promise.resolve()
 };
 const enqueue = operation => {
-  const promise = state$D.tail.then(operation);
-  state$D.tail = promise.catch(() => {});
+  const promise = state$E.tail.then(operation);
+  state$E.tail = promise.catch(() => {});
   return promise;
 };
 const waitForEligibleFrame = () => {
@@ -1361,7 +1361,7 @@ const waitForEligibleFrame = () => {
   }
   return new Promise(resolve => {
     const handleFrame = timestamp => {
-      if (timestamp - state$D.lastFrameTime < minimumFrameDuration) {
+      if (timestamp - state$E.lastFrameTime < minimumFrameDuration) {
         requestAnimationFrame(handleFrame);
         return;
       }
@@ -1372,7 +1372,7 @@ const waitForEligibleFrame = () => {
 };
 const invokeWithCacheRecovery = async (method, ...params) => {
   try {
-    return await state$D.rpc.invoke(method, ...params);
+    return await state$E.rpc.invoke(method, ...params);
   } catch (error) {
     reset$4();
     throw error;
@@ -1380,22 +1380,22 @@ const invokeWithCacheRecovery = async (method, ...params) => {
 };
 const runFrame = async frame => {
   const timestamp = await waitForEligibleFrame();
-  if (state$D.pendingFrame === frame) {
-    state$D.pendingFrame = undefined;
+  if (state$E.pendingFrame === frame) {
+    state$E.pendingFrame = undefined;
   }
   const commands = normalizeCommands(frame.commands);
   if (commands.length === 0) {
     return;
   }
-  state$D.frameCount++;
+  state$E.frameCount++;
   try {
     return await invokeWithCacheRecovery(kSendMultiple$1, commands);
   } finally {
-    state$D.lastFrameTime = Math.max(timestamp, now());
+    state$E.lastFrameTime = Math.max(timestamp, now());
   }
 };
 const sealPendingFrame = () => {
-  state$D.pendingFrame = undefined;
+  state$E.pendingFrame = undefined;
 };
 const invokeDirectRendererCommand = async (method, params) => {
   const commands = normalizeCommands([[method, ...params]]);
@@ -1414,23 +1414,23 @@ const invokeCssStyleSheet = async (id, text) => {
 };
 const reset$3 = rpc => {
   reset$4();
-  state$D.frameCount = 0;
-  state$D.lastFrameTime = Number.NEGATIVE_INFINITY;
-  state$D.pendingFrame = undefined;
-  state$D.rpc = rpc;
-  state$D.tail = Promise.resolve();
+  state$E.frameCount = 0;
+  state$E.lastFrameTime = Number.NEGATIVE_INFINITY;
+  state$E.pendingFrame = undefined;
+  state$E.rpc = rpc;
+  state$E.tail = Promise.resolve();
 };
 const sendMultiple = commands => {
-  if (state$D.pendingFrame) {
-    state$D.pendingFrame.commands.push(...commands);
-    return state$D.pendingFrame.promise;
+  if (state$E.pendingFrame) {
+    state$E.pendingFrame.commands.push(...commands);
+    return state$E.pendingFrame.promise;
   }
   /** @type {{commands: any[], promise: Promise<any>}} */
   const frame = {
     commands: [...commands],
     promise: Promise.resolve()
   };
-  state$D.pendingFrame = frame;
+  state$E.pendingFrame = frame;
   frame.promise = enqueue(() => runFrame(frame));
   return frame.promise;
 };
@@ -1453,7 +1453,7 @@ const invokeAndTransfer$P = (method, ...params) => {
   sealPendingFrame();
   return enqueue(async () => {
     try {
-      return await state$D.rpc.invokeAndTransfer(method, ...params);
+      return await state$E.rpc.invokeAndTransfer(method, ...params);
     } catch (error) {
       reset$4();
       throw error;
@@ -1462,7 +1462,7 @@ const invokeAndTransfer$P = (method, ...params) => {
 };
 
 // @ts-ignore
-const state$C = {
+const state$D = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1478,9 +1478,9 @@ const getRpc = async () => {
   return rpc;
 };
 const listen$1 = async () => {
-  console.assert(state$C.pendingMessages.length === 0);
+  console.assert(state$D.pendingMessages.length === 0);
   const rpc = await getRpc();
-  state$C.rpc = rpc;
+  state$D.rpc = rpc;
   reset$3(rpc);
 };
 const invoke$I = (method, ...params) => {
@@ -1747,6 +1747,9 @@ const getOrCreate$2 = fn => {
 };
 const getOrCreateWorker = fn => {
   return {
+    isCreated() {
+      return workers$1.has(fn);
+    },
     async invoke(method, ...params) {
       const ipc = await getOrCreate$2(fn);
       return invoke$H(ipc, method, ...params);
@@ -1890,18 +1893,18 @@ const create$1b = async ({
 
 const isProduction = true;
 
-const state$B = Object.create(null);
+const state$C = Object.create(null);
 const setAll = preferences => {
-  Object.assign(state$B, preferences);
+  Object.assign(state$C, preferences);
 };
 const get$h = key => {
-  return state$B[key];
+  return state$C[key];
 };
 const getAll$3 = () => {
-  return state$B;
+  return state$C;
 };
 const set$h = (key, value) => {
-  state$B[key] = value;
+  state$C[key] = value;
 };
 
 const getConfiguredWorkerUrl$2 = () => {
@@ -2006,24 +2009,24 @@ const showErrorDialog = async error => {
 // 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$A = {
+const state$B = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$A.listenerMap[event] || [];
+  const listeners = state$B.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$A.listenerMap[event] ||= [];
-  if (state$A.listenerMap[event].includes(fn)) {
+  state$B.listenerMap[event] ||= [];
+  if (state$B.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$A.listenerMap[event].unshift(fn);
+    state$B.listenerMap[event].unshift(fn);
   } else {
-    state$A.listenerMap[event].push(fn);
+    state$B.listenerMap[event].push(fn);
   }
 };
 
@@ -2262,7 +2265,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$z = {
+const state$A = {
   /**
    * @type {any}
    */
@@ -2273,14 +2276,14 @@ const state$z = {
 const invoke$F = async (method, ...params) => {
   const {
     ipc
-  } = state$z;
+  } = state$A;
   const result = await invoke$H(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$L = async (method, ...params) => {
   const {
     ipc
-  } = state$z;
+  } = state$A;
   const result = await invokeAndTransfer$N(ipc, method, ...params);
   return result;
 };
@@ -2377,14 +2380,14 @@ const toggleAutoSave = async () => {
   });
 };
 
-const state$y = {
+const state$z = {
   paths: {}
 };
 const initialize$4 = (paths = {}) => {
-  state$y.paths = paths;
+  state$z.paths = paths;
 };
 const get$e = key => {
-  return state$y.paths[key] || '';
+  return state$z.paths[key] || '';
 };
 
 const getConfiguredWorkerUrl$1 = (preferenceKey, fallback) => {
@@ -2486,7 +2489,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$x = {
+const state$y = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2497,7 +2500,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$x.colorTheme = colorThemeId;
+    state$y.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     if (!colorThemeCss) {
       return new Error(`Color theme is empty`);
@@ -2526,10 +2529,10 @@ const setColorTheme = async colorThemeId => {
   return undefined;
 };
 const watch$2 = async id => {
-  if (state$x.watchedTheme === id) {
+  if (state$y.watchedTheme === id) {
     return;
   }
-  state$x.watchedTheme = id;
+  state$y.watchedTheme = id;
   await invoke$F('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
@@ -2570,22 +2573,22 @@ const hydrate$b = async () => {
   await applyPreferredColorTheme();
 };
 
-const state$w = {
+const state$x = {
   href: ''
 };
 
 const initialize$3 = href => {
-  state$w.href = href;
+  state$x.href = href;
 };
 const getHref$1 = async () => {
   const href = await invoke$I(/* Location.getHref */'Location.getHref');
-  state$w.href = href;
+  state$x.href = href;
   return href;
 };
 const setPathName = async pathName => {
   const {
     href
-  } = state$w;
+  } = state$x;
   if (!href) {
     return invoke$I(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
   }
@@ -2595,7 +2598,7 @@ const setPathName = async pathName => {
     return;
   }
   await invoke$I(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
-  state$w.href = resolvedUrl.href;
+  state$x.href = resolvedUrl.href;
 };
 const hydrate$a = () => {
   return invoke$I(/* Location.hydrate */'Location.hydrate');
@@ -3237,7 +3240,7 @@ const ViewletModuleId = {
 // to allow having multiple instances of the same
 // type. for example multiple editors
 
-const state$v = {
+const state$w = {
   instances: Object.create(null),
   /**
    * Track focused instance by module ID/type
@@ -3271,10 +3274,10 @@ const set$f = (key, value) => {
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$v.instances[key] = value;
+  state$w.instances[key] = value;
 };
 const getByUid = uid => {
-  for (const value of Object.values(state$v.instances)) {
+  for (const value of Object.values(state$w.instances)) {
     if (value.renderedState.uid === uid) {
       return value;
     }
@@ -3282,7 +3285,7 @@ const getByUid = uid => {
   return undefined;
 };
 const getInstance = key => {
-  const fast = state$v.instances[key];
+  const fast = state$w.instances[key];
   if (fast) {
     return fast;
   }
@@ -3294,7 +3297,7 @@ const getInstance = key => {
   }
   const normalizedKey = normalizeModuleId(key);
   if (normalizedKey !== key) {
-    const normalizedFast = state$v.instances[normalizedKey];
+    const normalizedFast = state$w.instances[normalizedKey];
     if (normalizedFast) {
       return normalizedFast;
     }
@@ -3303,7 +3306,7 @@ const getInstance = key => {
   if (focusedInstance) {
     return focusedInstance;
   }
-  for (const value of Object.values(state$v.instances)) {
+  for (const value of Object.values(state$w.instances)) {
     if (value.moduleId === key || value.moduleId === normalizedKey) {
       return value;
     }
@@ -3311,17 +3314,17 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$v.instances;
+  return key in state$w.instances;
 };
 const remove$a = key => {
-  const instance = state$v.instances[key];
+  const instance = state$w.instances[key];
   if (instance) {
     clearFocusedInstanceByType(instance.renderedState?.uid, instance.moduleId);
   }
-  delete state$v.instances[key];
+  delete state$w.instances[key];
 };
 const getAllInstances = () => {
-  return state$v.instances;
+  return state$w.instances;
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -3363,7 +3366,7 @@ const setFocusedInstanceByType = (uid, moduleId) => {
   if (typeof moduleId !== 'string') {
     return;
   }
-  state$v.focusedInstanceByType[moduleId] = uid;
+  state$w.focusedInstanceByType[moduleId] = uid;
 };
 
 /**
@@ -3372,7 +3375,7 @@ const setFocusedInstanceByType = (uid, moduleId) => {
  * @returns {number|undefined} The UID of the focused instance, or undefined
  */
 const getFocusedInstanceByType = moduleId => {
-  return state$v.focusedInstanceByType[moduleId];
+  return state$w.focusedInstanceByType[moduleId];
 };
 
 /**
@@ -3381,8 +3384,8 @@ const getFocusedInstanceByType = moduleId => {
  * @param {string} moduleId - The module ID/type
  */
 const clearFocusedInstanceByType = (uid, moduleId) => {
-  if (state$v.focusedInstanceByType[moduleId] === uid) {
-    delete state$v.focusedInstanceByType[moduleId];
+  if (state$w.focusedInstanceByType[moduleId] === uid) {
+    delete state$w.focusedInstanceByType[moduleId];
   }
 };
 
@@ -3406,14 +3409,14 @@ const cleanUpWorkersAfterLoad = async () => {
   await Promise.all(promises);
 };
 
-const state$u = {
+const state$v = {
   id: 0
 };
 const create$1a = () => {
-  return ++state$u.id;
+  return ++state$v.id;
 };
 
-const state$t = {
+const state$u = {
   ipc: undefined
 };
 
@@ -3422,10 +3425,10 @@ const state$t = {
  * @returns {any}
  */
 const get$d = () => {
-  return state$t.ipc;
+  return state$u.ipc;
 };
 const set$e = ipc => {
-  state$t.ipc = ipc;
+  state$u.ipc = ipc;
 };
 
 const map$3 = Object.create(null);
@@ -3478,14 +3481,14 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
   return map$3[id];
 };
 
-const state$s = {
+const state$t = {
   id: 0
 };
 const set$d = value => {
-  state$s.id = value;
+  state$t.id = value;
 };
 const get$c = () => {
-  return state$s.id;
+  return state$t.id;
 };
 
 // TODO cache window id
@@ -3586,18 +3589,18 @@ const createTestWorker = async () => {
   await invoke$H(ipc, 'RendererProcess.initialize');
   return ipc;
 };
-const state$r = {
+const state$s = {
   launchPromise: undefined
 };
 const getOrCreateLaunchPromise = () => {
   const {
     launchPromise
-  } = state$r;
+  } = state$s;
   if (launchPromise) {
     return launchPromise;
   }
   const promise = createTestWorker();
-  state$r.launchPromise = promise;
+  state$s.launchPromise = promise;
   return promise;
 };
 const shouldPreloadTestWorker = (href, isPromptMode) => {
@@ -3621,9 +3624,9 @@ const launchTestWorker = async () => {
   } catch (error) {
     const {
       launchPromise
-    } = state$r;
+    } = state$s;
     if (launchPromise === promise) {
-      state$r.launchPromise = undefined;
+      state$s.launchPromise = undefined;
     }
     throw error;
   }
@@ -3804,7 +3807,7 @@ const isEqualUint32Array = (a, b) => {
   return true;
 };
 
-const state$q = {
+const state$r = {
   keyBindingSets: Object.create(null),
   keyBindingSetCounts: Object.create(null),
   /**
@@ -3817,7 +3820,7 @@ const state$q = {
   matchingKeyBindings: []
 };
 const getKeyBinding = identifier => {
-  for (const keyBinding of state$q.matchingKeyBindings) {
+  for (const keyBinding of state$r.matchingKeyBindings) {
     if (keyBinding.key === identifier) {
       return keyBinding;
     }
@@ -3843,39 +3846,39 @@ const update = () => {
   const {
     keyBindingIdentifiers: oldKeyBindingIdentifiers,
     keyBindingSets
-  } = state$q;
+  } = state$r;
   const matchingKeyBindings = getMatchingKeyBindings(keyBindingSets);
   const keyBindingIdentifiers = getAvailableKeyBindings(matchingKeyBindings);
-  state$q.matchingKeyBindings = matchingKeyBindings;
+  state$r.matchingKeyBindings = matchingKeyBindings;
   if (isEqualUint32Array(oldKeyBindingIdentifiers, keyBindingIdentifiers)) {
     return;
   }
   invoke$I('KeyBindings.setIdentifiers', keyBindingIdentifiers);
-  state$q.keyBindingIdentifiers = keyBindingIdentifiers;
+  state$r.keyBindingIdentifiers = keyBindingIdentifiers;
 };
 const addKeyBindings = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  if (id in state$q.keyBindingSets) {
-    state$q.keyBindingSetCounts[id]++;
+  if (id in state$r.keyBindingSets) {
+    state$r.keyBindingSetCounts[id]++;
     return;
   }
-  state$q.keyBindingSets[id] = keyBindings;
-  state$q.keyBindingSetCounts[id] = 1;
+  state$r.keyBindingSets[id] = keyBindings;
+  state$r.keyBindingSetCounts[id] = 1;
   update();
 };
 const setKeyBindings = (id, keyBindings) => {
   string(id);
   array(keyBindings);
-  state$q.keyBindingSets[id] = keyBindings;
-  state$q.keyBindingSetCounts[id] = 1;
+  state$r.keyBindingSets[id] = keyBindings;
+  state$r.keyBindingSetCounts[id] = 1;
   update();
 };
 const removeKeyBindings = id => {
   const {
     keyBindingSets,
     keyBindingSetCounts
-  } = state$q;
+  } = state$r;
   if (!(id in keyBindingSets)) {
     warn(`cannot remove keybindings that are not registered: ${id}`);
     return;
@@ -3928,14 +3931,14 @@ const handleViewContextChange$1 = (uid, viewId, context) => {
   update();
 };
 
-const state$p = {
+const state$q = {
   currentFocus: 0
 };
 const get$a = () => {
-  return state$p.currentFocus;
+  return state$q.currentFocus;
 };
 const set$b = value => {
-  state$p.currentFocus = value;
+  state$q.currentFocus = value;
 };
 
 /**
@@ -4754,7 +4757,7 @@ const declareWidget = (parentUid, uid, commands) => {
   return reconcile([...commands, [setWidgetsCommand, parentUid, revision, [uid]]]);
 };
 
-const state$o = {
+const state$p = {
   idMap: Object.create(null),
   idMapByModuleId: Object.create(null)
 };
@@ -4762,7 +4765,7 @@ const register = (id, module, moduleId) => {
   const {
     idMap,
     idMapByModuleId
-  } = state$o;
+  } = state$p;
   idMap[id] = module;
   if (moduleId) {
     idMapByModuleId[id] ||= Object.create(null);
@@ -4772,13 +4775,13 @@ const register = (id, module, moduleId) => {
 const get$9 = id => {
   const {
     idMap
-  } = state$o;
+  } = state$p;
   return idMap[id];
 };
 const getForModuleId = (id, moduleId) => {
   const {
     idMapByModuleId
-  } = state$o;
+  } = state$p;
   return idMapByModuleId[id]?.[moduleId] || get$9(id);
 };
 
@@ -4907,7 +4910,7 @@ const getResolveRootFromSessionStorage = async () => {
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$F.isTest = true;
+    state$G.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -4960,12 +4963,12 @@ const getResolvedRoot = async href => {
   }
 };
 
-const state$n = {
+const state$o = {
   notifications: []
 };
 const create$19 = async (type, text) => {
   // @ts-ignore
-  state$n.notifications.push({
+  state$o.notifications.push({
     type,
     text
   });
@@ -4973,7 +4976,7 @@ const create$19 = async (type, text) => {
 };
 const showWithOptions = async (type, text, options) => {
   // @ts-ignore
-  state$n.notifications.push({
+  state$o.notifications.push({
     type,
     text,
     options
@@ -4982,7 +4985,7 @@ const showWithOptions = async (type, text, options) => {
 };
 const handleClick$2 = index => {
   console.log('handle click');
-  const notification = state$n.notifications[0];
+  const notification = state$o.notifications[0];
   if (!notification.options) {
     throw new Error('notification has no options that can be clicked');
   }
@@ -5114,8 +5117,8 @@ const shouldTrace = (selectors, traceId) => {
   return selectors.has('*') || Boolean(traceId && selectors.has(traceId));
 };
 
-const version = '0.108.9';
-const commit$1 = 'c13c331';
+const version = '0.108.11';
+const commit$1 = 'dd9c918';
 const productNameLong = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$F('Process.getPid');
@@ -5262,7 +5265,7 @@ const createEmptyOptions = () => ({
 });
 
 /** @type {any} */
-const state$m = {
+const state$n = {
   batches: new Map(),
   connectionId: 0,
   disabled: false,
@@ -5281,30 +5284,30 @@ const state$m = {
   writeStderr: writeStderr
 };
 const reportError = error => {
-  if (state$m.disabled) {
+  if (state$n.disabled) {
     return;
   }
-  state$m.disabled = true;
-  if (state$m.flushTimer !== undefined) {
-    clearTimeout(state$m.flushTimer);
-    state$m.flushTimer = undefined;
+  state$n.disabled = true;
+  if (state$n.flushTimer !== undefined) {
+    clearTimeout(state$n.flushTimer);
+    state$n.flushTimer = undefined;
   }
-  state$m.batches.clear();
-  state$m.pendingRecordCount = 0;
+  state$n.batches.clear();
+  state$n.pendingRecordCount = 0;
   const message = error instanceof Error ? error.message : String(error);
   console.error(`IPC tracing disabled: ${message}`);
-  void Promise.resolve(state$m.writeStderr(`IPC tracing disabled: ${message}\n`)).catch(() => {});
+  void Promise.resolve(state$n.writeStderr(`IPC tracing disabled: ${message}\n`)).catch(() => {});
 };
 const initialize$2 = async () => {
   try {
-    const argv = await state$m.getArgv();
-    state$m.options = parseTraceIpc(argv);
-    if (state$m.options.error) {
-      reportError(new Error(state$m.options.error));
+    const argv = await state$n.getArgv();
+    state$n.options = parseTraceIpc(argv);
+    if (state$n.options.error) {
+      reportError(new Error(state$n.options.error));
     }
   } catch (error) {
     reportError(error);
-    state$m.options = createEmptyOptions();
+    state$n.options = createEmptyOptions();
   }
 };
 const getWorkerId = (traceId, name, runtimeId) => {
@@ -5315,44 +5318,44 @@ const getWorkerId = (traceId, name, runtimeId) => {
   return `runtime-${runtimeId}${suffix}`;
 };
 const writeBatches = batches => {
-  state$m.writeChain = state$m.writeChain.then(async () => {
+  state$n.writeChain = state$n.writeChain.then(async () => {
     for (const [workerId, records] of batches) {
-      await state$m.write(workerId, records);
+      await state$n.write(workerId, records);
     }
   }).catch(reportError);
 };
 const flush = async () => {
-  if (state$m.flushTimer !== undefined) {
-    clearTimeout(state$m.flushTimer);
-    state$m.flushTimer = undefined;
+  if (state$n.flushTimer !== undefined) {
+    clearTimeout(state$n.flushTimer);
+    state$n.flushTimer = undefined;
   }
-  if (state$m.pendingRecordCount === 0) {
-    await state$m.writeChain;
+  if (state$n.pendingRecordCount === 0) {
+    await state$n.writeChain;
     return;
   }
-  const batches = state$m.batches;
-  state$m.batches = new Map();
-  state$m.pendingRecordCount = 0;
+  const batches = state$n.batches;
+  state$n.batches = new Map();
+  state$n.pendingRecordCount = 0;
   writeBatches(batches);
-  await state$m.writeChain;
+  await state$n.writeChain;
 };
 const queueRecord = (workerId, record) => {
-  if (state$m.disabled) {
+  if (state$n.disabled) {
     return;
   }
-  let records = state$m.batches.get(workerId);
+  let records = state$n.batches.get(workerId);
   if (!records) {
     records = [];
-    state$m.batches.set(workerId, records);
+    state$n.batches.set(workerId, records);
   }
   records.push(record);
-  state$m.pendingRecordCount++;
-  if (state$m.pendingRecordCount >= flushRecordCount) {
+  state$n.pendingRecordCount++;
+  if (state$n.pendingRecordCount >= flushRecordCount) {
     void flush();
     return;
   }
-  state$m.flushTimer ||= state$m.setTimeout(() => {
-    state$m.flushTimer = undefined;
+  state$n.flushTimer ||= state$n.setTimeout(() => {
+    state$n.flushTimer = undefined;
     void flush();
   }, flushDelay);
 };
@@ -5365,19 +5368,19 @@ const getData$2 = event => {
 const createForwarder = (source, target, workerId, connectionId, direction, sequence) => {
   source.onmessage = event => {
     const message = getData$2(event);
-    const monotonicTime = state$m.now();
+    const monotonicTime = state$n.now();
     const startTime = monotonicTime;
     let serializedMessage;
     try {
-      serializedMessage = state$m.serialize(message);
+      serializedMessage = state$n.serialize(message);
     } catch (error) {
       serializedMessage = {
         $type: 'SerializationError',
         message: error instanceof Error ? error.message : String(error)
       };
     }
-    const serializationDuration = state$m.now() - startTime;
-    const transferables = state$m.getTransferrables(message);
+    const serializationDuration = state$n.now() - startTime;
+    const transferables = state$n.getTransferrables(message);
     target.postMessage(message, transferables);
     queueRecord(workerId, {
       connectionId,
@@ -5387,7 +5390,7 @@ const createForwarder = (source, target, workerId, connectionId, direction, sequ
       sequence: sequence.value++,
       serializationDuration,
       version: 1,
-      wallTime: state$m.wallTime(),
+      wallTime: state$n.wallTime(),
       workerId
     });
   };
@@ -5399,14 +5402,14 @@ const maybeCreateProxy = async ({
   port,
   traceId = ''
 }) => {
-  if (!port || state$m.disabled) {
+  if (!port || state$n.disabled) {
     return port;
   }
-  if (!shouldTrace(state$m.options.selectors, traceId)) {
+  if (!shouldTrace(state$n.options.selectors, traceId)) {
     return port;
   }
   const workerId = getWorkerId(traceId, name, id);
-  const connectionId = `${state$m.timeOrigin()}-${state$m.connectionId++}`;
+  const connectionId = `${state$n.timeOrigin()}-${state$n.connectionId++}`;
   try {
     const {
       port1: proxyPort,
@@ -5513,14 +5516,14 @@ const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   wrap: wrap$7
 };
 
-const state$l = {
+const state$m = {
   shouldLaunchMultipleWorkers: false
 };
 const setConfig = shouldLaunchMultipleWorkers => {
-  state$l.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+  state$m.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
 const getConfig = () => {
-  return state$l.shouldLaunchMultipleWorkers;
+  return state$m.shouldLaunchMultipleWorkers;
 };
 
 const objects = Object.create(null);
@@ -5823,7 +5826,7 @@ const IpcParentWithWebSocket = {
   wrap: wrap$6
 };
 
-const state$k = {
+const state$l = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -5833,7 +5836,7 @@ const state$k = {
   isTest: false
 };
 
-const state$j = {
+const state$k = {
   token: '',
   url: '',
   workspaceUri: ''
@@ -5849,24 +5852,24 @@ const set$9 = (workspaceUri, url, token) => {
   if (!isLoopbackUrl(url)) {
     throw new TypeError('Workspace backend must use a loopback WebSocket URL');
   }
-  state$j.workspaceUri = workspaceUri;
-  state$j.url = url;
-  state$j.token = token;
+  state$k.workspaceUri = workspaceUri;
+  state$k.url = url;
+  state$k.token = token;
 };
 const reset$1 = () => {
-  state$j.workspaceUri = '';
-  state$j.url = '';
-  state$j.token = '';
+  state$k.workspaceUri = '';
+  state$k.url = '';
+  state$k.token = '';
 };
 const getWebSocketUrl = type => {
-  if (!state$j.url || state$k.workspaceUri !== state$j.workspaceUri) {
+  if (!state$k.url || state$l.workspaceUri !== state$k.workspaceUri) {
     return '';
   }
-  const url = new URL(`/websocket/${encodeURIComponent(type)}`, state$j.url);
-  url.searchParams.set('token', state$j.token);
+  const url = new URL(`/websocket/${encodeURIComponent(type)}`, state$k.url);
+  url.searchParams.set('token', state$k.token);
   return url.toString();
 };
-const isActive = () => Boolean(state$j.url && state$k.workspaceUri === state$j.workspaceUri);
+const isActive = () => Boolean(state$k.url && state$l.workspaceUri === state$k.workspaceUri);
 const connectMessagePort = async (type, port) => {
   const url = getWebSocketUrl(type);
   if (!url) {
@@ -5907,14 +5910,14 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   await updateWindowTitle(path, pathSeparator);
-  if (path !== state$k.workspacePath) {
-    await emitEvent('workspace.beforeChange', state$k.workspacePath, path);
+  if (path !== state$l.workspacePath) {
+    await emitEvent('workspace.beforeChange', state$l.workspacePath, path);
   }
   // @ts-ignore
-  state$k.workspacePath = path;
+  state$l.workspacePath = path;
   // @ts-ignore
-  state$k.workspaceUri = path;
-  state$k.pathSeparator = pathSeparator;
+  state$l.workspaceUri = path;
+  state$l.pathSeparator = pathSeparator;
   reset$1();
   await dispose$O();
   await onWorkspaceChange();
@@ -5927,12 +5930,12 @@ const setUri = async (uri, providedPathSeparator, backend) => {
   }
   const pathSeparator = providedPathSeparator ?? (await getPathSeparator$9(uri));
   await updateWindowTitle(path, pathSeparator);
-  if (path !== state$k.workspacePath) {
-    await emitEvent('workspace.beforeChange', state$k.workspacePath, path);
+  if (path !== state$l.workspacePath) {
+    await emitEvent('workspace.beforeChange', state$l.workspacePath, path);
   }
-  state$k.workspacePath = path;
-  state$k.workspaceUri = uri;
-  state$k.pathSeparator = pathSeparator;
+  state$l.workspacePath = path;
+  state$l.workspaceUri = uri;
+  state$l.pathSeparator = pathSeparator;
   if (backend) {
     set$9(uri, backend.url, backend.token);
   } else {
@@ -5942,10 +5945,10 @@ const setUri = async (uri, providedPathSeparator, backend) => {
   await onWorkspaceChange();
 };
 const getPath$4 = () => {
-  return state$k.workspacePath;
+  return state$l.workspacePath;
 };
 const getUri$1 = () => {
-  return state$k.workspaceUri;
+  return state$l.workspaceUri;
 };
 const close$3 = async () => {
   await execute$4('Main.closeAllEditorsAndSave');
@@ -5978,46 +5981,46 @@ const getPathName$1 = workspacePath => {
 };
 const onWorkspaceChange = async () => {
   if (getPlatform$3() === Web$1 || getPlatform$3() === Remote) {
-    const pathName = getPathName$1(state$k.workspacePath);
+    const pathName = getPathName$1(state$l.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$k.workspacePath);
+  await emitEvent('workspace.change', state$l.workspacePath);
 };
 const hydrate$7 = async ({
   href
 }) => {
-  if (state$k.workspacePath) {
+  if (state$l.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$k.workspacePath) {
+  if (state$l.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$k.homeDir !== resolvedRoot.homeDir) {
-    state$k.homeDir = resolvedRoot.homeDir;
+  if (state$l.homeDir !== resolvedRoot.homeDir) {
+    state$l.homeDir = resolvedRoot.homeDir;
   }
   if (!canBeRestored$5(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$k.workspacePath = resolvedRoot.path;
-  state$k.homeDir = resolvedRoot.homeDir;
-  state$k.pathSeparator = resolvedRoot.pathSeparator;
-  state$k.workspaceUri = resolvedRoot.uri;
-  state$k.source = resolvedRoot.source;
-  if (state$k.workspaceUri && state$k.workspaceUri.startsWith('/')) {
-    state$k.workspaceUri = `file://${state$k.workspaceUri}`;
-  }
-  await updateWindowTitle(state$k.workspacePath, state$k.pathSeparator);
+  state$l.workspacePath = resolvedRoot.path;
+  state$l.homeDir = resolvedRoot.homeDir;
+  state$l.pathSeparator = resolvedRoot.pathSeparator;
+  state$l.workspaceUri = resolvedRoot.uri;
+  state$l.source = resolvedRoot.source;
+  if (state$l.workspaceUri && state$l.workspaceUri.startsWith('/')) {
+    state$l.workspaceUri = `file://${state$l.workspaceUri}`;
+  }
+  await updateWindowTitle(state$l.workspacePath, state$l.pathSeparator);
   await onWorkspaceChange();
 };
 const getWorkspaceUri = () => {
-  return state$k.workspaceUri;
+  return state$l.workspaceUri;
 };
 const getHomeDir = () => {
-  return state$k.homeDir;
+  return state$l.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -6036,10 +6039,10 @@ const getStateToSave = async () => {
     instances: getWorkspaceScopedViewletStates(savedInstances, workspaceUri),
     mainEditors: [],
     workspace: {
-      path: state$k.workspacePath,
-      homeDir: state$k.homeDir,
-      pathSeparator: state$k.pathSeparator,
-      uri: state$k.workspaceUri
+      path: state$l.workspacePath,
+      homeDir: state$l.homeDir,
+      pathSeparator: state$l.pathSeparator,
+      uri: state$l.workspaceUri
     }
   };
 };
@@ -6096,10 +6099,14 @@ const launchIframeWorker = async () => {
 
 const {
   invoke: invoke$z,
-  invokeAndTransfer: invokeAndTransfer$E
+  invokeAndTransfer: invokeAndTransfer$E,
+  isCreated: isCreated$1
 } = getOrCreateWorker(launchIframeWorker);
 
 const saveState$w = async () => {
+  if (!isCreated$1()) {
+    return (await getSavedState()) || [];
+  }
   return invoke$z('WebView.saveState');
 };
 const getSavedState = async () => {
@@ -6212,7 +6219,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$B);
+    await addDynamicCss(id, module.getDynamicCss, state$C);
   }
 };
 
@@ -6242,6 +6249,7 @@ const launchQuickPickWorker = async () => {
 const {
   invoke: invoke$y,
   invokeAndTransfer: invokeAndTransfer$D,
+  isCreated,
   restart: restart$j
 } = getOrCreateWorker(launchQuickPickWorker);
 
@@ -6249,24 +6257,24 @@ const QuickPickWorker = {
   __proto__: null,
   invoke: invoke$y,
   invokeAndTransfer: invokeAndTransfer$D,
+  isCreated,
   restart: restart$j
 };
 
-const state$i = {
+const state$j = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$i.menuEntries;
+  return state$j.menuEntries;
 };
 const add$1 = async menuEntries => {
-  state$i.menuEntries = [...state$i.menuEntries, ...menuEntries];
-  // TODO store menu entries here or in file search worker?
-  // Usually don't want to start worker for the menu entries
-  // But also quickpick menu entries would be better stored there
-  await invoke$y('QuickPick.addMenuEntries', menuEntries);
+  state$j.menuEntries = [...state$j.menuEntries, ...menuEntries];
+  if (isCreated()) {
+    await invoke$y('QuickPick.addMenuEntries', menuEntries);
+  }
 };
 
 const loadModule$2 = async (id, module) => {
@@ -6289,7 +6297,7 @@ const loadModule$1 = async (id, module) => {
 };
 
 // @ts-nocheck
-const state$h = {
+const state$i = {
   pendingModules: Object.create(null)
 };
 const runLoadContentLaterWithErrorHandling = async (loadContentLater, viewletState) => {
@@ -6730,10 +6738,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$h.pendingModules)) {
-    state$h.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$i.pendingModules)) {
+    state$i.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$h.pendingModules[id];
+  return state$i.pendingModules[id];
 };
 /**
  *
@@ -7572,15 +7580,15 @@ const restoreMainFocus = async (invoke = invoke$x) => {
   }
 };
 
-const state$g = {
+const state$h = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$g.isQuickPickOpen;
+  return state$h.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async (restoreFocus = true) => {
   const id = QuickPick;
-  state$g.isQuickPickOpen = false;
+  state$h.isQuickPickOpen = false;
   remove$a(id);
   await disposeBrowserViewQuickPick();
   await focus$i();
@@ -8188,6 +8196,16 @@ const getIcons = iconRequests => {
   return invoke$w('IconTheme.getIcons', iconRequests);
 };
 
+const FALLBACK_ICON_THEME_ID = 'vscode-icons';
+const state$g = {
+  assetDir: '',
+  iconThemeId: undefined,
+  platform: Web$1
+};
+const getPreferredIconThemeId = () => {
+  const configuredIconThemeId = get$f('workbench.iconTheme');
+  return configuredIconThemeId === undefined ? FALLBACK_ICON_THEME_ID : configuredIconThemeId;
+};
 const getIconThemePlatform = (platform, assetDir) => {
   if (platform === Electron$1 && !assetDir) {
     return Remote;
@@ -8197,7 +8215,7 @@ const getIconThemePlatform = (platform, assetDir) => {
 const setIconTheme = async (iconThemeId, platform, assetDir) => {
   try {
     const useCache = get$f('icon-theme.cache') ?? true;
-    const extensions = await invoke$E('Extensions.getAllExtensions', assetDir, platform);
+    const extensions = iconThemeId === null ? [] : await invoke$E('Extensions.getAllExtensions', assetDir, platform);
     const iconThemePlatform = getIconThemePlatform(platform, assetDir);
     const etag = getIconThemeEtag(iconThemeId);
     await invoke$w('IconTheme.getIconThemeJson', extensions, iconThemeId, assetDir, iconThemePlatform, useCache, etag);
@@ -8208,9 +8226,26 @@ const setIconTheme = async (iconThemeId, platform, assetDir) => {
     }
   }
 };
+const handlePreferencesChanged = async () => {
+  const iconThemeId = getPreferredIconThemeId();
+  const {
+    assetDir,
+    iconThemeId: currentIconThemeId,
+    platform
+  } = state$g;
+  if (iconThemeId === currentIconThemeId) {
+    return;
+  }
+  state$g.iconThemeId = iconThemeId;
+  await setIconTheme(iconThemeId, platform, assetDir);
+};
 const hydrate$4 = async (platform, assetDir) => {
   // TODO do this all in worker
-  const iconThemeId = get$f('workbench.iconTheme') || 'vscode-icons';
+  state$g.platform = platform;
+  state$g.assetDir = assetDir;
+  addListener('preferences.changed', handlePreferencesChanged);
+  const iconThemeId = getPreferredIconThemeId();
+  state$g.iconThemeId = iconThemeId;
   await setIconTheme(iconThemeId, platform, assetDir);
 };
 
@@ -8674,7 +8709,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$z.ipc = ipc;
+  state$A.ipc = ipc;
 };
 
 const Zero = 0;
@@ -9716,7 +9751,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$C.rpc.ipc;
+  const originalIpc = state$D.rpc.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -9731,33 +9766,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$C.rpc.ipc.onmessage = originalAddEventListsner;
-          state$C.rpc.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$C.rpc.ipc.onmessage = wrappedOnMessage;
-          state$C.rpc.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$C.rpc.ipc.onmessage = originalAddEventListsner;
-          state$C.rpc.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$C.rpc.ipc.onmessage = wrappedOnMessage;
-          state$C.rpc.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$C.rpc.ipc.onmessage = originalAddEventListsner;
-          state$C.rpc.ipc.send = originalSend;
+          state$D.rpc.ipc.onmessage = originalAddEventListsner;
+          state$D.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$C.rpc.ipc.onmessage = wrappedOnMessage;
-          state$C.rpc.ipc.send = wrappedSend;
+          state$D.rpc.ipc.onmessage = wrappedOnMessage;
+          state$D.rpc.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$C.rpc.send = wrappedSend;
-  state$C.rpc.addEventListener('message', wrappedOnMessage);
+  state$D.rpc.send = wrappedSend;
+  state$D.rpc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -9829,8 +9864,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$C.rpc.ipc = wrapIpc(state$C.rpc, 'renderer-process', event => event.data);
-  state$z.ipc = wrapIpc(state$z.ipc, 'shared-process', event => event);
+  state$D.rpc.ipc = wrapIpc(state$D.rpc, 'renderer-process', event => event.data);
+  state$A.ipc = wrapIpc(state$A.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -20635,7 +20670,7 @@ const createContext$1 = getPlatform => ({
     return getPlatform();
   },
   get workspacePath() {
-    return state$k.workspacePath;
+    return state$l.workspacePath;
   },
   get workspaceUri() {
     return getWorkspaceUri?.();
@@ -22606,7 +22641,7 @@ const loadContent$z = async (state, _savedState, configuredSpawnOptions) => {
     command,
     args
   } = configuredSpawnOptions || (await getTerminalSpawnOptions());
-  await invoke$2('Terminal.create', uid, cwd || state$k.workspacePath, command, args, {
+  await invoke$2('Terminal.create', uid, cwd || state$l.workspacePath, command, args, {
     backend: getBackend()
   });
   return {
@@ -25125,7 +25160,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = 'c13c331';
+const commit = 'dd9c918';
 
 const getAutoUpdateType = () => {
   return invoke$F('AutoUpdater.getAutoUpdateType');
@@ -27981,7 +28016,7 @@ const handleSettingsChanged = async state => {
 };
 const refreshSourceControlBadgeCount = async state => {
   try {
-    const badgeCount = await invoke$7('SourceControl.getWorkspaceBadgeCount', state$k.workspacePath, assetDir, platform);
+    const badgeCount = await invoke$7('SourceControl.getWorkspaceBadgeCount', state$l.workspacePath, assetDir, platform);
     return setBadgeCount(state, SourceControl, badgeCount);
   } catch {
     return {
@@ -31734,7 +31769,7 @@ const loadContent$5 = async (state, savedState) => {
     platform,
     assetDir
   } = state;
-  await invoke$7('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$k.workspacePath,
+  await invoke$7('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$l.workspacePath,
   // TODO use workspace uri
   platform, assetDir);
   const diffResult = await invoke$7('SourceControl.diff2', state.uid);
@@ -31855,7 +31890,7 @@ const hotReload$2 = async state => {
     ...state,
     items: []
   };
-  await invoke$7('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$k.workspacePath,
+  await invoke$7('SourceControl.create2', state.uid, state.uri, state.x, state.y, state.width, state.height, state$l.workspacePath,
   // TODO use workspace uri
   state.platform, state.assetDir);
   await invoke$7('SourceControl.loadContent', state.uid, savedState);