@lvce-editor/editor-worker 9.1.0 → 10.1.0

package/dist/editorWorkerMain.js

@@ -1066,6 +1066,39 @@ const createMockRpc = ({
   return mockRpc;
 };
 
+const Backspace = 1;
+const Tab$1 = 2;
+const Enter = 3;
+const Escape = 8;
+const Space$1 = 9;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+const Delete = 18;
+const KeyA = 29;
+const KeyC = 31;
+const KeyD = 32;
+const KeyF = 34;
+const KeyH = 36;
+const KeyJ = 38;
+const KeyK = 39;
+const KeyL = 40;
+const KeyO = 43;
+const KeyV = 50;
+const KeyX = 52;
+const KeyZ = 54;
+const F2 = 58;
+const F3 = 59;
+const F4 = 60;
+const F12 = 68;
+const Period = 87;
+const Slash$1 = 88;
+const BracketLeft = 90;
+const BracketRight = 92;
+
 const CodeGenerator = 1;
 const ColorPicker$1 = 2;
 const Completion = 3;
@@ -1075,6 +1108,10 @@ const Hover = 6;
 const Rename$1 = 7;
 const SourceAction$1 = 8;
 
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
+const Alt$1 = 1 << 9 >>> 0;
+
 const DebugWorker = 55;
 const EditorWorker = 99;
 const ExtensionHostWorker = 44;
@@ -1774,574 +1811,1272 @@ const setDeltaY$2 = (state, value) => {
   };
 };
 
-const splitLines = lines => {
-  if (!lines) {
-    return [''];
+const Link$1 = 'Link';
+const Function = 'Function';
+const Parameter = 'Parameter';
+const Type = 'Type';
+const VariableName = 'VariableName';
+const Class = 'Class';
+
+const Link = 1;
+const Ts2816 = 2816;
+const Ts2817 = 2817;
+const Ts2824 = 2824;
+const Ts2825 = 2825;
+const Ts2856 = 2956;
+const Ts2857 = 2857;
+const Ts3072 = 3072;
+const Ts3073 = 3073;
+const Ts3077 = 3077;
+const Ts3088 = 3088;
+const Ts1792 = 1792;
+const Ts1793 = 1793;
+const Ts512 = 512;
+const Ts513 = 513;
+const Ts769 = 769;
+const Ts1024 = 1024;
+const Ts1536 = 1536;
+const Ts1537 = 1537;
+const Ts1544 = 1544;
+const Ts1545 = 1545;
+const Ts2048 = 2048;
+const Ts2049 = 2049;
+const Ts2056 = 2056;
+const Ts2057 = 2057;
+const Ts2064 = 2064;
+const Ts2080 = 2080;
+const Ts2081 = 2081;
+const Ts2088 = 2088;
+const Ts2089 = 2089;
+const Ts2313 = 2313;
+const Ts2560 = 2560;
+const Ts2561 = 2561;
+const Ts2569 = 2569;
+const Ts2584 = 2584;
+const Ts256 = 256;
+const Ts257 = 257;
+const Ts272 = 272;
+
+const getDecorationClassName = type => {
+  switch (type) {
+    case Link:
+      return Link$1;
+    case Ts2816:
+    case Ts2817:
+    case Ts2824:
+    case Ts2825:
+    case Ts2856:
+    case Ts2857:
+    case Ts3072:
+    case Ts3073:
+    case Ts3077:
+    case Ts3088:
+      return Function;
+    case Ts1792:
+    case Ts1793:
+      return Parameter;
+    case Ts512:
+    case Ts513:
+    case Ts769:
+    case Ts1024:
+    case Ts1536:
+    case Ts1537:
+    case Ts1544:
+    case Ts1545:
+      return Type;
+    case Ts2048:
+    case Ts2049:
+    case Ts2056:
+    case Ts2057:
+    case Ts2064:
+    case Ts2080:
+    case Ts2081:
+    case Ts2088:
+    case Ts2089:
+    case Ts2313:
+    case Ts2560:
+    case Ts2561:
+    case Ts2569:
+    case Ts2584:
+      return VariableName;
+    case Ts256:
+    case Ts257:
+    case Ts272:
+      return Class;
+    default:
+      return `Unknown-${type}`;
   }
-  return lines.split('\n');
 };
 
-// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+const deepCopy = value => {
+  return structuredClone(value);
+};
 
-// @ts-ignore
-const insertInto = (array, start, newItems) => {
-  const originalLength = array.length;
-  const newItemsLength = newItems.length;
-  array.length = originalLength + newItemsLength;
-  // Move the items after the start index, start from the end so that we don't overwrite any value.
-  for (let i = originalLength - 1; i >= start; i--) {
-    array[i + newItemsLength] = array[i];
+const getInitialLineState = initialLineState => {
+  return deepCopy(initialLineState);
+};
+
+const state$8 = {
+  warned: []
+};
+const flattenTokensArray = tokens => {
+  const flattened = [];
+  for (const token of tokens) {
+    object(token);
+    flattened.push(token.type, token.length);
   }
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i];
+  return flattened;
+};
+const warnDeprecatedArrayReturn = (languageId, fn) => {
+  if (state$8.warned.includes(fn)) {
+    return;
+  }
+  state$8.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?.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
+    };
   }
 };
 
 /**
- * Alternative to the native Array.splice method, it
- * can only support limited number of items due to the maximum call stack size limit.
+ * @enum number
  */
