@lvce-editor/server 0.35.9 → 0.35.10

package/static/{19a90fe → 5d1ba9a}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -110,7 +110,7 @@ const getAssetDir = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/19a90fe';
+    return '/5d1ba9a';
   }
 };
 const assetDir = getAssetDir();
@@ -1907,6 +1907,12 @@ const readFile$e = async (uri, encoding = Utf8) => {
   const fileSystem = await getFileSystem(protocol);
   return fileSystem.readFile(path, encoding);
 };
+const readJson$3 = async (uri, encoding) => {
+  const protocol = getProtocol(uri);
+  const path = getPath$1(protocol, uri);
+  const fileSystem = await getFileSystem(protocol);
+  return fileSystem.readJson(path, encoding);
+};
 const remove$a = async uri => {
   const protocol = getProtocol(uri);
   const path = getPath$1(protocol, uri);
@@ -2060,8 +2066,6 @@ const parse$1 = content => {
 };
 
 const DownloadDownload = 'Download.download'; // TODO move to network process
-
-const ExtensionHostGetIconThemeJson = 'ExtensionHost.getIconThemeJson';
 const FileSystemChmod = 'FileSystem.chmod';
 const FileSystemCopy = 'FileSystem.copy';
 const FileSystemGetPathSeparator$1 = 'FileSystem.getPathSeparator';
@@ -2069,6 +2073,7 @@ const FileSystemGetRealPath = 'FileSystem.getRealPath';
 const FileSystemMkdir$1 = 'FileSystem.mkdir';
 const FileSystemReadDirWithFileTypes$1 = 'FileSystem.readDirWithFileTypes';
 const FileSystemReadFile$1 = 'FileSystem.readFile';
+const FileSystemReadJson = 'FileSystem.readJson';
 const FileSystemRemove$1 = 'FileSystem.remove';
 const FileSystemRename$1 = 'FileSystem.rename';
 const FileSystemStat = 'FileSystem.stat';
@@ -2488,9 +2493,576 @@ const state$F = {
   webExtensions: []
 };
 
+const findMatchingIconThemeExtension = (extensions, iconThemeId) => {
+  for (const extension of extensions) {
+    if (extension && extension.iconThemes) {
+      for (const iconTheme of extension.iconThemes) {
+        if (iconTheme.id === iconThemeId) {
+          return {
+            ...iconTheme,
+            extensionPath: extension.path
+          };
+        }
+      }
+    }
+  }
+  return undefined;
+};
+
+const Resolved = 'resolved';
+const Rejected$1 = 'rejected';
+
+const webExtensionsUrl = `${assetDir}/config/webExtensions.json`;
+
+const getSharedProcessExtensions$1 = () => {
+  return invoke$8(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+};
+const getStaticWebExtensions = () => {
+  return execute$4('Ajax.getJson', webExtensionsUrl);
+};
+const getWebExtensionsWeb = async () => {
+  const staticWebExtensions = await getStaticWebExtensions();
+  return [...staticWebExtensions, ...state$F.webExtensions];
+};
+const isWebExtension = extension => {
+  return extension && typeof extension.browser === 'string';
+};
+const getWebExtensionsDefault = async () => {
+  const staticWebExtensions = await getStaticWebExtensions();
+  const sharedProcessExtensions = await getSharedProcessExtensions$1();
+  const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$F.webExtensions];
+};
+const getWebExtensions = async () => {
+  try {
+    switch (platform) {
+      case Web$1:
+        return getWebExtensionsWeb();
+      default:
+        return getWebExtensionsDefault();
+    }
+  } catch {
+    return state$F.webExtensions;
+  }
+};
+
+const getLanguages$2 = async () => {
+  // TODO handle error
+  const languages = await invoke$8(/* ExtensionHost.getLanguages */'ExtensionHost.getLanguages');
+  return languages;
+};
+const joinPath = (extensionPath, relativePath) => {
+  if (relativePath.startsWith('./')) {
+    return extensionPath + relativePath.slice(1);
+  }
+  return extensionPath + relativePath;
+};
+const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
+  for (const extension of extensions) {
+    if (extension && extension.languages && Array.isArray(extension.languages)) {
+      for (const language of extension.languages) {
+        if (language && language.id === languageId && language.configuration) {
+          const path = joinPath(extension.path, language.configuration);
+          return path;
+        }
+      }
+    }
+  }
+  return '';
+};
+const getLanguageConfigurationFromWebExtension = async languageId => {
+  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$F.webExtensions, languageId);
+  if (!languageConfigurationPath) {
+    return undefined;
+  }
+  const json = await execute$4('Ajax.getJson', languageConfigurationPath);
+  return json;
+};
+const getLanguageConfiguration$3 = async languageId => {
+  const languageConfiguration = await invoke$8(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
+  if (languageConfiguration) {
+    return languageConfiguration;
+  }
+  return getLanguageConfigurationFromWebExtension(languageId);
+};
+
+const getLanguages$1 = async () => {
+  const url = `${assetDir}/config/languages.json`;
+  // TODO handle error ?
+  return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
+};
+const getLanguageConfiguration$2 = async languageId => {
+  warn$1('get language configuration not yet supported on web');
+};
+
+const getLanguages = async () => {
+  try {
+    switch (platform) {
+      case Web$1:
+        return await getLanguages$1();
+      default:
+        return await getLanguages$2();
+    }
+  } catch (error) {
+    throw new VError(error, 'Failed to load languages');
+  }
+};
+const getLanguageConfiguration$1 = async languageId => {
+  string(languageId);
+  switch (platform) {
+    case Web$1:
+      return getLanguageConfiguration$2();
+    default:
+      return getLanguageConfiguration$3(languageId);
+  }
+};
+
+const getFileExtensionIndex = file => {
+  string(file);
+  return file.lastIndexOf(Dot);
+};
+const getFileExtension = file => {
+  const index = getFileExtensionIndex(file);
+  return file.slice(index);
+};
+const getNthFileExtension = (file, startIndex) => {
+  return file.lastIndexOf(Dot, startIndex);
+};
+
+// TODO merge all of this with extension host languages module
+
+const state$E = {
+  loadState: false,
+  isHydrating: false,
+  fileNameMap: Object.create(null),
+  extensionMap: Object.create(null),
+  tokenizerMap: Object.create(null),
+  /**
+   * @type {any[]}
+   */
+  firstLines: [],
+  /**
+   * @type {string[]}
+   */
+  hasWarned: []
+};
+const getFirstLines = () => {
+  return state$E.firstLines;
+};
+const hasLanguageByExtension = extension => {
+  return extension in state$E.extensionMap;
+};
+const getLanguageByExtension = extension => {
+  return state$E.extensionMap[extension];
+};
+const hasLanguageByFileName = fileName => {
+  return fileName in state$E.fileNameMap;
+};
+const getLanguageByFileName = fileName => {
+  return state$E.fileNameMap[fileName];
+};
+const getTokenizeFunctionPath$1 = languageId => {
+  // TODO what if language.tokenize is not of type string? -> handle error gracefully
+  return state$E.tokenizerMap[languageId] || '';
+};
+const setHydrating = value => {
+  state$E.isHydrating = value;
+};
+const setLoaded = value => {
+  state$E.loaded = true;
+};
+const addExtension = (extension, languageId) => {
+  state$E.extensionMap[extension] = languageId;
+};
+const addFirstLine = (regex, languageId) => {
+  state$E.firstLines.push({
+    regex,
+    languageId
+  });
+};
+const hasWarned = languageId => {
+  return state$E.hasWarned.includes(languageId);
+};
+const addWarned = languageId => {
+  return state$E.hasWarned.push(languageId);
+};
+const addFileName = (fileName, languageId) => {
+  state$E.fileNameMap[fileName] = languageId;
+};
+const addTokenizer = (languageId, tokenizer) => {
+  state$E.tokenizerMap[languageId] = tokenizer;
+};
+const hasLoaded$1 = () => {
+  return state$E.loaded;
+};
+
+// TODO merge all of this with extension host languages module
+
+const getLanguageId$1 = fileName => {
+  string(fileName);
+  // TODO this is inefficient for icon theme, as file extension is computed twice
+  const extensionIndex = getFileExtensionIndex(fileName);
+  const extension = fileName.slice(extensionIndex);
+  const extensionLower = extension.toLowerCase();
+  if (hasLanguageByExtension(extensionLower)) {
+    return getLanguageByExtension(extensionLower);
+  }
+  const fileNameLower = fileName.toLowerCase();
+  const secondExtensionIndex = getNthFileExtension(fileName, extensionIndex - 1);
+  const secondExtension = fileName.slice(secondExtensionIndex);
+  if (secondExtensionIndex !== -1 && hasLanguageByExtension(secondExtension)) {
+    return getLanguageByExtension(secondExtension);
+  }
+  if (hasLanguageByFileName(fileNameLower)) {
+    return getLanguageByFileName(fileNameLower);
+  }
+  return 'unknown';
+};
+const getLanguageIdByFirstLine = firstLine => {
+  const firstLines = getFirstLines();
+  for (const {
+    regex,
+    languageId
+  } of firstLines) {
+    const actualRegex = new RegExp(regex);
+    if (actualRegex.test(firstLine)) {
+      return languageId;
+    }
+  }
+  return 'unknown';
+};
+const getTokenizeFunctionPath = languageId => {
+  // TODO what if language.tokenize is not of type string? -> handle error gracefully
+  return getTokenizeFunctionPath$1(languageId);
+};
+const hydrate$8 = async () => {
+  setHydrating(true);
+  // TODO handle error
+  // TODO main parts should have nothing todo with shared process -> only sub components
+  const languages = await getLanguages();
+  // TODO avoid side effect here, but how?
+  await addLanguages(languages);
+  const useJsx = get$e('languages.jsFilesAsJsx');
+  if (useJsx) {
+    addExtension('.js', 'jsx');
+  }
+  setLoaded();
+};
+
+// TODO make contribution points not rely on globals and side effects
+const contributionPointFileExtensions = {
+  key: 'fileExtensions',
+  handle(value, languageId) {
+    if (value) {
+      warn$1(`[renderer-worker] unsupported property "fileExtensions" for language ${languageId}, use the property "extensions" instead`);
+    }
+  }
+};
+const contributionPointFileNames = {
+  key: 'fileNames',
+  handle(value, languageId) {
+    if (value && Array.isArray(value)) {
+      for (const fileName of value) {
+        if (typeof fileName === 'string') {
+          const fileNameLower = fileName.toLowerCase();
+          addFileName(fileNameLower, languageId);
+        } else {
+          warn$1(`[renderer-worker] language.fileNames for ${languageId} should be an array of strings but includes ${typeof fileName}`);
+        }
+      }
+    }
+  }
+};
+const contributionPointFirstLine = {
+  key: 'firstLine',
+  handle(value, languageId) {
+    addFirstLine(value, languageId);
+  }
+};
+const warnFileNames = (languageId, language) => {
+  if (hasWarned(languageId)) {
+    return;
+  }
+  addWarned(languageId);
+  const code = JSON.stringify(language, null, 2);
+  const lines = splitLines(code);
+  let rowIndex = 0;
+  let columnIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fileNamesIndex = line.indexOf('filenames');
+    if (fileNamesIndex !== -1) {
+      rowIndex = i;
+      columnIndex = fileNamesIndex;
+      break;
+    }
+  }
+  const codeFrame = create$1b(code, {
+    start: {
+      line: rowIndex + 1,
+      column: columnIndex + 1
+    },
+    end: {
+      line: rowIndex + 1,
+      column: columnIndex + 'filenames'.length + 1
+    }
+  });
+  warn$1(`Please use "fileNames" instead of "filenames" for language ${languageId}
+${codeFrame}
+`);
+};
+const contributionPointFileNamesLower = {
+  key: 'filenames',
+  handle(value, languageId, language) {
+    warnFileNames(languageId, language);
+    contributionPointFileNames.handle(value, languageId);
+  }
+};
+const contributionPointExtensions = {
+  key: 'extensions',
+  handle(value, languageId) {
+    if (value && Array.isArray(value)) {
+      for (const extension of value) {
+        if (typeof extension === 'string') {
+          addExtension(extension, languageId);
+        } else {
+          warn$1(`[renderer-worker] language.extensions for ${languageId} should be an array of strings but includes ${typeof extension}`);
+        }
+      }
+    }
+  }
+};
+const contributionPointTokenize = {
+  key: 'tokenize',
+  handle(value, languageId) {
+    if (value) {
+      addTokenizer(languageId, value);
+    }
+  }
+};
+const contributionPoints = [contributionPointFileExtensions, contributionPointExtensions, contributionPointFileNames, contributionPointFileNamesLower, contributionPointTokenize, contributionPointFirstLine];
+const addLanguage = language => {
+  const languageId = language.id;
+  if (!languageId) {
+    warn$1('[renderer-worker] language is missing id', language);
+    return;
+  }
+  // TODO could use object destructuing here
+  // TODO maybe map the other way around from language keys to contribution points
+  for (const contributionPoint of contributionPoints) {
+    const value = language[contributionPoint.key];
+    if (value) {
+      contributionPoint.handle(value, languageId, language);
+    }
+  }
+};
+const addLanguages = async languages => {
+  for (const language of languages) {
+    addLanguage(language);
+  }
+  await emitEvent('languages.changed');
+};
+const hasLoaded = () => {
+  return hasLoaded$1();
+};
+const getLanguageConfiguration = async editor => {
+  if (!hasLoaded()) {
+    throw new Error('languages must be loaded before requesting language configuration');
+  }
+  try {
+    editor.languageId = getLanguageId$1(editor.uri);
+    const languageConfiguration = await getLanguageConfiguration$1(editor.languageId);
+    return languageConfiguration;
+  } catch (error$1) {
+    error(error$1);
+    return {};
+  }
+};
+
+const state$D = {
+  webViews: []
+};
+const addMany = webViews => {
+  state$D.webViews = [...state$D.webViews, ...webViews];
+};
+const get$b = () => {
+  return state$D.webViews;
+};
+
+const getId$3 = path => {
+  const slashIndex = path.lastIndexOf(Slash$2);
+  return path.slice(slashIndex + 1);
+};
+const getWebManifestPath = path => {
+  const manifestPath = `${path}/extension.json`;
+  return manifestPath;
+};
+const getWebExtensionManifest$1 = async (path, manifestPath) => {
+  try {
+    const manifest = await execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */manifestPath);
+    return {
+      ...manifest,
+      path
+    };
+  } catch (error) {
+    const id = getId$3(path);
+    throw new VError(error, `Failed to load extension manifest for ${id}`);
+  }
+};
+const addWebExtension = async path => {
+  const manifestPath = getWebManifestPath(path);
+  const manifest = await getWebExtensionManifest$1(path, manifestPath);
+  // TODO avoid side effect here
+  if (manifest.languages) {
+    for (const language of manifest.languages) {
+      language.tokenize &&= manifest.path + Slash$2 + language.tokenize;
+    }
+  }
+  manifest.status = Resolved;
+  state$F.webExtensions.push(manifest);
+  if (manifest.languages) {
+    // TODO handle case when languages is not of type array
+    await addLanguages(manifest.languages);
+  }
+  if (manifest.webViews) {
+    for (const webView of manifest.webViews) {
+      webView.path = manifest.path + Slash$2 + webView.path;
+    }
+    addMany(manifest.webViews);
+  }
+  // const absolutePath = manifest.path + '/' + manifest.browser
+  // await ExtensionHostWorker.invoke('ExtensionHostExtension.activate', manifest, absolutePath)
+};
+
+// TODO status fulfilled should be handled as resolved
+const organizeExtensions = extensions => {
+  const rejected = [];
+  const resolved = [];
+  for (const extension of extensions) {
+    switch (extension.status) {
+      case Resolved:
+        resolved.push(extension);
+        break;
+      case Rejected$1:
+        rejected.push(extension);
+        break;
+      default:
+        resolved.push(extension);
+        break;
+    }
+  }
+  return {
+    resolved,
+    rejected
+  };
+};
+const validateEvents = extension => {
+  if (!extension) {
+    return [];
+  }
+  if (!extension.activation) {
+    return [];
+  }
+  // TODO handle error when extension.activation is not of type array (null or number or ...)
+  const warnings = [];
+  for (const item of extension.activation) {
+    if (item.startsWith('onWebview:')) {
+      warnings.push(`[renderer-worker] Invalid extension activation event in ${extension.path}: should be onWebView:`);
+    }
+  }
+  return warnings;
+};
+const filterByMatchingEvent = (extensions, event) => {
+  const extensionsToActivate = [];
+  for (const extension of extensions) {
+    const warnings = validateEvents(extension);
+    for (const warning of warnings) {
+      console.warn(warning);
+    }
+    // TODO handle error when extension.activation is not of type array (null or number or ...)
+    if (extension.activation && extension.activation.includes(event)) {
+      extensionsToActivate.push(extension);
+    }
+  }
+  return extensionsToActivate;
+};
+const getCodeFrameFromError = error => {
+  if (error && error.jse_cause && error.jse_cause.codeFrame) {
+    return error.jse_cause.codeFrame;
+  }
+  return '';
+};
+const getOriginalStackFromError = error => {
+  if (error && error.originalStack) {
+    return error.originalStack;
+  }
+  return '';
+};
+const handleRejectedExtension = async extension => {
+  const {
+    reason
+  } = extension;
+  const {
+    message,
+    code
+  } = reason;
+  if (code === E_MANIFEST_NOT_FOUND || code === ENOTDIR) {
+    return;
+  }
+  const codeFrame = getCodeFrameFromError(reason);
+  const stack = getOriginalStackFromError(reason);
+  error(`${message}\n${codeFrame}\n${stack}`);
+};
+const handleRejectedExtensions = async extensions => {
+  for (const extension of extensions) {
+    await handleRejectedExtension(extension);
+  }
+};
+const getSharedProcessExtensions = () => {
+  return invoke$8(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+};
+const getExtensions$2 = async () => {
+  if (platform === Web$1) {
+    const webExtensions = await getWebExtensions();
+    return webExtensions;
+  }
+  if (platform === Remote) {
+    const webExtensions = await getWebExtensions();
+    const sharedProcessExtensions = await getSharedProcessExtensions();
+    return [...sharedProcessExtensions, ...webExtensions];
+  }
+  const extensions = await getSharedProcessExtensions();
+  return extensions;
+};
+const addNodeExtension = async path => {
+  // TODO add support for dynamically loading node extensions
+  // e.g. for testing multiple extensions
+  throw new Error('not implemented');
+};
+
+const cache = Object.create(null);
+const id$p = 1;
+const get$a = () => {
+  return cache[id$p];
+};
+const has$1 = () => {
+  return id$p in cache;
+};
+const set$c = value => {
+  cache[id$p] = value;
+};
+
+const getExtensions$1 = () => {
+  if (!has$1()) {
+    set$c(getExtensions$2());
+  }
+  return get$a();
+};
+
 const getIconThemeUrl = iconThemeId => {
   return `${assetDir}/extensions/builtin.${iconThemeId}/icon-theme.json`;
 };
+
 const getIconThemeJson = async iconThemeId => {
   if (platform === Web$1) {
     const url = getIconThemeUrl(iconThemeId);
@@ -2513,19 +3085,17 @@ const getIconThemeJson = async iconThemeId => {
       }
     }
   }
-  return invoke$8(ExtensionHostGetIconThemeJson, /* iconThemeId */iconThemeId);
-};
-
-const initialIconTheme = undefined;
-
-const state$E = {
-  seenFiles: [],
-  seenFolders: [],
-  hasWarned: [],
-  /**
-   * @type{any}
-   */
-  iconTheme: initialIconTheme
+  const extensions = await getExtensions$1();
+  const iconTheme = findMatchingIconThemeExtension(extensions, iconThemeId);
+  if (!iconTheme) {
+    return undefined;
+  }
+  const iconThemePath = `${iconTheme.extensionPath}/${iconTheme.path}`;
+  const iconThemeJson = await readJson$3(iconThemePath);
+  return {
+    extensionPath: iconTheme.extensionPath,
+    json: iconThemeJson
+  };
 };
 
 const dispatch = key => (...args) => {
@@ -2538,11 +3108,11 @@ const isOpen = () => {
   return false;
 };
 
-const state$D = {
+const state$C = {
   id: 0
 };
 const create$1a = () => {
-  return ++state$D.id;
+  return ++state$C.id;
 };
 
 class CancelationError extends Error {
@@ -2639,7 +3209,8 @@ const serializeInstances = instances => {
   for (const value of Object.values(instances)) {
     const serializedInstance = serializeInstance(value);
     if (serializedInstance) {
-      serialized[value.moduleId] = serializedInstance;
+      const storageKey = value.factory.StorageKey || value.moduleId;
+      serialized[storageKey] = serializedInstance;
     }
   }
   return serialized;
@@ -2655,23 +3226,23 @@ const setJson$1 = (key, value) => {
   return setJson$4(SessionStorage, key, value);
 };
 
-const state$C = {
+const state$B = {
   instances: Object.create(null),
   /**
    * @type {any}
    */
   focusedInstance: undefined
 };
-const set$c = (key, value) => {
+const set$b = (key, value) => {
   // TODO separate factories from state
   object(value);
   object(value.factory);
   object(value.state);
   object(value.renderedState);
-  state$C.instances[key] = value;
+  state$B.instances[key] = value;
 };
 const getInstance = key => {
-  const fast = state$C.instances[key];
+  const fast = state$B.instances[key];
   if (fast) {
     return fast;
   }
@@ -2684,7 +3255,7 @@ const getInstance = key => {
   if (key === 'EditorCompletion') {
     key = 'Editor';
   }
-  for (const value of Object.values(state$C.instances)) {
+  for (const value of Object.values(state$B.instances)) {
     if (value.moduleId === key) {
       return value;
     }
@@ -2692,16 +3263,16 @@ const getInstance = key => {
   return undefined;
 };
 const hasInstance = key => {
-  return key in state$C.instances;
+  return key in state$B.instances;
 };
 const remove$8 = key => {
-  delete state$C.instances[key];
+  delete state$B.instances[key];
 };
 const getAllInstances = () => {
-  return state$C.instances;
+  return state$B.instances;
 };
 const getValues = () => {
-  return Object.values(state$C.instances);
+  return Object.values(state$B.instances);
 };
 const getState$1 = key => {
   const instance = getInstance(key);
@@ -2737,7 +3308,7 @@ const getHref = () => {
 const setPathName = pathName => {
   return invoke$9(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
 };
-const hydrate$8 = () => {
+const hydrate$7 = () => {
   return invoke$9(/* Location.hydrate */'Location.hydrate');
 };
 const getOrigin = () => {
@@ -2749,11 +3320,11 @@ const getHost = () => {
 
 const Slash$1 = Slash$2;
 
-const set$b = title => {
+const set$a = title => {
   return invoke$9('WindowTitle.set', title);
 };
 
-const state$B = {
+const state$A = {
   workspacePath: '',
   homeDir: '',
   pathSeparator: '',
@@ -2771,16 +3342,16 @@ const setPath = async path => {
   // TODO not in electron
   const pathSeparator = await getPathSeparator$9(path);
   // @ts-ignore
-  state$B.workspacePath = path;
+  state$A.workspacePath = path;
   // @ts-ignore
-  state$B.workspaceUri = path;
-  state$B.pathSeparator = pathSeparator;
+  state$A.workspaceUri = path;
+  state$A.pathSeparator = pathSeparator;
   await onWorkspaceChange();
 };
 const setUri = async uri => {
   const path = uri.slice('file://'.length);
-  state$B.workspacePath = path;
-  state$B.workspaceUri = uri;
+  state$A.workspacePath = path;
+  state$A.workspaceUri = uri;
   await onWorkspaceChange();
 };
 const close$9 = () => {
@@ -2801,12 +3372,12 @@ const getResolveRootFromSessionStorage = async () => {
   return resolvedRoot;
 };
 const isTest = () => {
-  return state$B.isTest;
+  return state$A.isTest;
 };
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$B.isTest = true;
+    state$A.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -2855,7 +3426,7 @@ const getResolvedRoot = async href => {
   }
 };
 const getTitle$1 = workspacePath => {
-  const pathSeparator = state$B.pathSeparator;
+  const pathSeparator = state$A.pathSeparator;
   return workspacePath.slice(workspacePath.lastIndexOf(pathSeparator) + 1);
 };
 const getPathName = workspacePath => {
@@ -2865,41 +3436,41 @@ const getPathName = workspacePath => {
   return '';
 };
 const onWorkspaceChange = async () => {
-  const title = getTitle$1(state$B.workspacePath);
-  await set$b(title);
+  const title = getTitle$1(state$A.workspacePath);
+  await set$a(title);
   if (platform === Web$1 || platform === Remote) {
-    const pathName = getPathName(state$B.workspacePath);
+    const pathName = getPathName(state$A.workspacePath);
     await setPathName(pathName);
   }
-  await emitEvent('workspace.change', state$B.workspacePath);
+  await emitEvent('workspace.change', state$A.workspacePath);
 };
-const hydrate$7 = async ({
+const hydrate$6 = async ({
   href
 }) => {
-  if (state$B.workspacePath) {
+  if (state$A.workspacePath) {
     return;
   }
   const resolvedRoot = await getResolvedRoot(href);
-  if (state$B.isTest) {
+  if (state$A.isTest) {
     return;
   }
-  if (state$B.workspacePath) {
+  if (state$A.workspacePath) {
     return;
   }
   // TODO why is this if statement here?
-  if (state$B.homeDir !== resolvedRoot.homeDir) {
-    state$B.homeDir = resolvedRoot.homeDir;
+  if (state$A.homeDir !== resolvedRoot.homeDir) {
+    state$A.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$B.workspacePath = resolvedRoot.path;
-  state$B.homeDir = resolvedRoot.homeDir;
-  state$B.pathSeparator = resolvedRoot.pathSeparator;
-  state$B.workspaceUri = resolvedRoot.uri;
-  state$B.source = resolvedRoot.source;
+  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;
   await onWorkspaceChange();
 };
 
@@ -2908,10 +3479,10 @@ const hydrate$7 = async ({
  * @returns
  */
 const getWorkspacePath = () => {
-  return state$B.workspacePath;
+  return state$A.workspacePath;
 };
 const getHomeDir = () => {
-  return state$B.homeDir;
+  return state$A.homeDir;
 };
 
 // TODO this should be in FileSystem module
@@ -2919,15 +3490,15 @@ const pathBaseName = path => {
   return path.slice(path.lastIndexOf('/') + 1);
 };
 const pathRelative = path => {
-  if (path.startsWith(state$B.workspacePath)) {
-    return path.slice(state$B.workspacePath.length + 1, path.lastIndexOf('/'));
+  if (path.startsWith(state$A.workspacePath)) {
+    return path.slice(state$A.workspacePath.length + 1, path.lastIndexOf('/'));
   }
   return path;
 };
 
 // TODO this should be in FileSystem module
 const pathDirName = path => {
-  const pathSeparator = state$B.pathSeparator || '/';
+  const pathSeparator = state$A.pathSeparator || '/';
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
     return EmptyString;
@@ -2936,9 +3507,9 @@ const pathDirName = path => {
 };
 const getAbsolutePath = relativePath => {
   if (relativePath.startsWith('./')) {
-    return `${state$B.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
+    return `${state$A.workspacePath}/${relativePath.slice(2)}`; // TODO support windows paths
   }
-  return `${state$B.workspacePath}/${relativePath}`; // TODO support windows paths
+  return `${state$A.workspacePath}/${relativePath}`; // TODO support windows paths
 };
 
 const getStateToSave = () => {
@@ -2948,10 +3519,10 @@ const getStateToSave = () => {
     instances: savedInstances,
     mainEditors: [],
     workspace: {
-      path: state$B.workspacePath,
-      homeDir: state$B.homeDir,
-      pathSeparator: state$B.pathSeparator,
-      uri: state$B.workspaceUri
+      path: state$A.workspacePath,
+      homeDir: state$A.homeDir,
+      pathSeparator: state$A.pathSeparator,
+      uri: state$A.workspaceUri
     }
   };
 };
@@ -2974,7 +3545,7 @@ const handleVisibilityChange = async visibilityState => {
     // console.log('[renderer worker] state was saved')
   }
 };
-const hydrate$6 = async () => {
+const hydrate$5 = async () => {
   // TODO should set up listener in renderer process
   if (!get$e('workbench.saveStateOnVisibilityChange')) {
     console.info('[info] not saving state on visibility change - disabled by settings');
@@ -2986,14 +3557,14 @@ const getSavedViewletState = viewletId => {
   return getJson$2(viewletId);
 };
 
-const state$A = {
+const state$z = {
   idMap: Object.create(null)
 };
 const register$5 = (id, module) => {
-  state$A.idMap[id] = module;
+  state$z.idMap[id] = module;
 };
-const get$b = id => {
-  return state$A.idMap[id];
+const get$9 = id => {
+  return state$z.idMap[id];
 };
 
 const loadModule$3 = async (id, module) => {
@@ -3012,17 +3583,17 @@ const ViewletManagerVisitorCss = {
   loadModule: loadModule$3
 };
 
-const state$z = {
+const state$y = {
   /**
    * @type {any[]}
    */
   menuEntries: []
 };
 const getAll = () => {
-  return state$z.menuEntries;
+  return state$y.menuEntries;
 };
 const add$1 = menuEntries => {
-  state$z.menuEntries = [...state$z.menuEntries, ...menuEntries];
+  state$y.menuEntries = [...state$y.menuEntries, ...menuEntries];
 };
 
 const loadModule$2 = (id, module) => {
@@ -3043,7 +3614,7 @@ const loadModule$1 = async (id, module) => {
   }
 };
 
-const ActivityBar$5 = 'ActivityBar';
+const ActivityBar$6 = 'ActivityBar';
 const Audio$1 = 'Audio';
 const BrowserViewOverview = 'BrowserViewOverview';
 const Clock = 'Clock';
@@ -3109,7 +3680,7 @@ const WebView$1 = 'WebView';
 const ViewletModuleId = {
   __proto__: null,
   About: About$1,
-  ActivityBar: ActivityBar$5,
+  ActivityBar: ActivityBar$6,
   Audio: Audio$1,
   BrowserViewOverview,
   Clock,
@@ -3173,7 +3744,7 @@ const ViewletModuleId = {
 };
 
 // @ts-nocheck
-const state$y = {
+const state$x = {
   pendingModules: Object.create(null)
 };
 const ViewletState = {
@@ -3450,10 +4021,10 @@ const actuallyLoadModule = async (getModule, id) => {
   return module;
 };
 const loadModule = (getModule, id) => {
-  if (!(id in state$y.pendingModules)) {
-    state$y.pendingModules[id] = actuallyLoadModule(getModule, id);
+  if (!(id in state$x.pendingModules)) {
+    state$x.pendingModules[id] = actuallyLoadModule(getModule, id);
   }
-  return state$y.pendingModules[id];
+  return state$x.pendingModules[id];
 };
 
 // TODO add lots of unit tests for this
@@ -3587,7 +4158,7 @@ const load$7 = async (viewlet, focus = false, restore = false, restoreState = un
     }
     // TODO race condition: viewlet state may have been updated again in the mean time
     state = ViewletState.RendererProcessViewletLoaded;
-    set$c(viewletUid, {
+    set$b(viewletUid, {
       state: newState,
       renderedState: viewletState,
       factory: module,
@@ -3725,20 +4296,20 @@ const disposeBrowserViewQuickPick = () => {
   return invoke$8('ElectronBrowserViewQuickPick.disposeBrowserViewQuickPick');
 };
 
-const state$x = {
+const state$w = {
   id: 0
 };
-const set$a = value => {
-  state$x.id = value;
+const set$9 = value => {
+  state$w.id = value;
 };
-const get$a = () => {
-  return state$x.id;
+const get$8 = () => {
+  return state$w.id;
 };
 
 // TODO cache window id
 
 const getWindowId = async () => {
-  const webContentsId = get$a();
+  const webContentsId = get$8();
   const windowId = await invoke$8('GetWindowId.getWindowId', webContentsId);
   return windowId;
 };
@@ -3834,15 +4405,15 @@ const handleKeyBinding$1 = async identifier => {
   // }
 };
 
-const state$w = {
+const state$v = {
   isQuickPickOpen: false
 };
 const isQuickPickOpen = () => {
-  return state$w.isQuickPickOpen;
+  return state$v.isQuickPickOpen;
 };
 const closeWidgetElectronQuickPick = async () => {
   const id = QuickPick;
-  state$w.isQuickPickOpen = false;
+  state$v.isQuickPickOpen = false;
   remove$8(id);
   await disposeBrowserViewQuickPick();
   // TODO restore focus to previously focused element
@@ -4107,508 +4678,209 @@ const openWidget = async (moduleId, ...args) => {
     focus: true,
     args,
     uid: childUid
-  });
-  if (!commands) {
-    throw new Error('expected commands to be of type array');
-  }
-  if (hasInstance$1) {
-    commands.unshift(['Viewlet.dispose', moduleId]);
-  }
-  const layout = getState$1(Layout);
-  commands.push(['Viewlet.append', layout.uid, childUid]);
-  // TODO ask view to render, rendering focus
-  commands.push(['Viewlet.focus', childUid]);
-  await invoke$9('Viewlet.executeCommands', commands);
-  // TODO commands should be like this
-  // viewlet.create quickpick
-  // quickpick.setItems
-  // quickpick.setFocusedIndex
-  // quickpick.setValue
-  // viewlet.show quickpick
-  //
-};
-const closeWidget = async id => {
-  try {
-    if (isOpen() && id === isQuickPickOpen()) ;
-    const childInstance = getInstance(id);
-    if (!childInstance) {
-      return;
-    }
-    const child = childInstance.state;
-    const childUid = child.uid;
-    const commands = disposeFunctional(childUid);
-    await invoke$9(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
-    // TODO restore focus
-  } catch (error) {
-    throw new VError(error, `Failed to close widget ${id}`);
-  }
-};
-const getLazyImport = (module, fnName) => {
-  if (module.LazyCommands && module.LazyCommands[fnName]) {
-    return module.LazyCommands[fnName];
-  }
-  if (module.CommandsWithSideEffectsLazy && module.CommandsWithSideEffectsLazy[fnName]) {
-    return module.CommandsWithSideEffectsLazy[fnName];
-  }
-  return undefined;
-};
-const getFn$3 = async (module, fnName) => {
-  if (module.Commands && module.Commands[fnName]) {
-    return module.Commands[fnName];
-  }
-  if (module.CommandsWithSideEffects && module.CommandsWithSideEffects[fnName]) {
-    return module.CommandsWithSideEffects[fnName];
-  }
-  const lazyImport = getLazyImport(module, fnName);
-  if (!lazyImport) {
-    throw new Error(`Command ${module.name}.${fnName} not found in renderer worker`);
-  }
-  const importedModule = await lazyImport();
-  const lazyFn = importedModule[fnName];
-  if (!lazyFn) {
-    throw new Error(`Command not found ${module.name}.${fnName}`);
-  }
-  return lazyFn;
-};
-const executeViewletCommand = async (uid, fnName, ...args) => {
-  const instance = getInstance(uid);
-  if (!instance) {
-    warn$1(`cannot execute ${fnName} instance not found ${uid}`);
-    return;
-  }
-  const fn = await getFn$3(instance.factory, fnName);
-  const oldState = instance.state;
-  const newState = await fn(oldState, ...args);
-  const actualNewState = 'newState' in newState ? newState.newState : newState;
-  if (oldState === actualNewState) {
-    return;
-  }
-  if (!hasInstance(uid)) {
-    return;
-  }
-  const commands = render$Q(instance.factory, instance.renderedState, actualNewState);
-  if ('newState' in newState) {
-    commands.push(...newState.commands);
-  }
-  setRenderedState(uid, actualNewState);
-  if (commands.length === 0) {
-    return;
-  }
-  await invoke$9(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
-};
-
-// @ts-ignore
-const disposeWidgetWithValue = async (id, value) => {
-  try {
-    if (!id) {
-      console.warn('no instance to dispose');
-      return [];
-    }
-    const instance = getInstance(id);
-    if (!instance) {
-      warn$1(`cannot dispose instance ${id} because it may already be disposed`);
-      return [];
-    }
-    // TODO status should have enum
-    instance.status = 'disposing';
-    if (!instance.factory) {
-      throw new Error(`${id} is missing a factory function`);
-    }
-    if (instance.factory.dispose) {
-      instance.factory.dispose(instance.state);
-    }
-    const uid = instance.state.uid;
-    number$1(uid);
-    const commands = [[/* Viewlet.dispose */'Viewlet.dispose', /* id */uid]];
-    if (instance.factory.getKeyBindings) {
-      removeKeyBindings(uid);
-    }
-    if (instance.factory.getChildren) {
-      const children = instance.factory.getChildren(instance.state);
-      for (const child of children) {
-        if (child.id) {
-          commands.push(...disposeFunctional(child.id));
-        }
-      }
-    }
-    instance.status = 'disposed';
-    remove$8(id);
-    remove$8(uid);
-    await invoke$9('Viewlet.sendMultiple', commands);
-    // return commands
-    const parentInstance = getInstance(KeyBindings);
-    if (!parentInstance) {
-      return;
-    }
-    // @ts-ignore
-    const newState = parentInstance.factory.handleDefineKeyBindingDisposed(parentInstance.state, value);
-  } catch (error) {
-    console.error(error);
-    // TODO use Error.cause once proper stack traces are supported by chrome
-    throw new Error(`Failed to dispose viewlet ${id}: ${error}`);
-  }
-};
-
-const File$7 = '_file';
-const Folder$1 = '_folder';
-const FolderOpen = '_folder_open';
-const None$k = '';
-
-const BlockDevice = 1;
-const CharacterDevice = 2;
-const Directory$1 = 3;
-const DirectoryExpanded = 4;
-const DirectoryExpanding = 5;
-const File$6 = 7;
-const Socket = 8;
-const Symlink = 9;
-const SymLinkFile = 10;
-const SymLinkFolder = 11;
-const Unknown$1 = 12;
-
-const getAbsoluteIconPath = (iconTheme, icon) => {
-  const result = iconTheme.iconDefinitions[icon];
-  return `${assetDir}/file-icons/${result.slice(12)}`;
-};
-
-const getLanguages$2 = async () => {
-  // TODO handle error
-  const languages = await invoke$8(/* ExtensionHost.getLanguages */'ExtensionHost.getLanguages');
-  return languages;
-};
-const joinPath = (extensionPath, relativePath) => {
-  if (relativePath.startsWith('./')) {
-    return extensionPath + relativePath.slice(1);
-  }
-  return extensionPath + relativePath;
-};
-const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
-  for (const extension of extensions) {
-    if (extension && extension.languages && Array.isArray(extension.languages)) {
-      for (const language of extension.languages) {
-        if (language && language.id === languageId && language.configuration) {
-          const path = joinPath(extension.path, language.configuration);
-          return path;
-        }
-      }
-    }
-  }
-  return '';
-};
-const getLanguageConfigurationFromWebExtension = async languageId => {
-  const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(state$F.webExtensions, languageId);
-  if (!languageConfigurationPath) {
-    return undefined;
-  }
-  const json = await execute$4('Ajax.getJson', languageConfigurationPath);
-  return json;
-};
-const getLanguageConfiguration$3 = async languageId => {
-  const languageConfiguration = await invoke$8(/* ExtensionHost.getLanguageConfiguration */'ExtensionHost.getLanguageConfiguration', /* languageId */languageId);
-  if (languageConfiguration) {
-    return languageConfiguration;
-  }
-  return getLanguageConfigurationFromWebExtension(languageId);
-};
-
-const getLanguages$1 = async () => {
-  const url = `${assetDir}/config/languages.json`;
-  // TODO handle error ?
-  return execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */url);
-};
-const getLanguageConfiguration$2 = async languageId => {
-  warn$1('get language configuration not yet supported on web');
-};
-
-const getLanguages = async () => {
-  try {
-    switch (platform) {
-      case Web$1:
-        return await getLanguages$1();
-      default:
-        return await getLanguages$2();
-    }
-  } catch (error) {
-    throw new VError(error, 'Failed to load languages');
-  }
-};
-const getLanguageConfiguration$1 = async languageId => {
-  string(languageId);
-  switch (platform) {
-    case Web$1:
-      return getLanguageConfiguration$2();
-    default:
-      return getLanguageConfiguration$3(languageId);
-  }
-};
-
-const getFileExtensionIndex = file => {
-  string(file);
-  return file.lastIndexOf(Dot);
-};
-const getFileExtension = file => {
-  const index = getFileExtensionIndex(file);
-  return file.slice(index);
-};
-const getNthFileExtension = (file, startIndex) => {
-  return file.lastIndexOf(Dot, startIndex);
-};
-
-// TODO merge all of this with extension host languages module
-
-const state$v = {
-  loadState: false,
-  isHydrating: false,
-  fileNameMap: Object.create(null),
-  extensionMap: Object.create(null),
-  tokenizerMap: Object.create(null),
-  /**
-   * @type {any[]}
-   */
-  firstLines: [],
-  /**
-   * @type {string[]}
-   */
-  hasWarned: []
-};
-const getFirstLines = () => {
-  return state$v.firstLines;
-};
-const hasLanguageByExtension = extension => {
-  return extension in state$v.extensionMap;
-};
-const getLanguageByExtension = extension => {
-  return state$v.extensionMap[extension];
-};
-const hasLanguageByFileName = fileName => {
-  return fileName in state$v.fileNameMap;
-};
-const getLanguageByFileName = 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$v.tokenizerMap[languageId] || '';
-};
-const setHydrating = value => {
-  state$v.isHydrating = value;
-};
-const setLoaded = value => {
-  state$v.loaded = true;
-};
-const addExtension = (extension, languageId) => {
-  state$v.extensionMap[extension] = languageId;
-};
-const addFirstLine = (regex, languageId) => {
-  state$v.firstLines.push({
-    regex,
-    languageId
-  });
-};
-const hasWarned = languageId => {
-  return state$v.hasWarned.includes(languageId);
-};
-const addWarned = languageId => {
-  return state$v.hasWarned.push(languageId);
-};
-const addFileName = (fileName, languageId) => {
-  state$v.fileNameMap[fileName] = languageId;
-};
-const addTokenizer = (languageId, tokenizer) => {
-  state$v.tokenizerMap[languageId] = tokenizer;
-};
-const hasLoaded$1 = () => {
-  return state$v.loaded;
-};
-
-// TODO merge all of this with extension host languages module
-
-const getLanguageId$1 = fileName => {
-  string(fileName);
-  // TODO this is inefficient for icon theme, as file extension is computed twice
-  const extensionIndex = getFileExtensionIndex(fileName);
-  const extension = fileName.slice(extensionIndex);
-  const extensionLower = extension.toLowerCase();
-  if (hasLanguageByExtension(extensionLower)) {
-    return getLanguageByExtension(extensionLower);
-  }
-  const fileNameLower = fileName.toLowerCase();
-  const secondExtensionIndex = getNthFileExtension(fileName, extensionIndex - 1);
-  const secondExtension = fileName.slice(secondExtensionIndex);
-  if (secondExtensionIndex !== -1 && hasLanguageByExtension(secondExtension)) {
-    return getLanguageByExtension(secondExtension);
-  }
-  if (hasLanguageByFileName(fileNameLower)) {
-    return getLanguageByFileName(fileNameLower);
-  }
-  return 'unknown';
-};
-const getLanguageIdByFirstLine = firstLine => {
-  const firstLines = getFirstLines();
-  for (const {
-    regex,
-    languageId
-  } of firstLines) {
-    const actualRegex = new RegExp(regex);
-    if (actualRegex.test(firstLine)) {
-      return languageId;
-    }
+  });
+  if (!commands) {
+    throw new Error('expected commands to be of type array');
   }
-  return 'unknown';
-};
-const getTokenizeFunctionPath = languageId => {
-  // TODO what if language.tokenize is not of type string? -> handle error gracefully
-  return getTokenizeFunctionPath$1(languageId);
-};
-const hydrate$5 = async () => {
-  setHydrating(true);
-  // TODO handle error
-  // TODO main parts should have nothing todo with shared process -> only sub components
-  const languages = await getLanguages();
-  // TODO avoid side effect here, but how?
-  await addLanguages(languages);
-  const useJsx = get$e('languages.jsFilesAsJsx');
-  if (useJsx) {
-    addExtension('.js', 'jsx');
+  if (hasInstance$1) {
+    commands.unshift(['Viewlet.dispose', moduleId]);
   }
-  setLoaded();
+  const layout = getState$1(Layout);
+  commands.push(['Viewlet.append', layout.uid, childUid]);
+  // TODO ask view to render, rendering focus
+  commands.push(['Viewlet.focus', childUid]);
+  await invoke$9('Viewlet.executeCommands', commands);
+  // TODO commands should be like this
+  // viewlet.create quickpick
+  // quickpick.setItems
+  // quickpick.setFocusedIndex
+  // quickpick.setValue
+  // viewlet.show quickpick
+  //
 };
-
-// TODO make contribution points not rely on globals and side effects
-const contributionPointFileExtensions = {
-  key: 'fileExtensions',
-  handle(value, languageId) {
-    if (value) {
-      warn$1(`[renderer-worker] unsupported property "fileExtensions" for language ${languageId}, use the property "extensions" instead`);
+const closeWidget = async id => {
+  try {
+    if (isOpen() && id === isQuickPickOpen()) ;
+    const childInstance = getInstance(id);
+    if (!childInstance) {
+      return;
     }
+    const child = childInstance.state;
+    const childUid = child.uid;
+    const commands = disposeFunctional(childUid);
+    await invoke$9(/* Viewlet.dispose */'Viewlet.sendMultiple', commands);
+    // TODO restore focus
+  } catch (error) {
+    throw new VError(error, `Failed to close widget ${id}`);
   }
 };
-const contributionPointFileNames = {
-  key: 'fileNames',
-  handle(value, languageId) {
-    if (value && Array.isArray(value)) {
-      for (const fileName of value) {
-        if (typeof fileName === 'string') {
-          const fileNameLower = fileName.toLowerCase();
-          addFileName(fileNameLower, languageId);
-        } else {
-          warn$1(`[renderer-worker] language.fileNames for ${languageId} should be an array of strings but includes ${typeof fileName}`);
-        }
-      }
-    }
+const getLazyImport = (module, fnName) => {
+  if (module.LazyCommands && module.LazyCommands[fnName]) {
+    return module.LazyCommands[fnName];
+  }
+  if (module.CommandsWithSideEffectsLazy && module.CommandsWithSideEffectsLazy[fnName]) {
+    return module.CommandsWithSideEffectsLazy[fnName];
   }
+  return undefined;
 };
-const contributionPointFirstLine = {
-  key: 'firstLine',
-  handle(value, languageId) {
-    addFirstLine(value, languageId);
+const getFn$3 = async (module, fnName) => {
+  if (module.Commands && module.Commands[fnName]) {
+    return module.Commands[fnName];
+  }
+  if (module.CommandsWithSideEffects && module.CommandsWithSideEffects[fnName]) {
+    return module.CommandsWithSideEffects[fnName];
+  }
+  const lazyImport = getLazyImport(module, fnName);
+  if (!lazyImport) {
+    throw new Error(`Command ${module.name}.${fnName} not found in renderer worker`);
   }
+  const importedModule = await lazyImport();
+  const lazyFn = importedModule[fnName];
+  if (!lazyFn) {
+    throw new Error(`Command not found ${module.name}.${fnName}`);
+  }
+  return lazyFn;
 };
-const warnFileNames = (languageId, language) => {
-  if (hasWarned(languageId)) {
+const executeViewletCommand = async (uid, fnName, ...args) => {
+  const instance = getInstance(uid);
+  if (!instance) {
+    warn$1(`cannot execute ${fnName} instance not found ${uid}`);
     return;
   }
-  addWarned(languageId);
-  const code = JSON.stringify(language, null, 2);
-  const lines = splitLines(code);
-  let rowIndex = 0;
-  let columnIndex = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const fileNamesIndex = line.indexOf('filenames');
-    if (fileNamesIndex !== -1) {
-      rowIndex = i;
-      columnIndex = fileNamesIndex;
-      break;
-    }
+  const fn = await getFn$3(instance.factory, fnName);
+  const oldState = instance.state;
+  const newState = await fn(oldState, ...args);
+  const actualNewState = 'newState' in newState ? newState.newState : newState;
+  if (oldState === actualNewState) {
+    return;
   }
-  const codeFrame = create$1b(code, {
-    start: {
-      line: rowIndex + 1,
-      column: columnIndex + 1
-    },
-    end: {
-      line: rowIndex + 1,
-      column: columnIndex + 'filenames'.length + 1
-    }
-  });
-  warn$1(`Please use "fileNames" instead of "filenames" for language ${languageId}
-${codeFrame}
-`);
-};
-const contributionPointFileNamesLower = {
-  key: 'filenames',
-  handle(value, languageId, language) {
-    warnFileNames(languageId, language);
-    contributionPointFileNames.handle(value, languageId);
+  if (!hasInstance(uid)) {
+    return;
+  }
+  const commands = render$Q(instance.factory, instance.renderedState, actualNewState);
+  if ('newState' in newState) {
+    commands.push(...newState.commands);
   }
+  setRenderedState(uid, actualNewState);
+  if (commands.length === 0) {
+    return;
+  }
+  await invoke$9(/* Viewlet.sendMultiple */'Viewlet.sendMultiple', /* commands */commands);
 };
-const contributionPointExtensions = {
-  key: 'extensions',
-  handle(value, languageId) {
-    if (value && Array.isArray(value)) {
-      for (const extension of value) {
-        if (typeof extension === 'string') {
-          addExtension(extension, languageId);
-        } else {
-          warn$1(`[renderer-worker] language.extensions for ${languageId} should be an array of strings but includes ${typeof extension}`);
+
+// @ts-ignore
+const disposeWidgetWithValue = async (id, value) => {
+  try {
+    if (!id) {
+      console.warn('no instance to dispose');
+      return [];
+    }
+    const instance = getInstance(id);
+    if (!instance) {
+      warn$1(`cannot dispose instance ${id} because it may already be disposed`);
+      return [];
+    }
+    // TODO status should have enum
+    instance.status = 'disposing';
+    if (!instance.factory) {
+      throw new Error(`${id} is missing a factory function`);
+    }
+    if (instance.factory.dispose) {
+      instance.factory.dispose(instance.state);
+    }
+    const uid = instance.state.uid;
+    number$1(uid);
+    const commands = [[/* Viewlet.dispose */'Viewlet.dispose', /* id */uid]];
+    if (instance.factory.getKeyBindings) {
+      removeKeyBindings(uid);
+    }
+    if (instance.factory.getChildren) {
+      const children = instance.factory.getChildren(instance.state);
+      for (const child of children) {
+        if (child.id) {
+          commands.push(...disposeFunctional(child.id));
         }
       }
     }
-  }
-};
-const contributionPointTokenize = {
-  key: 'tokenize',
-  handle(value, languageId) {
-    if (value) {
-      addTokenizer(languageId, value);
+    instance.status = 'disposed';
+    remove$8(id);
+    remove$8(uid);
+    await invoke$9('Viewlet.sendMultiple', commands);
+    // return commands
+    const parentInstance = getInstance(KeyBindings);
+    if (!parentInstance) {
+      return;
     }
+    // @ts-ignore
+    const newState = parentInstance.factory.handleDefineKeyBindingDisposed(parentInstance.state, value);
+  } catch (error) {
+    console.error(error);
+    // TODO use Error.cause once proper stack traces are supported by chrome
+    throw new Error(`Failed to dispose viewlet ${id}: ${error}`);
   }
 };
-const contributionPoints = [contributionPointFileExtensions, contributionPointExtensions, contributionPointFileNames, contributionPointFileNamesLower, contributionPointTokenize, contributionPointFirstLine];
-const addLanguage = language => {
-  const languageId = language.id;
-  if (!languageId) {
-    warn$1('[renderer-worker] language is missing id', language);
-    return;
-  }
-  // TODO could use object destructuing here
-  // TODO maybe map the other way around from language keys to contribution points
-  for (const contributionPoint of contributionPoints) {
-    const value = language[contributionPoint.key];
-    if (value) {
-      contributionPoint.handle(value, languageId, language);
+
+const handleIconThemeChange$4 = async () => {
+  const instances = getAllInstances();
+  // TODO have one recalculate style and one paint
+  // @ts-ignore
+  for (const [key, value] of Object.entries(instances)) {
+    const {
+      factory,
+      state
+    } = value;
+    if (factory.handleIconThemeChange) {
+      const newState = factory.handleIconThemeChange(state);
+      await setState(factory.name, newState);
     }
   }
 };
-const addLanguages = async languages => {
-  for (const language of languages) {
-    addLanguage(language);
-  }
-  await emitEvent('languages.changed');
+
+const initialIconTheme = undefined;
+
+const state$u = {
+  seenFiles: [],
+  seenFolders: [],
+  hasWarned: [],
+  /**
+   * @type{any}
+   */
+  iconTheme: initialIconTheme,
+  extensionPath: ''
 };
-const hasLoaded = () => {
-  return hasLoaded$1();
+const setTheme = iconTheme => {
+  state$u.iconTheme = iconTheme.json;
+  state$u.extensionPath = iconTheme.extensionPath;
 };
-const getLanguageConfiguration = async editor => {
-  if (!hasLoaded()) {
-    throw new Error('languages must be loaded before requesting language configuration');
-  }
-  try {
-    editor.languageId = getLanguageId$1(editor.uri);
-    const languageConfiguration = await getLanguageConfiguration$1(editor.languageId);
-    return languageConfiguration;
-  } catch (error$1) {
-    error(error$1);
-    return {};
-  }
+const getIconTheme = () => {
+  return state$u.iconTheme;
+};
+
+const File$7 = '_file';
+const Folder$1 = '_folder';
+const FolderOpen = '_folder_open';
+const None$k = '';
+
+const BlockDevice = 1;
+const CharacterDevice = 2;
+const Directory$1 = 3;
+const DirectoryExpanded = 4;
+const DirectoryExpanding = 5;
+const File$6 = 7;
+const Socket = 8;
+const Symlink = 9;
+const SymLinkFile = 10;
+const SymLinkFolder = 11;
+const Unknown$1 = 12;
+
+const getAbsoluteIconPath = (iconTheme, icon) => {
+  const result = iconTheme.iconDefinitions[icon];
+  return `${assetDir}/file-icons/${result.slice(12)}`;
 };
 
 const getFileNameIcon = file => {
   string(file);
-  const {
-    iconTheme
-  } = state$E;
+  const iconTheme = getIconTheme();
   const fileNameLower = file.toLowerCase();
   if (!iconTheme) {
     return '';
@@ -4648,7 +4920,7 @@ const getFileIcon$3 = file => {
   return getFileNameIcon(file.name);
 };
 const getFolderNameIcon = folderName => {
-  const iconTheme = state$E.iconTheme;
+  const iconTheme = getIconTheme();
   // @ts-ignore
   if (!iconTheme || !iconTheme.folderNames || !iconTheme.iconDefinitions) {
     return '';
@@ -4665,7 +4937,7 @@ const getFolderIcon = folder => {
   return getFolderNameIcon(folder.name);
 };
 const getFolderIconExpanded = folder => {
-  const iconTheme = state$E.iconTheme;
+  const iconTheme = getIconTheme();
   if (!iconTheme) {
     return '';
   }
@@ -4694,7 +4966,7 @@ const getIcon$2 = dirent => {
     case CharacterDevice:
     case BlockDevice:
     case Socket:
-      return getAbsoluteIconPath(state$E.iconTheme, File$7);
+      return getAbsoluteIconPath(getIconTheme(), File$7);
     default:
       warn$1(`unsupported type ${dirent.type}`);
       return None$k;
@@ -4704,21 +4976,11 @@ const getIcon$2 = dirent => {
 const setIconTheme = async iconThemeId => {
   try {
     const iconTheme = await getIconThemeJson(iconThemeId);
-    state$E.iconTheme = iconTheme.json;
-    state$E.extensionPath = iconTheme.extensionPath;
-    const instances = getAllInstances();
-    // TODO have one recalculate style and one paint
-    // @ts-ignore
-    for (const [key, value] of Object.entries(instances)) {
-      const {
-        factory,
-        state
-      } = value;
-      if (factory.handleIconThemeChange) {
-        const newState = factory.handleIconThemeChange(state);
-        await setState(factory.name, newState);
-      }
+    if (!iconTheme) {
+      return;
     }
+    setTheme(iconTheme);
+    await handleIconThemeChange$4();
   } catch (error) {
     if (isTest()) ; else {
       console.error(new VError(error, 'Failed to load icon theme'));
@@ -4804,14 +5066,14 @@ const hydrate$3 = async () => {
   }
 };
 
-const state$u = {
+const state$t = {
   shouldLaunchMultipleWorkers: false
 };
 const setConfig = shouldLaunchMultipleWorkers => {
-  state$u.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
+  state$t.shouldLaunchMultipleWorkers = shouldLaunchMultipleWorkers;
 };
 const getConfig = () => {
-  return state$u.shouldLaunchMultipleWorkers;
+  return state$t.shouldLaunchMultipleWorkers;
 };
 
 const Zero = 0;
@@ -4831,27 +5093,27 @@ const Fourteen = 14;
 const Fifteen = 15;
 const Sixteen = 16;
 
-const state$t = {
+const state$s = {
   listenerMap: Object.create(null),
   phase: Zero
 };
 const once = (event, listener) => {
-  if (state$t.phase >= event) {
+  if (state$s.phase >= event) {
     listener();
   } else {
     // TODO could also statically allocate listenermap at start as array[13]
-    state$t.listenerMap[event] ||= [];
-    state$t.listenerMap[event].push(listener);
+    state$s.listenerMap[event] ||= [];
+    state$s.listenerMap[event].push(listener);
   }
 };
 const mark$1 = event => {
-  const listeners = state$t.listenerMap[event] || [];
+  const listeners = state$s.listenerMap[event] || [];
   for (const listener of listeners) {
     listener();
   }
-  state$t.phase = event;
+  state$s.phase = event;
   if (event === Twelve) {
-    state$t.listenerMap = Object.create(null);
+    state$s.listenerMap = Object.create(null);
   }
 };
 
@@ -5547,7 +5809,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state$s = {
+const state$r = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -5565,7 +5827,7 @@ const isDataCloneError = error => {
 
 const getDb$1 = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$s.dbVersion, {
+  const db = await openDB('session', state$r.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -5580,8 +5842,8 @@ const getDb$1 = async () => {
   return db;
 };
 const getDbMemoized$1 = async () => {
-  state$s.cachedDb ||= await getDb$1();
-  return state$s.cachedDb;
+  state$r.cachedDb ||= await getDb$1();
+  return state$r.cachedDb;
 };
 const saveValue$1 = async (storeId, value) => {
   try {
@@ -5608,7 +5870,7 @@ const getValuesByIndexName$1 = async (storeId, indexName, only) => {
 };
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state$s.dbVersion, {
+  const db = await openDB('handle', state$r.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         // @ts-ignore
@@ -5649,12 +5911,12 @@ const creareSessionId = () => {
   return `session-${new Date().toISOString()}`;
 };
 
-const state$r = {
+const state$q = {
   sessionId: ''
 };
 const getSessionId = () => {
-  state$r.sessionId ||= creareSessionId();
-  return state$r.sessionId;
+  state$q.sessionId ||= creareSessionId();
+  return state$q.sessionId;
 };
 
 const withResolvers = () => {
@@ -5715,7 +5977,7 @@ const addSearchParam = (href, key, value) => {
   return parsedUrl.toString();
 };
 const replayCurrentSession = async () => {
-  if (!state$r.sessionId) {
+  if (!state$q.sessionId) {
     throw new VError('session replay is disabled in settings');
   }
   // TODO
@@ -5873,7 +6135,7 @@ const handleUnhandledError = (message, filename, lineno, colno, error) => {
 
 const map$1 = {
   [About$1]: () => Promise.resolve().then(function () { return ViewletAbout_ipc; }),
-  [ActivityBar$5]: () => Promise.resolve().then(function () { return ViewletActivityBar_ipc; }),
+  [ActivityBar$6]: () => Promise.resolve().then(function () { return ViewletActivityBar_ipc; }),
   [Audio$1]: () => Promise.resolve().then(function () { return ViewletAudio_ipc; }),
   [BrowserViewOverview]: () => Promise.resolve().then(function () { return ViewletBrowserViewOverview_ipc; }),
   [Clock]: () => Promise.resolve().then(function () { return ViewletClock_ipc; }),
@@ -5928,223 +6190,6 @@ const map$1 = {
   [WebView$1]: () => Promise.resolve().then(function () { return ViewletWebView_ipc; })
 };
 
-const Resolved = 'resolved';
-const Rejected$1 = 'rejected';
-
-const webExtensionsUrl = `${assetDir}/config/webExtensions.json`;
-
-const getSharedProcessExtensions$1 = () => {
-  return invoke$8(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
-};
-const getStaticWebExtensions = () => {
-  return execute$4('Ajax.getJson', webExtensionsUrl);
-};
-const getWebExtensionsWeb = async () => {
-  const staticWebExtensions = await getStaticWebExtensions();
-  return [...staticWebExtensions, ...state$F.webExtensions];
-};
-const isWebExtension = extension => {
-  return extension && typeof extension.browser === 'string';
-};
-const getWebExtensionsDefault = async () => {
-  const staticWebExtensions = await getStaticWebExtensions();
-  const sharedProcessExtensions = await getSharedProcessExtensions$1();
-  const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
-  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$F.webExtensions];
-};
-const getWebExtensions = async () => {
-  try {
-    switch (platform) {
-      case Web$1:
-        return getWebExtensionsWeb();
-      default:
-        return getWebExtensionsDefault();
-    }
-  } catch {
-    return state$F.webExtensions;
-  }
-};
-
-const state$q = {
-  webViews: []
-};
-const addMany = webViews => {
-  state$q.webViews = [...state$q.webViews, ...webViews];
-};
-const get$9 = () => {
-  return state$q.webViews;
-};
-
-const getId$3 = path => {
-  const slashIndex = path.lastIndexOf(Slash$2);
-  return path.slice(slashIndex + 1);
-};
-const getWebManifestPath = path => {
-  const manifestPath = `${path}/extension.json`;
-  return manifestPath;
-};
-const getWebExtensionManifest$1 = async (path, manifestPath) => {
-  try {
-    const manifest = await execute$4(/* Ajax.getJson */'Ajax.getJson', /* url */manifestPath);
-    return {
-      ...manifest,
-      path
-    };
-  } catch (error) {
-    const id = getId$3(path);
-    throw new VError(error, `Failed to load extension manifest for ${id}`);
-  }
-};
-const addWebExtension = async path => {
-  const manifestPath = getWebManifestPath(path);
-  const manifest = await getWebExtensionManifest$1(path, manifestPath);
-  // TODO avoid side effect here
-  if (manifest.languages) {
-    for (const language of manifest.languages) {
-      language.tokenize &&= manifest.path + Slash$2 + language.tokenize;
-    }
-  }
-  manifest.status = Resolved;
-  state$F.webExtensions.push(manifest);
-  if (manifest.languages) {
-    // TODO handle case when languages is not of type array
-    await addLanguages(manifest.languages);
-  }
-  if (manifest.webViews) {
-    for (const webView of manifest.webViews) {
-      webView.path = manifest.path + Slash$2 + webView.path;
-    }
-    addMany(manifest.webViews);
-  }
-  // const absolutePath = manifest.path + '/' + manifest.browser
-  // await ExtensionHostWorker.invoke('ExtensionHostExtension.activate', manifest, absolutePath)
-};
-
-// TODO status fulfilled should be handled as resolved
-const organizeExtensions = extensions => {
-  const rejected = [];
-  const resolved = [];
-  for (const extension of extensions) {
-    switch (extension.status) {
-      case Resolved:
-        resolved.push(extension);
-        break;
-      case Rejected$1:
-        rejected.push(extension);
-        break;
-      default:
-        resolved.push(extension);
-        break;
-    }
-  }
-  return {
-    resolved,
-    rejected
-  };
-};
-const validateEvents = extension => {
-  if (!extension) {
-    return [];
-  }
-  if (!extension.activation) {
-    return [];
-  }
-  // TODO handle error when extension.activation is not of type array (null or number or ...)
-  const warnings = [];
-  for (const item of extension.activation) {
-    if (item.startsWith('onWebview:')) {
-      warnings.push(`[renderer-worker] Invalid extension activation event in ${extension.path}: should be onWebView:`);
-    }
-  }
-  return warnings;
-};
-const filterByMatchingEvent = (extensions, event) => {
-  const extensionsToActivate = [];
-  for (const extension of extensions) {
-    const warnings = validateEvents(extension);
-    for (const warning of warnings) {
-      console.warn(warning);
-    }
-    // TODO handle error when extension.activation is not of type array (null or number or ...)
-    if (extension.activation && extension.activation.includes(event)) {
-      extensionsToActivate.push(extension);
-    }
-  }
-  return extensionsToActivate;
-};
-const getCodeFrameFromError = error => {
-  if (error && error.jse_cause && error.jse_cause.codeFrame) {
-    return error.jse_cause.codeFrame;
-  }
-  return '';
-};
-const getOriginalStackFromError = error => {
-  if (error && error.originalStack) {
-    return error.originalStack;
-  }
-  return '';
-};
-const handleRejectedExtension = async extension => {
-  const {
-    reason
-  } = extension;
-  const {
-    message,
-    code
-  } = reason;
-  if (code === E_MANIFEST_NOT_FOUND || code === ENOTDIR) {
-    return;
-  }
-  const codeFrame = getCodeFrameFromError(reason);
-  const stack = getOriginalStackFromError(reason);
-  error(`${message}\n${codeFrame}\n${stack}`);
-};
-const handleRejectedExtensions = async extensions => {
-  for (const extension of extensions) {
-    await handleRejectedExtension(extension);
-  }
-};
-const getSharedProcessExtensions = () => {
-  return invoke$8(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
-};
-const getExtensions$2 = async () => {
-  if (platform === Web$1) {
-    const webExtensions = await getWebExtensions();
-    return webExtensions;
-  }
-  if (platform === Remote) {
-    const webExtensions = await getWebExtensions();
-    const sharedProcessExtensions = await getSharedProcessExtensions();
-    return [...sharedProcessExtensions, ...webExtensions];
-  }
-  const extensions = await getSharedProcessExtensions();
-  return extensions;
-};
-const addNodeExtension = async path => {
-  // TODO add support for dynamically loading node extensions
-  // e.g. for testing multiple extensions
-  throw new Error('not implemented');
-};
-
-const cache = Object.create(null);
-const id$p = 1;
-const get$8 = () => {
-  return cache[id$p];
-};
-const has$1 = () => {
-  return id$p in cache;
-};
-const set$9 = value => {
-  cache[id$p] = value;
-};
-
-const getExtensions$1 = () => {
-  if (!has$1()) {
-    set$9(getExtensions$2());
-  }
-  return get$8();
-};
-
 // TODO lazyload parts one by one (Main, SideBar, ActivityBar, TitleBar, StatusBar)
 const startup = async () => {
   onunhandledrejection = handleUnhandledRejection;
@@ -6185,7 +6230,7 @@ const startup = async () => {
   }
   mark$1(Twelve);
   mark(WillOpenWorkspace);
-  await hydrate$7(initData.Location);
+  await hydrate$6(initData.Location);
   mark(DidOpenWorkspace);
   await hydrate$9();
   mark$1(Three);
@@ -6219,7 +6264,7 @@ const startup = async () => {
   // await Layout.hydrate(initData)
   mark(DidShowLayout);
   mark(WillLoadLanguages);
-  await hydrate$5();
+  await hydrate$8();
   mark(DidLoadLanguages);
   mark$1(Five);
   mark(WillLoadMain);
@@ -6269,7 +6314,7 @@ const startup = async () => {
     return;
   }
   mark(WillLoadSaveState);
-  await hydrate$6();
+  await hydrate$5();
   mark(DidLoadSaveState);
   mark$1(Sixteen);
   mark(WillLoadRecentlyOpened);
@@ -6279,7 +6324,7 @@ const startup = async () => {
   // TODO tree shake out service worker in electron build
 
   mark(WillLoadLocation);
-  await hydrate$8();
+  await hydrate$7();
   mark(DidLoadLocation);
   await hydrate$3();
   measure(OpenWorkspace, WillOpenWorkspace, DidOpenWorkspace);
@@ -6629,9 +6674,9 @@ const launchExtensionHostWorker = async () => {
     ipc = wrap$7(port);
   }
   handleIpc(ipc);
-  await invoke$a(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
+  await invoke$a(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
   addListener('workspace.change', async () => {
-    await invoke$a(ipc, 'Workspace.setWorkspacePath', state$B.workspacePath);
+    await invoke$a(ipc, 'Workspace.setWorkspacePath', state$A.workspacePath);
   });
   return ipc;
 };
@@ -7463,6 +7508,9 @@ const copy$9 = (source, target) => {
 const readFile$7 = (path, encoding) => {
   return invoke$8(FileSystemReadFile$1, /* path */path, /* encoding */encoding);
 };
+const readJson$2 = path => {
+  return invoke$8(FileSystemReadJson, /* path */path);
+};
 const remove$1 = path => {
   return invoke$8(FileSystemRemove$1, /* path */path);
 };
@@ -7522,6 +7570,7 @@ const FileSystemDisk = {
   name: name$2m,
   readDirWithFileTypes: readDirWithFileTypes$1,
   readFile: readFile$7,
+  readJson: readJson$2,
   remove: remove$1,
   rename: rename$3,
   stat,
@@ -8323,7 +8372,7 @@ const getPort = async ipcId => {
     ipcId
   });
   // TODO avoid side effect?
-  set$a(webContentsId);
+  set$9(webContentsId);
   return port2;
 };
 const create$16 = async options => {
@@ -9271,9 +9320,9 @@ const formatAboutDate = isoDate => {
   return `${isoDate} (${ago})`;
 };
 
-const version = '0.35.9';
-const commit = '19a90fe';
-const date = '2024-10-06T14:35:33.000Z';
+const version = '0.35.10';
+const commit = '5d1ba9a';
+const date = '2024-10-06T17:53:48.000Z';
 const getPid = () => {
   return invoke$8('Process.getPid');
 };
@@ -11584,7 +11633,7 @@ const menuEntrySeparator = {
   command: ''
 };
 
-const ActivityBar$4 = 1;
+const ActivityBar$5 = 1;
 const Edit$1 = 2;
 const Editor$1 = 3;
 const Explorer$2 = 4;
@@ -12885,7 +12934,7 @@ const load$2 = id => {
 };
 
 const getModule$3 = id => {
-  const module = get$b(id);
+  const module = get$9(id);
   if (module) {
     return module;
   }
@@ -12943,7 +12992,7 @@ const Tree = 'tree';
 const TreeItem$1 = 'treeitem';
 
 const Actions = 'Actions';
-const ActivityBar$3 = 'ActivityBar';
+const ActivityBar$4 = 'ActivityBar';
 const TestActive = 'TestActive';
 const ActivityBarItem$1 = 'ActivityBarItem';
 const ActivityBarItemNested = 'ActivityBarItemNested';
@@ -14524,7 +14573,7 @@ const name$1p = 'SaveState';
 // prettier-ignore
 const Commands$1f = {
   handleVisibilityChange: handleVisibilityChange,
-  hydrate: hydrate$6
+  hydrate: hydrate$5
 };
 
 const SaveState_ipc = {
@@ -14668,7 +14717,7 @@ const Window_ipc = {
 
 const name$1h = 'Workspace';
 const Commands$17 = {
-  hydrate: hydrate$7,
+  hydrate: hydrate$6,
   setPath: setPath,
   setUri: setUri,
   close: close$9
@@ -14682,7 +14731,7 @@ const Workspace_ipc = {
 
 const name$1g = 'WindowTitle';
 const Commands$16 = {
-  set: set$b
+  set: set$a
 };
 
 const WindowTitle_ipc = {
@@ -15426,7 +15475,7 @@ const getWebViewsDefault = async () => {
 };
 const getWebViews = async () => {
   const nodeWebViews = await getWebViewsDefault();
-  const registeredWebViews = get$9();
+  const registeredWebViews = get$b();
   const allWebViews = [...nodeWebViews, ...registeredWebViews];
   return allWebViews;
 };
@@ -15591,7 +15640,7 @@ const Copy$1 = 2;
 
 // TODO remove this file and merge with whenExpressions
 const About = FocusAbout;
-const ActivityBar$2 = FocusActivityBar;
+const ActivityBar$3 = FocusActivityBar;
 const EditorCompletion = FocusEditorCompletions;
 const EditorImage = FocusEditorImage;
 const Empty = Empty$2;
@@ -16352,7 +16401,7 @@ const menuEntryMoveSideBar = sideBarLocation => {
       throw new Error('unexpected side bar location');
   }
 };
-const id$c = ActivityBar$4;
+const id$c = ActivityBar$5;
 const getMenuEntries$g = async (layoutState, activityBarState) => {
   const {
     activityBarItems
@@ -16367,7 +16416,7 @@ const getMenuEntries$g = async (layoutState, activityBarState) => {
     command: /* Layout.hideActivityBar */'Layout.hideActivityBar'
   }];
 };
-const inject = [Layout, ActivityBar$5];
+const inject = [Layout, ActivityBar$6];
 
 const MenuEntriesActivityBar = {
   __proto__: null,
@@ -16401,7 +16450,7 @@ const getQuickPickMenuEntries$4 = () => {
 
 const Vertical$2 = 'vertical';
 
-const ActivityBar$1 = 'ActivityBar';
+const ActivityBar$2 = 'ActivityBar';
 const Filter$3 = 'Filter';
 
 const getIconVirtualDom = (icon, type = Div$1) => {
@@ -16505,8 +16554,8 @@ const mergeClassNames = (...classNames) => {
 const getActivityBarVirtualDom = visibleItems => {
   return [{
     type: Div$1,
-    id: ActivityBar$1,
-    className: mergeClassNames(Viewlet, ActivityBar$3),
+    id: ActivityBar$2,
+    className: mergeClassNames(Viewlet, ActivityBar$4),
     role: ToolBar,
     ariaRoleDescription: activityBar(),
     ariaOrientation: Vertical$2,
@@ -16591,6 +16640,8 @@ const resize$n = (state, dimensions) => {
   };
 };
 
+const ActivityBar$1 = 'ActivityBar';
+
 const Events$6 = {
   'SourceControl.changeBadgeCount': updateSourceControlCount,
   'Layout.hideSideBar': handleSideBarHidden,
@@ -16599,6 +16650,7 @@ const Events$6 = {
 
 const ViewletActivityBar_ipc = {
   __proto__: null,
+  ActivityBar: ActivityBar$1,
   Commands: Commands$J,
   Css: Css$K,
   Events: Events$6,
@@ -21929,7 +21981,7 @@ const getSavedRoot$1 = (savedState, workspacePath) => {
   return workspacePath;
 };
 const loadContent$x = async (state, savedState) => {
-  const root = getSavedRoot$1(savedState, state$B.workspacePath);
+  const root = getSavedRoot$1(savedState, state$A.workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -21975,7 +22027,7 @@ const handleLanguagesChanged = state => {
   return updateIcons$1(state);
 };
 const handleWorkspaceChange$1 = async state => {
-  const newRoot = state$B.workspacePath;
+  const newRoot = state$A.workspacePath;
   const state1 = {
     ...state,
     root: newRoot
@@ -23543,7 +23595,7 @@ const restoreState = savedState => {
       deltaY: 0
     };
   }
-  const root = getSavedRoot(savedState, state$B.workspacePath);
+  const root = getSavedRoot(savedState, state$A.workspacePath);
   let minLineY = 0;
   if (savedState && typeof savedState.minLineY === 'number') {
     minLineY = savedState.minLineY;
@@ -25963,7 +26015,7 @@ const loadContent$s = async state => {
   return loadContent$t(state, getImplementations);
 };
 const contentLoaded$6 = state => {
-  set$c('Locations', {
+  set$b('Locations', {
     factory: ViewletLocations,
     state
   });
@@ -27264,7 +27316,7 @@ const Main$1 = {
   kHeight: MainHeight
 };
 const ActivityBar = {
-  moduleId: ActivityBar$5,
+  moduleId: ActivityBar$6,
   kVisible: ActivityBarVisible,
   kTop: ActivityBarTop,
   kLeft: ActivityBarLeft,
@@ -27711,9 +27763,9 @@ const toggleMain = state => {
 };
 const getReferenceNodes = sideBarLocation => {
   if (sideBarLocation === Left$2) {
-    return [TitleBar$2, ActivityBar$5, 'SashSideBar', SideBar$2, Main$3, 'SashPanel', Panel$2, StatusBar$1];
+    return [TitleBar$2, ActivityBar$6, 'SashSideBar', SideBar$2, Main$3, 'SashPanel', Panel$2, StatusBar$1];
   }
-  return [TitleBar$2, Main$3, SideBar$2, 'SashSideBar', ActivityBar$5, 'SashPanel', Panel$2, StatusBar$1];
+  return [TitleBar$2, Main$3, SideBar$2, 'SashSideBar', ActivityBar$6, 'SashPanel', Panel$2, StatusBar$1];
 };
 const loadIfVisible = async (state, module) => {
   try {
@@ -32866,7 +32918,7 @@ const loadContent$h = async state => {
 
 // TODO side effect is not good here, find a way to call ViewletLocations
 const contentLoaded$2 = state => {
-  set$c('Locations', {
+  set$b('Locations', {
     factory: ViewletLocations,
     state,
     renderedState: state
@@ -34798,7 +34850,7 @@ const handleUpdate = async (state, update) => {
         loaded: true
       };
     }
-    const root = state$B.workspacePath;
+    const root = state$A.workspacePath;
     const results = await textSearch$5(root, value, {
       threads,
       isCaseSensitive: matchCase,
@@ -34881,7 +34933,7 @@ const create$e = (id, uri, x, y, width, height) => {
     listFocused: false,
     listFocusedIndex: -1,
     inputSource: User,
-    workspacePath: state$B.workspacePath,
+    workspacePath: state$A.workspacePath,
     includeValue: '',
     excludeValue: '',
     detailsExpanded: false,
@@ -35754,7 +35806,7 @@ const openViewlet = async (state, moduleId, focus = false, args) => {
     const currentViewletUid = currentViewletState.uid;
     number$1(currentViewletUid);
     commands.unshift(...disposeFunctional(currentViewletUid));
-    const activityBar = getInstance(ActivityBar$5);
+    const activityBar = getInstance(ActivityBar$6);
     if (activityBar) {
       const oldState = activityBar.state;
       const newState = activityBar.factory.handleSideBarViewletChange(oldState, moduleId);
@@ -36733,7 +36785,7 @@ const loadContent$b = async state => {
     height,
     minimumSliderSize
   } = state;
-  const root = state$B.workspacePath;
+  const root = state$A.workspacePath;
   const scheme = getProtocol(root);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
@@ -37663,7 +37715,7 @@ const loadContent$8 = async state => {
   } = await getTerminalSpawnOptions();
   const canvasTextId = create$1a();
   const canvasCursorId = create$1a();
-  await invoke$5('Terminal.create', canvasTextId, canvasCursorId, uid, state$B.workspacePath, command, args);
+  await invoke$5('Terminal.create', canvasTextId, canvasCursorId, uid, state$A.workspacePath, command, args);
   const terminal = {
     handleBlur() {
       return invoke$5('Terminal.handleBlur', uid);
@@ -39895,7 +39947,7 @@ const ViewletActivityBarSelectCurrent = {
 };
 
 const handleFocus$3 = state => {
-  setFocus(ActivityBar$2);
+  setFocus(ActivityBar$3);
   return state;
 };
 
@@ -39905,7 +39957,7 @@ const ViewletActivityBarHandleFocus = {
 };
 
 const handleContextMenu$8 = async (state, button, x, y) => {
-  await show$a(x, y, ActivityBar$4);
+  await show$a(x, y, ActivityBar$5);
   return state;
 };
 
@@ -42833,7 +42885,7 @@ const getNoResults = () => {
   };
 };
 const getPicks = async searchValue => {
-  const workspace = state$B.workspacePath;
+  const workspace = state$A.workspacePath;
   if (!workspace) {
     return [];
   }
@@ -42842,7 +42894,7 @@ const getPicks = async searchValue => {
   return files;
 };
 const selectPick = async pick => {
-  const workspace = state$B.workspacePath;
+  const workspace = state$A.workspacePath;
   const absolutePath = `${workspace}/${pick}`;
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */absolutePath);
   return {
@@ -45098,7 +45150,7 @@ const SearchFileMemfs = {
 };
 
 const removeLeadingSlash = path => {
-  const workspacePath = state$B.workspacePath;
+  const workspacePath = state$A.workspacePath;
   return path.slice(workspacePath.length - Fetch.length - 2);
 };
 const searchFile$2 = async (path, value) => {