@lvce-editor/static-server 0.83.1 → 0.84.0

package/static/{7c12bd7 → ba431a4}/packages/completion-worker/dist/completionWorkerMain.js

@@ -518,56 +518,35 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
-  callbacks[id] = fn;
+const getCommand$1 = key => {
+  return commands[key];
 };
+const execute = (command, ...args) => {
+  const fn = getCommand$1(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
 const get$2 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$5(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -584,12 +563,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -718,7 +697,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -745,27 +724,27 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
@@ -774,27 +753,27 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$a = (message, result) => {
   return {
-    jsonrpc: Two,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -824,35 +803,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -874,11 +853,51 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+
+const Two = '2.0';
+
+const create$9 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$8 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$7 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$7();
   const {
-    message,
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
     promise
-  } = create$2$1(method, params);
+  } = registerPromise(callbacks);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -887,60 +906,40 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand$1 = key => {
-  return commands[key];
-};
-const execute$1 = (command, ...args) => {
-  const fn = getCommand$1(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$9(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -952,9 +951,10 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$1;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -963,6 +963,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -971,15 +972,17 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+
+const create$6 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -987,8 +990,10 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+
+const create$5 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -996,16 +1001,56 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$3
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
 };
+
 const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1015,108 +1060,40 @@ const create$4 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$4
-};
 
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$2 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    get(uid) {
-      return states[uid];
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseInt(key);
-      });
-    },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          oldState,
-          newState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || newState === newerState) {
-          return;
-        }
-        const latest = states[uid];
-        states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
     }
+    return command(...params);
   };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
 };
-const terminate = () => {
-  globalThis.close();
-};
-
-const EditorWorker$2 = 99;
-const ExtensionHostWorker = 44;
 
 const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
+const remove = id => {
+  delete rpcs[id];
+};
 
