@lvce-editor/editor-worker 3.19.0 → 3.20.0

package/dist/editorWorkerMain.js

@@ -1451,7 +1451,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(message, errorProperty);
 };
-const create$b = (message, result) => {
+const create$c = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -1460,7 +1460,7 @@ const create$b = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$b(message, resultProperty);
+  return create$c(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -1660,7 +1660,7 @@ const waitForFirstMessage$1 = async port => {
   return event;
 };
 
-const create$a = async () => {
+const create$b = async () => {
   const {
     port1,
     port2
@@ -1705,7 +1705,7 @@ const wrap$3 = port => {
 
 const IpcParentWithExtensionHostWorker = {
   __proto__: null,
-  create: create$a,
+  create: create$b,
   wrap: wrap$3
 };
 
@@ -1713,7 +1713,7 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
   await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
-const create$9 = async () => {
+const create$a = async () => {
   const {
     port1,
     port2
@@ -1758,7 +1758,7 @@ const wrap$1 = port => {
 
 const IpcParentWithSyntaxHighlightingWorker = {
   __proto__: null,
-  create: create$9,
+  create: create$a,
   wrap: wrap$1
 };
 
@@ -1766,7 +1766,7 @@ const sendMessagePortToRendererProcess = async port => {
   await invokeAndTransfer('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
 };
 
-const create$8 = async () => {
+const create$9 = async () => {
   const {
     port1,
     port2
@@ -1811,7 +1811,7 @@ const wrap = port => {
 
 const IpcParentWithRendererProcess = {
   __proto__: null,
-  create: create$8,
+  create: create$9,
   wrap
 };
 
@@ -1828,7 +1828,7 @@ const getModule$1 = method => {
   }
 };
 
-const create$7 = async ({
+const create$8 = async ({
   method,
   ...options
 }) => {
@@ -1846,7 +1846,7 @@ const create$7 = async ({
 const createRpc = method => {
   let _ipc;
   const listen = async () => {
-    const ipc = await create$7({
+    const ipc = await create$8({
       method
     });
     handleIpc(ipc);
@@ -2122,7 +2122,7 @@ const getAccurateColumnIndexAscii = (line, guess, averageCharWidth, eventX, font
 const supported = () => {
   return 'Segmenter' in Intl;
 };
-const create$6 = () => {
+const create$7 = () => {
   // @ts-ignore
   const segmenter = new Intl.Segmenter();
   return {
@@ -2160,7 +2160,7 @@ const create$6 = () => {
 
 // @ts-ignore
 const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const segmenter = create$6();
+  const segmenter = create$7();
   const segments = segmenter.getSegments(line);
   const isMonospaceFont = false;
   const charWidth = 0;
@@ -2395,6 +2395,7 @@ const CompletionDetail$1 = 'completionDetail';
 const ColorPicker$1 = 'colorPicker';
 const Find = 'find';
 const Hover = 'hover';
+const SourceAction = 'sourceAction';
 
 const isCompletionWidget = widget => {
   return widget.id === Completion;
@@ -2465,12 +2466,12 @@ const addWidgetToEditor = async (widgetId, focusKey, editor, factory, newStateGe
   return newEditor;
 };
 
-const create$5 = () => {
+const create$6 = () => {
   return Math.random();
 };
 
-const create$4 = () => {
-  const completionUid = create$5();
+const create$5 = () => {
+  const completionUid = create$6();
   const widget = {
     id: ColorPicker$1,
     oldState: {
@@ -2512,12 +2513,13 @@ const FocusFindWidgetCloseButton = 48;
 const FocusFindWidgetNextMatchButton = 49;
 const FocusFindWidgetPreviousMatchButton = 50;
 const FocusEditorHover = 51;
+const SourceActions = 52;
 
 const newStateGenerator$1 = state => {
   return loadContent$3(state);
 };
 const openColorPicker = async editor => {
-  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$4, newStateGenerator$1);
+  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$5, newStateGenerator$1);
 };
 
 const state$6 = {
@@ -2814,7 +2816,7 @@ const characterLeft = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create$6();
+  const segmenter = create$7();
   const last = segmenter.at(line, columnIndex - 1);
   return columnIndex - last.index;
 };
@@ -2825,7 +2827,7 @@ const characterRight = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create$6();
+  const segmenter = create$7();
   const next = segmenter.at(line, columnIndex);
   return next.segment.length;
 };
@@ -3239,36 +3241,105 @@ const deleteWordLeft = editor => {
   return newEditor;
 };
 
-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: []
+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 = [''];
     }
-  };
-  return widget;
+    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;
+  }
 };
 
 const RE_WORD_START$1 = /^[\w\-]+/;
@@ -3313,1774 +3384,1319 @@ const getWordBefore = (editor, rowIndex, columnIndex) => {
   return getWordBefore$1(line, columnIndex);
 };
 
-const OnCompletion = 'onCompletion';
-const OnHover = 'onHover';
-
-// TODO add tests for this
-const activateByEvent = async event => {
-  await invoke$3('ExtensionHostManagement.activateByEvent', event);
+// @ts-ignore
+const getDefinition = async (editor, offset) => {
+  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
+  return definition;
 };
 
-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 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 executeHoverProvider = (editor, offset) => {
-  object(editor);
-  number$1(offset);
-  return execute({
-    event: OnHover,
-    editor,
-    method: HoverExecute,
-    args: [offset],
-    noProviderFoundMessage: 'No hover provider found'
-  });
+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',
+  SourceAction: 'Source Action',
+  OrganizeImports: 'Organize Imports',
+  SortImports: 'Sort Imports'
 };
-
-const getHover = async (editor, offset) => {
-  object(editor);
-  number$1(offset);
-  // TODO invoke extension host worker directly
-  const hover = await executeHoverProvider(editor, offset);
-  return hover;
+const noDefinitionFound = () => {
+  return i18nString(UiStrings$1.NoDefinitionFound);
 };
-
-let _ipc;
-const listen$6 = async () => {
-  const ipc = await create$7({
-    method: RendererProcess
+const noDefinitionFoundFor = word => {
+  return i18nString(UiStrings$1.NoDefinitionFoundFor, {
+    PH1: word
   });
-  handleIpc(ipc);
-  _ipc = ipc;
 };
-const invoke$1 = async (method, ...args) => {
-  return invoke$5(_ipc, method, ...args);
+const noTypeDefinitionFoundFor = word => {
+  return i18nString(UiStrings$1.NoTypeDefinitionFoundFor, {
+    PH1: word
+  });
 };
-
-const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
-  return invoke$1('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
+const noTypeDefinitionFound = () => {
+  return i18nString(UiStrings$1.NoTypeDefinitionFound);
 };
-
-const deepCopy = value => {
-  return structuredClone(value);
+const noResults$1 = () => {
+  return i18nString(UiStrings$1.NoResults);
 };
-
-const getInitialLineState = initialLineState => {
-  return deepCopy(initialLineState);
+const organizeImports$1 = () => {
+  return i18nString(UiStrings$1.OrganizeImports);
 };
-
-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 sortImports = () => {
+  return i18nString(UiStrings$1.SortImports);
 };
 
-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) => {
+// @ts-ignore
+const goTo = async ({
+  editor,
+  getLocation,
+  getNoLocationFoundMessage,
+  getErrorMessage,
+  isNoProviderFoundError
+}) => {
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
   try {
-    const lineState = tokenizeLine(line, lineStateAtStart);
-    if (!lineState || !lineState.tokens || !lineState.state) {
-      throw new Error('invalid tokenization result');
+    const definition = await getLocation(editor, rowIndex, columnIndex);
+    // TODO if editor is already disposed at this point, do nothing
+    if (!definition) {
+      // TODO show popup that no definition was found
+      // TODO if there was an error, show popup that go to definition resulted in an error
+      const info = getWordAt(editor, rowIndex, columnIndex);
+      const message = getNoLocationFoundMessage(info);
+      return editorShowMessage(editor, rowIndex, columnIndex, message, false);
     }
-    if (!hasArrayReturn) {
-      warnDeprecatedArrayReturn(languageId, tokenizeLine);
-      // workaround for old tokenizers
-      lineState.tokens = flattenTokensArray(lineState.tokens);
+    if (typeof definition.uri !== 'string' || typeof definition.startOffset !== 'number' || typeof definition.endOffset !== 'number') {
+      // Logger.warn('invalid definition result', definition)
+      return editor;
     }
-    return lineState;
-  } catch (error) {
-    console.error(error);
-    return {
-      tokens: [/* type */0, /* length */line.length],
-      lineState: lineStateAtStart
+    const uri = definition.uri;
+    if (uri === editor.uri) {
+      // TODO set cursor to the definition position
+      const position = positionAt(editor, definition.startOffset);
+      const selectionEdits = new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]);
+      return scheduleSelections(editor, selectionEdits);
+    }
+    // TODO if definition.file is not of type string, show a popup that definition.file must be of type string
+    // TODO open file and scroll to that position and set cursor to that position
+
+    const context = {
+      startRowIndex: definition.startRowIndex,
+      startColumnIndex: definition.startColumnIndex,
+      endRowIndex: definition.endRowIndex,
+      endColumnIndex: definition.endColumnIndex
     };
+    await invoke$3(/* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
+    return editor;
+  } catch (error) {
+    // TODO if editor is already disposed at this point, do nothing
+    if (isNoProviderFoundError(error)) {
+      const displayErrorMessage = getErrorMessage(error);
+      await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, false);
+      return editor;
+    }
+    // @ts-ignore
+    // ErrorHandling.handleError(error, false)
+    const displayErrorMessage = getErrorMessage(error);
+    await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, true);
+    return editor;
   }
 };
 
-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;
-};
+// TODO race condition, check that editor hasn't been closed in the meantime
 
-/**
- * @enum number
- */
-const State = {
-  TopLevelContent: 1
+// TODO in case of error should show message "Definition Error: Cannot ready Property x of undefined"
+
+// TODO show some kind of message maybe ("No Definition found")
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+
+// TODO there are still race conditions in this function:
+// - when open is called twice, previous dom nodes can either be reused or the previous dom nodes must be disposed
+
+// @ts-ignore
+const getLocation$1 = async (editor, rowIndex, columnIndex) => {
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const definition = await getDefinition(editor, offset);
+  return definition;
 };
 
-/**
- * @enum number
- */
-const TokenType = {
-  Text: 1
+// @ts-ignore
+const getNoLocationFoundMessage$1 = info => {
+  if (info.word) {
+    return noDefinitionFoundFor(info.word);
+  }
+  return noDefinitionFound();
 };
-const TokenMap = {
-  [TokenType.Text]: 'Text'
+
+// @ts-ignore
+const getErrorMessage$3 = error => {
+  // if (
+  //   error &&
+  //   error.message &&
+  //   error.message.startsWith('Failed to execute definition provider: ')
+  // ) {
+  //   return error.message.replace('Failed to execute definition provider: ', '')
+  // }
+  return `${error}`;
 };
-const initialLineState = {
-  state: State.TopLevelContent
+
+// @ts-ignore
+const isNoProviderFoundError$1 = error => {
+  return error &&
+  // @ts-ignore
+  error.message &&
+  // @ts-ignore
+  error.message.startsWith('Failed to execute definition provider: No definition provider found');
 };
-const hasArrayReturn = true;
-const tokenizeLine = (line, lineState) => {
-  return {
-    tokens: [TokenType.Text, line.length],
-    state: lineState.state
-  };
+const goToDefinition = editor => {
+  return goTo({
+    editor,
+    getLocation: getLocation$1,
+    getNoLocationFoundMessage: getNoLocationFoundMessage$1,
+    getErrorMessage: getErrorMessage$3,
+    isNoProviderFoundError: isNoProviderFoundError$1
+  });
 };
 
-const TokenizePlainText = {
-  __proto__: null,
-  State,
-  TokenMap,
-  TokenType,
-  hasArrayReturn,
-  initialLineState,
-  tokenizeLine
+const getNoLocationFoundMessage = info => {
+  if (info.word) {
+    return noTypeDefinitionFoundFor(info.word);
+  }
+  return noTypeDefinitionFound();
 };
 
-const state$4 = {
-  tokenizers: Object.create(null),
-  tokenizePaths: Object.create(null),
-  listeners: [],
-  pending: Object.create(null),
-  /**
-   * @type {number[]}
-   */
-  connectedEditors: []
+const getTypeDefinition = async (editor, offset) => {
+  const definition = await invoke$3('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
+  return definition;
 };
-const has = languageId => {
-  return languageId in state$4.tokenizers;
+
+const getLocation = async (editor, rowIndex, columnIndex) => {
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const definition = await getTypeDefinition(editor, offset);
+  return definition;
 };
-const set$4 = (languageId, tokenizer) => {
-  state$4.tokenizers[languageId] = tokenizer;
+
+// @ts-ignore
+const getErrorMessage$2 = error => {
+  // if (
+  //   error &&
+  //   error.message &&
+  //   error.message.startsWith('Failed to execute type definition provider: ')
+  // ) {
+  //   return error.message.replace(
+  //     'Failed to execute type definition provider: ',
+  //     ''
+  //   )
+  // }
+  return `${error}`;
 };
-const get$4 = languageId => {
-  return state$4.tokenizers[languageId];
+const isNoProviderFoundError = error => {
+  return error &&
+  // @ts-ignore
+  error.message &&
+  // @ts-ignore
+  error.message.startsWith('Failed to execute type definition provider: No type definition provider found');
 };
-const isPending = languageId => {
-  return languageId in state$4.pending;
+const goToTypeDefinition = (editor, explicit = true) => {
+  return goTo({
+    editor,
+    getLocation,
+    getNoLocationFoundMessage: getNoLocationFoundMessage,
+    isNoProviderFoundError,
+    getErrorMessage: getErrorMessage$2
+  });
 };
 
-let enabled$1 = false;
-const setEnabled$1 = value => {
-  enabled$1 = value;
-};
-const getEnabled$1 = () => {
-  return enabled$1;
+const Editor = 3;
+
+const handleContextMenu = async (editor, button, x, y) => {
+  await invoke$3(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
+  return editor;
 };
 
-const {
-  listen: listen$5,
-  invoke
-} = createRpc(SyntaxHighlightingWorker);
+// @ts-ignore
 
-const tokenMaps = Object.create(null);
-const set$3 = (languageId, tokenMap) => {
-  tokenMaps[languageId] = tokenMap;
+// match all words, including umlauts, see https://stackoverflow.com/questions/5436824/matching-accented-characters-with-javascript-regexes/#answer-11550799
+const RE_WORD_START = /^[a-z\u00C0-\u017F\d]+/i;
+const RE_WORD_END = /[a-z\u00C0-\u017F\d]+$/i;
+
+// @ts-ignore
+const getNewSelections$7 = (line, rowIndex, columnIndex) => {
+  const before = line.slice(0, columnIndex);
+  const after = line.slice(columnIndex);
+  const beforeMatch = before.match(RE_WORD_END);
+  const afterMatch = after.match(RE_WORD_START);
+  const columnStart = columnIndex - (beforeMatch ? beforeMatch[0].length : 0);
+  const columnEnd = columnIndex + (afterMatch ? afterMatch[0].length : 0);
+  const newSelections = new Uint32Array([rowIndex, columnStart, rowIndex, columnEnd]);
+  return newSelections;
 };
-const get$3 = languageId => {
-  return tokenMaps[languageId] || {};
+
+// @ts-ignore
+const selectWord = (editor, rowIndex, columnIndex) => {
+  const line = getLine(editor, rowIndex);
+  const newSelections = getNewSelections$7(line, rowIndex, columnIndex);
+  return scheduleSelections(editor, newSelections);
 };
 
-// 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 handleDoubleClick = (editor, modifier, x, y) => {
+  const position = at(editor, x, y);
+  return selectWord(editor, position.rowIndex, position.columnIndex);
 };
 
-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 WhenExpressionEditorText = 12;
+const handleFocus = editor => {
+  // TODO make change events functional,
+  // when rendering, send focus changes to renderer worker
+  invoke$3('Focus.setFocus', WhenExpressionEditorText);
+  return editor;
 };
 
-const getHoverPosition = (position, selections) => {
-  if (position) {
-    return position;
+const Single = 1;
+const Double = 2;
+const Triple = 3;
+
+const state$5 = {
+  position: {
+    rowIndex: 0,
+    columnIndex: 0
   }
-  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 getPosition$1 = () => {
+  return state$5.position;
 };
-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
-  };
+// @ts-ignore
+const setPosition$1 = position => {
+  state$5.position = position;
 };
-const getEditorHoverInfo = async (editorUid, position) => {
-  number$1(editorUid);
-  const instance = get$7(editorUid);
-  const editor = instance.newState;
-  const {
-    selections
-  } = editor;
+
+const Ctrl = 1;
+const Alt = 2;
+
+// TODO first change cursor position, then run go to definition
+// cursor should appear at mousedown position immediately
+const handleSingleClickWithAlt = async (editor, position) => {
   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
+  } = position;
+  const newEditor = {
+    ...editor,
+    selections: new Uint32Array([rowIndex, columnIndex, rowIndex, columnIndex])
   };
+  // TODO rectangular selection with alt click,
+  // but also go to definition with alt click
+  const newEditor2 = await goToDefinition(newEditor);
+  return newEditor2;
 };
-
-const loadHoverContent = async state => {
-  // TODO
-  const position = undefined;
-  const hoverInfo = await getEditorHoverInfo(state.editorUid, position);
-  if (!hoverInfo) {
-    return state;
+const handleSingleClickWithCtrl = async (editor, position) => {
+  const selections = editor.selections;
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    if (selectionStartRow === position.rowIndex && selectionStartColumn === position.columnIndex && selectionEndRow === position.rowIndex && selectionEndColumn === position.columnIndex) {
+      // selection exists -> remove
+      const newSelections = new Uint32Array(selections.length - 4);
+      newSelections.set(selections.subarray(0, i), 0);
+      newSelections.set(selections.subarray(i + 4), i);
+      return scheduleSelections(editor, newSelections);
+    }
   }
-  const {
-    lineInfos,
-    documentation,
-    x,
-    y,
-    matchingDiagnostics
-  } = hoverInfo;
+  // TODO selection does not exist -> add
+  // TODO insert in order
+  const newSelections = new Uint32Array(selections.length + 4);
+  newSelections.set(selections, 0);
+  const insertIndex = selections.length;
+  newSelections[insertIndex] = position.rowIndex;
+  newSelections[insertIndex + 1] = position.columnIndex;
+  newSelections[insertIndex + 2] = position.rowIndex;
+  newSelections[insertIndex + 3] = position.columnIndex;
+  return scheduleSelections(editor, newSelections);
+};
+const handleSingleClickDefault = (editor, position) => {
+  setPosition$1(position);
   return {
-    ...state,
-    lineInfos,
-    documentation,
-    x,
-    y,
-    diagnostics: matchingDiagnostics
+    ...editor,
+    selections: new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]),
+    focused: true
   };
 };
-
-const newStateGenerator = state => {
-  return loadHoverContent(state);
-};
-const showHover2 = async editor => {
-  return addWidgetToEditor(Hover, FocusEditorHover, editor, create$3, newStateGenerator);
+const getFn = modifier => {
+  switch (modifier) {
+    case Alt:
+      return handleSingleClickWithAlt;
+    case Ctrl:
+      return handleSingleClickWithCtrl;
+    default:
+      return handleSingleClickDefault;
+  }
 };
-
-const deleteWordPartLeft = editor => {
-  const newEditor = editorDeleteHorizontalLeft(editor, wordPartLeft);
+const handleSingleClick = async (editor, modifier, x, y) => {
+  object(editor);
+  number$1(modifier);
+  number$1(x);
+  number$1(y);
+  const position = at(editor, x, y);
+  const fn = getFn(modifier);
+  const newEditor = await fn(editor, position);
+  // switch (newEditor.completionState) {
+  //   case EditorCompletionState.None:
+  //   case EditorCompletionState.Visible:
+  //   case EditorCompletionState.Loading:
+  //     return {
+  //       newState: newEditor,
+  //       commands: [],
+  //     }
+  //   default:
+  //     break
+  // }
   return newEditor;
 };
 
-const deleteWordPartRight = editor => {
-  return editorDeleteHorizontalRight(editor, wordPartRight);
+// @ts-ignore
+
+// @ts-ignore
+const getNewSelections$6 = (line, rowIndex) => {
+  // TODO handle virtual space when columnIndex is greater than line length
+  return new Uint32Array([rowIndex, 0, rowIndex, line.length]);
 };
 
-const deleteWordRight = editor => {
-  return editorDeleteHorizontalRight(editor, wordRight);
+// @ts-ignore
+const selectLine = editor => {
+  const selections = editor.selections;
+  const rowIndex = selections[editor.primarySelectionIndex];
+  const line = getLine(editor, rowIndex);
+  const newSelections = getNewSelections$6(line, rowIndex);
+  return scheduleSelections(editor, newSelections);
 };
 
-const findAllReferences = async editor => {
-  await invoke$3('SideBar.show', 'References', /* focus */true);
-  return editor;
+// TODO rowIndex and columnIndex should already be set because of singleClick which occurred before triple click
+// @ts-ignore
+const handleTripleClick = (editor, modifier, x, y) => {
+  object(editor);
+  number$1(x);
+  number$1(y);
+  return {
+    newState: selectLine(editor),
+    commands: []
+  };
 };
 
-// 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 handleMouseDown = (state, modifier, x, y, detail) => {
+  switch (detail) {
+    case Single:
+      return handleSingleClick(state, modifier, x, y);
+    case Double:
+      return handleDoubleClick(state, modifier, x, y);
+    case Triple:
+      return handleTripleClick(state, modifier, x, y);
+    default:
+      return state;
+  }
 };
 
-const warn = (...args) => {
-  console.warn(...args);
+const state$4 = {
+  timeout: -1,
+  x: 0,
+  y: 0,
+  editor: undefined
 };
-const error = (...args) => {
-  console.error(...args);
+const get$4 = () => {
+  return state$4;
+};
+const set$4 = (editor, timeout, x, y) => {
+  state$4.editor = editor;
+  state$4.timeout = timeout;
+  state$4.x = x;
+  state$4.y = y;
 };
 
-// @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;
+const showHover$1 = async (editor, position) => {
+  // TODO race condition
+  // await Viewlet.closeWidget(ViewletModuleId.EditorHover)
+  // await Viewlet.openWidget(ViewletModuleId.EditorHover, position)
+};
+
+// TODO several things can happen:
+// 1. highlight link when alt key is pressed
+// 2. show hover info
+// 3. selection moves
+// 4. highlight go to definition
+// 5. show color picker
+// 6. show error info
+
+const onHoverIdle = async () => {
+  const {
+    x,
+    y,
+    editor
+  } = get$4();
+  at(editor, x, y);
+  await showHover$1();
 };
+const hoverDelay = 300;
 
 // @ts-ignore
-const applyDocumentEdits = (editor, edits) => {
-  if (!Array.isArray(edits)) {
-    warn('something is wrong with format on save', edits);
+const handleMouseMove = (editor, x, y) => {
+  if (!editor.hoverEnabled) {
     return editor;
   }
-  if (edits.length === 0) {
-    return editor;
+  const oldState = get$4();
+  if (oldState.timeout !== -1) {
+    clearTimeout(oldState.timeout);
   }
-  const documentEdits = getDocumentEdits(editor, edits);
-  return scheduleDocumentAndCursorsSelections(editor, documentEdits);
+  const timeout = setTimeout(onHoverIdle, hoverDelay);
+  set$4(editor, timeout, x, y);
+  return editor;
 };
 
-const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
-const isFormattingError = error => {
-  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage);
+// @ts-ignore
+const getTokenIndex = (tokens, offset) => {
+  let currentOffset = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    currentOffset += token.length;
+    if (currentOffset >= offset) {
+      return i;
+    }
+  }
+  return -1;
 };
 
-// TODO also format with cursor
-const format = async editor => {
+// @ts-ignore
+const handleMouseMoveWithAltKey = async (editor, x, y) => {
+  object(editor);
+  number$1(x);
+  number$1(y);
+  const position = at(editor, x, y);
+  const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   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));
+    const definition = await getDefinition(editor, documentOffset);
+    if (!definition) {
       return editor;
     }
-    console.error(error);
-    const displayErrorMessage = `${error}`;
-    await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
+
+    // TODO make sure that editor is not disposed
+
+    const definitionStartPosition = positionAt(editor, definition.startOffset);
+    const definitionEndPosition = positionAt(editor, definition.endOffset);
+    // @ts-ignore
+    const definitionRelativeStartX = definitionStartPosition.columnIndex;
+    // @ts-ignore
+    const definitionRelativeEndX = definitionEndPosition.columnIndex;
+    // const definitionRelativeY = definitionStartPosition.rowIndex - editor.minLineY
+
+    const lineTokenMap = editor.lineCache[definitionStartPosition.rowIndex + 1];
+    if (!lineTokenMap) {
+      return editor;
+    }
+    const tokenIndex = getTokenIndex(lineTokenMap.tokens, definitionStartPosition.columnIndex);
+    if (tokenIndex === -1) {
+      return editor;
+    }
+    // .tokens
+    // await RendererProcess.invoke(
+    //   /* Viewlet.invoke */ 'Viewlet.send',
+    //   /* id */ ViewletModuleId.EditorText,
+    //   /* method */ 'highlightAsLink',
+    //   /* relativeY */ definitionRelativeY,
+    //   /* tokenIndex */ tokenIndex,
+    // )
     return editor;
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.message.startsWith('Failed to execute definition provider: No definition provider found')) {
+      return editor;
+    }
+    throw error;
   }
 };
 
+// TODO adjust relative position
 // @ts-ignore
-const getDefinition = async (editor, offset) => {
-  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
-  return definition;
+const getSelectionFromNativeRange = (editor, range) => {
+  return new Uint32Array([range.startRowIndex, range.startColumnIndex, range.endRowIndex, range.endColumnIndex]);
 };
 
-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];
+// @ts-ignore
+const getChanges$4 = (editor, data, range) => {
+  const selection = getSelectionFromNativeRange(editor, range);
+  const selectionRange = {
+    start: {
+      rowIndex: selection[0],
+      columnIndex: selection[1]
+    },
+    end: {
+      rowIndex: selection[2],
+      columnIndex: selection[3]
+    }
   };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  const changes = [{
+    start: selectionRange.start,
+    end: selectionRange.end,
+    inserted: [data],
+    deleted: getSelectionText(editor, selectionRange),
+    origin: ContentEditableInput
+  }];
+  return changes;
+};
+const handleBeforeInputFromContentEditable = (editor, data, range) => {
+  const changes = getChanges$4(editor, data, range);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-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'
+// @ts-ignore
+
+// @ts-ignore
+const editorHandleNativeSelectionChange = (editor, range) => {
+  const selections = getSelectionFromNativeRange(editor, range);
+  return scheduleSelections(editor, selections);
 };
-const noDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoDefinitionFound);
+
+const state$3 = {
+  /**
+   * @type {any}
+   */
+  currentEditor: undefined,
+  hasListener: false,
+  position: {
+    rowIndex: 0,
+    columnIndex: 0
+  }
 };
-const noDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoDefinitionFoundFor, {
-    PH1: word
-  });
+
+// @ts-ignore
+const setEditor = editor => {
+  state$3.currentEditor = editor;
+  state$3.hasListener = true;
 };
-const noTypeDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFoundFor, {
-    PH1: word
-  });
+const clearEditor = () => {
+  state$3.currentEditor = undefined;
+  state$3.hasListener = false;
 };
-const noTypeDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFound);
+
+// @ts-ignore
+const setPosition = position => {
+  state$3.position = position;
 };
-const noResults$1 = () => {
-  return i18nString(UiStrings$1.NoResults);
+const getEditor$1 = () => {
+  return state$3.currentEditor;
+};
+const getPosition = () => {
+  return state$3.position;
+};
+const hasListener = () => {
+  return state$3.hasListener;
 };
 
 // @ts-ignore
-const goTo = async ({
-  editor,
-  getLocation,
-  getNoLocationFoundMessage,
-  getErrorMessage,
-  isNoProviderFoundError
-}) => {
-  const {
-    selections
-  } = editor;
-  const rowIndex = selections[0];
-  const columnIndex = selections[1];
-  try {
-    const definition = await getLocation(editor, rowIndex, columnIndex);
-    // TODO if editor is already disposed at this point, do nothing
-    if (!definition) {
-      // TODO show popup that no definition was found
-      // TODO if there was an error, show popup that go to definition resulted in an error
-      const info = getWordAt(editor, rowIndex, columnIndex);
-      const message = getNoLocationFoundMessage(info);
-      return editorShowMessage(editor, rowIndex, columnIndex, message, false);
-    }
-    if (typeof definition.uri !== 'string' || typeof definition.startOffset !== 'number' || typeof definition.endOffset !== 'number') {
-      // Logger.warn('invalid definition result', definition)
-      return editor;
-    }
-    const uri = definition.uri;
-    if (uri === editor.uri) {
-      // TODO set cursor to the definition position
-      const position = positionAt(editor, definition.startOffset);
-      const selectionEdits = new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]);
-      return scheduleSelections(editor, selectionEdits);
-    }
-    // TODO if definition.file is not of type string, show a popup that definition.file must be of type string
-    // TODO open file and scroll to that position and set cursor to that position
-
-    const context = {
-      startRowIndex: definition.startRowIndex,
-      startColumnIndex: definition.startColumnIndex,
-      endRowIndex: definition.endRowIndex,
-      endColumnIndex: definition.endColumnIndex
-    };
-    await invoke$3(/* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
-    return editor;
-  } catch (error) {
-    // TODO if editor is already disposed at this point, do nothing
-    if (isNoProviderFoundError(error)) {
-      const displayErrorMessage = getErrorMessage(error);
-      await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, false);
-      return editor;
-    }
-    // @ts-ignore
-    // ErrorHandling.handleError(error, false)
-    const displayErrorMessage = getErrorMessage(error);
-    await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, true);
-    return editor;
-  }
+const handlePointerCaptureLost = editor => {
+  clearEditor();
+  return editor;
 };
 
-// TODO race condition, check that editor hasn't been closed in the meantime
-
-// TODO in case of error should show message "Definition Error: Cannot ready Property x of undefined"
-
-// TODO show some kind of message maybe ("No Definition found")
-
-// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
-
-// TODO there are still race conditions in this function:
-// - when open is called twice, previous dom nodes can either be reused or the previous dom nodes must be disposed
+// @ts-ignore
 
 // @ts-ignore
-const getLocation$1 = async (editor, rowIndex, columnIndex) => {
-  const offset = offsetAt(editor, rowIndex, columnIndex);
-  const definition = await getDefinition(editor, offset);
-  return definition;
+const getNewPercent$1 = (size, scrollBarSize, relativeX) => {
+  if (relativeX <= 0) {
+    return 0;
+  }
+  // if (relativeY <= editor.scrollBarHeight / 2) {
+  //   console.log('clicked at top')
+  //   // clicked at top
+  //   return 0
+  // }
+  if (relativeX <= size - scrollBarSize / 2) {
+    // clicked in middle
+    return relativeX / (size - scrollBarSize);
+  }
+  // clicked at bottom
+  return 1;
 };
 
 // @ts-ignore
-const getNoLocationFoundMessage$1 = info => {
-  if (info.word) {
-    return noDefinitionFoundFor(info.word);
+const handleScrollBarHorizontalMove = (state, eventX) => {
+  const {
+    x,
+    width,
+    longestLineWidth,
+    handleOffsetX
+  } = state;
+  const spaceRight = 20; // TODO make this configurable
+  const normalizedEventX = clamp(eventX, x, x + width);
+  if (width > longestLineWidth) {
+    return {
+      ...state,
+      deltaX: 0,
+      scrollBarWidth: 0
+    };
   }
-  return noDefinitionFound();
+  const relativeX = normalizedEventX - x - handleOffsetX;
+  const scrollBarWidth = getScrollBarWidth(width, longestLineWidth);
+  const finalDeltaX = longestLineWidth - width + spaceRight;
+  const newPercent = getNewPercent$1(width, scrollBarWidth, relativeX);
+  const clampedPercent = clamp(newPercent, 0, 1);
+  const newDeltaX = clampedPercent * finalDeltaX;
+  return {
+    ...state,
+    deltaX: newDeltaX
+  };
 };
 
 // @ts-ignore
-const getErrorMessage$3 = error => {
-  // if (
-  //   error &&
-  //   error.message &&
-  //   error.message.startsWith('Failed to execute definition provider: ')
-  // ) {
-  //   return error.message.replace('Failed to execute definition provider: ', '')
-  // }
-  return `${error}`;
-};
+
+// TODO duplicate code with vertical pointer down event listener
 
 // @ts-ignore
-const isNoProviderFoundError$1 = error => {
-  return error &&
-  // @ts-ignore
-  error.message &&
+const handleScrollBarHorizontalPointerDown = (state, eventX) => {
   // @ts-ignore
-  error.message.startsWith('Failed to execute definition provider: No definition provider found');
-};
-const goToDefinition = editor => {
-  return goTo({
-    editor,
-    getLocation: getLocation$1,
-    getNoLocationFoundMessage: getNoLocationFoundMessage$1,
-    getErrorMessage: getErrorMessage$3,
-    isNoProviderFoundError: isNoProviderFoundError$1
-  });
-};
-
-const getNoLocationFoundMessage = info => {
-  if (info.word) {
-    return noTypeDefinitionFoundFor(info.word);
+  const {
+    x,
+    deltaX,
+    width,
+    finalDeltaY,
+    height,
+    scrollBarHeight,
+    longestLineWidth
+  } = state;
+  const relativeX = eventX - x;
+  const scrollBarWidth = getScrollBarWidth(width, longestLineWidth);
+  const finalDeltaX = width - scrollBarWidth;
+  const currentScrollBarX = getScrollBarOffset(deltaX, finalDeltaX, width, scrollBarWidth);
+  const diff = relativeX - currentScrollBarX;
+  if (diff >= 0 && diff < scrollBarWidth) {
+    return {
+      ...state,
+      handleOffsetX: diff
+    };
   }
-  return noTypeDefinitionFound();
-};
-
-const getTypeDefinition = async (editor, offset) => {
-  const definition = await invoke$3('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
-  return definition;
+  const {
+    percent,
+    handleOffset
+  } = getNewDeltaPercent(width, scrollBarWidth, relativeX);
+  const newDeltaX = percent * finalDeltaX;
+  return {
+    ...state,
+    handleOffsetX: handleOffset,
+    deltaX: newDeltaX
+  };
 };
 
-const getLocation = async (editor, rowIndex, columnIndex) => {
-  const offset = offsetAt(editor, rowIndex, columnIndex);
-  const definition = await getTypeDefinition(editor, offset);
-  return definition;
-};
+// @ts-ignore
 
 // @ts-ignore
-const getErrorMessage$2 = error => {
-  // if (
-  //   error &&
-  //   error.message &&
-  //   error.message.startsWith('Failed to execute type definition provider: ')
-  // ) {
-  //   return error.message.replace(
-  //     'Failed to execute type definition provider: ',
-  //     ''
-  //   )
+const getNewPercent = (state, relativeY) => {
+  const {
+    height,
+    scrollBarHeight
+  } = state;
+  // if (relativeY <= editor.scrollBarHeight / 2) {
+  //   console.log('clicked at top')
+  //   // clicked at top
+  //   return 0
   // }
-  return `${error}`;
-};
-const isNoProviderFoundError = error => {
-  return error &&
-  // @ts-ignore
-  error.message &&
-  // @ts-ignore
-  error.message.startsWith('Failed to execute type definition provider: No type definition provider found');
-};
-const goToTypeDefinition = (editor, explicit = true) => {
-  return goTo({
-    editor,
-    getLocation,
-    getNoLocationFoundMessage: getNoLocationFoundMessage,
-    isNoProviderFoundError,
-    getErrorMessage: getErrorMessage$2
-  });
+  if (relativeY <= height - scrollBarHeight / 2) {
+    // clicked in middle
+    return relativeY / (height - scrollBarHeight);
+  }
+  // clicked at bottom
+  return 1;
 };
 
-const Editor = 3;
-
-const handleContextMenu = async (editor, button, x, y) => {
-  await invoke$3(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
-  return editor;
+// @ts-ignore
+const handleScrollBarMove = (state, eventY) => {
+  const {
+    y,
+    finalDeltaY,
+    handleOffset
+  } = state;
+  const relativeY = eventY - y - handleOffset;
+  const newPercent = getNewPercent(state, relativeY);
+  const newDeltaY = newPercent * finalDeltaY;
+  return setDeltaYFixedValue$1(state, newDeltaY);
 };
+const handleScrollBarVerticalPointerMove = handleScrollBarMove;
 
 // @ts-ignore
 
-// match all words, including umlauts, see https://stackoverflow.com/questions/5436824/matching-accented-characters-with-javascript-regexes/#answer-11550799
-const RE_WORD_START = /^[a-z\u00C0-\u017F\d]+/i;
-const RE_WORD_END = /[a-z\u00C0-\u017F\d]+$/i;
+// TODO scrollbar position can be in interval [0, editor.height - editor.scrollBarHeight]
+// when clicked at y <= editor.scrollbarHeight/2, position is set to zero
+// when clicked at y >= editor.height - editor.scrollBarHeight/2, position is set to (editor.height - scrollBarHeight/2)
+// when clicked at y > editor.height - editor.scrollBarHeight/2, position scrollbar at (y - scrollbarHeight/2)
+// additionally, when clicked on scrollbar, scrollbar position shouldn't move
 
 // @ts-ignore
-const getNewSelections$7 = (line, rowIndex, columnIndex) => {
-  const before = line.slice(0, columnIndex);
-  const after = line.slice(columnIndex);
-  const beforeMatch = before.match(RE_WORD_END);
-  const afterMatch = after.match(RE_WORD_START);
-  const columnStart = columnIndex - (beforeMatch ? beforeMatch[0].length : 0);
-  const columnEnd = columnIndex + (afterMatch ? afterMatch[0].length : 0);
-  const newSelections = new Uint32Array([rowIndex, columnStart, rowIndex, columnEnd]);
-  return newSelections;
+const handleScrollBarPointerDown = (state, eventY) => {
+  const {
+    y,
+    deltaY,
+    finalDeltaY,
+    height,
+    scrollBarHeight
+  } = state;
+  const relativeY = eventY - y;
+  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, height, scrollBarHeight);
+  const diff = relativeY - currentScrollBarY;
+  if (diff >= 0 && diff < scrollBarHeight) {
+    return {
+      ...state,
+      handleOffset: diff
+    };
+  }
+  const {
+    percent,
+    handleOffset
+  } = getNewDeltaPercent(height, scrollBarHeight, relativeY);
+  const newDeltaY = percent * finalDeltaY;
+  return {
+    ...setDeltaYFixedValue$1(state, newDeltaY),
+    handleOffset
+  };
 };
 
-// @ts-ignore
-const selectWord = (editor, rowIndex, columnIndex) => {
-  const line = getLine(editor, rowIndex);
-  const newSelections = getNewSelections$7(line, rowIndex, columnIndex);
-  return scheduleSelections(editor, newSelections);
+const state$2 = {
+  touchOffsetY: 0,
+  deltaY: 0
 };
 
-const handleDoubleClick = (editor, modifier, x, y) => {
-  const position = at(editor, x, y);
-  return selectWord(editor, position.rowIndex, position.columnIndex);
+// @ts-ignore
+const handleTouchStart = (editor, touchEvent) => {
+  if (touchEvent.touches.length === 0) {
+    return;
+  }
+  const firstTouch = touchEvent.touches[0];
+  state$2.touchOffsetY = firstTouch.y;
+  state$2.deltaY = editor.deltaY;
+  // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
+  // EditorMoveSelection.state.position = position
+  // state.date = Date.now()
 };
 
-const WhenExpressionEditorText = 12;
-const handleFocus = editor => {
-  // TODO make change events functional,
-  // when rendering, send focus changes to renderer worker
-  invoke$3('Focus.setFocus', WhenExpressionEditorText);
-  return editor;
-};
+const LessThan = -1;
+const Equal = 0;
+const GreaterThan = 1;
 
-const Single = 1;
-const Double = 2;
-const Triple = 3;
+// @ts-ignore
 
-const state$3 = {
-  position: {
-    rowIndex: 0,
-    columnIndex: 0
+// @ts-ignore
+const compare = (positionA, positionB) => {
+  if (positionA.rowIndex > positionB.rowIndex) {
+    return GreaterThan;
   }
-};
-const getPosition$1 = () => {
-  return state$3.position;
+  if (positionA.rowIndex === positionB.rowIndex) {
+    if (positionA.columnIndex > positionB.columnIndex) {
+      return GreaterThan;
+    }
+    if (positionA.columnIndex < positionB.columnIndex) {
+      return LessThan;
+    }
+    return Equal;
+  }
+  return LessThan;
 };
 
 // @ts-ignore
-const setPosition$1 = position => {
-  state$3.position = position;
+const editorMoveSelectionBackwards = (anchor, position) => {
+  return new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex, position.columnIndex]);
 };
 
-const Ctrl = 1;
-const Alt = 2;
-
-// TODO first change cursor position, then run go to definition
-// cursor should appear at mousedown position immediately
-const handleSingleClickWithAlt = async (editor, position) => {
-  const {
-    rowIndex,
-    columnIndex
-  } = position;
-  const newEditor = {
-    ...editor,
-    selections: new Uint32Array([rowIndex, columnIndex, rowIndex, columnIndex])
-  };
-  // TODO rectangular selection with alt click,
-  // but also go to definition with alt click
-  const newEditor2 = await goToDefinition(newEditor);
-  return newEditor2;
-};
-const handleSingleClickWithCtrl = async (editor, position) => {
-  const selections = editor.selections;
-  for (let i = 0; i < selections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
-    if (selectionStartRow === position.rowIndex && selectionStartColumn === position.columnIndex && selectionEndRow === position.rowIndex && selectionEndColumn === position.columnIndex) {
-      // selection exists -> remove
-      const newSelections = new Uint32Array(selections.length - 4);
-      newSelections.set(selections.subarray(0, i), 0);
-      newSelections.set(selections.subarray(i + 4), i);
-      return scheduleSelections(editor, newSelections);
-    }
-  }
-  // TODO selection does not exist -> add
-  // TODO insert in order
-  const newSelections = new Uint32Array(selections.length + 4);
-  newSelections.set(selections, 0);
-  const insertIndex = selections.length;
-  newSelections[insertIndex] = position.rowIndex;
-  newSelections[insertIndex + 1] = position.columnIndex;
-  newSelections[insertIndex + 2] = position.rowIndex;
-  newSelections[insertIndex + 3] = position.columnIndex;
-  return scheduleSelections(editor, newSelections);
+// @ts-ignore
+const editorMoveSelectionEqual = (anchor, position) => {
+  return new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]);
 };
-const handleSingleClickDefault = (editor, position) => {
-  setPosition$1(position);
-  return {
-    ...editor,
-    selections: new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]),
-    focused: true
-  };
+
+// @ts-ignore
+const editorMoveSelectionForwards = (anchor, position) => {
+  return new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex, position.columnIndex]);
 };
-const getFn = modifier => {
-  switch (modifier) {
-    case Alt:
-      return handleSingleClickWithAlt;
-    case Ctrl:
-      return handleSingleClickWithCtrl;
+
+// @ts-ignore
+const getNewSelections$5 = (anchor, position) => {
+  switch (compare(position, anchor)) {
+    case LessThan:
+      return editorMoveSelectionBackwards(anchor, position);
+    case Equal:
+      return editorMoveSelectionEqual(anchor, position);
+    case GreaterThan:
+      return editorMoveSelectionForwards(anchor, position);
     default:
-      return handleSingleClickDefault;
+      throw new Error('unexpected comparison result');
   }
 };
-const handleSingleClick = async (editor, modifier, x, y) => {
-  object(editor);
-  number$1(modifier);
-  number$1(x);
-  number$1(y);
-  const position = at(editor, x, y);
-  const fn = getFn(modifier);
-  const newEditor = await fn(editor, position);
-  // switch (newEditor.completionState) {
-  //   case EditorCompletionState.None:
-  //   case EditorCompletionState.Visible:
-  //   case EditorCompletionState.Loading:
-  //     return {
-  //       newState: newEditor,
-  //       commands: [],
-  //     }
-  //   default:
-  //     break
-  // }
-  return newEditor;
+
+// @ts-ignore
+const editorMoveSelection = (editor, position) => {
+  const anchor = getPosition$1();
+  const newSelections = getNewSelections$5(anchor, position);
+  // TODO if selection equals previous selection -> do nothing
+  return scheduleSelections(editor, newSelections);
 };
 
+const LONG_TOUCH_THRESHOLD = 150;
+
 // @ts-ignore
+const handleTouchEnd = (editor, touchEvent) => {
+  if (touchEvent.changedTouches.length === 0) {
+    return;
+  }
+  const firstTouch = touchEvent.changedTouches[0];
+  const position = at(editor, firstTouch.x, firstTouch.y);
+  // @ts-ignore
+  if (undefined.position.rowIndex === position.rowIndex && undefined.position.columnIndex === position.columnIndex) {
+    // @ts-ignore
+    if (Date.now() - state$2.date > LONG_TOUCH_THRESHOLD) {
+      selectWord(editor, position.rowIndex, position.columnIndex);
+    } else {
+      // @ts-ignore
+      cursorSet(editor, position);
+    }
+  } else {
+    console.log('different position');
+  }
+};
 
 // @ts-ignore
-const getNewSelections$6 = (line, rowIndex) => {
-  // TODO handle virtual space when columnIndex is greater than line length
-  return new Uint32Array([rowIndex, 0, rowIndex, line.length]);
+const setDeltaY = (editor, deltaY) => {
+  return setDeltaY$1(editor, deltaY);
 };
 
 // @ts-ignore
-const selectLine = editor => {
-  const selections = editor.selections;
-  const rowIndex = selections[editor.primarySelectionIndex];
-  const line = getLine(editor, rowIndex);
-  const newSelections = getNewSelections$6(line, rowIndex);
-  return scheduleSelections(editor, newSelections);
+const setDeltaYFixedValue = (editor, deltaY) => {
+  return setDeltaYFixedValue$1(editor, deltaY);
 };
 
-// TODO rowIndex and columnIndex should already be set because of singleClick which occurred before triple click
 // @ts-ignore
-const handleTripleClick = (editor, modifier, x, y) => {
-  object(editor);
-  number$1(x);
-  number$1(y);
+const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
+  number$1(deltaMode);
+  number$1(eventDeltaX);
+  number$1(eventDeltaY);
+  // @ts-ignore
+  const {
+    deltaX,
+    deltaY
+  } = editor;
+  if (eventDeltaX === 0) {
+    return setDeltaY(editor, eventDeltaY);
+  }
+  const newDeltaX = clamp(deltaX + eventDeltaX, 0, Number.POSITIVE_INFINITY);
   return {
-    newState: selectLine(editor),
-    commands: []
+    ...setDeltaY(editor, eventDeltaY),
+    deltaX: newDeltaX
   };
 };
 
-const handleMouseDown = (state, modifier, x, y, detail) => {
-  switch (detail) {
-    case Single:
-      return handleSingleClick(state, modifier, x, y);
-    case Double:
-      return handleDoubleClick(state, modifier, x, y);
-    case Triple:
-      return handleTripleClick(state, modifier, x, y);
-    default:
-      return state;
-  }
-};
-
-const state$2 = {
-  timeout: -1,
-  x: 0,
-  y: 0,
-  editor: undefined
-};
-const get$2 = () => {
-  return state$2;
-};
-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) => {
-  // TODO race condition
-  // await Viewlet.closeWidget(ViewletModuleId.EditorHover)
-  // await Viewlet.openWidget(ViewletModuleId.EditorHover, position)
-};
-
-// TODO several things can happen:
-// 1. highlight link when alt key is pressed
-// 2. show hover info
-// 3. selection moves
-// 4. highlight go to definition
-// 5. show color picker
-// 6. show error info
-
-const onHoverIdle = async () => {
-  const {
-    x,
-    y,
-    editor
-  } = get$2();
-  at(editor, x, y);
-  await showHover$1();
-};
-const hoverDelay = 300;
-
 // @ts-ignore
-const handleMouseMove = (editor, x, y) => {
-  if (!editor.hoverEnabled) {
-    return editor;
-  }
-  const oldState = get$2();
-  if (oldState.timeout !== -1) {
-    clearTimeout(oldState.timeout);
+const handleTouchMove = (editor, touchEvent) => {
+  if (touchEvent.touches.length === 0) {
+    return;
   }
-  const timeout = setTimeout(onHoverIdle, hoverDelay);
-  set$2(editor, timeout, x, y);
-  return editor;
+  const firstTouch = touchEvent.touches[0];
+  const offsetY = state$2.deltaY + (state$2.touchOffsetY - firstTouch.y);
+  setDeltaYFixedValue(editor, offsetY);
 };
 
 // @ts-ignore
-const getTokenIndex = (tokens, offset) => {
-  let currentOffset = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    currentOffset += token.length;
-    if (currentOffset >= offset) {
-      return i;
+const getChanges$3 = selections => {
+  const changes = [];
+  const rowsToIndentLess = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionEndRow = selections[i + 2];
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndentLess.push(i);
     }
   }
-  return -1;
-};
-
-// @ts-ignore
-const handleMouseMoveWithAltKey = async (editor, x, y) => {
-  object(editor);
-  number$1(x);
-  number$1(y);
-  const position = at(editor, x, y);
-  const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
-  try {
-    const definition = await getDefinition(editor, documentOffset);
-    if (!definition) {
-      return editor;
-    }
-
-    // TODO make sure that editor is not disposed
-
-    const definitionStartPosition = positionAt(editor, definition.startOffset);
-    const definitionEndPosition = positionAt(editor, definition.endOffset);
-    // @ts-ignore
-    const definitionRelativeStartX = definitionStartPosition.columnIndex;
-    // @ts-ignore
-    const definitionRelativeEndX = definitionEndPosition.columnIndex;
-    // const definitionRelativeY = definitionStartPosition.rowIndex - editor.minLineY
-
-    const lineTokenMap = editor.lineCache[definitionStartPosition.rowIndex + 1];
-    if (!lineTokenMap) {
-      return editor;
-    }
-    const tokenIndex = getTokenIndex(lineTokenMap.tokens, definitionStartPosition.columnIndex);
-    if (tokenIndex === -1) {
-      return editor;
-    }
-    // .tokens
-    // await RendererProcess.invoke(
-    //   /* Viewlet.invoke */ 'Viewlet.send',
-    //   /* id */ ViewletModuleId.EditorText,
-    //   /* method */ 'highlightAsLink',
-    //   /* relativeY */ definitionRelativeY,
-    //   /* tokenIndex */ tokenIndex,
-    // )
-    return editor;
-  } catch (error) {
-    // @ts-ignore
-    if (error && error.message.startsWith('Failed to execute definition provider: No definition provider found')) {
-      return editor;
-    }
-    throw error;
+  for (const rowToIndent of rowsToIndentLess) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 2
+      },
+      inserted: [''],
+      deleted: ['  '],
+      origin: IndentLess
+    });
   }
+  return changes;
 };
 
-// TODO adjust relative position
 // @ts-ignore
-const getSelectionFromNativeRange = (editor, range) => {
-  return new Uint32Array([range.startRowIndex, range.startColumnIndex, range.endRowIndex, range.endColumnIndex]);
+const indentLess = editor => {
+  const selections = editor.selections;
+  const changes = getChanges$3(selections);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-// @ts-ignore
-const getChanges$4 = (editor, data, range) => {
-  const selection = getSelectionFromNativeRange(editor, range);
-  const selectionRange = {
-    start: {
-      rowIndex: selection[0],
-      columnIndex: selection[1]
-    },
-    end: {
-      rowIndex: selection[2],
-      columnIndex: selection[3]
+const getChanges$2 = selections => {
+  const rowsToIndent = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionEndRow = selections[i + 2];
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndent.push(i);
     }
-  };
-  const changes = [{
-    start: selectionRange.start,
-    end: selectionRange.end,
-    inserted: [data],
-    deleted: getSelectionText(editor, selectionRange),
-    origin: ContentEditableInput
-  }];
+  }
+  const changes = [];
+  for (const rowToIndent of rowsToIndent) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      inserted: ['  '],
+      deleted: [''],
+      origin: IndentMore
+    });
+  }
   return changes;
 };
-const handleBeforeInputFromContentEditable = (editor, data, range) => {
-  const changes = getChanges$4(editor, data, range);
+const indentMore = editor => {
+  const {
+    selections
+  } = editor;
+  const changes = getChanges$2(selections);
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-// @ts-ignore
-
-// @ts-ignore
-const editorHandleNativeSelectionChange = (editor, range) => {
-  const selections = getSelectionFromNativeRange(editor, range);
-  return scheduleSelections(editor, selections);
+const getLanguageConfiguration = editor => {
+  return invoke$3('Languages.getLanguageConfiguration', {
+    uri: editor.uri,
+    languageId: editor.languageId
+  });
 };
 
-const state$1 = {
-  /**
-   * @type {any}
-   */
-  currentEditor: undefined,
-  hasListener: false,
-  position: {
-    rowIndex: 0,
-    columnIndex: 0
+const getIncreaseIndentRegex = languageConfiguration => {
+  if (languageConfiguration && languageConfiguration.indentationRules && languageConfiguration.indentationRules.increaseIndentPattern && typeof languageConfiguration.indentationRules.increaseIndentPattern === 'string') {
+    const regex = new RegExp(languageConfiguration.indentationRules.increaseIndentPattern);
+    return regex;
   }
+  return undefined;
 };
-
-// @ts-ignore
-const setEditor = editor => {
-  state$1.currentEditor = editor;
-  state$1.hasListener = true;
-};
-const clearEditor = () => {
-  state$1.currentEditor = undefined;
-  state$1.hasListener = false;
-};
-
-// @ts-ignore
-const setPosition = position => {
-  state$1.position = position;
-};
-const getEditor$1 = () => {
-  return state$1.currentEditor;
-};
-const getPosition = () => {
-  return state$1.position;
-};
-const hasListener = () => {
-  return state$1.hasListener;
-};
-
-// @ts-ignore
-const handlePointerCaptureLost = editor => {
-  clearEditor();
-  return editor;
-};
-
-// @ts-ignore
-
-// @ts-ignore
-const getNewPercent$1 = (size, scrollBarSize, relativeX) => {
-  if (relativeX <= 0) {
-    return 0;
-  }
-  // if (relativeY <= editor.scrollBarHeight / 2) {
-  //   console.log('clicked at top')
-  //   // clicked at top
-  //   return 0
-  // }
-  if (relativeX <= size - scrollBarSize / 2) {
-    // clicked in middle
-    return relativeX / (size - scrollBarSize);
+const shouldIncreaseIndent = (before, increaseIndentRegex) => {
+  if (!increaseIndentRegex) {
+    return false;
   }
-  // clicked at bottom
-  return 1;
+  return increaseIndentRegex.test(before);
 };
-
-// @ts-ignore
-const handleScrollBarHorizontalMove = (state, eventX) => {
-  const {
-    x,
-    width,
-    longestLineWidth,
-    handleOffsetX
-  } = state;
-  const spaceRight = 20; // TODO make this configurable
-  const normalizedEventX = clamp(eventX, x, x + width);
-  if (width > longestLineWidth) {
-    return {
-      ...state,
-      deltaX: 0,
-      scrollBarWidth: 0
+const getChanges$1 = (lines, selections, languageConfiguration) => {
+  const changes = [];
+  const selectionChanges = [];
+  const increaseIndentRegex = getIncreaseIndentRegex(languageConfiguration);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    const start = {
+      rowIndex: selectionStartRow,
+      columnIndex: selectionStartColumn
+    };
+    const end = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn
+    };
+    const range = {
+      start,
+      end
     };
+    if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
+      const line = lines[selectionStartRow];
+      const before = line.slice(0, selectionStartColumn);
+      const indent = getIndent(before);
+      if (shouldIncreaseIndent(before, increaseIndentRegex)) {
+        changes.push({
+          start: start,
+          end: end,
+          inserted: ['', indent + '  ', indent],
+          deleted: getSelectionText({
+            lines
+          }, range),
+          origin: InsertLineBreak
+        });
+        selectionChanges.push(selectionStartRow + 1, indent.length + 2, selectionStartRow + 1, indent.length + 2);
+      } else {
+        changes.push({
+          start: start,
+          end: end,
+          inserted: ['', indent],
+          deleted: getSelectionText({
+            lines
+          }, range),
+          origin: InsertLineBreak
+        });
+        selectionChanges.push(selectionStartRow + 1, indent.length, selectionStartRow + 1, indent.length);
+      }
+    } else {
+      changes.push({
+        start: start,
+        end: end,
+        inserted: ['', ''],
+        deleted: getSelectionText({
+          lines
+        }, range),
+        origin: InsertLineBreak
+      });
+      selectionChanges.push(selectionStartRow + 1, 0, selectionStartRow + 1, 0);
+    }
   }
-  const relativeX = normalizedEventX - x - handleOffsetX;
-  const scrollBarWidth = getScrollBarWidth(width, longestLineWidth);
-  const finalDeltaX = longestLineWidth - width + spaceRight;
-  const newPercent = getNewPercent$1(width, scrollBarWidth, relativeX);
-  const clampedPercent = clamp(newPercent, 0, 1);
-  const newDeltaX = clampedPercent * finalDeltaX;
   return {
-    ...state,
-    deltaX: newDeltaX
+    changes,
+    selectionChanges: new Uint32Array(selectionChanges)
   };
 };
-
-// @ts-ignore
-
-// TODO duplicate code with vertical pointer down event listener
-
-// @ts-ignore
-const handleScrollBarHorizontalPointerDown = (state, eventX) => {
-  // @ts-ignore
+const insertLineBreak = async editor => {
   const {
-    x,
-    deltaX,
-    width,
-    finalDeltaY,
-    height,
-    scrollBarHeight,
-    longestLineWidth
-  } = state;
-  const relativeX = eventX - x;
-  const scrollBarWidth = getScrollBarWidth(width, longestLineWidth);
-  const finalDeltaX = width - scrollBarWidth;
-  const currentScrollBarX = getScrollBarOffset(deltaX, finalDeltaX, width, scrollBarWidth);
-  const diff = relativeX - currentScrollBarX;
-  if (diff >= 0 && diff < scrollBarWidth) {
-    return {
-      ...state,
-      handleOffsetX: diff
-    };
-  }
+    lines,
+    selections
+  } = editor;
+  const languageConfiguration = await getLanguageConfiguration(editor);
   const {
-    percent,
-    handleOffset
-  } = getNewDeltaPercent(width, scrollBarWidth, relativeX);
-  const newDeltaX = percent * finalDeltaX;
-  return {
-    ...state,
-    handleOffsetX: handleOffset,
-    deltaX: newDeltaX
-  };
+    changes,
+    selectionChanges
+  } = getChanges$1(lines, selections, languageConfiguration);
+  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
 };
 
 // @ts-ignore
 
 // @ts-ignore
-const getNewPercent = (state, relativeY) => {
-  const {
-    height,
-    scrollBarHeight
-  } = state;
-  // if (relativeY <= editor.scrollBarHeight / 2) {
-  //   console.log('clicked at top')
-  //   // clicked at top
-  //   return 0
-  // }
-  if (relativeY <= height - scrollBarHeight / 2) {
-    // clicked in middle
-    return relativeY / (height - scrollBarHeight);
+const moveRectangleSelection = (editor, position) => {
+  // @ts-ignore
+  const anchor = undefined.position;
+  const startRowIndex = anchor.rowIndex;
+  const startColumnIndex = anchor.columnIndex;
+  const endRowIndex = position.rowIndex;
+  const endColumnIndex = position.columnIndex;
+  const selectionEdits = [];
+  for (let i = startRowIndex; i <= endRowIndex; i++) {
+    selectionEdits.push({
+      start: {
+        rowIndex: i,
+        columnIndex: startColumnIndex
+      },
+      end: {
+        rowIndex: i,
+        columnIndex: endColumnIndex
+      }
+    });
   }
-  // clicked at bottom
-  return 1;
+  // @ts-ignore
+  const cursorEdits = [selectionEdits.at(-1).end];
+  // @ts-ignore
+  undefined(editor, cursorEdits, selectionEdits);
 };
 
 // @ts-ignore
-const handleScrollBarMove = (state, eventY) => {
-  const {
-    y,
-    finalDeltaY,
-    handleOffset
-  } = state;
-  const relativeY = eventY - y - handleOffset;
-  const newPercent = getNewPercent(state, relativeY);
-  const newDeltaY = newPercent * finalDeltaY;
-  return setDeltaYFixedValue$1(state, newDeltaY);
+const moveRectangleSelectionPx = (editor, x, y) => {
+  const position = at(editor, x, y);
+  moveRectangleSelection(editor, position);
 };
-const handleScrollBarVerticalPointerMove = handleScrollBarMove;
-
-// @ts-ignore
 
-// TODO scrollbar position can be in interval [0, editor.height - editor.scrollBarHeight]
-// when clicked at y <= editor.scrollbarHeight/2, position is set to zero
-// when clicked at y >= editor.height - editor.scrollBarHeight/2, position is set to (editor.height - scrollBarHeight/2)
-// when clicked at y > editor.height - editor.scrollBarHeight/2, position scrollbar at (y - scrollbarHeight/2)
-// additionally, when clicked on scrollbar, scrollbar position shouldn't move
+const requestAnimationFrame = fn => {
+  globalThis.requestAnimationFrame(fn);
+};
 
 // @ts-ignore
-const handleScrollBarPointerDown = (state, eventY) => {
+const getNewEditor$1 = (editor, position) => {
   const {
-    y,
-    deltaY,
-    finalDeltaY,
-    height,
-    scrollBarHeight
-  } = state;
-  const relativeY = eventY - y;
-  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, height, scrollBarHeight);
-  const diff = relativeY - currentScrollBarY;
-  if (diff >= 0 && diff < scrollBarHeight) {
+    minLineY,
+    maxLineY,
+    rowHeight
+  } = editor;
+  const diff = maxLineY - minLineY;
+  if (position.rowIndex < minLineY) {
+    const newMinLineY = position.rowIndex;
+    const newMaxLineY = position.rowIndex + diff;
+    const newDeltaY = position.rowIndex * rowHeight;
+    const anchor = getPosition$1();
+    const newSelections = new Uint32Array([position.rowIndex - 1, position.columnIndex, anchor.rowIndex, anchor.columnIndex]);
     return {
-      ...state,
-      handleOffset: diff
+      ...editor,
+      minLineY: newMinLineY,
+      maxLineY: newMaxLineY,
+      deltaY: newDeltaY,
+      selections: newSelections
     };
   }
-  const {
-    percent,
-    handleOffset
-  } = getNewDeltaPercent(height, scrollBarHeight, relativeY);
-  const newDeltaY = percent * finalDeltaY;
-  return {
-    ...setDeltaYFixedValue$1(state, newDeltaY),
-    handleOffset
-  };
-};
-
-const state = {
-  touchOffsetY: 0,
-  deltaY: 0
+  if (position.rowIndex > maxLineY) {
+    const diff = maxLineY - minLineY;
+    const newMinLineY = position.rowIndex - diff;
+    const newMaxLineY = position.rowIndex;
+    const newDeltaY = newMinLineY * rowHeight;
+    const anchor = getPosition$1();
+    const newSelections = new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex + 1, position.columnIndex]);
+    return {
+      ...editor,
+      minLineY: newMinLineY,
+      maxLineY: newMaxLineY,
+      deltaY: newDeltaY,
+      selections: newSelections
+    };
+  }
+  return editor;
 };
-
-// @ts-ignore
-const handleTouchStart = (editor, touchEvent) => {
-  if (touchEvent.touches.length === 0) {
+const continueScrollingAndMovingSelection = async () => {
+  const editor = getEditor$1();
+  if (!editor) {
     return;
   }
-  const firstTouch = touchEvent.touches[0];
-  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()
-};
-
-const LessThan = -1;
-const Equal = 0;
-const GreaterThan = 1;
-
-// @ts-ignore
-
-// @ts-ignore
-const compare = (positionA, positionB) => {
-  if (positionA.rowIndex > positionB.rowIndex) {
-    return GreaterThan;
+  const position = getPosition();
+  if (position.rowIndex === 0) {
+    return;
   }
-  if (positionA.rowIndex === positionB.rowIndex) {
-    if (positionA.columnIndex > positionB.columnIndex) {
-      return GreaterThan;
-    }
-    if (positionA.columnIndex < positionB.columnIndex) {
-      return LessThan;
-    }
-    return Equal;
+  const newEditor = getNewEditor$1(editor, position);
+  if (editor === newEditor) {
+    return;
   }
-  return LessThan;
+  // await Viewlet.setState(ViewletModuleId.EditorText, newEditor)
+  setEditor(newEditor);
+  // @ts-ignore
+  const delta = position.rowIndex < editor.minLineY ? -1 : 1;
+  setPosition({
+    rowIndex: position.rowIndex + delta,
+    columnIndex: position.columnIndex
+  });
+  requestAnimationFrame(continueScrollingAndMovingSelection);
+  // TODO get editor state
+  // if editor is disposed, return and remove animation frame
+  // on cursor up, remove animation frame
+  //
 };
 
 // @ts-ignore
-const editorMoveSelectionBackwards = (anchor, position) => {
-  return new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex, position.columnIndex]);
+const moveSelectionPx = (editor, x, y) => {
+  object(editor);
+  number$1(x);
+  number$1(y);
+  const position = at(editor, x, y);
+  if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
+    requestAnimationFrame(continueScrollingAndMovingSelection);
+    setEditor(editor);
+    setPosition(position);
+  }
+  return editorMoveSelection(editor, position);
 };
 
-// @ts-ignore
-const editorMoveSelectionEqual = (anchor, position) => {
-  return new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]);
+const create$4 = () => {
+  const completionUid = create$6();
+  const completionWidget = {
+    id: Completion,
+    oldState: {
+      items: [],
+      itemHeight: 20,
+      maxHeight: 150,
+      minLineY: 0,
+      maxLineY: 0,
+      uid: completionUid,
+      focusedIndex: -1,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    },
+    newState: {
+      items: [],
+      itemHeight: 20,
+      maxHeight: 150,
+      minLineY: 0,
+      maxLineY: 10,
+      uid: completionUid,
+      focusedIndex: -1,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    }
+  };
+  return completionWidget;
 };
 
-// @ts-ignore
-const editorMoveSelectionForwards = (anchor, position) => {
-  return new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex, position.columnIndex]);
-};
+const OnCompletion = 'onCompletion';
+const OnHover = 'onHover';
 
-// @ts-ignore
-const getNewSelections$5 = (anchor, position) => {
-  switch (compare(position, anchor)) {
-    case LessThan:
-      return editorMoveSelectionBackwards(anchor, position);
-    case Equal:
-      return editorMoveSelectionEqual(anchor, position);
-    case GreaterThan:
-      return editorMoveSelectionForwards(anchor, position);
-    default:
-      throw new Error('unexpected comparison result');
-  }
+// TODO add tests for this
+const activateByEvent = async event => {
+  await invoke$3('ExtensionHostManagement.activateByEvent', event);
 };
 
-// @ts-ignore
-const editorMoveSelection = (editor, position) => {
-  const anchor = getPosition$1();
-  const newSelections = getNewSelections$5(anchor, position);
-  // TODO if selection equals previous selection -> do nothing
-  return scheduleSelections(editor, newSelections);
+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 LONG_TOUCH_THRESHOLD = 150;
-
-// @ts-ignore
-const handleTouchEnd = (editor, touchEvent) => {
-  if (touchEvent.changedTouches.length === 0) {
-    return;
-  }
-  const firstTouch = touchEvent.changedTouches[0];
-  const position = at(editor, firstTouch.x, firstTouch.y);
-  // @ts-ignore
-  if (undefined.position.rowIndex === position.rowIndex && undefined.position.columnIndex === position.columnIndex) {
-    // @ts-ignore
-    if (Date.now() - state.date > LONG_TOUCH_THRESHOLD) {
-      selectWord(editor, position.rowIndex, position.columnIndex);
-    } else {
-      // @ts-ignore
-      cursorSet(editor, position);
-    }
-  } else {
-    console.log('different position');
-  }
+const combineResults = results => {
+  return results[0] ?? [];
 };
-
-// @ts-ignore
-const setDeltaY = (editor, deltaY) => {
-  return setDeltaY$1(editor, deltaY);
+const executeCompletionProvider = (editor, offset) => {
+  return execute({
+    editor,
+    event: OnCompletion,
+    method: CompletionExecute,
+    args: [offset],
+    noProviderFoundMessage: 'no completion provider found',
+    noProviderFoundResult: [],
+    combineResults
+  });
 };
-
-// @ts-ignore
-const setDeltaYFixedValue = (editor, deltaY) => {
-  return setDeltaYFixedValue$1(editor, deltaY);
+const combineResultsResolve = items => {
+  return items[0] ?? undefined;
+};
+const executeResolveCompletionItem = (editor, offset, name, completionItem) => {
+  return execute({
+    editor,
+    event: OnCompletion,
+    method: CompletionResolveExecute,
+    args: [offset, name, completionItem],
+    noProviderFoundMessage: 'no completion provider found',
+    noProviderFoundResult: [],
+    combineResults: combineResultsResolve
+  });
 };
 
-// @ts-ignore
-const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
-  number$1(deltaMode);
-  number$1(eventDeltaX);
-  number$1(eventDeltaY);
-  // @ts-ignore
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+const getCompletions = async editor => {
   const {
-    deltaX,
-    deltaY
+    selections
   } = editor;
-  if (eventDeltaX === 0) {
-    return setDeltaY(editor, eventDeltaY);
-  }
-  const newDeltaX = clamp(deltaX + eventDeltaX, 0, Number.POSITIVE_INFINITY);
-  return {
-    ...setDeltaY(editor, eventDeltaY),
-    deltaX: newDeltaX
-  };
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  // Editor.sync(editor)
+  const offset = await offsetAt(editor, rowIndex, columnIndex);
+  const completions = await executeCompletionProvider(editor, offset);
+  return completions;
 };
 
-// @ts-ignore
-const handleTouchMove = (editor, touchEvent) => {
-  if (touchEvent.touches.length === 0) {
-    return;
+// TODO don't send unnecessary parts of completion item like matches
+const resolveCompletion = async (editor, name, completionItem) => {
+  try {
+    object(editor);
+    string(name);
+    object(completionItem);
+    const rowIndex = editor.selections[0];
+    const columnIndex = editor.selections[1];
+    const offset = await offsetAt(editor, rowIndex, columnIndex);
+    // @ts-ignore
+    const resolvedCompletionItem = await executeResolveCompletionItem(editor, offset, name, completionItem);
+    return resolvedCompletionItem;
+  } catch {
+    return undefined;
   }
-  const firstTouch = touchEvent.touches[0];
-  const offsetY = state.deltaY + (state.touchOffsetY - firstTouch.y);
-  setDeltaYFixedValue(editor, offsetY);
 };
 
-// @ts-ignore
-const getChanges$3 = selections => {
-  const changes = [];
-  const rowsToIndentLess = [];
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i];
-    const selectionEndRow = selections[i + 2];
-    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
-      rowsToIndentLess.push(i);
-    }
-  }
-  for (const rowToIndent of rowsToIndentLess) {
-    changes.push({
-      start: {
-        rowIndex: rowToIndent,
-        columnIndex: 0
-      },
-      end: {
-        rowIndex: rowToIndent,
-        columnIndex: 2
-      },
-      inserted: [''],
-      deleted: ['  '],
-      origin: IndentLess
-    });
-  }
-  return changes;
-};
-
-// @ts-ignore
-const indentLess = editor => {
-  const selections = editor.selections;
-  const changes = getChanges$3(selections);
-  return scheduleDocumentAndCursorsSelections(editor, changes);
-};
-
-const getChanges$2 = selections => {
-  const rowsToIndent = [];
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i];
-    const selectionEndRow = selections[i + 2];
-    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
-      rowsToIndent.push(i);
-    }
-  }
-  const changes = [];
-  for (const rowToIndent of rowsToIndent) {
-    changes.push({
-      start: {
-        rowIndex: rowToIndent,
-        columnIndex: 0
-      },
-      end: {
-        rowIndex: rowToIndent,
-        columnIndex: 0
-      },
-      inserted: ['  '],
-      deleted: [''],
-      origin: IndentMore
-    });
-  }
-  return changes;
-};
-const indentMore = editor => {
-  const {
-    selections
-  } = editor;
-  const changes = getChanges$2(selections);
-  return scheduleDocumentAndCursorsSelections(editor, changes);
-};
-
-const getLanguageConfiguration = editor => {
-  return invoke$3('Languages.getLanguageConfiguration', {
-    uri: editor.uri,
-    languageId: editor.languageId
-  });
-};
-
-const getIncreaseIndentRegex = languageConfiguration => {
-  if (languageConfiguration && languageConfiguration.indentationRules && languageConfiguration.indentationRules.increaseIndentPattern && typeof languageConfiguration.indentationRules.increaseIndentPattern === 'string') {
-    const regex = new RegExp(languageConfiguration.indentationRules.increaseIndentPattern);
-    return regex;
-  }
-  return undefined;
-};
-const shouldIncreaseIndent = (before, increaseIndentRegex) => {
-  if (!increaseIndentRegex) {
-    return false;
-  }
-  return increaseIndentRegex.test(before);
-};
-const getChanges$1 = (lines, selections, languageConfiguration) => {
-  const changes = [];
-  const selectionChanges = [];
-  const increaseIndentRegex = getIncreaseIndentRegex(languageConfiguration);
-  for (let i = 0; i < selections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
-    const start = {
-      rowIndex: selectionStartRow,
-      columnIndex: selectionStartColumn
-    };
-    const end = {
-      rowIndex: selectionEndRow,
-      columnIndex: selectionEndColumn
-    };
-    const range = {
-      start,
-      end
-    };
-    if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
-      const line = lines[selectionStartRow];
-      const before = line.slice(0, selectionStartColumn);
-      const indent = getIndent(before);
-      if (shouldIncreaseIndent(before, increaseIndentRegex)) {
-        changes.push({
-          start: start,
-          end: end,
-          inserted: ['', indent + '  ', indent],
-          deleted: getSelectionText({
-            lines
-          }, range),
-          origin: InsertLineBreak
-        });
-        selectionChanges.push(selectionStartRow + 1, indent.length + 2, selectionStartRow + 1, indent.length + 2);
-      } else {
-        changes.push({
-          start: start,
-          end: end,
-          inserted: ['', indent],
-          deleted: getSelectionText({
-            lines
-          }, range),
-          origin: InsertLineBreak
-        });
-        selectionChanges.push(selectionStartRow + 1, indent.length, selectionStartRow + 1, indent.length);
-      }
-    } else {
-      changes.push({
-        start: start,
-        end: end,
-        inserted: ['', ''],
-        deleted: getSelectionText({
-          lines
-        }, range),
-        origin: InsertLineBreak
-      });
-      selectionChanges.push(selectionStartRow + 1, 0, selectionStartRow + 1, 0);
-    }
-  }
-  return {
-    changes,
-    selectionChanges: new Uint32Array(selectionChanges)
-  };
-};
-const insertLineBreak = async editor => {
-  const {
-    lines,
-    selections
-  } = editor;
-  const languageConfiguration = await getLanguageConfiguration(editor);
-  const {
-    changes,
-    selectionChanges
-  } = getChanges$1(lines, selections, languageConfiguration);
-  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
-};
-
-// @ts-ignore
-
-// @ts-ignore
-const moveRectangleSelection = (editor, position) => {
-  // @ts-ignore
-  const anchor = undefined.position;
-  const startRowIndex = anchor.rowIndex;
-  const startColumnIndex = anchor.columnIndex;
-  const endRowIndex = position.rowIndex;
-  const endColumnIndex = position.columnIndex;
-  const selectionEdits = [];
-  for (let i = startRowIndex; i <= endRowIndex; i++) {
-    selectionEdits.push({
-      start: {
-        rowIndex: i,
-        columnIndex: startColumnIndex
-      },
-      end: {
-        rowIndex: i,
-        columnIndex: endColumnIndex
-      }
-    });
-  }
-  // @ts-ignore
-  const cursorEdits = [selectionEdits.at(-1).end];
-  // @ts-ignore
-  undefined(editor, cursorEdits, selectionEdits);
-};
-
-// @ts-ignore
-const moveRectangleSelectionPx = (editor, x, y) => {
-  const position = at(editor, x, y);
-  moveRectangleSelection(editor, position);
-};
-
-const requestAnimationFrame = fn => {
-  globalThis.requestAnimationFrame(fn);
-};
-
-// @ts-ignore
-const getNewEditor$1 = (editor, position) => {
-  const {
-    minLineY,
-    maxLineY,
-    rowHeight
-  } = editor;
-  const diff = maxLineY - minLineY;
-  if (position.rowIndex < minLineY) {
-    const newMinLineY = position.rowIndex;
-    const newMaxLineY = position.rowIndex + diff;
-    const newDeltaY = position.rowIndex * rowHeight;
-    const anchor = getPosition$1();
-    const newSelections = new Uint32Array([position.rowIndex - 1, position.columnIndex, anchor.rowIndex, anchor.columnIndex]);
-    return {
-      ...editor,
-      minLineY: newMinLineY,
-      maxLineY: newMaxLineY,
-      deltaY: newDeltaY,
-      selections: newSelections
-    };
-  }
-  if (position.rowIndex > maxLineY) {
-    const diff = maxLineY - minLineY;
-    const newMinLineY = position.rowIndex - diff;
-    const newMaxLineY = position.rowIndex;
-    const newDeltaY = newMinLineY * rowHeight;
-    const anchor = getPosition$1();
-    const newSelections = new Uint32Array([anchor.rowIndex, anchor.columnIndex, position.rowIndex + 1, position.columnIndex]);
-    return {
-      ...editor,
-      minLineY: newMinLineY,
-      maxLineY: newMaxLineY,
-      deltaY: newDeltaY,
-      selections: newSelections
-    };
-  }
-  return editor;
-};
-const continueScrollingAndMovingSelection = async () => {
-  const editor = getEditor$1();
-  if (!editor) {
-    return;
-  }
-  const position = getPosition();
-  if (position.rowIndex === 0) {
-    return;
-  }
-  const newEditor = getNewEditor$1(editor, position);
-  if (editor === newEditor) {
-    return;
-  }
-  // await Viewlet.setState(ViewletModuleId.EditorText, newEditor)
-  setEditor(newEditor);
-  // @ts-ignore
-  const delta = position.rowIndex < editor.minLineY ? -1 : 1;
-  setPosition({
-    rowIndex: position.rowIndex + delta,
-    columnIndex: position.columnIndex
-  });
-  requestAnimationFrame(continueScrollingAndMovingSelection);
-  // TODO get editor state
-  // if editor is disposed, return and remove animation frame
-  // on cursor up, remove animation frame
-  //
-};
-
-// @ts-ignore
-const moveSelectionPx = (editor, x, y) => {
-  object(editor);
-  number$1(x);
-  number$1(y);
-  const position = at(editor, x, y);
-  if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
-    requestAnimationFrame(continueScrollingAndMovingSelection);
-    setEditor(editor);
-    setPosition(position);
-  }
-  return editorMoveSelection(editor, position);
-};
-
-const create$2 = () => {
-  const completionUid = create$5();
-  const completionWidget = {
-    id: Completion,
-    oldState: {
-      items: [],
-      itemHeight: 20,
-      maxHeight: 150,
-      minLineY: 0,
-      maxLineY: 0,
-      uid: completionUid,
-      focusedIndex: -1,
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0
-    },
-    newState: {
-      items: [],
-      itemHeight: 20,
-      maxHeight: 150,
-      minLineY: 0,
-      maxLineY: 10,
-      uid: completionUid,
-      focusedIndex: -1,
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0
-    }
-  };
-  return completionWidget;
-};
-
-const combineResults = results => {
-  return results[0] ?? [];
-};
-const executeCompletionProvider = (editor, offset) => {
-  return execute({
-    editor,
-    event: OnCompletion,
-    method: CompletionExecute,
-    args: [offset],
-    noProviderFoundMessage: 'no completion provider found',
-    noProviderFoundResult: [],
-    combineResults
-  });
-};
-const combineResultsResolve = items => {
-  return items[0] ?? undefined;
-};
-const executeResolveCompletionItem = (editor, offset, name, completionItem) => {
-  return execute({
-    editor,
-    event: OnCompletion,
-    method: CompletionResolveExecute,
-    args: [offset, name, completionItem],
-    noProviderFoundMessage: 'no completion provider found',
-    noProviderFoundResult: [],
-    combineResults: combineResultsResolve
-  });
-};
-
-// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
-const getCompletions = async editor => {
-  const {
-    selections
-  } = editor;
-  const rowIndex = selections[0];
-  const columnIndex = selections[1];
-  // Editor.sync(editor)
-  const offset = await offsetAt(editor, rowIndex, columnIndex);
-  const completions = await executeCompletionProvider(editor, offset);
-  return completions;
-};
-
-// TODO don't send unnecessary parts of completion item like matches
-const resolveCompletion = async (editor, name, completionItem) => {
-  try {
-    object(editor);
-    string(name);
-    object(completionItem);
-    const rowIndex = editor.selections[0];
-    const columnIndex = editor.selections[1];
-    const offset = await offsetAt(editor, rowIndex, columnIndex);
-    // @ts-ignore
-    const resolvedCompletionItem = await executeResolveCompletionItem(editor, offset, name, completionItem);
-    return resolvedCompletionItem;
-  } catch {
-    return undefined;
-  }
-};
-
-const None$1 = 1;
+const None$1 = 1;
 
 const Diagonal = 1;
 const Left = 2;
@@ -5452,7 +5068,7 @@ const openCompletion = async editor => {
   if (hasWidget(widgets, Completion)) {
     return editor;
   }
-  const completionWidget = create$2();
+  const completionWidget = create$4();
   const newWidgets = [...widgets, completionWidget];
   const newEditor = {
     ...editor,
@@ -5481,8 +5097,8 @@ const User = 1;
 const Script = 2;
 const Unknown$1 = 0;
 
-const create$1 = () => {
-  const uid = create$5();
+const create$3 = () => {
+  const uid = create$6();
   const widget = {
     id: Find,
     oldState: {
@@ -5879,7 +5495,7 @@ const openFind2 = async editor => {
     return latestState;
   };
   const fullFocus = true;
-  return addWidgetToEditor(Find, FindWidget, editor, create$1, newStateGenerator, fullFocus);
+  return addWidgetToEditor(Find, FindWidget, editor, create$3, newStateGenerator, fullFocus);
 };
 
 const openFind = async state => {
@@ -6429,228 +6045,623 @@ const getSelectionEditsSingleLineWord = (lines, selections) => {
       };
     }
   }
-  return undefined;
+  return undefined;
+};
+const getSelectNextOccurrenceResult = editor => {
+  const lines = editor.lines;
+  const selections = editor.selections;
+  if (isEverySelectionEmpty(selections)) {
+    const newSelections = new Uint32Array(selections.length);
+    for (let i = 0; i < selections.length; i += 4) {
+      const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+      const wordMatch = getWordMatchAtPosition(lines, selectionStartRow, selectionStartColumn);
+      if (wordMatch.start === wordMatch.end) {
+        newSelections[i] = selectionStartRow;
+        newSelections[i + 1] = selectionStartColumn;
+        newSelections[i + 2] = selectionEndRow;
+        newSelections[i + 3] = selectionEndColumn;
+      } else {
+        newSelections[i] = selectionStartRow;
+        newSelections[i + 1] = wordMatch.start;
+        newSelections[i + 2] = selectionStartRow;
+        newSelections[i + 3] = wordMatch.end;
+      }
+    }
+    return {
+      selectionEdits: newSelections,
+      revealRange: newSelections.length - 4 // TODO should be primary selection
+    };
+  }
+  if (isEverySelectionSingleLine(editor.selections)) {
+    return getSelectionEditsSingleLineWord(editor.lines, editor.selections);
+  }
+  return undefined;
+};
+
+// TODO handle virtual space
+
+// TODO editors behave differently when selecting next occurrence, for example:
+
+// aaa
+// bbb 1
+// ccc
+// bbb 2
+// bbb 3
+// aaa
+// bbb 4
+// ccc
+
+// when clicking first at position 4 and then position 2,
+// - vscode selects next position 3 and refuses to select position 1
+// - atom also selects next position 3 and refuses to select position 1
+// - WebStorm also selects next position 3 and refuses to select position 1
+// - brackets (codemirror) selects position 3 and then selects position 1
+// - sublime selects next position 1, then next position 3
+
+const isRangeInViewPort = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
+  return startRowIndex >= minLineY && endRowIndex <= maxLineY;
+};
+
+// TODO handle virtual space
+const selectNextOccurrence = editor => {
+  const result = getSelectNextOccurrenceResult(editor);
+  if (!result) {
+    return editor;
+  }
+  const revealRange = result.revealRange;
+  const selectionEdits = result.selectionEdits;
+  const revealRangeStartRowIndex = selectionEdits[revealRange];
+  const revealRangeEndRowIndex = selectionEdits[revealRange + 2];
+  if (isRangeInViewPort(editor.minLineY, editor.maxLineY, revealRangeStartRowIndex, revealRangeEndRowIndex)) {
+    return scheduleSelections(editor, selectionEdits);
+  }
+  // TODO what is this magic number 5?
+  // const deltaY = (revealRangeStartRowIndex - 5) * editor.rowHeight
+  return scheduleDocumentAndCursorsSelections(editor, [], selectionEdits);
+};
+
+// @ts-ignore
+const selectPreviousOccurrence = editor => {
+  return editor;
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getSelectUpChanges = (lines, selections) => {
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    newSelections[i] = Math.max(selectionStartRow - 1, 0);
+    newSelections[i + 1] = selectionStartColumn;
+    newSelections[i + 2] = selectionEndRow;
+    newSelections[i + 3] = selectionEndColumn;
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const selectUp = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getSelectUpChanges(lines, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const selectWordLeft = editor => {
+  return editorSelectHorizontalLeft(editor, wordLeft);
+};
+
+// @ts-ignore
+const selectWordRight = editor => {
+  return editorSelectHorizontalRight(editor, wordRight);
+};
+
+// import * as ExtensionHostSelection from '../ExtensionHost/ExtensionHostSelection.ts'
+
+const getNewSelections = async (editor, selections) => {
+  const newSelections = await invoke$3('ExtensionHostSelection.executeGrowSelection', editor, selections);
+  if (newSelections.length === 0) {
+    return selections;
+  }
+  return new Uint32Array(newSelections);
+};
+const selectionGrow = async editor => {
+  const {
+    selections
+  } = editor;
+  const newSelections = await getNewSelections(editor, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+const setDecorations = (editor, decorations, diagnostics) => {
+  if (editor.decorations.length === 0 && decorations.length === 0) {
+    return editor;
+  }
+  return {
+    ...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 getSelectNextOccurrenceResult = editor => {
-  const lines = editor.lines;
-  const selections = editor.selections;
-  if (isEverySelectionEmpty(selections)) {
-    const newSelections = new Uint32Array(selections.length);
-    for (let i = 0; i < selections.length; i += 4) {
-      const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
-      const wordMatch = getWordMatchAtPosition(lines, selectionStartRow, selectionStartColumn);
-      if (wordMatch.start === wordMatch.end) {
-        newSelections[i] = selectionStartRow;
-        newSelections[i + 1] = selectionStartColumn;
-        newSelections[i + 2] = selectionEndRow;
-        newSelections[i + 3] = selectionEndColumn;
-      } else {
-        newSelections[i] = selectionStartRow;
-        newSelections[i + 1] = wordMatch.start;
-        newSelections[i + 2] = selectionStartRow;
-        newSelections[i + 3] = wordMatch.end;
-      }
-    }
+
+const tokenizers = Object.create(null);
+const set$1 = (id, value) => {
+  tokenizers[id] = value;
+};
+const get$1 = id => {
+  return tokenizers[id] || TokenizePlainText;
+};
+
+// TODO add command to set language id
+// without needing to specify tokenizePath
+const setLanguageId = async (editor, languageId, tokenizePath) => {
+  const {
+    tokenizerId
+  } = editor;
+  // TODO move tokenizer to syntax highlighting worker
+  // TODO only load tokenizer if not already loaded
+  // if already loaded just set tokenizer and rerender text
+  // TODO race condition
+  await loadTokenizer(languageId, tokenizePath);
+  const tokenizer = getTokenizer(languageId);
+  const newTokenizerId = tokenizerId + 1;
+  set$1(newTokenizerId, tokenizer);
+  const latest = getEditor(editor.uid);
+  if (!latest) {
+    return editor;
+  }
+  // TODO don't update editor if tokenizer was already loaded
+  // TODO update syntax highlighting
+  // TODO get edits
+
+  return {
+    ...latest,
+    languageId,
+    invalidStartIndex: 0,
+    tokenizerId: newTokenizerId
+  };
+};
+
+const setSelections = (editor, selections) => {
+  const {
+    minLineY,
+    maxLineY,
+    rowHeight
+  } = editor;
+  const startRowIndex = selections[0];
+  if (startRowIndex < minLineY) {
+    const deltaY = startRowIndex * rowHeight;
     return {
-      selectionEdits: newSelections,
-      revealRange: newSelections.length - 4 // TODO should be primary selection
+      ...editor,
+      minLineY: startRowIndex,
+      maxLineY: startRowIndex + 1,
+      selections,
+      deltaY
     };
   }
-  if (isEverySelectionSingleLine(editor.selections)) {
-    return getSelectionEditsSingleLineWord(editor.lines, editor.selections);
+  if (startRowIndex > maxLineY) {
+    const deltaY = startRowIndex * rowHeight;
+    return {
+      ...editor,
+      minLineY: startRowIndex,
+      maxLineY: startRowIndex + 1,
+      selections,
+      deltaY
+    };
   }
-  return undefined;
+  return {
+    ...editor,
+    selections
+  };
 };
 
-// TODO handle virtual space
+const EditorHover = 'EditorHover';
+const showHover = async state => {
+  await invoke$3('Viewlet.openWidget', EditorHover);
+  return state;
+};
 
-// TODO editors behave differently when selecting next occurrence, for example:
+const create$2 = () => {
+  const uid = create$6();
+  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: []
+    }
+  };
+  return widget;
+};
 
-// aaa
-// bbb 1
-// ccc
-// bbb 2
-// bbb 3
-// aaa
-// bbb 4
-// ccc
+const executeHoverProvider = (editor, offset) => {
+  object(editor);
+  number$1(offset);
+  return execute({
+    event: OnHover,
+    editor,
+    method: HoverExecute,
+    args: [offset],
+    noProviderFoundMessage: 'No hover provider found'
+  });
+};
 
-// when clicking first at position 4 and then position 2,
-// - vscode selects next position 3 and refuses to select position 1
-// - atom also selects next position 3 and refuses to select position 1
-// - WebStorm also selects next position 3 and refuses to select position 1
-// - brackets (codemirror) selects position 3 and then selects position 1
-// - sublime selects next position 1, then next position 3
+const getHover = async (editor, offset) => {
+  object(editor);
+  number$1(offset);
+  // TODO invoke extension host worker directly
+  const hover = await executeHoverProvider(editor, offset);
+  return hover;
+};
 
-const isRangeInViewPort = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
-  return startRowIndex >= minLineY && endRowIndex <= maxLineY;
+let _ipc;
+const listen$5 = async () => {
+  const ipc = await create$8({
+    method: RendererProcess
+  });
+  handleIpc(ipc);
+  _ipc = ipc;
+};
+const invoke = async (method, ...args) => {
+  return invoke$5(_ipc, method, ...args);
 };
 
-// TODO handle virtual space
-const selectNextOccurrence = editor => {
-  const result = getSelectNextOccurrenceResult(editor);
-  if (!result) {
-    return editor;
-  }
-  const revealRange = result.revealRange;
-  const selectionEdits = result.selectionEdits;
-  const revealRangeStartRowIndex = selectionEdits[revealRange];
-  const revealRangeEndRowIndex = selectionEdits[revealRange + 2];
-  if (isRangeInViewPort(editor.minLineY, editor.maxLineY, revealRangeStartRowIndex, revealRangeEndRowIndex)) {
-    return scheduleSelections(editor, selectionEdits);
-  }
-  // TODO what is this magic number 5?
-  // const deltaY = (revealRangeStartRowIndex - 5) * editor.rowHeight
-  return scheduleDocumentAndCursorsSelections(editor, [], selectionEdits);
+const measureTextBlockHeight = (text, fontFamily, fontSize, lineHeight, width) => {
+  return invoke('MeasureTextBlockHeight.measureTextBlockHeight', text, fontSize, fontFamily, lineHeight, width);
 };
 
-// @ts-ignore
-const selectPreviousOccurrence = editor => {
-  return editor;
+const deepCopy = value => {
+  return structuredClone(value);
 };
 
-// @ts-ignore
+const getInitialLineState = initialLineState => {
+  return deepCopy(initialLineState);
+};
 
-// @ts-ignore
-const getSelectUpChanges = (lines, selections) => {
-  const newSelections = new Uint32Array(selections.length);
-  for (let i = 0; i < selections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
-    newSelections[i] = Math.max(selectionStartRow - 1, 0);
-    newSelections[i + 1] = selectionStartColumn;
-    newSelections[i + 2] = selectionEndRow;
-    newSelections[i + 3] = selectionEndColumn;
+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
+    };
   }
-  return newSelections;
 };
 
-// @ts-ignore
-const selectUp = editor => {
+const getLineInfos = (lines, tokenizer, languageId) => {
+  const lineInfos = [];
   const {
-    lines,
-    selections
-  } = editor;
-  const newSelections = getSelectUpChanges(lines, selections);
-  return scheduleSelections(editor, newSelections);
-};
-
-// @ts-ignore
-const selectWordLeft = editor => {
-  return editorSelectHorizontalLeft(editor, wordLeft);
+    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;
 };
 
-// @ts-ignore
-const selectWordRight = editor => {
-  return editorSelectHorizontalRight(editor, wordRight);
+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;
 };
 
-// import * as ExtensionHostSelection from '../ExtensionHost/ExtensionHostSelection.ts'
-
-const getNewSelections = async (editor, selections) => {
-  const newSelections = await invoke$3('ExtensionHostSelection.executeGrowSelection', editor, selections);
-  if (newSelections.length === 0) {
-    return selections;
+const getHoverPosition = (position, selections) => {
+  if (position) {
+    return position;
   }
-  return new Uint32Array(newSelections);
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  return {
+    rowIndex,
+    columnIndex
+  };
 };
-const selectionGrow = async editor => {
-  const {
-    selections
-  } = editor;
-  const newSelections = await getNewSelections(editor, selections);
-  return scheduleSelections(editor, newSelections);
+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 setDecorations = (editor, decorations, diagnostics) => {
-  if (editor.decorations.length === 0 && decorations.length === 0) {
-    return editor;
-  }
+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 {
-    ...editor,
-    decorations,
-    diagnostics
+    x: x$1,
+    y: y$1
   };
 };
-
-const tokenizers = Object.create(null);
-const set$1 = (id, value) => {
-  tokenizers[id] = value;
-};
-const get$1 = id => {
-  return tokenizers[id] || TokenizePlainText;
-};
-
-// TODO add command to set language id
-// without needing to specify tokenizePath
-const setLanguageId = async (editor, languageId, tokenizePath) => {
+const getEditorHoverInfo = async (editorUid, position) => {
+  number$1(editorUid);
+  const instance = get$7(editorUid);
+  const editor = instance.newState;
   const {
-    tokenizerId
+    selections
   } = editor;
-  // TODO move tokenizer to syntax highlighting worker
-  // TODO only load tokenizer if not already loaded
-  // if already loaded just set tokenizer and rerender text
-  // TODO race condition
-  await loadTokenizer(languageId, tokenizePath);
-  const tokenizer = getTokenizer(languageId);
-  const newTokenizerId = tokenizerId + 1;
-  set$1(newTokenizerId, tokenizer);
-  const latest = getEditor(editor.uid);
-  if (!latest) {
-    return editor;
+  const {
+    rowIndex,
+    columnIndex
+  } = getHoverPosition(position, selections);
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const hover = await getHover(editor, offset);
+  if (!hover) {
+    return undefined;
   }
-  // TODO don't update editor if tokenizer was already loaded
-  // TODO update syntax highlighting
-  // TODO get edits
-
+  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 {
-    ...latest,
-    languageId,
-    invalidStartIndex: 0,
-    tokenizerId: newTokenizerId
+    lineInfos,
+    documentation,
+    x,
+    y,
+    matchingDiagnostics
   };
 };
 
-const setSelections = (editor, selections) => {
-  const {
-    minLineY,
-    maxLineY,
-    rowHeight
-  } = editor;
-  const startRowIndex = selections[0];
-  if (startRowIndex < minLineY) {
-    const deltaY = startRowIndex * rowHeight;
-    return {
-      ...editor,
-      minLineY: startRowIndex,
-      maxLineY: startRowIndex + 1,
-      selections,
-      deltaY
-    };
-  }
-  if (startRowIndex > maxLineY) {
-    const deltaY = startRowIndex * rowHeight;
-    return {
-      ...editor,
-      minLineY: startRowIndex,
-      maxLineY: startRowIndex + 1,
-      selections,
-      deltaY
-    };
+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 {
-    ...editor,
-    selections
+    ...state,
+    lineInfos,
+    documentation,
+    x,
+    y,
+    diagnostics: matchingDiagnostics
   };
 };
 
-const EditorHover = 'EditorHover';
-const showHover = async state => {
-  await invoke$3('Viewlet.openWidget', EditorHover);
-  return state;
+const newStateGenerator = state => {
+  return loadHoverContent(state);
+};
+const showHover2 = async editor => {
+  return addWidgetToEditor(Hover, FocusEditorHover, editor, create$2, newStateGenerator);
 };
 
 const EditorSourceActions = 'EditorSourceActions';
-const showSourceActions = async editor => {
+const showSourceActions$1 = async editor => {
   // TODO
   // 1. hide hover, completions, color picker
   // 2. query source actions from extension host
@@ -6660,6 +6671,70 @@ const showSourceActions = async editor => {
   return editor;
 };
 
+const getEditorSourceActions = async () => {
+  const sourceActions = [{
+    name: organizeImports$1(),
+    command: 'Editor.organizeImports'
+  }, {
+    name: sortImports(),
+    command: 'Editor.sortImports'
+  }];
+  return sourceActions;
+};
+
+const loadSourceActions = async (editorUid, state) => {
+  // const editor = GetEditor.getEditor(editorUid)
+  // TODO request source actions information from extensions
+  const sourceActions = await getEditorSourceActions();
+  // TODO avoid side effect
+  return {
+    ...state,
+    sourceActions,
+    x: 200,
+    y: -200,
+    width: 250,
+    height: 150,
+    maxHeight: 150,
+    focusedIndex: 0
+  };
+};
+
+const create$1 = () => {
+  const completionUid = create$6();
+  const widget = {
+    id: SourceAction,
+    oldState: {
+      uid: completionUid,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      focusedIndex: 0,
+      sourceActions: [],
+      maxHeight: 0
+    },
+    newState: {
+      uid: completionUid,
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      focusedIndex: 0,
+      sourceActions: [],
+      maxHeight: 0
+    }
+  };
+  return widget;
+};
+
+const showSourceActions = async editor => {
+  const uid = editor.uid;
+  const newStateGenerator = state => {
+    return loadSourceActions(uid, state);
+  };
+  return addWidgetToEditor(SourceAction, SourceActions, editor, create$1, newStateGenerator);
+};
+
 const compareString = (a, b) => {
   return a.localeCompare(b);
 };
@@ -7510,7 +7585,7 @@ const focusPrevious = editor => {
 };
 
 const create = () => {
-  const completionUid = create$5();
+  const completionUid = create$6();
   const completionWidget = {
     id: CompletionDetail$1,
     oldState: {
@@ -7906,10 +7981,10 @@ const getEnabled = () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await listen$6();
+  await listen$5();
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
-    await listen$5();
+    await listen$6();
   }
   if (syncIncremental) {
     setEnabled(true);
@@ -8197,10 +8272,10 @@ const getTokensViewport2 = (editor, startLineIndex, endLineIndex, syncIncrementa
         languageId,
         invalidStartIndex
       };
-      return invoke('GetTokensViewport.getTokensViewport', slimEditor, startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
+      return invoke$1('GetTokensViewport.getTokensViewport', slimEditor, startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
     }
     // TODO only send needed lines of text
-    return invoke('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
+    return invoke$1('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
   }
   return getTokensViewport(editor, startLineIndex, endLineIndex);
 };
@@ -8393,7 +8468,7 @@ const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLine
     decorations,
     languageId
   } = editor;
-  const tokenMap = get$3(languageId);
+  const tokenMap = get$2(languageId);
   let offset = minLineOffset;
   const tabSize = 2;
   for (let i = minLineY; i < maxLineY; i++) {
@@ -8550,7 +8625,7 @@ const getIncrementalEdits = async (oldState, newState) => {
       const lines = newState.lines;
       const oldLine = oldState.lines[rowIndex];
       const newLine = lines[rowIndex];
-      const incrementalEdits = await invoke('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
+      const incrementalEdits = await invoke$1('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
       if (incrementalEdits && incrementalEdits.length === 1) {
         return incrementalEdits;
       }
@@ -8985,7 +9060,8 @@ const commandMap = {
   'Editor.setSelections': setSelections,
   'Editor.showHover': showHover,
   'Editor.showHover2': showHover2,
-  'Editor.showSourceActions': showSourceActions,
+  'Editor.showSourceActions': showSourceActions$1,
+  'Editor.showSourceActions2': showSourceActions,
   'Editor.sortLinesAscending': sortLinesAscending,
   'Editor.tabCompletion': tabCompletion,
   'Editor.toggleBlockComment': toggleBlockComment,
@@ -10452,6 +10528,10 @@ const EditorFindWidget = {
   render: render$1
 };
 
+const SourceActionWidget = {
+  __proto__: null
+};
+
 const render = widget => {
   const commands = renderHover(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -10483,6 +10563,7 @@ const registerWidgets = () => {
   set(CompletionDetail$1, EditorCompletionDetailWidget);
   set(Find, EditorFindWidget);
   set(Hover, EditorHoverWidget);
+  set(SourceAction, SourceActionWidget);
 };
 
 const main = async () => {