@lvce-editor/editor-worker 2.1.0 → 2.2.0

package/dist/editorWorkerMain.js

@@ -57,7 +57,6 @@ const boolean = value => {
   }
 };
 
-// @ts-ignore
 const clamp = (num, min, max) => {
   number$1(num);
   number$1(min);
@@ -212,10 +211,10 @@ const renderColorPickerDom = {
     return ['Viewlet.setDom2', dom];
   }
 };
-const render$3 = [renderColorPickerDom, renderColor, renderOffsetX];
+const render$4 = [renderColorPickerDom, renderColor, renderOffsetX];
 const renderColorPicker = async (oldState, newState) => {
   const commands = [];
-  for (const item of render$3) {
+  for (const item of render$4) {
     if (!item.isEqual(oldState, newState)) {
       commands.push(item.apply(oldState, newState));
     }
@@ -226,7 +225,7 @@ const renderColorPicker = async (oldState, newState) => {
 // TODO use numeric enum
 const CompositionUpdate = 'compositionUpdate';
 const ContentEditableInput = 'contentEditableInput';
-const Delete = 'delete';
+const DeleteLeft = 'deleteLeft';
 const DeleteHorizontalRight = 'deleteHorizontalRight';
 const EditorCut = 'editorCut';
 const EditorPasteText = 'editorPasteText';
@@ -239,365 +238,1291 @@ const IndentMore = 'indentMore';
 const InsertLineBreak = 'insertLineBreak';
 const ToggleBlockComment = 'toggleBlockComment';
 
-const splitLines$2 = lines => {
-  if (!lines) {
-    return [];
-  }
-  return lines.split('\n');
+const Dash = '-';
+const Dot = '.';
+const EmptyString = '';
+const Space = ' ';
+const Tab = '\t';
+const Underline = '_';
+const T = 't';
+
+// @ts-ignore
+const getFontString = (fontWeight, fontSize, fontFamily) => {
+  return `${fontWeight} ${fontSize}px ${fontFamily}`;
+};
+
+const getLetterSpacingString = letterSpacing => {
+  return `${letterSpacing}px`;
+};
+
+const state$b = {
+  ctx: undefined
 };
 
 /**
- *
- * @param {number} size
- * @param {number} contentSize
- * @param {number} minimumSliderSize
- * @returns
+ * @param {()=>OffscreenCanvasRenderingContext2D} createCtx
+ * @returns {OffscreenCanvasRenderingContext2D}
  */
-const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
-  if (size >= contentSize) {
-    return 0;
+const getOrCreate = createCtx => {
+  if (state$b.ctx) {
+    return state$b.ctx;
   }
-  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
-};
-const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  return scrollBarOffset;
+  state$b.ctx = createCtx();
+  return state$b.ctx;
 };
-const getScrollBarY = getScrollBarOffset;
-const getScrollBarWidth = (width, longestLineWidth) => {
-  if (width > longestLineWidth) {
-    return 0;
+
+const createCtx = () => {
+  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 width ** 2 / longestLineWidth;
+  return ctx;
 };
-const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
-  const halfScrollBarHeight = scrollBarHeight / 2;
-  if (relativeY <= halfScrollBarHeight) {
-    // clicked at top
-    return {
-      percent: 0,
-      handleOffset: relativeY
-    };
-  }
-  if (relativeY <= height - halfScrollBarHeight) {
-    // clicked in middle
-    return {
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
-      handleOffset: halfScrollBarHeight
-    };
-  }
-  // clicked at bottom
-  return {
-    percent: 1,
-    handleOffset: scrollBarHeight - height + relativeY
-  };
+const getContext = () => {
+  const ctx = getOrCreate(createCtx);
+  return ctx;
 };
 
-// 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];
+const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
+  string(text);
+  number$1(fontWeight);
+  number$1(fontSize);
+  string(fontFamily);
+  boolean(isMonoSpaceFont);
+  number$1(charWidth);
+  if (isMonoSpaceFont) {
+    return text.length * charWidth;
   }
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i];
+  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();
+  // @ts-ignore
+  ctx.letterSpacing = letterSpacingString;
+  // @ts-ignore
+  ctx.font = fontString;
+  // @ts-ignore
+  const metrics = ctx.measureText(text);
+  const width = metrics.width;
+  return width;
 };
 
-/**
- * Alternative to the native Array.splice method, it
- * can only support limited number of items due to the maximum call stack size limit.
- */
+const getAccurateColumnIndexAscii = (
 // @ts-ignore
-const spliceLargeArray = (array, start, deleteCount, newItems) => {
-  const result = array.splice(start, deleteCount);
-  insertInto(array, start, newItems);
-  return result;
+line,
+// @ts-ignore
+guess,
+// @ts-ignore
+averageCharWidth,
+// @ts-ignore
+eventX,
+// @ts-ignore
+fontWeight,
+// @ts-ignore
+fontSize,
+// @ts-ignore
+fontFamily,
+// @ts-ignore
+letterSpacing,
+// @ts-ignore
+isMonospaceFont,
+// @ts-ignore
+charWidth) => {
+  for (let i = guess; i < line.length; i++) {
+    const width = measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    if (eventX - width < averageCharWidth / 2) {
+      return i;
+    }
+  }
+  return line.length;
 };
 
-const joinLines$2 = lines => {
-  return lines.join('\n');
+const supported = () => {
+  return 'Segmenter' in Intl;
 };
-
-// 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.inserted;
-    const deleted = change.deleted;
-    number$1(startRowIndex);
-    number$1(endRowIndex);
-    number$1(startColumnIndex);
-    number$1(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 create$5 = () => {
+  // @ts-ignore
+  const segmenter = new Intl.Segmenter();
+  return {
+    at(line, index) {
+      const segments = segmenter.segment(line);
+      return segments.containing(index);
+    },
+    visualIndex(line, index) {
+      const segments = segmenter.segment(line);
+      let currentVisualIndex = 0;
+      for (const segment of segments) {
+        if (segment.index >= index) {
+          return currentVisualIndex;
         }
-        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);
+        currentVisualIndex++;
       }
-    } 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]);
+      return currentVisualIndex;
+    },
+    modelIndex(line, visualIndex) {
+      const segments = segmenter.segment(line);
+      let currentVisualIndex = 0;
+      for (const segment of segments) {
+        if (currentVisualIndex >= visualIndex) {
+          return segment.index;
+        }
+        currentVisualIndex++;
       }
-      // TODO only do this once after all edits, not inside loop
-      textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, textDocument.lines.length);
+      return line.length;
+    },
+    getSegments(line) {
+      return segmenter.segment(line);
     }
-    linesDelta += Math.max(inserted.length - deleted.length, 0);
-  }
-  return newLines;
-};
-const getLine = (textDocument, index) => {
-  return textDocument.lines[index];
-};
-const getText$1 = state => {
-  return joinLines$2(state.lines);
+  };
 };
-const RE_WHITESPACE = /^\s+/;
 
-// TODO this doesn't belong here
-const getIndent = line => {
-  const whitespaceMatch = line.match(RE_WHITESPACE);
-  if (!whitespaceMatch) {
-    return '';
-  }
-  return whitespaceMatch[0];
-};
-
-// TDOO this doesn;t belong here
-const getSelectionText = (textDocument, range) => {
-  object(textDocument);
-  // console.log(range)
-  // console.log(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) {
-    // console.log(startRowIndex)
-    // console.log(textDocument.lines)
-    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 offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
-  object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
-  let offset = 0;
-  let rowIndex = 0;
-  const lines = textDocument.lines;
-  const max = Math.min(positionRowIndex, textDocument.lines.length);
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1;
-    rowIndex++;
-  }
-  offset += positionColumnIndex;
-  return offset;
-};
-const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
-  object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
-  let offset = 0;
-  let rowIndex = 0;
-  const lines = textDocument.lines;
-  const max = Math.min(positionRowIndex, textDocument.lines.length);
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1;
-    rowIndex++;
-  }
-  offset += positionColumnIndex;
-  return offset;
-};
-const positionAt = (textDocument, offset) => {
-  // console.log({ textDocument, offset })
-  let rowIndex = 0;
-  let columnIndex = 0;
-  let currentOffset = 0;
-  while (rowIndex < textDocument.lines.length && currentOffset < offset) {
-    currentOffset += textDocument.lines[rowIndex].length + 1;
-    rowIndex++;
-  }
-  if (currentOffset > offset) {
-    rowIndex--;
-    currentOffset -= textDocument.lines[rowIndex].length + 1;
-    columnIndex = offset - currentOffset;
-  } else {
-    columnIndex = currentOffset - offset;
+// @ts-ignore
+const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const segmenter = create$5();
+  const segments = segmenter.getSegments(line);
+  const isMonospaceFont = false;
+  const charWidth = 0;
+  for (const segment of segments) {
+    const width = measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    if (eventX - width < averageCharWidth) {
+      return segment.index;
+    }
   }
-  // for (let i = 0; i < textDocument.lines.length; i++) {
-  // if(currentOffset)
-  // }
-  // TODO
-  return {
-    rowIndex,
-    columnIndex
-  };
+  return line.length;
 };
 
-// TODO this should be in a separate scrolling module
-// @ts-ignore
-const setDeltaY$3 = (state, value) => {
-  object(state);
-  number$1(value);
-  const {
-    finalDeltaY,
-    deltaY,
-    numberOfVisibleLines,
-    height,
-    scrollBarHeight,
-    itemHeight
-  } = state;
-  const newDeltaY = clamp(value, 0, finalDeltaY);
-  if (deltaY === newDeltaY) {
-    return state;
-  }
-  const newMinLineY = Math.floor(newDeltaY / itemHeight);
-  const newMaxLineY = newMinLineY + numberOfVisibleLines;
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight);
-  return {
-    ...state,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    deltaY: newDeltaY,
-    scrollBarY
-  };
+const RE_ASCII = /^[\p{ASCII}]*$/u;
+const isAscii = line => {
+  return RE_ASCII.test(line);
 };
 
-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 normalizeText = (text, normalize, tabSize) => {
+  if (normalize) {
+    return text.replaceAll(Tab, Space.repeat(tabSize));
   }
-  return [first, second, third, fourth, 0];
+  return text;
 };
-
-const state$b = {
-  ctx: undefined
+const shouldNormalizeText = text => {
+  return text.includes(Tab);
 };
 
-/**
- * @param {()=>OffscreenCanvasRenderingContext2D} createCtx
- * @returns {OffscreenCanvasRenderingContext2D}
- */
-const getOrCreate = createCtx => {
-  if (state$b.ctx) {
-    return state$b.ctx;
-  }
-  state$b.ctx = createCtx();
-  return state$b.ctx;
+// @ts-ignore
+const guessOffset = (eventX, averageCharWidth) => {
+  const guess = Math.round(eventX / averageCharWidth);
+  return guess;
 };
 
-const createCtx = () => {
-  const canvas = new OffscreenCanvas(0, 0);
-  const ctx = /** @type {OffscreenCanvasRenderingContext2D} */canvas.getContext('2d');
-  if (!ctx) {
-    throw new Error('Failed to get canvas context 2d');
+// @ts-ignore
+const normalizeGuess = (line, guess, tabSize) => {
+  let normalizedGuess = guess;
+  for (let i = 0; i < guess; i++) {
+    if (line[i] === Tab) {
+      normalizedGuess -= tabSize - 1;
+    }
   }
-  return ctx;
-};
-const getContext = () => {
-  const ctx = getOrCreate(createCtx);
-  return ctx;
+  return normalizedGuess;
 };
 
 // @ts-ignore
-const getFontString = (fontWeight, fontSize, fontFamily) => {
-  return `${fontWeight} ${fontSize}px ${fontFamily}`;
-};
-
-const getLetterSpacingString = letterSpacing => {
-  return `${letterSpacing}px`;
-};
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  string(text);
+const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
+  string(line);
   number$1(fontWeight);
   number$1(fontSize);
   string(fontFamily);
-  boolean(isMonoSpaceFont);
+  number$1(letterSpacing);
+  boolean(isMonospaceFont);
   number$1(charWidth);
-  if (isMonoSpaceFont) {
-    return text.length * charWidth;
-  }
-  if (typeof letterSpacing !== 'number') {
-    throw new TypeError('letterSpacing must be of type number');
+  number$1(tabSize);
+  number$1(eventX);
+  // Assert.greaterZero(charWidth)
+  const guess = guessOffset(eventX, charWidth);
+  const normalize = shouldNormalizeText(line);
+  const normalizedGuess = normalizeGuess(line, guess, tabSize);
+  const text = line.slice(0, normalizedGuess);
+  const normalizedText = normalizeText(text, normalize, tabSize);
+  const actual = measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  const isAscii$1 = isAscii(line);
+  if (isAscii$1) {
+    if (Math.abs(eventX - actual) < charWidth / 2) {
+      return normalizedGuess;
+    }
+    return getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
   }
-  const letterSpacingString = getLetterSpacingString(letterSpacing);
-  const fontString = getFontString(fontWeight, fontSize, fontFamily);
-  const ctx = getContext();
-  // @ts-ignore
-  ctx.letterSpacing = letterSpacingString;
-  // @ts-ignore
-  ctx.font = fontString;
-  // @ts-ignore
-  const metrics = ctx.measureText(text);
-  const width = metrics.width;
-  return width;
+  return getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
 };
 
-const Dash = '-';
-const Dot = '.';
-const EmptyString = '';
-const Space = ' ';
-const Tab = '\t';
-const Underline = '_';
-const T = 't';
-
-const normalizeText = (text, normalize, tabSize) => {
-  if (normalize) {
-    return text.replaceAll(Tab, Space.repeat(tabSize));
+// @ts-ignore
+const at = (editor, eventX, eventY) => {
+  object(editor);
+  number$1(eventX);
+  number$1(eventY);
+  const {
+    y,
+    deltaY,
+    rowHeight,
+    fontSize,
+    fontWeight,
+    fontFamily,
+    letterSpacing,
+    lines,
+    tabSize,
+    differences,
+    isMonospaceFont,
+    charWidth
+  } = editor;
+  const rowIndex = Math.floor((eventY - y + deltaY) / rowHeight);
+  if (rowIndex < 0) {
+    return {
+      rowIndex: 0,
+      columnIndex: 0
+    };
   }
-  return text;
-};
-const shouldNormalizeText = text => {
-  return text.includes(Tab);
+  const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
+  const line = lines[clampedRowIndex];
+  const columnIndex = getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
+  return {
+    rowIndex: clampedRowIndex,
+    columnIndex
+  };
 };
 
-// TODO visible selections could also be uint16array
-// [top1, left1, width1, height1, top2, left2, width2, height2...]
+/**
+ * @deprecated this doesn't work for variable width characters (unicode/emoji).
+ * Use position computation in renderer process instead
+ *
+ * @param {object} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @returns
+ */
+// @ts-ignore
+const x = (editor, rowIndex, columnIndex) => {
+  const {
+    columnWidth,
+    x
+  } = editor;
+  const offsetX = columnIndex * columnWidth + x;
+  return offsetX;
+};
+
+// @ts-ignore
+const y = (editor, rowIndex) => {
+  const {
+    rowHeight,
+    y
+  } = editor;
+  const offsetY = (rowIndex + 1) * rowHeight + y;
+  return offsetY;
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  OrganizeImports: 'Organize Imports',
+  Copy: 'Copy',
+  CopyLineDown: 'Copy Line Down',
+  CopyLineUp: 'Copy Line Up',
+  Cut: 'Cut',
+  DuplicateSelection: 'Duplicate Selection',
+  FindAllImplementations: 'Find All Implementations',
+  FindAllReferences: 'Find All References',
+  GoToDefinition: 'Go to Definition',
+  GoToTypeDefinition: 'Go to Type Definition',
+  MoveLineDown: 'Move Line Down',
+  MoveLineUp: 'Move Line Up',
+  NoDefinitionFound: 'No definition found',
+  NoDefinitionFoundFor: "No definition found for '{PH1}'",
+  NoTypeDefinitionFound: 'No type definition found',
+  NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
+  Paste: 'Paste',
+  Redo: 'Redo',
+  SelectAll: 'Select All',
+  Separator: 'Separator',
+  ToggleBlockComment: 'Toggle Block Comment',
+  ToggleLineComment: 'Toggle Line Comment',
+  Undo: 'Undo',
+  FormatDocument: 'Format Document',
+  SourceActions: 'Source Actions',
+  EditorShowHover: 'Show Hover',
+  EditorFormatDocumentForced: 'Editor: Format Document (forced)',
+  EditorSelectNextOccurrence: 'Editor: Select Next Occurrence',
+  EditorSelectAllOccurrences: 'Editor: Select All Occurrences',
+  EditorGoToDefinition: 'Editor: Go To Definition',
+  EditorGoToTypeDefinition: 'Editor: Go To Type Definition',
+  EditorSelectInsideString: 'Editor: Select Inside String',
+  EditorIndent: 'Editor: Indent',
+  EditorUnindent: 'Editor: Unindent',
+  EditorSortLinesAscending: 'Editor: Sort Lines Ascending',
+  EditorToggleComment: 'Editor: Toggle Comment',
+  EditorSelectUp: 'Editor: Select Up',
+  EditorSelectDown: 'Editor: Select Down',
+  EditorToggleBlockComment: 'Editor: Toggle Block Comment',
+  EditorOpenColorPicker: 'Editor: Open Color Picker',
+  EditorCloseColorPicker: 'Editor: Close Color Picker',
+  EditorCopyLineDown: 'Editor: Copy Line Down',
+  EditorCopyLineUp: 'Editor: Copy Line Up',
+  Replace: 'replace',
+  NoResults: 'No Results'
+};
+const noDefinitionFound = () => {
+  return i18nString(UiStrings.NoDefinitionFound);
+};
+
+// @ts-ignore
+const noDefinitionFoundFor = word => {
+  return i18nString(UiStrings.NoDefinitionFoundFor, {
+    PH1: word
+  });
+};
+
+// @ts-ignore
+const noTypeDefinitionFoundFor = word => {
+  return i18nString(UiStrings.NoTypeDefinitionFoundFor, {
+    PH1: word
+  });
+};
+const noTypeDefinitionFound = () => {
+  return i18nString(UiStrings.NoTypeDefinitionFound);
+};
+const noResults = () => {
+  return i18nString(UiStrings.NoResults);
+};
+
+const None$1 = 'none';
+const Option = 'option';
+
+const getFileIconVirtualDom = icon => {
+  return {
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None$1,
+    childCount: 0
+  };
+};
+
+const getIconDom = (fileIcon, symbolName) => {
+  if (fileIcon) {
+    return getFileIconVirtualDom(fileIcon);
+  }
+  return {
+    type: Div,
+    className: `${ColoredMaskIcon} ${symbolName}`,
+    childCount: 0
+  };
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const label1 = {
+  type: Div,
+  className: Label,
+  childCount: 1
+};
+const completionHighlight = {
+  type: Span,
+  className: EditorCompletionItemHighlight,
+  childCount: 1
+};
+const getHighlightedLabelDom = (label, highlights) => {
+  if (highlights.length === 0) {
+    return [label1, text(label)];
+  }
+  const dom = [];
+  const labelDom = {
+    type: Div,
+    className: Label,
+    childCount: 0
+  };
+  dom.push(labelDom);
+  let position = 0;
+  for (let i = 0; i < highlights.length; i += 2) {
+    const highlightStart = highlights[i];
+    const highlightEnd = highlights[i + 1];
+    if (position < highlightStart) {
+      const beforeText = label.slice(position, highlightStart);
+      labelDom.childCount++;
+      dom.push(text(beforeText));
+    }
+    const highlightText = label.slice(highlightStart, highlightEnd);
+    labelDom.childCount++;
+    dom.push(completionHighlight, text(highlightText));
+    position = highlightEnd;
+  }
+  if (position < label.length) {
+    const afterText = label.slice(position);
+    labelDom.childCount++;
+    dom.push(text(afterText));
+  }
+  return dom;
+};
+
+const getCompletionItemVirtualDom = visibleItem => {
+  const {
+    top,
+    label,
+    symbolName,
+    highlights,
+    focused,
+    deprecated,
+    fileIcon
+  } = visibleItem;
+  let className = EditorCompletionItem;
+  if (focused) {
+    className += ' ' + EditorCompletionItemFocused;
+  }
+  if (deprecated) {
+    className += ' ' + EditorCompletionItemDeprecated;
+  }
+  return [{
+    type: Div,
+    role: Option,
+    className,
+    top,
+    childCount: 2
+  }, getIconDom(fileIcon, symbolName), ...getHighlightedLabelDom(label, highlights)];
+};
+
+const getCompletionItemsVirtualDom = visibleItems => {
+  if (visibleItems.length === 0) {
+    return [{
+      type: Div,
+      childCount: 1
+    }, text(noResults())];
+  }
+  const root = {
+    type: Div,
+    childCount: visibleItems.length
+  };
+  const dom = [root, ...visibleItems.flatMap(getCompletionItemVirtualDom)];
+  return dom;
+};
+
+const Deprecated = 1 << 0;
+
+const Property = 1;
+const Value = 2;
+const Function$1 = 3;
+const Variable = 4;
+const Keyword = 5;
+const Folder = 6;
+const File = 7;
+const Field = 8;
+
+const SymbolProperty = 'SymbolProperty';
+const SymbolValue = 'SymbolValue';
+const SymbolFunction = 'SymbolFunction';
+const SymbolVariable = 'SymbolVariable';
+const SymbolKeyword = 'SymbolKeyword';
+const SymbolDefault = 'SymbolDefault';
+const SymbolField = 'SymbolField';
+const SymbolNone = '';
+
+const getSymbolName = item => {
+  switch (item.kind) {
+    case Property:
+      return SymbolProperty;
+    case Value:
+      return SymbolValue;
+    case Function$1:
+      return SymbolFunction;
+    case Variable:
+      return SymbolVariable;
+    case Keyword:
+      return SymbolKeyword;
+    case Field:
+      return SymbolField;
+    case File:
+      return SymbolNone;
+    default:
+      return SymbolDefault;
+  }
+};
+
+const getHighlights = item => {
+  const {
+    matches
+  } = item;
+  return matches.slice(1);
+};
+
+// import * as IconTheme from '../IconTheme/IconTheme.ts'
+
+const getLabel = item => {
+  return item.label;
+};
+const getFileIcon = item => {
+  switch (item.kind) {
+    case File:
+      // TODO IconTheme.getFileNameIcon(item.label)
+      return '';
+    case Folder:
+      // TODO IconTheme.getFolderNameIcon(item.label)
+      return '';
+    default:
+      return '';
+  }
+};
+const getVisibleIem = (item, itemHeight, leadingWord, i, focusedIndex) => {
+  return {
+    label: getLabel(item),
+    symbolName: getSymbolName(item),
+    top: i * itemHeight,
+    highlights: getHighlights(item),
+    focused: i === focusedIndex,
+    deprecated: item.flags & Deprecated,
+    fileIcon: getFileIcon(item)
+  };
+};
+
+const getVisibleItems = (filteredItems, itemHeight, leadingWord, minLineY, maxLineY, focusedIndex) => {
+  const visibleItems = [];
+  for (let i = minLineY; i < maxLineY; i++) {
+    const filteredItem = filteredItems[i];
+    visibleItems.push(getVisibleIem(filteredItem, itemHeight, leadingWord, i, focusedIndex));
+  }
+  return visibleItems;
+};
+
+/**
+ *
+ * @param {number} size
+ * @param {number} contentSize
+ * @param {number} minimumSliderSize
+ * @returns
+ */
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
+  }
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+};
+const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  return scrollBarOffset;
+};
+const getScrollBarY = getScrollBarOffset;
+const getScrollBarWidth = (width, longestLineWidth) => {
+  if (width > longestLineWidth) {
+    return 0;
+  }
+  return width ** 2 / longestLineWidth;
+};
+const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
+  const halfScrollBarHeight = scrollBarHeight / 2;
+  if (relativeY <= halfScrollBarHeight) {
+    // clicked at top
+    return {
+      percent: 0,
+      handleOffset: relativeY
+    };
+  }
+  if (relativeY <= height - halfScrollBarHeight) {
+    // clicked in middle
+    return {
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
+      handleOffset: halfScrollBarHeight
+    };
+  }
+  // clicked at bottom
+  return {
+    percent: 1,
+    handleOffset: scrollBarHeight - height + relativeY
+  };
+};
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex;
+  },
+  apply(oldState, newState) {
+    const visibleItems = getVisibleItems(newState.items, newState.itemHeight, newState.leadingWord, newState.minLineY, newState.maxLineY, newState.focusedIndex);
+    const dom = getCompletionItemsVirtualDom(visibleItems);
+    return ['setDom', dom];
+  }
+};
+const renderBounds$1 = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.x === newState.x && oldState.y === newState.y;
+  },
+  apply(oldState, newState) {
+    const {
+      x,
+      y,
+      width,
+      height
+    } = newState;
+    return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
+  }
+};
+const renderHeight = {
+  isEqual(oldState, newState) {
+    return oldState.items.length === newState.items.length;
+  },
+  apply(oldState, newState) {
+    const {
+      itemHeight
+    } = newState;
+    const contentHeight = newState.items.length * itemHeight;
+    return [/* method */SetContentHeight, /* contentHeight */contentHeight];
+  }
+};
+const renderNegativeMargin = {
+  isEqual(oldState, newState) {
+    return oldState.deltaY === newState.deltaY;
+  },
+  apply(oldState, newState) {
+    return [/* method */SetNegativeMargin, /* negativeMargin */-newState.deltaY];
+  }
+};
+const renderScrollBar = {
+  isEqual(oldState, newState) {
+    return oldState.negativeMargin === newState.negativeMargin && oldState.deltaY === newState.deltaY && oldState.height === newState.height && oldState.finalDeltaY === newState.finalDeltaY && oldState.items.length === newState.items.length;
+  },
+  apply(oldState, newState) {
+    const total = newState.items.length;
+    const contentHeight = total * newState.itemHeight;
+    const scrollBarHeight = getScrollBarSize(newState.height, contentHeight, newState.minimumSliderSize);
+    const scrollBarY = getScrollBarY(newState.deltaY, newState.finalDeltaY, newState.height - newState.headerHeight, scrollBarHeight);
+    return [/* method */SetScrollBar, /* scrollBarY */scrollBarY, /* scrollBarHeight */scrollBarHeight];
+  }
+};
+const render$3 = [renderItems, renderBounds$1, renderHeight, renderNegativeMargin, renderScrollBar];
+const renderCompletion = (oldState, newState) => {
+  const commands = [];
+  for (const item of render$3) {
+    if (!item.isEqual(oldState, newState)) {
+      commands.push(item.apply(oldState, newState));
+    }
+  }
+  return commands;
+};
+
+const EmptyMatches = [];
+
+const Diagonal = 1;
+const Left = 2;
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const createTable = size => {
+  const table = [];
+  for (let i = 0; i < size; i++) {
+    const row = new Uint8Array(size);
+    table.push(row);
+  }
+  return table;
+};
+
+const isLowerCase = char => {
+  return char === char.toLowerCase();
+};
+
+const isUpperCase = char => {
+  return char === char.toUpperCase();
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const isGap = (columnCharBefore, columnChar) => {
+  switch (columnCharBefore) {
+    case Dash:
+    case Underline:
+    case EmptyString:
+    case T:
+    case Space:
+    case Dot:
+      return true;
+  }
+  if (isLowerCase(columnCharBefore) && isUpperCase(columnChar)) {
+    return true;
+  }
+  return false;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch) => {
+  if (rowCharLow !== columnCharLow) {
+    return -1;
+  }
+  const isMatch = rowChar === columnChar;
+  if (isMatch) {
+    if (isDiagonalMatch) {
+      return 8;
+    }
+    if (isGap(columnCharBefore, columnChar)) {
+      return 8;
+    }
+    return 5;
+  }
+  if (isGap(columnCharBefore, columnChar)) {
+    return 8;
+  }
+  return 5;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const isPatternInWord = (patternLow, patternPos, patternLen, wordLow, wordPos, wordLen) => {
+  while (patternPos < patternLen && wordPos < wordLen) {
+    if (patternLow[patternPos] === wordLow[wordPos]) {
+      patternPos += 1;
+    }
+    wordPos += 1;
+  }
+  return patternPos === patternLen; // pattern must be exhausted
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const traceHighlights = (table, arrows, patternLength, wordLength) => {
+  let row = patternLength;
+  let column = wordLength;
+  const matches = [];
+  while (row >= 1 && column >= 1) {
+    const arrow = arrows[row][column];
+    if (arrow === Left) {
+      column--;
+    } else if (arrow === Diagonal) {
+      row--;
+      column--;
+      const start = column + 1;
+      while (row >= 1 && column >= 1) {
+        const arrow = arrows[row][column];
+        if (arrow === Left) {
+          break;
+        }
+        if (arrow === Diagonal) {
+          row--;
+          column--;
+        }
+      }
+      const end = column;
+      matches.unshift(end, start);
+    }
+  }
+  matches.unshift(table[patternLength][wordLength - 1]);
+  return matches;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const gridSize = 128;
+const table = createTable(gridSize);
+const arrows = createTable(gridSize);
+// @ts-ignore
+createTable(gridSize);
+const filterCompletionItem = (pattern, word) => {
+  const patternLength = Math.min(pattern.length, gridSize - 1);
+  const wordLength = Math.min(word.length, gridSize - 1);
+  const patternLower = pattern.toLowerCase();
+  const wordLower = word.toLowerCase();
+  if (!isPatternInWord(patternLower, 0, patternLength, wordLower, 0, wordLength)) {
+    return EmptyMatches;
+  }
+  let strongMatch = false;
+  for (let row = 1; row < patternLength + 1; row++) {
+    const rowChar = pattern[row - 1];
+    const rowCharLow = patternLower[row - 1];
+    for (let column = 1; column < wordLength + 1; column++) {
+      const columnChar = word[column - 1];
+      const columnCharLow = wordLower[column - 1];
+      const columnCharBefore = word[column - 2] || '';
+      const isDiagonalMatch = arrows[row - 1][column - 1] === Diagonal;
+      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch);
+      if (row === 1 && score > 5) {
+        strongMatch = true;
+      }
+      let diagonalScore = score + table[row - 1][column - 1];
+      if (isDiagonalMatch && score !== -1) {
+        diagonalScore += 2;
+      }
+      const leftScore = table[row][column - 1];
+      if (leftScore > diagonalScore) {
+        table[row][column] = leftScore;
+        arrows[row][column] = Left;
+      } else {
+        table[row][column] = diagonalScore;
+        arrows[row][column] = Diagonal;
+      }
+    }
+  }
+  if (!strongMatch) {
+    return EmptyMatches;
+  }
+  // printTables(pattern, 0, word, 0)
+  const highlights = traceHighlights(table, arrows, patternLength, wordLength);
+  return highlights;
+};
+
+const addEmptyMatch = item => {
+  return {
+    ...item,
+    matches: EmptyMatches
+  };
+};
+const filterCompletionItems = (completionItems, word) => {
+  if (word === EmptyString) {
+    return completionItems.map(addEmptyMatch);
+  }
+  const filteredCompletions = [];
+  const deprecated = [];
+  for (const completionItem of completionItems) {
+    const {
+      label,
+      flags
+    } = completionItem;
+    const result = filterCompletionItem(word, label);
+    if (result !== EmptyMatches) {
+      if (flags & Deprecated) {
+        // TODO avoid mutation
+        completionItem.matches = EmptyMatches;
+        deprecated.push(completionItem);
+      } else {
+        // TODO avoid mutation
+        completionItem.matches = result;
+        filteredCompletions.push(completionItem);
+      }
+    }
+  }
+  if (deprecated.length > 0) {
+    filteredCompletions.push(...deprecated);
+  }
+  return filteredCompletions;
+};
+
+const getListHeight = (itemsLength, itemHeight, maxHeight) => {
+  number$1(itemsLength);
+  number$1(itemHeight);
+  number$1(maxHeight);
+  if (itemsLength === 0) {
+    return itemHeight;
+  }
+  const totalHeight = itemsLength * itemHeight;
+  return Math.min(totalHeight, maxHeight);
+};
+
+const RE_WORD_START$1 = /^\w+/;
+const RE_WORD_END$1 = /\w+$/;
+const getWordAt = (editor, rowIndex, columnIndex) => {
+  const {
+    lines
+  } = editor;
+  const line = lines[rowIndex];
+  const before = line.slice(0, columnIndex);
+  const matchBefore = before.match(RE_WORD_END$1);
+  const after = line.slice(columnIndex);
+  const matchAfter = after.match(RE_WORD_START$1);
+  let word = EmptyString;
+  if (matchBefore) {
+    word += matchBefore[0];
+  }
+  if (matchAfter) {
+    word += matchAfter[0];
+  }
+  return {
+    word
+  };
+};
+const getWordBefore = (editor, rowIndex, columnIndex) => {
+  const {
+    lines
+  } = editor;
+  const line = lines[rowIndex];
+  const before = line.slice(0, columnIndex);
+  const matchBefore = before.match(RE_WORD_END$1);
+  if (matchBefore) {
+    return matchBefore[0];
+  }
+  return EmptyString;
+};
+
+const render$2 = (oldState, newState) => {
+  const commands = renderCompletion(oldState, newState);
+  const wrappedCommands = [];
+  const uid = newState.uid;
+  for (const command of commands) {
+    wrappedCommands.push(['Viewlet.send', uid, ...command]);
+  }
+  return wrappedCommands;
+};
+const add = widget => {
+  const commands = render$2(widget.oldState, widget.newState);
+  const id = 'EditorCompletion';
+  // TODO how to generate a unique integer id
+  // that doesn't collide with ids created in renderer worker?
+  const uid = widget.newState.uid;
+  const allCommands = [];
+  allCommands.push(['Viewlet.create', id, uid]);
+  allCommands.push(...commands);
+  return allCommands;
+};
+const remove$1 = widget => {
+  return [['Viewlet.send', widget.newState.uid, 'dispose']];
+};
+const handleEditorType$1 = (editor, state) => {
+  const {
+    unfilteredItems,
+    itemHeight,
+    maxHeight
+  } = state;
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  const x$1 = x(editor, rowIndex, columnIndex);
+  const y$1 = y(editor, rowIndex);
+  const wordAtOffset = getWordBefore(editor, rowIndex, columnIndex);
+  const items = filterCompletionItems(unfilteredItems, wordAtOffset);
+  const newMinLineY = 0;
+  const newMaxLineY = Math.min(items.length, 8);
+  const height = getListHeight(items.length, itemHeight, maxHeight);
+  const finalDeltaY = items.length * itemHeight - height;
+  return {
+    ...state,
+    items,
+    x: x$1,
+    y: y$1,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    leadingWord: wordAtOffset,
+    height,
+    finalDeltaY
+  };
+};
+const handleEditorDeleteLeft$1 = (editor, state) => {
+  const {
+    unfilteredItems,
+    itemHeight,
+    maxHeight
+  } = state;
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  const x$1 = x(editor, rowIndex, columnIndex);
+  const y$1 = y(editor, rowIndex);
+  const wordAtOffset = getWordBefore(editor, rowIndex, columnIndex);
+  if (!wordAtOffset) {
+    return state;
+  }
+  const items = filterCompletionItems(unfilteredItems, wordAtOffset);
+  const newMaxLineY = Math.min(items.length, 8);
+  const height = getListHeight(items.length, itemHeight, maxHeight);
+  return {
+    ...state,
+    items,
+    x: x$1,
+    y: y$1,
+    maxLineY: newMaxLineY,
+    leadingWord: wordAtOffset,
+    height
+  };
+};
+
+const EditorCompletionWidget = {
+  __proto__: null,
+  add,
+  handleEditorDeleteLeft: handleEditorDeleteLeft$1,
+  handleEditorType: handleEditorType$1,
+  remove: remove$1,
+  render: render$2
+};
+
+const Completion = 'completion';
+
+const getModule$2 = id => {
+  switch (id) {
+    case Completion:
+      return EditorCompletionWidget;
+    default:
+      throw new Error('unsupported widget');
+  }
+};
+
+const applyWidgetChange = (editor, widget, changes) => {
+  const module = getModule$2(widget.id);
+  if (changes.length === 1 && changes[0].origin === EditorType && module.handleEditorType) {
+    const newState = module.handleEditorType(editor, widget.newState);
+    return {
+      ...widget,
+      newState
+    };
+  }
+  if (changes.length === 1 && changes[0].origin === DeleteLeft && module.handleEditorDeleteLeft) {
+    const newState = module.handleEditorDeleteLeft(editor, widget.newState);
+    return {
+      ...widget,
+      newState
+    };
+  }
+  return widget;
+};
+
+const applyWidgetChanges = (editor, changes) => {
+  const widgets = editor.widgets || [];
+  if (widgets.length === 0) {
+    return widgets;
+  }
+  const newWidgets = widgets.map(widget => {
+    const newWidget = applyWidgetChange(editor, widget, changes);
+    return newWidget;
+  });
+  return newWidgets;
+};
+
+const splitLines$2 = lines => {
+  if (!lines) {
+    return [];
+  }
+  return lines.split('\n');
+};
+
+// 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];
+  }
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
+  }
+};
+
+/**
+ * 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 joinLines$2 = lines => {
+  return lines.join('\n');
+};
+
+// 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.inserted;
+    const deleted = change.deleted;
+    number$1(startRowIndex);
+    number$1(endRowIndex);
+    number$1(startColumnIndex);
+    number$1(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 += Math.max(inserted.length - deleted.length, 0);
+  }
+  return newLines;
+};
+const getLine = (textDocument, index) => {
+  return textDocument.lines[index];
+};
+const getText$1 = state => {
+  return joinLines$2(state.lines);
+};
+const RE_WHITESPACE = /^\s+/;
+
+// TODO this doesn't belong here
+const getIndent = line => {
+  const whitespaceMatch = line.match(RE_WHITESPACE);
+  if (!whitespaceMatch) {
+    return '';
+  }
+  return whitespaceMatch[0];
+};
+
+// TDOO this doesn;t belong here
+const getSelectionText = (textDocument, range) => {
+  object(textDocument);
+  // console.log(range)
+  // console.log(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) {
+    // console.log(startRowIndex)
+    // console.log(textDocument.lines)
+    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 offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
+  object(textDocument);
+  number$1(positionRowIndex);
+  number$1(positionColumnIndex);
+  let offset = 0;
+  let rowIndex = 0;
+  const lines = textDocument.lines;
+  const max = Math.min(positionRowIndex, textDocument.lines.length);
+  while (rowIndex < max) {
+    offset += lines[rowIndex].length + 1;
+    rowIndex++;
+  }
+  offset += positionColumnIndex;
+  return offset;
+};
+const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
+  object(textDocument);
+  number$1(positionRowIndex);
+  number$1(positionColumnIndex);
+  let offset = 0;
+  let rowIndex = 0;
+  const lines = textDocument.lines;
+  const max = Math.min(positionRowIndex, textDocument.lines.length);
+  while (rowIndex < max) {
+    offset += lines[rowIndex].length + 1;
+    rowIndex++;
+  }
+  offset += positionColumnIndex;
+  return offset;
+};
+const positionAt = (textDocument, offset) => {
+  // console.log({ textDocument, offset })
+  let rowIndex = 0;
+  let columnIndex = 0;
+  let currentOffset = 0;
+  while (rowIndex < textDocument.lines.length && currentOffset < offset) {
+    currentOffset += textDocument.lines[rowIndex].length + 1;
+    rowIndex++;
+  }
+  if (currentOffset > offset) {
+    rowIndex--;
+    currentOffset -= textDocument.lines[rowIndex].length + 1;
+    columnIndex = offset - currentOffset;
+  } else {
+    columnIndex = currentOffset - offset;
+  }
+  // for (let i = 0; i < textDocument.lines.length; i++) {
+  // if(currentOffset)
+  // }
+  // TODO
+  return {
+    rowIndex,
+    columnIndex
+  };
+};
+
+// TODO this should be in a separate scrolling module
+// @ts-ignore
+const setDeltaY$3 = (state, value) => {
+  object(state);
+  number$1(value);
+  const {
+    finalDeltaY,
+    deltaY,
+    numberOfVisibleLines,
+    height,
+    scrollBarHeight,
+    itemHeight
+  } = state;
+  const newDeltaY = clamp(value, 0, finalDeltaY);
+  if (deltaY === newDeltaY) {
+    return state;
+  }
+  const newMinLineY = Math.floor(newDeltaY / itemHeight);
+  const newMaxLineY = newMinLineY + numberOfVisibleLines;
+  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight);
+  return {
+    ...state,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    deltaY: newDeltaY,
+    scrollBarY
+  };
+};
+
+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];
+};
+
+// TODO visible selections could also be uint16array
+// [top1, left1, width1, height1, top2, left2, width2, height2...]
 const getTabCount = string => {
   let count = 0;
   for (const element of string) {
@@ -882,22 +1807,15 @@ const applyEdit$1 = (editor, changes) => {
 };
 
 // TODO
-// @ts-ignore
 const setDeltaYFixedValue$1 = (editor, value) => {
   return setDeltaY$3(editor, value);
 };
-
-// @ts-ignore
 const setDeltaY$2 = (editor, value) => {
   return setDeltaYFixedValue$1(editor, editor.deltaY + value);
 };
-
-// @ts-ignore
 const isAutoClosingChange = change => {
   return change.origin === EditorTypeWithAutoClosing;
 };
-
-// @ts-ignore
 const applyAutoClosingRangesEdit = (editor, changes) => {
   const {
     autoClosingRanges = []
@@ -937,7 +1855,6 @@ const scheduleSelections = (editor, selectionEdits) => {
  * @param {Uint32Array|undefined} selectionChanges
  * @returns
  */