-// @ts-ignore
-const spliceLargeArray = (array, start, deleteCount, newItems) => {
-  const result = array.splice(start, deleteCount);
-  insertInto(array, start, newItems);
-  return result;
+const State = {
+  TopLevelContent: 1
 };
 
-const joinLines = lines => {
-  return lines.join('\n');
+/**
+ * @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 RE_WHITESPACE = /^\s+/;
+const TokenizePlainText = {
+  __proto__: null,
+  State,
+  TokenMap,
+  TokenType,
+  hasArrayReturn,
+  initialLineState,
+  tokenizeLine
+};
 
-// TODO this doesn't belong here
-const getIndent = line => {
-  const whitespaceMatch = line.match(RE_WHITESPACE);
-  if (!whitespaceMatch) {
-    return '';
-  }
-  return whitespaceMatch[0];
+let enabled$1 = false;
+const setEnabled$1 = value => {
+  enabled$1 = value;
+};
+const getEnabled$1 = () => {
+  return enabled$1;
 };
 
-// TODO have function for single edit (most common, avoid one array)
-const applyEdits = (textDocument, changes) => {
-  object(textDocument);
-  array(changes);
-  // TODO don't copy all lines (can be expensive, e.g. 10000 lines = 10000 * 64bit = 64kB on every keystroke)
-  const newLines = [...textDocument.lines];
-  let linesDelta = 0;
-  for (const change of changes) {
-    const startRowIndex = change.start.rowIndex + linesDelta;
-    const endRowIndex = change.end.rowIndex + linesDelta;
-    const startColumnIndex = change.start.columnIndex;
-    const endColumnIndex = change.end.columnIndex;
-    const {
-      inserted
-    } = change;
-    const {
-      deleted
-    } = change;
-    number(startRowIndex);
-    number(endRowIndex);
-    number(startColumnIndex);
-    number(endColumnIndex);
-    array(inserted);
-    array(deleted);
-    if (startRowIndex === endRowIndex) {
-      if (inserted.length === 0) {
-        const line = newLines[startRowIndex];
-        const before = line.slice(0, startColumnIndex);
-        const after = line.slice(endColumnIndex);
-        newLines[startRowIndex] = before + after;
-      } else if (inserted.length === 1) {
-        const line = newLines[startRowIndex];
-        let before = line.slice(0, startColumnIndex);
-        if (startColumnIndex > line.length) {
-          before += ' '.repeat(startColumnIndex - line.length);
-        }
-        const after = line.slice(endColumnIndex);
-        const text = inserted[0];
-        newLines[startRowIndex] = before + text + after;
-      } else {
-        const line = newLines[startRowIndex];
-        const before = line.slice(0, startColumnIndex) + inserted[0];
-        const after = inserted.at(-1) + line.slice(endColumnIndex);
-        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...inserted.slice(1, -1), after]);
-        // TODO only do this once after all edits, not inside loop
-        textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, newLines.length);
-      }
-    } else {
-      if (inserted.length === 1) {
-        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
-        const after = endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex);
-        spliceLargeArray(newLines, startRowIndex, deleted.length, [before + after]);
-      } else {
-        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
-        const middle = inserted.slice(1, -1);
-        const after = inserted.at(-1) + (endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex));
-        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...middle, after]);
-      }
-      // TODO only do this once after all edits, not inside loop
-      textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, textDocument.lines.length);
-    }
-    linesDelta += inserted.length - deleted.length;
-  }
-  return newLines;
+const {
+  set: set$5,
+  invoke: invoke$7} = SyntaxHighlightingWorker;
+
+const state$7 = {
+  tokenizers: Object.create(null),
+  pending: Object.create(null)};
+const has = languageId => {
+  return languageId in state$7.tokenizers;
 };
-const getLine = (textDocument, index) => {
-  return textDocument.lines[index];
+const set$4 = (languageId, tokenizer) => {
+  state$7.tokenizers[languageId] = tokenizer;
 };
-const getText$1 = state => {
-  return joinLines(state.lines);
+const get$3 = languageId => {
+  return state$7.tokenizers[languageId];
+};
+const isPending = languageId => {
+  return languageId in state$7.pending;
 };
 
-// TDOO this doesn;t belong here
-const getSelectionText = (textDocument, range) => {
-  object(textDocument);
-  const startRowIndex = range.start.rowIndex;
-  const startColumnIndex = range.start.columnIndex;
-  const endRowIndex = Math.min(range.end.rowIndex, textDocument.lines.length - 1);
-  const endColumnIndex = range.end.columnIndex;
-  if (startRowIndex === endRowIndex) {
-    return [textDocument.lines[startRowIndex].slice(startColumnIndex, endColumnIndex)];
-  }
-  const selectedLines = [textDocument.lines[startRowIndex].slice(startColumnIndex), ...textDocument.lines.slice(startRowIndex + 1, endRowIndex), textDocument.lines[endRowIndex].slice(0, endColumnIndex)];
-  return selectedLines;
+const tokenMaps = Object.create(null);
+const set$3 = (languageId, tokenMap) => {
+  tokenMaps[languageId] = tokenMap;
 };
-const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
-  object(textDocument);
-  number(positionRowIndex);
-  number(positionColumnIndex);
-  let offset = 0;
-  let rowIndex = 0;
-  const {
-    lines
-  } = textDocument;
-  const max = Math.min(positionRowIndex, textDocument.lines.length);
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1;
-    rowIndex++;
-  }
-  offset += positionColumnIndex;
-  return offset;
+const get$2 = languageId => {
+  return tokenMaps[languageId] || {};
 };
-const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
-  object(textDocument);
-  number(positionRowIndex);
-  number(positionColumnIndex);
-  let offset = 0;
-  let rowIndex = 0;
-  const {
-    lines
-  } = textDocument;
-  const max = Math.min(positionRowIndex, textDocument.lines.length);
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1;
-    rowIndex++;
+
+// TODO loadTokenizer should be invoked from renderer worker
+const loadTokenizer = async (languageId, tokenizePath) => {
+  if (!tokenizePath) {
+    return;
   }
-  offset += positionColumnIndex;
-  return offset;
-};
-const positionAt = (textDocument, offset) => {
-  const {
-    lines
-  } = textDocument;
-  let rowIndex = 0;
-  let columnIndex = 0;
-  let currentOffset = 0;
-  while (rowIndex < lines.length && currentOffset < offset) {
-    currentOffset += lines[rowIndex].length + 1;
-    rowIndex++;
+  if (getEnabled$1()) {
+    // @ts-ignore
+    const tokenMap = await invoke$7('Tokenizer.load', languageId, tokenizePath);
+    set$3(languageId, tokenMap);
+    return;
   }
-  if (currentOffset > offset) {
-    rowIndex--;
-    currentOffset -= lines[rowIndex].length + 1;
-    columnIndex = offset - currentOffset;
-  } else {
-    columnIndex = currentOffset - offset;
+  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 {
-    rowIndex,
-    columnIndex
-  };
 };
-
-const getSelectionPairs = (selections, i) => {
-  const first = selections[i];
-  const second = selections[i + 1];
-  const third = selections[i + 2];
-  const fourth = selections[i + 3];
-  if (first > third || first === third && second >= fourth) {
-    return [third, fourth, first, second, 1];
+const getTokenizer = languageId => {
+  if (has(languageId)) {
+    return get$3(languageId);
   }
-  return [first, second, third, fourth, 0];
-};
-
-const EmptyString = '';
-const NewLine = '\n';
-const Space$1 = ' ';
-const Tab$1 = '\t';
-const DoubleQuote$1 = '"';
-
-const getTabCount = string => {
-  let count = 0;
-  for (const element of string) {
-    if (element === Tab$1) {
-      count++;
-    }
+  if (isPending(languageId)) {
+    return TokenizePlainText;
   }
-  return count;
-};
-
-const measureTextWidthFast = (text, charWidth) => {
-  return text.length * charWidth;
-};
-
-const getFontString = (fontWeight, fontSize, fontFamily) => {
-  return `${fontWeight} ${fontSize}px ${fontFamily}`;
+  return TokenizePlainText;
 };
 
-const getLetterSpacingString = letterSpacing => {
-  return `${letterSpacing}px`;
+const tokenizers = Object.create(null);
+const set$2 = (id, value) => {
+  tokenizers[id] = value;
 };
-
-const createMeasureContext = () => {
-  const canvas = new OffscreenCanvas(0, 0);
-  const ctx = /** @type {OffscreenCanvasRenderingContext2D} */canvas.getContext('2d');
-  if (!ctx) {
-    throw new Error('Failed to get canvas context 2d');
-  }
-  return ctx;
+const get$1 = id => {
+  return tokenizers[id] || TokenizePlainText;
 };
 
-const state$8 = {
-  ctx: undefined
-};
-const getOrCreate$4 = createCtx => {
-  if (state$8.ctx) {
-    return state$8.ctx;
+const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed) => {
+  const tokenizersToLoad = [];
+  const embeddedResults = [];
+  let topContext;
+  for (const index of linesWithEmbed) {
+    const result = lineCache[index + 1];
+    const line = lines[index];
+    if (result.embeddedLanguage) {
+      const {
+        embeddedLanguage,
+        embeddedLanguageStart,
+        embeddedLanguageEnd
+      } = result;
+      const embeddedTokenizer = getTokenizer(embeddedLanguage);
+      if (embeddedLanguageStart !== line.length && embeddedTokenizer && embeddedTokenizer !== TokenizePlainText) {
+        const isFull = embeddedLanguageStart === 0 && embeddedLanguageEnd === line.length;
+        const partialLine = line.slice(embeddedLanguageStart, embeddedLanguageEnd);
+        const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, topContext || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
+        topContext = embedResult;
+        result.embeddedResultIndex = embeddedResults.length;
+        embeddedResults.push({
+          result: embedResult,
+          TokenMap: embeddedTokenizer.TokenMap,
+          isFull
+        });
+      } else if (line.length === 0) {
+        const embedResult = {
+          tokens: []
+        };
+        result.embeddedResultIndex = embeddedResults.length;
+        embeddedResults.push({
+          result: embedResult,
+          isFull: true,
+          TokenMap: []
+        });
+      } else {
+        tokenizersToLoad.push(embeddedLanguage);
+        embeddedResults.push({
+          result: {},
+          isFull: false,
+          TokenMap: []
+        });
+        topContext = undefined;
+      }
+    } else {
+      topContext = undefined;
+    }
   }
-  state$8.ctx = createCtx();
-  return state$8.ctx;
+  return {
+    tokenizersToLoad,
+    embeddedResults
+  };
 };
-
-const getContext = () => {
-  const ctx = getOrCreate$4(createMeasureContext);
-  return ctx;
+const getTokenizeEndIndex = (invalidStartIndex, endLineIndex, tokenizeStartIndex) => {
+  return invalidStartIndex < endLineIndex ? endLineIndex : tokenizeStartIndex;
 };
 
-// TODO for text editor, could dispose measuring canvas after editor has been initialized to free up offscreencanvas space
+// TODO only send changed lines to renderer process instead of all lines in viewport
+const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
+  const {
+    invalidStartIndex,
+    lineCache,
+    tokenizerId,
+    lines,
+    languageId
+  } = editor;
+  const tokenizer = get$1(tokenizerId);
+  const {
+    hasArrayReturn,
+    tokenizeLine,
+    initialLineState
+  } = tokenizer;
+  const tokenizeStartIndex = invalidStartIndex;
+  const tokenizeEndIndex = getTokenizeEndIndex(invalidStartIndex, endLineIndex, tokenizeStartIndex);
+  const tokenizersToLoad = [];
+  const embeddedResults = [];
+  const linesWithEmbed = [];
+  for (let i = tokenizeStartIndex; i < tokenizeEndIndex; i++) {
+    const lineState = i === 0 ? getInitialLineState(initialLineState) : lineCache[i];
+    const line = lines[i];
+    const result = safeTokenizeLine(languageId, tokenizeLine, line, lineState, hasArrayReturn);
+    // TODO if lineCacheEnd matches the one before, skip tokenizing lines after
+    lineCache[i + 1] = result;
+    if (result.embeddedLanguage) {
+      result.embeddedResultIndex = linesWithEmbed.length;
+      linesWithEmbed.push(i);
+    }
+  }
+  const visibleLines = lineCache.slice(startLineIndex + 1, endLineIndex + 1);
+  if (linesWithEmbed.length > 0) {
+    const {
+      tokenizersToLoad,
+      embeddedResults
+    } = getTokensViewportEmbedded(languageId, lines, lineCache, linesWithEmbed);
+    // TODO support lineCache with embedded content
+    editor.invalidStartIndex = 0;
+    return {
+      tokens: visibleLines,
+      tokenizersToLoad,
+      embeddedResults
+    };
+  }
+  editor.invalidStartIndex = Math.max(invalidStartIndex, tokenizeEndIndex);
+  return {
+    tokens: visibleLines,
+    tokenizersToLoad,
+    embeddedResults
+  };
+};
 
-const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  string(text);
-  number(fontWeight);
-  number(fontSize);
-  string(fontFamily);
-  boolean(isMonoSpaceFont);
-  number(charWidth);
-  if (typeof letterSpacing !== 'number') {
-    throw new TypeError('letterSpacing must be of type number');
+const sentLines = Object.create(null);
+
+// TODO only send changed lines to renderer process instead of all lines in viewport
+const getTokensViewport2 = async (editor, startLineIndex, endLineIndex, syncIncremental) => {
+  if (getEnabled$1()) {
+    if (syncIncremental) {
+      const {
+        invalidStartIndex,
+        lines,
+        languageId,
+        id
+      } = editor;
+      let hasLinesToSend = true;
+      let linesToSend = lines;
+      if (sentLines[id] === lines) {
+        hasLinesToSend = false;
+        linesToSend = [];
+      } else {
+        sentLines[id] = lines;
+      }
+      const slimEditor = {
+        languageId,
+        invalidStartIndex
+      };
+      return invoke$7('GetTokensViewport.getTokensViewport', slimEditor,
+      // @ts-ignore
+      startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
+    }
+    // TODO only send needed lines of text
+    // @ts-ignore
+    return invoke$7('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
   }
-  const letterSpacingString = getLetterSpacingString(letterSpacing);
-  const fontString = getFontString(fontWeight, fontSize, fontFamily);
-  const ctx = getContext();
-  ctx.letterSpacing = letterSpacingString;
-  ctx.font = fontString;
-  const metrics = ctx.measureText(text);
-  const {
-    width
-  } = metrics;
-  return width;
+  return getTokensViewport(editor, startLineIndex, endLineIndex);
 };
 
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  if (isMonoSpaceFont) {
-    return measureTextWidthFast(text, charWidth);
+const loadTokenizers = async languageIds => {
+  for (const languageId of languageIds) {
+    // @ts-ignore
+    await loadTokenizer(languageId);
   }
-  return measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
 };
 
+const EmptyString = '';
+const NewLine = '\n';
+const Space = ' ';
+const Tab = '\t';
+const DoubleQuote$1 = '"';
+
 const normalizeText = (text, normalize, tabSize) => {
   if (normalize) {
-    return text.replaceAll(Tab$1, Space$1.repeat(tabSize));
+    return text.replaceAll(Tab, Space.repeat(tabSize));
   }
   return text;
 };
 const shouldNormalizeText = text => {
-  return text.includes(Tab$1);
+  return text.includes(Tab);
 };
 
-const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
-  if (!line) {
-    return 0;
-  }
-  string(line);
-  number(tabSize);
-  number(halfCursorWidth);
-  number(width);
-  boolean(isMonospaceFont);
-  number(averageCharWidth);
-  number(difference);
-  if (column === 0) {
-    return 0;
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+
+// @ts-ignore
+const insertInto = (array, start, newItems) => {
+  const originalLength = array.length;
+  const newItemsLength = newItems.length;
+  array.length = originalLength + newItemsLength;
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i];
   }
-  // TODO support non-monospace font, emoji, tab character, zero width characters
-  if (column * averageCharWidth > width) {
-    return width;
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
   }
-  const normalize = shouldNormalizeText(line);
-  const normalizedLine = normalizeText(line, normalize, tabSize);
-  const tabCount = getTabCount(line.slice(0, column));
-  const partialText = normalizedLine.slice(0, column + tabCount);
-  return measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth) - halfCursorWidth + difference;
 };
 
-const getY = (row, minLineY, rowHeight) => {
-  return (row - minLineY) * rowHeight;
+/**
+ * Alternative to the native Array.splice method, it
+ * can only support limited number of items due to the maximum call stack size limit.
+ */
+// @ts-ignore
+const spliceLargeArray = (array, start, deleteCount, newItems) => {
+  const result = array.splice(start, deleteCount);
+  insertInto(array, start, newItems);
+  return result;
 };
 
-const px = value => {
-  return `${value}px`;
+const joinLines = lines => {
+  return lines.join('\n');
 };
 
-const fromRange = (startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
-  return new Uint32Array([startRowIndex, startColumnIndex, endRowIndex, endColumnIndex]);
-};
-const alloc = length => {
-  return new Uint32Array(length);
-};
-const clone = selections => {
-  return alloc(selections.length);
-};
-const map = (selections, fn) => {
-  const newSelections = clone(selections);
-  for (let i = 0; i < newSelections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
-    fn(newSelections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+const RE_WHITESPACE = /^\s+/;
+
+// TODO this doesn't belong here
+const getIndent = line => {
+  const whitespaceMatch = line.match(RE_WHITESPACE);
+  if (!whitespaceMatch) {
+    return '';
   }
-  return newSelections;
+  return whitespaceMatch[0];
 };
-const forEach = (selections, fn) => {
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i];
-    const selectionStartColumn = selections[i + 1];
-    const selectionEndRow = selections[i + 2];
-    const selectionEndColumn = selections[i + 3];
-    fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+
+// TODO have function for single edit (most common, avoid one array)
+const applyEdits = (textDocument, changes) => {
+  object(textDocument);
+  array(changes);
+  // TODO don't copy all lines (can be expensive, e.g. 10000 lines = 10000 * 64bit = 64kB on every keystroke)
+  const newLines = [...textDocument.lines];
+  let linesDelta = 0;
+  for (const change of changes) {
+    const startRowIndex = change.start.rowIndex + linesDelta;
+    const endRowIndex = change.end.rowIndex + linesDelta;
+    const startColumnIndex = change.start.columnIndex;
+    const endColumnIndex = change.end.columnIndex;
+    const {
+      inserted
+    } = change;
+    const {
+      deleted
+    } = change;
+    number(startRowIndex);
+    number(endRowIndex);
+    number(startColumnIndex);
+    number(endColumnIndex);
+    array(inserted);
+    array(deleted);
+    if (startRowIndex === endRowIndex) {
+      if (inserted.length === 0) {
+        const line = newLines[startRowIndex];
+        const before = line.slice(0, startColumnIndex);
+        const after = line.slice(endColumnIndex);
+        newLines[startRowIndex] = before + after;
+      } else if (inserted.length === 1) {
+        const line = newLines[startRowIndex];
+        let before = line.slice(0, startColumnIndex);
+        if (startColumnIndex > line.length) {
+          before += ' '.repeat(startColumnIndex - line.length);
+        }
+        const after = line.slice(endColumnIndex);
+        const text = inserted[0];
+        newLines[startRowIndex] = before + text + after;
+      } else {
+        const line = newLines[startRowIndex];
+        const before = line.slice(0, startColumnIndex) + inserted[0];
+        const after = inserted.at(-1) + line.slice(endColumnIndex);
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...inserted.slice(1, -1), after]);
+        // TODO only do this once after all edits, not inside loop
+        textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, newLines.length);
+      }
+    } else {
+      if (inserted.length === 1) {
+        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
+        const after = endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex);
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before + after]);
+      } else {
+        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
+        const middle = inserted.slice(1, -1);
+        const after = inserted.at(-1) + (endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex));
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...middle, after]);
+      }
+      // TODO only do this once after all edits, not inside loop
+      textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, textDocument.lines.length);
+    }
+    linesDelta += inserted.length - deleted.length;
   }
+  return newLines;
 };
