@lvce-editor/server 0.36.4 → 0.36.6

package/static/{24dc3f9 → 2a3108d}/packages/editor-worker/dist/editorWorkerMain.js

@@ -1,3 +1,23 @@
+const commands = Object.create(null);
+const registerCommand = (key, fn) => {
+  commands[key] = fn;
+};
+const register$1 = commandMap => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute$1 = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
+
 let AssertionError$1 = class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -121,7 +141,7 @@ const IconButtonDisabled = 'IconButtonDisabled';
 const IconButton = 'IconButton';
 const CompletionDetailContent = 'CompletionDetailContent';
 const Diagnostic = 'Diagnostic';
-const FindWidgetReplace$1 = 'FindWidgetReplace';
+const FindWidgetReplace = 'FindWidgetReplace';
 const FindWidgetFind = 'FindWidgetFind';
 const FindWidgetMatchCount = 'FindWidgetMatchCount';
 const FindWidgetRight = 'FindWidgetRight';
@@ -238,9 +258,9 @@ const renderColorPickerDom = {
     return ['Viewlet.setDom2', dom];
   }
 };
-const render$a = [renderColorPickerDom, renderColor$1, renderOffsetX$1];
+const render$b = [renderColorPickerDom, renderColor$1, renderOffsetX$1];
 const renderColorPicker = async (oldState, newState) => {
-  return renderParts(render$a, oldState, newState);
+  return renderParts(render$b, oldState, newState);
 };
 
 // TODO use numeric enum
@@ -575,14 +595,10 @@ const getSelectionPairs = (selections, i) => {
   return [first, second, third, fourth, 0];
 };
 
-const Dash = '-';
-const Dot = '.';
-const EmptyString = '';
-const Space = ' ';
+const EmptyString$1 = '';
+const Space$1 = ' ';
 const Tab = '\t';
-const Underline = '_';
 const DoubleQuote$1 = '"';
