@lvce-editor/shared-process 0.85.2 → 0.86.0

package/src/parts/ExtensionManagement/ExtensionManagementIconTheme.js

@@ -1,29 +1,29 @@
-import * as ReadJson from '../JsonFile/JsonFile.js';
-import * as Path from '../Path/Path.js';
-import { VError } from '../VError/VError.js';
-import * as ExtensionManagement from './ExtensionManagement.js';
+import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
+import { VError } from '../VError/VError.js'
+import * as ExtensionManagement from './ExtensionManagement.js'
+
 export const getIconTheme = async (iconThemeId) => {
-    const extensions = await ExtensionManagement.getExtensions();
-    for (const extension of extensions) {
-        if (!extension.iconThemes) {
-            continue;
-        }
-        for (const iconTheme of extension.iconThemes) {
-            if (iconTheme.id !== iconThemeId) {
-                continue;
-            }
-            const absolutePath = Path.join(extension.path, iconTheme.path);
-            try {
-                const json = await ReadJson.readJson(absolutePath);
-                return {
-                    extensionPath: extension.path,
-                    json,
-                };
-            }
-            catch (error) {
-                throw new VError(error, `Failed to load icon theme "${iconThemeId}"`);
-            }
+  const extensions = await ExtensionManagement.getExtensions()
+  for (const extension of extensions) {
+    if (!extension.iconThemes) {
+      continue
+    }
+    for (const iconTheme of extension.iconThemes) {
+      if (iconTheme.id !== iconThemeId) {
+        continue
+      }
+      const absolutePath = Path.join(extension.path, iconTheme.path)
+      try {
+        const json = await ReadJson.readJson(absolutePath)
+        return {
+          extensionPath: extension.path,
+          json,
         }
+      } catch (error) {
+        throw new VError(error, `Failed to load icon theme "${iconThemeId}"`)
+      }
     }
-    throw new VError(`Icon theme "${iconThemeId}" not found in extensions folder`);
-};
+  }
+  throw new VError(`Icon theme "${iconThemeId}" not found in extensions folder`)
+}

package/src/parts/ExtensionManagement/ExtensionManagementLanguages.js

@@ -1,69 +1,74 @@
 // TODO rename file to languageConfiguration.js
-import { join } from 'node:path';
-import * as GetRemoteUrl from '../GetRemoteUrl/GetRemoteUrl.js';
-import * as GetWebViewsFromEXtensions from '../GetWebViewsFromExtensions/GetWebViewsFromExtensions.js';
-import * as JsonFile from '../JsonFile/JsonFile.js';
-import { VError } from '../VError/VError.js';
-import * as ExtensionManagement from './ExtensionManagement.js';
+import { join } from 'node:path'
+import * as GetRemoteUrl from '../GetRemoteUrl/GetRemoteUrl.js'
+import * as GetWebViewsFromEXtensions from '../GetWebViewsFromExtensions/GetWebViewsFromExtensions.js'
+import * as JsonFile from '../JsonFile/JsonFile.js'
+import { VError } from '../VError/VError.js'
+import * as ExtensionManagement from './ExtensionManagement.js'
+
 const getLanguagesFromExtension = (extension) => {
-    // TODO what if extension is null? should not crash process, handle error gracefully
-    if (!extension.languages) {
-        return [];
-    }
-    const extensionPath = extension.path;
-    const getLanguageFromExtension = (language) => {
-        if (language.tokenize) {
-            if (typeof language.tokenize !== 'string') {
-                console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`);
-                return {
-                    ...language,
-                    extensionPath,
-                    tokenize: '',
-                };
-            }
-            return {
-                ...language,
-                extensionPath,
-                tokenize: GetRemoteUrl.getRemoteUrl(join(extensionPath, language.tokenize)),
-            };
+  // TODO what if extension is null? should not crash process, handle error gracefully
+  if (!extension.languages) {
+    return []
+  }
+  const extensionPath = extension.path
+  const getLanguageFromExtension = (language) => {
+    if (language.tokenize) {
+      if (typeof language.tokenize !== 'string') {
+        console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`)
+        return {
+          ...language,
+          extensionPath,
+          tokenize: '',
         }
-        return language;
-    };
-    return extension.languages.map(getLanguageFromExtension);
-};
+      }
+      return {
+        ...language,
+        extensionPath,
+        tokenize: GetRemoteUrl.getRemoteUrl(join(extensionPath, language.tokenize)),
+      }
+    }
+    return language
+  }
+  return extension.languages.map(getLanguageFromExtension)
+}
+
 const getLanguagesFromExtensions = (extensions) => {
-    return extensions.flatMap(getLanguagesFromExtension);
-};
+  return extensions.flatMap(getLanguagesFromExtension)
+}
+
 export const getLanguages = async () => {
-    throw new Error('deprecated');
-};
+  throw new Error('deprecated')
+}
+
 export const getWebViews = async () => {
-    const extensions = await ExtensionManagement.getExtensions();
-    const webViews = GetWebViewsFromEXtensions.getWebViewsFromExtensions(extensions);
-    return webViews;
-};
+  const extensions = await ExtensionManagement.getExtensions()
+  const webViews = GetWebViewsFromEXtensions.getWebViewsFromExtensions(extensions)
+  return webViews
+}
+
 const getLanguageConfigurationPathFromExtensions = (extensions, languageId) => {
-    for (const extension of extensions) {
-        if (extension.languages && extension.languages) {
-            for (const language of extension.languages) {
-                if (language.id === languageId && language.configuration) {
-                    return join(extension.path, language.configuration);
-                }
-            }
+  for (const extension of extensions) {
+    if (extension.languages && extension.languages) {
+      for (const language of extension.languages) {
+        if (language.id === languageId && language.configuration) {
+          return join(extension.path, language.configuration)
         }
+      }
     }
-    return '';
-};
+  }
+  return ''
+}
+
 export const getLanguageConfiguration = async (languageId) => {
-    try {
-        const extensions = await ExtensionManagement.getExtensions();
-        const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(extensions, languageId);
-        if (!languageConfigurationPath) {
-            return undefined;
-        }
-        return await JsonFile.readJson(languageConfigurationPath);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to load language configuration for ${languageId}`);
+  try {
+    const extensions = await ExtensionManagement.getExtensions()
+    const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(extensions, languageId)
+    if (!languageConfigurationPath) {
+      return undefined
     }
-};
+    return await JsonFile.readJson(languageConfigurationPath)
+  } catch (error) {
+    throw new VError(error, `Failed to load language configuration for ${languageId}`)
+  }
+}

package/src/parts/ExtensionManifest/ExtensionManifest.js

@@ -1,63 +1,61 @@
-import isObject from 'is-object';
-import { pathToFileURL } from 'node:url';
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
-import * as InferExtensionId from '../InferExtensionId/InferExtensionId.js';
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
-import * as ReadJson from '../JsonFile/JsonFile.js';
-import * as Path from '../Path/Path.js';
-import { VError } from '../VError/VError.js';
+import isObject from 'is-object'
+import { pathToFileURL } from 'node:url'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
+import * as InferExtensionId from '../InferExtensionId/InferExtensionId.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
+import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as Path from '../Path/Path.js'
+import { VError } from '../VError/VError.js'
+
 // TODO json parsing and error handling should happen in renderer process
 export const get = async (path) => {
-    const absolutePath = Path.join(path, 'extension.json');
-    try {
-        const json = await ReadJson.readJson(absolutePath);
+  const absolutePath = Path.join(path, 'extension.json')
+  try {
+    const json = await ReadJson.readJson(absolutePath)
+    if (!isObject(json)) {
+      // TODO should include stack of extension json file here
+      throw new VError('Invalid manifest file: Not an JSON object.')
+    }
+    const uri = pathToFileURL(path).toString()
+    return {
+      ...json,
+      path,
+      uri,
+      status: ExtensionManifestStatus.Resolved,
+    }
+  } catch (error) {
+    const id = InferExtensionId.inferExtensionId(path)
+    const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`)
+    if (IsEnoentError.isEnoentError(error)) {
+      try {
+        const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json')
+        const json = await ReadJson.readJson(monoRepoPath)
         if (!isObject(json)) {
-            // TODO should include stack of extension json file here
-            throw new VError('Invalid manifest file: Not an JSON object.');
+          // TODO should include stack of extension json file here
+          throw new VError('Invalid manifest file: Not an JSON object.')
         }
-        const uri = pathToFileURL(path).toString();
+        const extensionPath = Path.join(path, 'packages', 'extension')
+        const uri = pathToFileURL(extensionPath).toString()
         return {
-            ...json,
-            path,
-            uri,
-            status: ExtensionManifestStatus.Resolved,
-        };
-    }
-    catch (error) {
-        const id = InferExtensionId.inferExtensionId(path);
-        const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`);
-        if (IsEnoentError.isEnoentError(error)) {
-            try {
-                const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json');
-                const json = await ReadJson.readJson(monoRepoPath);
-                if (!isObject(json)) {
-                    // TODO should include stack of extension json file here
-                    throw new VError('Invalid manifest file: Not an JSON object.');
-                }
-                const extensionPath = Path.join(path, 'packages', 'extension');
-                const uri = pathToFileURL(extensionPath).toString();
-                return {
-                    ...json,
-                    path: extensionPath,
-                    uri,
-                    status: ExtensionManifestStatus.Resolved,
-                };
-            }
-            catch { }
-            // @ts-ignore
-            enhancedError.path = absolutePath;
-            // @ts-ignore
-            enhancedError.code = ErrorCodes.E_MANIFEST_NOT_FOUND;
+          ...json,
+          path: extensionPath,
+          uri,
+          status: ExtensionManifestStatus.Resolved,
         }
-        else {
-            // @ts-ignore
-            enhancedError.code = error.code;
-        }
-        return {
-            path,
-            status: ExtensionManifestStatus.Rejected,
-            reason: enhancedError,
-        };
+      } catch {}
+      // @ts-ignore
+      enhancedError.path = absolutePath
+      // @ts-ignore
+      enhancedError.code = ErrorCodes.E_MANIFEST_NOT_FOUND
+    } else {
+      // @ts-ignore
+      enhancedError.code = error.code
+    }
+    return {
+      path,
+      status: ExtensionManifestStatus.Rejected,
+      reason: enhancedError,
     }
-};
+  }
+}

package/src/parts/ExtensionManifestInputType/ExtensionManifestInputType.js

@@ -1,4 +1,7 @@
-export const Folder = 1;
-export const OnlyExtension = 2;
-export const LinkedExtensionsFolder = 3;
-export const LinkedExtension = 4;
+export const Folder = 1
+
+export const OnlyExtension = 2
+
+export const LinkedExtensionsFolder = 3
+
+export const LinkedExtension = 4

package/src/parts/ExtensionManifestStatus/ExtensionManifestStatus.js

@@ -1,2 +1,3 @@
-export const Resolved = 'resolved';
-export const Rejected = 'rejected';
+export const Resolved = 'resolved'
+
+export const Rejected = 'rejected'

package/src/parts/ExtensionManifests/ExtensionManifests.js

@@ -1,45 +1,50 @@
-import * as DeduplicateExtensions from '../DeduplicateExtensions/DeduplicateExtensions.js';
-import { getDisabledExtensionIds } from '../ExtensionManagement/ExtensionManagement.js';
-import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js';
-import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js';
-import * as ExtensionManifestsGetFromLinkedExtension from './ExtensionManifestsFromLinkedExtension.js';
-import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js';
-import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js';
+import * as DeduplicateExtensions from '../DeduplicateExtensions/DeduplicateExtensions.js'
+import { getDisabledExtensionIds } from '../ExtensionManagement/ExtensionManagement.js'
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
+import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js'
+import * as ExtensionManifestsGetFromLinkedExtension from './ExtensionManifestsFromLinkedExtension.js'
+import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js'
+import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js'
+
 const getModule = (type) => {
-    switch (type) {
-        case ExtensionManifestInputType.Folder:
-            return ExtensionManifestsGetFromFolder;
-        case ExtensionManifestInputType.OnlyExtension:
-            return ExtensionManifestsGetFromOnlyExtension;
-        case ExtensionManifestInputType.LinkedExtension:
-            return ExtensionManifestsGetFromLinkedExtension;
-        case ExtensionManifestInputType.LinkedExtensionsFolder:
-            return ExtensionManifestsGetFromLinkedExtensionsFolder;
-        default:
-            throw new Error('unsupported input type');
-    }
-};
+  switch (type) {
+    case ExtensionManifestInputType.Folder:
+      return ExtensionManifestsGetFromFolder
+    case ExtensionManifestInputType.OnlyExtension:
+      return ExtensionManifestsGetFromOnlyExtension
+    case ExtensionManifestInputType.LinkedExtension:
+      return ExtensionManifestsGetFromLinkedExtension
+    case ExtensionManifestInputType.LinkedExtensionsFolder:
+      return ExtensionManifestsGetFromLinkedExtensionsFolder
+    default:
+      throw new Error('unsupported input type')
+  }
+}
+
 const get = (input) => {
-    const module = getModule(input.type);
-    return module.getExtensionManifests(input.path);
-};
+  const module = getModule(input.type)
+  return module.getExtensionManifests(input.path)
+}
+
 const isBuiltin = (extension) => {
-    return extension && extension.id && extension.id.startsWith('builtin.');
-};
+  return extension && extension.id && extension.id.startsWith('builtin.')
+}
+
 const addExtensionDisabledStatus = (uniqueExtensions, disabledExtensionIds) => {
-    return uniqueExtensions.map((extension) => {
-        return {
-            ...extension,
-            disabled: disabledExtensionIds.includes(extension.id),
-            isBuiltin: isBuiltin(extension),
-        };
-    });
-};
-export const getAll = async (inputs, builtinExtensionsPath) => {
-    const manifests = await Promise.all(inputs.map(get));
-    const disabledIds = await getDisabledExtensionIds();
-    const flatManifests = manifests.flat(1);
-    const uniqueExtensions = DeduplicateExtensions.deduplicateExtensions(flatManifests, builtinExtensionsPath);
-    const filteredExtensions = addExtensionDisabledStatus(uniqueExtensions, disabledIds);
-    return filteredExtensions;
-};
+  return uniqueExtensions.map((extension) => {
+    return {
+      ...extension,
+      disabled: disabledExtensionIds.includes(extension.id),
+      isBuiltin: isBuiltin(extension),
+    }
+  })
+}
+
+export const getAll = async (inputs, builtinExtensionsPath      = undefined) => {
+  const manifests = await Promise.all(inputs.map(get))
+  const disabledIds = await getDisabledExtensionIds()
+  const flatManifests = manifests.flat(1)
+  const uniqueExtensions = DeduplicateExtensions.deduplicateExtensions(flatManifests, builtinExtensionsPath)
+  const filteredExtensions = addExtensionDisabledStatus(uniqueExtensions, disabledIds)
+  return filteredExtensions
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -1,24 +1,24 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
-import * as DirentType from '../DirentType/DirentType.js';
-import * as FileSystem from '../FileSystem/FileSystem.js';
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
-import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js';
-import { VError } from '../VError/VError.js';
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as DirentType from '../DirentType/DirentType.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
+import { VError } from '../VError/VError.js'
+
 export const getExtensionManifests = async (path) => {
-    try {
-        if (!path) {
-            return [];
-        }
-        const dirents = await FileSystem.readDirWithFileTypes(path);
-        const folderNames = dirents.filter((dirent) => dirent.type === DirentType.Directory).map((dirent) => dirent.name);
-        const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, folderNames);
-        const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get));
-        return manifests;
+  try {
+    if (!path) {
+      return []
     }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            return [];
-        }
-        throw new VError(error, 'Failed to get extension manifests');
+    const dirents = await FileSystem.readDirWithFileTypes(path)
+    const folderNames = dirents.filter((dirent) => dirent.type === DirentType.Directory).map((dirent) => dirent.name)
+    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, folderNames)
+    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
+    return manifests
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      return []
     }
-};
+    throw new VError(error, 'Failed to get extension manifests')
+  }
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtension.js

@@ -1,17 +1,18 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
+
 export const getExtensionManifests = async (path) => {
-    if (!path) {
-        return [];
-    }
-    const manifest = await ExtensionManifest.get(path);
-    if (manifest.status === ExtensionManifestStatus.Rejected) {
-        return [manifest];
-    }
-    return [
-        {
-            ...manifest,
-            symlink: path,
-        },
-    ];
-};
+  if (!path) {
+    return []
+  }
+  const manifest = await ExtensionManifest.get(path)
+  if (manifest.status === ExtensionManifestStatus.Rejected) {
+    return [manifest]
+  }
+  return [
+    {
+      ...manifest,
+      symlink: path,
+    },
+  ]
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtensionsFolder.js

@@ -1,40 +1,41 @@
-import { readlink } from 'node:fs/promises';
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
-import * as DirentType from '../DirentType/DirentType.js';
-import * as FileSystem from '../FileSystem/FileSystem.js';
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
-import * as MergeWithSymlinks from '../MergeWithSymlinks/MergeWithSymlinks.js';
-import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js';
-import { VError } from '../VError/VError.js';
+import { readlink } from 'node:fs/promises'
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as DirentType from '../DirentType/DirentType.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
+import * as MergeWithSymlinks from '../MergeWithSymlinks/MergeWithSymlinks.js'
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
+import { VError } from '../VError/VError.js'
+
 const readSymlink = async (absolutePath) => {
-    try {
-        const info = await readlink(absolutePath);
-        return info;
-    }
-    catch {
-        return '';
-    }
-};
+  try {
+    const info = await readlink(absolutePath)
+    return info
+  } catch {
+    return ''
+  }
+}
+
 const readSymlinks = (absolutePaths) => {
-    return Promise.all(absolutePaths.map(readSymlink));
-};
+  return Promise.all(absolutePaths.map(readSymlink))
+}
+
 export const getExtensionManifests = async (path) => {
-    try {
-        if (!path) {
-            return [];
-        }
-        const dirents = await FileSystem.readDirWithFileTypes(path);
-        const folderNames = dirents.filter((dirent) => dirent.type === DirentType.Directory).map((dirent) => dirent.name);
-        const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, folderNames);
-        const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get));
-        const symlinks = await readSymlinks(absolutePaths);
-        const merged = MergeWithSymlinks.mergeWithSymLinks(manifests, symlinks);
-        return merged;
+  try {
+    if (!path) {
+      return []
     }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            return [];
-        }
-        throw new VError(error, 'Failed to get extension manifests');
+    const dirents = await FileSystem.readDirWithFileTypes(path)
+    const folderNames = dirents.filter((dirent) => dirent.type === DirentType.Directory).map((dirent) => dirent.name)
+    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, folderNames)
+    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
+    const symlinks = await readSymlinks(absolutePaths)
+    const merged = MergeWithSymlinks.mergeWithSymLinks(manifests, symlinks)
+    return merged
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      return []
     }
-};
+    throw new VError(error, 'Failed to get extension manifests')
+  }
+}

package/src/parts/ExtensionManifests/ExtensionManifestsFromOnlyExtension.js

@@ -1,8 +1,9 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+
 export const getExtensionManifests = async (path) => {
-    if (path) {
-        const manifest = await ExtensionManifest.get(path);
-        return [manifest];
-    }
-    return [];
-};
+  if (path) {
+    const manifest = await ExtensionManifest.get(path)
+    return [manifest]
+  }
+  return []
+}

package/src/parts/ExtensionUninstall/ExtensionUninstall.js

@@ -1,16 +1,16 @@
-import { rm } from 'node:fs/promises';
-import * as Path from '../Path/Path.js';
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
-import { VError } from '../VError/VError.js';
+import { rm } from 'node:fs/promises'
+import * as Path from '../Path/Path.js'
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
+import { VError } from '../VError/VError.js'
+
 export const uninstall = async (id) => {
-    try {
-        const extensionsPath = PlatformPaths.getExtensionsPath();
-        await rm(Path.join(extensionsPath, id), { recursive: true });
-    }
-    catch (error) {
-        // if (error.code === 'ENOENT') {
-        //   return
-        // }
-        throw new VError(error, `Failed to uninstall extension "${id}"`);
-    }
-};
+  try {
+    const extensionsPath = PlatformPaths.getExtensionsPath()
+    await rm(Path.join(extensionsPath, id), { recursive: true })
+  } catch (error) {
+    // if (error.code === 'ENOENT') {
+    //   return
+    // }
+    throw new VError(error, `Failed to uninstall extension "${id}"`)
+  }
+}