-const moveRangeToPosition$1 = (selections, i, rowIndex, columnIndex) => {
-  selections[i] = selections[i + 2] = rowIndex;
-  selections[i + 1] = selections[i + 3] = columnIndex;
-};
-const isEmpty = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
-  return selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn;
-};
-const isSelectionSingleLine = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
-  return selectionStartRow === selectionEndRow;
-};
-const isEverySelection = (selections, fn) => {
-  for (let i = 0; i < selections.length; i += 4) {
-    const selectionStartRow = selections[i];
-    const selectionStartColumn = selections[i + 1];
-    const selectionEndRow = selections[i + 2];
-    const selectionEndColumn = selections[i + 3];
-    if (!fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
-      return false;
-    }
-  }
-  return true;
-};
-const isEverySelectionEmpty = selections => {
-  return isEverySelection(selections, isEmpty);
-};
-const isEverySelectionSingleLine = selections => {
-  return isEverySelection(selections, isSelectionSingleLine);
-};
-const from = (array, getSelection) => {
-  const newSelections = alloc(array.length * 4);
-  let i = 0;
-  for (const item of array) {
-    const {
-      start,
-      end
-    } = getSelection(item);
-    newSelections[i++] = start.rowIndex;
-    newSelections[i++] = start.columnIndex;
-    newSelections[i++] = end.rowIndex;
-    newSelections[i++] = end.columnIndex;
-  }
-  return newSelections;
+const getLine = (textDocument, index) => {
+  return textDocument.lines[index];
 };
-const push = (selections, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
-  const oldLength = selections.length;
-  const newSelections = alloc(oldLength + 4);
-  newSelections.set(selections);
-  newSelections[oldLength + 1] = startRowIndex;
-  newSelections[oldLength + 2] = startColumnIndex;
-  newSelections[oldLength + 3] = endRowIndex;
-  newSelections[oldLength + 4] = endColumnIndex;
-  return newSelections;
+const getText$1 = state => {
+  return joinLines(state.lines);
 };
 
-// TODO maybe only accept sorted selection edits in the first place
-
-const emptyCursors = [];
-const getCursorArray = (visibleCursors, isFocused) => {
-  if (!isFocused) {
-    return emptyCursors;
-  }
-  const cursorArray = [];
-  for (let i = 0; i < visibleCursors.length; i += 2) {
-    const x = visibleCursors[i];
-    const y = visibleCursors[i + 1];
-    cursorArray.push(`${px(x)} ${px(y)}`);
+// TDOO this doesn;t belong here
+const getSelectionText = (textDocument, range) => {
+  object(textDocument);
+  const startRowIndex = range.start.rowIndex;
+  const startColumnIndex = range.start.columnIndex;
+  const endRowIndex = Math.min(range.end.rowIndex, textDocument.lines.length - 1);
+  const endColumnIndex = range.end.columnIndex;
+  if (startRowIndex === endRowIndex) {
+    return [textDocument.lines[startRowIndex].slice(startColumnIndex, endColumnIndex)];
   }
-  return cursorArray;
+  const selectedLines = [textDocument.lines[startRowIndex].slice(startColumnIndex), ...textDocument.lines.slice(startRowIndex + 1, endRowIndex), textDocument.lines[endRowIndex].slice(0, endColumnIndex)];
+  return selectedLines;
 };
-const getSelectionArray = visibleSelections => {
-  const selectionsArray = [];
-  for (let i = 0; i < visibleSelections.length; i += 4) {
-    const x = visibleSelections[i];
-    const y = visibleSelections[i + 1];
-    const width = visibleSelections[i + 2];
-    const height = visibleSelections[i + 3];
-    selectionsArray.push(px(x), px(y), px(width), px(height));
+const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
+  object(textDocument);
+  number(positionRowIndex);
+  number(positionColumnIndex);
+  let offset = 0;
+  let rowIndex = 0;
+  const {
+    lines
+  } = textDocument;
+  const max = Math.min(positionRowIndex, textDocument.lines.length);
+  while (rowIndex < max) {
+    offset += lines[rowIndex].length + 1;
+    rowIndex++;
   }
-  return selectionsArray;
+  offset += positionColumnIndex;
+  return offset;
 };
-const getVisible$1 = editor => {
-  const visibleCursors = [];
-  const visibleSelections = [];
-  // // TODO binary search
-
+const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
+  object(textDocument);
+  number(positionRowIndex);
+  number(positionColumnIndex);
+  let offset = 0;
+  let rowIndex = 0;
   const {
-    selections,
-    minLineY,
-    maxLineY,
-    rowHeight,
-    lines,
-    fontSize,
-    fontFamily,
-    fontWeight,
-    letterSpacing,
-    cursorWidth,
-    tabSize,
-    width,
-    differences,
-    focused,
-    charWidth,
-    isMonospaceFont
-  } = editor;
-  const averageCharWidth = charWidth;
-  const halfCursorWidth = cursorWidth / 2;
-  for (let i = 0; i < selections.length; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(selections, i);
-    if (selectionEndRow < minLineY || selectionStartRow > maxLineY) {
-      continue;
-    }
-    const relativeEndLineRow = selectionEndRow - minLineY;
-    const endLineDifference = differences[relativeEndLineRow];
-    const endLine = lines[selectionEndRow];
-    const endLineEndX = getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
-    const endLineY = getY(selectionEndRow, minLineY, rowHeight);
-    if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
-      visibleCursors.push(endLineEndX, endLineY);
-      continue;
-    }
-    const startLineY = getY(selectionStartRow, minLineY, rowHeight);
-    const startLineYRelative = selectionStartRow - minLineY;
-    const startLineDifference = differences[startLineYRelative];
-    if (selectionStartRow === selectionEndRow) {
-      const startX = getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-      if (reversed) {
-        visibleCursors.push(startX, endLineY);
-      } else if (endLineEndX >= 0) {
-        visibleCursors.push(endLineEndX, endLineY);
-      }
-      const selectionWidth = endLineEndX - startX;
-      visibleSelections.push(startX, startLineY, selectionWidth, rowHeight);
-    } else {
-      if (selectionStartRow >= minLineY) {
-        const startLine = lines[selectionStartRow];
-        const startLineStartX = getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-        const startLineEndX = getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
-        const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
-        const selectionWidth = startLineEndX - startLineStartX;
-        if (reversed) {
-          visibleCursors.push(startLineStartX, startLineStartY);
-        }
-        visibleSelections.push(startLineStartX, startLineStartY, selectionWidth, rowHeight);
-      }
-      const iMin = Math.max(selectionStartRow + 1, minLineY);
-      const iMax = Math.min(selectionEndRow, maxLineY);
-      for (let i = iMin; i < iMax; i++) {
-        const currentLine = lines[i];
-        const currentLineY = getY(i, minLineY, rowHeight);
-        const relativeLine = i - minLineY;
-        const difference = differences[relativeLine];
-        const selectionWidth = getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
-        visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
-      }
-      if (selectionEndRow <= maxLineY) {
-        const selectionWidth = endLineEndX;
-        visibleSelections.push(0, endLineY, selectionWidth, rowHeight);
-        if (!reversed) {
-          visibleCursors.push(selectionWidth, endLineY);
-        }
-      }
-    }
+    lines
+  } = textDocument;
+  const max = Math.min(positionRowIndex, textDocument.lines.length);
+  while (rowIndex < max) {
+    offset += lines[rowIndex].length + 1;
+    rowIndex++;
   }
-  // TODO maybe use Uint32array or Float64Array?
-  return {
-    cursorInfos: getCursorArray(visibleCursors, focused),
-    selectionInfos: getSelectionArray(visibleSelections)
-  };
+  offset += positionColumnIndex;
+  return offset;
 };
-
-const getSelectionFromChange = change => {
+const positionAt = (textDocument, offset) => {
   const {
-    start,
-    inserted
-  } = change;
-  const startRowIndex = start.rowIndex;
-  const startColumnIndex = start.columnIndex;
-  const insertedLength = inserted.length;
-  if (insertedLength === 1) {
-    const newPosition = {
-      rowIndex: startRowIndex + insertedLength - 1,
-      columnIndex: inserted.at(-1).length + startColumnIndex
-    };
-    return {
-      start: newPosition,
-      end: newPosition
-    };
+    lines
+  } = textDocument;
+  let rowIndex = 0;
+  let columnIndex = 0;
+  let currentOffset = 0;
+  while (rowIndex < lines.length && currentOffset < offset) {
+    currentOffset += lines[rowIndex].length + 1;
+    rowIndex++;
+  }
+  if (currentOffset > offset) {
+    rowIndex--;
+    currentOffset -= lines[rowIndex].length + 1;
+    columnIndex = offset - currentOffset;
+  } else {
+    columnIndex = currentOffset - offset;
   }
-  const newPosition = {
-    rowIndex: startRowIndex + insertedLength - 1,
-    columnIndex: startColumnIndex
-  };
-  return {
-    start: newPosition,
-    end: newPosition
-  };
-};
-const setSelections$1 = (editor, selections) => {
-  object(editor);
-  // Assert.uint32array(selections)
   return {
-    ...editor,
-    selections
+    rowIndex,
+    columnIndex
   };
-  // editor.selections = selections
-  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
 };
 
-// TODO maybe only accept sorted selection edits in the first place
-
-// TODO avoid allocating too many objects when creating new selection from changes
-// @ts-ignore
-const applyEdit$1 = (editor, changes) => {
+// const getTokensIncremental = (editor, min, max) => {
+//   const currentLength = editor.lineStateCache.length
+//   const tokens = []
+//   const lines = editor.lines
+//   let lineState = editor.tokenizer.initialLineState
+//   for (let i = currentLength; i < max; i++) {
+//     const line = lines[i]
+//     try {
+//       lineState = editor.tokenizer.tokenizeLine(line, lineState)
+//       if (!lineState || !lineState.tokens || !lineState.state) {
+//         throw new Error('invalid tokenization result')
+//       }
+//     } catch (error) {
+//       tokens.push([{ length: line.length, type: 0 }])
+//       console.error(error)
+//       // renderWithoutSyntaxHighlighting(state, firstRow, lastRow)
+//       continue
+//     }
+//     const newTokens = lineState.tokens
+//     tokens.push(newTokens)
+//   }
+//   return tokens
+// }
+
+// const getLineInfosIncremental = (editor, tokens, minLineY, maxLineY) => {
+//   const result = []
+//   const lines = editor.lines
+//   const TokenMap = editor.tokenizer.TokenMap
+//   for (let i = minLineY; i < maxLineY; i++) {
+//     result.push(getLineInfo(lines[i], tokens[i], TokenMap))
+//   }
+//   return result
+// }
+
+const getStartDefaults = (tokens, minOffset) => {
+  let start = 0;
+  let end = 0;
+  let startIndex = 0;
+  const tokensLength = tokens.length;
+  for (let i = 0; i < tokensLength; i += 2) {
+    const tokenLength = tokens[i + 1];
+    end += tokenLength;
+    start = end;
+    if (start >= minOffset) {
+      start -= tokenLength;
+      end -= tokenLength;
+      startIndex = i;
+      break;
+    }
+  }
+  return {
+    start,
+    end,
+    startIndex
+  };
+};
+const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
+  const lineInfo = [];
+  const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
+  const embeddedTokens = embeddedResult.result.tokens;
+  const embeddedTokenMap = embeddedResult.TokenMap;
+  const tokensLength = embeddedTokens.length;
+  let {
+    startIndex,
+    start,
+    end
+  } = getStartDefaults(embeddedTokens, minOffset);
+  const difference = getDifference(start, averageCharWidth, deltaX);
+  for (let i = startIndex; i < tokensLength; i += 2) {
+    const tokenType = embeddedTokens[i];
+    const tokenLength = embeddedTokens[i + 1];
+    end += tokenLength;
+    const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
+    const text = line.slice(start, end);
+    const normalizedText = normalizeText(text, normalize, tabSize);
+    lineInfo.push(normalizedText, className);
+    start = end;
+    if (end >= maxOffset) {
+      break;
+    }
+  }
+  return {
+    lineInfo,
+    difference
+  };
+};
+const getOffsets = (deltaX, width, averageCharWidth) => {
+  // TODO accurately measure char widths using offscreen canvas
+  // and use fast measurements for monospace ascii text
+  if (deltaX === 0) {
+    return {
+      minOffset: 0,
+      maxOffset: Math.ceil(width / averageCharWidth)
+    };
+  }
+  const minOffset = Math.ceil(deltaX / averageCharWidth);
+  const maxOffset = minOffset + Math.ceil(width / averageCharWidth);
+  return {
+    minOffset,
+    maxOffset
+  };
+};
+const getDifference = (start, averageCharWidth, deltaX) => {
+  const beforeWidth = start * averageCharWidth;
+  const difference = beforeWidth - deltaX;
+  return difference;
+};
+const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
+  const lineInfo = [];
+  let decorationIndex = 0;
+  for (; decorationIndex < decorations.length; decorationIndex += 3) {
+    const decorationOffset = decorations[decorationIndex];
+    if (decorationOffset >= lineOffset) {
+      break;
+    }
+  }
+  const {
+    tokens
+  } = tokenResults;
+  let {
+    startIndex,
+    start,
+    end
+  } = getStartDefaults(tokens, minOffset);
+  const difference = getDifference(start, averageCharWidth, deltaX);
+  const tokensLength = tokens.length;
+  for (let i = startIndex; i < tokensLength; i += 2) {
+    const tokenType = tokens[i];
+    const tokenLength = tokens[i + 1];
+    const decorationOffset = decorations[decorationIndex];
+    let extraClassName = '';
+    if (decorationOffset !== undefined && decorationOffset - lineOffset === start) {
+      // @ts-ignore
+      decorations[++decorationIndex];
+      const decorationType = decorations[++decorationIndex];
+      // @ts-ignore
+      decorations[++decorationIndex];
+      //   decorationIndex,
+      //   decorationLength,
+      //   decorationType,
+      //   decorationModifiers,
+      // })
+      extraClassName = getDecorationClassName(decorationType);
+    }
+    end += tokenLength;
+    const text = line.slice(start, end);
+    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`;
+    const normalizedText = normalizeText(text, normalize, tabSize);
+    lineInfo.push(normalizedText, className);
+    start = end;
+    if (end >= maxOffset) {
+      break;
+    }
+  }
+  return {
+    lineInfo,
+    difference
+  };
+};
+const getLineInfo$1 = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth) => {
+  const {
+    minOffset,
+    maxOffset
+  } = getOffsets(deltaX, width, averageCharWidth);
+  if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
+    const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
+    if (embeddedResult?.isFull) {
+      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
+    }
+  }
+  return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
+};
+
+// TODO need lots of tests for this
+const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth) => {
+  const result = [];
+  const differences = [];
+  const {
+    lines,
+    decorations,
+    languageId
+  } = editor;
+  const tokenMap = get$2(languageId);
+  let offset = minLineOffset;
+  const tabSize = 2;
+  for (let i = minLineY; i < maxLineY; i++) {
+    const line = lines[i];
+    const normalize = shouldNormalizeText(line);
+    const {
+      lineInfo,
+      difference
+    } = getLineInfo$1(line, tokens[i - minLineY], embeddedResults, decorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
+    result.push(lineInfo);
+    differences.push(difference);
+    offset += line.length + 1;
+  }
+  return {
+    result,
+    differences
+  };
+};
+const getVisible$1 = async (editor, syncIncremental) => {
+  // TODO should separate rendering from business logic somehow
+  // currently hard to test because need to mock editor height, top, left,
+  // invalidStartIndex, lineCache, etc. just for testing editorType
+  // editor.invalidStartIndex = changes[0].start.rowIndex
+  // @ts-ignore
+  const {
+    minLineY,
+    numberOfVisibleLines,
+    lines,
+    width,
+    deltaX,
+    charWidth
+  } = editor;
+  const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
+  // @ts-ignore
+  const {
+    tokens,
+    tokenizersToLoad,
+    embeddedResults
+  } = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
+  const minLineOffset = offsetAtSync(editor, minLineY, 0);
+  const averageCharWidth = charWidth;
+  const {
+    result,
+    differences
+  } = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth);
+  if (tokenizersToLoad.length > 0) {
+    loadTokenizers(tokenizersToLoad);
+  }
+  return {
+    textInfos: result,
+    differences
+  };
+};
+
+const emptyIncrementalEdits = [];
+
+const getIncrementalEdits = async (oldState, newState) => {
+  if (!newState.undoStack) {
+    return emptyIncrementalEdits;
+  }
+  if (oldState.undoStack === newState.undoStack) {
+    return emptyIncrementalEdits;
+  }
+  const lastChanges = newState.undoStack.at(-1);
+  if (lastChanges && lastChanges.length === 1) {
+    const lastChange = lastChanges[0];
+    if (lastChange.origin === EditorType) {
+      const {
+        rowIndex
+      } = lastChange.start;
+      const {
+        lines
+      } = newState;
+      const oldLine = oldState.lines[rowIndex];
+      const newLine = lines[rowIndex];
+      // @ts-ignore
+      const incrementalEdits = await invoke$7(
+      // @ts-ignore
+      'TokenizeIncremental.tokenizeIncremental', newState.uid,
+      // @ts-ignore
+      newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
+      if (incrementalEdits && incrementalEdits.length === 1) {
+        return incrementalEdits;
+      }
+    }
+  }
+  return emptyIncrementalEdits;
+};
+
+const splitLines = lines => {
+  if (!lines) {
+    return [''];
+  }
+  return lines.split('\n');
+};
+
+let enabled = false;
+const setEnabled = value => {
+  enabled = value;
+};
+const getEnabled = () => {
+  return enabled;
+};
+
+const getSelectionPairs = (selections, i) => {
+  const first = selections[i];
+  const second = selections[i + 1];
+  const third = selections[i + 2];
+  const fourth = selections[i + 3];
+  if (first > third || first === third && second >= fourth) {
+    return [third, fourth, first, second, 1];
+  }
+  return [first, second, third, fourth, 0];
+};
+
+const getTabCount = string => {
+  let count = 0;
+  for (const element of string) {
+    if (element === Tab) {
+      count++;
+    }
+  }
+  return count;
+};
+
+const measureTextWidthFast = (text, charWidth) => {
+  return text.length * charWidth;
+};
+
+const getFontString = (fontWeight, fontSize, fontFamily) => {
+  return `${fontWeight} ${fontSize}px ${fontFamily}`;
+};
+
+const getLetterSpacingString = letterSpacing => {
+  return `${letterSpacing}px`;
+};
+
+const createMeasureContext = () => {
+  const canvas = new OffscreenCanvas(0, 0);
+  const ctx = /** @type {OffscreenCanvasRenderingContext2D} */canvas.getContext('2d');
+  if (!ctx) {
+    throw new Error('Failed to get canvas context 2d');
+  }
+  return ctx;
+};
+
+const state$6 = {
+  ctx: undefined
+};
+const getOrCreate$4 = createCtx => {
+  if (state$6.ctx) {
+    return state$6.ctx;
+  }
+  state$6.ctx = createCtx();
+  return state$6.ctx;
+};
+
+const getContext = () => {
+  const ctx = getOrCreate$4(createMeasureContext);
+  return ctx;
+};
+
+// TODO for text editor, could dispose measuring canvas after editor has been initialized to free up offscreencanvas space
+
+const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  string(text);
+  number(fontWeight);
+  number(fontSize);
+  string(fontFamily);
+  boolean(isMonoSpaceFont);
+  number(charWidth);
+  if (typeof letterSpacing !== 'number') {
+    throw new TypeError('letterSpacing must be of type number');
+  }
+  const letterSpacingString = getLetterSpacingString(letterSpacing);
+  const fontString = getFontString(fontWeight, fontSize, fontFamily);
+  const ctx = getContext();
+  ctx.letterSpacing = letterSpacingString;
+  ctx.font = fontString;
+  const metrics = ctx.measureText(text);
+  const {
+    width
+  } = metrics;
+  return width;
+};
+
+const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  if (isMonoSpaceFont) {
+    return measureTextWidthFast(text, charWidth);
+  }
+  return measureTextWidthSlow(text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
+};
+
+const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference = 0) => {
+  if (!line) {
+    return 0;
+  }
+  string(line);
+  number(tabSize);
+  number(halfCursorWidth);
+  number(width);
+  boolean(isMonospaceFont);
+  number(averageCharWidth);
+  number(difference);
+  if (column === 0) {
+    return 0;
+  }
+  // TODO support non-monospace font, emoji, tab character, zero width characters
+  if (column * averageCharWidth > width) {
+    return width;
+  }
+  const normalize = shouldNormalizeText(line);
+  const normalizedLine = normalizeText(line, normalize, tabSize);
+  const tabCount = getTabCount(line.slice(0, column));
+  const partialText = normalizedLine.slice(0, column + tabCount);
+  return measureTextWidth(partialText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, averageCharWidth) - halfCursorWidth + difference;
+};
+
+const getY = (row, minLineY, rowHeight) => {
+  return (row - minLineY) * rowHeight;
+};
+
+const px = value => {
+  return `${value}px`;
+};
+
+const fromRange = (startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  return new Uint32Array([startRowIndex, startColumnIndex, endRowIndex, endColumnIndex]);
+};
+const alloc = length => {
+  return new Uint32Array(length);
+};
+const clone = selections => {
+  return alloc(selections.length);
+};
+const map = (selections, fn) => {
+  const newSelections = clone(selections);
+  for (let i = 0; i < newSelections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    fn(newSelections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+  }
+  return newSelections;
+};
+const forEach = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+  }
+};
+const moveRangeToPosition$1 = (selections, i, rowIndex, columnIndex) => {
+  selections[i] = selections[i + 2] = rowIndex;
+  selections[i + 1] = selections[i + 3] = columnIndex;
+};
+const isEmpty = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  return selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn;
+};
+const isSelectionSingleLine = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  return selectionStartRow === selectionEndRow;
+};
+const isEverySelection = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    if (!fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
+      return false;
+    }
+  }
+  return true;
+};
+const isEverySelectionEmpty = selections => {
+  return isEverySelection(selections, isEmpty);
+};
+const isEverySelectionSingleLine = selections => {
+  return isEverySelection(selections, isSelectionSingleLine);
+};
+const from = (array, getSelection) => {
+  const newSelections = alloc(array.length * 4);
+  let i = 0;
+  for (const item of array) {
+    const {
+      start,
+      end
+    } = getSelection(item);
+    newSelections[i++] = start.rowIndex;
+    newSelections[i++] = start.columnIndex;
+    newSelections[i++] = end.rowIndex;
+    newSelections[i++] = end.columnIndex;
+  }
+  return newSelections;
+};
+const push = (selections, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  const oldLength = selections.length;
+  const newSelections = alloc(oldLength + 4);
+  newSelections.set(selections);
+  newSelections[oldLength + 1] = startRowIndex;
+  newSelections[oldLength + 2] = startColumnIndex;
+  newSelections[oldLength + 3] = endRowIndex;
+  newSelections[oldLength + 4] = endColumnIndex;
+  return newSelections;
+};
+
+// TODO maybe only accept sorted selection edits in the first place
+
+const emptyCursors = [];
+const getCursorArray = (visibleCursors, isFocused) => {
+  if (!isFocused) {
+    return emptyCursors;
+  }
+  const cursorArray = [];
+  for (let i = 0; i < visibleCursors.length; i += 2) {
+    const x = visibleCursors[i];
+    const y = visibleCursors[i + 1];
+    cursorArray.push(`${px(x)} ${px(y)}`);
+  }
+  return cursorArray;
+};
+const getSelectionArray = visibleSelections => {
+  const selectionsArray = [];
+  for (let i = 0; i < visibleSelections.length; i += 4) {
+    const x = visibleSelections[i];
+    const y = visibleSelections[i + 1];
+    const width = visibleSelections[i + 2];
+    const height = visibleSelections[i + 3];
+    selectionsArray.push(px(x), px(y), px(width), px(height));
+  }
+  return selectionsArray;
+};
+const getVisible = editor => {
+  const visibleCursors = [];
+  const visibleSelections = [];
+  // // TODO binary search
+
+  const {
+    selections,
+    minLineY,
+    maxLineY,
+    rowHeight,
+    lines,
+    fontSize,
+    fontFamily,
+    fontWeight,
+    letterSpacing,
+    cursorWidth,
+    tabSize,
+    width,
+    differences,
+    focused,
+    charWidth,
+    isMonospaceFont
+  } = editor;
+  const averageCharWidth = charWidth;
+  const halfCursorWidth = cursorWidth / 2;
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(selections, i);
+    if (selectionEndRow < minLineY || selectionStartRow > maxLineY) {
+      continue;
+    }
+    const relativeEndLineRow = selectionEndRow - minLineY;
+    const endLineDifference = differences[relativeEndLineRow];
+    const endLine = lines[selectionEndRow];
+    const endLineEndX = getX(endLine, selectionEndColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, endLineDifference);
+    const endLineY = getY(selectionEndRow, minLineY, rowHeight);
+    if (isEmpty(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) && endLineEndX > 0) {
+      visibleCursors.push(endLineEndX, endLineY);
+      continue;
+    }
+    const startLineY = getY(selectionStartRow, minLineY, rowHeight);
+    const startLineYRelative = selectionStartRow - minLineY;
+    const startLineDifference = differences[startLineYRelative];
+    if (selectionStartRow === selectionEndRow) {
+      const startX = getX(endLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+      if (reversed) {
+        visibleCursors.push(startX, endLineY);
+      } else if (endLineEndX >= 0) {
+        visibleCursors.push(endLineEndX, endLineY);
+      }
+      const selectionWidth = endLineEndX - startX;
+      visibleSelections.push(startX, startLineY, selectionWidth, rowHeight);
+    } else {
+      if (selectionStartRow >= minLineY) {
+        const startLine = lines[selectionStartRow];
+        const startLineStartX = getX(startLine, selectionStartColumn, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineEndX = getX(startLine, startLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, startLineDifference);
+        const startLineStartY = getY(selectionStartRow, minLineY, rowHeight);
+        const selectionWidth = startLineEndX - startLineStartX;
+        if (reversed) {
+          visibleCursors.push(startLineStartX, startLineStartY);
+        }
+        visibleSelections.push(startLineStartX, startLineStartY, selectionWidth, rowHeight);
+      }
+      const iMin = Math.max(selectionStartRow + 1, minLineY);
+      const iMax = Math.min(selectionEndRow, maxLineY);
+      for (let i = iMin; i < iMax; i++) {
+        const currentLine = lines[i];
+        const currentLineY = getY(i, minLineY, rowHeight);
+        const relativeLine = i - minLineY;
+        const difference = differences[relativeLine];
+        const selectionWidth = getX(currentLine, currentLine.length, fontWeight, fontSize, fontFamily, isMonospaceFont, letterSpacing, tabSize, halfCursorWidth, width, averageCharWidth, difference);
+        visibleSelections.push(0, currentLineY, selectionWidth, rowHeight);
+      }
+      if (selectionEndRow <= maxLineY) {
+        const selectionWidth = endLineEndX;
+        visibleSelections.push(0, endLineY, selectionWidth, rowHeight);
+        if (!reversed) {
+          visibleCursors.push(selectionWidth, endLineY);
+        }
+      }
+    }
+  }
+  // TODO maybe use Uint32array or Float64Array?
+  return {
+    cursorInfos: getCursorArray(visibleCursors, focused),
+    selectionInfos: getSelectionArray(visibleSelections)
+  };
+};
+
+const getSelectionFromChange = change => {
+  const {
+    start,
+    inserted
+  } = change;
+  const startRowIndex = start.rowIndex;
+  const startColumnIndex = start.columnIndex;
+  const insertedLength = inserted.length;
+  if (insertedLength === 1) {
+    const newPosition = {
+      rowIndex: startRowIndex + insertedLength - 1,
+      columnIndex: inserted.at(-1).length + startColumnIndex
+    };
+    return {
+      start: newPosition,
+      end: newPosition
+    };
+  }
+  const newPosition = {
+    rowIndex: startRowIndex + insertedLength - 1,
+    columnIndex: startColumnIndex
+  };
+  return {
+    start: newPosition,
+    end: newPosition
+  };
+};
+const setSelections$1 = (editor, selections) => {
+  object(editor);
+  // Assert.uint32array(selections)
+  return {
+    ...editor,
+    selections
+  };
+  // editor.selections = selections
+  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
+};
+
+// TODO maybe only accept sorted selection edits in the first place
+
+// TODO avoid allocating too many objects when creating new selection from changes
+// @ts-ignore
+const applyEdit$1 = (editor, changes) => {
   object(editor);
   array(changes);
   const newSelections = from(changes, getSelectionFromChange);
@@ -2428,15 +3163,29 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
     autoClosingRanges
   };
   set$6(editor.uid, editor, newEditor);
+  const incrementalEdits = await getIncrementalEdits(editor, newEditor);
   const newWidgets = await applyWidgetChanges(newEditor, changes);
   const newEditor2 = {
     ...newEditor,
-    widgets: newWidgets
+    widgets: newWidgets,
+    incrementalEdits
+  };
+  if (incrementalEdits !== emptyIncrementalEdits) {
+    return newEditor2;
+  }
+  const syncIncremental = getEnabled();
+  const {
+    textInfos,
+    differences
+  } = await getVisible$1(newEditor2, syncIncremental);
+  return {
+    ...newEditor2,
+    textInfos,
+    differences
   };
-  return newEditor2;
 };
 // @ts-ignore
-const scheduleDocumentAndCursorsSelectionIsUndo = (editor, changes) => {
+const scheduleDocumentAndCursorsSelectionIsUndo = async (editor, changes) => {
   object(editor);
   array(changes);
   if (changes.length === 0) {
@@ -2456,7 +3205,26 @@ const scheduleDocumentAndCursorsSelectionIsUndo = (editor, changes) => {
     // undoStack: [...editor.undoStack.slice(0, -2)],
     invalidStartIndex
   };
-  return newEditor;
+  const incrementalEdits = await getIncrementalEdits(editor, newEditor);
+
+  // TODO change event should be emitted after rendering
+  const finalEditor = {
+    ...newEditor,
+    incrementalEdits
+  };
+  if (incrementalEdits !== emptyIncrementalEdits) {
+    return finalEditor;
+  }
+  const syncIncremental = getEnabled();
+  const {
+    textInfos,
+    differences
+  } = await getVisible$1(finalEditor, syncIncremental);
+  return {
+    ...finalEditor,
+    textInfos,
+    differences
+  };
 };
 
 // @ts-ignore
@@ -2481,8 +3249,26 @@ const scheduleDocument = async (editor, changes) => {
     lines: newLines,
     invalidStartIndex
   };
+  const incrementalEdits = await getIncrementalEdits(editor, newEditor);
+
   // TODO change event should be emitted after rendering
-  return newEditor;
+  const finalEditor = {
+    ...newEditor,
+    incrementalEdits
+  };
+  if (incrementalEdits !== emptyIncrementalEdits) {
+    return finalEditor;
+  }
+  const syncIncremental = getEnabled();
+  const {
+    textInfos,
+    differences
+  } = await getVisible$1(finalEditor, syncIncremental);
+  return {
+    ...finalEditor,
+    textInfos,
+    differences
+  };
   // RendererProcess.send([
   //   /* Viewlet.invoke */ 'Viewlet.send',
   //   /* id */ 'EditorText',
@@ -2548,8 +3334,8 @@ const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompl
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
 const {
-  set: set$5,
-  invoke: invoke$7} = ExtensionHost;
+  set: set$1,
+  invoke: invoke$6} = ExtensionHost;
 
 const ColorPicker = 41;
 const EditorCompletion = 9;
@@ -2578,7 +3364,7 @@ const execute = async ({
 }) => {
   const fullEvent = `${event}:${editor.languageId}`;
   await activateByEvent(fullEvent);
-  const result = await invoke$7(method, editor.uid, ...args);
+  const result = await invoke$6(method, editor.uid, ...args);
   return result;
 };
 
@@ -2646,7 +3432,7 @@ const updateDiagnostics = async newState => {
     // TODO don't really need text document sync response
     // could perhaps save a lot of messages by using send instead of invoke
     // @ts-ignore
-    await invoke$7(TextDocumentSyncFull, newState.uri, newState.id, newState.languageId, content);
+    await invoke$6(TextDocumentSyncFull, newState.uri, newState.id, newState.languageId, content);
     const diagnostics = await executeDiagnosticProvider(newState);
     const latest = get$4(newState.id);
     if (!latest) {
@@ -2672,6 +3458,8 @@ const updateDiagnostics = async newState => {
 };
 
 const emptyEditor = {
+  textInfos: [],
+  differences: [],
   uri: '',
   languageId: '',
   // TODO use numeric language id?
@@ -2695,7 +3483,8 @@ const emptyEditor = {
   selections: new Uint32Array(),
   diagnostics: [],
   highlightedLine: -1,
-  debugEnabled: false
+  debugEnabled: false,
+  incrementalEdits: emptyIncrementalEdits
 };
 const createEditor = async ({
   id,
@@ -2732,6 +3521,7 @@ const createEditor = async ({
   string(content);
   const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
   const editor = {
+    textInfos: [],
     uri,
     isAutoClosingBracketsEnabled,
     isAutoClosingTagsEnabled,
@@ -2787,7 +3577,8 @@ const createEditor = async ({
     id,
     widgets: [],
     focusKey: Empty,
-    diagnosticsEnabled
+    diagnosticsEnabled,
+    incrementalEdits: emptyIncrementalEdits
   };
   // TODO avoid creating intermediate editors here
   const newEditor1 = setBounds(editor, x, y, width, height, 9);
@@ -2800,13 +3591,23 @@ const createEditor = async ({
   } else {
     newEditor3 = setDeltaY$2(newEditor2, 0);
   }
+  const syncIncremental = getEnabled();
+  const {
+    textInfos,
+    differences
+  } = await getVisible$1(newEditor3, syncIncremental);
   const newEditor4 = {
     ...newEditor3,
-    focused: true
+    focused: true,
+    textInfos,
+    differences
   };
   set$6(id, emptyEditor, newEditor4);
+
+  // TODO only sync when needed
+  // e.g. it might not always be necessary to send text to extension host worker
   // @ts-ignore
-  await invoke$7(TextDocumentSyncFull, uri, id, languageId, content);
+  await invoke$6(TextDocumentSyncFull, uri, id, languageId, content);
   if (diagnosticsEnabled) {
     updateDiagnostics(newEditor4);
   }
@@ -3086,7 +3887,7 @@ const guessOffset = (eventX, averageCharWidth) => {
 const normalizeGuess = (line, guess, tabSize) => {
   let normalizedGuess = guess;
   for (let i = 0; i < guess; i++) {
-    if (line[i] === Tab$1) {
+    if (line[i] === Tab) {
       normalizedGuess -= tabSize - 1;
     }
   }
@@ -3180,7 +3981,7 @@ const y = (editor, rowIndex) => {
   return offsetY;
 };
 
-const state$7 = {
+const state$5 = {
   timeout: -1
 };
 
@@ -3211,7 +4012,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
 
     // TODO use wrapper timing module instead of this
     // @ts-ignore
-    state$7.timeout = setTimeout(handleTimeout, 3000);
+    state$5.timeout = setTimeout(handleTimeout, 3000);
   }
   return editor;
 };
@@ -3231,8 +4032,8 @@ const showErrorMessage = async (editor, rowIndex, columnIndex, message) => {
 
 // @ts-ignore
 const editorHideMessage = async editor => {
-  clearTimeout(state$7.timeout);
-  state$7.timeout = -1;
+  clearTimeout(state$5.timeout);
+  state$5.timeout = -1;
   // await RendererProcess.invoke(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage')
   return editor;
 };
@@ -3357,7 +4158,7 @@ const getOrCreate$3 = () => {
   }
   return workerPromise$3;
 };
-const invoke$6 = async (method, ...params) => {
+const invoke$5 = async (method, ...params) => {
   const worker = await getOrCreate$3();
   return await worker.invoke(method, ...params);
 };
@@ -3376,7 +4177,7 @@ const closeRename = async editor => {
     return editor;
   }
   const renameWidget = widgets[renameWidgetIndex];
-  await invoke$6('Rename.close', renameWidget.newState.uid);
+  await invoke$5('Rename.close', renameWidget.newState.uid);
   const latest = get$4(uid);
   const {
     newState
@@ -3495,12 +4296,12 @@ const openColorPicker = async editor => {
   return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$6, newStateGenerator$6);
 };
 
-const state$6 = {
+const state$4 = {
   isComposing: false,
   compositionText: ''
 };
 const compositionStart = (editor, event) => {
-  state$6.isComposing = true;
+  state$4.isComposing = true;
   return editor;
 };
 const getCompositionChanges = (selections, data) => {
@@ -3510,7 +4311,7 @@ const getCompositionChanges = (selections, data) => {
     const selectionStartColumn = selections[i + 1];
     const selectionEndRow = selections[i + 2];
     const selectionEndColumn = selections[i + 3];
-    const startColumnIndex = selectionStartColumn - state$6.compositionText.length;
+    const startColumnIndex = selectionStartColumn - state$4.compositionText.length;
     changes.push({
       start: {
         rowIndex: selectionStartRow,
@@ -3521,7 +4322,7 @@ const getCompositionChanges = (selections, data) => {
         columnIndex: selectionEndColumn
       },
       inserted: [data],
-      deleted: [state$6.compositionText],
+      deleted: [state$4.compositionText],
       origin: CompositionUpdate
     });
   }
@@ -3532,7 +4333,7 @@ const compositionUpdate = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$6.compositionText = data;
+  state$4.compositionText = data;
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 const compositionEnd = (editor, data) => {
@@ -3540,8 +4341,8 @@ const compositionEnd = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$6.isComposing = false;
-  state$6.compositionText = '';
+  state$4.isComposing = false;
+  state$4.compositionText = '';
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
@@ -3755,7 +4556,7 @@ const characterRight = (line, columnIndex) => {
   return next.segment.length;
 };
 const isWhitespace = char => {
-  return char === Space$1 || char === Tab$1;
+  return char === Space || char === Tab;
 };
 const lineCharacterStart = (line, columnIndex) => {
   if (line.length === 0) {
@@ -4567,68 +5368,19 @@ const goToTypeDefinition = async (editor, explicit = true) => {
   });
 };
 
-const Editor = 3;
-
-const handleContextMenu = async (editor, button, x, y) => {
-  await invoke$9(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
-  return editor;
-};
-
-// @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;
-
-// @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;
-};
-
-// @ts-ignore
-const selectWord = (editor, rowIndex, columnIndex) => {
-  const line = getLine(editor, rowIndex);
-  const newSelections = getNewSelections$7(line, rowIndex, columnIndex);
-  return scheduleSelections(editor, newSelections);
-};
-
-const handleDoubleClick = (editor, modifier, x, y) => {
-  const position = at(editor, x, y);
-  return selectWord(editor, position.rowIndex, position.columnIndex);
-};
-
-const WhenExpressionEditorText = 12;
-const handleFocus$1 = editor => {
-  // TODO make change events functional,
-  // when rendering, send focus changes to renderer worker
-  invoke$9('Focus.setFocus', WhenExpressionEditorText);
-  return editor;
-};
-
-const Single = 1;
-const Double = 2;
-const Triple = 3;
-
-const state$5 = {
+const state$3 = {
   position: {
     rowIndex: 0,
     columnIndex: 0
   }
 };
 const getPosition$1 = () => {
-  return state$5.position;
+  return state$3.position;
 };
 
 // @ts-ignore
 const setPosition$1 = position => {
-  state$5.position = position;
+  state$3.position = position;
 };
 
 // TODO first change cursor position, then run go to definition
@@ -4675,7 +5427,7 @@ const handleSingleClickWithCtrl = async (editor, position) => {
 };
 
 const Ctrl = 1;
-const Alt$1 = 2;
+const Alt = 2;
 
 const handleSingleClickDefault = (editor, position) => {
   setPosition$1(position);
@@ -4685,37 +5437,86 @@ const handleSingleClickDefault = (editor, position) => {
     focused: true
   };
 };
-const getClickHandler = modifier => {
-  switch (modifier) {
-    case Alt$1:
-      return handleSingleClickWithAlt;
-    case Ctrl:
-      return handleSingleClickWithCtrl;
-    default:
-      return handleSingleClickDefault;
-  }
+const getClickHandler = modifier => {
+  switch (modifier) {
+    case Alt:
+      return handleSingleClickWithAlt;
+    case Ctrl:
+      return handleSingleClickWithCtrl;
+    default:
+      return handleSingleClickDefault;
+  }
+};
+
+const handleClickAtPosition = async (editor, modifier, rowIndex, columnIndex) => {
+  object(editor);
+  number(modifier);
+  number(rowIndex);
+  number(columnIndex);
+  const fn = getClickHandler(modifier);
+  const newEditor = await fn(editor, {
+    rowIndex,
+    columnIndex
+  });
+  return newEditor;
+};
+
+const Editor = 3;
+
+const handleContextMenu = async (editor, button, x, y) => {
+  await invoke$9(/* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
+  return editor;
+};
+
+// @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;
+
+// @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;
+};
+
+// @ts-ignore
+const selectWord = (editor, rowIndex, columnIndex) => {
+  const line = getLine(editor, rowIndex);
+  const newSelections = getNewSelections$7(line, rowIndex, columnIndex);
+  return scheduleSelections(editor, newSelections);
+};
+
+const handleDoubleClick = (editor, modifier, x, y) => {
+  const position = at(editor, x, y);
+  return selectWord(editor, position.rowIndex, position.columnIndex);
+};
+
+const WhenExpressionEditorText = 12;
+const handleFocus$1 = editor => {
+  // TODO make change events functional,
+  // when rendering, send focus changes to renderer worker
+  invoke$9('Focus.setFocus', WhenExpressionEditorText);
+  return editor;
 };
 
+const Single = 1;
+const Double = 2;
+const Triple = 3;
+
 const handleSingleClick = async (editor, modifier, x, y) => {
   object(editor);
   number(modifier);
   number(x);
   number(y);
   const position = at(editor, x, y);
-  const fn = getClickHandler(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;
+  return handleClickAtPosition(editor, modifier, position.rowIndex, position.columnIndex);
 };
 
 // @ts-ignore
@@ -4762,20 +5563,20 @@ const handleMouseDown = (state, modifier, x, y, detail) => {
   }
 };
 
-const state$4 = {
+const state$2 = {
   timeout: -1,
   x: 0,
   y: 0,
   editor: undefined
 };
-const get$3 = () => {
-  return state$4;
+const get = () => {
+  return state$2;
 };
-const set$4 = (editor, timeout, x, y) => {
-  state$4.editor = editor;
-  state$4.timeout = timeout;
-  state$4.x = x;
-  state$4.y = y;
+const set = (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) => {
@@ -4797,7 +5598,7 @@ const onHoverIdle = async () => {
     x,
     y,
     editor
-  } = get$3();
+  } = get();
   at(editor, x, y);
   await showHover$1();
 };
@@ -4808,12 +5609,12 @@ const handleMouseMove = (editor, x, y) => {
   if (!editor.hoverEnabled) {
     return editor;
   }
-  const oldState = get$3();
+  const oldState = get();
   if (oldState.timeout !== -1) {
     clearTimeout(oldState.timeout);
   }
   const timeout = setTimeout(onHoverIdle, hoverDelay);
-  set$4(editor, timeout, x, y);
+  set(editor, timeout, x, y);
   return editor;
 };
 
@@ -4920,7 +5721,7 @@ const editorHandleNativeSelectionChange = (editor, range) => {
   return scheduleSelections(editor, selections);
 };
 
-const state$3 = {
+const state$1 = {
   /**
    * @type {any}
    */
@@ -4934,26 +5735,26 @@ const state$3 = {
 
 // @ts-ignore
 const setEditor = editor => {
-  state$3.currentEditor = editor;
-  state$3.hasListener = true;
+  state$1.currentEditor = editor;
+  state$1.hasListener = true;
 };
 const clearEditor = () => {
-  state$3.currentEditor = undefined;
-  state$3.hasListener = false;
+  state$1.currentEditor = undefined;
+  state$1.hasListener = false;
 };
 
 // @ts-ignore
 const setPosition = position => {
-  state$3.position = position;
+  state$1.position = position;
 };
 const getEditor$1 = () => {
-  return state$3.currentEditor;
+  return state$1.currentEditor;
 };
 const getPosition = () => {
-  return state$3.position;
+  return state$1.position;
 };
 const hasListener = () => {
-  return state$3.hasListener;
+  return state$1.hasListener;
 };
 
 // @ts-ignore
@@ -5136,7 +5937,7 @@ const handleTouchEnd = (editor, touchEvent) => {
   // }
 };
 
-const state$2 = {
+const state = {
   touchOffsetY: 0,
   deltaY: 0
 };
@@ -5147,8 +5948,8 @@ const handleTouchStart = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  state$2.touchOffsetY = firstTouch.y;
-  state$2.deltaY = editor.deltaY;
+  state.touchOffsetY = firstTouch.y;
+  state.deltaY = editor.deltaY;
   // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
   // EditorMoveSelection.state.position = position
   // state.date = Date.now()
@@ -5188,7 +5989,7 @@ const handleTouchMove = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  const offsetY = state$2.deltaY + (state$2.touchOffsetY - firstTouch.y);
+  const offsetY = state.deltaY + (state.touchOffsetY - firstTouch.y);
   setDeltaYFixedValue(editor, offsetY);
 };
 
@@ -5624,7 +6425,7 @@ const getOrCreate$2 = () => {
   }
   return workerPromise$2;
 };
-const invoke$5 = async (method, ...params) => {
+const invoke$4 = async (method, ...params) => {
   const worker = await getOrCreate$2();
   return await worker.invoke(method, ...params);
 };
@@ -5643,10 +6444,10 @@ const newStateGenerator$4 = async (state, parentUid) => {
   const {
     languageId
   } = newState;
-  await invoke$5('Completions.create', uid, x, y, width, height, parentUid, languageId);
-  await invoke$5('Completions.loadContent', uid);
-  const diff = await invoke$5('Completions.diff2', uid);
-  const commands = await invoke$5('Completions.render2', uid, diff);
+  await invoke$4('Completions.create', uid, x, y, width, height, parentUid, languageId);
+  await invoke$4('Completions.loadContent', uid);
+  const diff = await invoke$4('Completions.diff2', uid);
+  const commands = await invoke$4('Completions.render2', uid, diff);
   return {
     ...state,
     commands
@@ -5698,7 +6499,7 @@ const launch = async () => {
   const rpc = await launchFindWidgetWorker();
   set$c(rpcId, rpc);
 };
-const invoke$4 = async (method, ...params) => {
+const invoke$3 = async (method, ...params) => {
   const rpc = get$6(rpcId);
   return await rpc.invoke(method, ...params);
 };
@@ -5737,10 +6538,10 @@ const loadContent$1 = async (state, parentUid) => {
     height
   } = editor;
   await launch();
-  await invoke$4('FindWidget.create', uid, x, y, width, height, parentUid);
-  await invoke$4('FindWidget.loadContent', uid);
-  const diff = await invoke$4('FindWidget.diff2', uid);
-  const commands = await invoke$4('FindWidget.render2', uid, diff);
+  await invoke$3('FindWidget.create', uid, x, y, width, height, parentUid);
+  await invoke$3('FindWidget.loadContent', uid);
+  const diff = await invoke$3('FindWidget.diff2', uid);
+  const commands = await invoke$3('FindWidget.render2', uid, diff);
   return {
     ...state,
     commands
@@ -5813,10 +6614,10 @@ const newStateGenerator$2 = async (state, parentUid) => {
   const {
     languageId
   } = newState;
-  await invoke$6('Rename.create', uid, x, y, width, height, parentUid, languageId);
-  await invoke$6('Rename.loadContent', uid);
-  const diff = await invoke$6('Rename.diff2', uid);
-  const commands = await invoke$6('Rename.render2', uid, diff);
+  await invoke$5('Rename.create', uid, x, y, width, height, parentUid, languageId);
+  await invoke$5('Rename.loadContent', uid);
+  const diff = await invoke$5('Rename.diff2', uid);
+  const commands = await invoke$5('Rename.render2', uid, diff);
   return {
     ...state,
     commands
@@ -6556,128 +7357,6 @@ const setDecorations = (editor, decorations, diagnostics) => {
   };
 };
 
-let enabled$1 = false;
-const setEnabled$1 = value => {
-  enabled$1 = value;
-};
-const getEnabled$1 = () => {
-  return enabled$1;
-};
-
-const {
-  set: set$3,
-  invoke: invoke$3} = SyntaxHighlightingWorker;
-
-/**
- * @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),
-  pending: Object.create(null)};
-const has = languageId => {
-  return languageId in state$1.tokenizers;
-};
-const set$2 = (languageId, tokenizer) => {
-  state$1.tokenizers[languageId] = tokenizer;
-};
-const get$2 = languageId => {
-  return state$1.tokenizers[languageId];
-};
-const isPending = languageId => {
-  return languageId in state$1.pending;
-};
-
-const tokenMaps = Object.create(null);
-const set$1 = (languageId, tokenMap) => {
-  tokenMaps[languageId] = tokenMap;
-};
-const get$1 = languageId => {
-  return tokenMaps[languageId] || {};
-};
-
-// TODO loadTokenizer should be invoked from renderer worker
-const loadTokenizer = async (languageId, tokenizePath) => {
-  if (!tokenizePath) {
-    return;
-  }
-  if (getEnabled$1()) {
-    // @ts-ignore
-    const tokenMap = await invoke$3('Tokenizer.load', languageId, tokenizePath);
-    set$1(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$1(languageId, tokenizer.TokenMap);
-    set$2(languageId, tokenizer);
-  } catch (error) {
-    // TODO better error handling
-    console.error(error);
-  }
-};
-const getTokenizer = languageId => {
-  if (has(languageId)) {
-    return get$2(languageId);
-  }
-  if (isPending(languageId)) {
-    return TokenizePlainText;
-  }
-  return TokenizePlainText;
-};
-
-const tokenizers = Object.create(null);
-const set = (id, value) => {
-  tokenizers[id] = value;
-};
-const get = id => {
-  return tokenizers[id] || TokenizePlainText;
-};
-
 // TODO add command to set language id
 // without needing to specify tokenizePath
 const setLanguageId = async (editor, languageId, tokenizePath) => {
@@ -6691,17 +7370,33 @@ const setLanguageId = async (editor, languageId, tokenizePath) => {
   await loadTokenizer(languageId, tokenizePath);
   const tokenizer = getTokenizer(languageId);
   const newTokenizerId = tokenizerId + 1;
-  set(newTokenizerId, tokenizer);
+  set$2(newTokenizerId, tokenizer);
   const latest = getEditor(editor.uid);
   if (!latest) {
     return editor;
   }
+  const syncIncremental = getEnabled();
+  const {
+    textInfos,
+    differences
+  } = await getVisible$1(editor, syncIncremental);
+  const latest2 = getEditor(editor.uid);
+  if (!latest2) {
+    return editor;
+  }
+  const newEditor4 = {
+    ...latest2,
+    focused: true,
+    textInfos,
+    differences
+  };
+
   // TODO don't update editor if tokenizer was already loaded
   // TODO update syntax highlighting
   // TODO get edits
 
   return {
-    ...latest,
+    ...newEditor4,
     languageId,
     invalidStartIndex: 0,
     tokenizerId: newTokenizerId
@@ -7404,7 +8099,7 @@ const type = (editor, text) => {
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-const Slash$1 = '/';
+const Slash = '/';
 
 const CurlyOpen = '{';
 const CurlyClose = '}';
@@ -7519,7 +8214,7 @@ const typeWithAutoClosing = async (editor, text) => {
       }
       break;
     // case AutoClosing.ClosingAngleBracket: // TODO support auto closing when typing closing angle bracket of start tag
-    case Slash$1:
+    case Slash:
       if (isAutoClosingTagsEnabled) {
         return typeWithAutoClosingTag(editor, text);
       }
@@ -7746,11 +8441,11 @@ const getWidgetInvoke = widgetId => {
     case ColorPicker$1:
       return invoke$8;
     case Completion:
-      return invoke$5;
-    case Find:
       return invoke$4;
+    case Find:
+      return invoke$3;
     case Rename$1:
-      return invoke$6;
+      return invoke$5;
     case SourceAction$1:
       return invoke$1;
     case Hover:
@@ -8017,15 +8712,7 @@ const measureTextBlockHeight = async (text, fontFamily, fontSize, lineHeight, wi
   return 100;
 };
 
-const deepCopy = value => {
-  return structuredClone(value);
-};
-
-const getInitialLineState = initialLineState => {
-  return deepCopy(initialLineState);
-};
-
-const getLineInfo$1 = (line, tokens, TokenMap) => {
+const getLineInfo = (line, tokens, TokenMap) => {
   const tokensLength = tokens.length;
   let end = 0;
   let start = 0;
@@ -8043,45 +8730,6 @@ const getLineInfo$1 = (line, tokens, TokenMap) => {
   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?.tokens || !lineState.state) {
-      throw new Error('invalid tokenization result');
-    }
-    if (!hasArrayReturn) {
-      warnDeprecatedArrayReturn(languageId, tokenizeLine);
-      // workaround for old tokenizers
-      lineState.tokens = flattenTokensArray(lineState.tokens);
-    }
-    return lineState;
-  } catch (error) {
-    console.error(error);
-    return {
-      tokens: [/* type */0, /* length */line.length],
-      lineState: lineStateAtStart
-    };
-  }
-};
-
 const getLineInfos = (lines, tokenizer, languageId) => {
   const lineInfos = [];
   const {
@@ -8096,7 +8744,7 @@ const getLineInfos = (lines, tokenizer, languageId) => {
     const {
       tokens
     } = result;
-    const lineInfo = getLineInfo$1(line, tokens, TokenMap);
+    const lineInfo = getLineInfo(line, tokens, TokenMap);
     lineInfos.push(lineInfo);
     currentLineState = result;
   }
@@ -8698,71 +9346,34 @@ const getFonts = () => {
 
 const loadFont = async (fontName, fontUrl) => {
   try {
-    string(fontName);
-    string(fontUrl);
-    if (fontName.startsWith("'")) {
-      throw new Error('font name is not allowed start with quotes');
-    }
-    const fontFace = new FontFace(fontName, fontUrl, {});
-    await fontFace.load();
-    const fonts = getFonts();
-    // @ts-ignore
-    fonts.add(fontFace);
-  } catch (error) {
-    throw new VError(error, `Failed to load font ${fontName}`);
-  }
-};
-
-const ensure = async (fontName, fontUrl) => {
-  if (isLoaded(fontName)) {
-    return;
-  }
-  if (hasPending(fontName)) {
-    return getPending(fontName);
-  }
-  const promise = loadFont(fontName, fontUrl);
-  setPending(fontName, promise);
-  await promise;
-  removePending(fontName);
-  setLoaded(fontName);
-};
-
-const Backspace = 1;
-const Tab = 2;
-const Enter = 3;
-const Escape = 8;
-const Space = 9;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const Delete = 18;
-const KeyA = 29;
-const KeyC = 31;
-const KeyD = 32;
-const KeyF = 34;
-const KeyH = 36;
-const KeyJ = 38;
-const KeyK = 39;
-const KeyL = 40;
-const KeyO = 43;
-const KeyV = 50;
-const KeyX = 52;
-const KeyZ = 54;
-const F2 = 58;
-const F3 = 59;
-const F4 = 60;
-const F12 = 68;
-const Period = 87;
-const Slash = 88;
-const BracketLeft = 90;
-const BracketRight = 92;
+    string(fontName);
+    string(fontUrl);
+    if (fontName.startsWith("'")) {
+      throw new Error('font name is not allowed start with quotes');
+    }
+    const fontFace = new FontFace(fontName, fontUrl, {});
+    await fontFace.load();
+    const fonts = getFonts();
+    // @ts-ignore
+    fonts.add(fontFace);
+  } catch (error) {
+    throw new VError(error, `Failed to load font ${fontName}`);
+  }
+};
 
-const CtrlCmd = 1 << 11 >>> 0;
-const Shift = 1 << 10 >>> 0;
-const Alt = 1 << 9 >>> 0;
+const ensure = async (fontName, fontUrl) => {
+  if (isLoaded(fontName)) {
+    return;
+  }
+  if (hasPending(fontName)) {
+    return getPending(fontName);
+  }
+  const promise = loadFont(fontName, fontUrl);
+  setPending(fontName, promise);
+  await promise;
+  removePending(fontName);
+  setLoaded(fontName);
+};
 
 const getKeyBindings = () => {
   return [{
@@ -8806,59 +9417,59 @@ const getKeyBindings = () => {
     command: 'FindWidget.focusNext',
     when: FocusFindWidget
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusToggleReplace',
     when: FocusFindWidget
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusReplace',
     when: FocusFindWidget
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusPreviousMatchButton',
     when: FocusFindWidgetReplace
   }, {
-    key: Alt | CtrlCmd | Enter,
+    key: Alt$1 | CtrlCmd | Enter,
     command: 'FindWidget.replaceAll',
     when: FocusFindWidgetReplace
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusNextMatchButton',
     when: FocusFindWidgetPreviousMatchButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusReplace',
     when: FocusFindWidgetPreviousMatchButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusPreviousMatchButton',
     when: FocusFindWidgetNextMatchButton
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusCloseButton',
     when: FocusFindWidgetNextMatchButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusNextMatchButton',
     when: FocusFindWidgetCloseButton
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusReplaceButton',
     when: FocusFindWidgetCloseButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusFind',
     when: FocusFindWidgetReplace
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'FindWidget.focusReplaceAllButton',
     when: FocusFindWidgetReplaceButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusCloseButton',
     when: FocusFindWidgetReplaceButton
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'FindWidget.focusReplaceButton',
     when: FocusFindWidgetReplaceAllButton
   }, {
@@ -8886,7 +9497,7 @@ const getKeyBindings = () => {
     command: 'EditorCompletion.focusFirst',
     when: FocusEditorCompletions
   }, {
-    key: CtrlCmd | Space,
+    key: CtrlCmd | Space$1,
     command: 'EditorCompletion.toggleDetails',
     when: FocusEditorCompletions
   }, {
@@ -8898,11 +9509,11 @@ const getKeyBindings = () => {
     command: 'Editor.cursorWordLeft',
     when: FocusEditorText
   }, {
-    key: Alt | Backspace,
+    key: Alt$1 | Backspace,
     command: 'Editor.deleteWordPartLeft',
     when: FocusEditorText
   }, {
-    key: Alt | Delete,
+    key: Alt$1 | Delete,
     command: 'Editor.deleteWordPartRight',
     when: FocusEditorText
   }, {
@@ -8926,11 +9537,11 @@ const getKeyBindings = () => {
     command: 'Editor.showSourceActions3',
     when: FocusEditorText
   }, {
-    key: Tab,
+    key: Tab$1,
     command: 'Editor.handleTab',
     when: FocusEditorText
   }, {
-    key: Shift | Tab,
+    key: Shift | Tab$1,
     command: 'Editor.unindent',
     when: FocusEditorText
   }, {
@@ -9038,7 +9649,7 @@ const getKeyBindings = () => {
     command: 'Editor.moveLineUp',
     when: FocusEditorText
   }, {
-    key: CtrlCmd | Space,
+    key: CtrlCmd | Space$1,
     command: 'Editor.openCompletion',
     when: FocusEditorText
   }, {
@@ -9062,7 +9673,7 @@ const getKeyBindings = () => {
     command: 'Editor.cursorEnd',
     when: FocusEditorText
   }, {
-    key: CtrlCmd | Slash,
+    key: CtrlCmd | Slash$1,
     command: 'Editor.toggleComment',
     when: FocusEditorText
   }, {
@@ -9086,35 +9697,35 @@ const getKeyBindings = () => {
     command: 'Editor.paste',
     when: FocusEditorText
   }, {
-    key: Alt | LeftArrow,
+    key: Alt$1 | LeftArrow,
     command: 'Editor.cursorWordPartLeft',
     when: FocusEditorText
   }, {
-    key: Alt | RightArrow,
+    key: Alt$1 | RightArrow,
     command: 'Editor.cursorWordPartRight',
     when: FocusEditorText
   }, {
-    key: Alt | F3,
+    key: Alt$1 | F3,
     command: 'Editor.selectAllOccurrences',
     when: FocusEditorText
   }, {
-    key: Alt | Shift | UpArrow,
+    key: Alt$1 | Shift | UpArrow,
     command: 'Editor.addCursorAbove',
     when: FocusEditorText
   }, {
-    key: Alt | Shift | DownArrow,
+    key: Alt$1 | Shift | DownArrow,
     command: 'Editor.addCursorBelow',
     when: FocusEditorText
   }, {
-    key: Alt | Shift | F12,
+    key: Alt$1 | Shift | F12,
     command: 'Editor.findAllReferences',
     when: FocusEditorText
   }, {
-    key: Alt | Shift | KeyO,
+    key: Alt$1 | Shift | KeyO,
     command: 'Editor.organizeImports',
     when: FocusEditorText
   }, {
-    key: CtrlCmd | Shift | Space,
+    key: CtrlCmd | Shift | Space$1,
     command: 'Editor.selectionGrow',
     when: FocusEditor
   }];
@@ -9211,776 +9822,282 @@ const getQuickPickMenuEntries = () => {
   }, {
     id: 'Editor.showSourceActions2',
     label: sourceAction()
-  }];
-};
-
-const getSelections = editorUid => {
-  const editor = getEditor(editorUid);
-  const {
-    selections
-  } = editor;
-  return selections;
-};
-
-const getText = editorUid => {
-  number(editorUid);
-  const editor = getEditor(editorUid);
-  const {
-    lines
-  } = editor;
-  return lines.join(NewLine);
-};
-
-const InsertText = 'insertText';
-
-const handleBeforeInput = (editor, inputType, data) => {
-  switch (inputType) {
-    case InsertText:
-      return typeWithAutoClosing(editor, data);
-    default:
-      return editor;
-  }
-};
-
-const handleMessagePort = async (port, rpcId) => {
-  const rpc = await PlainMessagePortRpcParent.create({
-    messagePort: port,
-    commandMap: {}
-  });
-  if (rpcId) {
-    set$c(rpcId, rpc);
-  }
-};
-
-const applyTabCompletion = (editor, result) => {
-  return editorSnippet(editor, result);
-};
-
-const handleTab = async editor => {
-  const result = await getTabCompletion(editor);
-  if (!result) {
-    // TODO enter tab or two spaces
-    return editor;
-  }
-  return applyTabCompletion(editor, result);
-};
-
-const relaunchWorkers = async () => {
-  await dispose();
-  await launch();
-};
-
-const getWidgetName = widgetId => {
-  switch (widgetId) {
-    case Find:
-      return `FindWidget`;
-    default:
-      return '';
-  }
-};
-const saveWidgetState = async keys => {
-  const savedStates = Object.create(null);
-  for (const key of keys) {
-    const editor = get$4(parseInt(key));
-    const {
-      widgets
-    } = editor.newState;
-    for (const widget of widgets) {
-      const invoke = getWidgetInvoke(widget.id);
-      const fullKey = `${key}:${widget.newState.uid}`;
-      const name = getWidgetName(widget.id);
-      const savedState = await invoke(`${name}.saveState`, widget.newState.uid);
-      savedStates[fullKey] = savedState;
-    }
-  }
-  return savedStates;
-};
-
-const restoreWidgetState = async (keys, savedStates) => {
-  const newEditors = [];
-  for (const key of keys) {
-    const editorUid = parseInt(key);
-    const editor = get$4(editorUid);
-    const {
-      widgets
-    } = editor.newState;
-    const newWidgets = [];
-    for (const widget of widgets) {
-      const invoke = getWidgetInvoke(widget.id);
-      const fullKey = `${key}:${widget.newState.uid}`;
-      const savedState = savedStates[fullKey] || {};
-      const name = getWidgetName(widget.id);
-      await invoke(`${name}.create`, widget.newState.uid, widget.newState.x, widget.newState.y, widget.newState.width, widget.newState.height, editorUid);
-      await invoke(`${name}.loadContent`, widget.newState.uid, savedState);
-      const diffResult = await invoke(`${name}.diff2`, widget.newState.uid);
-      const commands = await invoke(`${name}.render2`, widget.newState.uid, diffResult);
-      const newWidget = {
-        ...widget,
-        newState: {
-          ...widget.newState,
-          commands
-        }
-      };
-      newWidgets.push(newWidget);
-    }
-    newEditors.push({
-      ...editor,
-      newState: {
-        ...editor.newState,
-        widgets: newWidgets
-      }
-    });
-  }
-  return newEditors;
-};
-
-let isReloading = false;
-const hotReload = async () => {
-  if (isReloading) {
-    return;
-  }
-  isReloading = true;
-
-  // TODO use getEditors
-  const keys = getKeys$1();
-  const savedStates = await saveWidgetState(keys);
-  await relaunchWorkers();
-  const newEditors = await restoreWidgetState(keys, savedStates);
-  for (const editor of newEditors) {
-    set$6(editor.newState.uid, editor.oldState, editor.newState);
-  }
-
-  // TODO ask renderer worker to rerender all editors
-  // @ts-ignore
-  await invoke$9(`Editor.rerender`);
-  isReloading = false;
-};
-
-const sendMessagePortToExtensionHostWorker2 = async (port, initialCommand, rpcId) => {
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, initialCommand, rpcId);
-};
-
-const createExtensionHostRpc = async () => {
-  try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    const initialCommand = 'HandleMessagePort.handleMessagePort2';
-    // TODO use transfer rpc
-    await sendMessagePortToExtensionHostWorker2(port2, initialCommand, EditorWorker);
-    const rpc = await PlainMessagePortRpcParent.create({
-      commandMap: {},
-      messagePort: port1
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
-const initializeExtensionHost = async () => {
-  const extensionHostRpc = await createExtensionHostRpc();
-  set$5(extensionHostRpc);
-};
-
-const sendMessagePortToSyntaxHighlightingWorker = async () => {
-  try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await invokeAndTransfer(
-    // @ts-ignore
-    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort2');
-    return port2;
-  } catch {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await invokeAndTransfer(
-    // @ts-ignore
-    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort');
-    return port2;
-  }
-};
-
-const createSyntaxHighlightingWorkerRpc = async () => {
-  try {
-    const port = await sendMessagePortToSyntaxHighlightingWorker();
-    const rpc = await PlainMessagePortRpcParent.create({
-      commandMap: {},
-      messagePort: port
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create syntax highlighting worker rpc`);
-  }
-};
-
-let enabled = false;
-const setEnabled = value => {
-  enabled = value;
-};
-const getEnabled = () => {
-  return enabled;
-};
-
-const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncremental) => {
-  if (syntaxHighlightingEnabled) {
-    setEnabled$1(true);
-    const syntaxRpc = await createSyntaxHighlightingWorkerRpc();
-    set$3(syntaxRpc);
-  }
-  if (syncIncremental) {
-    setEnabled(true);
-  }
-};
-
-const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost()]);
+  }];
 };
 