-const T = 't';
 
 const getTabCount = string => {
   let count = 0;
@@ -611,15 +627,15 @@ const createMeasureContext = () => {
   return ctx;
 };
 
-const state$b = {
+const state$a = {
   ctx: undefined
 };
 const getOrCreate = createCtx => {
-  if (state$b.ctx) {
-    return state$b.ctx;
+  if (state$a.ctx) {
+    return state$a.ctx;
   }
-  state$b.ctx = createCtx();
-  return state$b.ctx;
+  state$a.ctx = createCtx();
+  return state$a.ctx;
 };
 
 const getContext = () => {
@@ -655,7 +671,7 @@ const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing,
 
 const normalizeText = (text, normalize, tabSize) => {
   if (normalize) {
-    return text.replaceAll(Tab, Space.repeat(tabSize));
+    return text.replaceAll(Tab, Space$1.repeat(tabSize));
   }
   return text;
 };
@@ -1197,14 +1213,14 @@ const set$6 = (id, fn) => {
 const get$6 = id => {
   return state$1$1.callbacks[id];
 };
-const remove$4 = id => {
+const remove$5 = id => {
   delete state$1$1.callbacks[id];
 };
-const state$a = {
+const state$9 = {
   id: 0
 };
 const create$3$1 = () => {
-  return ++state$a.id;
+  return ++state$9.id;
 };
 const warn$1 = (...args) => {
   console.warn(...args);
@@ -1243,7 +1259,7 @@ const resolve = (id, args) => {
     return;
   }
   fn(args);
-  remove$4(id);
+  remove$5(id);
 };
 const create$2$1 = (method, params) => {
   const {
@@ -1435,7 +1451,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(message, errorProperty);
 };
-const create$a = (message, result) => {
+const create$b = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -1444,7 +1460,7 @@ const create$a = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$a(message, resultProperty);
+  return create$b(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -1531,38 +1547,6 @@ const invokeAndTransfer$2 = async (ipc, method, ...params) => {
   return result;
 };
 
-const state$9 = {
-  commands: Object.create(null)
-};
-
-// @ts-ignore
-const registerCommand = (key, fn) => {
-  state$9.commands[key] = fn;
-};
-
-// @ts-ignore
-const registerCommands = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
-};
-
-// @ts-ignore
-const getCommand = key => {
-  return state$9.commands[key];
-};
-
-const processName = 'editor-worker';
-
-// @ts-ignore
-const execute$1 = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`[${processName}] command not found ${command}`);
-  }
-  return fn(...args);
-};
-
 const requiresSocket = () => {
   return false;
 };
@@ -1676,7 +1660,7 @@ const waitForFirstMessage$1 = async port => {
   return event;
 };
 
-const create$9 = async () => {
+const create$a = async () => {
   const {
     port1,
     port2
@@ -1721,7 +1705,7 @@ const wrap$3 = port => {
 
 const IpcParentWithExtensionHostWorker = {
   __proto__: null,
-  create: create$9,
+  create: create$a,
   wrap: wrap$3
 };
 
@@ -1729,7 +1713,7 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
   await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
-const create$8 = async () => {
+const create$9 = async () => {
   const {
     port1,
     port2
@@ -1774,7 +1758,7 @@ const wrap$1 = port => {
 
 const IpcParentWithSyntaxHighlightingWorker = {
   __proto__: null,
-  create: create$8,
+  create: create$9,
   wrap: wrap$1
 };
 
@@ -1782,7 +1766,7 @@ const sendMessagePortToRendererProcess = async port => {
   await invokeAndTransfer('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
 };
 
-const create$7 = async () => {
+const create$8 = async () => {
   const {
     port1,
     port2
@@ -1827,7 +1811,7 @@ const wrap = port => {
 
 const IpcParentWithRendererProcess = {
   __proto__: null,
-  create: create$7,
+  create: create$8,
   wrap
 };
 
@@ -1844,7 +1828,7 @@ const getModule$1 = method => {
   }
 };
 
-const create$6 = async ({
+const create$7 = async ({
   method,
   ...options
 }) => {
@@ -1862,7 +1846,7 @@ const create$6 = async ({
 const createRpc = method => {
   let _ipc;
   const listen = async () => {
-    const ipc = await create$6({
+    const ipc = await create$7({
       method
     });
     handleIpc(ipc);
@@ -2138,7 +2122,7 @@ const getAccurateColumnIndexAscii = (line, guess, averageCharWidth, eventX, font
 const supported = () => {
   return 'Segmenter' in Intl;
 };
-const create$5 = () => {
+const create$6 = () => {
   // @ts-ignore
   const segmenter = new Intl.Segmenter();
   return {
@@ -2176,7 +2160,7 @@ const create$5 = () => {
 
 // @ts-ignore
 const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const segmenter = create$5();
+  const segmenter = create$6();
   const segments = segmenter.getSegments(line);
   const isMonospaceFont = false;
   const charWidth = 0;
@@ -2410,6 +2394,7 @@ const Completion = 'completion';
 const CompletionDetail$1 = 'completionDetail';
 const ColorPicker$1 = 'colorPicker';
 const Find = 'find';
+const Hover = 'hover';
 
 const isCompletionWidget = widget => {
   return widget.id === Completion;
@@ -2442,7 +2427,14 @@ const setAdditionalFocus = async focusKey => {
   await invoke$3('Focus.setAdditionalFocus', focusKey);
 };
 
-const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGenerator) => {
+const setFocus = async focusKey => {
+  if (!focusKey) {
+    return;
+  }
+  await invoke$3('Focus.setFocus', focusKey);
+};
+
+const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGenerator, fullFocus) => {
   const {
     widgets
   } = editor;
@@ -2450,14 +2442,22 @@ const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGe
     return editor;
   }
   const widget = factory();
+  // @ts-ignore
+  widget.newState.editorUid = editor.uid;
   const newState = await newStateGenerator(widget.newState);
+  // @ts-ignore
+  newState.editorUid = editor.uid;
   const latestWidget = {
     ...widget,
     newState
   };
   const newWidgets = [...widgets, latestWidget];
   // TODO avoid side effect, apply focus shift during render
-  await setAdditionalFocus(focusKey);
+  if (fullFocus) {
+    await setFocus(focusKey);
+  } else {
+    await setAdditionalFocus(focusKey);
+  }
   const newEditor = {
     ...editor,
     widgets: newWidgets
@@ -2465,12 +2465,12 @@ const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGe
   return newEditor;
 };
 
-const create$4 = () => {
+const create$5 = () => {
   return Math.random();
 };
 
-const create$3 = () => {
-  const completionUid = create$4();
+const create$4 = () => {
+  const completionUid = create$5();
   const widget = {
     id: ColorPicker$1,
     oldState: {
@@ -2504,16 +2504,20 @@ const FindWidget = 16;
 const EditorCompletion = 9;
 const CompletionDetail = 999;
 const Empty = 0;
-const FindWidgetToggleReplace = 42;
-const FindWidgetReplace = 43;
-const FindWidgetReplaceAll = 46;
-const FindWidgetClose = 47;
-
-const newStateGenerator = state => {
+const FocusFindWidgetToggleReplace = 42;
+const FocusFindWidgetReplace = 43;
+const FocusFindWidgetReplaceButton = 46;
+const FocusFindWidgetReplaceAllButton = 47;
+const FocusFindWidgetCloseButton = 48;
+const FocusFindWidgetNextMatchButton = 49;
+const FocusFindWidgetPreviousMatchButton = 50;
+const FocusEditorHover = 51;
+
+const newStateGenerator$1 = state => {
   return loadContent$3(state);
 };
 const openColorPicker = async editor => {
-  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$3, newStateGenerator);
+  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$4, newStateGenerator$1);
 };
 
 const state$6 = {
@@ -2810,7 +2814,7 @@ const characterLeft = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create$5();
+  const segmenter = create$6();
   const last = segmenter.at(line, columnIndex - 1);
   return columnIndex - last.index;
 };
@@ -2821,12 +2825,12 @@ const characterRight = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create$5();
+  const segmenter = create$6();
   const next = segmenter.at(line, columnIndex);
   return next.segment.length;
 };
 const isWhitespace = char => {
-  return char === Space || char === Tab;
+  return char === Space$1 || char === Tab;
 };
 const lineCharacterStart = (line, columnIndex) => {
   if (line.length === 0) {
@@ -3235,105 +3239,36 @@ const deleteWordLeft = editor => {
   return newEditor;
 };
 
-const deleteWordPartLeft = editor => {
-  const newEditor = editorDeleteHorizontalLeft(editor, wordPartLeft);
-  return newEditor;
-};
-
-const deleteWordPartRight = editor => {
-  return editorDeleteHorizontalRight(editor, wordPartRight);
-};
-
-const deleteWordRight = editor => {
-  return editorDeleteHorizontalRight(editor, wordRight);
-};
-
-const findAllReferences = async editor => {
-  await invoke$3('SideBar.show', 'References', /* focus */true);
-  return editor;
-};
-
-// TODO format should be executed in parallel with saving
-// -> fast save, no need to wait for formatting
-// -> fast formatting, no need to wait for save
-
-// TODO should format on save when closing/switching editor?
-
-// TODO format with cursor
-// TODO should be in editor folder
-
-const format$1 = async editor => {
-  const edits = await invoke$3('Format.format', editor);
-  return edits;
-};
-
-const warn = (...args) => {
-  console.warn(...args);
-};
-const error = (...args) => {
-  console.error(...args);
-};
-
-// @ts-ignore
-const getDocumentEdits = (editor, edits) => {
-  const documentEdits = [];
-  for (const edit of edits) {
-    const start = positionAt(editor, edit.startOffset);
-    const end = positionAt(editor, edit.endOffset);
-    const deleted = getSelectionText(editor, {
-      start,
-      end
-    });
-    const documentEdit = {
-      start,
-      end,
-      inserted: splitLines$2(edit.inserted),
-      deleted,
-      origin: Format
-    };
-    if (documentEdit.inserted.length === 0) {
-      documentEdit.inserted = [''];
-    }
-    documentEdits.push(documentEdit);
-  }
-  return documentEdits;
-};
-
-// @ts-ignore
-const applyDocumentEdits = (editor, edits) => {
-  if (!Array.isArray(edits)) {
-    warn('something is wrong with format on save', edits);
-    return editor;
-  }
-  if (edits.length === 0) {
-    return editor;
-  }
-  const documentEdits = getDocumentEdits(editor, edits);
-  return scheduleDocumentAndCursorsSelections(editor, documentEdits);
-};
-
-const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
-const isFormattingError = error => {
-  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage);
-};
-
-// TODO also format with cursor
-const format = async editor => {
-  try {
-    const edits = await format$1(editor);
-    return applyDocumentEdits(editor, edits);
-  } catch (error) {
-    if (isFormattingError(error)) {
-      console.error('Formatting Error:',
-      // @ts-ignore
-      error.message.slice(expectedErrorMessage.length));
-      return editor;
+const create$3 = () => {
+  const uid = create$5();
+  const widget = {
+    id: Hover,
+    oldState: {
+      uid: uid,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      content: '',
+      diagnostics: [],
+      documentation: '',
+      editorUid: 0,
+      lineInfos: []
+    },
+    newState: {
+      uid: uid,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      content: '',
+      diagnostics: [],
+      documentation: '',
+      editorUid: 0,
+      lineInfos: []
     }
-    console.error(error);
-    const displayErrorMessage = `${error}`;
-    await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
-    return editor;
-  }
+  };
+  return widget;
 };
 
 const RE_WORD_START$1 = /^[\w\-]+/;
@@ -3343,7 +3278,7 @@ const getWordAt$1 = (line, columnIndex) => {
   const matchBefore = before.match(RE_WORD_END$1);
   const after = line.slice(columnIndex);
   const matchAfter = after.match(RE_WORD_START$1);
-  let word = EmptyString;
+  let word = EmptyString$1;
   if (matchBefore) {
     word += matchBefore[0];
   }
@@ -3360,7 +3295,7 @@ const getWordBefore$1 = (line, columnIndex) => {
   if (matchBefore) {
     return matchBefore[0];
   }
-  return EmptyString;
+  return EmptyString$1;
 };
 
 const getWordAt = (editor, rowIndex, columnIndex) => {
@@ -3378,49 +3313,535 @@ const getWordBefore = (editor, rowIndex, columnIndex) => {
   return getWordBefore$1(line, columnIndex);
 };
 
-// @ts-ignore
-const getDefinition = async (editor, offset) => {
-  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
-  return definition;
-};
+const OnCompletion = 'onCompletion';
+const OnHover = 'onHover';
 
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
-  }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+// TODO add tests for this
+const activateByEvent = async event => {
+  await invoke$3('ExtensionHostManagement.activateByEvent', event);
 };
 
-const UiStrings$1 = {
-  GoToDefinition: 'Go to Definition',
-  NoDefinitionFound: 'No definition found',
-  NoDefinitionFoundFor: "No definition found for '{PH1}'",
-  NoTypeDefinitionFound: 'No type definition found',
-  NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
-  NoResults: 'No Results',
-  Replace: 'Replace'
-};
-const noDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoDefinitionFound);
-};
-const noDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoDefinitionFoundFor, {
-    PH1: word
-  });
+const execute = async ({
+  editor,
+  args,
+  event,
+  method,
+  noProviderFoundMessage,
+  noProviderFoundResult = undefined
+}) => {
+  const fullEvent = `${event}:${editor.languageId}`;
+  await activateByEvent(fullEvent);
+  const result = await invoke$2(method, editor.uid, ...args);
+  return result;
 };
-const noTypeDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFoundFor, {
-    PH1: word
+
+const executeHoverProvider = (editor, offset) => {
+  object(editor);
+  number$1(offset);
+  return execute({
+    event: OnHover,
+    editor,
+    method: HoverExecute,
+    args: [offset],
+    noProviderFoundMessage: 'No hover provider found'
   });
 };
-const noTypeDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFound);
-};
+
+const getHover = async (editor, offset) => {
+  object(editor);
+  number$1(offset);
+  // TODO invoke extension host worker directly
+  const hover = await executeHoverProvider(editor, offset);
+  return hover;
+};
+
+let _ipc;
+const listen$6 = async () => {
+  const ipc = await create$7({
+    method: RendererProcess
+  });
+  handleIpc(ipc);
+  _ipc = ipc;
+};
+const invoke$1 = async (method, ...args) => {
+  return invoke$5(_ipc, method, ...args);
+};
+
+const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
+  return invoke$1('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+};
+
+const deepCopy = value => {
+  return structuredClone(value);
+};
+
+const getInitialLineState = initialLineState => {
+  return deepCopy(initialLineState);
+};
+
+const getLineInfo$1 = (line, tokens, TokenMap) => {
+  const tokensLength = tokens.length;
+  let end = 0;
+  let start = 0;
+  const lineInfo = [];
+  for (let i = 0; i < tokensLength; i += 2) {
+    const tokenType = tokens[i];
+    const tokenLength = tokens[i + 1];
+    end += tokenLength;
+    const text = line.slice(start, end);
+    const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
+    const normalizedText = text;
+    lineInfo.push(normalizedText, className);
+    start = end;
+  }
+  return lineInfo;
+};
+
+const state$5 = {
+  warned: []
+};
+const flattenTokensArray = tokens => {
+  const flattened = [];
+  for (const token of tokens) {
+    object(token);
+    flattened.push(token.type, token.length);
+  }
+  return flattened;
+};
+const warnDeprecatedArrayReturn = (languageId, fn) => {
+  if (state$5.warned.includes(fn)) {
+    return;
+  }
+  state$5.warned.push(fn);
+  console.warn(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
+};
+const safeTokenizeLine = (languageId, tokenizeLine, line, lineStateAtStart, hasArrayReturn) => {
+  try {
+    const lineState = tokenizeLine(line, lineStateAtStart);
+    if (!lineState || !lineState.tokens || !lineState.state) {
+      throw new Error('invalid tokenization result');
+    }
+    if (!hasArrayReturn) {
+      warnDeprecatedArrayReturn(languageId, tokenizeLine);
+      // workaround for old tokenizers
+      lineState.tokens = flattenTokensArray(lineState.tokens);
+    }
+    return lineState;
+  } catch (error) {
+    console.error(error);
+    return {
+      tokens: [/* type */0, /* length */line.length],
+      lineState: lineStateAtStart
+    };
+  }
+};
+
+const getLineInfos = (lines, tokenizer, languageId) => {
+  const lineInfos = [];
+  const {
+    tokenizeLine,
+    initialLineState,
+    hasArrayReturn,
+    TokenMap
+  } = tokenizer;
+  let currentLineState = getInitialLineState(initialLineState);
+  for (const line of lines) {
+    const result = safeTokenizeLine(languageId, tokenizeLine, line, currentLineState, hasArrayReturn);
+    const {
+      tokens
+    } = result;
+    const lineInfo = getLineInfo$1(line, tokens, TokenMap);
+    lineInfos.push(lineInfo);
+    currentLineState = result;
+  }
+  return lineInfos;
+};
+
+/**
+ * @enum number
+ */
+const State = {
+  TopLevelContent: 1
+};
+
+/**
+ * @enum number
+ */
+const TokenType = {
+  Text: 1
+};
+const TokenMap = {
+  [TokenType.Text]: 'Text'
+};
+const initialLineState = {
+  state: State.TopLevelContent
+};
+const hasArrayReturn = true;
+const tokenizeLine = (line, lineState) => {
+  return {
+    tokens: [TokenType.Text, line.length],
+    state: lineState.state
+  };
+};
+
+const TokenizePlainText = {
+  __proto__: null,
+  State,
+  TokenMap,
+  TokenType,
+  hasArrayReturn,
+  initialLineState,
+  tokenizeLine
+};
+
+const state$4 = {
+  tokenizers: Object.create(null),
+  tokenizePaths: Object.create(null),
+  listeners: [],
+  pending: Object.create(null),
+  /**
+   * @type {number[]}
+   */
+  connectedEditors: []
+};
+const has = languageId => {
+  return languageId in state$4.tokenizers;
+};
+const set$4 = (languageId, tokenizer) => {
+  state$4.tokenizers[languageId] = tokenizer;
+};
+const get$4 = languageId => {
+  return state$4.tokenizers[languageId];
+};
+const isPending = languageId => {
+  return languageId in state$4.pending;
+};
+
+let enabled$1 = false;
+const setEnabled$1 = value => {
+  enabled$1 = value;
+};
+const getEnabled$1 = () => {
+  return enabled$1;
+};
+
+const {
+  listen: listen$5,
+  invoke
+} = createRpc(SyntaxHighlightingWorker);
+
+const tokenMaps = Object.create(null);
+const set$3 = (languageId, tokenMap) => {
+  tokenMaps[languageId] = tokenMap;
+};
+const get$3 = languageId => {
+  return tokenMaps[languageId] || {};
+};
+
+// TODO loadTokenizer should be invoked from renderer worker
+const loadTokenizer = async (languageId, tokenizePath) => {
+  if (!tokenizePath) {
+    return;
+  }
+  if (getEnabled$1()) {
+    const tokenMap = await invoke('Tokenizer.load', languageId, tokenizePath);
+    set$3(languageId, tokenMap);
+    return;
+  }
+  try {
+    // TODO check that tokenizer is valid
+    // 1. tokenizeLine should be of type function
+    // 2. getTokenClass should be of type function
+    const tokenizer = await import(tokenizePath);
+    if (typeof tokenizer.tokenizeLine !== 'function') {
+      console.warn(`tokenizer.tokenizeLine should be a function in "${tokenizePath}"`);
+      return;
+    }
+    if (!tokenizer.TokenMap || typeof tokenizer.TokenMap !== 'object' || Array.isArray(tokenizer.TokenMap)) {
+      console.warn(`tokenizer.TokenMap should be an object in "${tokenizePath}"`);
+      return;
+    }
+    set$3(languageId, tokenizer.TokenMap);
+    set$4(languageId, tokenizer);
+  } catch (error) {
+    // TODO better error handling
+    console.error(error);
+    return;
+  }
+};
+const getTokenizer = languageId => {
+  if (has(languageId)) {
+    return get$4(languageId);
+  }
+  if (isPending(languageId)) {
+    return TokenizePlainText;
+  }
+  return TokenizePlainText;
+};
+
+const tokenizeCodeBlock = async (codeBlock, languageId, tokenizerPath) => {
+  await loadTokenizer(languageId, tokenizerPath);
+  const tokenizer = getTokenizer(languageId);
+  const lines = splitLines$2(codeBlock);
+  const lineInfos = getLineInfos(lines, tokenizer, languageId);
+  return lineInfos;
+};
+
+const getHoverPosition = (position, selections) => {
+  if (position) {
+    return position;
+  }
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  return {
+    rowIndex,
+    columnIndex
+  };
+};
+const getMatchingDiagnostics = (diagnostics, rowIndex, columnIndex) => {
+  const matching = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.rowIndex === rowIndex) {
+      matching.push(diagnostic);
+    }
+  }
+  return matching;
+};
+const fallbackDisplayStringLanguageId = 'typescript'; // TODO remove this
+
+const hoverDocumentationFontSize = 15;
+const hoverDocumentationFontFamily = 'Fira Code';
+const hoverDocumentationLineHeight = '1.33333';
+const hoverBorderLeft = 1;
+const hoverBorderRight = 1;
+const hoverPaddingLeft = 8;
+const hoverPaddingRight = 8;
+const hovverFullWidth = 400;
+const hoverDocumentationWidth = hovverFullWidth - hoverPaddingLeft - hoverPaddingRight - hoverBorderLeft - hoverBorderRight;
+const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) => {
+  const x$1 = x(editor, rowIndex, wordStart);
+  const y$1 = editor.height - y(editor, rowIndex) + editor.y + 40;
+  return {
+    x: x$1,
+    y: y$1
+  };
+};
+const getEditorHoverInfo = async (editorUid, position) => {
+  number$1(editorUid);
+  const instance = get$7(editorUid);
+  const editor = instance.newState;
+  const {
+    selections
+  } = editor;
+  const {
+    rowIndex,
+    columnIndex
+  } = getHoverPosition(position, selections);
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const hover = await getHover(editor, offset);
+  if (!hover) {
+    return undefined;
+  }
+  const {
+    displayString,
+    documentation,
+    displayStringLanguageId
+  } = hover;
+  const tokenizerPath = '';
+  const lineInfos = await tokenizeCodeBlock(displayString, displayStringLanguageId || fallbackDisplayStringLanguageId, tokenizerPath);
+  const wordPart = await getWordBefore(editor, rowIndex, columnIndex);
+  const wordStart = columnIndex - wordPart.length;
+  await measureTextBlockHeight(documentation, hoverDocumentationFontFamily, hoverDocumentationFontSize, hoverDocumentationLineHeight, hoverDocumentationWidth);
+  const {
+    x,
+    y
+  } = getHoverPositionXy(editor, rowIndex, wordStart);
+  const diagnostics = editor.diagnostics || [];
+  const matchingDiagnostics = getMatchingDiagnostics(diagnostics, rowIndex);
+  return {
+    lineInfos,
+    documentation,
+    x,
+    y,
+    matchingDiagnostics
+  };
+};
+
+const loadHoverContent = async state => {
+  // TODO
+  const position = undefined;
+  const hoverInfo = await getEditorHoverInfo(state.editorUid, position);
+  if (!hoverInfo) {
+    return state;
+  }
+  const {
+    lineInfos,
+    documentation,
+    x,
+    y,
+    matchingDiagnostics
+  } = hoverInfo;
+  return {
+    ...state,
+    lineInfos,
+    documentation,
+    x,
+    y,
+    diagnostics: matchingDiagnostics
+  };
+};
+
+const newStateGenerator = state => {
+  return loadHoverContent(state);
+};
+const showHover2 = async editor => {
+  return addWidgetToEditor(Hover, FocusEditorHover, editor, create$3, newStateGenerator);
+};
+
+const deleteWordPartLeft = editor => {
+  const newEditor = editorDeleteHorizontalLeft(editor, wordPartLeft);
+  return newEditor;
+};
+
+const deleteWordPartRight = editor => {
+  return editorDeleteHorizontalRight(editor, wordPartRight);
+};
+
+const deleteWordRight = editor => {
+  return editorDeleteHorizontalRight(editor, wordRight);
+};
+
+const findAllReferences = async editor => {
+  await invoke$3('SideBar.show', 'References', /* focus */true);
+  return editor;
+};
+
+// TODO format should be executed in parallel with saving
+// -> fast save, no need to wait for formatting
+// -> fast formatting, no need to wait for save
+
+// TODO should format on save when closing/switching editor?
+
+// TODO format with cursor
+// TODO should be in editor folder
+
+const format$1 = async editor => {
+  const edits = await invoke$3('Format.format', editor);
+  return edits;
+};
+
+const warn = (...args) => {
+  console.warn(...args);
+};
+const error = (...args) => {
+  console.error(...args);
+};
+
+// @ts-ignore
+const getDocumentEdits = (editor, edits) => {
+  const documentEdits = [];
+  for (const edit of edits) {
+    const start = positionAt(editor, edit.startOffset);
+    const end = positionAt(editor, edit.endOffset);
+    const deleted = getSelectionText(editor, {
+      start,
+      end
+    });
+    const documentEdit = {
+      start,
+      end,
+      inserted: splitLines$2(edit.inserted),
+      deleted,
+      origin: Format
+    };
+    if (documentEdit.inserted.length === 0) {
+      documentEdit.inserted = [''];
+    }
+    documentEdits.push(documentEdit);
+  }
+  return documentEdits;
+};
+
+// @ts-ignore
+const applyDocumentEdits = (editor, edits) => {
+  if (!Array.isArray(edits)) {
+    warn('something is wrong with format on save', edits);
+    return editor;
+  }
+  if (edits.length === 0) {
+    return editor;
+  }
+  const documentEdits = getDocumentEdits(editor, edits);
+  return scheduleDocumentAndCursorsSelections(editor, documentEdits);
+};
+
+const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
+const isFormattingError = error => {
+  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage);
+};
+
+// TODO also format with cursor
+const format = async editor => {
+  try {
+    const edits = await format$1(editor);
+    return applyDocumentEdits(editor, edits);
+  } catch (error) {
+    if (isFormattingError(error)) {
+      console.error('Formatting Error:',
+      // @ts-ignore
+      error.message.slice(expectedErrorMessage.length));
+      return editor;
+    }
+    console.error(error);
+    const displayErrorMessage = `${error}`;
+    await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
+    return editor;
+  }
+};
+
+// @ts-ignore
+const getDefinition = async (editor, offset) => {
+  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
+  return definition;
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const UiStrings$1 = {
+  GoToDefinition: 'Go to Definition',
+  NoDefinitionFound: 'No definition found',
+  NoDefinitionFoundFor: "No definition found for '{PH1}'",
+  NoTypeDefinitionFound: 'No type definition found',
+  NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
+  NoResults: 'No Results',
+  Replace: 'Replace'
+};
+const noDefinitionFound = () => {
+  return i18nString(UiStrings$1.NoDefinitionFound);
+};
+const noDefinitionFoundFor = word => {
+  return i18nString(UiStrings$1.NoDefinitionFoundFor, {
+    PH1: word
+  });
+};
+const noTypeDefinitionFoundFor = word => {
+  return i18nString(UiStrings$1.NoTypeDefinitionFoundFor, {
+    PH1: word
+  });
+};
+const noTypeDefinitionFound = () => {
+  return i18nString(UiStrings$1.NoTypeDefinitionFound);
+};
 const noResults$1 = () => {
   return i18nString(UiStrings$1.NoResults);
 };
@@ -3628,7 +4049,7 @@ const handleDoubleClick = (editor, modifier, x, y) => {
 };
 
 const WhenExpressionEditorText = 12;
-const handleFocus$1 = editor => {
+const handleFocus = editor => {
   // TODO make change events functional,
   // when rendering, send focus changes to renderer worker
   invoke$3('Focus.setFocus', WhenExpressionEditorText);
@@ -3639,19 +4060,19 @@ const Single = 1;
 const Double = 2;
 const Triple = 3;
 
-const state$5 = {
+const state$3 = {
   position: {
     rowIndex: 0,
     columnIndex: 0
   }
 };
-const getPosition$2 = () => {
-  return state$5.position;
+const getPosition$1 = () => {
+  return state$3.position;
 };
 
 // @ts-ignore
 const setPosition$1 = position => {
-  state$5.position = position;
+  state$3.position = position;
 };
 
 const Ctrl = 1;
@@ -3778,20 +4199,20 @@ const handleMouseDown = (state, modifier, x, y, detail) => {
   }
 };
 
-const state$4 = {
+const state$2 = {
   timeout: -1,
   x: 0,
   y: 0,
   editor: undefined
 };
-const get$4 = () => {
-  return state$4;
+const get$2 = () => {
+  return state$2;
 };
-const set$4 = (editor, timeout, x, y) => {
-  state$4.editor = editor;
-  state$4.timeout = timeout;
-  state$4.x = x;
-  state$4.y = y;
+const set$2 = (editor, timeout, x, y) => {
+  state$2.editor = editor;
+  state$2.timeout = timeout;
+  state$2.x = x;
+  state$2.y = y;
 };
 
 const showHover$1 = async (editor, position) => {
@@ -3813,7 +4234,7 @@ const onHoverIdle = async () => {
     x,
     y,
     editor
-  } = get$4();
+  } = get$2();
   at(editor, x, y);
   await showHover$1();
 };
@@ -3824,12 +4245,12 @@ const handleMouseMove = (editor, x, y) => {
   if (!editor.hoverEnabled) {
     return editor;
   }
-  const oldState = get$4();
+  const oldState = get$2();
   if (oldState.timeout !== -1) {
     clearTimeout(oldState.timeout);
   }
   const timeout = setTimeout(onHoverIdle, hoverDelay);
-  set$4(editor, timeout, x, y);
+  set$2(editor, timeout, x, y);
   return editor;
 };
 
@@ -3936,7 +4357,7 @@ const editorHandleNativeSelectionChange = (editor, range) => {
   return scheduleSelections(editor, selections);
 };
 
-const state$3 = {
+const state$1 = {
   /**
    * @type {any}
    */
@@ -3950,26 +4371,26 @@ const state$3 = {
 
 // @ts-ignore
 const setEditor = editor => {
-  state$3.currentEditor = editor;
-  state$3.hasListener = true;
+  state$1.currentEditor = editor;
+  state$1.hasListener = true;
 };
 const clearEditor = () => {
-  state$3.currentEditor = undefined;
-  state$3.hasListener = false;
+  state$1.currentEditor = undefined;
+  state$1.hasListener = false;
 };
 
 // @ts-ignore
 const setPosition = position => {
-  state$3.position = position;
+  state$1.position = position;
 };
 const getEditor$1 = () => {
-  return state$3.currentEditor;
+  return state$1.currentEditor;
 };
-const getPosition$1 = () => {
-  return state$3.position;
+const getPosition = () => {
+  return state$1.position;
 };
 const hasListener = () => {
-  return state$3.hasListener;
+  return state$1.hasListener;
 };
 
 // @ts-ignore
@@ -4138,7 +4559,7 @@ const handleScrollBarPointerDown = (state, eventY) => {
   };
 };
 
-const state$2 = {
+const state = {
   touchOffsetY: 0,
   deltaY: 0
 };
@@ -4149,8 +4570,8 @@ const handleTouchStart = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  state$2.touchOffsetY = firstTouch.y;
-  state$2.deltaY = editor.deltaY;
+  state.touchOffsetY = firstTouch.y;
+  state.deltaY = editor.deltaY;
   // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
   // EditorMoveSelection.state.position = position
   // state.date = Date.now()
@@ -4210,7 +4631,7 @@ const getNewSelections$5 = (anchor, position) => {
 
 // @ts-ignore
 const editorMoveSelection = (editor, position) => {
-  const anchor = getPosition$2();
+  const anchor = getPosition$1();
   const newSelections = getNewSelections$5(anchor, position);
   // TODO if selection equals previous selection -> do nothing
   return scheduleSelections(editor, newSelections);
@@ -4228,7 +4649,7 @@ const handleTouchEnd = (editor, touchEvent) => {
   // @ts-ignore
   if (undefined.position.rowIndex === position.rowIndex && undefined.position.columnIndex === position.columnIndex) {
     // @ts-ignore
-    if (Date.now() - state$2.date > LONG_TOUCH_THRESHOLD) {
+    if (Date.now() - state.date > LONG_TOUCH_THRESHOLD) {
       selectWord(editor, position.rowIndex, position.columnIndex);
     } else {
       // @ts-ignore
@@ -4275,7 +4696,7 @@ const handleTouchMove = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  const offsetY = state$2.deltaY + (state$2.touchOffsetY - firstTouch.y);
+  const offsetY = state.deltaY + (state.touchOffsetY - firstTouch.y);
   setDeltaYFixedValue(editor, offsetY);
 };
 
@@ -4497,7 +4918,7 @@ const getNewEditor$1 = (editor, position) => {
     const newMinLineY = position.rowIndex;
     const newMaxLineY = position.rowIndex + diff;
     const newDeltaY = position.rowIndex * rowHeight;
-    const anchor = getPosition$2();
+    const anchor = getPosition$1();
     const newSelections = new Uint32Array([position.rowIndex - 1, position.columnIndex, anchor.rowIndex, anchor.columnIndex]);
     return {
       ...editor,
@@ -4512,7 +4933,7 @@ const getNewEditor$1 = (editor, position) => {
     const newMinLineY = position.rowIndex - diff;
     const newMaxLineY = position.rowIndex;
     const newDeltaY = newMinLineY * rowHeight;
-    const anchor = getPosition$2();
+    const anchor = getPosition$1();
     const newSelections = new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex + 1, position.columnIndex]);
     return {
       ...editor,
@@ -4529,7 +4950,7 @@ const continueScrollingAndMovingSelection = async () => {
   if (!editor) {
     return;
   }
-  const position = getPosition$1();
+  const position = getPosition();
   if (position.rowIndex === 0) {
     return;
   }
@@ -4567,7 +4988,7 @@ const moveSelectionPx = (editor, x, y) => {
 };
 
 const create$2 = () => {
-  const completionUid = create$4();
+  const completionUid = create$5();
   const completionWidget = {
     id: Completion,
     oldState: {
@@ -4600,28 +5021,6 @@ const create$2 = () => {
   return completionWidget;
 };
 
-const OnCompletion = 'onCompletion';
-const OnHover = 'onHover';
-
-// TODO add tests for this
-const activateByEvent = async event => {
-  await invoke$3('ExtensionHostManagement.activateByEvent', event);
-};
-
-const execute = async ({
-  editor,
-  args,
-  event,
-  method,
-  noProviderFoundMessage,
-  noProviderFoundResult = undefined
-}) => {
-  const fullEvent = `${event}:${editor.languageId}`;
-  await activateByEvent(fullEvent);
-  const result = await invoke$2(method, editor.uid, ...args);
-  return result;
-};
-
 const combineResults = results => {
   return results[0] ?? [];
 };
@@ -4683,8 +5082,6 @@ const resolveCompletion = async (editor, name, completionItem) => {
 
 const None$1 = 1;
 
-const EmptyMatches = [];
-
 const Diagonal = 1;
 const Left = 2;
 
@@ -4698,11 +5095,16 @@ const createTable = size => {
   }
   return table;
 };
-
+const EmptyMatches$1 = [];
+const Dash = '-';
+const Dot = '.';
+const EmptyString = '';
+const Space = ' ';
+const Underline = '_';
+const T = 't';
 const isLowerCase = char => {
   return char === char.toLowerCase();
 };
-
 const isUpperCase = char => {
   return char === char.toUpperCase();
 };
@@ -4725,7 +5127,7 @@ const isGap = (columnCharBefore, columnChar) => {
 };
 
 // based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch) => {
+const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, isDiagonalMatch) => {
   if (rowCharLow !== columnCharLow) {
     return -1;
   }
@@ -4792,13 +5194,13 @@ const traceHighlights = (table, arrows, patternLength, wordLength) => {
 const gridSize = 128;
 const table = createTable(gridSize);
 const arrows = createTable(gridSize);
-const filterCompletionItem = (pattern, word) => {
+const fuzzySearch = (pattern, word) => {
   const patternLength = Math.min(pattern.length, gridSize - 1);
   const wordLength = Math.min(word.length, gridSize - 1);
   const patternLower = pattern.toLowerCase();
   const wordLower = word.toLowerCase();
   if (!isPatternInWord(patternLower, 0, patternLength, wordLower, 0, wordLength)) {
-    return EmptyMatches;
+    return EmptyMatches$1;
   }
   let strongMatch = false;
   for (let row = 1; row < patternLength + 1; row++) {
@@ -4809,7 +5211,7 @@ const filterCompletionItem = (pattern, word) => {
       const columnCharLow = wordLower[column - 1];
       const columnCharBefore = word[column - 2] || '';
       const isDiagonalMatch = arrows[row - 1][column - 1] === Diagonal;
-      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch);
+      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, isDiagonalMatch);
       if (row === 1 && score > 5) {
         strongMatch = true;
       }
@@ -4828,7 +5230,7 @@ const filterCompletionItem = (pattern, word) => {
     }
   }
   if (!strongMatch) {
-    return EmptyMatches;
+    return EmptyMatches$1;
   }
   const highlights = traceHighlights(table, arrows, patternLength, wordLength);
   return highlights;
@@ -4836,6 +5238,8 @@ const filterCompletionItem = (pattern, word) => {
 
 const Deprecated = 1 << 0;
 
+const EmptyMatches = [];
+
 const addEmptyMatch = item => {
   return {
     ...item,
@@ -4843,7 +5247,7 @@ const addEmptyMatch = item => {
   };
 };
 const filterCompletionItems = (completionItems, word) => {
-  if (word === EmptyString) {
+  if (word === EmptyString$1) {
     return completionItems.map(addEmptyMatch);
   }
   const filteredCompletions = [];
@@ -4853,8 +5257,8 @@ const filterCompletionItems = (completionItems, word) => {
       label,
       flags
     } = completionItem;
-    const result = filterCompletionItem(word, label);
-    if (result !== EmptyMatches) {
+    const result = fuzzySearch(word, label);
+    if (result.length > 0) {
       if (flags & Deprecated) {
         // TODO avoid mutation
         completionItem.matches = EmptyMatches;
@@ -5078,7 +5482,7 @@ const Script = 2;
 const Unknown$1 = 0;
 
 const create$1 = () => {
-  const uid = create$4();
+  const uid = create$5();
   const widget = {
     id: Find,
     oldState: {
@@ -5162,12 +5566,187 @@ const findRegexMatches = (lines, regex) => {
   return new Uint32Array(matches);
 };
 
-const findMatchesCaseInsensitive = (lines, searchString) => {
-  if (searchString.length === 0) {
-    return new Uint32Array([]);
-  }
-  const regex = getSearchRegex(searchString);
-  return findRegexMatches(lines, regex);
+const findMatchesCaseInsensitive = (lines, searchString) => {
+  if (searchString.length === 0) {
+    return new Uint32Array([]);
+  }
+  const regex = getSearchRegex(searchString);
+  return findRegexMatches(lines, regex);
+};
+
+const getMatchCount = matches => {
+  return matches.length / 2;
+};
+
+const setFindWidgetFocus = (state, focusKey) => {
+  if (state.focus === focusKey) {
+    return state;
+  }
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: Script
+  };
+};
+
+const focusCloseButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetCloseButton);
+};
+
+const focusFind = state => {
+  return setFindWidgetFocus(state, FindWidget);
+};
+
+const getWidgetState = (editor, id) => {
+  const {
+    widgets
+  } = editor;
+  for (const widget of widgets) {
+    if (widget.id === id) {
+      return widget.newState;
+    }
+  }
+  return undefined;
+};
+
+const getFindState = editor => {
+  return getWidgetState(editor, Find);
+};
+
+const isFind = widget => {
+  return widget.id === Find;
+};
+// TODO don't call renderer worker, set editor state
+// TODO this function should be synchronous
+const focusIndex$1 = (editor, index) => {
+  const findState = getFindState(editor);
+  if (!findState) {
+    return editor;
+  }
+  const {
+    value,
+    matches,
+    matchIndex
+  } = findState;
+  if (index === matchIndex) {
+    return editor;
+  }
+  const {
+    widgets
+  } = editor;
+  const childIndex = widgets.findIndex(isFind);
+  const childWidget = widgets[childIndex];
+
+  // TODO find next match and highlight it
+  const matchRowIndex = matches[index * 2];
+  const matchColumnIndex = matches[index * 2 + 1];
+  const newSelections = new Uint32Array([matchRowIndex, matchColumnIndex, matchRowIndex, matchColumnIndex + value.length]);
+  const newState = {
+    ...findState,
+    matchIndex: index
+  };
+  const newWidget = {
+    ...childWidget,
+    newState
+  };
+  const newWidgets = [...widgets.slice(0, childIndex), newWidget, ...widgets.slice(childIndex + 1)];
+  return {
+    ...editor,
+    selections: newSelections,
+    widgets: newWidgets
+  };
+};
+const focusFirst$1 = editor => {
+  const findState = getFindState(editor);
+  if (!findState) {
+    return editor;
+  }
+  return focusIndex$1(editor, 0);
+};
+const focusLast = editor => {
+  const findState = getFindState(editor);
+  if (!findState) {
+    return editor;
+  }
+  const {
+    matchCount
+  } = findState;
+  return focusIndex$1(editor, matchCount - 1);
+};
+const focusNext$1 = editor => {
+  const findState = getFindState(editor);
+  if (!findState) {
+    return editor;
+  }
+  const {
+    matchIndex,
+    matchCount
+  } = findState;
+  if (matchIndex === matchCount - 1) {
+    return focusFirst$1(editor);
+  }
+  return focusIndex$1(editor, matchIndex + 1);
+};
+const focusPrevious$1 = editor => {
+  const findState = getFindState(editor);
+  if (!findState) {
+    return editor;
+  }
+  const {
+    matchIndex
+  } = findState;
+  if (matchIndex === 0) {
+    return focusLast(editor);
+  }
+  return focusIndex$1(editor, matchIndex - 1);
+};
+
+const focusNextMatchButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetNextMatchButton);
+};
+
+const focusPreviousMatchButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetPreviousMatchButton);
+};
+
+const focusReplace = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetReplace);
+};
+
+const focusReplaceAllButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetReplaceAllButton);
+};
+
+const focusReplaceButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetReplaceButton);
+};
+
+const focusToggleReplaceButton = state => {
+  return setFindWidgetFocus(state, FocusFindWidgetToggleReplace);
+};
+
+const handleBlur = async state => {
+  await setFocus(Empty);
+  return state;
+};
+
+const handleFindWidgetFocus = (state, focusKey) => {
+  if (state.focus === focusKey) {
+    return state;
+  }
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: User
+  };
+};
+
+const handleReplaceAllFocus = state => {
+  return handleFindWidgetFocus(state, FocusFindWidgetReplaceAllButton);
+};
+
+const handleReplaceFocus = state => {
+  return handleFindWidgetFocus(state, FocusFindWidgetReplace);
 };
 
 const getFindWidgetHeight = replaceExpanded => {
@@ -5177,28 +5756,16 @@ const getFindWidgetHeight = replaceExpanded => {
   return newHeight;
 };
 
-const getMatchCount = matches => {
-  return matches.length / 2;
-};
-
-const setFocus = async focusKey => {
-  await invoke$3('Focus.setFocus', focusKey);
-};
-
-const getPosition = editor => {
-  const width = 300;
-  const height = 30;
-  const paddingTop = 10;
-  const paddingRight = 20;
-  const x = editor.x + editor.width - width - paddingRight;
-  const y = editor.y + paddingTop;
+const toggleReplace = state => {
+  const newExpanded = !state.replaceExpanded;
+  const newHeight = getFindWidgetHeight(newExpanded);
   return {
-    y,
-    x,
-    width,
-    height
+    ...state,
+    replaceExpanded: !state.replaceExpanded,
+    height: newHeight
   };
 };
+
 const loadContent$1 = editorId => {
   const editor = getEditor(editorId);
   const {
@@ -5243,82 +5810,6 @@ const refresh = (state, value = state.value) => {
 const handleInput = (state, value) => {
   return refresh(state, value);
 };
-const handleFocus = async state => {
-  if (state.focus === FindWidget) {
-    return state;
-  }
-  await setFocus(FindWidget);
-  return {
-    ...state,
-    focus: FindWidget
-  };
-};
-const handleBlur = async state => {
-  await setFocus(Empty);
-  return state;
-};
-const toggleReplace = state => {
-  const newExpanded = !state.replaceExpanded;
-  const newHeight = getFindWidgetHeight(newExpanded);
-  return {
-    ...state,
-    replaceExpanded: !state.replaceExpanded,
-    height: newHeight
-  };
-};
-
-// TODO this function should be synchronous
-const focusIndex$1 = async (state, index) => {
-  const {
-    value,
-    matches,
-    matchIndex
-  } = state;
-  if (index === matchIndex) {
-    return state;
-  }
-  // TODO find next match and highlight it
-  const matchRowIndex = matches[index * 2];
-  const matchColumnIndex = matches[index * 2 + 1];
-  // @ts-ignore
-  const newSelections = new Uint32Array([matchRowIndex, matchColumnIndex, matchRowIndex, matchColumnIndex + value.length]);
-  // TODO set selections synchronously and render input match index,
-  // input value and new selections at the same time
-  // TODO
-  await invoke$3('Editor.setSelections', newSelections);
-  return {
-    ...state,
-    matchIndex: index
-  };
-};
-const focusFirst$1 = state => {
-  return focusIndex$1(state, 0);
-};
-const focusLast = state => {
-  const {
-    matchCount
-  } = state;
-  return focusIndex$1(state, matchCount - 1);
-};
-const focusNext$1 = state => {
-  const {
-    matchIndex,
-    matchCount
-  } = state;
-  if (matchIndex === matchCount - 1) {
-    return focusFirst$1(state);
-  }
-  return focusIndex$1(state, matchIndex + 1);
-};
-const focusPrevious$1 = state => {
-  const {
-    matchIndex
-  } = state;
-  if (matchIndex === 0) {
-    return focusLast(state);
-  }
-  return focusIndex$1(state, matchIndex - 1);
-};
 const close$1 = async state => {
   // TODO
   // await Viewlet.closeWidget(uid)
@@ -5328,62 +5819,32 @@ const close$1 = async state => {
   };
 };
 const handleToggleReplaceFocus = async state => {
-  if (state.focus === FindWidgetToggleReplace) {
-    return state;
-  }
-  await setFocus(FindWidgetToggleReplace);
-  return {
-    ...state,
-    focus: FindWidgetToggleReplace
-  };
-};
-const handleReplaceFocus = async state => {
-  if (state.focus === FindWidgetReplace) {
+  if (state.focus === FocusFindWidgetToggleReplace) {
     return state;
   }
-  await setFocus(FindWidgetReplace);
-  return {
-    ...state,
-    focus: FindWidgetReplace,
-    focusSource: User
-  };
-};
-const focusReplace = state => {
-  // TODO
-  return {
-    ...state,
-    focus: FindWidgetReplace,
-    focusSource: Script
-  };
-};
-const focusFind = state => {
-  // TODO
+  await setFocus(FocusFindWidgetToggleReplace);
   return {
     ...state,
-    focus: FindWidget,
-    focusSource: Script
+    focus: FocusFindWidgetToggleReplace
   };
 };
 const handleReplaceInput = state => {
   // TODO
   return state;
 };
-const focusToggleReplace = async state => {
-  await setFocus(FindWidgetToggleReplace);
-  return {
-    ...state,
-    focus: FindWidgetToggleReplace,
-    focusSource: Script
-  };
-};
-const handleReplaceAllFocus = async state => {
-  if (state.focus === FindWidgetReplaceAll) {
-    return state;
-  }
-  await setFocus(FindWidgetReplaceAll);
+
+const getFindWidgetPosition = editor => {
+  const width = 300;
+  const height = 30;
+  const paddingTop = 10;
+  const paddingRight = 20;
+  const x = editor.x + editor.width - width - paddingRight;
+  const y = editor.y + paddingTop;
   return {
-    ...state,
-    focus: FindWidgetReplaceAll
+    y,
+    x,
+    width,
+    height
   };
 };
 
@@ -5400,7 +5861,7 @@ const openFind2 = async editor => {
       y,
       width,
       height
-    } = getPosition(editor);
+    } = getFindWidgetPosition(editor);
     const latestState = {
       ...state,
       value,
@@ -5417,7 +5878,8 @@ const openFind2 = async editor => {
     };
     return latestState;
   };
-  return addWidgetToEditor(Find, FindWidget, editor, create$1, newStateGenerator);
+  const fullFocus = true;
+  return addWidgetToEditor(Find, FindWidget, editor, create$1, newStateGenerator, fullFocus);
 };
 
 const openFind = async state => {
@@ -6110,128 +6572,6 @@ const setDecorations = (editor, decorations, diagnostics) => {
   };
 };
 
-/**
- * @enum number
- */
-const State = {
-  TopLevelContent: 1
-};
-
-/**
- * @enum number
- */
-const TokenType = {
-  Text: 1
-};
-const TokenMap = {
-  [TokenType.Text]: 'Text'
-};
-const initialLineState = {
-  state: State.TopLevelContent
-};
-const hasArrayReturn = true;
-const tokenizeLine = (line, lineState) => {
-  return {
-    tokens: [TokenType.Text, line.length],
-    state: lineState.state
-  };
-};
-
-const TokenizePlainText = {
-  __proto__: null,
-  State,
-  TokenMap,
-  TokenType,
-  hasArrayReturn,
-  initialLineState,
-  tokenizeLine
-};
-
-const state$1 = {
-  tokenizers: Object.create(null),
-  tokenizePaths: Object.create(null),
-  listeners: [],
-  pending: Object.create(null),
-  /**
-   * @type {number[]}
-   */
-  connectedEditors: []
-};
-const has = languageId => {
-  return languageId in state$1.tokenizers;
-};
-const set$3 = (languageId, tokenizer) => {
-  state$1.tokenizers[languageId] = tokenizer;
-};
-const get$3 = languageId => {
-  return state$1.tokenizers[languageId];
-};
-const isPending = languageId => {
-  return languageId in state$1.pending;
-};
-
-let enabled$1 = false;
-const setEnabled$1 = value => {
-  enabled$1 = value;
-};
-const getEnabled$1 = () => {
-  return enabled$1;
-};
-
-const {
-  listen: listen$6,
-  invoke: invoke$1
-} = createRpc(SyntaxHighlightingWorker);
-
-const tokenMaps = Object.create(null);
-const set$2 = (languageId, tokenMap) => {
-  tokenMaps[languageId] = tokenMap;
-};
-const get$2 = languageId => {
-  return tokenMaps[languageId] || {};
-};
-
-// TODO loadTokenizer should be invoked from renderer worker
-const loadTokenizer = async (languageId, tokenizePath) => {
-  if (!tokenizePath) {
-    return;
-  }
-  if (getEnabled$1()) {
-    const tokenMap = await invoke$1('Tokenizer.load', languageId, tokenizePath);
-    set$2(languageId, tokenMap);
-    return;
-  }
-  try {
-    // TODO check that tokenizer is valid
-    // 1. tokenizeLine should be of type function
-    // 2. getTokenClass should be of type function
-    const tokenizer = await import(tokenizePath);
-    if (typeof tokenizer.tokenizeLine !== 'function') {
-      console.warn(`tokenizer.tokenizeLine should be a function in "${tokenizePath}"`);
-      return;
-    }
-    if (!tokenizer.TokenMap || typeof tokenizer.TokenMap !== 'object' || Array.isArray(tokenizer.TokenMap)) {
-      console.warn(`tokenizer.TokenMap should be an object in "${tokenizePath}"`);
-      return;
-    }
-    set$2(languageId, tokenizer.TokenMap);
-    set$3(languageId, tokenizer);
-  } catch (error) {
-    // TODO better error handling
-    console.error(error);
-    return;
-  }
-};
-const getTokenizer = languageId => {
-  if (has(languageId)) {
-    return get$3(languageId);
-  }
-  if (isPending(languageId)) {
-    return TokenizePlainText;
-  }
-  return TokenizePlainText;
-};
-
 const tokenizers = Object.create(null);
 const set$1 = (id, value) => {
   tokenizers[id] = value;
@@ -7105,27 +7445,15 @@ const closeDetails = editor => {
   const {
     widgets
   } = editor;
-  const index = widgets.findIndex(isCompletionDetailWidget);
-  if (index === -1) {
-    return editor;
-  }
-  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
-  return {
-    ...editor,
-    widgets: newWidgets
-  };
-};
-
-const getWidgetState = (editor, id) => {
-  const {
-    widgets
-  } = editor;
-  for (const widget of widgets) {
-    if (widget.id === id) {
-      return widget.newState;
-    }
+  const index = widgets.findIndex(isCompletionDetailWidget);
+  if (index === -1) {
+    return editor;
   }
-  return undefined;
+  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
+  return {
+    ...editor,
+    widgets: newWidgets
+  };
 };
 
 const getCompletionState = editor => {
@@ -7182,7 +7510,7 @@ const focusPrevious = editor => {
 };
 
 const create = () => {
-  const completionUid = create$4();
+  const completionUid = create$5();
   const completionWidget = {
     id: CompletionDetail$1,
     oldState: {
@@ -7196,340 +7524,130 @@ const create = () => {
     newState: {
       content: '',
       uid: completionUid,
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0
-    }
-  };
-  return completionWidget;
-};
-
-const getCompletionDetailBounds = (completionBounds, borderSize) => {
-  return {
-    x: completionBounds.x + completionBounds.width - borderSize,
-    y: completionBounds.y,
-    width: 100,
-    height: 100
-  };
-};
-
-const openDetails = editor => {
-  const child = getCompletionState(editor);
-  if (!child) {
-    return editor;
-  }
-  // TODO avoid closure
-  const newStateGenerator = state => {
-    const borderSize = 1;
-    const newestState = {
-      ...state,
-      content: 'abc',
-      ...getCompletionDetailBounds(child, borderSize)
-    };
-    return newestState;
-  };
-  return addWidgetToEditor(CompletionDetail$1, CompletionDetail, editor, create, newStateGenerator);
-};
-
-const getEdits = async (editor, completionItem) => {
-  const child = getCompletionState(editor);
-  // @ts-ignore
-  const {
-    leadingWord,
-    uid
-  } = child;
-  const word = completionItem.label;
-  const resolvedItem = await resolveCompletion(editor, word, completionItem);
-  const inserted = resolvedItem ? resolvedItem.snippet : word;
-  // TODO type and dispose commands should be sent to renderer process at the same time
-  const {
-    selections
-  } = editor;
-  const [startRowIndex, startColumnIndex] = selections;
-  const leadingWordLength = leadingWord.length;
-  const replaceRange$1 = new Uint32Array([startRowIndex, startColumnIndex - leadingWordLength, startRowIndex, startColumnIndex]);
-  const changes = replaceRange(editor, replaceRange$1, [inserted], '');
-  return changes;
-};
-const isCompletion = widget => {
-  return widget.id === Completion;
-};
-const select = async (editor, completionItem) => {
-  const changes = await getEdits(editor, completionItem);
-  const index = editor.widgets.indexOf
-  // ViewletModuleId.EditorCompletion
-  ();
-  if (index !== -1) {
-    editor.widgets.splice(index, 1);
-    editor.completionState = None$1;
-    editor.completionUid = 0;
-  }
-  // TODO dispose completion widget
-  // TODO apply edit in editor worker instead of asking renderer worker
-  // await RendererWorker.invoke('Viewlet.dispose', state.uid)
-  const {
-    widgets
-  } = editor;
-  const completionWidgetIndex = editor.widgets.findIndex(isCompletion);
-  const newWidgets = [...widgets.slice(0, completionWidgetIndex), ...widgets.slice(completionWidgetIndex + 1)];
-  const intermediateEditor = await applyEdit(editor, changes);
-  return {
-    ...intermediateEditor,
-    widgets: newWidgets
-  };
-};
-const selectIndex = (editor, index) => {
-  const child = getCompletionState(editor);
-  if (!child) {
-    return editor;
-  }
-  const {
-    items
-  } = child;
-  if (index === -1) {
-    return editor;
-  }
-  if (index > items.length) {
-    throw new Error('index too large');
-  }
-  const actualIndex = index;
-  const completionItem = items[actualIndex];
-  return select(editor, completionItem);
-};
-
-const selectCurrent = editor => {
-  const child = getCompletionState(editor);
-  if (!child) {
-    return editor;
-  }
-  const {
-    focusedIndex
-  } = child;
-  return selectIndex(editor, focusedIndex);
-};
-
-const getCompletionDetailState = editor => {
-  return getWidgetState(editor, CompletionDetail$1);
-};
-
-const toggleDetails = editor => {
-  const child = getCompletionDetailState(editor);
-  if (!child) {
-    return openDetails(editor);
-  }
-  return closeDetails(editor);
-};
-
-const executeHoverProvider = (editor, offset) => {
-  object(editor);
-  number$1(offset);
-  return execute({
-    event: OnHover,
-    editor,
-    method: HoverExecute,
-    args: [offset],
-    noProviderFoundMessage: 'No hover provider found'
-  });
-};
-
-const getHover = async (editor, offset) => {
-  object(editor);
-  number$1(offset);
-  // TODO invoke extension host worker directly
-  const hover = await executeHoverProvider(editor, offset);
-  return hover;
-};
-
-let _ipc;
-const listen$5 = async () => {
-  const ipc = await create$6({
-    method: RendererProcess
-  });
-  handleIpc(ipc);
-  _ipc = ipc;
-};
-const invoke = async (method, ...args) => {
-  return invoke$5(_ipc, method, ...args);
-};
-
-const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
-};
-
-const deepCopy = value => {
-  return structuredClone(value);
-};
-
-const getInitialLineState = initialLineState => {
-  return deepCopy(initialLineState);
-};
-
-const getLineInfo$1 = (line, tokens, TokenMap) => {
-  const tokensLength = tokens.length;
-  let end = 0;
-  let start = 0;
-  const lineInfo = [];
-  for (let i = 0; i < tokensLength; i += 2) {
-    const tokenType = tokens[i];
-    const tokenLength = tokens[i + 1];
-    end += tokenLength;
-    const text = line.slice(start, end);
-    const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
-    const normalizedText = text;
-    lineInfo.push(normalizedText, className);
-    start = end;
-  }
-  return lineInfo;
-};
-
-const state = {
-  warned: []
-};
-const flattenTokensArray = tokens => {
-  const flattened = [];
-  for (const token of tokens) {
-    object(token);
-    flattened.push(token.type, token.length);
-  }
-  return flattened;
-};
-const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state.warned.includes(fn)) {
-    return;
-  }
-  state.warned.push(fn);
-  console.warn(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
-};
-const safeTokenizeLine = (languageId, tokenizeLine, line, lineStateAtStart, hasArrayReturn) => {
-  try {
-    const lineState = tokenizeLine(line, lineStateAtStart);
-    if (!lineState || !lineState.tokens || !lineState.state) {
-      throw new Error('invalid tokenization result');
-    }
-    if (!hasArrayReturn) {
-      warnDeprecatedArrayReturn(languageId, tokenizeLine);
-      // workaround for old tokenizers
-      lineState.tokens = flattenTokensArray(lineState.tokens);
-    }
-    return lineState;
-  } catch (error) {
-    console.error(error);
-    return {
-      tokens: [/* type */0, /* length */line.length],
-      lineState: lineStateAtStart
-    };
-  }
-};
-
-const getLineInfos = (lines, tokenizer, languageId) => {
-  const lineInfos = [];
-  const {
-    tokenizeLine,
-    initialLineState,
-    hasArrayReturn,
-    TokenMap
-  } = tokenizer;
-  let currentLineState = getInitialLineState(initialLineState);
-  for (const line of lines) {
-    const result = safeTokenizeLine(languageId, tokenizeLine, line, currentLineState, hasArrayReturn);
-    const {
-      tokens
-    } = result;
-    const lineInfo = getLineInfo$1(line, tokens, TokenMap);
-    lineInfos.push(lineInfo);
-    currentLineState = result;
-  }
-  return lineInfos;
-};
-
-const tokenizeCodeBlock = async (codeBlock, languageId, tokenizerPath) => {
-  await loadTokenizer(languageId, tokenizerPath);
-  const tokenizer = getTokenizer(languageId);
-  const lines = splitLines$2(codeBlock);
-  const lineInfos = getLineInfos(lines, tokenizer, languageId);
-  return lineInfos;
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }
+  };
+  return completionWidget;
 };
 
-const getHoverPosition = (position, selections) => {
-  if (position) {
-    return position;
-  }
-  const rowIndex = selections[0];
-  const columnIndex = selections[1];
+const getCompletionDetailBounds = (completionBounds, borderSize) => {
   return {
-    rowIndex,
-    columnIndex
+    x: completionBounds.x + completionBounds.width - borderSize,
+    y: completionBounds.y,
+    width: 100,
+    height: 100
   };
 };
-const getMatchingDiagnostics = (diagnostics, rowIndex, columnIndex) => {
-  const matching = [];
-  for (const diagnostic of diagnostics) {
-    if (diagnostic.rowIndex === rowIndex) {
-      matching.push(diagnostic);
-    }
-  }
-  return matching;
-};
-const fallbackDisplayStringLanguageId = 'typescript'; // TODO remove this
 
-const hoverDocumentationFontSize = 15;
-const hoverDocumentationFontFamily = 'Fira Code';
-const hoverDocumentationLineHeight = '1.33333';
-const hoverBorderLeft = 1;
-const hoverBorderRight = 1;
-const hoverPaddingLeft = 8;
-const hoverPaddingRight = 8;
-const hovverFullWidth = 400;
-const hoverDocumentationWidth = hovverFullWidth - hoverPaddingLeft - hoverPaddingRight - hoverBorderLeft - hoverBorderRight;
-const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) => {
-  const x$1 = x(editor, rowIndex, wordStart);
-  const y$1 = editor.height - y(editor, rowIndex) + editor.y + 40;
-  return {
-    x: x$1,
-    y: y$1
+const openDetails = editor => {
+  const child = getCompletionState(editor);
+  if (!child) {
+    return editor;
+  }
+  // TODO avoid closure
+  const newStateGenerator = state => {
+    const borderSize = 1;
+    const newestState = {
+      ...state,
+      content: 'abc',
+      ...getCompletionDetailBounds(child, borderSize)
+    };
+    return newestState;
   };
+  return addWidgetToEditor(CompletionDetail$1, CompletionDetail, editor, create, newStateGenerator);
 };
-const getEditorHoverInfo = async (editorUid, position) => {
-  number$1(editorUid);
-  const instance = get$7(editorUid);
-  const editor = instance.newState;
+
+const getEdits = async (editor, completionItem) => {
+  const child = getCompletionState(editor);
+  // @ts-ignore
+  const {
+    leadingWord,
+    uid
+  } = child;
+  const word = completionItem.label;
+  const resolvedItem = await resolveCompletion(editor, word, completionItem);
+  const inserted = resolvedItem ? resolvedItem.snippet : word;
+  // TODO type and dispose commands should be sent to renderer process at the same time
   const {
     selections
   } = editor;
-  const {
-    rowIndex,
-    columnIndex
-  } = getHoverPosition(position, selections);
-  const offset = offsetAt(editor, rowIndex, columnIndex);
-  const hover = await getHover(editor, offset);
-  if (!hover) {
-    return undefined;
+  const [startRowIndex, startColumnIndex] = selections;
+  const leadingWordLength = leadingWord.length;
+  const replaceRange$1 = new Uint32Array([startRowIndex, startColumnIndex - leadingWordLength, startRowIndex, startColumnIndex]);
+  const changes = replaceRange(editor, replaceRange$1, [inserted], '');
+  return changes;
+};
+const isCompletion = widget => {
+  return widget.id === Completion;
+};
+const select = async (editor, completionItem) => {
+  const changes = await getEdits(editor, completionItem);
+  const index = editor.widgets.indexOf
+  // ViewletModuleId.EditorCompletion
+  ();
+  if (index !== -1) {
+    editor.widgets.splice(index, 1);
+    editor.completionState = None$1;
+    editor.completionUid = 0;
   }
+  // TODO dispose completion widget
+  // TODO apply edit in editor worker instead of asking renderer worker
+  // await RendererWorker.invoke('Viewlet.dispose', state.uid)
   const {
-    displayString,
-    documentation,
-    displayStringLanguageId
-  } = hover;
-  const tokenizerPath = '';
-  const lineInfos = await tokenizeCodeBlock(displayString, displayStringLanguageId || fallbackDisplayStringLanguageId, tokenizerPath);
-  const wordPart = await getWordBefore(editor, rowIndex, columnIndex);
-  const wordStart = columnIndex - wordPart.length;
-  await measureTextBlockHeight(documentation, hoverDocumentationFontFamily, hoverDocumentationFontSize, hoverDocumentationLineHeight, hoverDocumentationWidth);
-  const {
-    x,
-    y
-  } = getHoverPositionXy(editor, rowIndex, wordStart);
-  const diagnostics = editor.diagnostics || [];
-  const matchingDiagnostics = getMatchingDiagnostics(diagnostics, rowIndex);
+    widgets
+  } = editor;
+  const completionWidgetIndex = editor.widgets.findIndex(isCompletion);
+  const newWidgets = [...widgets.slice(0, completionWidgetIndex), ...widgets.slice(completionWidgetIndex + 1)];
+  const intermediateEditor = await applyEdit(editor, changes);
   return {
-    lineInfos,
-    documentation,
-    x,
-    y,
-    matchingDiagnostics
+    ...intermediateEditor,
+    widgets: newWidgets
   };
 };
+const selectIndex = (editor, index) => {
+  const child = getCompletionState(editor);
+  if (!child) {
+    return editor;
+  }
+  const {
+    items
+  } = child;
+  if (index === -1) {
+    return editor;
+  }
+  if (index > items.length) {
+    throw new Error('index too large');
+  }
+  const actualIndex = index;
+  const completionItem = items[actualIndex];
+  return select(editor, completionItem);
+};
+
+const selectCurrent = editor => {
+  const child = getCompletionState(editor);
+  if (!child) {
+    return editor;
+  }
+  const {
+    focusedIndex
+  } = child;
+  return selectIndex(editor, focusedIndex);
+};
+
+const getCompletionDetailState = editor => {
+  return getWidgetState(editor, CompletionDetail$1);
+};
+
+const toggleDetails = editor => {
+  const child = getCompletionDetailState(editor);
+  if (!child) {
+    return openDetails(editor);
+  }
+  return closeDetails(editor);
+};
 
 const loadContent = async (editorUid, state, position) => {
   const hoverInfo = await getEditorHoverInfo(editorUid, position);
@@ -7660,7 +7778,7 @@ const getHoverVirtualDom = (lineInfos, documentation, diagnostics) => {
 
 const renderHoverDom = {
   isEqual(oldState, newState) {
-    return oldState.lineInfos === newState.lineInfos && oldState.documentation === newState.documentation && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.diagnostics === newState.diagnostics;
+    return oldState.lineInfos === newState.lineInfos && oldState.documentation === newState.documentation && oldState.diagnostics === newState.diagnostics;
   },
   apply(oldState, newState) {
     const dom = getHoverVirtualDom(newState.lineInfos, newState.documentation, newState.diagnostics);
@@ -7669,26 +7787,22 @@ const renderHoverDom = {
 };
 const renderBounds$4 = {
   isEqual(oldState, newState) {
-    return oldState.x === newState.x && oldState.y === newState.y && oldState.resizedWidth === newState.resizedWidth;
+    return oldState.x === newState.x && oldState.y === newState.y;
   },
   apply(oldState, newState) {
-    // @ts-ignore
     const {
       x,
       y,
-      width,
-      height,
-      resizedWidth,
-      uid
+      height
     } = newState;
-    console.log('apply');
-    return [SetBounds, x, y, resizedWidth, height];
+    const renderWidth = 200;
+    return [SetBounds, x, y, renderWidth, height];
   }
 };
-const render$9 = [renderHoverDom, renderBounds$4];
-const renderHover = async (oldState, newState) => {
+const render$a = [renderHoverDom, renderBounds$4];
+const renderHover = (oldState, newState) => {
   const commands = [];
-  for (const item of render$9) {
+  for (const item of render$a) {
     if (!item.isEqual(oldState, newState)) {
       commands.push(item.apply(oldState, newState));
     }
@@ -7792,10 +7906,10 @@ const getEnabled = () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await listen$5();
+  await listen$6();
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
-    await listen$6();
+    await listen$5();
   }
   if (syncIncremental) {
     setEnabled(true);
@@ -8083,10 +8197,10 @@ const getTokensViewport2 = (editor, startLineIndex, endLineIndex, syncIncrementa
         languageId,
         invalidStartIndex
       };
-      return invoke$1('GetTokensViewport.getTokensViewport', slimEditor, startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
+      return invoke('GetTokensViewport.getTokensViewport', slimEditor, startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
     }
     // TODO only send needed lines of text
-    return invoke$1('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
+    return invoke('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
   }
   return getTokensViewport(editor, startLineIndex, endLineIndex);
 };
@@ -8279,7 +8393,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++) {
@@ -8436,7 +8550,7 @@ const getIncrementalEdits = async (oldState, newState) => {
       const lines = newState.lines;
       const oldLine = oldState.lines[rowIndex];
       const newLine = lines[rowIndex];
-      const incrementalEdits = await invoke$1('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
+      const incrementalEdits = await invoke('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
       if (incrementalEdits && incrementalEdits.length === 1) {
         return incrementalEdits;
       }
@@ -8646,7 +8760,7 @@ const renderWidgets = {
   },
   multiple: true
 };
-const render$8 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets];
+const render$9 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets];
 const renderEditor = async id => {
   const instance = get$7(id);
   if (!instance) {
@@ -8658,7 +8772,7 @@ const renderEditor = async id => {
   } = instance;
   const commands = [];
   set$7(id, newState, newState);
-  for (const item of render$8) {
+  for (const item of render$9) {
     if (!item.isEqual(oldState, newState)) {
       const result = await item.apply(oldState, newState);
       // @ts-ignore
@@ -8706,12 +8820,12 @@ const wrapWidgetCommand = (widgetId, fn) => {
 const widgetCommands = {
   'ColorPicker.handleSliderPointerDown': ColorPicker$1,
   'ColorPicker.handleSliderPointerMove': ColorPicker$1,
-  'FindWidget.focusNext': Find,
-  'FindWidget.focusPrevious': Find,
+  // 'FindWidget.focusNext': WidgetId.Find,
+  // 'FindWidget.focusPrevious': WidgetId.Find,
   'FindWidget.close': Find,
-  'FindWidget.focusIndex': Find,
-  'FindWidget.focusFirst': Find,
-  'FindWidget.focusLast': Find,
+  // 'FindWidget.focusIndex': WidgetId.Find,
+  // 'FindWidget.focusFirst': WidgetId.Find,
+  // 'FindWidget.focusLast': WidgetId.Find,
   'FindWidget.toggleReplace': Find,
   'FindWidget.handleFocus': Find,
   'FindWidget.handleBlur': Find,
@@ -8721,7 +8835,12 @@ const widgetCommands = {
   'FindWidget.handleReplaceFocus': Find,
   'FindWidget.focusFind': Find,
   'FindWidget.focusToggleReplace': Find,
-  'FindWidget.focusReplace': Find
+  'FindWidget.focusReplace': Find,
+  'FindWidget.focusReplaceButton': Find,
+  'FindWidget.focusReplaceAllButton': Find,
+  'FindWidget.focusNextMatchButton': Find,
+  'FindWidget.focusPreviousMatchButton': Find,
+  'FindWidget.focusCloseButton': Find
 };
 
 // TODO wrap commands globally, not per editor
@@ -8804,7 +8923,7 @@ const commandMap = {
   'Editor.handleBlur': handleBlur$1,
   'Editor.handleContextMenu': handleContextMenu,
   'Editor.handleDoubleClick': handleDoubleClick,
-  'Editor.handleFocus': handleFocus$1,
+  'Editor.handleFocus': handleFocus,
   'Editor.handleMouseDown': handleMouseDown,
   'Editor.handleMouseMove': handleMouseMove,
   'Editor.handleMouseMoveWithAltKey': handleMouseMoveWithAltKey,
@@ -8865,6 +8984,7 @@ const commandMap = {
   'Editor.setLanguageId': setLanguageId,
   'Editor.setSelections': setSelections,
   'Editor.showHover': showHover,
+  'Editor.showHover2': showHover2,
   'Editor.showSourceActions': showSourceActions,
   'Editor.sortLinesAscending': sortLinesAscending,
   'Editor.tabCompletion': tabCompletion,
@@ -8891,23 +9011,28 @@ const commandMap = {
   'EditorCompletion.selectIndex': selectIndex,
   'EditorCompletion.toggleDetails': toggleDetails,
   'FindWidget.close': close$1,
+  'FindWidget.focusCloseButton': focusCloseButton,
   'FindWidget.focusFind': focusFind,
   'FindWidget.focusFirst': focusFirst$1,
   'FindWidget.focusIndex': focusIndex$1,
   'FindWidget.focusLast': focusLast,
   'FindWidget.focusNext': focusNext$1,
+  'FindWidget.focusNextMatchButton': focusNextMatchButton,
   'FindWidget.focusPrevious': focusPrevious$1,
+  'FindWidget.focusPreviousMatchButton': focusPreviousMatchButton,
   'FindWidget.focusReplace': focusReplace,
-  'FindWidget.focusToggleReplace': focusToggleReplace,
+  'FindWidget.focusReplaceAllButton': focusReplaceAllButton,
+  'FindWidget.focusReplaceButton': focusReplaceButton,
+  'FindWidget.focusToggleReplace': focusToggleReplaceButton,
   'FindWidget.handleBlur': handleBlur,
-  'FindWidget.handleFocus': handleFocus,
+  'FindWidget.handleFocus': handleFindWidgetFocus,
   'FindWidget.handleInput': handleInput,
+  'FindWidget.handleReplaceAllFocus': handleReplaceAllFocus,
   'FindWidget.handleReplaceFocus': handleReplaceFocus,
   'FindWidget.handleReplaceInput': handleReplaceInput,
+  'FindWidget.handleToggleReplaceFocus': handleToggleReplaceFocus,
   'FindWidget.loadContent': loadContent$1,
   'FindWidget.toggleReplace': toggleReplace,
-  'FindWidget.handleToggleReplaceFocus': handleToggleReplaceFocus,
-  'FindWidget.handleReplaceAllFocus': handleReplaceAllFocus,
   'Font.ensure': ensure,
   'Hover.getHoverInfo': getEditorHoverInfo,
   'Hover.handleSashPointerDown': handleSashPointerDown,
@@ -9072,11 +9197,11 @@ const getSymbolName = kind => {
 const getCompletionFileIcon = kind => {
   switch (kind) {
     case File:
-      return EmptyString;
+      return EmptyString$1;
     case Folder:
-      return EmptyString;
+      return EmptyString$1;
     default:
-      return EmptyString;
+      return EmptyString$1;
   }
 };
 
@@ -9167,10 +9292,10 @@ const renderScrollBar = {
     return [/* method */SetScrollBar, /* scrollBarY */scrollBarY, /* scrollBarHeight */scrollBarHeight];
   }
 };
-const render$7 = [renderItems, renderBounds$3, renderHeight, renderNegativeMargin, renderScrollBar];
+const render$8 = [renderItems, renderBounds$3, renderHeight, renderNegativeMargin, renderScrollBar];
 const renderCompletion = (oldState, newState) => {
   const commands = [];
-  for (const item of render$7) {
+  for (const item of render$8) {
     if (!item.isEqual(oldState, newState)) {
       commands.push(item.apply(oldState, newState));
     }
@@ -9183,7 +9308,7 @@ const removeWidget = widget => {
   return [['Viewlet.send', widget.newState.uid, 'dispose']];
 };
 
-const render$6 = widget => {
+const render$7 = widget => {
   const commands = renderCompletion(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const uid = widget.newState.uid;
@@ -9192,8 +9317,8 @@ const render$6 = widget => {
   }
   return wrappedCommands;
 };
-const add$3 = widget => {
-  const commands = render$6(widget);
+const add$4 = widget => {
+  const commands = render$7(widget);
   const id = 'EditorCompletion';
   // TODO how to generate a unique integer id
   // that doesn't collide with ids created in renderer worker?
@@ -9203,7 +9328,7 @@ const add$3 = widget => {
   allCommands.push(...commands);
   return allCommands;
 };
-const remove$3 = removeWidget;
+const remove$4 = removeWidget;
 const handleEditorType = (editor, state) => {
   const {
     unfilteredItems,
@@ -9268,11 +9393,11 @@ const handleEditorDeleteLeft = (editor, state) => {
 
 const EditorCompletionWidget = {
   __proto__: null,
-  add: add$3,
+  add: add$4,
   handleEditorDeleteLeft,
   handleEditorType,
-  remove: remove$3,
-  render: render$6
+  remove: remove$4,
+  render: render$7
 };
 
 const MessagePort$1 = 1;
@@ -9751,7 +9876,7 @@ const listen$1 = async ({
 };
 
 const listen = async () => {
-  registerCommands(commandMap);
+  register$1(commandMap);
   register(Completion, EditorCompletionWidget);
   const ipc = await listen$1({
     method: Auto()
@@ -9823,10 +9948,10 @@ const renderBounds$2 = {
     return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
   }
 };
-const render$5 = [renderContent$1, renderBounds$2, renderColor, renderOffsetX];
+const render$6 = [renderContent$1, renderBounds$2, renderColor, renderOffsetX];
 const renderFull$1 = (oldState, newState) => {
   const commands = [];
-  for (const item of render$5) {
+  for (const item of render$6) {
     if (!item.isEqual(oldState, newState)) {
       commands.push(item.apply(oldState, newState));
     }
@@ -9834,7 +9959,7 @@ const renderFull$1 = (oldState, newState) => {
   return commands;
 };
 
-const render$4 = widget => {
+const render$5 = widget => {
   const commands = renderFull$1(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const uid = widget.newState.uid;
@@ -9847,10 +9972,10 @@ const render$4 = widget => {
   }
   return wrappedCommands;
 };
-const add$2 = widget => {
-  return addWidget(widget, 'ColorPicker', render$4);
+const add$3 = widget => {
+  return addWidget(widget, 'ColorPicker', render$5);
 };
-const remove$2 = removeWidget;
+const remove$3 = removeWidget;
 const Commands$1 = {
   'ColorPicker.handleSliderPointerDown': handleSliderPointerDown,
   'ColorPicker.handleSliderPointerMove': handleSliderPointerMove
@@ -9859,9 +9984,9 @@ const Commands$1 = {
 const EditorColorPickerWidget = {
   __proto__: null,
   Commands: Commands$1,
-  add: add$2,
-  remove: remove$2,
-  render: render$4
+  add: add$3,
+  remove: remove$3,
+  render: render$5
 };
 
 const getCompletionDetailVirtualDom = content => {
@@ -9909,12 +10034,12 @@ const renderBounds$1 = {
     return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
   }
 };
-const render$3 = [renderContent, renderBounds$1];
+const render$4 = [renderContent, renderBounds$1];
 const renderFull = (oldState, newState) => {
-  return renderParts(render$3, oldState, newState);
+  return renderParts(render$4, oldState, newState);
 };
 
-const render$2 = widget => {
+const render$3 = widget => {
   const commands = renderFull(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const uid = widget.newState.uid;
@@ -9927,16 +10052,16 @@ const render$2 = widget => {
   }
   return wrappedCommands;
 };
-const add$1 = widget => {
-  return addWidget(widget, 'EditorCompletionDetails', render$2);
+const add$2 = widget => {
+  return addWidget(widget, 'EditorCompletionDetails', render$3);
 };
-const remove$1 = removeWidget;
+const remove$2 = removeWidget;
 
 const EditorCompletionDetailWidget = {
   __proto__: null,
-  add: add$1,
-  remove: remove$1,
-  render: render$2
+  add: add$2,
+  remove: remove$2,
+  render: render$3
 };
 
 /**
@@ -9981,19 +10106,79 @@ const replaceAll = () => {
   return i18nString(UiStrings.ReplaceAll);
 };
 
+const ArrowDown = 'ArrowDown';
+const ArrowUp = 'ArrowUp';
+const Close$1 = 'Close';
+const Replace$1 = 'Replace';
+const ReplaceAll$1 = 'ReplaceAll';
+
+const SearchValue = 'search-value';
+const ReplaceValue = 'replace-value';
+const ReplaceAll = 'ReplaceAll';
+const Close = 'Close';
+const ToggleReplace = 'ToggleReplace';
+const FocusNext = 'FocusNext';
+const FocusPrevious = 'FocusPrevious';
+const Replace = 'Replace';
+
+const getFindWidgetButtons = buttonsEnabled => {
+  const findButtons = [{
+    label: previousMatch(),
+    icon: ArrowUp,
+    disabled: !buttonsEnabled,
+    onClick: 'handleClickPreviousMatch',
+    name: FocusPrevious
+  }, {
+    label: nextMatch(),
+    icon: ArrowDown,
+    disabled: !buttonsEnabled,
+    onClick: 'handleClickNextMatch',
+    name: FocusNext
+  }, {
+    label: close(),
+    icon: Close$1,
+    disabled: false,
+    onClick: 'handleClickClose',
+    name: Close
+  }];
+  const replaceButtons = [{
+    label: replace(),
+    icon: Replace$1,
+    disabled: !buttonsEnabled,
+    onClick: 'handleClickReplace',
+    name: Replace
+  }, {
+    label: replaceAll(),
+    icon: ReplaceAll$1,
+    disabled: !buttonsEnabled,
+    onClick: 'handleClickReplaceAll',
+    name: ReplaceAll
+  }];
+  return {
+    findButtons,
+    replaceButtons
+  };
+};
+
 // TODO always focus element by name
 const getFindWidgetFocusSelector = focus => {
   switch (focus) {
     case FindWidget:
-      return `[name="search-value"]`;
-    case FindWidgetReplace:
-      return '[name="replace-value"]';
-    case FindWidgetReplaceAll:
-      return `[name="replaceAll"]`;
-    case FindWidgetClose:
-      return `[name="close"]`;
-    case FindWidgetToggleReplace:
-      return `[name="ToggleReplace"]`;
+      return `[name="${SearchValue}"]`;
+    case FocusFindWidgetReplace:
+      return `[name="${ReplaceValue}"]`;
+    case FocusFindWidgetReplaceAllButton:
+      return `[name="${ReplaceAll}"]`;
+    case FocusFindWidgetCloseButton:
+      return `[name="${Close}"]`;
+    case FocusFindWidgetToggleReplace:
+      return `[name="${ToggleReplace}"]`;
+    case FocusFindWidgetNextMatchButton:
+      return `[name="${FocusNext}"]`;
+    case FocusFindWidgetPreviousMatchButton:
+      return `[name="${FocusPrevious}"]`;
+    case FocusFindWidgetReplaceButton:
+      return `[name="${Replace}"]`;
     default:
       return '';
   }
@@ -10012,7 +10197,9 @@ const getIconButtonVirtualDom = iconButton => {
   const {
     label,
     icon,
-    disabled
+    disabled,
+    name,
+    onClick
   } = iconButton;
   let className = IconButton;
   if (disabled) {
@@ -10025,7 +10212,8 @@ const getIconButtonVirtualDom = iconButton => {
     ariaLabel: label,
     childCount: 1,
     disabled: disabled ? true : undefined,
-    onClick: iconButton.onClick
+    onClick: onClick,
+    name: name
   }, getIconVirtualDom(icon)];
 };
 
@@ -10099,7 +10287,7 @@ const getFindWidgetReplaceVirtualDom = (replaceExpanded, replaceButtons) => {
   if (replaceExpanded) {
     dom.push({
       type: Div,
-      className: FindWidgetReplace$1,
+      className: FindWidgetReplace,
       childCount: 1 + replaceButtons.length
     }, ...getSearchFieldVirtualDom('replace-value', replace(), 'handleReplaceInput', [], [], 'handleReplaceFocus'), ...replaceButtons.flatMap(getIconButtonVirtualDom));
   }
@@ -10153,12 +10341,6 @@ const getMatchCountText = (matchIndex, matchCount) => {
   return matchOf(matchIndex + 1, matchCount);
 };
 
-const ArrowDown = 'ArrowDown';
-const ArrowUp = 'ArrowUp';
-const Close = 'Close';
-const Replace = 'Replace';
-const ReplaceAll = 'ReplaceAll';
-
 const renderValue = {
   isEqual(oldState, newState) {
     return oldState.value === newState.value;
@@ -10174,33 +10356,10 @@ const renderDetails = {
   apply(oldState, newState) {
     const matchCountText = getMatchCountText(newState.matchIndex, newState.matchCount);
     const buttonsEnabled = newState.matchCount > 0;
-    const findButtons = [{
-      label: previousMatch(),
-      icon: ArrowUp,
-      disabled: !buttonsEnabled,
-      onClick: 'handleClickPreviousMatch'
-    }, {
-      label: nextMatch(),
-      icon: ArrowDown,
-      disabled: !buttonsEnabled,
-      onClick: 'handleClickNextMatch'
-    }, {
-      label: close(),
-      icon: Close,
-      disabled: false,
-      onClick: 'handleClickClose'
-    }];
-    const replaceButtons = [{
-      label: replace(),
-      icon: Replace,
-      disabled: !buttonsEnabled,
-      onClick: 'handleClickReplace'
-    }, {
-      label: replaceAll(),
-      icon: ReplaceAll,
-      disabled: !buttonsEnabled,
-      onClick: 'handleClickReplaceAll'
-    }];
+    const {
+      findButtons,
+      replaceButtons
+    } = getFindWidgetButtons(buttonsEnabled);
     const dom = getFindWidgetVirtualDom(matchCountText, newState.replaceExpanded, findButtons, replaceButtons);
     return ['Viewlet.setDom2', dom];
   }
@@ -10248,12 +10407,16 @@ const renderFocus = {
 //   },
 // }
 
-const render$1 = [renderDetails, renderBounds, renderValue, renderFocus];
+const render$2 = [renderDetails, renderBounds, renderValue, renderFocus];
 const apply = (oldState, newState) => {
-  return renderParts(render$1, oldState, newState);
+  // TODO avoid side effect
+  if (oldState.focus !== newState.focus) {
+    setFocus(newState.focus);
+  }
+  return renderParts(render$2, oldState, newState);
 };
 
-const render = widget => {
+const render$1 = widget => {
   const commands = apply(widget.oldState, widget.newState);
   const wrappedCommands = [];
   const uid = widget.newState.uid;
@@ -10266,10 +10429,10 @@ const render = widget => {
   }
   return wrappedCommands;
 };
-const add = widget => {
-  return addWidget(widget, 'FindWidget', render);
+const add$1 = widget => {
+  return addWidget(widget, 'FindWidget', render$1);
 };
-const remove = removeWidget;
+const remove$1 = removeWidget;
 const Commands = {
   'FindWidget.close': close$1,
   'FindWidget.focusNext': focusNext$1,
@@ -10277,13 +10440,38 @@ const Commands = {
   'FindWidget.focusIndex': focusIndex$1,
   'FindWidget.focusLast': focusLast,
   'FindWidget.toggleReplace': toggleReplace,
-  'FindWidget.handleFocus': handleFocus,
+  'FindWidget.handleFocus': focusFind,
   'FindWidget.handleBlur': handleBlur
 };
 
 const EditorFindWidget = {
   __proto__: null,
   Commands,
+  add: add$1,
+  remove: remove$1,
+  render: render$1
+};
+
+const render = widget => {
+  const commands = renderHover(widget.oldState, widget.newState);
+  const wrappedCommands = [];
+  const uid = widget.newState.uid;
+  for (const command of commands) {
+    if (command[0] === 'Viewlet.setDom2') {
+      wrappedCommands.push([command[0], uid, ...command.slice(1)]);
+    } else {
+      wrappedCommands.push(['Viewlet.send', uid, ...command]);
+    }
+  }
+  return wrappedCommands;
+};
+const add = widget => {
+  return addWidget(widget, 'EditorHover', render);
+};
+const remove = removeWidget;
+
+const EditorHoverWidget = {
+  __proto__: null,
   add,
   remove,
   render
@@ -10294,6 +10482,7 @@ const registerWidgets = () => {
   set(Completion, EditorCompletionWidget);
   set(CompletionDetail$1, EditorCompletionDetailWidget);
   set(Find, EditorFindWidget);
+  set(Hover, EditorHoverWidget);
 };
 
 const main = async () => {