-// @ts-ignore
 const scheduleDocumentAndCursorsSelections = (editor, changes, selectionChanges = undefined) => {
   object(editor);
   array(changes);
@@ -967,7 +1884,12 @@ const scheduleDocumentAndCursorsSelections = (editor, changes, selectionChanges
     invalidStartIndex,
     autoClosingRanges
   };
-  return newEditor;
+  const newWidgets = applyWidgetChanges(newEditor, changes);
+  const newEditor2 = {
+    ...newEditor,
+    widgets: newWidgets
+  };
+  return newEditor2;
 };
 // @ts-ignore
 const scheduleDocumentAndCursorsSelectionIsUndo = (editor, changes) => {
@@ -1032,8 +1954,6 @@ const scheduleDocument = async (editor, changes) => {
   //   /* selectionInfos */ selectionInfos,
   // ])
 };
-
-// @ts-ignore
 const hasSelection = editor => {
   // TODO editor.selections should always be defined
   return editor.selections && editor.selections.length > 0;
@@ -1401,7 +2321,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(message, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$4 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -1410,7 +2330,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$4(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -1571,161 +2491,55 @@ const listen$8 = ipc => {
 const invoke$3 = async (method, ...params) => {
   return invoke$4(method, ...params);
 };
-const invokeAndTransfer = async (transfer, method, ...params) => {
-  return invokeAndTransfer$1(transfer, method, ...params);
-};
-
-const sendMessagePortToExtensionHostWorker = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, 'HandleMessagePort.handleMessagePort');
-};
-
-const withResolvers$1 = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-
-const waitForFirstMessage$1 = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers$1();
-  const cleanup = value => {
-    port.onmessage = null;
-    resolve(value);
-  };
-  const handleMessage = event => {
-    cleanup(event);
-  };
-  port.onmessage = handleMessage;
-  const event = await promise;
-  return event;
-};
-
-const create$4 = async () => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToExtensionHostWorker(port1);
-  const event = await waitForFirstMessage$1(port2);
-  if (event.data !== 'ready') {
-    throw new IpcError$1('unexpected first message');
-  }
-  return port2;
-};
-const wrap$3 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = getData(event);
-        // @ts-ignore
-        listener({
-          target: this,
-          data
-        });
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
-};
-
-const IpcParentWithExtensionHostWorker = {
-  __proto__: null,
-  create: create$4,
-  wrap: wrap$3
-};
-
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
-};
-
-const create$3 = async () => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToSyntaxHighlightingWorker(port1);
-  const event = await waitForFirstMessage$1(port2);
-  if (event.data !== 'ready') {
-    throw new IpcError$1('unexpected first message');
-  }
-  return port2;
-};
-const wrap$1 = port => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = getData(event);
-        // @ts-ignore
-        listener({
-          target: this,
-          data
-        });
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
+const invokeAndTransfer = async (transfer, method, ...params) => {
+  return invokeAndTransfer$1(transfer, method, ...params);
 };
 