-// TODO move cursor
-// TODO multiple cursors -> vscode removes multiple cursors
-// TODO with selection -> vscode moves whole selection
-const moveLineDown = editor => {
-  // const rowIndex = editor.cursor.rowIndex
-  // if (rowIndex === editor.lines.length - 1) {
-  //   return
-  // }
-  // const documentEdits = [
-  //   {
-  //     type: /* splice */ 2,
-  //     rowIndex: rowIndex,
-  //     count: 2,
-  //     newLines: [TextDocument.getLine(editor.textDocument, rowIndex + 1), TextDocument.getLine(editor.textDocument, rowIndex)],
-  //   },
-  // ]
-  // // @ts-ignore
-  // const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
-  //   return {
-  //     rowIndex: cursor.rowIndex + 1,
-  //     columnIndex: cursor.columnIndex,
-  //   }
-  // })
-  // @ts-ignore
-  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
-  return editor;
+const getSelections = editorUid => {
+  const editor = getEditor(editorUid);
+  const {
+    selections
+  } = editor;
+  return selections;
 };
 
-// TODO handle multiple cursors
-const moveLineUp = editor => {
-  // const rowIndex = editor.cursor.rowIndex
-  // if (rowIndex === 0) {
-  //   return
-  // }
-  // const documentEdits = [
-  //   {
-  //     type: /* splice */ 2,
-  //     rowIndex: rowIndex - 1,
-  //     count: 2,
-  //     newLines: [TextDocument.getLine(editor.textDocument, rowIndex), TextDocument.getLine(editor.textDocument, rowIndex - 1)],
-  //   },
-  // ]
-  // // @ts-ignore
-  // const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
-  //   return {
-  //     // TODO handle bottom 0
-  //     rowIndex: cursor.rowIndex - 1,
-  //     columnIndex: cursor.columnIndex,
-  //   }
-  // })
-  // // @ts-ignore
-  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
-  return editor;
+const getText = editorUid => {
+  number(editorUid);
+  const editor = getEditor(editorUid);
+  const {
+    lines
+  } = editor;
+  return lines.join(NewLine);
 };
 
-const Link$1 = 'Link';
-const Function = 'Function';
-const Parameter = 'Parameter';
-const Type = 'Type';
-const VariableName = 'VariableName';
-const Class = 'Class';
-
-const Link = 1;
-const Ts2816 = 2816;
-const Ts2817 = 2817;
-const Ts2824 = 2824;
-const Ts2825 = 2825;
-const Ts2856 = 2956;
-const Ts2857 = 2857;
-const Ts3072 = 3072;
-const Ts3073 = 3073;
-const Ts3077 = 3077;
-const Ts3088 = 3088;
-const Ts1792 = 1792;
-const Ts1793 = 1793;
-const Ts512 = 512;
-const Ts513 = 513;
-const Ts769 = 769;
-const Ts1024 = 1024;
-const Ts1536 = 1536;
-const Ts1537 = 1537;
-const Ts1544 = 1544;
-const Ts1545 = 1545;
-const Ts2048 = 2048;
-const Ts2049 = 2049;
-const Ts2056 = 2056;
-const Ts2057 = 2057;
-const Ts2064 = 2064;
-const Ts2080 = 2080;
-const Ts2081 = 2081;
-const Ts2088 = 2088;
-const Ts2089 = 2089;
-const Ts2313 = 2313;
-const Ts2560 = 2560;
-const Ts2561 = 2561;
-const Ts2569 = 2569;
-const Ts2584 = 2584;
-const Ts256 = 256;
-const Ts257 = 257;
-const Ts272 = 272;
+const InsertText = 'insertText';
 
-const getDecorationClassName = type => {
-  switch (type) {
-    case Link:
-      return Link$1;
-    case Ts2816:
-    case Ts2817:
-    case Ts2824:
-    case Ts2825:
-    case Ts2856:
-    case Ts2857:
-    case Ts3072:
-    case Ts3073:
-    case Ts3077:
-    case Ts3088:
-      return Function;
-    case Ts1792:
-    case Ts1793:
-      return Parameter;
-    case Ts512:
-    case Ts513:
-    case Ts769:
-    case Ts1024:
-    case Ts1536:
-    case Ts1537:
-    case Ts1544:
-    case Ts1545:
-      return Type;
-    case Ts2048:
-    case Ts2049:
-    case Ts2056:
-    case Ts2057:
-    case Ts2064:
-    case Ts2080:
-    case Ts2081:
-    case Ts2088:
-    case Ts2089:
-    case Ts2313:
-    case Ts2560:
-    case Ts2561:
-    case Ts2569:
-    case Ts2584:
-      return VariableName;
-    case Ts256:
-    case Ts257:
-    case Ts272:
-      return Class;
+const handleBeforeInput = (editor, inputType, data) => {
+  switch (inputType) {
+    case InsertText:
+      return typeWithAutoClosing(editor, data);
     default:
-      return `Unknown-${type}`;
+      return editor;
   }
 };
 
-const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed) => {
-  const tokenizersToLoad = [];
-  const embeddedResults = [];
-  let topContext;
-  for (const index of linesWithEmbed) {
-    const result = lineCache[index + 1];
-    const line = lines[index];
-    if (result.embeddedLanguage) {
-      const {
-        embeddedLanguage,
-        embeddedLanguageStart,
-        embeddedLanguageEnd
-      } = result;
-      const embeddedTokenizer = getTokenizer(embeddedLanguage);
-      if (embeddedLanguageStart !== line.length && embeddedTokenizer && embeddedTokenizer !== TokenizePlainText) {
-        const isFull = embeddedLanguageStart === 0 && embeddedLanguageEnd === line.length;
-        const partialLine = line.slice(embeddedLanguageStart, embeddedLanguageEnd);
-        const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, topContext || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
-        topContext = embedResult;
-        result.embeddedResultIndex = embeddedResults.length;
-        embeddedResults.push({
-          result: embedResult,
-          TokenMap: embeddedTokenizer.TokenMap,
-          isFull
-        });
-      } else if (line.length === 0) {
-        const embedResult = {
-          tokens: []
-        };
-        result.embeddedResultIndex = embeddedResults.length;
-        embeddedResults.push({
-          result: embedResult,
-          isFull: true,
-          TokenMap: []
-        });
-      } else {
-        tokenizersToLoad.push(embeddedLanguage);
-        embeddedResults.push({
-          result: {},
-          isFull: false,
-          TokenMap: []
-        });
-        topContext = undefined;
-      }
-    } else {
-      topContext = undefined;
-    }
+const handleMessagePort = async (port, rpcId) => {
+  const rpc = await PlainMessagePortRpcParent.create({
+    messagePort: port,
+    commandMap: {}
+  });
+  if (rpcId) {
+    set$c(rpcId, rpc);
   }
-  return {
-    tokenizersToLoad,
-    embeddedResults
-  };
 };
-const getTokenizeEndIndex = (invalidStartIndex, endLineIndex, tokenizeStartIndex) => {
-  return invalidStartIndex < endLineIndex ? endLineIndex : tokenizeStartIndex;
+
+const applyTabCompletion = (editor, result) => {
+  return editorSnippet(editor, result);
 };
 
-// TODO only send changed lines to renderer process instead of all lines in viewport
-const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
-  const {
-    invalidStartIndex,
-    lineCache,
-    tokenizerId,
-    lines,
-    languageId
-  } = editor;
-  const tokenizer = get(tokenizerId);
-  const {
-    hasArrayReturn,
-    tokenizeLine,
-    initialLineState
-  } = tokenizer;
-  const tokenizeStartIndex = invalidStartIndex;
-  const tokenizeEndIndex = getTokenizeEndIndex(invalidStartIndex, endLineIndex, tokenizeStartIndex);
-  const tokenizersToLoad = [];
-  const embeddedResults = [];
-  const linesWithEmbed = [];
-  for (let i = tokenizeStartIndex; i < tokenizeEndIndex; i++) {
-    const lineState = i === 0 ? getInitialLineState(initialLineState) : lineCache[i];
-    const line = lines[i];
-    const result = safeTokenizeLine(languageId, tokenizeLine, line, lineState, hasArrayReturn);
-    // TODO if lineCacheEnd matches the one before, skip tokenizing lines after
-    lineCache[i + 1] = result;
-    if (result.embeddedLanguage) {
-      result.embeddedResultIndex = linesWithEmbed.length;
-      linesWithEmbed.push(i);
-    }
+const handleTab = async editor => {
+  const result = await getTabCompletion(editor);
+  if (!result) {
+    // TODO enter tab or two spaces
+    return editor;
   }
-  const visibleLines = lineCache.slice(startLineIndex + 1, endLineIndex + 1);
-  if (linesWithEmbed.length > 0) {
+  return applyTabCompletion(editor, result);
+};
+
+const relaunchWorkers = async () => {
+  await dispose();
+  await launch();
+};
+
+const getWidgetName = widgetId => {
+  switch (widgetId) {
+    case Find:
+      return `FindWidget`;
+    default:
+      return '';
+  }
+};
+const saveWidgetState = async keys => {
+  const savedStates = Object.create(null);
+  for (const key of keys) {
+    const editor = get$4(parseInt(key));
     const {
-      tokenizersToLoad,
-      embeddedResults
-    } = getTokensViewportEmbedded(languageId, lines, lineCache, linesWithEmbed);
-    // TODO support lineCache with embedded content
-    editor.invalidStartIndex = 0;
-    return {
-      tokens: visibleLines,
-      tokenizersToLoad,
-      embeddedResults
-    };
+      widgets
+    } = editor.newState;
+    for (const widget of widgets) {
+      const invoke = getWidgetInvoke(widget.id);
+      const fullKey = `${key}:${widget.newState.uid}`;
+      const name = getWidgetName(widget.id);
+      const savedState = await invoke(`${name}.saveState`, widget.newState.uid);
+      savedStates[fullKey] = savedState;
+    }
   }
-  editor.invalidStartIndex = Math.max(invalidStartIndex, tokenizeEndIndex);
-  return {
-    tokens: visibleLines,
-    tokenizersToLoad,
-    embeddedResults
-  };
+  return savedStates;
 };
 
-const sentLines = Object.create(null);
-
-// TODO only send changed lines to renderer process instead of all lines in viewport
-const getTokensViewport2 = async (editor, startLineIndex, endLineIndex, syncIncremental) => {
-  if (getEnabled$1()) {
-    if (syncIncremental) {
-      const {
-        invalidStartIndex,
-        lines,
-        languageId,
-        id
-      } = editor;
-      let hasLinesToSend = true;
-      let linesToSend = lines;
-      if (sentLines[id] === lines) {
-        hasLinesToSend = false;
-        linesToSend = [];
-      } else {
-        sentLines[id] = lines;
-      }
-      const slimEditor = {
-        languageId,
-        invalidStartIndex
+const restoreWidgetState = async (keys, savedStates) => {
+  const newEditors = [];
+  for (const key of keys) {
+    const editorUid = parseInt(key);
+    const editor = get$4(editorUid);
+    const {
+      widgets
+    } = editor.newState;
+    const newWidgets = [];
+    for (const widget of widgets) {
+      const invoke = getWidgetInvoke(widget.id);
+      const fullKey = `${key}:${widget.newState.uid}`;
+      const savedState = savedStates[fullKey] || {};
+      const name = getWidgetName(widget.id);
+      await invoke(`${name}.create`, widget.newState.uid, widget.newState.x, widget.newState.y, widget.newState.width, widget.newState.height, editorUid);
+      await invoke(`${name}.loadContent`, widget.newState.uid, savedState);
+      const diffResult = await invoke(`${name}.diff2`, widget.newState.uid);
+      const commands = await invoke(`${name}.render2`, widget.newState.uid, diffResult);
+      const newWidget = {
+        ...widget,
+        newState: {
+          ...widget.newState,
+          commands
+        }
       };
-      return invoke$3('GetTokensViewport.getTokensViewport', slimEditor,
-      // @ts-ignore
-      startLineIndex, endLineIndex, hasLinesToSend, id, linesToSend);
+      newWidgets.push(newWidget);
     }
-    // TODO only send needed lines of text
-    // @ts-ignore
-    return invoke$3('GetTokensViewport.getTokensViewport', editor, startLineIndex, endLineIndex, true, editor.id, editor.lines);
+    newEditors.push({
+      ...editor,
+      newState: {
+        ...editor.newState,
+        widgets: newWidgets
+      }
+    });
   }
-  return getTokensViewport(editor, startLineIndex, endLineIndex);
+  return newEditors;
 };
 
-const loadTokenizers = async languageIds => {
-  for (const languageId of languageIds) {
-    // @ts-ignore
-    await loadTokenizer(languageId);
+let isReloading = false;
+const hotReload = async () => {
+  if (isReloading) {
+    return;
   }
-};
+  isReloading = true;
 
-// const getTokensIncremental = (editor, min, max) => {
-//   const currentLength = editor.lineStateCache.length
-//   const tokens = []
-//   const lines = editor.lines
-//   let lineState = editor.tokenizer.initialLineState
-//   for (let i = currentLength; i < max; i++) {
-//     const line = lines[i]
-//     try {
-//       lineState = editor.tokenizer.tokenizeLine(line, lineState)
-//       if (!lineState || !lineState.tokens || !lineState.state) {
-//         throw new Error('invalid tokenization result')
-//       }
-//     } catch (error) {
-//       tokens.push([{ length: line.length, type: 0 }])
-//       console.error(error)
-//       // renderWithoutSyntaxHighlighting(state, firstRow, lastRow)
-//       continue
-//     }
-//     const newTokens = lineState.tokens
-//     tokens.push(newTokens)
-//   }
-//   return tokens
-// }
+  // TODO use getEditors
+  const keys = getKeys$1();
+  const savedStates = await saveWidgetState(keys);
+  await relaunchWorkers();
+  const newEditors = await restoreWidgetState(keys, savedStates);
+  for (const editor of newEditors) {
+    set$6(editor.newState.uid, editor.oldState, editor.newState);
+  }
 
-// const getLineInfosIncremental = (editor, tokens, minLineY, maxLineY) => {
-//   const result = []
-//   const lines = editor.lines
-//   const TokenMap = editor.tokenizer.TokenMap
-//   for (let i = minLineY; i < maxLineY; i++) {
-//     result.push(getLineInfo(lines[i], tokens[i], TokenMap))
-//   }
-//   return result
-// }
+  // TODO ask renderer worker to rerender all editors
+  // @ts-ignore
+  await invoke$9(`Editor.rerender`);
+  isReloading = false;
+};
 
-const getStartDefaults = (tokens, minOffset) => {
-  let start = 0;
-  let end = 0;
-  let startIndex = 0;
-  const tokensLength = tokens.length;
-  for (let i = 0; i < tokensLength; i += 2) {
-    const tokenLength = tokens[i + 1];
-    end += tokenLength;
-    start = end;
-    if (start >= minOffset) {
-      start -= tokenLength;
-      end -= tokenLength;
-      startIndex = i;
-      break;
-    }
+const sendMessagePortToExtensionHostWorker2 = async (port, initialCommand, rpcId) => {
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, initialCommand, rpcId);
+};
+
+const createExtensionHostRpc = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    const initialCommand = 'HandleMessagePort.handleMessagePort2';
+    // TODO use transfer rpc
+    await sendMessagePortToExtensionHostWorker2(port2, initialCommand, EditorWorker);
+    const rpc = await PlainMessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port1
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
   }
-  return {
-    start,
-    end,
-    startIndex
-  };
 };
-const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
-  const lineInfo = [];
-  const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
-  const embeddedTokens = embeddedResult.result.tokens;
-  const embeddedTokenMap = embeddedResult.TokenMap;
-  const tokensLength = embeddedTokens.length;
-  let {
-    startIndex,
-    start,
-    end
-  } = getStartDefaults(embeddedTokens, minOffset);
-  const difference = getDifference(start, averageCharWidth, deltaX);
-  for (let i = startIndex; i < tokensLength; i += 2) {
-    const tokenType = embeddedTokens[i];
-    const tokenLength = embeddedTokens[i + 1];
-    end += tokenLength;
-    const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
-    const text = line.slice(start, end);
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
-    if (end >= maxOffset) {
-      break;
-    }
+
+const initializeExtensionHost = async () => {
+  const extensionHostRpc = await createExtensionHostRpc();
+  set$1(extensionHostRpc);
+};
+
+const sendMessagePortToSyntaxHighlightingWorker = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await invokeAndTransfer(
+    // @ts-ignore
+    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort2');
+    return port2;
+  } catch {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await invokeAndTransfer(
+    // @ts-ignore
+    'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port1, 'HandleMessagePort.handleMessagePort');
+    return port2;
   }
-  return {
-    lineInfo,
-    difference
-  };
 };
-const getOffsets = (deltaX, width, averageCharWidth) => {
-  // TODO accurately measure char widths using offscreen canvas
-  // and use fast measurements for monospace ascii text
-  if (deltaX === 0) {
-    return {
-      minOffset: 0,
-      maxOffset: Math.ceil(width / averageCharWidth)
-    };
+
+const createSyntaxHighlightingWorkerRpc = async () => {
+  try {
+    const port = await sendMessagePortToSyntaxHighlightingWorker();
+    const rpc = await PlainMessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create syntax highlighting worker rpc`);
   }
-  const minOffset = Math.ceil(deltaX / averageCharWidth);
-  const maxOffset = minOffset + Math.ceil(width / averageCharWidth);
-  return {
-    minOffset,
-    maxOffset
-  };
-};
-const getDifference = (start, averageCharWidth, deltaX) => {
-  const beforeWidth = start * averageCharWidth;
-  const difference = beforeWidth - deltaX;
-  return difference;
 };
-const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
-  const lineInfo = [];
-  let decorationIndex = 0;
-  for (; decorationIndex < decorations.length; decorationIndex += 3) {
-    const decorationOffset = decorations[decorationIndex];
-    if (decorationOffset >= lineOffset) {
-      break;
-    }
-  }
-  const {
-    tokens
-  } = tokenResults;
-  let {
-    startIndex,
-    start,
-    end
-  } = getStartDefaults(tokens, minOffset);
-  const difference = getDifference(start, averageCharWidth, deltaX);
-  const tokensLength = tokens.length;
-  for (let i = startIndex; i < tokensLength; i += 2) {
-    const tokenType = tokens[i];
-    const tokenLength = tokens[i + 1];
-    const decorationOffset = decorations[decorationIndex];
-    let extraClassName = '';
-    if (decorationOffset !== undefined && decorationOffset - lineOffset === start) {
-      // @ts-ignore
-      decorations[++decorationIndex];
-      const decorationType = decorations[++decorationIndex];
-      // @ts-ignore
-      decorations[++decorationIndex];
-      //   decorationIndex,
-      //   decorationLength,
-      //   decorationType,
-      //   decorationModifiers,
-      // })
-      extraClassName = getDecorationClassName(decorationType);
-    }
-    end += tokenLength;
-    const text = line.slice(start, end);
-    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`;
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
-    if (end >= maxOffset) {
-      break;
-    }
+
+const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncremental) => {
+  if (syntaxHighlightingEnabled) {
+    setEnabled$1(true);
+    const syntaxRpc = await createSyntaxHighlightingWorkerRpc();
+    set$5(syntaxRpc);
   }
-  return {
-    lineInfo,
-    difference
-  };
-};
-const getLineInfo = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth) => {
-  const {
-    minOffset,
-    maxOffset
-  } = getOffsets(deltaX, width, averageCharWidth);
-  if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
-    const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
-    if (embeddedResult?.isFull) {
-      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
-    }
+  if (syncIncremental) {
+    setEnabled(true);
   }
-  return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
 };
 
-// TODO need lots of tests for this
-const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth) => {
-  const result = [];
-  const differences = [];
-  const {
-    lines,
-    decorations,
-    languageId
-  } = editor;
-  const tokenMap = get$1(languageId);
-  let offset = minLineOffset;
-  const tabSize = 2;
-  for (let i = minLineY; i < maxLineY; i++) {
-    const line = lines[i];
-    const normalize = shouldNormalizeText(line);
-    const {
-      lineInfo,
-      difference
-    } = getLineInfo(line, tokens[i - minLineY], embeddedResults, decorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
-    result.push(lineInfo);
-    differences.push(difference);
-    offset += line.length + 1;
-  }
-  return {
-    result,
-    differences
-  };
+const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
+  await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost()]);
 };
-const getVisible = async (editor, syncIncremental) => {
-  // TODO should separate rendering from business logic somehow
-  // currently hard to test because need to mock editor height, top, left,
-  // invalidStartIndex, lineCache, etc. just for testing editorType
-  // editor.invalidStartIndex = changes[0].start.rowIndex
-  // @ts-ignore
-  const {
-    minLineY,
-    numberOfVisibleLines,
-    lines,
-    width,
-    deltaX,
-    charWidth
-  } = editor;
-  const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
+
+// TODO move cursor
+// TODO multiple cursors -> vscode removes multiple cursors
+// TODO with selection -> vscode moves whole selection
+const moveLineDown = editor => {
+  // const rowIndex = editor.cursor.rowIndex
+  // if (rowIndex === editor.lines.length - 1) {
+  //   return
+  // }
+  // const documentEdits = [
+  //   {
+  //     type: /* splice */ 2,
+  //     rowIndex: rowIndex,
+  //     count: 2,
+  //     newLines: [TextDocument.getLine(editor.textDocument, rowIndex + 1), TextDocument.getLine(editor.textDocument, rowIndex)],
+  //   },
+  // ]
+  // // @ts-ignore
+  // const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
+  //   return {
+  //     rowIndex: cursor.rowIndex + 1,
+  //     columnIndex: cursor.columnIndex,
+  //   }
+  // })
   // @ts-ignore
-  const {
-    tokens,
-    tokenizersToLoad,
-    embeddedResults
-  } = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
-  const minLineOffset = offsetAtSync(editor, minLineY, 0);
-  const averageCharWidth = charWidth;
-  const {
-    result,
-    differences
-  } = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth);
-  if (tokenizersToLoad.length > 0) {
-    loadTokenizers(tokenizersToLoad);
-  }
-  return {
-    textInfos: result,
-    differences
-  };
+  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
+  return editor;
+};
+
+// TODO handle multiple cursors
+const moveLineUp = editor => {
+  // const rowIndex = editor.cursor.rowIndex
+  // if (rowIndex === 0) {
+  //   return
+  // }
+  // const documentEdits = [
+  //   {
+  //     type: /* splice */ 2,
+  //     rowIndex: rowIndex - 1,
+  //     count: 2,
+  //     newLines: [TextDocument.getLine(editor.textDocument, rowIndex), TextDocument.getLine(editor.textDocument, rowIndex - 1)],
+  //   },
+  // ]
+  // // @ts-ignore
+  // const cursorEdits = Editor.moveCursors(editor, (editor, cursor) => {
+  //   return {
+  //     // TODO handle bottom 0
+  //     rowIndex: cursor.rowIndex - 1,
+  //     columnIndex: cursor.columnIndex,
+  //   }
+  // })
+  // // @ts-ignore
+  // Editor.scheduleDocumentAndCursors(editor, documentEdits, cursorEdits)
+  return editor;
 };
 
 const getCursorsVirtualDom = cursors => {
@@ -10079,36 +10196,6 @@ const getEditorRowsVirtualDom = (textInfos, differences, lineNumbers = true, hig
   return dom;
 };
 
-const getIncrementalEdits = async (oldState, newState) => {
-  if (!newState.undoStack) {
-    return undefined;
-  }
-  const lastChanges = newState.undoStack.at(-1);
-  if (lastChanges && lastChanges.length === 1) {
-    const lastChange = lastChanges[0];
-    if (lastChange.origin === EditorType) {
-      const {
-        rowIndex
-      } = lastChange.start;
-      const {
-        lines
-      } = newState;
-      const oldLine = oldState.lines[rowIndex];
-      const newLine = lines[rowIndex];
-      // @ts-ignore
-      const incrementalEdits = await invoke$3(
-      // @ts-ignore
-      'TokenizeIncremental.tokenizeIncremental', newState.uid,
-      // @ts-ignore
-      newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
-      if (incrementalEdits && incrementalEdits.length === 1) {
-        return incrementalEdits;
-      }
-    }
-  }
-  return undefined;
-};
-
 const getSelectionsVirtualDom = selections => {
   const dom = [];
   for (let i = 0; i < selections.length; i += 4) {
@@ -10154,16 +10241,17 @@ const renderLines = {
   isEqual(oldState, newState) {
     return oldState.lines === newState.lines && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width && oldState.highlightedLine === newState.highlightedLine && oldState.debugEnabled === newState.debugEnabled;
   },
-  async apply(oldState, newState) {
-    const incrementalEdits = await getIncrementalEdits(oldState, newState);
-    if (incrementalEdits) {
+  apply(oldState, newState) {
+    const {
+      incrementalEdits
+    } = newState;
+    if (incrementalEdits !== emptyIncrementalEdits) {
       return [/* method */'setIncrementalEdits', /* incrementalEdits */incrementalEdits];
     }
-    const syncIncremental = getEnabled();
     const {
       textInfos,
       differences
-    } = await getVisible(newState, syncIncremental);
+    } = newState;
     newState.differences = differences;
     const {
       highlightedLine,
@@ -10182,7 +10270,7 @@ const renderSelections = {
     const {
       cursorInfos,
       selectionInfos
-    } = getVisible$1(newState);
+    } = getVisible(newState);
     const cursorsDom = getCursorsVirtualDom(cursorInfos);
     const selectionsDom = getSelectionsVirtualDom(selectionInfos);
     return [/* method */'setSelections', cursorsDom, selectionsDom];
@@ -10308,7 +10396,7 @@ const renderWidgets = {
   multiple: true
 };
 const render$6 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets];
-const renderEditor = async id => {
+const renderEditor = id => {
   const instance = get$4(id);
   if (!instance) {
     return [];
@@ -10321,7 +10409,7 @@ const renderEditor = async id => {
   set$6(id, newState, newState);
   for (const item of render$6) {
     if (!item.isEqual(oldState, newState)) {
-      const result = await item.apply(oldState, newState);
+      const result = item.apply(oldState, newState);
       // @ts-ignore
       if (item.multiple) {
         commands.push(...result);
@@ -10453,16 +10541,24 @@ const effects = [editorDiagnosticEffect];
 const wrapCommand = fn => async (editorUid, ...args) => {
   const oldInstance = get$4(editorUid);
   const newEditor = await fn(oldInstance.newState, ...args);
+  if (oldInstance.newState === newEditor) {
+    return newEditor;
+  }
   for (const effect of effects) {
     if (effect.isActive(oldInstance.newState, newEditor)) {
       effect.apply(newEditor);
     }
   }
+  // TODO if editor did not change, no need to update furthur
+
+  // TODO combine neweditor with latest editor?
+
   set$6(editorUid, oldInstance.newState, newEditor);
-  // TODO if possible, rendering should be sync
-  const commands = await renderEditor(editorUid);
-  newEditor.commands = commands;
-  return newEditor;
+  const commands = renderEditor(editorUid);
+  return {
+    ...newEditor,
+    commands
+  };
 };
 const wrapCommands = commands => {
   for (const [key, value] of Object.entries(commands)) {
@@ -10497,6 +10593,7 @@ const commandMap = {
   'Editor.compositionEnd': compositionEnd,
   'Editor.compositionStart': compositionStart,
   'Editor.compositionUpdate': compositionUpdate,
+  'Editor.handleClickAtPosition': handleClickAtPosition,
   'Editor.applyDocumentEdits': applyDocumentEdits,
   'Editor.contextMenu': handleContextMenu,
   'Editor.copy': copy,