-const create$1 = rpcId => {
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$2 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1134,91 +1111,85 @@ const create$1 = rpcId => {
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$3(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
     set(rpc) {
-      set$4(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
 
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const DeltaMode = 'event.deltaMode';
+const DeltaY = 'event.deltaY';
+
+const Enter = 3;
+const Escape = 8;
+const Space$1 = 9;
+const End = 255;
+const Home = 12;
+const UpArrow = 14;
+const DownArrow = 16;
+
+const CtrlCmd = 1 << 11 >>> 0;
+
+const EditorWorker$1 = 99;
+const ExtensionManagementWorker = 9006;
 
 const {
-  dispose: dispose$2,
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$3
-} = create$1(EditorWorker$2);
-const sendMessagePortToExtensionHostWorker$2 = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
-};
-// TODO add tests for this
-const activateByEvent$2 = async event => {
-  // @ts-ignore
-  await invoke$1('ActivateByEvent.activateByEvent', event);
+  set: set$2
+} = create$2(EditorWorker$1);
+const sendMessagePortToExtensionManagementWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker', port, 0);
 };
-const applyEdit$2 = async (editorUid, changes) => {
+const applyEdit$1 = async (editorUid, changes) => {
   // @ts-ignore
   await invoke$1('Editor.applyEdit2', editorUid, changes);
 };
-const applyWorkspaceEdit = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$1('Editor.applyWorkspaceEdit', editorUid, changes);
-};
-const closeWidget$1 = async (editorUid, widgetId, widgetName, focusId) => {
+const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
   // @ts-ignore
   await invoke$1('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
 };
-const getWordAt = async (uid, rowIndex, columnIndex) => {
-  // @ts-ignore
-  const word = await invoke$1('Editor.getWordAt2', uid, rowIndex, columnIndex);
-  return word;
-};
-const getLines$2 = async editorUid => {
+const getLines$1 = async editorUid => {
   const lines = await invoke$1('Editor.getLines2', editorUid);
   return lines;
 };
-const getPositionAtCursor$2 = async parentUid => {
+const getPositionAtCursor$1 = async parentUid => {
   const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
   return position;
 };
-const getOffsetAtCursor$2 = async editorId => {
+const getOffsetAtCursor$1 = async editorId => {
   // @ts-ignore
   return await invoke$1('Editor.getOffsetAtCursor', editorId);
 };
-const getSelections$2 = async editorUid => {
+const getSelections$1 = async editorUid => {
   const selections = await invoke$1('Editor.getSelections2', editorUid);
   return selections;
 };
-const getWordAtOffset2$1 = async editorUid => {
+const getWordAtOffset2 = async editorUid => {
   return invoke$1('Editor.getWordAtOffset2', editorUid);
 };
-const getWordBefore$2 = async (editorUid, rowIndex, columnIndex) => {
+const getWordBefore$1 = async (editorUid, rowIndex, columnIndex) => {
   return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
-const updateDebugInfo = async info => {
-  await invoke$1('Editor.updateDebugInfo', info);
-};
 const getUri = async editorUid => {
   // @ts-ignore
   return invoke$1('Editor.getUri', editorUid);
@@ -1227,75 +1198,148 @@ const getLanguageId = async editorUid => {
   // @ts-ignore
   return invoke$1('Editor.getLanguageId', editorUid);
 };
-const getProblems = async () => {
-  // @ts-ignore
-  return invoke$1('Editor.getProblems');
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$3(mockRpc);
-  return mockRpc;
-};
-
-const EditorWorker$1 = {
-  __proto__: null,
-  activateByEvent: activateByEvent$2,
-  applyEdit: applyEdit$2,
-  applyWorkspaceEdit,
-  closeWidget: closeWidget$1,
-  dispose: dispose$2,
-  getLanguageId,
-  getLines: getLines$2,
-  getOffsetAtCursor: getOffsetAtCursor$2,
-  getPositionAtCursor: getPositionAtCursor$2,
-  getProblems,
-  getSelections: getSelections$2,
-  getUri,
-  getWordAt,
-  getWordAtOffset2: getWordAtOffset2$1,
-  getWordBefore: getWordBefore$2,
-  invoke: invoke$1,
-  invokeAndTransfer,
-  registerMockRpc,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$2,
-  set: set$3,
-  updateDebugInfo
-};
-
-const {
-  invoke,
-  set: set$2
-} = create$1(ExtensionHostWorker);
-
-const {
-  activateByEvent: activateByEvent$1,
-  applyEdit: applyEdit$1,
-  closeWidget,
-  getLines: getLines$1,
-  getOffsetAtCursor: getOffsetAtCursor$1,
-  getPositionAtCursor: getPositionAtCursor$1,
-  getSelections: getSelections$1,
-  getWordAtOffset2,
-  getWordBefore: getWordBefore$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  set: set$1
-} = EditorWorker$1;
 
 const EditorWorker = {
   __proto__: null,
-  activateByEvent: activateByEvent$1,
   applyEdit: applyEdit$1,
   closeWidget,
+  getLanguageId,
   getLines: getLines$1,
   getOffsetAtCursor: getOffsetAtCursor$1,
   getPositionAtCursor: getPositionAtCursor$1,
   getSelections: getSelections$1,
+  getUri,
   getWordAtOffset2,
   getWordBefore: getWordBefore$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  sendMessagePortToExtensionManagementWorker,
+  set: set$2
+};
+
+const {
+  invoke,
   set: set$1
+} = create$2(ExtensionManagementWorker);
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$1 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseFloat(key);
+      });
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
 };
 
 const FocusEditorCompletions = 9;
@@ -1316,7 +1360,7 @@ const {
   get,
   set,
   wrapCommand
-} = create$2();
+} = create$1();
 
 const create = (uid, x, y, width, height, editorUid, editorLanguageId) => {
   const state = {
@@ -1494,44 +1538,27 @@ const replaceRange = (lines, ranges, replacement, origin) => {
   return changes;
 };
 
-const OnCompletion = 'onCompletion';
-
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
-
-const {
-  activateByEvent
-} = EditorWorker;
-
-const execute = async ({
-  args,
-  editorLanguageId,
-  editorUid,
-  event,
-  method
-}) => {
-  const fullEvent = `${event}:${editorLanguageId}`;
-  await activateByEvent(fullEvent);
-  const result = await invoke(method, editorUid, ...args);
-  return result;
+const getText = async editorUid => {
+  const lines = await getLines$1(editorUid);
+  return lines.join('\n');
+};
+const getTextDocument = async (editorUid, languageId) => {
+  const [text, uri] = await Promise.all([getText(editorUid), getUri(editorUid)]);
+  return {
+    documentId: editorUid,
+    languageId,
+    text,
+    uri
+  };
 };
-
 const executeCompletionProvider = async (editorUid, editorLanguageId, offset) => {
-  return execute({
-    args: [offset],
-    editorLanguageId,
-    editorUid,
-    event: OnCompletion,
-    method: CompletionExecute
-  });
+  const textDocument = await getTextDocument(editorUid, editorLanguageId);
+  return invoke('Extensions.executeCompletionProvider', textDocument, offset);
 };
 const executeResolveCompletionItem = async (editorUid, offset, name, completionItem) => {
-  return execute({
-    args: [offset, name, completionItem],
-    editorUid,
-    event: OnCompletion,
-    method: CompletionResolveExecute
-  });
+  const editorLanguageId = await getLanguageId(editorUid);
+  const textDocument = await getTextDocument(editorUid, editorLanguageId);
+  return invoke('Extensions.executeResolveCompletionItemProvider', textDocument, offset, name, completionItem);
 };
 
 const getOffsetAtCursor = async editorUid => {
@@ -1602,26 +1629,6 @@ const getCommandIds = () => {
   return commandIds;
 };
 
-const Div = 4;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const DeltaMode = 'event.deltaMode';
-const DeltaY = 'event.deltaY';
-
-const Enter = 3;
-const Escape = 8;
-const Space$1 = 9;
-const End = 255;
-const Home = 12;
-const UpArrow = 14;
-const DownArrow = 16;
-
-const CtrlCmd = 1 << 11 >>> 0;
-
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
@@ -1635,9 +1642,9 @@ const position = (x, y) => {
 
 const text = data => {
   return {
-    type: Text,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text
   };
 };
 
@@ -1889,9 +1896,7 @@ const getListHeight = (itemsLength, itemHeight, maxHeight) => {
   return Math.min(totalHeight, maxHeight);
 };
 
-const {
-  getPositionAtCursor
-} = EditorWorker;
+const getPositionAtCursor = getPositionAtCursor$1;
 
 const getWordAtOffset = getWordAtOffset2;
 
@@ -2054,25 +2059,8 @@ const handleWheel = (state, deltaMode, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const {
-  sendMessagePortToExtensionHostWorker
-} = EditorWorker;
-
-const createExtensionHostRpc = async () => {
-  try {
-    const rpc = await TransferMessagePortRpcParent.create({
-      commandMap: {},
-      send: sendMessagePortToExtensionHostWorker
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
 const initialize = async () => {
-  const rpc = await createExtensionHostRpc();
-  set$2(rpc);
+  // Initialization happens during worker startup in Listen.listen.
 };
 
 const error = message => {
@@ -2248,7 +2236,7 @@ const getIconDom = (fileIcon, symbolName) => {
   }
   return {
     childCount: 0,
-    className: `${ColoredMaskIcon} ${symbolName}`,
+    className: mergeClassNames(ColoredMaskIcon, symbolName),
     type: Div
   };
 };
@@ -2296,6 +2284,18 @@ const getHighlightedLabelDom = (label, highlights) => {
   return dom;
 };
 
+const getCompletionItemClassName = (focused, deprecated) => {
+  if (focused && deprecated) {
+    return mergeClassNames(EditorCompletionItem, EditorCompletionItemFocused, EditorCompletionItemDeprecated);
+  }
+  if (focused) {
+    return mergeClassNames(EditorCompletionItem, EditorCompletionItemFocused);
+  }
+  if (deprecated) {
+    return mergeClassNames(EditorCompletionItem, EditorCompletionItemDeprecated);
+  }
+  return EditorCompletionItem;
+};
 const getCompletionItemVirtualDom = visibleItem => {
   const {
     deprecated,
@@ -2306,13 +2306,7 @@ const getCompletionItemVirtualDom = visibleItem => {
     symbolName,
     top
   } = visibleItem;
-  let className = EditorCompletionItem;
-  if (focused) {
-    className += ' ' + EditorCompletionItemFocused;
-  }
-  if (deprecated) {
-    className += ' ' + EditorCompletionItemDeprecated;
-  }
+  const className = getCompletionItemClassName(focused, deprecated);
   return [{
     childCount: 2,
     className,
@@ -2572,13 +2566,28 @@ const commandMap = {
   'Completions.terminate': terminate
 };
 
-const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+const initializeEditorWorker = async () => {
+  const rpc = await create$3({
     commandMap: commandMap
   });
+  set$2(rpc);
+};
+
+const send = async port => {
+  await sendMessagePortToExtensionManagementWorker(port);
+};
+const initializeExtensionManagementWorker = async () => {
+  const rpc = await create$4({
+    commandMap: commandMap,
+    send
+  });
   set$1(rpc);
 };
 
+const listen = async () => {
+  await Promise.all([initializeEditorWorker(), initializeExtensionManagementWorker()]);
+};
+
 const main = async () => {
   await listen();
 };