-const IpcParentWithSyntaxHighlightingWorker = {
-  __proto__: null,
-  create: create$3,
-  wrap: wrap$1
+const sendMessagePortToExtensionHostWorker = async port => {
+  await invokeAndTransfer([port], 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
-const sendMessagePortToRendererProcess = async port => {
-  await invokeAndTransfer([port], 'SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
+const withResolvers$1 = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
 };
 
-const create$2 = async () => {
+const waitForFirstMessage$1 = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers$1();
+  const cleanup = value => {
+    port.onmessage = null;
+    resolve(value);
+  };
+  const handleMessage = event => {
+    cleanup(event);
+  };
+  port.onmessage = handleMessage;
+  const event = await promise;
+  return event;
+};
+
+const create$3 = async () => {
   const {
     port1,
     port2
   } = getPortTuple();
-  await sendMessagePortToRendererProcess(port1);
+  await sendMessagePortToExtensionHostWorker(port1);
   const event = await waitForFirstMessage$1(port2);
   if (event.data !== 'ready') {
     throw new IpcError$1('unexpected first message');
   }
   return port2;
 };
-const wrap = port => {
+const wrap$3 = port => {
   return {
     port,
     /**
@@ -1756,507 +2570,411 @@ const wrap = port => {
   };
 };
 
-const IpcParentWithRendererProcess = {
-  __proto__: null,
-  create: create$2,
-  wrap
-};
-
-const getModule$1 = method => {
-  switch (method) {
-    case RendererProcess:
-      return IpcParentWithRendererProcess;
-    case ExtensionHostWorker:
-      return IpcParentWithExtensionHostWorker;
-    case SyntaxHighlightingWorker:
-      return IpcParentWithSyntaxHighlightingWorker;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const create$1 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$1(method);
-  // @ts-ignore
-  const rawIpc = await module.create(options);
-  // @ts-ignore
-  if (options.raw) {
-    return rawIpc;
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const createRpc = method => {
-  let _ipc;
-  const listen = async () => {
-    const ipc = await create$1({
-      method
-    });
-    handleIpc(ipc);
-    _ipc = ipc;
-  };
-  const invoke = (method, ...params) => {
-    return invoke$5(_ipc, method, ...params);
-  };
-  return {
-    listen,
-    invoke
-  };
-};
-
-const {
-  listen: listen$7,
-  invoke: invoke$2
-} = createRpc(ExtensionHostWorker);
-
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
-const HoverExecute = 'ExtensionHostHover.execute';
-const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
-
-const measureCharacterWidth = (fontWeight, fontSize, fontFamily, letterSpacing) => {
-  return measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
-};
-
-const emptyEditor = {
-  uri: '',
-  languageId: '',
-  // TODO use numeric language id?
-  lines: [],
-  x: 0,
-  y: 0,
-  width: 0,
-  height: 0,
-  tokenizerId: 0,
-  minLineY: 0,
-  decorations: [],
-  embeds: [],
-  deltaX: 0,
-  focused: false,
-  deltaY: 0,
-  scrollBarHeight: 0,
-  longestLineWidth: 0,
-  maxLineY: 0,
-  undoStack: [],
-  lineCache: [],
-  selections: new Uint32Array(),
-  diagnostics: []
-};
-const createEditor = async ({
-  id,
-  content,
-  savedDeltaY,
-  rowHeight,
-  fontSize,
-  hoverEnabled,
-  letterSpacing,
-  tabSize,
-  links,
-  lineNumbers,
-  formatOnSave,
-  isAutoClosingBracketsEnabled,
-  isAutoClosingTagsEnabled,
-  isAutoClosingQuotesEnabled,
-  isQuickSuggestionsEnabled,
-  completionTriggerCharacters,
-  savedSelections,
-  languageId,
-  x,
-  y,
-  width,
-  height,
-  fontWeight,
-  fontFamily,
-  isMonospaceFont,
-  uri
-}) => {
-  number$1(id);
-  string(content);
-  const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
-  const editor = {
-    uri,
-    isAutoClosingBracketsEnabled,
-    isAutoClosingTagsEnabled,
-    isAutoClosingQuotesEnabled,
-    isQuickSuggestionsEnabled,
-    completionTriggerCharacters,
-    savedSelections,
-    languageId,
-    x,
-    y,
-    width,
-    height,
-    tokenizerId: 0,
-    minLineY: 0,
-    maxLineY: 0,
-    lines: [],
-    undoStack: [],
-    lineCache: [],
-    selections: new Uint32Array(),
-    diagnostics: [],
-    decorations: [],
-    primarySelectionIndex: 0,
-    deltaX: 0,
-    deltaY: 0,
-    numberOfVisiblelines: 0,
-    finalY: 0,
-    finalDeltaY: 0,
-    columnWidth: 0,
-    rowHeight,
-    scrollBarWidth: 0,
-    scrollBarHeight: 0,
-    validLines: [],
-    invalidStartIndex: 0,
-    focused: false,
-    handleOffsetX: 0,
-    itemHeight: 20,
-    fontFamily,
-    fontWeight,
-    tabSize,
-    fontSize,
-    cursorWidth: 2,
-    completionState: '',
-    longestLineWidth: 0,
-    minimumSliderSize: 20,
-    differences: [],
-    completionUid: 0,
-    lineNumbers,
-    numberOfVisibleLines: 0,
-    isMonospaceFont,
-    letterSpacing,
-    charWidth,
-    uid: id,
-    id,
-    widgets: []
-  };
-  // TODO avoid creating intermediate editors here
-  const newEditor1 = setBounds(editor, x, y, width, height, 9);
-  const newEditor2 = setText(newEditor1, content);
-  const newEditor3 = setDeltaY$1(newEditor2, 0);
-  const newEditor4 = {
-    ...newEditor3,
-    focused: true
-  };
-  // console.log({ newEditor })
-  set$6(id, emptyEditor, newEditor4);
-  await invoke$2(TextDocumentSyncFull, uri, id, languageId, content);
-};
-
-// @ts-ignore
-const getNewSelections$d = selections => {
-  const newSelections = [];
-  for (let i = 0; i < selections.length; i += 4) {
-    const startRowIndex = selections[i];
-    const startColumnIndex = selections[i + 1];
-    const endRowIndex = selections[i + 2];
-    const endColumnIndex = selections[i + 3];
-    if (i === 0 && startRowIndex !== 0) {
-      newSelections.push(startRowIndex - 1, startColumnIndex, startRowIndex - 1, startColumnIndex);
-    }
-    newSelections.push(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
-  }
-  return new Uint32Array(newSelections);
+const IpcParentWithExtensionHostWorker = {
+  __proto__: null,
+  create: create$3,
+  wrap: wrap$3
 };
 
-// @ts-ignore
-const addCursorAbove = editor => {
-  const {
-    selections
-  } = editor;
-  const newSelections = getNewSelections$d(selections);
-  return {
-    ...editor,
-    selections: newSelections
-  };
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer([port], 'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
-// @ts-ignore
-const getNewSelections$c = (selections, linesLength) => {
-  const newSelections = [];
-  for (let i = 0; i < selections.length; i += 4) {
-    const startRowIndex = selections[i];
-    const startColumnIndex = selections[i + 1];
-    const endRowIndex = selections[i + 2];
-    const endColumnIndex = selections[i + 3];
-    newSelections.push(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
-    if (i === selections.length - 4 && endRowIndex < linesLength) {
-      newSelections.push(endRowIndex + 1, endColumnIndex, endRowIndex + 1, endColumnIndex);
-    }
+const create$2 = async () => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToSyntaxHighlightingWorker(port1);
+  const event = await waitForFirstMessage$1(port2);
+  if (event.data !== 'ready') {
+    throw new IpcError$1('unexpected first message');
   }
-  return new Uint32Array(newSelections);
+  return port2;
 };
-
-// @ts-ignore
-const addCursorBelow = editor => {
-  const {
-    selections,
-    lines
-  } = editor;
-  const newSelections = getNewSelections$c(selections, lines.length);
+const wrap$1 = port => {
   return {
-    ...editor,
-    selections: newSelections
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = event => {
+        const data = getData(event);
+        // @ts-ignore
+        listener({
+          target: this,
+          data
+        });
+      };
+      this.port.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
+    }
   };
 };
 
-// @ts-ignore
-
-// @ts-ignore
-const applyEdit = async (editor, changes) => {
-  object(editor);
-  array(changes);
-  return scheduleDocumentAndCursorsSelections(editor, changes);
-};
-
-const handleBlur = editor => {
-  // for (const listener of state.blurListeners) {
-  //   listener(editor)
-  // }
-  // TODO save on blur
-  // Command.execute(/* Main.save */ 89)
-  const newEditor = {
-    ...editor,
-    focused: false
-  };
-  return newEditor;
+const IpcParentWithSyntaxHighlightingWorker = {
+  __proto__: null,
+  create: create$2,
+  wrap: wrap$1
 };
 
-const replaceRange = (editor, ranges, replacement, origin) => {
-  const changes = [];
-  const rangesLength = ranges.length;
-  for (let i = 0; i < rangesLength; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(ranges, i);
-    const start = {
-      rowIndex: selectionStartRow,
-      columnIndex: selectionStartColumn
-    };
-    const end = {
-      rowIndex: selectionEndRow,
-      columnIndex: selectionEndColumn
-    };
-    const selection = {
-      start,
-      end
-    };
-    changes.push({
-      start: start,
-      end: end,
-      inserted: replacement,
-      deleted: getSelectionText(editor, selection),
-      origin
-    });
-  }
-  return changes;
+const sendMessagePortToRendererProcess = async port => {
+  await invokeAndTransfer([port], 'SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
 };
 
-// @ts-ignore
-const editorReplaceSelections = (editor, replacement, origin) => {
+const create$1 = async () => {
   const {
-    selections
-  } = editor;
-  return replaceRange(editor, selections, replacement, origin);
-};
-
-const getAccurateColumnIndexAscii = (
-// @ts-ignore
-line,
-// @ts-ignore
-guess,
-// @ts-ignore
-averageCharWidth,
-// @ts-ignore
-eventX,
-// @ts-ignore
-fontWeight,
-// @ts-ignore
-fontSize,
-// @ts-ignore
-fontFamily,
-// @ts-ignore
-letterSpacing,
-// @ts-ignore
-isMonospaceFont,
-// @ts-ignore
-charWidth) => {
-  for (let i = guess; i < line.length; i++) {
-    const width = measureTextWidth(line.slice(0, i), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
-    if (eventX - width < averageCharWidth / 2) {
-      return i;
-    }
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToRendererProcess(port1);
+  const event = await waitForFirstMessage$1(port2);
+  if (event.data !== 'ready') {
+    throw new IpcError$1('unexpected first message');
   }
-  return line.length;
-};
-
-const supported = () => {
-  return 'Segmenter' in Intl;
+  return port2;
 };
-const create = () => {
-  // @ts-ignore
-  const segmenter = new Intl.Segmenter();
+const wrap = port => {
   return {
-    at(line, index) {
-      const segments = segmenter.segment(line);
-      return segments.containing(index);
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
     },
-    visualIndex(line, index) {
-      const segments = segmenter.segment(line);
-      let currentVisualIndex = 0;
-      for (const segment of segments) {
-        if (segment.index >= index) {
-          return currentVisualIndex;
-        }
-        currentVisualIndex++;
-      }
-      return currentVisualIndex;
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = event => {
+        const data = getData(event);
+        // @ts-ignore
+        listener({
+          target: this,
+          data
+        });
+      };
+      this.port.onmessage = wrappedListener;
     },
-    modelIndex(line, visualIndex) {
-      const segments = segmenter.segment(line);
-      let currentVisualIndex = 0;
-      for (const segment of segments) {
-        if (currentVisualIndex >= visualIndex) {
-          return segment.index;
-        }
-        currentVisualIndex++;
-      }
-      return line.length;
+    send(message) {
+      this.port.postMessage(message);
     },
-    getSegments(line) {
-      return segmenter.segment(line);
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
     }
   };
 };
 
-// @ts-ignore
-const getAccurateColumnIndexUnicode = (line, guess, averageCharWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const segmenter = create();
-  const segments = segmenter.getSegments(line);
-  const isMonospaceFont = false;
-  const charWidth = 0;
-  for (const segment of segments) {
-    const width = measureTextWidth(line.slice(0, segment.index), fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
-    if (eventX - width < averageCharWidth) {
-      return segment.index;
-    }
+const IpcParentWithRendererProcess = {
+  __proto__: null,
+  create: create$1,
+  wrap
+};
+
+const getModule$1 = method => {
+  switch (method) {
+    case RendererProcess:
+      return IpcParentWithRendererProcess;
+    case ExtensionHostWorker:
+      return IpcParentWithExtensionHostWorker;
+    case SyntaxHighlightingWorker:
+      return IpcParentWithSyntaxHighlightingWorker;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const create = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule$1(method);
+  // @ts-ignore
+  const rawIpc = await module.create(options);
+  // @ts-ignore
+  if (options.raw) {
+    return rawIpc;
   }
-  return line.length;
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
 
-const RE_ASCII = /^[\p{ASCII}]*$/u;
-const isAscii = line => {
-  return RE_ASCII.test(line);
+const createRpc = method => {
+  let _ipc;
+  const listen = async () => {
+    const ipc = await create({
+      method
+    });
+    handleIpc(ipc);
+    _ipc = ipc;
+  };
+  const invoke = (method, ...params) => {
+    return invoke$5(_ipc, method, ...params);
+  };
+  return {
+    listen,
+    invoke
+  };
 };
 
-// @ts-ignore
-const guessOffset = (eventX, averageCharWidth) => {
-  const guess = Math.round(eventX / averageCharWidth);
-  return guess;
+const {
+  listen: listen$7,
+  invoke: invoke$2
+} = createRpc(ExtensionHostWorker);
+
+const CompletionExecute = 'ExtensionHostCompletion.execute';
+const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
+const HoverExecute = 'ExtensionHostHover.execute';
+const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
+
+const measureCharacterWidth = (fontWeight, fontSize, fontFamily, letterSpacing) => {
+  return measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
 };
 
-// @ts-ignore
-const normalizeGuess = (line, guess, tabSize) => {
-  let normalizedGuess = guess;
-  for (let i = 0; i < guess; i++) {
-    if (line[i] === Tab) {
-      normalizedGuess -= tabSize - 1;
-    }
-  }
-  return normalizedGuess;
+const emptyEditor = {
+  uri: '',
+  languageId: '',
+  // TODO use numeric language id?
+  lines: [],
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  tokenizerId: 0,
+  minLineY: 0,
+  decorations: [],
+  embeds: [],
+  deltaX: 0,
+  focused: false,
+  deltaY: 0,
+  scrollBarHeight: 0,
+  longestLineWidth: 0,
+  maxLineY: 0,
+  undoStack: [],
+  lineCache: [],
+  selections: new Uint32Array(),
+  diagnostics: []
+};
+const createEditor = async ({
+  id,
+  content,
+  savedDeltaY,
+  rowHeight,
+  fontSize,
+  hoverEnabled,
+  letterSpacing,
+  tabSize,
+  links,
+  lineNumbers,
+  formatOnSave,
+  isAutoClosingBracketsEnabled,
+  isAutoClosingTagsEnabled,
+  isAutoClosingQuotesEnabled,
+  isQuickSuggestionsEnabled,
+  completionTriggerCharacters,
+  savedSelections,
+  languageId,
+  x,
+  y,
+  width,
+  height,
+  fontWeight,
+  fontFamily,
+  isMonospaceFont,
+  uri
+}) => {
+  number$1(id);
+  string(content);
+  const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
+  const editor = {
+    uri,
+    isAutoClosingBracketsEnabled,
+    isAutoClosingTagsEnabled,
+    isAutoClosingQuotesEnabled,
+    isQuickSuggestionsEnabled,
+    completionTriggerCharacters,
+    savedSelections,
+    languageId,
+    x,
+    y,
+    width,
+    height,
+    tokenizerId: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    lines: [],
+    undoStack: [],
+    lineCache: [],
+    selections: new Uint32Array(),
+    diagnostics: [],
+    decorations: [],
+    primarySelectionIndex: 0,
+    deltaX: 0,
+    deltaY: 0,
+    numberOfVisiblelines: 0,
+    finalY: 0,
+    finalDeltaY: 0,
+    columnWidth: 0,
+    rowHeight,
+    scrollBarWidth: 0,
+    scrollBarHeight: 0,
+    validLines: [],
+    invalidStartIndex: 0,
+    focused: false,
+    handleOffsetX: 0,
+    itemHeight: 20,
+    fontFamily,
+    fontWeight,
+    tabSize,
+    fontSize,
+    cursorWidth: 2,
+    completionState: '',
+    longestLineWidth: 0,
+    minimumSliderSize: 20,
+    differences: [],
+    completionUid: 0,
+    lineNumbers,
+    numberOfVisibleLines: 0,
+    isMonospaceFont,
+    letterSpacing,
+    charWidth,
+    uid: id,
+    id,
+    widgets: []
+  };
+  // TODO avoid creating intermediate editors here
+  const newEditor1 = setBounds(editor, x, y, width, height, 9);
+  const newEditor2 = setText(newEditor1, content);
+  const newEditor3 = setDeltaY$1(newEditor2, 0);
+  const newEditor4 = {
+    ...newEditor3,
+    focused: true
+  };
+  // console.log({ newEditor })
+  set$6(id, emptyEditor, newEditor4);
+  await invoke$2(TextDocumentSyncFull, uri, id, languageId, content);
 };
 
 // @ts-ignore
-const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
-  string(line);
-  number$1(fontWeight);
-  number$1(fontSize);
-  string(fontFamily);
-  number$1(letterSpacing);
-  boolean(isMonospaceFont);
-  number$1(charWidth);
-  number$1(tabSize);
-  number$1(eventX);
-  // Assert.greaterZero(charWidth)
-  const guess = guessOffset(eventX, charWidth);
-  const normalize = shouldNormalizeText(line);
-  const normalizedGuess = normalizeGuess(line, guess, tabSize);
-  const text = line.slice(0, normalizedGuess);
-  const normalizedText = normalizeText(text, normalize, tabSize);
-  const actual = measureTextWidth(normalizedText, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
-  const isAscii$1 = isAscii(line);
-  if (isAscii$1) {
-    if (Math.abs(eventX - actual) < charWidth / 2) {
-      return normalizedGuess;
+const getNewSelections$d = selections => {
+  const newSelections = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const startRowIndex = selections[i];
+    const startColumnIndex = selections[i + 1];
+    const endRowIndex = selections[i + 2];
+    const endColumnIndex = selections[i + 3];
+    if (i === 0 && startRowIndex !== 0) {
+      newSelections.push(startRowIndex - 1, startColumnIndex, startRowIndex - 1, startColumnIndex);
     }
-    return getAccurateColumnIndexAscii(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+    newSelections.push(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
   }
-  return getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
+  return new Uint32Array(newSelections);
 };
 
 // @ts-ignore
-const at = (editor, eventX, eventY) => {
-  object(editor);
-  number$1(eventX);
-  number$1(eventY);
+const addCursorAbove = editor => {
   const {
-    y,
-    deltaY,
-    rowHeight,
-    fontSize,
-    fontWeight,
-    fontFamily,
-    letterSpacing,
-    lines,
-    tabSize,
-    differences,
-    isMonospaceFont,
-    charWidth
+    selections
   } = editor;
-  const rowIndex = Math.floor((eventY - y + deltaY) / rowHeight);
-  if (rowIndex < 0) {
-    return {
-      rowIndex: 0,
-      columnIndex: 0
-    };
-  }
-  const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
-  const line = lines[clampedRowIndex];
-  const columnIndex = getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX);
-  return {
-    rowIndex: clampedRowIndex,
-    columnIndex
+  const newSelections = getNewSelections$d(selections);
+  return {
+    ...editor,
+    selections: newSelections
   };
 };
 
-/**
- * @deprecated this doesn't work for variable width characters (unicode/emoji).
- * Use position computation in renderer process instead
- *
- * @param {object} editor
- * @param {number} rowIndex
- * @param {number} columnIndex
- * @returns
- */
 // @ts-ignore
-const x = (editor, rowIndex, columnIndex) => {
+const getNewSelections$c = (selections, linesLength) => {
+  const newSelections = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const startRowIndex = selections[i];
+    const startColumnIndex = selections[i + 1];
+    const endRowIndex = selections[i + 2];
+    const endColumnIndex = selections[i + 3];
+    newSelections.push(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
+    if (i === selections.length - 4 && endRowIndex < linesLength) {
+      newSelections.push(endRowIndex + 1, endColumnIndex, endRowIndex + 1, endColumnIndex);
+    }
+  }
+  return new Uint32Array(newSelections);
+};
+
+// @ts-ignore
+const addCursorBelow = editor => {
   const {
-    columnWidth,
-    x
+    selections,
+    lines
   } = editor;
-  const offsetX = columnIndex * columnWidth + x;
-  return offsetX;
+  const newSelections = getNewSelections$c(selections, lines.length);
+  return {
+    ...editor,
+    selections: newSelections
+  };
 };
 
-// @ts-ignore
-const y = (editor, rowIndex) => {
+const applyEdit = async (editor, changes) => {
+  object(editor);
+  array(changes);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+const handleBlur = editor => {
+  // for (const listener of state.blurListeners) {
+  //   listener(editor)
+  // }
+  // TODO save on blur
+  // Command.execute(/* Main.save */ 89)
+  const newEditor = {
+    ...editor,
+    focused: false
+  };
+  return newEditor;
+};
+
+const replaceRange = (editor, ranges, replacement, origin) => {
+  const changes = [];
+  const rangesLength = ranges.length;
+  for (let i = 0; i < rangesLength; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(ranges, i);
+    const start = {
+      rowIndex: selectionStartRow,
+      columnIndex: selectionStartColumn
+    };
+    const end = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn
+    };
+    const selection = {
+      start,
+      end
+    };
+    changes.push({
+      start: start,
+      end: end,
+      inserted: replacement,
+      deleted: getSelectionText(editor, selection),
+      origin
+    });
+  }
+  return changes;
+};
+
+const editorReplaceSelections = (editor, replacement, origin) => {
   const {
-    rowHeight,
-    y
+    selections
   } = editor;
-  const offsetY = (rowIndex + 1) * rowHeight + y;
-  return offsetY;
+  return replaceRange(editor, selections, replacement, origin);
 };
 
 const state$7 = {
@@ -2712,7 +3430,7 @@ const characterLeft = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create();
+  const segmenter = create$5();
   const last = segmenter.at(line, columnIndex - 1);
   return columnIndex - last.index;
 };
@@ -2725,7 +3443,7 @@ const characterRight = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
-  const segmenter = create();
+  const segmenter = create$5();
   const next = segmenter.at(line, columnIndex);
   return next.segment.length;
 };
@@ -3037,7 +3755,7 @@ const cut = editor => {
 // @ts-ignore
 const getChanges$6 = (lines, selections, getDelta) => {
   const changes = [];
-  // @ts-ignore
+  // TODO avoid closure
   const deleteSelection = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
     const positionLeft = editorGetPositionLeft(selectionStartRow, selectionStartColumn, lines, getDelta);
     const selectionEnd = {
@@ -3054,7 +3772,7 @@ const getChanges$6 = (lines, selections, getDelta) => {
         start: positionLeft,
         end: selectionEnd
       }),
-      origin: Delete
+      origin: DeleteLeft
     });
   };
   forEach(selections, deleteSelection);
@@ -3090,9 +3808,6 @@ const isAllAutoClosingPairDelete = (autoClosingRanges, selections) => {
   return true;
 };
 
-// @ts-ignore
-
-// @ts-ignore
 const deleteLeftWithAutoClose = editor => {
   const {
     selections,
@@ -3105,8 +3820,6 @@ const deleteLeftWithAutoClose = editor => {
   const changes = getChanges$6(lines, selections, twoCharactersLeft);
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
-
-// @ts-ignore
 const editorDeleteHorizontalLeft = (editor, getDelta) => {
   const {
     autoClosingRanges = [],
@@ -3120,7 +3833,7 @@ const editorDeleteHorizontalLeft = (editor, getDelta) => {
     const changes = getChanges$6(lines, selections, getDelta);
     return scheduleDocumentAndCursorsSelections(editor, changes);
   }
-  const changes = editorReplaceSelections(editor, [''], Delete);
+  const changes = editorReplaceSelections(editor, [''], DeleteLeft);
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
@@ -3245,182 +3958,51 @@ const getDocumentEdits = (editor, edits) => {
       documentEdit.inserted = [''];
     }
     documentEdits.push(documentEdit);
-  }
-  return documentEdits;
-};
-
-// @ts-ignore
-const applyDocumentEdits = (editor, edits) => {
-  if (!Array.isArray(edits)) {
-    warn('something is wrong with format on save', edits);
-    return editor;
-  }
-  if (edits.length === 0) {
-    return editor;
-  }
-  const documentEdits = getDocumentEdits(editor, edits);
-  return scheduleDocumentAndCursorsSelections(editor, documentEdits);
-};
-
-const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
-const isFormattingError = error => {
-  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage);
-};
-
-// TODO also format with cursor
-const format = async editor => {
-  try {
-    const edits = await format$1(editor);
-    return applyDocumentEdits(editor, edits);
-  } catch (error) {
-    if (isFormattingError(error)) {
-      console.error('Formatting Error:',
-      // @ts-ignore
-      error.message.slice(expectedErrorMessage.length));
-      return editor;
-    }
-    console.error(error);
-    const displayErrorMessage = `${error}`;
-    await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
-    return editor;
-  }
-};
-
-const RE_WORD_START$1 = /^\w+/;
-const RE_WORD_END$1 = /\w+$/;
-const getWordAt = (editor, rowIndex, columnIndex) => {
-  const {
-    lines
-  } = editor;
-  const line = lines[rowIndex];
-  const before = line.slice(0, columnIndex);
-  const matchBefore = before.match(RE_WORD_END$1);
-  const after = line.slice(columnIndex);
-  const matchAfter = after.match(RE_WORD_START$1);
-  let word = EmptyString;
-  if (matchBefore) {
-    word += matchBefore[0];
-  }
-  if (matchAfter) {
-    word += matchAfter[0];
-  }
-  return {
-    word
-  };
-};
-const getWordBefore = (editor, rowIndex, columnIndex) => {
-  const {
-    lines
-  } = editor;
-  const line = lines[rowIndex];
-  const before = line.slice(0, columnIndex);
-  const matchBefore = before.match(RE_WORD_END$1);
-  if (matchBefore) {
-    return matchBefore[0];
-  }
-  return EmptyString;
-};
-
-// @ts-ignore
-const getDefinition = async (editor, offset) => {
-  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
-  return definition;
-};
-
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-
-/**
- *
- * @param {string} key
- * @param {any} placeholders
- * @returns {string}
- */
-// @ts-ignore
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
-  }
-  // @ts-ignore
-  const replacer = (match, rest) => {
-    // @ts-ignore
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
-};
-
-/**
- * @enum {string}
- */
-const UiStrings = {
-  OrganizeImports: 'Organize Imports',
-  Copy: 'Copy',
-  CopyLineDown: 'Copy Line Down',
-  CopyLineUp: 'Copy Line Up',
-  Cut: 'Cut',
-  DuplicateSelection: 'Duplicate Selection',
-  FindAllImplementations: 'Find All Implementations',
-  FindAllReferences: 'Find All References',
-  GoToDefinition: 'Go to Definition',
-  GoToTypeDefinition: 'Go to Type Definition',
-  MoveLineDown: 'Move Line Down',
-  MoveLineUp: 'Move Line Up',
-  NoDefinitionFound: 'No definition found',
-  NoDefinitionFoundFor: "No definition found for '{PH1}'",
-  NoTypeDefinitionFound: 'No type definition found',
-  NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
-  Paste: 'Paste',
-  Redo: 'Redo',
-  SelectAll: 'Select All',
-  Separator: 'Separator',
-  ToggleBlockComment: 'Toggle Block Comment',
-  ToggleLineComment: 'Toggle Line Comment',
-  Undo: 'Undo',
-  FormatDocument: 'Format Document',
-  SourceActions: 'Source Actions',
-  EditorShowHover: 'Show Hover',
-  EditorFormatDocumentForced: 'Editor: Format Document (forced)',
-  EditorSelectNextOccurrence: 'Editor: Select Next Occurrence',
-  EditorSelectAllOccurrences: 'Editor: Select All Occurrences',
-  EditorGoToDefinition: 'Editor: Go To Definition',
-  EditorGoToTypeDefinition: 'Editor: Go To Type Definition',
-  EditorSelectInsideString: 'Editor: Select Inside String',
-  EditorIndent: 'Editor: Indent',
-  EditorUnindent: 'Editor: Unindent',
-  EditorSortLinesAscending: 'Editor: Sort Lines Ascending',
-  EditorToggleComment: 'Editor: Toggle Comment',
-  EditorSelectUp: 'Editor: Select Up',
-  EditorSelectDown: 'Editor: Select Down',
-  EditorToggleBlockComment: 'Editor: Toggle Block Comment',
-  EditorOpenColorPicker: 'Editor: Open Color Picker',
-  EditorCloseColorPicker: 'Editor: Close Color Picker',
-  EditorCopyLineDown: 'Editor: Copy Line Down',
-  EditorCopyLineUp: 'Editor: Copy Line Up',
-  Replace: 'replace',
-  NoResults: 'No Results'
-};
-const noDefinitionFound = () => {
-  return i18nString(UiStrings.NoDefinitionFound);
+  }
+  return documentEdits;
 };
 
 // @ts-ignore
-const noDefinitionFoundFor = word => {
-  return i18nString(UiStrings.NoDefinitionFoundFor, {
-    PH1: word
-  });
+const applyDocumentEdits = (editor, edits) => {
+  if (!Array.isArray(edits)) {
+    warn('something is wrong with format on save', edits);
+    return editor;
+  }
+  if (edits.length === 0) {
+    return editor;
+  }
+  const documentEdits = getDocumentEdits(editor, edits);
+  return scheduleDocumentAndCursorsSelections(editor, documentEdits);
 };
 
-// @ts-ignore
-const noTypeDefinitionFoundFor = word => {
-  return i18nString(UiStrings.NoTypeDefinitionFoundFor, {
-    PH1: word
-  });
+const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
+const isFormattingError = error => {
+  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage);
 };
-const noTypeDefinitionFound = () => {
-  return i18nString(UiStrings.NoTypeDefinitionFound);
+
+// TODO also format with cursor
+const format = async editor => {
+  try {
+    const edits = await format$1(editor);
+    return applyDocumentEdits(editor, edits);
+  } catch (error) {
+    if (isFormattingError(error)) {
+      console.error('Formatting Error:',
+      // @ts-ignore
+      error.message.slice(expectedErrorMessage.length));
+      return editor;
+    }
+    console.error(error);
+    const displayErrorMessage = `${error}`;
+    await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
+    return editor;
+  }
 };
-const noResults = () => {
-  return i18nString(UiStrings.NoResults);
+
+// @ts-ignore
+const getDefinition = async (editor, offset) => {
+  const definition = await invoke$3('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
+  return definition;
 };
 
 // @ts-ignore
@@ -4642,233 +5224,30 @@ const getCompletions = async editor => {
 };
 
 // TODO don't send unnecessary parts of completion item like matches
-const resolveCompletion = async (editor, name, completionItem) => {
-  try {
-    object(editor);
-    string(name);
-    object(completionItem);
-    const rowIndex = editor.selections[0];
-    const columnIndex = editor.selections[1];
-    const offset = await offsetAt(editor, rowIndex, columnIndex);
-    // @ts-ignore
-    const resolvedCompletionItem = await executeResolveCompletionItem(editor, offset, name, completionItem);
-    return resolvedCompletionItem;
-  } catch {
-    return undefined;
-  }
-};
-
-const None$1 = 1;
-
-const EmptyMatches = [];
-
-const Diagonal = 1;
-const Left = 2;
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-
-const createTable = size => {
-  const table = [];
-  for (let i = 0; i < size; i++) {
-    const row = new Uint8Array(size);
-    table.push(row);
-  }
-  return table;
-};
-
-const isLowerCase = char => {
-  return char === char.toLowerCase();
-};
-
-const isUpperCase = char => {
-  return char === char.toUpperCase();
-};
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-const isGap = (columnCharBefore, columnChar) => {
-  switch (columnCharBefore) {
-    case Dash:
-    case Underline:
-    case EmptyString:
-    case T:
-    case Space:
-    case Dot:
-      return true;
-  }
-  if (isLowerCase(columnCharBefore) && isUpperCase(columnChar)) {
-    return true;
-  }
-  return false;
-};
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch) => {
-  if (rowCharLow !== columnCharLow) {
-    return -1;
-  }
-  const isMatch = rowChar === columnChar;
-  if (isMatch) {
-    if (isDiagonalMatch) {
-      return 8;
-    }
-    if (isGap(columnCharBefore, columnChar)) {
-      return 8;
-    }
-    return 5;
-  }
-  if (isGap(columnCharBefore, columnChar)) {
-    return 8;
-  }
-  return 5;
-};
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-
-const isPatternInWord = (patternLow, patternPos, patternLen, wordLow, wordPos, wordLen) => {
-  while (patternPos < patternLen && wordPos < wordLen) {
-    if (patternLow[patternPos] === wordLow[wordPos]) {
-      patternPos += 1;
-    }
-    wordPos += 1;
-  }
-  return patternPos === patternLen; // pattern must be exhausted
-};
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-const traceHighlights = (table, arrows, patternLength, wordLength) => {
-  let row = patternLength;
-  let column = wordLength;
-  const matches = [];
-  while (row >= 1 && column >= 1) {
-    const arrow = arrows[row][column];
-    if (arrow === Left) {
-      column--;
-    } else if (arrow === Diagonal) {
-      row--;
-      column--;
-      const start = column + 1;
-      while (row >= 1 && column >= 1) {
-        const arrow = arrows[row][column];
-        if (arrow === Left) {
-          break;
-        }
-        if (arrow === Diagonal) {
-          row--;
-          column--;
-        }
-      }
-      const end = column;
-      matches.unshift(end, start);
-    }
-  }
-  matches.unshift(table[patternLength][wordLength - 1]);
-  return matches;
-};
-
-// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
-const gridSize = 128;
-const table = createTable(gridSize);
-const arrows = createTable(gridSize);
-// @ts-ignore
-createTable(gridSize);
-const filterCompletionItem = (pattern, word) => {
-  const patternLength = Math.min(pattern.length, gridSize - 1);
-  const wordLength = Math.min(word.length, gridSize - 1);
-  const patternLower = pattern.toLowerCase();
-  const wordLower = word.toLowerCase();
-  if (!isPatternInWord(patternLower, 0, patternLength, wordLower, 0, wordLength)) {
-    return EmptyMatches;
-  }
-  let strongMatch = false;
-  for (let row = 1; row < patternLength + 1; row++) {
-    const rowChar = pattern[row - 1];
-    const rowCharLow = patternLower[row - 1];
-    for (let column = 1; column < wordLength + 1; column++) {
-      const columnChar = word[column - 1];
-      const columnCharLow = wordLower[column - 1];
-      const columnCharBefore = word[column - 2] || '';
-      const isDiagonalMatch = arrows[row - 1][column - 1] === Diagonal;
-      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, column, wordLength, isDiagonalMatch);
-      if (row === 1 && score > 5) {
-        strongMatch = true;
-      }
-      let diagonalScore = score + table[row - 1][column - 1];
-      if (isDiagonalMatch && score !== -1) {
-        diagonalScore += 2;
-      }
-      const leftScore = table[row][column - 1];
-      if (leftScore > diagonalScore) {
-        table[row][column] = leftScore;
-        arrows[row][column] = Left;
-      } else {
-        table[row][column] = diagonalScore;
-        arrows[row][column] = Diagonal;
-      }
-    }
-  }
-  if (!strongMatch) {
-    return EmptyMatches;
-  }
-  // printTables(pattern, 0, word, 0)
-  const highlights = traceHighlights(table, arrows, patternLength, wordLength);
-  return highlights;
-};
-
-const Deprecated = 1 << 0;
-
-const addEmptyMatch = item => {
-  return {
-    ...item,
-    matches: EmptyMatches
-  };
-};
-const filterCompletionItems = (completionItems, word) => {
-  if (word === EmptyString) {
-    return completionItems.map(addEmptyMatch);
-  }
-  const filteredCompletions = [];
-  const deprecated = [];
-  for (const completionItem of completionItems) {
-    const {
-      label,
-      flags
-    } = completionItem;
-    const result = filterCompletionItem(word, label);
-    if (result !== EmptyMatches) {
-      if (flags & Deprecated) {
-        // TODO avoid mutation
-        completionItem.matches = EmptyMatches;
-        deprecated.push(completionItem);
-      } else {
-        // TODO avoid mutation
-        completionItem.matches = result;
-        filteredCompletions.push(completionItem);
-      }
-    }
-  }
-  if (deprecated.length > 0) {
-    filteredCompletions.push(...deprecated);
+const resolveCompletion = async (editor, name, completionItem) => {
+  try {
+    object(editor);
+    string(name);
+    object(completionItem);
+    const rowIndex = editor.selections[0];
+    const columnIndex = editor.selections[1];
+    const offset = await offsetAt(editor, rowIndex, columnIndex);
+    // @ts-ignore
+    const resolvedCompletionItem = await executeResolveCompletionItem(editor, offset, name, completionItem);
+    return resolvedCompletionItem;
+  } catch {
+    return undefined;
   }
-  return filteredCompletions;
 };
 
+const None = 1;
+
 const getFinalDeltaY = (height, itemHeight, itemsLength) => {
   const contentHeight = itemsLength * itemHeight;
   const finalDeltaY = Math.max(contentHeight - height, 0);
   return finalDeltaY;
 };
 
-const getListHeight = (itemsLength, itemHeight, maxHeight) => {
-  number$1(itemsLength);
-  number$1(itemHeight);
-  number$1(maxHeight);
-  if (itemsLength === 0) {
-    return itemHeight;
-  }
-  const totalHeight = itemsLength * itemHeight;
-  return Math.min(totalHeight, maxHeight);
-};
-
 const getEditor = editorUid => {
   const instance = get$6(editorUid);
   if (!instance) {
@@ -4940,7 +5319,7 @@ const handleEditorDeleteLeft = (editorUid, state) => {
   const y$1 = y(editor, rowIndex);
   const wordAtOffset = getWordAtOffset(editor);
   if (!wordAtOffset) {
-    editor.completionState = None$1;
+    editor.completionState = None;
     return {
       ...state,
       disposed: true
@@ -4966,7 +5345,7 @@ const dispose = state => {
   };
 };
 const disposeWithEditor = (state, editor) => {
-  editor.completionState = None$1;
+  editor.completionState = None;
   editor.completionUid = 0;
   // Focus.removeAdditionalFocus(FocusKey.EditorCompletion)
   return dispose(state);
@@ -6866,7 +7245,7 @@ const select = async (editor, completionItem) => {
   ();
   if (index !== -1) {
     editor.widgets.splice(index, 1);
-    editor.completionState = None$1;
+    editor.completionState = None;
     editor.completionUid = 0;
   }
   // TODO dispose completion widget
@@ -6929,7 +7308,7 @@ const getHover = async (editor, offset) => {
 
 let _ipc;
 const listen$5 = async () => {
-  const ipc = await create$1({
+  const ipc = await create({
     method: RendererProcess
   });
   handleIpc(ipc);
@@ -7158,14 +7537,6 @@ const handleSashPointerUp = (state, eventX, eventY) => {
   return state;
 };
 
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
 const getLineInfoVirtualDom = lineInfo => {
   const dom = [{
     type: Div,
@@ -7253,7 +7624,7 @@ const renderHoverDom = {
     return [/* method */'Viewlet.setDom2', dom];
   }
 };
-const renderBounds$1 = {
+const renderBounds = {
   isEqual(oldState, newState) {
     return oldState.x === newState.x && oldState.y === newState.y && oldState.resizedWidth === newState.resizedWidth;
   },
@@ -7271,10 +7642,10 @@ const renderBounds$1 = {
     return [SetBounds, x, y, resizedWidth, height];
   }
 };
-const render$2 = [renderHoverDom, renderBounds$1];
+const render$1 = [renderHoverDom, renderBounds];
 const renderHover = async (oldState, newState) => {
   const commands = [];
-  for (const item of render$2) {
+  for (const item of render$1) {
     if (!item.isEqual(oldState, newState)) {
       commands.push(item.apply(oldState, newState));
     }
@@ -7580,7 +7951,7 @@ const moveLineUp = editor => {
 };
 
 const Link$1 = 'Link';
-const Function$1 = 'Function';
+const Function = 'Function';
 const Parameter = 'Parameter';
 const Type = 'Type';
 const VariableName = 'VariableName';
@@ -7639,7 +8010,7 @@ const getDecorationClassName = type => {
     case Ts3073:
     case Ts3077:
     case Ts3088:
-      return Function$1;
+      return Function;
     case Ts1792:
     case Ts1793:
       return Parameter;
@@ -8062,422 +8433,143 @@ const getVisible = async (editor, syncIncremental) => {
   return {
     textInfos: result,
     differences
-  };
-};
-
-const getCursorsVirtualDom = cursors => {
-  const dom = [];
-  for (const translate of cursors) {
-    dom.push({
-      type: Div,
-      className: EditorCursor,
-      translate
-    });
-  }
-  return dom;
-};
-
-const Error$1 = 'error';
-const Warning = 'warning';
-
-const getDiagnosticClassName = type => {
-  // TODO use classnames enum
-  switch (type) {
-    case Error$1:
-      return 'DiagnosticError';
-    case Warning:
-      return 'DiagnosticWarning';
-    default:
-      return 'DiagnosticError';
-  }
-};
-const getDiagnosticVirtualDom = diagnostic => {
-  const {
-    x,
-    y,
-    width,
-    height,
-    type
-  } = diagnostic;
-  const extraClassName = getDiagnosticClassName(type);
-  return [{
-    type: Div,
-    className: `${Diagnostic} ${extraClassName}`,
-    width,
-    height,
-    top: y,
-    left: x,
-    childCount: 0
-  }];
-};
-
-const getDiagnosticsVirtualDom = diagnostics => {
-  const dom = diagnostics.flatMap(getDiagnosticVirtualDom);
-  return dom;
-};
-
-const getGutterInfoVirtualDom = gutterInfo => {
-  return [{
-    type: Span,
-    className: 'LineNumber',
-    childCount: 1
-  }, text(gutterInfo)];
-};
-const getEditorGutterVirtualDom = gutterInfos => {
-  const dom = gutterInfos.flatMap(getGutterInfoVirtualDom);
-  return dom;
-};
-
-const getEditorRowsVirtualDom = (textInfos, differences, lineNumbers = true) => {
-  const dom = [];
-  for (let i = 0; i < textInfos.length; i++) {
-    const textInfo = textInfos[i];
-    const difference = differences[i];
-    dom.push({
-      type: Div,
-      className: EditorRow,
-      translate: px(difference),
-      childCount: textInfo.length / 2
-    });
-    for (let j = 0; j < textInfo.length; j += 2) {
-      const tokenText = textInfo[j];
-      const className = textInfo[j + 1];
-      dom.push({
-        type: Span,
-        className,
-        childCount: 1
-      }, text(tokenText));
-    }
-  }
-  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.rowIndex;
-      const lines = newState.lines;
-      const oldLine = oldState.lines[rowIndex];
-      const newLine = lines[rowIndex];
-      const incrementalEdits = await invoke$1('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
-      if (incrementalEdits && incrementalEdits.length === 1) {
-        return incrementalEdits;
-      }
-    }
-  }
-  return undefined;
-};
-
-const getSelectionsVirtualDom = selections => {
-  const dom = [];
-  for (let i = 0; i < selections.length; i += 4) {
-    const x = selections[i];
-    const y = selections[i + 1];
-    const width = selections[i + 2];
-    const height = selections[i + 3];
-    dom.push({
-      type: Div,
-      className: EditorSelection,
-      left: x,
-      top: y,
-      width,
-      height
-    });
-  }
-  return dom;
-};
-
-const None = 'none';
-const Option = 'option';
-
-const getFileIconVirtualDom = icon => {
-  return {
-    type: Img,
-    className: FileIcon,
-    src: icon,
-    role: None,
-    childCount: 0
-  };
-};
-
-const getIconDom = (fileIcon, symbolName) => {
-  if (fileIcon) {
-    return getFileIconVirtualDom(fileIcon);
-  }
-  return {
-    type: Div,
-    className: `${ColoredMaskIcon} ${symbolName}`,
-    childCount: 0
-  };
-};
-
-const label1 = {
-  type: Div,
-  className: Label,
-  childCount: 1
-};
-const completionHighlight = {
-  type: Span,
-  className: EditorCompletionItemHighlight,
-  childCount: 1
-};
-const getHighlightedLabelDom = (label, highlights) => {
-  if (highlights.length === 0) {
-    return [label1, text(label)];
-  }
-  const dom = [];
-  const labelDom = {
-    type: Div,
-    className: Label,
-    childCount: 0
-  };
-  dom.push(labelDom);
-  let position = 0;
-  for (let i = 0; i < highlights.length; i += 2) {
-    const highlightStart = highlights[i];
-    const highlightEnd = highlights[i + 1];
-    if (position < highlightStart) {
-      const beforeText = label.slice(position, highlightStart);
-      labelDom.childCount++;
-      dom.push(text(beforeText));
-    }
-    const highlightText = label.slice(highlightStart, highlightEnd);
-    labelDom.childCount++;
-    dom.push(completionHighlight, text(highlightText));
-    position = highlightEnd;
-  }
-  if (position < label.length) {
-    const afterText = label.slice(position);
-    labelDom.childCount++;
-    dom.push(text(afterText));
-  }
-  return dom;
-};
-
-const getCompletionItemVirtualDom = visibleItem => {
-  const {
-    top,
-    label,
-    symbolName,
-    highlights,
-    focused,
-    deprecated,
-    fileIcon
-  } = visibleItem;
-  let className = EditorCompletionItem;
-  if (focused) {
-    className += ' ' + EditorCompletionItemFocused;
-  }
-  if (deprecated) {
-    className += ' ' + EditorCompletionItemDeprecated;
-  }
-  return [{
-    type: Div,
-    role: Option,
-    className,
-    top,
-    childCount: 2
-  }, getIconDom(fileIcon, symbolName), ...getHighlightedLabelDom(label, highlights)];
+  };
 };
 
-const getCompletionItemsVirtualDom = visibleItems => {
-  if (visibleItems.length === 0) {
-    return [{
+const getCursorsVirtualDom = cursors => {
+  const dom = [];
+  for (const translate of cursors) {
+    dom.push({
       type: Div,
-      childCount: 1
-    }, text(noResults())];
+      className: EditorCursor,
+      translate
+    });
   }
-  const root = {
-    type: Div,
-    childCount: visibleItems.length
-  };
-  const dom = [root, ...visibleItems.flatMap(getCompletionItemVirtualDom)];
   return dom;
 };
 
-const Property = 1;
-const Value = 2;
-const Function = 3;
-const Variable = 4;
-const Keyword = 5;
-const Folder = 6;
-const File = 7;
-const Field = 8;
-
-const SymbolProperty = 'SymbolProperty';
-const SymbolValue = 'SymbolValue';
-const SymbolFunction = 'SymbolFunction';
-const SymbolVariable = 'SymbolVariable';
-const SymbolKeyword = 'SymbolKeyword';
-const SymbolDefault = 'SymbolDefault';
-const SymbolField = 'SymbolField';
-const SymbolNone = '';
+const Error$1 = 'error';
+const Warning = 'warning';
 
-const getSymbolName = item => {
-  switch (item.kind) {
-    case Property:
-      return SymbolProperty;
-    case Value:
-      return SymbolValue;
-    case Function:
-      return SymbolFunction;
-    case Variable:
-      return SymbolVariable;
-    case Keyword:
-      return SymbolKeyword;
-    case Field:
-      return SymbolField;
-    case File:
-      return SymbolNone;
+const getDiagnosticClassName = type => {
+  // TODO use classnames enum
+  switch (type) {
+    case Error$1:
+      return 'DiagnosticError';
+    case Warning:
+      return 'DiagnosticWarning';
     default:
-      return SymbolDefault;
+      return 'DiagnosticError';
   }
 };
-
-const getHighlights = (item, leadingWord) => {
+const getDiagnosticVirtualDom = diagnostic => {
   const {
-    matches
-  } = item;
-  return matches.slice(1);
+    x,
+    y,
+    width,
+    height,
+    type
+  } = diagnostic;
+  const extraClassName = getDiagnosticClassName(type);
+  return [{
+    type: Div,
+    className: `${Diagnostic} ${extraClassName}`,
+    width,
+    height,
+    top: y,
+    left: x,
+    childCount: 0
+  }];
 };
 
-// import * as IconTheme from '../IconTheme/IconTheme.ts'
-
-const getLabel = item => {
-  return item.label;
+const getDiagnosticsVirtualDom = diagnostics => {
+  const dom = diagnostics.flatMap(getDiagnosticVirtualDom);
+  return dom;
 };
-const getFileIcon = item => {
-  switch (item.kind) {
-    case File:
-      // TODO IconTheme.getFileNameIcon(item.label)
-      return '';
-    case Folder:
-      // TODO IconTheme.getFolderNameIcon(item.label)
-      return '';
-    default:
-      return '';
-  }
+
+const getGutterInfoVirtualDom = gutterInfo => {
+  return [{
+    type: Span,
+    className: 'LineNumber',
+    childCount: 1
+  }, text(gutterInfo)];
 };
-const getVisibleIem = (item, itemHeight, leadingWord, i, focusedIndex) => {
-  return {
-    label: getLabel(item),
-    symbolName: getSymbolName(item),
-    top: i * itemHeight,
-    highlights: getHighlights(item),
-    focused: i === focusedIndex,
-    deprecated: item.flags & Deprecated,
-    fileIcon: getFileIcon(item)
-  };
+const getEditorGutterVirtualDom = gutterInfos => {
+  const dom = gutterInfos.flatMap(getGutterInfoVirtualDom);
+  return dom;
 };
 
-const getVisibleItems = (filteredItems, itemHeight, leadingWord, minLineY, maxLineY, focusedIndex) => {
-  const visibleItems = [];
-  for (let i = minLineY; i < maxLineY; i++) {
-    const filteredItem = filteredItems[i];
-    visibleItems.push(getVisibleIem(filteredItem, itemHeight, leadingWord, i, focusedIndex));
+const getEditorRowsVirtualDom = (textInfos, differences, lineNumbers = true) => {
+  const dom = [];
+  for (let i = 0; i < textInfos.length; i++) {
+    const textInfo = textInfos[i];
+    const difference = differences[i];
+    dom.push({
+      type: Div,
+      className: EditorRow,
+      translate: px(difference),
+      childCount: textInfo.length / 2
+    });
+    for (let j = 0; j < textInfo.length; j += 2) {
+      const tokenText = textInfo[j];
+      const className = textInfo[j + 1];
+      dom.push({
+        type: Span,
+        className,
+        childCount: 1
+      }, text(tokenText));
+    }
   }
-  return visibleItems;
+  return dom;
 };
 
-const renderItems = {
-  isEqual(oldState, newState) {
-    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex;
-  },
-  apply(oldState, newState) {
-    const visibleItems = getVisibleItems(newState.items, newState.itemHeight, newState.leadingWord, newState.minLineY, newState.maxLineY, newState.focusedIndex);
-    const dom = getCompletionItemsVirtualDom(visibleItems);
-    return ['setDom', dom];
-  }
-};
-const renderBounds = {
-  isEqual(oldState, newState) {
-    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.x === newState.x && oldState.y === newState.y;
-  },
-  apply(oldState, newState) {
-    const {
-      x,
-      y,
-      width,
-      height
-    } = newState;
-    return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
-  }
-};
-const renderHeight = {
-  isEqual(oldState, newState) {
-    return oldState.items.length === newState.items.length;
-  },
-  apply(oldState, newState) {
-    const {
-      itemHeight
-    } = newState;
-    const contentHeight = newState.items.length * itemHeight;
-    return [/* method */SetContentHeight, /* contentHeight */contentHeight];
-  }
-};
-const renderNegativeMargin = {
-  isEqual(oldState, newState) {
-    return oldState.deltaY === newState.deltaY;
-  },
-  apply(oldState, newState) {
-    return [/* method */SetNegativeMargin, /* negativeMargin */-newState.deltaY];
-  }
-};
-const renderScrollBar = {
-  isEqual(oldState, newState) {
-    return oldState.negativeMargin === newState.negativeMargin && oldState.deltaY === newState.deltaY && oldState.height === newState.height && oldState.finalDeltaY === newState.finalDeltaY && oldState.items.length === newState.items.length;
-  },
-  apply(oldState, newState) {
-    const total = newState.items.length;
-    const contentHeight = total * newState.itemHeight;
-    const scrollBarHeight = getScrollBarSize(newState.height, contentHeight, newState.minimumSliderSize);
-    const scrollBarY = getScrollBarY(newState.deltaY, newState.finalDeltaY, newState.height - newState.headerHeight, scrollBarHeight);
-    return [/* method */SetScrollBar, /* scrollBarY */scrollBarY, /* scrollBarHeight */scrollBarHeight];
+const getIncrementalEdits = async (oldState, newState) => {
+  if (!newState.undoStack) {
+    return undefined;
   }
-};
-const render$1 = [renderItems, renderBounds, renderHeight, renderNegativeMargin, renderScrollBar];
-const renderCompletion$1 = (oldState, newState) => {
-  const commands = [];
-  for (const item of render$1) {
-    if (!item.isEqual(oldState, newState)) {
-      commands.push(item.apply(oldState, newState));
+  const lastChanges = newState.undoStack.at(-1);
+  if (lastChanges && lastChanges.length === 1) {
+    const lastChange = lastChanges[0];
+    if (lastChange.origin === EditorType) {
+      const rowIndex = lastChange.start.rowIndex;
+      const lines = newState.lines;
+      const oldLine = oldState.lines[rowIndex];
+      const newLine = lines[rowIndex];
+      const incrementalEdits = await invoke$1('TokenizeIncremental.tokenizeIncremental', newState.uid, newState.languageId, oldLine, newLine, rowIndex, newState.minLineY);
+      if (incrementalEdits && incrementalEdits.length === 1) {
+        return incrementalEdits;
+      }
     }
   }
-  return commands;
+  return undefined;
 };
 
-const renderCompletion = (oldState, newState) => {
-  const commands = renderCompletion$1(oldState, newState);
-  const wrappedCommands = [];
-  const uid = newState.uid;
-  for (const command of commands) {
-    wrappedCommands.push(['Viewlet.send', uid, ...command]);
+const getSelectionsVirtualDom = selections => {
+  const dom = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const x = selections[i];
+    const y = selections[i + 1];
+    const width = selections[i + 2];
+    const height = selections[i + 3];
+    dom.push({
+      type: Div,
+      className: EditorSelection,
+      left: x,
+      top: y,
+      width,
+      height
+    });
   }
-  return wrappedCommands;
-};
-const addWidgetCompletion = widget => {
-  const commands = renderCompletion(widget.oldState, widget.newState);
-  const id = 'EditorCompletion';
-  // TODO how to generate a unique integer id
-  // that doesn't collide with ids created in renderer worker?
-  const uid = widget.newState.uid;
-  const allCommands = [];
-  allCommands.push(['Viewlet.create', id, uid]);
-  allCommands.push(...commands);
-  return allCommands;
+  return dom;
 };
+
 const addWidget = widget => {
   const {
     id
   } = widget;
   switch (id) {
-    case 'completion':
-      return addWidgetCompletion(widget);
+    case Completion:
+      return add(widget);
     default:
       throw new Error('unsupported widget');
   }
@@ -8487,22 +8579,19 @@ const renderWidget = widget => {
     id
   } = widget;
   switch (id) {
-    case 'completion':
-      return renderCompletion(widget.oldState, widget.newState);
+    case Completion:
+      return render$2(widget.oldState, widget.newState);
     default:
       throw new Error(`unsupported widget`);
   }
 };
-const removeCompletion = widget => {
-  return [['Viewlet.send', widget.newState.uid, 'dispose']];
-};
 const removeWidget = widget => {
   const {
     id
   } = widget;
   switch (id) {
-    case 'completion':
-      return removeCompletion(widget);
+    case Completion:
+      return remove$1(widget);
     default:
       throw new Error('unsupported widget');
   }