@lvce-editor/extension-host-worker 6.3.0 → 6.5.0

package/dist/extensionHostWorkerMain.js

@@ -113,12 +113,12 @@ const fn = value => {
 };
 
 const state$d = {
-  /** @type{any[]} */
-  onWillChangeEditorListeners: [],
   /** @type{any[]} */
   onDidChangeTextDocumentListeners: [],
   /** @type{any[]} */
   onDidSaveTextDocumentListeners: [],
+  /** @type{any[]} */
+  onWillChangeEditorListeners: [],
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
@@ -284,10 +284,10 @@ const runListenersSafe = (listeners, ...args) => {
 };
 const syncFull = (uri, textDocumentId, languageId, text) => {
   const textDocument = {
-    uri,
     documentId: textDocumentId,
     languageId,
-    text
+    text,
+    uri
   };
   setDocument(textDocumentId, textDocument);
   runListenersSafe(getDidOpenListeners(), textDocument);
@@ -301,9 +301,9 @@ const getSyntheticChanges = (textDocument, changes) => {
   const endOffset = getOffset$1(textDocument, change.end);
   const inserted = change.inserted.join('\n');
   const syntheticChanges = [{
-    startOffset,
     endOffset,
-    inserted
+    inserted,
+    startOffset
   }];
   return syntheticChanges;
 };
@@ -353,12 +353,12 @@ class NoProviderFoundError extends Error {
 
 const getType = value => {
   switch (typeof value) {
-    case 'number':
-      return 'number';
+    case 'boolean':
+      return 'boolean';
     case 'function':
       return 'function';
-    case 'string':
-      return 'string';
+    case 'number':
+      return 'number';
     case 'object':
       if (value === null) {
         return 'null';
@@ -367,8 +367,8 @@ const getType = value => {
         return 'array';
       }
       return 'object';
-    case 'boolean':
-      return 'boolean';
+    case 'string':
+      return 'string';
     case 'undefined':
       return 'undefined';
     default:
@@ -415,10 +415,10 @@ const getPreviewString = item => {
 const getPreview = item => {
   const type = getType(item);
   switch (type) {
-    case 'object':
-      return getPreviewObject();
     case 'array':
       return getPreviewArray(item);
+    case 'object':
+      return getPreviewObject();
     case 'string':
       return getPreviewString(item);
     default:
@@ -439,10 +439,10 @@ const validate = (item, schema) => {
     return `item must be of type ${expectedType} but is ${preview}`;
   }
   switch (actualType) {
-    case 'object':
-      return validateResultObject(item, schema);
     case 'array':
       return validateResultArray(item, schema);
+    case 'object':
+      return validateResultObject(item, schema);
   }
   // TODO use json schema to validate result
   return undefined;
@@ -538,11 +538,11 @@ const improveValidationError = (name, validationError) => {
 };
 const registerMethod = ({
   context,
-  providers,
-  returnUndefinedWhenNoProviderFound,
-  name,
   methodName,
-  resultShape
+  name,
+  providers,
+  resultShape,
+  returnUndefinedWhenNoProviderFound
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
@@ -580,11 +580,11 @@ const registerMethod = ({
   };
 };
 const create$b = ({
+  additionalMethodNames = [],
+  executeKey = '',
   name,
   resultShape,
-  executeKey = '',
-  returnUndefinedWhenNoProviderFound = false,
-  additionalMethodNames = []
+  returnUndefinedWhenNoProviderFound = false
 }) => {
   const multipleResults = resultShape.type === 'array';
   const methodName = executeKey || (multipleResults ? `provide${name}s` : `provide${name}`);
@@ -593,22 +593,22 @@ const create$b = ({
     [`register${name}Provider`](provider) {
       providers[provider.languageId] = provider;
     },
+    getProvider(languageId) {
+      return providers[languageId];
+    },
     reset() {
       for (const key in providers) {
         delete providers[key];
       }
-    },
-    getProvider(languageId) {
-      return providers[languageId];
     }
   };
   registerMethod({
     context,
-    providers,
-    name,
     methodName,
-    returnUndefinedWhenNoProviderFound,
-    resultShape
+    name,
+    providers,
+    resultShape,
+    returnUndefinedWhenNoProviderFound
   });
   for (const method of additionalMethodNames) {
     // @ts-ignore
@@ -631,8 +631,8 @@ const Object$1 = 'object';
 const String$1 = 'string';
 
 const {
-  registerBraceCompletionProvider,
-  executeBraceCompletionProvider} = create$b({
+  executeBraceCompletionProvider,
+  registerBraceCompletionProvider} = create$b({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean$1
@@ -640,27 +640,27 @@ const {
 });
 
 const {
-  registerClosingTagProvider,
-  executeClosingTagProvider
+  executeClosingTagProvider,
+  registerClosingTagProvider
 } = create$b({
   name: 'ClosingTag',
-  returnUndefinedWhenNoProviderFound: true,
   resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  }
+    allowUndefined: true,
+    type: Object$1
+  },
+  returnUndefinedWhenNoProviderFound: true
 });
 
 const {
-  registerCodeActionProvider,
-  executeCodeActionProvider
+  executeCodeActionProvider,
+  registerCodeActionProvider
 } = create$b({
   name: 'CodeAction',
   resultShape: {
-    type: Array$1,
     items: {
       type: Object$1
-    }
+    },
+    type: Array$1
   }
 });
 const isOrganizeImports = action => {
@@ -734,8 +734,8 @@ const executeCommand = async (id, ...args) => {
 };
 
 const {
-  registerCommentProvider,
-  executeCommentProvider
+  executeCommentProvider,
+  registerCommentProvider
 } = create$b({
   name: 'Comment',
   resultShape() {
@@ -744,27 +744,27 @@ const {
 });
 
 const {
-  registerCompletionProvider,
   executeCompletionProvider,
-  executeresolveCompletionItemProvider
+  executeresolveCompletionItemProvider,
+  registerCompletionProvider
 } = create$b({
-  name: 'Completion',
-  resultShape: {
-    type: Array$1,
-    items: {
-      type: Object$1
-    }
-  },
   additionalMethodNames: [
   // @ts-ignore
   {
-    name: 'resolveCompletionItem',
     methodName: 'resolveCompletionItem',
+    name: 'resolveCompletionItem',
     resultShape: {
-      type: Object$1,
-      allowUndefined: true
+      allowUndefined: true,
+      type: Object$1
     }
-  }]
+  }],
+  name: 'Completion',
+  resultShape: {
+    items: {
+      type: Object$1
+    },
+    type: Array$1
+  }
 });
 
 const state$b = {
@@ -1953,10 +1953,10 @@ const start = async (protocol, path) => {
   try {
     const provider = getDebugProvider(protocol);
     const emitter = {
+      handleChange,
       handlePaused,
       handleResumed,
-      handleScriptParsed,
-      handleChange
+      handleScriptParsed
     };
     await provider.start(emitter, path);
   } catch (error) {
@@ -2098,36 +2098,36 @@ const setPauseOnExceptions = async (protocol, value) => {
 };
 
 const {
-  registerDefinitionProvider,
-  executeDefinitionProvider} = create$b({
+  executeDefinitionProvider,
+  registerDefinitionProvider} = create$b({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
-    type: Object$1,
     properties: {
-      uri: {
-        type: String$1
+      endOffset: {
+        type: Number
       },
       startOffset: {
         type: Number
       },
-      endOffset: {
-        type: Number
+      uri: {
+        type: String$1
       }
-    }
+    },
+    type: Object$1
   }
 });
 
 const {
-  registerDiagnosticProvider,
-  executeDiagnosticProvider
+  executeDiagnosticProvider,
+  registerDiagnosticProvider
 } = create$b({
   name: 'Diagnostic',
   resultShape: {
-    type: Array$1,
     items: {
       type: Object$1
-    }
+    },
+    type: Array$1
   }
 });
 
@@ -2270,27 +2270,27 @@ const getPathSeparator = protocol => {
 };
 
 const {
-  registerFormattingProvider,
-  executeFormattingProvider} = create$b({
-  name: 'Formatting',
+  executeFormattingProvider,
+  registerFormattingProvider} = create$b({
   executeKey: 'format',
+  name: 'Formatting',
   resultShape: {
     allowUndefined: true,
-    type: Array$1,
     items: {
-      type: Object$1,
       properties: {
-        startOffset: {
-          type: Number
-        },
         endOffset: {
           type: Number
         },
         inserted: {
           type: String$1
+        },
+        startOffset: {
+          type: Number
         }
-      }
-    }
+      },
+      type: Object$1
+    },
+    type: Array$1
   }
 });
 
@@ -2326,31 +2326,31 @@ const getPosition = (textDocument, offset) => {
   }
   const columnIndex = offset - index;
   return {
-    rowIndex,
-    columnIndex
+    columnIndex,
+    rowIndex
   };
 };
 
 const {
-  registerHoverProvider,
-  executeHoverProvider} = create$b({
+  executeHoverProvider,
+  registerHoverProvider} = create$b({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
-    type: Object$1,
-    properties: {}
+    properties: {},
+    type: Object$1
   }
 });
 
 const {
-  registerImplementationProvider,
-  executeImplementationProvider} = create$b({
+  executeImplementationProvider,
+  registerImplementationProvider} = create$b({
   name: 'Implementation',
   resultShape: {
-    type: Array$1,
     items: {
       type: Object$1
-    }
+    },
+    type: Array$1
   }
 });
 
@@ -2372,22 +2372,22 @@ const getPortTuple = () => {
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 
 const sendPort = async ({
-  url,
   name,
-  port
+  port,
+  url
 }) => {
   await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url,
     name,
+    port,
     raw: true,
-    port
+    url
   });
 };
 const create$6 = async ({
-  url,
+  commandMap,
   name,
-  commandMap
+  url
 }) => {
   string(url);
   string(name);
@@ -2396,16 +2396,16 @@ const create$6 = async ({
     port2
   } = getPortTuple();
   const rpcPromise = MessagePortRpcParent.create({
-    messagePort: port2,
+    commandMap,
     isMessagePortOpen: true,
-    commandMap
+    messagePort: port2
   });
   // TODO rpc module should start port
   port2.start();
   await sendPort({
-    url,
     name,
-    port: port1
+    port: port1,
+    url
   });
   const rpc = await rpcPromise;
   return rpc;
@@ -2435,9 +2435,9 @@ const create$5 = async ({
   // TODO rpc module should start port
   port.start();
   const rpc = await MessagePortRpcParent.create({
-    messagePort: port,
+    commandMap: {},
     isMessagePortOpen: true,
-    commandMap: {}
+    messagePort: port
   });
   return rpc;
 };
@@ -2463,8 +2463,8 @@ const create$4 = async ({
   const wsUrl = getWebSocketUrl(type, location.host);
   const webSocket = new WebSocket(wsUrl);
   const rpc = await WebSocketRpcParent.create({
-    webSocket,
-    commandMap: {}
+    commandMap: {},
+    webSocket
   });
   return rpc;
 };
@@ -2509,8 +2509,8 @@ const getModule$1 = platform => {
   }
 };
 const create$3 = async ({
-  type,
-  raw
+  raw,
+  type
 }) => {
   const module = getModule$1(platform);
   const rpc = await module.create({
@@ -2526,12 +2526,12 @@ const IpcParentWithNode = {
 
 const getModule = method => {
   switch (method) {
-    case WebSocket$1:
-      return IpcParentWithWebSocket;
     case ElectronMessagePort:
       return IpcParentWithNode;
     case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
       return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug;
+    case WebSocket$1:
+      return IpcParentWithWebSocket;
     default:
       throw new Error('unexpected ipc type');
   }
@@ -2555,18 +2555,18 @@ const defaultExecute = () => {
   throw new Error('not implemented');
 };
 const createNodeRpc = async ({
-  path,
   execute = defaultExecute,
-  name = ''
+  name = '',
+  path
 }) => {
   try {
     string(path);
     fn(execute);
     const rpc = await create$2({
+      commandMap: {},
       method: ElectronMessagePort,
-      type: 'extension-host-helper-process',
       name,
-      commandMap: {}
+      type: 'extension-host-helper-process'
     });
     await rpc.invoke('LoadFile.loadFile', path);
     return rpc;
@@ -2635,11 +2635,11 @@ const registerOutputChannel = provider => {
       }
       await append(uri, text + '\n');
     },
-    async replace(text) {
-      await writeFile$2(uri, text);
-    },
     getUri() {
       return uri;
+    },
+    async replace(text) {
+      await writeFile$2(uri, text);
     }
   };
 };
@@ -2674,37 +2674,36 @@ const showQuickPick = async ({
 };
 
 const {
-  registerReferenceProvider,
-  executeReferenceProvider,
   executefileReferenceProvider,
-  getProvider: getProvider$1
-} = create$b({
-  name: 'Reference',
-  resultShape: {
-    type: Array$1,
-    items: {
-      type: Object$1
-    }
-  },
+  executeReferenceProvider,
+  getProvider: getProvider$1,
+  registerReferenceProvider} = create$b({
   additionalMethodNames: [
   // @ts-ignore
   {
-    name: 'fileReference',
     methodName: 'provideFileReferences',
+    name: 'fileReference',
     resultShape: {
-      type: Array$1,
       items: {
         type: Object$1
-      }
+      },
+      type: Array$1
     }
-  }]
+  }],
+  name: 'Reference',
+  resultShape: {
+    items: {
+      type: Object$1
+    },
+    type: Array$1
+  }
 });
 const executeReferenceProvider2 = (uri, languageId, offset, position) => {
   const provider = getProvider$1(languageId);
   return provider.provideReferences2({
-    uri,
     offset,
-    position
+    position,
+    uri
   });
 };
 
@@ -2738,21 +2737,21 @@ const validateResult = renameResult => {
   return '';
 };
 const {
-  registerRenameProvider,
+  executeprepareRenameProvider,
   executeRenameProvider,
-  executeprepareRenameProvider} = create$b({
-  name: 'Rename',
-  resultShape: validateResult,
+  registerRenameProvider} = create$b({
   additionalMethodNames: [
   // @ts-ignore
   {
-    name: 'prepareRename',
     methodName: 'prepareRename',
+    name: 'prepareRename',
     resultShape: {
-      type: Object$1,
-      allowUndefined: true
+      allowUndefined: true,
+      type: Object$1
     }
-  }]
+  }],
+  name: 'Rename',
+  resultShape: validateResult
 });
 
 const getExtensionHostSubWorkerUrl = () => {
@@ -2770,11 +2769,11 @@ const set$8 = async (url, contentSecurityPolicy) => {
  * @deprecated
  */
 const createLegacyRpc = async ({
-  url,
-  name,
-  execute,
   commandMap = {},
-  contentSecurityPolicy
+  contentSecurityPolicy,
+  execute,
+  name,
+  url
 }) => {
   string(url);
   string(name);
@@ -2783,10 +2782,10 @@ const createLegacyRpc = async ({
     await set$8(url, contentSecurityPolicy);
   }
   const rpc = await create$2({
+    commandMap,
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
     name,
-    commandMap
+    url: extensionHostSubWorkerUrl
   });
   if (execute) {
     // deprecated
@@ -2823,11 +2822,11 @@ const createRpcWithId$1 = async (id, commandMap, execute) => {
     throw new Error(`rpc with id ${id} not found`);
   }
   const rpc = await create$2({
+    commandMap,
+    isMessagePortOpen: true,
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
     name: info.name,
-    commandMap,
-    isMessagePortOpen: true
+    url: extensionHostSubWorkerUrl
   });
   if (execute) {
     // @ts-ignore
@@ -2846,9 +2845,9 @@ const getOrCreateRpc = async (id, commandMap, execute) => {
   return get$7(id);
 };
 const createRpcWithId = ({
-  id,
   commandMap,
-  execute
+  execute,
+  id
 }) => {
   string(id);
   register(id, commandMap);
@@ -2862,12 +2861,12 @@ const createRpcWithId = ({
 };
 
 const createRpc = ({
-  id,
-  url,
-  name,
   commandMap,
   contentSecurityPolicy,
-  execute
+  execute,
+  id,
+  name,
+  url
 }) => {
   try {
     if (execute && !commandMap) {
@@ -2878,17 +2877,17 @@ const createRpc = ({
     if (id) {
       string(id);
       return createRpcWithId({
-        id,
+        commandMap,
         execute,
-        commandMap
+        id
       });
     }
     return createLegacyRpc({
-      url,
-      name,
-      execute,
       commandMap,
-      contentSecurityPolicy
+      contentSecurityPolicy,
+      execute,
+      name,
+      url
     });
   } catch (error) {
     throw new VError(error, `Failed to create webworker rpc`);
@@ -2896,15 +2895,15 @@ const createRpc = ({
 };
 
 const {
-  registerSelectionProvider,
-  executeSelectionProvider} = create$b({
+  executeSelectionProvider,
+  registerSelectionProvider} = create$b({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
-    type: Array$1,
     items: {
       type: 'number'
-    }
+    },
+    type: Array$1
   }
 });
 
@@ -2919,17 +2918,17 @@ const getProtocol = uri => {
 
 const createWebViewIpc = async webView => {
   const {
-    uid,
-    origin
+    origin,
+    uid
   } = webView;
   const {
     port1,
     port2
   } = getPortTuple();
   const rpcPromise = MessagePortRpcParent.create({
-    messagePort: port2,
+    commandMap: {},
     isMessagePortOpen: false,
-    commandMap: {}
+    messagePort: port2
   });
   const portType = 'test';
   await invokeAndTransfer$1('WebView.setPort', uid, port1, origin, portType);
@@ -3130,8 +3129,8 @@ const getGroupsFromProvider = async (provider, cwd) => {
     const files = await provider.getChangedFiles();
     const groups = [{
       id: 'changes',
-      label: 'Changes',
-      items: files
+      items: files,
+      label: 'Changes'
     }];
     return groups;
   }
@@ -3215,12 +3214,12 @@ const getFileDecorations = async (providerId, uris) => {
 };
 
 const {
-  registerTabCompletionProvider,
-  executeTabCompletionProvider} = create$b({
+  executeTabCompletionProvider,
+  registerTabCompletionProvider} = create$b({
   name: 'TabCompletion',
   resultShape: {
-    type: Object$1,
-    allowUndefined: true
+    allowUndefined: true,
+    type: Object$1
   }
 });
 
@@ -3254,23 +3253,23 @@ const executeTextSearchProvider = async (scheme, query) => {
 };
 
 const {
-  registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider} = create$b({
+  executeTypeDefinitionProvider,
+  registerTypeDefinitionProvider} = create$b({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
-    type: Object$1,
     properties: {
-      uri: {
-        type: String$1
+      endOffset: {
+        type: Number
       },
       startOffset: {
         type: Number
       },
-      endOffset: {
-        type: Number
+      uri: {
+        type: String$1
       }
-    }
+    },
+    type: Object$1
   }
 });
 
@@ -3289,19 +3288,19 @@ const createWebView = async (providerId, port, uri, uid, origin, webView) => {
   // TODO handle case when webview doesn't send ready message
 
   const rpc = await MessagePortRpcParent.create({
-    messagePort: port,
+    commandMap: provider.commands || {},
     isMessagePortOpen: false,
-    commandMap: provider.commands || {}
+    messagePort: port
   });
   const outer = {
-    uri,
-    provider,
-    uid,
-    origin,
-    webView,
     async invoke(method, ...params) {
       return rpc.invoke(method, ...params);
-    }
+    },
+    origin,
+    provider,
+    uid,
+    uri,
+    webView
   };
   // TODO allow creating multiple webviews per provider
   setWebView(providerId, outer);
@@ -3327,24 +3326,24 @@ const getWebViewInfo = providerId => {
     throw new Error(`Webview not found: ${providerId}`);
   }
   return {
-    uid: webView.uid,
     origin: webView.origin,
+    uid: webView.uid,
     uri: webView.uri
   };
 };
 
 const createWorker = async ({
   method,
-  url,
-  name
+  name,
+  url
 }) => {
   string(method);
   string(url);
   string(name);
   const rpc = create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url,
-    name
+    name,
+    url
   });
   return rpc;
 };
@@ -3382,110 +3381,110 @@ const TextSearchResultType = {
 };
 
 const api = {
+  // Prompt
+  confirm: confirm,
+  createNodeRpc: createNodeRpc,
+  // Rpc
+  createRpc: createRpc,
+  // Worker
+  createWorker: createWorker,
+  EditorCompletionType,
+  // Env
+  env: env,
+  // Exec`
+  exec: exec,
+  executeBraceCompletionProvider: executeBraceCompletionProvider,
+  // Comment
+
+  executeClosingTagProvider: executeClosingTagProvider,
+  executeCommand: executeCommand,
+  executeCommentProvider: executeCommentProvider,
+  executeCompletionProvider: executeCompletionProvider,
+  executeDefinitionProvider: executeDefinitionProvider,
+  executeDiagnosticProvider: executeDiagnosticProvider,
+  executeFormattingProvider: executeFormattingProvider,
+  executeHoverProvider: executeHoverProvider,
+  executeImplementationProvider: executeImplementationProvider,
+  executePrepareRenameProvider: executeprepareRenameProvider,
+  executeReferenceProvider: executeReferenceProvider,
+  executeRenameProvider: executeRenameProvider,
+  executeSelectionProvider: executeSelectionProvider,
+  executeTabCompletionProvider: executeTabCompletionProvider,
+  executeTextSearchProvider: executeTextSearchProvider,
+  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
+  exists: existsExternal,
+  // Errors
+  FormattingError,
+  // Configuration
+  getConfiguration: getConfiguration,
   // Ajax
   getJson: getJson$1,
+  // Get Offset
+  getOffset: getOffset,
+  // Get Position
+  getPosition: getPosition,
+  // Url
+  getRemoteUrl: getRemoteUrl$1,
+  // Text Document
+  getTextFromTextDocument: getText$2,
+  getWorkspaceFolder: getWorkspaceFolder,
+  // Workspace
+  handleWorkspaceRefresh: handleWorkspaceRefresh,
+  mkdir: mkdirExternal,
+  readDirWithFileTypes: readDirWithFileTypesExternal,
+  readFile: readFileExternal,
   // Brace Completion
   registerBraceCompletionProvider: registerBraceCompletionProvider,
-  executeBraceCompletionProvider: executeBraceCompletionProvider,
   // Closing Tag
   registerClosingTagProvider: registerClosingTagProvider,
-  executeClosingTagProvider: executeClosingTagProvider,
   // Code Action
   registerCodeActionsProvider: registerCodeActionProvider,
   // Command
   registerCommand: registerCommand,
-  executeCommand: executeCommand,
-  // Comment
-
   registerCommentProvider: registerCommentProvider,
-  executeCommentProvider: executeCommentProvider,
   // Completion
   registerCompletionProvider: registerCompletionProvider,
-  executeCompletionProvider: executeCompletionProvider,
-  EditorCompletionType,
-  // Configuration
-  getConfiguration: getConfiguration,
   // Debug
   registerDebugProvider: registerDebugProvider,
   // Definition
   registerDefinitionProvider: registerDefinitionProvider,
-  executeDefinitionProvider: executeDefinitionProvider,
   // Diagnostic
   registerDiagnosticProvider: registerDiagnosticProvider,
-  executeDiagnosticProvider: executeDiagnosticProvider,
-  // Dialog
-  showInformationMessage: showInformationMessage,
-  // Env
-  env: env,
-  // Errors
-  FormattingError,
-  VError,
-  // Exec`
-  exec: exec,
   // File System
   registerFileSystemProvider: registerFileSystemProvider,
-  readFile: readFileExternal,
-  readDirWithFileTypes: readDirWithFileTypesExternal,
-  exists: existsExternal,
-  mkdir: mkdirExternal,
-  remove: removeExternal,
-  writeFile: writeFileExternal,
-  stat: statExternal,
   // Formatting
   registerFormattingProvider: registerFormattingProvider,
-  executeFormattingProvider: executeFormattingProvider,
-  // Get Offset
-  getOffset: getOffset,
-  // Get Position
-  getPosition: getPosition,
   // Hover
   registerHoverProvider: registerHoverProvider,
-  executeHoverProvider: executeHoverProvider,
-  // Rpc
-  createRpc: createRpc,
-  createNodeRpc: createNodeRpc,
   // Implementation
   registerImplementationProvider: registerImplementationProvider,
-  executeImplementationProvider: executeImplementationProvider,
   // Output
   registerOutputChannel: registerOutputChannel,
-  // Prompt
-  confirm: confirm,
-  // QuickPick
-  showQuickPick: showQuickPick,
-  // Rename
-  registerRenameProvider: registerRenameProvider,
-  executeRenameProvider: executeRenameProvider,
-  executePrepareRenameProvider: executeprepareRenameProvider,
   // Reference
   registerReferenceProvider: registerReferenceProvider,
-  executeReferenceProvider: executeReferenceProvider,
+  // Rename
+  registerRenameProvider: registerRenameProvider,
   // Selection
   registerSelectionProvider: registerSelectionProvider,
-  executeSelectionProvider: executeSelectionProvider,
   // Source Control
   registerSourceControlProvider: registerSourceControlProvider,
   // Tab Completion
   registerTabCompletionProvider: registerTabCompletionProvider,
-  executeTabCompletionProvider: executeTabCompletionProvider,
-  // Text Document
-  getTextFromTextDocument: getText$2,
   // Text Search
   registerTextSearchProvider: registerTextSearchProvider,
-  executeTextSearchProvider: executeTextSearchProvider,
-  TextSearchResultType,
   // Type Definition
   registerTypeDefinitionProvider: registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
-  // Url
-  getRemoteUrl: getRemoteUrl$1,
   // Webview
   registerWebViewProvider: registerWebViewProvider,
-  // Worker
-  createWorker: createWorker,
-  // Workspace
-  handleWorkspaceRefresh: handleWorkspaceRefresh,
-  getWorkspaceFolder: getWorkspaceFolder
+  remove: removeExternal,
+  // Dialog
+  showInformationMessage: showInformationMessage,
+  // QuickPick
+  showQuickPick: showQuickPick,
+  stat: statExternal,
+  TextSearchResultType,
+  VError,
+  writeFile: writeFileExternal
 };
 
 const handleError = async error => {
@@ -3540,16 +3539,16 @@ const getRecentError = () => {
 
 const handleContentSecurityPolicyViolation = event => {
   const {
-    violatedDirective,
-    sourceFile,
+    columnNumber,
     lineNumber,
-    columnNumber
+    sourceFile,
+    violatedDirective
   } = event;
   addError({
-    violatedDirective,
-    sourceFile,
+    columnNumber,
     lineNumber,
-    columnNumber
+    sourceFile,
+    violatedDirective
   });
 };
 
@@ -3560,8 +3559,8 @@ const setStackTraceLimit = (errorConstructor, value) => {
 };
 
 const setup = ({
-  global,
-  errorConstructor
+  errorConstructor,
+  global
 }) => {
   setStackTraceLimit(errorConstructor, 20);
   global.onerror ||= handleUnhandledError;
@@ -3647,8 +3646,8 @@ const Error$1 = 4;
 
 const sleep = duration => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   setTimeout(resolve, duration);
   return promise;
@@ -3713,8 +3712,8 @@ const getLineAndColumn = (text, start, end) => {
     }
   }
   return {
-    line,
-    column
+    column,
+    line
   };
 };
 
@@ -3722,8 +3721,8 @@ class DependencyNotFoundError extends Error {
   constructor(code, start, end, dependencyRelativePath, dependencyUrl, sourceUrl) {
     super(`Module not found "${dependencyRelativePath}"`);
     const {
-      line,
-      column
+      column,
+      line
     } = getLineAndColumn(code, start);
     this.stack = `${this.message}
     at Module (${sourceUrl}:${line}:${column})`;
@@ -3757,35 +3756,35 @@ const walk = (node, visitor) => {
   }
   visitor(node);
   switch (node.type) {
-    case File$2:
-      walk(node.program, visitor);
+    case ArrowFunctionExpression:
+      walk(node.body, visitor);
       break;
-    case Program:
+    case AwaitExpression:
+      walk(node.argument, visitor);
+      break;
+    case BlockStatement:
       walk(node.body, visitor);
       break;
+    case CallExpression:
+      walk(node.callee, visitor);
+      break;
     case ExportNamedDeclaration:
       walk(node.declaration, visitor);
       break;
-    case VariableDeclaration:
-      walk(node.declarations, visitor);
-      break;
-    case VariableDeclarator:
-      walk(node.init, visitor);
+    case ExpressionStatement:
+      walk(node.expression, visitor);
       break;
-    case ArrowFunctionExpression:
-      walk(node.body, visitor);
+    case File$2:
+      walk(node.program, visitor);
       break;
-    case BlockStatement:
+    case Program:
       walk(node.body, visitor);
       break;
-    case ExpressionStatement:
-      walk(node.expression, visitor);
-      break;
-    case AwaitExpression:
-      walk(node.argument, visitor);
+    case VariableDeclaration:
+      walk(node.declarations, visitor);
       break;
-    case CallExpression:
-      walk(node.callee, visitor);
+    case VariableDeclarator:
+      walk(node.init, visitor);
       break;
   }
 };
@@ -3809,10 +3808,10 @@ const getBabelAstDependencies = (code, ast) => {
       } = node.source;
       // @ts-ignore
       dependencies.push({
-        relativePath,
         code,
-        start,
-        end
+        end,
+        relativePath,
+        start
       });
     } else if (node.type === VariableDeclaration && node.declarations && node.declarations[0] && node.declarations[0].type === VariableDeclarator && node.declarations[0].init && node.declarations[0].init.type === AwaitExpression && node.declarations[0].init.argument && node.declarations[0].init.argument.type === CallExpression && node.declarations[0].init.argument.callee && node.declarations[0].init.argument.callee.type === Import && node.declarations[0].init.argument.arguments && node.declarations[0].init.argument.arguments[0] && node.declarations[0].init.argument.arguments[0].type === StringLiteral) {
       const relativePath = node.declarations[0].init.argument.arguments[0].extra.rawValue;
@@ -3824,10 +3823,10 @@ const getBabelAstDependencies = (code, ast) => {
       } = node.declarations[0].init.argument.arguments[0];
       // @ts-ignore
       dependencies.push({
-        relativePath,
         code,
-        start,
-        end
+        end,
+        relativePath,
+        start
       });
     }
   }
@@ -3842,10 +3841,10 @@ const getBabelAstDependencies = (code, ast) => {
       } = node.arguments[0];
       // @ts-ignore
       dependencies.push({
-        relativePath,
         code,
-        start,
-        end
+        end,
+        relativePath,
+        start
       });
     }
   };
@@ -3974,17 +3973,17 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
   try {
     const startTime = performance.now();
     update(extensionId, {
-      status: Activating,
-      activationStartTime: startTime
+      activationStartTime: startTime,
+      status: Activating
     });
     const module = acquire(extensionId);
     await Promise.race([module.activate(extension), rejectAfterTimeout$1(activationTimeout$1, token)]);
     const endTime = performance.now();
     const time = endTime - startTime;
     update(extensionId, {
-      status: Activated,
+      activationEndTime: endTime,
       activationTime: time,
-      activationEndTime: endTime
+      status: Activated
     });
   } catch (error) {
     const id = getExtensionId(extension);
@@ -4087,10 +4086,10 @@ const activateExtension = async (extension, absolutePath, activationEvent) => {
       activationStartTime: startTime,
       activationTime: 0,
       id: extensionId,
-      status: Importing,
       importEndTime: 0,
       importStartTime: 0,
-      importTime: 0
+      importTime: 0,
+      status: Importing
     });
     const module = await importScript(absolutePath);
     handleRpcInfos(extension, platform);
@@ -4103,8 +4102,8 @@ const activateExtension = async (extension, absolutePath, activationEvent) => {
       const endTime = performance.now();
       const time = endTime - startTime;
       update(extensionId, {
-        status: Activated,
-        activationStartTime: time
+        activationStartTime: time,
+        status: Activated
       });
     } catch (error) {
       if (isImportError(error)) {
@@ -4534,12 +4533,11 @@ replaceTraps(oldTraps => ({
 }));
 
 const state$4 = {
-  dbVersion: 1,
   /**
    * @type {any}
    */
-  cachedDb: undefined
-};
+  cachedDb: undefined,
+  dbVersion: 1};
 
 const storeId = 'lvce-keyvalue';
 
@@ -4561,8 +4559,7 @@ const getDb$1 = async () => {
 // TODO high memory usage in idb because of transactionDoneMap
 
 const state$3 = {
-  cachedDb: undefined
-};
+  cachedDb: undefined};
 const getDbMemoized$1 = async () => {
   state$3.cachedDb ||= await getDb$1();
   return state$3.cachedDb;
@@ -4650,10 +4647,10 @@ const get = key => {
 
 const getCacheFn = config => {
   switch (config) {
-    case 'localStorage':
-      return GetColorThemeCssCachedLocalStorage;
     case 'indexedDb':
       return GetColorThemeCssCachedIndexedDb;
+    case 'localStorage':
+      return GetColorThemeCssCachedLocalStorage;
     default:
       return GetColorThemeCssCachedNoop;
   }
@@ -4831,21 +4828,21 @@ const create = () => {
 };
 
 const iframeWorkerCommandMap = {
+  'ExtensionHostManagement.activateByEvent': (...args) => invoke$1('ExtensionHostManagement.activateByEvent', ...args),
   'WebView.compatExtensionHostWorkerInvoke': (...args) => invoke$1('WebView.compatExtensionHostWorkerInvoke', ...args),
   'WebView.compatExtensionHostWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatExtensionHostWorkerInvokeAndTransfer', ...args),
   'WebView.compatRendererProcessInvoke': (...args) => invoke$1('WebView.compatRendererProcessInvoke', ...args),
   'WebView.compatRendererProcessInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatRendererProcessInvokeAndTransfer', ...args),
   // @ts-ignore
-  'WebView.compatRendererWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1(...args),
-  // @ts-ignore
   'WebView.compatRendererWorkerInvoke': (...args) => invoke$1(...args),
+  // @ts-ignore
+  'WebView.compatRendererWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1(...args),
   'WebView.compatSharedProcessInvoke': (...args) => invoke$1('WebView.compatSharedProcessInvoke', ...args),
+  'WebView.getRemoteUrl': options => getRemoteUrlForWebView(options.uri, options),
   'WebView.getSavedState': (...args) => invoke$1('WebView.getSavedState', ...args),
   'WebView.getWebViewInfo': (...args) => invoke$1('WebView.getWebViewInfo', ...args),
   'WebView.getWebViews': (...args) => invoke$1('WebView.getWebViews', ...args),
-  'WebView.setPort': (...args) => invoke$1('WebView.setPort', ...args),
-  'ExtensionHostManagement.activateByEvent': (...args) => invoke$1('ExtensionHostManagement.activateByEvent', ...args),
-  'WebView.getRemoteUrl': options => getRemoteUrlForWebView(options.uri, options)
+  'WebView.setPort': (...args) => invoke$1('WebView.setPort', ...args)
 };
 
 const launchIframeWorker = async () => {
@@ -4853,11 +4850,11 @@ const launchIframeWorker = async () => {
   const name = 'Iframe Worker';
   const id = create();
   const rpc = await create$2({
+    commandMap: iframeWorkerCommandMap,
+    id,
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     name,
-    url: configuredWorkerUrl,
-    id,
-    commandMap: iframeWorkerCommandMap
+    url: configuredWorkerUrl
   });
   return rpc;
 };
@@ -4882,22 +4879,22 @@ const invokeAndTransfer = async (method, ...params) => {
 };
 
 const createWebView3 = async ({
+  assetDir,
   id,
-  uri,
   isGitpod,
   platform,
-  assetDir,
-  webViewScheme,
-  useNewWebViewHandler
+  uri,
+  useNewWebViewHandler,
+  webViewScheme
 }) => {
   await invoke('WebView.create3', {
+    assetDir,
     id,
-    uri,
     isGitpod,
     platform,
-    assetDir,
-    webViewScheme,
-    useNewWebViewHandler
+    uri,
+    useNewWebViewHandler,
+    webViewScheme
   });
 };
 
@@ -4912,10 +4909,10 @@ const createWebViewWorkerRpc2 = async (rpcInfo, port) => {
   // host subworker doesn't need to import the other file
   await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: rpcInfo.url,
     name: rpcInfo.name,
+    port,
     raw: true,
-    port
+    url: rpcInfo.url
   });
 };
 
@@ -4933,10 +4930,10 @@ const createWebViewWorkerRpc = async (rpcInfo, port) => {
   // host subworker doesn't need to import the other file
   await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: extensionHostSubWorkerUrl,
     name: rpcInfo.name,
+    port,
     raw: true,
-    port
+    url: extensionHostSubWorkerUrl
   });
 };
 
@@ -4977,6 +4974,7 @@ const SourceControlDiscard = 'ExtensionHostSourceControl.discard';
 const SourceControlGetChangedFiles = 'ExtensionHost.sourceControlGetChangedFiles';
 const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
 const SourceControlGetFileBefore = 'ExtensionHostSourceControl.GetFileBefore';
+const SourceControlGetFileBefore2 = 'ExtensionHostSourceControl.getFileBefore';
 const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
 const SourceControlGetFileDecorations = 'ExtensionHostSourceControl.getFileDecorations';
 const StatusBarGetStatusBarItems = 'ExtensionHost.getStatusBarItems';
@@ -5008,17 +5006,17 @@ const mockExec = () => {
     api.exec = async (command, args, options) => {
       const result = await invoke$1('Test.executeMockExecFunction', command, args, options);
       const {
-        stdout,
+        exitCode,
         stderr,
-        exitCode
+        stdout
       } = result;
       if (exitCode !== 0) {
         throw new ExecError(command, args, stdout, stderr, exitCode);
       }
       return {
-        stdout,
+        exitCode,
         stderr,
-        exitCode
+        stdout
       };
     };
   } catch (error) {
@@ -5126,13 +5124,13 @@ const readDirWithFileTypes$1 = async uri => {
           continue;
         }
         dirents.push({
-          type: Directory$1,
-          name
+          name,
+          type: Directory$1
         });
       } else {
         dirents.push({
-          type: File$1,
-          name: rest
+          name: rest,
+          type: File$1
         });
       }
     }
@@ -5184,29 +5182,29 @@ const VideoWebm = 'video/webm';
 
 const getMimeType = fileExtension => {
   switch (fileExtension) {
-    case '.html':
-      return TextHtml;
     case '.css':
       return TextCss;
-    case '.ttf':
-      return FontTtf;
+    case '.html':
+      return TextHtml;
     case '.js':
     case '.mjs':
     case '.ts':
       return TextJavaScript;
-    case '.svg':
-      return ImageSvgXml;
-    case '.png':
-      return ImagePng;
     case '.json':
     case '.map':
       return ApplicationJson;
     case '.mp3':
       return AudioMpeg;
-    case '.webm':
-      return VideoWebm;
+    case '.png':
+      return ImagePng;
+    case '.svg':
+      return ImageSvgXml;
+    case '.ttf':
+      return FontTtf;
     case '.txt':
       return TextPlain;
+    case '.webm':
+      return VideoWebm;
     default:
       return '';
   }
@@ -5268,8 +5266,8 @@ const ensureParentDir = uri => {
   while (endIndex >= 0) {
     const part = uri.slice(startIndex, endIndex + 1);
     setDirent(part, {
-      type: Directory$1,
-      content: ''
+      content: '',
+      type: Directory$1
     });
     endIndex = uri.indexOf(Slash, endIndex + 1);
   }
@@ -5283,8 +5281,8 @@ const writeFile = (uri, content) => {
   } else {
     ensureParentDir(uri);
     setDirent(uri, {
-      type: File$1,
-      content
+      content,
+      type: File$1
     });
   }
 };
@@ -5294,8 +5292,8 @@ const mkdir = uri => {
   }
   ensureParentDir(uri);
   setDirent(uri, {
-    type: Directory$1,
-    content: ''
+    content: '',
+    type: Directory$1
   });
 };
 const remove = uri => {
@@ -5327,8 +5325,8 @@ const renameDirectory = (oldUri, newUri) => {
   }
   ensureParentDir(newUri);
   setDirent(newUri, {
-    type: Directory$1,
-    content: ''
+    content: '',
+    type: Directory$1
   });
   const allFiles = getAll();
   for (const [key, value] of Object.entries(allFiles)) {
@@ -5362,18 +5360,18 @@ const readDirWithFileTypes = uri => {
         case Directory$1:
           if (!key.slice(0, -1).includes(Slash, uri.length) && key !== `${uri}/` && key !== uri) {
             dirents.push({
+              name: key.slice(uri.length, -1),
               // @ts-ignore
-              type: value.type,
-              name: key.slice(uri.length, -1)
+              type: value.type
             });
           }
           break;
         case File$1:
           if (!key.includes(Slash, uri.length + 1)) {
             dirents.push({
+              name: key.slice(uri.length),
               // @ts-ignore
-              type: value.type,
-              name: key.slice(uri.length)
+              type: value.type
             });
           }
           break;
@@ -5457,8 +5455,8 @@ const getIconThemeJson$1 = async iconThemeId => {
     const url = getIconThemeUrl(iconThemeId);
     const json = await getJson(url);
     return {
-      json,
-      extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
+      extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`,
+      json
     };
   }
   for (const webExtension of state$9.webExtensions) {
@@ -5468,8 +5466,8 @@ const getIconThemeJson$1 = async iconThemeId => {
         const iconThemeUrl = `${webExtension.path}/${iconTheme.path}`;
         const json = await getJson(iconThemeUrl);
         return {
-          json,
-          extensionPath: webExtension.path
+          extensionPath: webExtension.path,
+          json
         };
       }
     }
@@ -5500,15 +5498,15 @@ const getRpcInfo = rpcId => {
 };
 
 const emptyStatus = {
-  status: None,
-  id: '',
+  activationEndTime: 0,
   activationEvent: '',
   activationStartTime: 0,
-  activationEndTime: 0,
   activationTime: 0,
+  id: '',
   importEndTime: 0,
   importStartTime: 0,
-  importTime: 0
+  importTime: 0,
+  status: None
 };
 const getRuntimeStatus = extensionId => {
   return get$5(extensionId) || emptyStatus;
@@ -5541,8 +5539,8 @@ const getWebViewsFromExtensions = extensions => {
         webViews.push({
           ...webView,
           path,
-          uri,
-          remotePath
+          remotePath,
+          uri
         });
       }
     }
@@ -5564,8 +5562,8 @@ const handleBeforeUnload = () => {
 
 const handleMessagePort2 = async (port, rpcId) => {
   const rpc = await PlainMessagePortRpcParent.create({
-    messagePort: port,
-    commandMap: {}
+    commandMap: {},
+    messagePort: port
   });
   if (rpcId) {
     set$c(rpcId, rpc);
@@ -5574,8 +5572,8 @@ const handleMessagePort2 = async (port, rpcId) => {
 
 const handleMessagePort = async (port, rpcId) => {
   const rpc = await MessagePortRpcClient.create({
-    messagePort: port,
-    commandMap: {}
+    commandMap: {},
+    messagePort: port
   });
   if (rpcId) {
     set$c(rpcId, rpc);
@@ -5589,14 +5587,14 @@ const handleIconThemeChange = async () => {
 const initialIconTheme = undefined;
 
 const state = {
-  seenFiles: [],
-  seenFolders: [],
+  extensionPath: '',
   hasWarned: [],
   /**
    * @type{any}
    */
   iconTheme: initialIconTheme,
-  extensionPath: ''
+  seenFiles: [],
+  seenFolders: []
 };
 const setTheme = iconTheme => {
   state.iconTheme = iconTheme.json;
@@ -5628,15 +5626,15 @@ const importExtension = async (extensionId, absolutePath, activationEvent) => {
     string(absolutePath);
     const startTime = performance.now();
     set$4({
+      activationEndTime: 0,
       activationEvent: activationEvent,
-      id: extensionId,
       activationStartTime: performance.now(),
-      status: Importing,
-      activationEndTime: 0,
       activationTime: 0,
-      importStartTime: startTime,
+      id: extensionId,
       importEndTime: 0,
-      importTime: 0
+      importStartTime: startTime,
+      importTime: 0,
+      status: Importing
     });
     try {
       const module = await importScript(absolutePath);
@@ -5805,8 +5803,8 @@ const serializeWebView = async webView => {
   if (webView && webView.provider && webView.provider.saveState) {
     const saved = await webView.provider.saveState();
     return {
-      uri: webView.uri,
-      state: saved
+      state: saved,
+      uri: webView.uri
     };
   }
   return undefined;
@@ -5980,11 +5978,11 @@ const getLineMatchRegex = (line, lineNumber, query, matchCase) => {
   const match = line.match(regex);
   if (match && typeof match.index === 'number') {
     return [{
-      type: Match,
-      text: line,
-      start: match.index,
       end: match.index + match[0].length,
-      lineNumber
+      lineNumber,
+      start: match.index,
+      text: line,
+      type: Match
     }];
   }
   return [];
@@ -6010,11 +6008,11 @@ const getLineMatchText = (line, lineNumber, query, queryLower, matchCase, matchW
     return [];
   }
   return [{
-    type: Match,
-    text: line,
-    start: index,
     end: index + query.length,
-    lineNumber
+    lineNumber,
+    start: index,
+    text: line,
+    type: Match
   }];
 };
 
@@ -6043,11 +6041,11 @@ const textSearchInText = (file, content, query, flags = 0) => {
   const results = lines.flatMap((line, i) => getLineMatch(line, i, query, queryLower, useRegularExpression, matchCase, matchWholeWord));
   if (results.length > 0) {
     return [{
-      type: File$3,
-      text: file,
-      start: 0,
       end: 0,
-      lineNumber: 0
+      lineNumber: 0,
+      start: 0,
+      text: file,
+      type: File$3
     }, ...results];
   }
   return results;
@@ -6177,8 +6175,8 @@ const textSearch2 = async (scheme, root, query, options, assetDir) => {
     }
   }
   return {
-    results: options.limit ? allResults.slice(0, options.limit) : allResults,
-    limitHit: allResults.length > options.limit
+    limitHit: allResults.length > options.limit,
+    results: options.limit ? allResults.slice(0, options.limit) : allResults
   };
 };
 
@@ -6200,6 +6198,51 @@ const commandMap = {
   'ExtensionHost.getRuntimeStatus': getRuntimeStatus,
   'ExtensionHost.importExtension': importExtension,
   'ExtensionHost.launchIframeWorker': launchIframeWorker,
+  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
+  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
+  [CommandExecute]: executeCommand,
+  [CommentProviderExecute]: executeCommentProvider,
+  [CompletionExecute]: executeCompletionProvider,
+  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
+  [ConfigurationSetConfiguration]: setConfigurations,
+  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
+  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
+  [ExtensionActivate]: activateExtension,
+  [FileSystemGetPathSeparator]: getPathSeparator,
+  [FileSystemMkdir]: mkdir$2,
+  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes$2,
+  [FileSystemReadFile]: readFile$2,
+  [FileSystemRemove]: remove$3,
+  [FileSystemRename]: rename$1,
+  [FileSystemWriteFile]: writeFile$3,
+  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
+  [HoverExecute]: executeHoverProvider,
+  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
+  [MockExec]: mockExec,
+  [MockRpc]: mockRpc,
+  [OrganizeImportsExecute]: executeOrganizeImports,
+  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
+  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
+  [ReferenceExecuteReferenceProvider2]: executeReferenceProvider2,
+  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
+  [SourceControlAcceptInput]: acceptInput,
+  [SourceControlAdd]: add,
+  [SourceControlDiscard]: discard,
+  [SourceControlGetChangedFiles]: getChangedFiles,
+  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
+  [SourceControlGetFileBefore]: getFileBefore,
+  [SourceControlGetFileBefore2]: getFileBefore,
+  [SourceControlGetFileDecorations]: getFileDecorations,
+  [SourceControlGetGroups]: getGroups,
+  [StatusBarGetStatusBarItems]: getStatusBarItems,
+  [StatusBarRegisterChangeListener]: registerChangeListener,
+  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
+  [TextDocumentSetLanguageId]: setLanguageId,
+  [TextDocumentSyncFull]: syncFull,
+  [TextDocumentSyncIncremental]: syncIncremental,
+  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
+  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
+  [WorkspaceSetPath]: setWorkspacePath,
   'ExtensionHostDebug.evaluate': evaluate,
   'ExtensionHostDebug.getCallStack': getCallStack,
   'ExtensionHostDebug.getPausedStatus': getPausedStatus,
@@ -6230,17 +6273,16 @@ const commandMap = {
   'Extensions.getExtensions': getExtensions,
   'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
   'FileSystemFetch.chmod': chmod$1,
+  'FileSystemFetch.exists': exists$1,
   'FileSystemFetch.getBlob': getBlob$1,
   'FileSystemFetch.mkdir': mkdir$1,
   'FileSystemFetch.readDirWithFileTypes': readDirWithFileTypes$1,
   'FileSystemFetch.readFile': readFile$1,
   'FileSystemFetch.remove': remove$2,
-  'FileSystemFetch.exists': exists$1,
   'FileSystemFetch.writeFile': writeFile$1,
   'FileSystemMemory.chmod': chmod,
   'FileSystemMemory.copy': copy,
   'FileSystemMemory.exists': exists,
-  'FileSystemMemory.stat': stat,
   'FileSystemMemory.getBlob': getBlob,
   'FileSystemMemory.getBlobUrl': getBlobUrl,
   'FileSystemMemory.getFiles': getFiles,
@@ -6249,6 +6291,7 @@ const commandMap = {
   'FileSystemMemory.readFile': readFile,
   'FileSystemMemory.remove': remove,
   'FileSystemMemory.rename': rename,
+  'FileSystemMemory.stat': stat,
   'FileSystemMemory.writeFile': writeFile,
   'HandleBeforeUnload.handleBeforeUnload': handleBeforeUnload,
   'HandleMessagePort.handleMessagePort': handleMessagePort,
@@ -6280,51 +6323,7 @@ const commandMap = {
   'WebView.getRpcInfo': getRpcInfo,
   'WebView.registerInterceptor': registerInterceptor,
   'WebView.unregisterInterceptor': unregisterInterceptor,
-  'WebViews.getWebViews': getWebViews,
-  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
-  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
-  [CommandExecute]: executeCommand,
-  [CompletionExecute]: executeCompletionProvider,
-  [CommentProviderExecute]: executeCommentProvider,
-  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
-  [ConfigurationSetConfiguration]: setConfigurations,
-  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
-  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
-  [ExtensionActivate]: activateExtension,
-  [FileSystemGetPathSeparator]: getPathSeparator,
-  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes$2,
-  [FileSystemReadFile]: readFile$2,
-  [FileSystemRename]: rename$1,
-  [FileSystemWriteFile]: writeFile$3,
-  [FileSystemRemove]: remove$3,
-  [FileSystemMkdir]: mkdir$2,
-  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
-  [HoverExecute]: executeHoverProvider,
-  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
-  [MockExec]: mockExec,
-  [MockRpc]: mockRpc,
-  [OrganizeImportsExecute]: executeOrganizeImports,
-  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
-  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
-  [ReferenceExecuteReferenceProvider2]: executeReferenceProvider2,
-  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
-  [SourceControlAcceptInput]: acceptInput,
-  [SourceControlAdd]: add,
-  [SourceControlDiscard]: discard,
-  [SourceControlGetChangedFiles]: getChangedFiles,
-  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
-  [SourceControlGetFileBefore]: getFileBefore,
-  [SourceControlGetGroups]: getGroups,
-  [SourceControlGetFileDecorations]: getFileDecorations,
-  [StatusBarGetStatusBarItems]: getStatusBarItems,
-  [StatusBarRegisterChangeListener]: registerChangeListener,
-  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
-  [TextDocumentSetLanguageId]: setLanguageId,
-  [TextDocumentSyncFull]: syncFull,
-  [TextDocumentSyncIncremental]: syncIncremental,
-  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
-  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
-  [WorkspaceSetPath]: setWorkspacePath
+  'WebViews.getWebViews': getWebViews
 };
 
 const listen = async () => {