@lvce-editor/static-server 0.67.0 → 0.67.3

package/static/{a01bf62 → 40424f5}/packages/editor-worker/dist/editorWorkerMain.js

@@ -539,26 +539,26 @@ const create$4$2 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$d = (id, fn) => {
+const set$c = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$7 = id => {
+const get$8 = id => {
   return callbacks[id];
 };
 const remove$9 = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3$1 = () => {
+const create$3$2 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3$1();
+  const id = create$3$2();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$d(id, resolve);
+  set$c(id, resolve);
   return {
     id,
     promise
@@ -723,7 +723,7 @@ const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$7(id);
+  const fn = get$8(id);
   if (!fn) {
     console.log(response);
     warn$1(`callback ${id} may already be disposed`);
@@ -899,14 +899,14 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
+const send$1 = (transport, method, ...params) => {
   const message = create$4$2(method, params);
   transport.send(message);
 };
-const invoke$d = (ipc, method, ...params) => {
+const invoke$c = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$4 = (ipc, method, ...params) => {
+const invokeAndTransfer$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -939,13 +939,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$d(ipc, method, ...params);
+      return invoke$c(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$4(ipc, method, ...params);
+      return invokeAndTransfer$3(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1032,6 +1032,24 @@ const PlainMessagePortRpcParent = {
   __proto__: null,
   create: create$4$1
 };
+const create$3$1 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5$1({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3$1
+};
 const create$a = async ({
   commandMap
 }) => {
@@ -1112,19 +1130,21 @@ const CtrlCmd = 1 << 11 >>> 0;
 const Shift = 1 << 10 >>> 0;
 const Alt$1 = 1 << 9 >>> 0;
 
+const CompletionWorker = 301;
 const DebugWorker = 55;
 const EditorWorker = 99;
 const ExtensionHostWorker = 44;
 const MarkdownWorker = 300;
-const RendererWorker$1 = 1;
+const RendererWorker = 1;
+const TextMeasurementWorker = 7011;
 
 const FocusEditorText$1 = 12;
 
 const rpcs = Object.create(null);
-const set$c = (id, rpc) => {
+const set$b = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$6 = id => {
+const get$7 = id => {
   return rpcs[id];
 };
 const remove$8 = id => {
@@ -1135,443 +1155,117 @@ const create$9 = rpcId => {
   return {
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$6(rpcId);
+      const rpc = get$7(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$6(rpcId);
+      const rpc = get$7(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$c(rpcId, rpc);
+      set$b(rpcId, rpc);
     },
     async dispose() {
-      const rpc = get$6(rpcId);
+      const rpc = get$7(rpcId);
       await rpc.dispose();
     }
   };
 };
 
 const {
-  invoke: invoke$c,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$b,
-  dispose: dispose$3
+  invoke: invoke$b,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$a,
+  dispose: dispose$2
 } = create$9(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
-  return invoke$c('ExtensionHostReference.executeReferenceProvider', id, offset);
+  return invoke$b('ExtensionHostReference.executeReferenceProvider', id, offset);
 };
 const executeFileReferenceProvider = async id => {
   // @ts-ignore
-  return invoke$c('ExtensionHostReference.executeFileReferenceProvider', id);
+  return invoke$b('ExtensionHostReference.executeFileReferenceProvider', id);
 };
 const getRuntimeStatus = async extensionId => {
   // @ts-ignore
-  return invoke$c('ExtensionHost.getRuntimeStatus', extensionId);
+  return invoke$b('ExtensionHost.getRuntimeStatus', extensionId);
 };
-const registerMockRpc$1 = commandMap => {
+const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
     commandMap
   });
-  set$b(mockRpc);
+  set$a(mockRpc);
   return mockRpc;
 };
 
 const ExtensionHost = {
   __proto__: null,
-  dispose: dispose$3,
+  dispose: dispose$2,
   executeFileReferenceProvider,
   executeReferenceProvider,
   getRuntimeStatus,
-  invoke: invoke$c,
-  invokeAndTransfer: invokeAndTransfer$3,
-  registerMockRpc: registerMockRpc$1,
-  set: set$b
-};
-
-const {
   invoke: invoke$b,
   invokeAndTransfer: invokeAndTransfer$2,
-  set: set$a,
-  dispose: dispose$2
-} = create$9(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$b('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$b('FileSystemHandle.getFilePathElectron', file);
-};
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$b('ContextMenu.show', x, y, id, ...args);
-};
-const getElectronVersion = async () => {
-  return invoke$b('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke$b('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme = async id => {
-  // @ts-ignore
-  return invoke$b(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke$b('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke$b('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke$b('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke$b('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke$b('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer$2('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke$b('WebView.unregisterInterceptor', id);
-};
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const sendMessagePortToErrorWorker = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
-  const command = 'Markdown.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
-};
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile = async uri => {
-  return invoke$b('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$b('WebView.getSecret', key);
-};
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer$2('WebView.setPort', uid, port, origin, portType);
-};
-const setFocus$1 = key => {
-  return invoke$b('Focus.setFocus', key);
-};
-const getFileIcon = async options => {
-  return invoke$b('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames = async () => {
-  return invoke$b('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke$b('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke$b('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke$b('Run And Debug.handleChange', params);
-};
-const getFolderIcon = async options => {
-  return invoke$b('IconTheme.getFolderIcon', options);
-};
-const closeWidget = async widgetId => {
-  return invoke$b('Viewlet.closeWidget', widgetId);
-};
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer$2('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
-};
-const confirm = async (message, options) => {
-  // @ts-ignore
-  const result = await invoke$b('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened = async () => {
-  return invoke$b(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings$1 = async () => {
-  return invoke$b('KeyBindingsInitial.getKeyBindings');
-};
-const writeClipBoardText = async text => {
-  await invoke$b('ClipBoard.writeText', /* text */text);
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$b('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$b('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$b('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$b('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$b('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$b('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$b('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent$1 = event => {
-  return invoke$b('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$b('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke$b('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke$b('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const getPreference = async key => {
-  return await invoke$b('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$b('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$b('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$b('Run And Debug.handlePaused', params);
-};
-const openUri = async (uri, focus, options) => {
-  await invoke$b('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker$1 = async port => {
-  await invokeAndTransfer$2(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$b('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$b('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$b('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$b('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$b('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke$b('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$b('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$b('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$b('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$b('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$b('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$b('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$b('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$b('Extensions.handleInput', searchValue);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$b('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$b('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$b('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$b('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$b('PlatformPaths.getLogsDir');
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$a(mockRpc);
-  return mockRpc;
-};
-
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent: activateByEvent$1,
-  applyBulkReplacement,
-  closeWidget,
-  confirm,
-  disableExtension,
-  dispose: dispose$2,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
-  getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  installExtension,
-  invoke: invoke$b,
-  invokeAndTransfer: invokeAndTransfer$2,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readFile,
   registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSyntaxHighlightingWorker: sendMessagePortToSyntaxHighlightingWorker$1,
-  set: set$a,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus: setFocus$1,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
+  set: set$a
 };
 
 const {
   invoke: invoke$a,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$9,
+  set: set$9} = create$9(RendererWorker);
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+
+const {
+  invoke: invoke$9,
+  invokeAndTransfer,
+  set: set$8,
   dispose: dispose$1
 } = create$9(MarkdownWorker);
 
 const SyntaxHighlightingWorker = {
   __proto__: null,
   dispose: dispose$1,
-  invoke: invoke$a,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set: set$9
+  invoke: invoke$9,
+  invokeAndTransfer,
+  set: set$8
 };
 
-const {
-  set: set$8,
-  invoke: invoke$9,
-  invokeAndTransfer
-} = RendererWorker;
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$b(rpcId, rpc);
+  };
+  const ensureRpc = async () => {
+    if (!rpcPromise) {
+      rpcPromise = createRpc();
+    }
+    await rpcPromise;
+  };
+  return {
+    setFactory(value) {
+      factory = value;
+    },
+    async invoke(method, ...params) {
+      await ensureRpc();
+      const rpc = get$7(rpcId);
+      return rpc.invoke(method, ...params);
+    }
+  };
+};
 
 // TODO add tests for this
 const activateByEvent = async event => {
-  await invoke$9('ExtensionHostManagement.activateByEvent', event);
+  await invoke$a('ExtensionHostManagement.activateByEvent', event);
 };
 
 const codeGeneratorAccept = state => {
@@ -1599,7 +1293,7 @@ const launchWorker = async (name, url, intializeCommand) => {
     port2
   } = getPortTuple();
   // @ts-ignore
-  await invokeAndTransfer('IpcParent.create', {
+  await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url,
     name: name,
@@ -1624,15 +1318,15 @@ const launchColorPickerWorker = async () => {
   return launchWorker(name, url);
 };
 
-let workerPromise$4;
-const getOrCreate$5 = () => {
-  if (!workerPromise$4) {
-    workerPromise$4 = launchColorPickerWorker();
+let workerPromise$3;
+const getOrCreate$4 = () => {
+  if (!workerPromise$3) {
+    workerPromise$3 = launchColorPickerWorker();
   }
-  return workerPromise$4;
+  return workerPromise$3;
 };
 const invoke$8 = async (method, ...params) => {
-  const worker = await getOrCreate$5();
+  const worker = await getOrCreate$4();
   return await worker.invoke(method, ...params);
 };
 
@@ -1676,28 +1370,26 @@ const map$1 = Object.create(null);
 const set$7 = (id, widget) => {
   map$1[id] = widget;
 };
-const get$5 = id => {
+const get$6 = id => {
   return map$1[id];
 };
 
 const getModule = id => {
-  return get$5(id);
+  return get$6(id);
 };
 
 const applyWidgetChange = async (editor, widget, changes) => {
   const module = getModule(widget.id);
   if (changes.length === 1 && changes[0].origin === EditorType && module.handleEditorType) {
-    const newState = await module.handleEditorType(widget.newState);
+    const newState = await module.handleEditorType(editor);
     return {
-      ...widget,
-      newState
+      ...newState
     };
   }
   if (changes.length === 1 && changes[0].origin === DeleteLeft && module.handleEditorDeleteLeft) {
-    const newState = await module.handleEditorDeleteLeft(widget.newState);
+    const newState = await module.handleEditorDeleteLeft(editor);
     return {
-      ...widget,
-      newState
+      ...newState
     };
   }
   return widget;
@@ -1708,18 +1400,15 @@ const applyWidgetChanges = async (editor, changes) => {
   if (widgets.length === 0) {
     return widgets;
   }
-  const newWidgets = [];
+  let latestEditor = editor;
   for (const widget of widgets) {
-    const newWidget = await applyWidgetChange(editor, widget, changes);
-    if (newWidget.newState) {
-      newWidgets.push(newWidget);
-    }
+    latestEditor = await applyWidgetChange(editor, widget, changes);
   }
-  return newWidgets;
+  return latestEditor;
 };
 
 const editors = Object.create(null);
-const get$4 = id => {
+const get$5 = id => {
   number(id);
   return editors[id];
 };
@@ -1944,7 +1633,7 @@ const has = languageId => {
 const set$4 = (languageId, tokenizer) => {
   state$7.tokenizers[languageId] = tokenizer;
 };
-const get$3 = languageId => {
+const get$4 = languageId => {
   return state$7.tokenizers[languageId];
 };
 const isPending = languageId => {
@@ -1955,7 +1644,7 @@ const tokenMaps = Object.create(null);
 const set$3 = (languageId, tokenMap) => {
   tokenMaps[languageId] = tokenMap;
 };
-const get$2 = languageId => {
+const get$3 = languageId => {
   return tokenMaps[languageId] || {};
 };
 
@@ -1992,7 +1681,7 @@ const loadTokenizer = async (languageId, tokenizePath) => {
 };
 const getTokenizer = languageId => {
   if (has(languageId)) {
-    return get$3(languageId);
+    return get$4(languageId);
   }
   if (isPending(languageId)) {
     return TokenizePlainText;
@@ -2004,7 +1693,7 @@ const tokenizers = Object.create(null);
 const set$2 = (id, value) => {
   tokenizers[id] = value;
 };
-const get$1 = id => {
+const get$2 = id => {
   return tokenizers[id] || TokenizePlainText;
 };
 
@@ -2074,7 +1763,7 @@ const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
     lines,
     languageId
   } = editor;
-  const tokenizer = get$1(tokenizerId);
+  const tokenizer = get$2(tokenizerId);
   const {
     hasArrayReturn,
     tokenizeLine,
@@ -2160,11 +1849,12 @@ const loadTokenizers = async languageIds => {
   }
 };
 
+const Dot = '.';
+const DoubleQuote$1 = '"';
 const EmptyString = '';
 const NewLine = '\n';
 const Space = ' ';
 const Tab = '\t';
-const DoubleQuote$1 = '"';
 
 const normalizeText = (text, normalize, tabSize) => {
   if (normalize) {
@@ -2543,7 +2233,7 @@ const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLine
     decorations,
     languageId
   } = editor;
-  const tokenMap = get$2(languageId);
+  const tokenMap = get$3(languageId);
   let offset = minLineOffset;
   const tabSize = 2;
   for (let i = minLineY; i < maxLineY; i++) {
@@ -2751,7 +2441,12 @@ const getTabCount = string => {
   return count;
 };
 
-const measureTextWidthFast = (text, charWidth) => {
+const RE_ASCII = /^[\p{ASCII}]*$/u;
+const isAscii = line => {
+  return RE_ASCII.test(line);
+};
+
+const measureTextWidthFast = async (text, charWidth) => {
   return text.length * charWidth;
 };
 
@@ -2775,7 +2470,7 @@ const createMeasureContext = () => {
 const state$6 = {
   ctx: undefined
 };
-const getOrCreate$4 = createCtx => {
+const getOrCreate$3 = createCtx => {
   if (state$6.ctx) {
     return state$6.ctx;
   }
@@ -2784,13 +2479,13 @@ const getOrCreate$4 = createCtx => {
 };
 
 const getContext = () => {
-  const ctx = getOrCreate$4(createMeasureContext);
+  const ctx = getOrCreate$3(createMeasureContext);
   return ctx;
 };
 
 // TODO for text editor, could dispose measuring canvas after editor has been initialized to free up offscreencanvas space
 
-const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+const measureTextWidthSlow = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   string(text);
   number(fontWeight);
   number(fontSize);
@@ -2812,14 +2507,18 @@ const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpac
   return width;
 };
 
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  if (isMonoSpaceFont) {
-    return measureTextWidthFast(text, charWidth);
+const measureTextWidth = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  // TODO maybe have a property for the whole text document
+  // whether the document is ascii or not
+  // so that it doesn't need to be checked on every cursor change
+  // or scroll position change
+  if (isMonoSpaceFont && isAscii(text)) {
+    return await measureTextWidthFast(text, charWidth);
   }
-  return measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
+  return await measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
 };
 
-const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
+const getX = async (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
   if (!line) {
     return 0;
   }
@@ -2841,7 +2540,8 @@ const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, l
   const normalizedLine = normalizeText(line, normalize, tabSize);
   const tabCount = getTabCount(line.slice(0, column));
   const partialText = normalizedLine.slice(0, column + tabCount);
-  return measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth) - halfCursorWidth + difference;
+  const textWidth = await measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth);
+  return textWidth - halfCursorWidth + difference;
 };
 
 const getY = (row, minLineY, rowHeight) => {
@@ -2958,7 +2658,7 @@ const getSelectionArray = visibleSelections => {
   }
   return selectionsArray;
 };
-const getVisible = editor => {
+const getVisible = async editor => {
   const visibleCursors = [];
   const visibleSelections = [];
   // // TODO binary search
@@ -2991,7 +2691,7 @@ const getVisible = editor => {
     const relativeEndLineRow = selectionEndRow - minLineY;
     const endLineDifference = differences[relativeEndLineRow];
     const endLine = lines[selectionEndRow];
-    const endLineEndX = getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
+    const endLineEndX = await getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
     const endLineY = getY(selectionEndRow, minLineY, rowHeight);
     if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
       visibleCursors.push(endLineEndX, endLineY);
@@ -3001,7 +2701,7 @@ const getVisible = editor => {
     const startLineYRelative = selectionStartRow - minLineY;
     const startLineDifference = differences[startLineYRelative];
     if (selectionStartRow === selectionEndRow) {
-      const startX = getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+      const startX = await getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
       if (reversed) {
         visibleCursors.push(startX, endLineY);
       } else if (endLineEndX >= 0) {
@@ -3012,8 +2712,8 @@ const getVisible = editor => {
     } else {
       if (selectionStartRow >= minLineY) {
         const startLine = lines[selectionStartRow];
-        const startLineStartX = getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-        const startLineEndX = getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineStartX = await getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineEndX = await getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
         const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
         const selectionWidth = startLineEndX - startLineStartX;
         if (reversed) {
@@ -3028,7 +2728,7 @@ const getVisible = editor => {
         const currentLineY = getY(i, minLineY, rowHeight);
         const relativeLine = i - minLineY;
         const difference = differences[relativeLine];
-        const selectionWidth = getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
+        const selectionWidth = await getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
         visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
       }
       if (selectionEndRow <= maxLineY) {
@@ -3177,10 +2877,10 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
   };
   set$6(editor.uid, editor, newEditor);
   const incrementalEdits = await getIncrementalEdits(editor, newEditor);
-  const newWidgets = await applyWidgetChanges(newEditor, changes);
+  const editorWithNewWidgets = await applyWidgetChanges(newEditor, changes);
   const newEditor2 = {
     ...newEditor,
-    widgets: newWidgets,
+    ...editorWithNewWidgets,
     incrementalEdits
   };
   if (incrementalEdits !== emptyIncrementalEdits) {
@@ -3342,6 +3042,36 @@ const setText = (editor, text) => {
   };
 };
 
+const emptyEditor = {
+  textInfos: [],
+  differences: [],
+  uri: '',
+  languageId: '',
+  // TODO use numeric language id?
+  lines: [],
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  tokenizerId: 0,
+  minLineY: 0,
+  decorations: [],
+  embeds: [],
+  deltaX: 0,
+  focused: false,
+  deltaY: 0,
+  scrollBarHeight: 0,
+  longestLineWidth: 0,
+  maxLineY: 0,
+  undoStack: [],
+  lineCache: [],
+  selections: new Uint32Array(),
+  diagnostics: [],
+  highlightedLine: -1,
+  debugEnabled: false,
+  incrementalEdits: emptyIncrementalEdits
+};
+
 const HoverExecute = 'ExtensionHostHover.execute';
 const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompletionProvider';
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
@@ -3359,8 +3089,71 @@ const FocusEditorRename$1 = 11;
 const SourceActions = 38;
 const FocusCodeGenerator = 52;
 
-const measureCharacterWidth = (fontWeight, fontSize, fontFamily, letterSpacing) => {
-  return measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
+const getFileExtensionIndex = file => {
+  string(file);
+  return file.lastIndexOf(Dot);
+};
+const getNthFileExtension = (file, startIndex) => {
+  return file.lastIndexOf(Dot, startIndex);
+};
+
+// TODO merge all of this with extension host languages module
+
+const getLanguageByExtension = (languages, extensionLower) => {
+  for (const language of languages) {
+    if (language && language.extensions && Array.isArray(language.extensions) && language.extensions.includes(extensionLower)) {
+      return language.id;
+    }
+  }
+  return '';
+};
+const getLanguageByFileName = (languages, fileNameLower) => {
+  for (const language of languages) {
+    if (language && language.fileNames && Array.isArray(language.fileNames) && language.fileNames.includes(fileNameLower)) {
+      return language.id;
+    }
+  }
+  return '';
+};
+const getLanguageId$1 = (uri, languages) => {
+  string(uri);
+  // TODO this is inefficient for icon theme, as file extension is computed twice
+  // maybe icon theme should get a slimmed down version of languages so that it can internally compute
+  // the language id
+  const extensionIndex = getFileExtensionIndex(uri);
+  const extension = uri.slice(extensionIndex);
+  const extensionLower = extension.toLowerCase();
+  const candidate1 = getLanguageByExtension(languages, extensionLower);
+  if (candidate1) {
+    return candidate1;
+  }
+  const fileNameLower = uri.toLowerCase();
+  const secondExtensionIndex = getNthFileExtension(uri, extensionIndex - 1);
+  const secondExtension = uri.slice(secondExtensionIndex);
+  const candidate2 = getLanguageByExtension(languages, secondExtension);
+  if (candidate2) {
+    return candidate2;
+  }
+  const candidate3 = getLanguageByFileName(languages, fileNameLower);
+  if (candidate3) {
+    return candidate3;
+  }
+  return 'unknown';
+};
+
+const getLanguages = async () => {
+  // @ts-ignore
+  const languages = await invoke$6('Languages.getLanguages');
+  return languages;
+};
+
+const measureCharacterWidth = async (fontWeight, fontSize, fontFamily, letterSpacing) => {
+  return await measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
+};
+
+const get$1 = async key => {
+  const value = await invoke$a('Preferences.get', key);
+  return value;
 };
 
 const OnDiagnostic = 'onDiagnostic';
@@ -3394,7 +3187,7 @@ const getDiagnosticType = diagnostic => {
   return diagnostic.type;
 };
 
-const getVisibleDiagnostics = (editor, diagnostics) => {
+const getVisibleDiagnostics = async (editor, diagnostics) => {
   const visibleDiagnostics = [];
   const {
     width,
@@ -3419,7 +3212,7 @@ const getVisibleDiagnostics = (editor, diagnostics) => {
     const diagnosticWidth = columnDelta * charWidth;
     const endLineDifference = 0;
     const halfCursorWidth = 0;
-    const x = getX(lines[rowIndex], columnIndex, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, charWidth, endLineDifference);
+    const x = await getX(lines[rowIndex], columnIndex, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, charWidth, endLineDifference);
     const y = getY(rowIndex, minLineY, rowHeight) - rowHeight;
     visibleDiagnostics.push({
       x,
@@ -3447,11 +3240,11 @@ const updateDiagnostics = async newState => {
     // @ts-ignore
     await invoke$6(TextDocumentSyncFull, newState.uri, newState.id, newState.languageId, content);
     const diagnostics = await executeDiagnosticProvider(newState);
-    const latest = get$4(newState.id);
+    const latest = get$5(newState.id);
     if (!latest) {
       return newState;
     }
-    const decorations = getVisibleDiagnostics(latest.newState, diagnostics);
+    const decorations = await getVisibleDiagnostics(latest.newState, diagnostics);
     const newEditor = {
       ...latest.newState,
       diagnostics,
@@ -3459,7 +3252,7 @@ const updateDiagnostics = async newState => {
     };
     set$6(newState.id, latest.oldState, newEditor);
     // @ts-ignore
-    await invoke$9('Editor.rerender', newState.id);
+    await invoke$a('Editor.rerender', newState.id);
     return newEditor;
   } catch (error) {
     // @ts-ignore
@@ -3471,35 +3264,6 @@ const updateDiagnostics = async newState => {
   }
 };
 
-const emptyEditor = {
-  textInfos: [],
-  differences: [],
-  uri: '',
-  languageId: '',
-  // TODO use numeric language id?
-  lines: [],
-  x: 0,
-  y: 0,
-  width: 0,
-  height: 0,
-  tokenizerId: 0,
-  minLineY: 0,
-  decorations: [],
-  embeds: [],
-  deltaX: 0,
-  focused: false,
-  deltaY: 0,
-  scrollBarHeight: 0,
-  longestLineWidth: 0,
-  maxLineY: 0,
-  undoStack: [],
-  lineCache: [],
-  selections: new Uint32Array(),
-  diagnostics: [],
-  highlightedLine: -1,
-  debugEnabled: false,
-  incrementalEdits: emptyIncrementalEdits
-};
 const createEditor = async ({
   id,
   content,
@@ -3533,67 +3297,71 @@ const createEditor = async ({
 }) => {
   number(id);
   string(content);
-  const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
+  // TODO support overwriting language id by setting it explicitly or via settings
+  const charWidth = await measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
+  const languages = await getLanguages();
+  const computedlanguageId = getLanguageId$1(uri, languages);
   const editor = {
-    textInfos: [],
-    uri,
-    isAutoClosingBracketsEnabled,
-    isAutoClosingTagsEnabled,
-    isAutoClosingQuotesEnabled,
-    isQuickSuggestionsEnabled,
+    charWidth,
+    columnWidth: 0,
+    completionState: '',
     completionTriggerCharacters,
-    savedSelections,
-    languageId,
-    x,
-    y,
-    width,
-    height,
-    tokenizerId: 0,
-    minLineY: 0,
-    maxLineY: 0,
-    lines: [],
-    undoStack: [],
-    lineCache: [],
-    selections: new Uint32Array(),
-    diagnostics: [],
+    completionUid: 0,
+    cursorWidth: 2,
     decorations: [],
-    primarySelectionIndex: 0,
     deltaX: 0,
     deltaY: 0,
-    numberOfVisiblelines: 0,
-    finalY: 0,
+    diagnostics: [],
+    diagnosticsEnabled,
+    differences: [],
     finalDeltaY: 0,
-    columnWidth: 0,
-    rowHeight,
-    scrollBarWidth: 0,
-    scrollBarHeight: 0,
-    validLines: [],
-    invalidStartIndex: 0,
+    finalY: 0,
     focused: false,
-    handleOffsetX: 0,
-    itemHeight: 20,
+    focusKey: Empty,
     fontFamily,
-    fontWeight,
-    tabSize,
     fontSize,
-    cursorWidth: 2,
-    completionState: '',
+    fontWeight,
+    handleOffsetX: 0,
+    height,
+    id,
+    incrementalEdits: emptyIncrementalEdits,
+    invalidStartIndex: 0,
+    isAutoClosingBracketsEnabled,
+    isAutoClosingQuotesEnabled,
+    isAutoClosingTagsEnabled,
+    isMonospaceFont,
+    isQuickSuggestionsEnabled,
+    itemHeight: 20,
+    languageId: computedlanguageId,
+    letterSpacing,
+    lineCache: [],
+    lineNumbers,
+    lines: [],
     longestLineWidth: 0,
+    maxLineY: 0,
     minimumSliderSize: 20,
-    differences: [],
-    completionUid: 0,
-    lineNumbers,
+    minLineY: 0,
+    numberOfVisiblelines: 0,
     numberOfVisibleLines: 0,
-    isMonospaceFont,
-    letterSpacing,
-    charWidth,
+    primarySelectionIndex: 0,
+    rowHeight,
+    savedSelections,
+    scrollBarHeight: 0,
+    scrollBarWidth: 0,
+    selections: new Uint32Array(),
+    tabSize,
+    textInfos: [],
+    tokenizerId: 0,
     uid: id,
-    id,
+    undoStack: [],
+    uri,
+    validLines: [],
     widgets: [],
-    focusKey: Empty,
-    diagnosticsEnabled,
-    incrementalEdits: emptyIncrementalEdits
+    width,
+    x,
+    y
   };
+
   // TODO avoid creating intermediate editors here
   const newEditor1 = setBounds(editor, x, y, width, height, 9);
   const newEditor2 = setText(newEditor1, content);
@@ -3628,6 +3396,12 @@ const createEditor = async ({
   if (diagnosticsEnabled) {
     await updateDiagnostics(newEditor4);
   }
+  const completionsOnTypeRaw = await get$1('editor.completionsOnType');
+  const completionsOnType = Boolean(completionsOnTypeRaw);
+  set$6(id, emptyEditor, {
+    ...newEditor4,
+    completionsOnType
+  });
 };
 
 // @ts-ignore
@@ -3824,9 +3598,9 @@ const editorReplaceSelections = (editor, replacement, origin) => {
   return replaceRange(editor, selections, replacement, origin);
 };
 
-const getAccurateColumnIndexAscii = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
+const getAccurateColumnIndexAscii = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
   for (let i = guess; i < line.length; i++) {
-    const width = measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    const width = await measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
     if (eventX - width < averageCharWidth / 2) {
       return i;
     }
@@ -3873,14 +3647,13 @@ const create$8 = () => {
   };
 };
 
-// @ts-ignore
-const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
+const getAccurateColumnIndexUnicode = async (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
   const segmenter = create$8();
   const segments = segmenter.getSegments(line);
   const isMonospaceFont = false;
   const charWidth = 0;
   for (const segment of segments) {
-    const width = measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    const width = await measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
     if (eventX - width < averageCharWidth) {
       return segment.index;
     }
@@ -3888,18 +3661,10 @@ const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fo
   return line.length;
 };
 
-const RE_ASCII = /^[\p{ASCII}]*$/u;
-const isAscii = line => {
-  return RE_ASCII.test(line);
-};
-
-// @ts-ignore
 const guessOffset = (eventX, averageCharWidth) => {
   const guess = Math.round(eventX / averageCharWidth);
   return guess;
 };
-
-// @ts-ignore
 const normalizeGuess = (line, guess, tabSize) => {
   let normalizedGuess = guess;
   for (let i = 0; i < guess; i++) {
@@ -3909,9 +3674,7 @@ const normalizeGuess = (line, guess, tabSize) => {
   }
   return normalizedGuess;
 };
-
-// @ts-ignore
-const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
+const getAccurateColumnIndex = async (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
   string(line);
   number(fontWeight);
   number(fontSize);
@@ -3927,18 +3690,18 @@ const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSp
   const normalizedGuess = normalizeGuess(line, guess, tabSize);
   const text = line.slice(0, normalizedGuess);
   const normalizedText = normalizeText(text, normalize, tabSize);
-  const actual = measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  const actual = await measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
   const isAscii$1 = isAscii(line);
   if (isAscii$1) {
     if (Math.abs(eventX - actual) < charWidth / 2) {
       return normalizedGuess;
     }
-    return getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    return await getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
   }
-  return getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
+  return await getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
 };
 
-const at = (editor, eventX, eventY) => {
+const at = async (editor, eventX, eventY) => {
   object(editor);
   number(eventX);
   number(eventY);
@@ -3964,7 +3727,7 @@ const at = (editor, eventX, eventY) => {
   }
   const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
   const line = lines[clampedRowIndex];
-  const columnIndex = getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
+  const columnIndex = await getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
   return {
     rowIndex: clampedRowIndex,
     columnIndex
@@ -4020,7 +3783,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
   const y$1 = y(editor, rowIndex);
   const displayErrorMessage = message;
   // @ts-ignore
-  await invoke$9('Editor.showOverlayMessage', editor, 'Viewlet.send', editor.uid, 'showOverlayMessage', x$1, y$1, displayErrorMessage);
+  await invoke$a('Editor.showOverlayMessage', editor, 'Viewlet.send', editor.uid, 'showOverlayMessage', x$1, y$1, displayErrorMessage);
   if (!isError) {
     const handleTimeout = () => {
       editorHideMessage(editor);
@@ -4077,7 +3840,7 @@ const braceCompletion = async (editor, text) => {
     // @ts-ignore
     const offset = offsetAt(editor, editor.cursor);
     // @ts-ignore
-    const result = await invoke$9('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
+    const result = await invoke$a('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
     if (result) {
       const closingBrace = getMatchingClosingBrace$1(text);
       const insertText = text + closingBrace;
@@ -4167,15 +3930,15 @@ const launchRenameWorker = async () => {
   return rpc;
 };
 
-let workerPromise$3;
-const getOrCreate$3 = () => {
-  if (!workerPromise$3) {
-    workerPromise$3 = launchRenameWorker();
+let workerPromise$2;
+const getOrCreate$2 = () => {
+  if (!workerPromise$2) {
+    workerPromise$2 = launchRenameWorker();
   }
-  return workerPromise$3;
+  return workerPromise$2;
 };
 const invoke$5 = async (method, ...params) => {
-  const worker = await getOrCreate$3();
+  const worker = await getOrCreate$2();
   return await worker.invoke(method, ...params);
 };
 
@@ -4194,7 +3957,7 @@ const closeRename = async editor => {
   }
   const renameWidget = widgets[renameWidgetIndex];
   await invoke$5('Rename.close', renameWidget.newState.uid);
-  const latest = get$4(uid);
+  const latest = get$5(uid);
   const {
     newState
   } = latest;
@@ -4345,7 +4108,7 @@ const compositionEnd = (editor, data) => {
 const writeText = async text => {
   try {
     string(text);
-    await invoke$9('ClipBoard.writeText', /* text */text);
+    await invoke$a('ClipBoard.writeText', /* text */text);
   } catch (error) {
     throw new VError(error, 'Failed to write text to clipboard');
   }
@@ -4982,7 +4745,7 @@ const deleteWordRight = editor => {
 
 const findAllReferences = async editor => {
   // @ts-ignore
-  await invoke$9('SideBar.show', 'References', /* focus */true);
+  await invoke$a('SideBar.show', 'References', /* focus */true);
   return editor;
 };
 
@@ -5070,7 +4833,7 @@ const getWordBefore = (editor, rowIndex, columnIndex) => {
 // @ts-ignore
 const getDefinition = async (editor, offset) => {
   // @ts-ignore
-  const definition = await invoke$9('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
+  const definition = await invoke$a('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
   return definition;
 };
 
@@ -5249,7 +5012,7 @@ const goTo = async ({
       endRowIndex: definition.endRowIndex,
       endColumnIndex: definition.endColumnIndex
     };
-    await invoke$9(/* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
+    await invoke$a(/* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
     return editor;
   } catch (error) {
     // TODO if editor is already disposed at this point, do nothing
@@ -5327,7 +5090,7 @@ const getNoLocationFoundMessage = info => {
 
 const getTypeDefinition = async (editor, offset) => {
   // @ts-ignore
-  const definition = await invoke$9('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
+  const definition = await invoke$a('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
   return definition;
 };
 
@@ -5482,7 +5245,7 @@ const handleClickAtPosition = async (editor, modifier, rowIndex, columnIndex) =>
 const Editor = 3;
 
 const handleContextMenu = async (editor, button, x, y) => {
-  await invoke$9(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
+  await invoke$a(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
   return editor;
 };
 
@@ -5511,8 +5274,8 @@ const selectWord = (editor, rowIndex, columnIndex) => {
   return scheduleSelections(editor, newSelections);
 };
 
-const handleDoubleClick = (editor, modifier, x, y) => {
-  const position = at(editor, x, y);
+const handleDoubleClick = async (editor, modifier, x, y) => {
+  const position = await at(editor, x, y);
   return selectWord(editor, position.rowIndex, position.columnIndex);
 };
 
@@ -5537,7 +5300,7 @@ const handleSingleClick = async (editor, modifier, x, y) => {
   number(modifier);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   return handleClickAtPosition(editor, modifier, position.rowIndex, position.columnIndex);
 };
 
@@ -5621,7 +5384,7 @@ const onHoverIdle = async () => {
     y,
     editor
   } = get();
-  at(editor, x, y);
+  await at(editor, x, y);
   await showHover$1();
 };
 const hoverDelay = 300;
@@ -5658,7 +5421,7 @@ const handleMouseMoveWithAltKey = async (editor, x, y) => {
   object(editor);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   try {
     const definition = await getDefinition(editor, documentOffset);
@@ -6090,7 +5853,7 @@ const indentMore = editor => {
 
 const getLanguageConfiguration = async editor => {
   // @ts-ignore
-  return invoke$9('Languages.getLanguageConfiguration', {
+  return invoke$a('Languages.getLanguageConfiguration', {
     uri: editor.uri,
     languageId: editor.languageId
   });
@@ -6213,8 +5976,8 @@ const moveRectangleSelection = (editor, position) => {
 };
 
 // @ts-ignore
-const moveRectangleSelectionPx = (editor, x, y) => {
-  at(editor, x, y);
+const moveRectangleSelectionPx = async (editor, x, y) => {
+  await at(editor, x, y);
 };
 
 const LessThan = -1;
@@ -6349,11 +6112,11 @@ const continueScrollingAndMovingSelection = async () => {
 };
 
 // @ts-ignore
-const moveSelectionPx = (editor, x, y) => {
+const moveSelectionPx = async (editor, x, y) => {
   object(editor);
   number(x);
   number(y);
-  const position = at(editor, x, y);
+  const position = await at(editor, x, y);
   if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
     requestAnimationFrame(continueScrollingAndMovingSelection);
     setEditor(editor);
@@ -6432,25 +6195,10 @@ const create$4 = () => {
   return completionWidget;
 };
 
-const launchCompletionWorker = async () => {
-  const name = 'Completion Worker';
-  const url = 'completionWorkerMain.js';
-  const intializeCommand = 'Completions.initialize';
-  const rpc = await launchWorker(name, url, intializeCommand);
-  return rpc;
-};
-
-let workerPromise$2;
-const getOrCreate$2 = () => {
-  if (!workerPromise$2) {
-    workerPromise$2 = launchCompletionWorker();
-  }
-  return workerPromise$2;
-};
-const invoke$4 = async (method, ...params) => {
-  const worker = await getOrCreate$2();
-  return await worker.invoke(method, ...params);
-};
+const {
+  setFactory: setFactory$1,
+  invoke: invoke$4
+} = createLazyRpc(CompletionWorker);
 
 const newStateGenerator$4 = async (state, parentUid) => {
   const {
@@ -6462,7 +6210,7 @@ const newStateGenerator$4 = async (state, parentUid) => {
   } = state;
   const {
     newState
-  } = get$4(parentUid);
+  } = get$5(parentUid);
   const {
     languageId
   } = newState;
@@ -6515,18 +6263,18 @@ const launchFindWidgetWorker = async () => {
 const rpcId = 9002;
 const launch = async () => {
   // TODO race condition
-  if (get$6(rpcId)) {
+  if (get$7(rpcId)) {
     return;
   }
   const rpc = await launchFindWidgetWorker();
-  set$c(rpcId, rpc);
+  set$b(rpcId, rpc);
 };
 const invoke$3 = async (method, ...params) => {
-  const rpc = get$6(rpcId);
+  const rpc = get$7(rpcId);
   return await rpc.invoke(method, ...params);
 };
 const dispose = async () => {
-  const rpc = get$6(rpcId);
+  const rpc = get$7(rpcId);
   remove$8(rpcId);
   if (rpc) {
     await rpc.dispose();
@@ -6538,7 +6286,7 @@ const dispose = async () => {
 };
 
 const getEditor = editorUid => {
-  const instance = get$4(editorUid);
+  const instance = get$5(editorUid);
   if (!instance) {
     throw new Error(`editor ${editorUid} not found`);
   }
@@ -6632,7 +6380,7 @@ const newStateGenerator$2 = async (state, parentUid) => {
   } = state;
   const {
     newState
-  } = get$4(parentUid);
+  } = get$5(parentUid);
   const {
     languageId
   } = newState;
@@ -6686,7 +6434,7 @@ const pasteText = (editor, text) => {
 
 const paste = async editor => {
   // @ts-ignore
-  const text = await invoke$9('ClipBoard.readText');
+  const text = await invoke$a('ClipBoard.readText');
   string(text);
   return pasteText(editor, text);
 };
@@ -6815,6 +6563,10 @@ const handleError = async error => {
   }
 };
 
+// @ts-ignore
+// @ts-ignore
+// @ts-ignore
+
 // @ts-ignore
 const getNewEditor = async editor => {
   return editor;
@@ -6828,7 +6580,7 @@ const save = async editor => {
     } = editor;
     const newEditor = await getNewEditor(editor);
     const content = getText$1(newEditor);
-    await invoke$9('FileSystem.writeFile', uri, content);
+    await invoke$a('FileSystem.writeFile', uri, content);
     return newEditor;
   } catch (error) {
     // @ts-ignore
@@ -7135,7 +6887,7 @@ const selectInsideString = editor => {
 
 const getNewSelections = async (editor, selections) => {
   // @ts-ignore
-  const newSelections = await invoke$9('ExtensionHostSelection.executeGrowSelection', editor, selections);
+  const newSelections = await invoke$a('ExtensionHostSelection.executeGrowSelection', editor, selections);
   if (newSelections.length === 0) {
     return selections;
   }
@@ -7522,7 +7274,7 @@ const newStateGenerator$1 = async (state, parentUid) => {
   } = state;
   const {
     newState
-  } = get$4(parentUid);
+  } = get$5(parentUid);
   const {
     languageId
   } = newState;
@@ -7542,7 +7294,7 @@ const showHover3 = async editor => {
 
 const EditorHover = 'EditorHover';
 const showHover = async state => {
-  await invoke$9('Viewlet.openWidget', EditorHover);
+  await invoke$a('Viewlet.openWidget', EditorHover);
   return state;
 };
 
@@ -7606,7 +7358,7 @@ const newStateGenerator = async (state, parentUid) => {
   } = state;
   const {
     newState
-  } = get$4(parentUid);
+  } = get$5(parentUid);
   const {
     languageId
   } = newState;
@@ -8131,9 +7883,16 @@ const toggleComment = async editor => {
   }
 };
 
-const type = (editor, text) => {
+const type = async (editor, text) => {
   const changes = editorReplaceSelections(editor, [text], EditorType);
-  return scheduleDocumentAndCursorsSelections(editor, changes);
+  const newEditor = await scheduleDocumentAndCursorsSelections(editor, changes);
+  if (newEditor.completionsOnType) {
+    // TODO if completion widget is already visible, advance
+    // TODO if character typed is space or tab or separator, close completions
+    const withCompletion = await openCompletion(newEditor);
+    return withCompletion;
+  }
+  return newEditor;
 };
 
 const Slash = '/';
@@ -8212,7 +7971,7 @@ const typeWithAutoClosingQuote = (editor, text) => {
 const typeWithAutoClosingTag = async (editor, text) => {
   const offset = offsetAt(editor, editor.selections[0], editor.selections[1]);
   // @ts-ignore
-  const result = await invoke$9('ExtensionHostClosingTagCompletion.executeClosingTagProvider', editor, offset, text);
+  const result = await invoke$a('ExtensionHostClosingTagCompletion.executeClosingTagProvider', editor, offset, text);
   if (!result) {
     const changes = editorReplaceSelections(editor, [text], EditorType);
     return scheduleDocumentAndCursorsSelections(editor, changes);
@@ -8538,7 +8297,7 @@ const createFn = (key, name, widgetId) => {
       ...state,
       commands
     };
-    const latest = get$4(editor.uid).newState;
+    const latest = get$5(editor.uid).newState;
     const newEditor = updateWidget(latest, widgetId, newState);
     return newEditor;
   };
@@ -8832,7 +8591,7 @@ const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) =>
 };
 const getEditorHoverInfo = async (editorUid, position) => {
   number(editorUid);
-  const instance = get$4(editorUid);
+  const instance = get$5(editorUid);
   const editor = instance.newState;
   const {
     selections
@@ -9228,12 +8987,12 @@ const getEditorSourceActions = async editorId => {
   }
   const {
     newState
-  } = get$4(editorId);
+  } = get$5(editorId);
   const {
     languageId
   } = newState;
   // @ts-ignore
-  const allActions = await invoke$9('GetEditorSourceActions.getEditorSourceActions');
+  const allActions = await invoke$a('GetEditorSourceActions.getEditorSourceActions');
   const filtered = filterActions(allActions, languageId);
   return filtered;
 };
@@ -9256,14 +9015,14 @@ const getWordAtOffset = editor => {
 };
 
 const setFocus = async focusKey => {
-  await invoke$9('Focus.setFocus', focusKey);
+  await invoke$a('Focus.setFocus', focusKey);
 };
 const unsetAdditionalFocus = async focusKey => {
   if (!focusKey) {
     return;
   }
   // @ts-ignore
-  await invoke$9('Focus.removeAdditionalFocus', focusKey);
+  await invoke$a('Focus.removeAdditionalFocus', focusKey);
 };
 
 const FocusEditor = 12;
@@ -9804,7 +9563,7 @@ const getProblems = async () => {
   const keys = getKeys$1();
   const editors = keys.map(key => {
     const numericKey = parseInt(key);
-    const editor = get$4(numericKey);
+    const editor = get$5(numericKey);
     return editor;
   });
   const newEditors = editors.map(editor => editor.newState);
@@ -9919,7 +9678,7 @@ const handleMessagePort = async (port, rpcId) => {
     commandMap: {}
   });
   if (rpcId) {
-    set$c(rpcId, rpc);
+    set$b(rpcId, rpc);
   }
 };
 
@@ -9952,7 +9711,7 @@ const getWidgetName = widgetId => {
 const saveWidgetState = async keys => {
   const savedStates = Object.create(null);
   for (const key of keys) {
-    const editor = get$4(parseInt(key));
+    const editor = get$5(parseInt(key));
     const {
       widgets
     } = editor.newState;
@@ -9971,7 +9730,7 @@ const restoreWidgetState = async (keys, savedStates) => {
   const newEditors = [];
   for (const key of keys) {
     const editorUid = parseInt(key);
-    const editor = get$4(editorUid);
+    const editor = get$5(editorUid);
     const {
       widgets
     } = editor.newState;
@@ -10023,26 +9782,22 @@ const hotReload = async () => {
 
   // TODO ask renderer worker to rerender all editors
   // @ts-ignore
-  await invoke$9(`Editor.rerender`);
+  await invoke$a(`Editor.rerender`);
   isReloading = false;
 };
 
 const sendMessagePortToExtensionHostWorker2 = async (port, initialCommand, rpcId) => {
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, initialCommand, rpcId);
+  await invokeAndTransfer$1('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, initialCommand, rpcId);
 };
 
 const createExtensionHostRpc = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
     const initialCommand = 'HandleMessagePort.handleMessagePort2';
-    // TODO use transfer rpc
-    await sendMessagePortToExtensionHostWorker2(port2, initialCommand, EditorWorker);
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1
+      async send(port) {
+        await sendMessagePortToExtensionHostWorker2(port, initialCommand, EditorWorker);
+      }
     });
     return rpc;
   } catch (error) {
@@ -10055,34 +9810,23 @@ const initializeExtensionHost = async () => {
   set$1(extensionHostRpc);
 };
 
-const sendMessagePortToSyntaxHighlightingWorker = async () => {
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await invokeAndTransfer(
+    await invokeAndTransfer$1(
     // @ts-ignore
-    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort2');
-    return port2;
+    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
   } catch {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await invokeAndTransfer(
+    await invokeAndTransfer$1(
     // @ts-ignore
-    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort');
-    return port2;
+    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
   }
 };
 
 const createSyntaxHighlightingWorkerRpc = async () => {
   try {
-    const port = await sendMessagePortToSyntaxHighlightingWorker();
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port
+      send: sendMessagePortToSyntaxHighlightingWorker
     });
     return rpc;
   } catch (error) {
@@ -10101,7 +9845,16 @@ const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncre
   }
 };
 
+const launchCompletionWorker = async () => {
+  const name = 'Completion Worker';
+  const url = 'completionWorkerMain.js';
+  const intializeCommand = 'Completions.initialize';
+  const rpc = await launchWorker(name, url, intializeCommand);
+  return rpc;
+};
+
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
+  setFactory$1(launchCompletionWorker);
   await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost()]);
 };
 
@@ -10276,21 +10029,21 @@ const getSelectionsVirtualDom = selections => {
 };
 
 const addWidget = widget => {
-  const module = get$5(widget.id);
+  const module = get$6(widget.id);
   if (!module) {
     throw new Error('unsupported widget');
   }
   return module.add(widget);
 };
 const renderWidget = widget => {
-  const module = get$5(widget.id);
+  const module = get$6(widget.id);
   if (!module) {
     throw new Error('unsupported widget');
   }
   return module.render(widget);
 };
 const removeWidget = widget => {
-  const module = get$5(widget.id);
+  const module = get$6(widget.id);
   if (!module) {
     throw new Error('unsupported widget');
   }
@@ -10326,11 +10079,11 @@ const renderSelections = {
   isEqual(oldState, newState) {
     return oldState.selections === newState.selections && oldState.focused === newState.focused && oldState.minLineY === newState.minLineY && oldState.deltaX === newState.deltaX;
   },
-  apply(oldState, newState) {
+  apply: async (oldState, newState) => {
     const {
       cursorInfos,
       selectionInfos
-    } = getVisible(newState);
+    } = await getVisible(newState);
     const cursorsDom = getCursorsVirtualDom(cursorInfos);
     const selectionsDom = getSelectionsVirtualDom(selectionInfos);
     return [/* method */'setSelections', cursorsDom, selectionsDom];
@@ -10471,8 +10224,8 @@ const renderWidgets = {
   multiple: true
 };
 const render$6 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets, renderFocusContext, renderAdditionalFocusContext];
-const renderEditor = id => {
-  const instance = get$4(id);
+const renderEditor = async id => {
+  const instance = get$5(id);
   if (!instance) {
     return [];
   }
@@ -10484,7 +10237,7 @@ const renderEditor = id => {
   set$6(id, newState, newState);
   for (const item of render$6) {
     if (!item.isEqual(oldState, newState)) {
-      const result = item.apply(oldState, newState);
+      const result = await item.apply(oldState, newState);
       // @ts-ignore
       if (item.multiple) {
         commands.push(...result);
@@ -10538,7 +10291,7 @@ const setDebugEnabled = (state, enabled) => {
 };
 
 const invoke = async (method, ...params) => {
-  const worker = get$6(DebugWorker);
+  const worker = get$7(DebugWorker);
   return worker.invoke(method, ...params);
 };
 
@@ -10554,7 +10307,7 @@ const getKey = () => {
 const updateDebugInfo = async debugId => {
   const newInfo = await getDebugHighlight(debugId);
   const key = getKey();
-  const instance = get$4(key);
+  const instance = get$5(key);
   if (!instance) {
     return;
   }
@@ -10568,7 +10321,7 @@ const updateDebugInfo = async debugId => {
   };
   set$6(key, oldState, newEditor);
   // @ts-ignore
-  await invoke$9('Editor.rerender', key);
+  await invoke$a('Editor.rerender', key);
 };
 
 const keep = ['ActivateByEvent.activateByEvent', 'ExtensionHostManagement.activateByEvent', 'Editor.applyEdit2', 'Editor.applyEdits2', 'Editor.closeFind2', 'Editor.closeWidget2', 'Editor.create', 'Editor.getKeyBindings', 'Editor.getSourceActions', 'Editor.getLines2', 'Editor.getPositionAtCursor', 'Editor.getOffsetAtCursor', 'Editor.getQuickPickMenuEntries', 'Editor.getSelections', 'Editor.hotReload', 'Editor.getSelections2', 'Editor.getDiagnostics', 'Editor.getText', 'Editor.getWordAt', 'Editor.getWordAt2', 'Editor.getWordAtOffset2', 'Editor.getUri', 'Editor.getWordBefore', 'Editor.getWordBefore2', 'Editor.offsetAt', 'Editor.render', 'Editor.setSelections2', 'Editor.updateDebugInfo', 'Editor.getLanguageId', 'Editor.getProblems', 'Editor.getKeys', 'Font.ensure', 'HandleMessagePort.handleMessagePort', 'Hover.getHoverInfo', 'Hover.handleSashPointerDown', 'Hover.handleSashPointerMove', 'Hover.handleSashPointerUp', 'Hover.loadContent', 'Hover.render', 'Initialize.initialize', 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker'
@@ -10602,7 +10355,7 @@ const widgetCommands = {
 // TODO only store editor state in editor worker, not in renderer worker also
 
 const wrapCommand = fn => async (editorUid, ...args) => {
-  const oldInstance = get$4(editorUid);
+  const oldInstance = get$5(editorUid);
   const state = oldInstance.newState;
   const newEditor = await fn(state, ...args);
   if (state === newEditor) {
@@ -10613,7 +10366,7 @@ const wrapCommand = fn => async (editorUid, ...args) => {
   // TODO combine neweditor with latest editor?
 
   set$6(editorUid, state, newEditor);
-  const commands = renderEditor(editorUid);
+  const commands = await renderEditor(editorUid);
   return {
     ...newEditor,
     commands
@@ -10869,11 +10622,32 @@ const commandMap = {
 };
 wrapCommands(commandMap);
 
+const send = port => {
+  // @ts-ignore
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const createTextMeasurementWorkerRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create text measurement worker rpc`);
+  }
+};
+
+const {
+  setFactory
+} = createLazyRpc(TextMeasurementWorker);
+
 const listen = async () => {
+  setFactory(createTextMeasurementWorkerRpc);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$8(rpc);
+  set$9(rpc);
 };
 
 const CodeGeneratorInput = 'CodeGeneratorInput';