@lvce-editor/server 0.29.8 → 0.30.0

package/static/1d13af6/packages/editor-worker/dist/editorWorkerMain.js

@@ -0,0 +1,3733 @@
+// @ts-ignore
+const getNewSelections$b = 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);
+};
+
+// @ts-ignore
+const addCursorAbove = editor => {
+  const {
+    selections
+  } = editor;
+  const newSelections = getNewSelections$b(selections);
+  return {
+    ...editor,
+    selections: newSelections
+  };
+};
+
+// @ts-ignore
+const getNewSelections$a = (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 {
+    selections,
+    lines
+  } = editor;
+  const newSelections = getNewSelections$a(selections, lines.length);
+  return {
+    ...editor,
+    selections: newSelections
+  };
+};
+
+class AssertionError extends Error {
+  // @ts-ignore
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+
+// TODO treeshake out this whole module in production
+
+
+// @ts-ignore
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      if (value instanceof Uint32Array) {
+        return 'uint32array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
+};
+
+// @ts-ignore
+const object = value => {
+  const type = getType(value);
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+
+// @ts-ignore
+const number = value => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
+  }
+  if (isNaN(value)) {
+    throw new AssertionError('value is NaN');
+  }
+};
+
+// @ts-ignore
+const array = value => {
+  const type = getType(value);
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
+
+// @ts-ignore
+const string = value => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
+// @ts-ignore
+const boolean = value => {
+  const type = getType(value);
+  if (type !== 'boolean') {
+    throw new AssertionError('expected value to be of type boolean');
+  }
+};
+
+// @ts-ignore
+const uint32array = value => {
+  const type = getType(value);
+  if (type !== 'uint32array') {
+    throw new AssertionError('expected value to be of type uint32array');
+  }
+};
+
+// @ts-ignore
+const greaterZero = value => {
+  if (value <= 0) {
+    throw new Error('value must be greater than zero');
+  }
+};
+
+// TODO use numeric enum
+const CompositionUpdate = 'compositionUpdate';
+const Delete = 'delete';
+const DeleteHorizontalRight = 'deleteHorizontalRight';
+const EditorCut = 'editorCut';
+const EditorPasteText = 'editorPasteText';
+const EditorTypeWithAutoClosing = 'editorTypeWithAutoClosing';
+const IndentLess = 'indentLess';
+const IndentMore = 'indentMore';
+
+// 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 splitLines = lines => {
+  if (!lines) {
+    return [];
+  }
+  return lines.split('\n');
+};
+
+const joinLines = 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];
+  for (const change of changes) {
+    const startRowIndex = change.start.rowIndex;
+    const endRowIndex = change.end.rowIndex;
+    const startColumnIndex = change.start.columnIndex;
+    const endColumnIndex = change.end.columnIndex;
+    const inserted = change.inserted;
+    const deleted = change.deleted;
+    number(startRowIndex);
+    number(endRowIndex);
+    number(startColumnIndex);
+    number(endColumnIndex);
+    array(inserted);
+    array(deleted);
+    if (startRowIndex === endRowIndex) {
+      if (inserted.length === 0) {
+        const line = newLines[startRowIndex];
+        const before = line.slice(0, startColumnIndex);
+        const after = line.slice(endColumnIndex);
+        newLines[startRowIndex] = before + after;
+      } else if (inserted.length === 1) {
+        const line = newLines[startRowIndex];
+        let before = line.slice(0, startColumnIndex);
+        if (startColumnIndex > line.length) {
+          before += ' '.repeat(startColumnIndex - line.length);
+        }
+        const after = line.slice(endColumnIndex);
+        const text = inserted[0];
+        newLines[startRowIndex] = before + text + after;
+      } else {
+        const line = newLines[startRowIndex];
+        const before = line.slice(0, startColumnIndex) + inserted[0];
+        const after = inserted.at(-1) + line.slice(endColumnIndex);
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...inserted.slice(1, -1), after]);
+        // TODO only do this once after all edits, not inside loop
+        textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, newLines.length);
+      }
+    } else {
+      if (inserted.length === 1) {
+        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
+        const after = endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex);
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before + after]);
+      } else {
+        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
+        const middle = inserted.slice(1, -1);
+        const after = inserted.at(-1) + (endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex));
+        spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...middle, after]);
+      }
+      // TODO only do this once after all edits, not inside loop
+      textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, textDocument.lines.length);
+    }
+  }
+  return newLines;
+};
+const getLine = (textDocument, index) => {
+  return textDocument.lines[index];
+};
+const getText = state => {
+  return joinLines(state.lines);
+};
+
+// 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 offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
+  object(textDocument);
+  number(positionRowIndex);
+  number(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
+  };
+};
+
+// @ts-ignore
+const clamp = (num, min, max) => {
+  number(num);
+  number(min);
+  number(max);
+  return Math.min(Math.max(num, min), max);
+};
+
+// @ts-ignore
+const getSelectionPairs = (selections, i) => {
+  const first = selections[i];
+  const second = selections[i + 1];
+  const third = selections[i + 2];
+  const fourth = selections[i + 3];
+  if (first > third || first === third && second >= fourth) {
+    return [third, fourth, first, second, 1];
+  }
+  return [first, second, third, fourth, 0];
+};
+
+const fromRange = (startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  return new Uint32Array([startRowIndex, startColumnIndex, endRowIndex, endColumnIndex]);
+};
+const alloc = length => {
+  return new Uint32Array(length);
+};
+const clone = selections => {
+  return alloc(selections.length);
+};
+const map = (selections, fn) => {
+  const newSelections = clone(selections);
+  for (let i = 0; i < newSelections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    fn(newSelections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+  }
+  return newSelections;
+};
+const forEach = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn);
+  }
+};
+const moveRangeToPosition$1 = (selections, i, rowIndex, columnIndex) => {
+  selections[i] = selections[i + 2] = rowIndex;
+  selections[i + 1] = selections[i + 3] = columnIndex;
+};
+const isEmpty = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  return selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn;
+};
+const isSelectionSingleLine = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  return selectionStartRow === selectionEndRow;
+};
+const isEverySelection = (selections, fn) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    if (!fn(selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
+      return false;
+    }
+  }
+  return true;
+};
+const isEverySelectionEmpty = selections => {
+  return isEverySelection(selections, isEmpty);
+};
+const isEverySelectionSingleLine = selections => {
+  return isEverySelection(selections, isSelectionSingleLine);
+};
+const from = (array, getSelection) => {
+  const newSelections = alloc(array.length * 4);
+  let i = 0;
+  for (const item of array) {
+    const {
+      start,
+      end
+    } = getSelection(item);
+    newSelections[i++] = start.rowIndex;
+    newSelections[i++] = start.columnIndex;
+    newSelections[i++] = end.rowIndex;
+    newSelections[i++] = end.columnIndex;
+  }
+  return newSelections;
+};
+const push = (selections, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  const oldLength = selections.length;
+  const newSelections = alloc(oldLength + 4);
+  newSelections.set(selections);
+  newSelections[oldLength + 1] = startRowIndex;
+  newSelections[oldLength + 2] = startColumnIndex;
+  newSelections[oldLength + 3] = endRowIndex;
+  newSelections[oldLength + 4] = endColumnIndex;
+  return newSelections;
+};
+
+const state$7 = {
+  ctx: undefined
+};
+
+/**
+ * @param {()=>OffscreenCanvasRenderingContext2D} createCtx
+ * @returns {OffscreenCanvasRenderingContext2D}
+ */
+const getOrCreate = createCtx => {
+  if (state$7.ctx) {
+    return state$7.ctx;
+  }
+  state$7.ctx = createCtx();
+  return state$7.ctx;
+};
+
+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 ctx;
+};
+const getContext = () => {
+  const ctx = getOrCreate(createCtx);
+  return ctx;
+};
+
+// @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);
+  number(fontWeight);
+  number(fontSize);
+  string(fontFamily);
+  boolean(isMonoSpaceFont);
+  number(charWidth);
+  if (isMonoSpaceFont) {
+    return text.length * charWidth;
+  }
+  if (typeof letterSpacing !== 'number') {
+    throw new TypeError('letterSpacing must be of type number');
+  }
+  const letterSpacingString = getLetterSpacingString(letterSpacing);
+  const fontString = getFontString(fontWeight, fontSize, fontFamily);
+  const ctx = getContext();
+  // @ts-ignore
+  ctx.letterSpacing = letterSpacingString;
+  // @ts-ignore
+  ctx.font = fontString;
+  // @ts-ignore
+  const metrics = ctx.measureText(text);
+  const width = metrics.width;
+  return width;
+};
+
+const EmptyString = '';
+const NewLine = '\n';
+const Space = ' ';
+const Tab = '\t';
+
+const normalizeText = (text, normalize, tabSize) => {
+  if (normalize) {
+    return text.replaceAll(Tab, Space.repeat(tabSize));
+  }
+  return text;
+};
+const shouldNormalizeText = text => {
+  return text.includes(Tab);
+};
+
+// @ts-ignore
+const getSelectionFromChange = change => {
+  const {
+    start,
+    inserted
+  } = change;
+  const startRowIndex = start.rowIndex;
+  const startColumnIndex = start.columnIndex;
+  const insertedLength = inserted.length;
+  if (insertedLength === 1) {
+    const newPosition = {
+      rowIndex: startRowIndex + insertedLength - 1,
+      columnIndex: inserted.at(-1).length + startColumnIndex
+    };
+    return {
+      start: newPosition,
+      end: newPosition
+    };
+  }
+  const newPosition = {
+    rowIndex: startRowIndex + insertedLength - 1,
+    columnIndex: inserted.at(-1).length
+  };
+  return {
+    start: newPosition,
+    end: newPosition
+  };
+};
+
+// @ts-ignore
+const setSelections = (editor, selections) => {
+  object(editor);
+  uint32array(selections);
+  return {
+    ...editor,
+    selections
+  };
+  // editor.selections = selections
+  // GlobalEventBus.emitEvent('editor.selectionChange', editor, selections)
+};
+
+// TODO maybe only accept sorted selection edits in the first place
+
+// TODO avoid allocating too many objects when creating new selection from changes
+// @ts-ignore
+const applyEdit = (editor, changes) => {
+  object(editor);
+  array(changes);
+  const newSelections = from(changes, getSelectionFromChange);
+  // setSelections(editor, newSelections)
+  return newSelections;
+};
+
+// @ts-ignore
+const isAutoClosingChange = change => {
+  return change.origin === EditorTypeWithAutoClosing;
+};
+
+// @ts-ignore
+const applyAutoClosingRangesEdit = (editor, changes) => {
+  const {
+    autoClosingRanges = []
+  } = editor;
+  const newAutoClosingRanges = [];
+  const change = changes[0];
+  const changeStartRowIndex = change.start.rowIndex;
+  const changeStartColumnIndex = change.start.columnIndex;
+  const changeEndRowIndex = change.end.rowIndex;
+  const changeEndColumnIndex = change.end.columnIndex;
+  for (let i = 0; i < autoClosingRanges.length; i += 4) {
+    const autoStartRowIndex = autoClosingRanges[i];
+    const autoStartColumnIndex = autoClosingRanges[i + 1];
+    const autoEndRowIndex = autoClosingRanges[i + 2];
+    const autoEndColumnIndex = autoClosingRanges[i + 3];
+    if (changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex === autoEndColumnIndex) {
+      const delta = change.inserted[0].length - change.deleted[0].length;
+      newAutoClosingRanges.push(autoStartRowIndex, autoStartColumnIndex, autoEndRowIndex, autoEndColumnIndex + delta);
+    } else if (changeStartRowIndex === autoStartRowIndex && changeStartColumnIndex >= autoStartColumnIndex && changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex <= autoEndColumnIndex) {
+      const delta = change.inserted[0].length - change.deleted[0].length;
+      newAutoClosingRanges.push(autoStartRowIndex, autoStartColumnIndex, autoEndRowIndex, autoEndColumnIndex + delta);
+    } else ;
+  }
+  if (isAutoClosingChange(change)) {
+    newAutoClosingRanges.push(changeStartRowIndex, changeStartColumnIndex + 1, changeEndRowIndex, changeEndColumnIndex + 1);
+  }
+  return newAutoClosingRanges;
+};
+
+// @ts-ignore
+const scheduleSelections = (editor, selectionEdits) => {
+  return setSelections(editor, selectionEdits);
+};
+
+/**
+ *
+ * @param {any} editor
+ * @param {any[]} changes
+ * @param {Uint32Array|undefined} selectionChanges
+ * @returns
+ */
+// @ts-ignore
+const scheduleDocumentAndCursorsSelections = (editor, changes, selectionChanges = undefined) => {
+  object(editor);
+  array(changes);
+  if (changes.length === 0) {
+    return editor;
+  }
+  const newLines = applyEdits(editor, changes);
+  const partialNewEditor = {
+    ...editor,
+    lines: newLines
+  };
+  const newSelections = selectionChanges || applyEdit(partialNewEditor, changes);
+  // TODO should separate rendering from business logic somehow
+  // currently hard to test because need to mock editor height, top, left,
+  // invalidStartIndex, lineCache, etc. just for testing editorType
+  const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex);
+
+  // TODO maybe put undostack into indexeddb so that there is no memory leak in application
+  // then clear old undostack from indexeddb after 3 days
+  // TODO should push to undostack after rendering
+  const autoClosingRanges = applyAutoClosingRangesEdit(editor, changes);
+  const newEditor = {
+    ...partialNewEditor,
+    lines: newLines,
+    selections: newSelections,
+    undoStack: [...editor.undoStack, changes],
+    invalidStartIndex,
+    autoClosingRanges
+  };
+  return newEditor;
+};
+
+// @ts-ignore
+const hasSelection = editor => {
+  // TODO editor.selections should always be defined
+  return editor.selections && editor.selections.length > 0;
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const cancelSelection = editor => {
+  const selections = editor.selections;
+  if (selections.length === 4 && selections[0] === selections[2] && selections[1] === selections[3]) {
+    return editor;
+  }
+  const newSelections = alloc(4);
+  moveRangeToPosition$1(newSelections, 0, selections[0], selections[1]);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const state$6 = {
+  isComposing: false,
+  compositionText: ''
+};
+
+// @ts-ignore
+const compositionStart = (editor, event) => {
+  state$6.isComposing = true;
+  return editor;
+};
+
+// @ts-ignore
+const getCompositionChanges = (selections, data) => {
+  const changes = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    const startColumnIndex = selectionStartColumn - state$6.compositionText.length;
+    changes.push({
+      start: {
+        rowIndex: selectionStartRow,
+        columnIndex: startColumnIndex
+      },
+      end: {
+        rowIndex: selectionEndRow,
+        columnIndex: selectionEndColumn
+      },
+      inserted: [data],
+      deleted: [state$6.compositionText],
+      origin: CompositionUpdate
+    });
+  }
+  return changes;
+};
+
+// @ts-ignore
+const compositionUpdate = (editor, data) => {
+  const selections = editor.selections;
+  const changes = getCompositionChanges(selections, data);
+  state$6.compositionText = data;
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+const compositionEnd = (editor, data) => {
+  const selections = editor.selections;
+  const changes = getCompositionChanges(selections, data);
+  state$6.isComposing = false;
+  state$6.compositionText = '';
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+const state$5 = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined
+};
+const get = () => {
+  return state$5.ipc;
+};
+const set = ipc => {
+  state$5.ipc = ipc;
+};
+
+const Two = '2.0';
+
+const state$4 = {
+  id: 0
+};
+const create$2 = () => {
+  return ++state$4.id;
+};
+
+const warn = (...args) => {
+  console.warn(...args);
+};
+
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+
+const state$3 = {
+  callbacks: Object.create(null)
+};
+const registerPromise = () => {
+  const id = create$2();
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  state$3.callbacks[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const resolve = (id, args) => {
+  number(id);
+  if (!(id in state$3.callbacks)) {
+    console.log(args);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  state$3.callbacks[id](args);
+  delete state$3.callbacks[id];
+};
+
+const create$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+
+// @ts-ignore
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+
+const MethodNotFound = -32601;
+const Custom = -32001;
+
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const recreateStack = (message, stack) => {
+  if (message && !stack.includes(message)) {
+    return message + NewLine + stack;
+  }
+  return stack;
+};
+const getErrorType = error => {
+  if (error && error.type) {
+    return error.type;
+  }
+  if (error && error.data && error.data.type) {
+    return error.data.type;
+  }
+  return '';
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    restoredError.stack = error.stack || error.data || '';
+    return restoredError;
+  }
+  if (error && error.message) {
+    const type = getErrorType(error);
+    const restoredError = constructError(error.message, type, error.name);
+    const currentStack = joinLines(splitLines(new Error().stack).slice(1));
+    if (error.data) {
+      if (error.data.stack && type && error.message) {
+        restoredError.stack = type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = recreateStack(error.message, error.data.stack) + NewLine + currentStack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+    } else if (error.stack) {
+      // @ts-ignore
+      restoredError.stack = recreateStack(error.message, error.stack) + NewLine + currentStack;
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  console.log({
+    error
+  });
+  return new Error(`JsonRpc Error: Unknown Error`);
+};
+
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+
+const invoke$2 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$1(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+
+const invoke$1 = (method, ...params) => {
+  const ipc = get();
+  return invoke$2(ipc, method, ...params);
+};
+const listen$6 = ipc => {
+  set(ipc);
+};
+
+/**
+ *
+ * @param {string} method
+ * @param  {...any} params
+ * @returns {Promise<any>}
+ */
+const invoke = async (method, ...params) => {
+  return invoke$1(method, ...params);
+};
+
+/**
+ *
+ * @param {string} string
+ * @param {number|undefined} startIndex
+ * @returns
+ */
+// @ts-ignore
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf('\n', startIndex);
+};
+
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length);
+  }
+  return line;
+};
+
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex(parent);
+  const childNewLineIndex = getNewLineIndex(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+
+// @ts-nocheck
+const stringifyError = error => {
+  if (error instanceof DOMException && error.message) {
+    return `DOMException: ${error.message}`;
+  }
+  const errorPrefixes = ['Error: ', 'VError: '];
+  const stringifiedError = `${error}`;
+  for (const errorPrefix of errorPrefixes) {
+    if (stringifiedError.startsWith(errorPrefix)) {
+      return stringifiedError.slice(errorPrefix.length);
+    }
+  }
+  return stringifiedError;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = stringifyError(error);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return `${stringifiedError}`;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame;
+    }
+  }
+}
+
+// @ts-ignore
+const writeText = async text => {
+  try {
+    string(text);
+    await invoke('ClipBoard.writeText', /* text */text);
+  } catch (error) {
+    throw new VError(error, 'Failed to write text to clipboard');
+  }
+};
+
+// @ts-ignore
+const getSelectionRange = (lines, copyFullLine, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  if (copyFullLine) {
+    const lineLength = lines[endRowIndex].length;
+    return {
+      start: {
+        rowIndex: startRowIndex,
+        columnIndex: 0
+      },
+      end: {
+        rowIndex: startRowIndex,
+        columnIndex: lineLength
+      }
+    };
+  }
+  return {
+    start: {
+      rowIndex: startRowIndex,
+      columnIndex: startColumnIndex
+    },
+    end: {
+      rowIndex: endRowIndex,
+      columnIndex: endColumnIndex
+    }
+  };
+};
+
+// @ts-ignore
+const shouldCopyFullLine = (startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  return startRowIndex === endRowIndex && startColumnIndex === endColumnIndex;
+};
+
+// @ts-ignore
+const copy = async editor => {
+  if (!hasSelection(editor)) {
+    // TODO copy line where cursor is
+    return editor;
+  }
+  const {
+    lines,
+    selections
+  } = editor;
+  const selectionStartRowIndex = selections[0];
+  const selectionStartColumnIndex = selections[1];
+  const selectionEndRowIndex = selections[2];
+  const selectionEndColumnIndex = selections[3];
+  const copyFullLine = shouldCopyFullLine(selectionStartRowIndex, selectionStartColumnIndex, selectionEndRowIndex, selectionEndColumnIndex);
+  const range = getSelectionRange(lines, copyFullLine, selectionStartRowIndex, selectionStartColumnIndex, selectionEndRowIndex, selectionEndColumnIndex);
+  const selectedLines = getSelectionText(editor, range);
+  const text = joinLines(selectedLines);
+  const fullText = copyFullLine ? '\n' + text : text;
+  await writeText(fullText);
+  return editor;
+};
+
+// TODO handle multiline selection
+// TODO handle multiple cursors
+
+// @ts-ignore
+const copyLineDown = editor => {
+  const {
+    selections,
+    primarySelectionIndex
+  } = editor;
+  const rowIndex = selections[primarySelectionIndex];
+  number(rowIndex);
+  const position = {
+    rowIndex,
+    columnIndex: 0
+  };
+  const changes = [{
+    inserted: [getLine(editor, rowIndex), ''],
+    deleted: [''],
+    start: position,
+    end: position
+  }];
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const copyLineUp = editor => {
+  const {
+    selections,
+    primarySelectionIndex
+  } = editor;
+  const rowIndex = selections[primarySelectionIndex];
+  const position = {
+    rowIndex: rowIndex,
+    columnIndex: 0
+  };
+  const changes = [{
+    start: position,
+    end: position,
+    inserted: [getLine(editor, rowIndex), ''],
+    deleted: ['']
+  }];
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+const editorGetPositionLeft = (rowIndex, columnIndex, lines, getDelta) => {
+  if (columnIndex === 0) {
+    if (rowIndex === 0) {
+      return {
+        rowIndex: 0,
+        columnIndex: 0
+      };
+    }
+    return {
+      rowIndex: rowIndex - 1,
+      columnIndex: lines[rowIndex - 1].length
+    };
+  }
+  const delta = getDelta(lines[rowIndex], columnIndex);
+  return {
+    rowIndex,
+    columnIndex: columnIndex - delta
+  };
+};
+
+// @ts-ignore
+const moveToPositionEqual = (selections, i, rowIndex, columnIndex) => {
+  selections[i] = rowIndex;
+  selections[i + 1] = columnIndex;
+};
+
+// @ts-ignore
+const moveRangeToPosition = (selections, i, rowIndex, columnIndex) => {
+  selections[i] = selections[i + 2] = rowIndex;
+  selections[i + 1] = selections[i + 3] = columnIndex;
+};
+
+// @ts-ignore
+const moveToPositionLeft = (selections, i, rowIndex, columnIndex, lines, getDelta) => {
+  if (columnIndex === 0) {
+    if (rowIndex === 0) {
+      selections[i] = 0;
+      selections[i + 1] = 0;
+    } else {
+      selections[i] = rowIndex - 1;
+      selections[i + 1] = lines[rowIndex - 1].length;
+    }
+  } else {
+    const delta = getDelta(lines[rowIndex], columnIndex);
+    selections[i] = rowIndex;
+    selections[i + 1] = columnIndex - delta;
+  }
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getNewSelections$9 = (selections, lines, getDelta) => {
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    if (selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn) {
+      if (selectionStartRow === 0 && selectionStartColumn === 0) {
+        newSelections[i] = 0;
+        newSelections[i + 1] = 0;
+        newSelections[i + 2] = 0;
+        newSelections[i + 3] = 0;
+      } else {
+        moveToPositionLeft(newSelections, i, selectionStartRow, selectionStartColumn, lines, getDelta);
+        moveToPositionLeft(newSelections, i + 2, selectionStartRow, selectionStartColumn, lines, getDelta);
+      }
+    } else {
+      moveRangeToPosition(newSelections, i, selections[i], selections[i + 1]);
+    }
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const editorCursorHorizontalLeft = (editor, getDelta) => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getNewSelections$9(selections, lines, getDelta);
+  return scheduleSelections(editor, newSelections);
+};
+
+const supported = () => {
+  return 'Segmenter' in Intl;
+};
+const create = () => {
+  // @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;
+        }
+        currentVisualIndex++;
+      }
+      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++;
+      }
+      return line.length;
+    },
+    getSegments(line) {
+      return segmenter.segment(line);
+    }
+  };
+};
+
+// @ts-ignore
+const characterLeft = (line, columnIndex) => {
+  if (!supported()) {
+    return 1;
+  }
+  const segmenter = create();
+  const last = segmenter.at(line, columnIndex - 1);
+  return columnIndex - last.index;
+};
+const twoCharactersLeft = () => {
+  return 2;
+};
+
+// @ts-ignore
+const characterRight = (line, columnIndex) => {
+  if (!supported()) {
+    return 1;
+  }
+  const segmenter = create();
+  const next = segmenter.at(line, columnIndex);
+  return next.segment.length;
+};
+
+// @ts-ignore
+const isWhitespace = char => {
+  return char === Space || char === Tab;
+};
+
+// @ts-ignore
+const lineCharacterStart = (line, columnIndex) => {
+  if (line.length === 0) {
+    return 0;
+  }
+  for (let i = 0; i < columnIndex; i++) {
+    if (!isWhitespace(line[i])) {
+      return columnIndex - i;
+    }
+  }
+  return columnIndex;
+};
+
+// @ts-ignore
+const lineEnd = (line, columnIndex) => {
+  return line.length - columnIndex;
+};
+
+// @ts-ignore
+const tryRegexArray = (partialLine, regexArray) => {
+  for (const regex of regexArray) {
+    const match = partialLine.match(regex);
+    if (match) {
+      return match[0].length;
+    }
+  }
+  return 1;
+};
+const RE_WORD_LEFT_1 = /(?<![A-Z])[A-Z]+\s*$/;
+const RE_WORD_LEFT_2 = /[\u00C0-\u017F\w\-]+>?\s*$/;
+const RE_WORD_LEFT_3 = /[a-zA-Z]+[^a-zA-Z\d]+\s*$/;
+const RE_WORD_LEFT_4 = /\s+$/;
+const RE_WORD_LEFT_5 = /[^a-zA-Z\d]+\s*$/;
+const RE_WORD_LEFT = [RE_WORD_LEFT_1, RE_WORD_LEFT_2, RE_WORD_LEFT_3, RE_WORD_LEFT_4, RE_WORD_LEFT_5];
+
+// @ts-ignore
+const wordLeft = (line, columnIndex) => {
+  const partialLine = line.slice(0, columnIndex);
+  return tryRegexArray(partialLine, RE_WORD_LEFT);
+};
+const RE_WORD_RIGHT_1 = /^\s*[\u00C0-\u017F\w]+/i;
+const RE_WORD_RIGHT_2 = /^[^a-zA-Z\d]+\w*/;
+const RE_WORD_RIGHT = [RE_WORD_RIGHT_1, RE_WORD_RIGHT_2];
+
+// @ts-ignore
+const wordRight = (line, columnIndex) => {
+  const partialLine = line.slice(columnIndex);
+  return tryRegexArray(partialLine, RE_WORD_RIGHT);
+};
+const RE_PARTIAL_WORD_LEFT_1 = /(?<![A-Z])[A-Z]{2}[a-z]+$/;
+const RE_PARTIAL_WORD_LEFT_2 = /(?=[A-Z]+)[A-Z][a-z]+$/;
+const RE_PARTIAL_WORD_LEFT_3 = /[A-Z]+[a-z]+\d?\s*$/;
+const RE_PARTIAL_WORD_LEFT_4 = /[A-Z]+\d*\s*$/;
+const RE_PARTIAL_WORD_LEFT_5 = /[a-z]+\d*\s*$/;
+const RE_PARTIAL_WORD_LEFT_6 = /[A-Z]*[a-z]+_+\s*$/;
+const RE_PARTIAL_WORD_LEFT_7 = /(?<![A-Z])[A-Z]_+\s*$/;
+const RE_PARTIAL_WORD_LEFT_8 = /[a-z]+\s*$/;
+const RE_PARTIAL_WORD_LEFT_9 = /[^a-zA-Z\d\s]+\s*$/;
+const RE_PARTIAL_WORD_LEFT = [RE_PARTIAL_WORD_LEFT_1, RE_PARTIAL_WORD_LEFT_2, RE_PARTIAL_WORD_LEFT_3, RE_PARTIAL_WORD_LEFT_4, RE_PARTIAL_WORD_LEFT_5, RE_PARTIAL_WORD_LEFT_6, RE_PARTIAL_WORD_LEFT_7, RE_PARTIAL_WORD_LEFT_8, RE_PARTIAL_WORD_LEFT_9];
+
+// @ts-ignore
+const wordPartLeft = (line, columnIndex) => {
+  const partialLine = line.slice(0, columnIndex);
+  return tryRegexArray(partialLine, RE_PARTIAL_WORD_LEFT);
+};
+const RE_PARTIAL_WORD_RIGHT_1 = /^\s*[a-z]+\d?/;
+const RE_PARTIAL_WORD_RIGHT_2 = /^\s*[A-Z]{2}[a-z\d]+/;
+const RE_PARTIAL_WORD_RIGHT_3 = /^\s*[A-Z]+(?=[A-Z][a-z]+)/;
+const RE_PARTIAL_WORD_RIGHT_4 = /^\s*[A-Z]+[a-z]*\d*/;
+const RE_PARTIAL_WORD_RIGHT_5 = /^\s*_+[a-z]*\d?/;
+const RE_PARTIAL_WORD_RIGHT_6 = /^\s*[^\da-zA-Z\s]+/;
+// const RE_PARTIAL_WORD_RIGHT_6 = /^\s*[A-Z][A-Z](?![A-Z])*/
+// const RE_PARTIAL_WORD_RIGHT_7 = /^\s*[A-Z][A-Z][a-z]*/
+
+const ARRAY_PARTIAL_WORD_RIGHT_1 = [RE_PARTIAL_WORD_RIGHT_1,
+// RE_PARTIAL_WORD_RIGHT_2,
+RE_PARTIAL_WORD_RIGHT_3, RE_PARTIAL_WORD_RIGHT_4, RE_PARTIAL_WORD_RIGHT_5, RE_PARTIAL_WORD_RIGHT_6];
+const ARRAY_PARTIAL_WORD_RIGHT_2 = [RE_PARTIAL_WORD_RIGHT_1, RE_PARTIAL_WORD_RIGHT_2, RE_PARTIAL_WORD_RIGHT_3, RE_PARTIAL_WORD_RIGHT_4, RE_PARTIAL_WORD_RIGHT_5, RE_PARTIAL_WORD_RIGHT_6];
+const RE_UPPERCASE = /[A-Z]/;
+
+// @ts-ignore
+const wordPartRight = (line, columnIndex) => {
+  const partialLine = line.slice(columnIndex);
+  // line[columnIndex]//?
+  if (RE_UPPERCASE.test(line[columnIndex - 1])) {
+    return tryRegexArray(partialLine, ARRAY_PARTIAL_WORD_RIGHT_1);
+  }
+  return tryRegexArray(partialLine, ARRAY_PARTIAL_WORD_RIGHT_2);
+};
+
+// @ts-ignore
+const cursorCharacterLeft = editor => {
+  return editorCursorHorizontalLeft(editor, characterLeft);
+};
+
+// @ts-ignore
+const editorGetPositionRight = (position, lines, getDelta) => {
+  const rowIndex = position.rowIndex;
+  const columnIndex = position.columnIndex;
+  if (columnIndex >= lines[rowIndex].length) {
+    if (rowIndex >= lines.length) {
+      return position;
+    }
+    return {
+      rowIndex: rowIndex + 1,
+      columnIndex: 0
+    };
+  }
+  const delta = getDelta(lines[rowIndex], columnIndex);
+  return {
+    rowIndex,
+    columnIndex: columnIndex + delta
+  };
+};
+
+// @ts-ignore
+const moveToPositionRight = (selections, i, rowIndex, columnIndex, lines, getDelta) => {
+  if (rowIndex >= lines.length) {
+    return;
+  }
+  const line = lines[rowIndex];
+  if (columnIndex >= line.length) {
+    selections[i] = selections[i + 2] = rowIndex + 1;
+    selections[i + 1] = selections[i + 3] = 0;
+  } else {
+    const delta = getDelta(line, columnIndex);
+    selections[i] = selections[i + 2] = rowIndex;
+    selections[i + 1] = selections[i + 3] = columnIndex + delta;
+  }
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getNewSelections$8 = (selections, lines, getDelta) => {
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    if (selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn) {
+      moveToPositionRight(newSelections, i, selectionStartRow, selectionStartColumn, lines, getDelta);
+    } else {
+      newSelections[i] = newSelections[i + 2] = selectionEndRow;
+      newSelections[i + 1] = newSelections[i + 3] = selectionEndColumn;
+    }
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const editorCursorHorizontalRight = (editor, getDelta) => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getNewSelections$8(selections, lines, getDelta);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const cursorCharacterRight = editor => {
+  return editorCursorHorizontalRight(editor, characterRight);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const moveSelectionDown = (selections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  moveRangeToPosition$1(selections, i, selectionEndRow + 1, selectionEndColumn);
+};
+
+// @ts-ignore
+const getNewSelections$7 = selections => {
+  return map(selections, moveSelectionDown);
+};
+
+// @ts-ignore
+const cursorDown = editor => {
+  const selections = editor.selections;
+  const newSelections = getNewSelections$7(selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const cursorEnd = editor => {
+  return editorCursorHorizontalRight(editor, lineEnd);
+};
+
+// @ts-ignore
+const cursorHome = editor => {
+  return editorCursorHorizontalLeft(editor, lineCharacterStart);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const moveSelectionWithoutIntlSegmenter = (selections, i, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+  if (selectionStartRow === 0) {
+    moveRangeToPosition$1(selections, i, 0, 0);
+  } else {
+    moveRangeToPosition$1(selections, i, selectionStartRow - 1, selectionStartColumn);
+  }
+};
+
+// @ts-ignore
+const getNewSelections$6 = selections => {
+  return map(selections, moveSelectionWithoutIntlSegmenter);
+};
+
+// @ts-ignore
+const cursorVertical = (editor, getPosition, getEdgePosition, delta) => {
+  // if (TextSegmenter.supported()) {
+  //   return editorCursorsVerticalWithIntlSegmenter(
+  //     editor,
+  //     getPosition,
+  //     getEdgePosition,
+  //     delta
+  //   )
+  // }
+  const selections = editor.selections;
+  // @ts-ignore
+  const newSelections = getNewSelections$6(selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const cursorUp = editor => {
+  return cursorVertical(editor);
+};
+
+// TODO put all of these into editor -> also makes extracting editor into standalone npm package easier (no 20+ modules, just single ~10kB bundle)
+// also can share code between moveCursorWordRight moveCursoryWordLeft deleteCursorWordLeft
+
+// @ts-ignore
+const cursorWordLeft = editor => {
+  return editorCursorHorizontalLeft(editor, wordLeft);
+};
+
+// @ts-ignore
+const cursorWordPartLeft = editor => {
+  return editorCursorHorizontalLeft(editor, wordPartLeft);
+};
+
+// @ts-ignore
+const cursorWordPartRight = editor => {
+  return editorCursorHorizontalRight(editor, wordPartRight);
+};
+
+// @ts-ignore
+const cursorWordRight = editor => {
+  return editorCursorHorizontalRight(editor, wordRight);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+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;
+};
+
+// @ts-ignore
+const cutLine = async editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const [startRowIndex] = selections;
+  const line = lines[startRowIndex];
+  const replaceRange$1 = new Uint32Array([startRowIndex, 0, startRowIndex, line.length]);
+  const changes = replaceRange(editor, replaceRange$1, [''], EditorCut);
+  const selectionChanges = new Uint32Array([startRowIndex, 0, startRowIndex, 0]);
+  await writeText(line);
+  // @ts-ignore
+  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
+};
+
+// @ts-ignore
+const editorReplaceSelections = (editor, replacement, origin) => {
+  const {
+    selections
+  } = editor;
+  return replaceRange(editor, selections, replacement, origin);
+};
+
+// @ts-ignore
+const cutSelectedText = async editor => {
+  const {
+    selections
+  } = editor;
+  const [startRowIndex, startColumnIndex, endRowIndex, endColumnIndex] = selections;
+  const changes = editorReplaceSelections(editor, [''], EditorCut);
+  const selectionChanges = new Uint32Array([startRowIndex, startColumnIndex, endRowIndex, endColumnIndex]);
+  // @ts-ignore
+  const text = joinLines(changes[0].deleted);
+  // TODO remove selected text from document
+  await writeText(text);
+  // @ts-ignore
+  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
+};
+
+// @ts-ignore
+const cut = editor => {
+  const {
+    selections
+  } = editor;
+  const [startRowIndex, startColumnIndex, endRowIndex, endColumnIndex] = selections;
+  if (isEmpty(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex)) {
+    return cutLine(editor);
+  }
+  return cutSelectedText(editor);
+};
+
+// TODO optimize this function by profiling and not allocating too many objects
+// @ts-ignore
+const getChanges$3 = (lines, selections, getDelta) => {
+  const changes = [];
+  // @ts-ignore
+  const deleteSelection = (selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn) => {
+    const positionLeft = editorGetPositionLeft(selectionStartRow, selectionStartColumn, lines, getDelta);
+    const selectionEnd = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn
+    };
+    changes.push({
+      start: positionLeft,
+      end: selectionEnd,
+      inserted: [''],
+      deleted: getSelectionText({
+        lines
+      }, {
+        start: positionLeft,
+        end: selectionEnd
+      }),
+      origin: Delete
+    });
+  };
+  forEach(selections, deleteSelection);
+  return changes;
+};
+
+const isAutoClosingPairDelete = (autoClosingRanges, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
+  if (!isEmpty(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex)) {
+    return false;
+  }
+  if (startColumnIndex < 1) {
+    return false;
+  }
+  for (let j = 0; j < autoClosingRanges.length; j += 4) {
+    const autoStartRowIndex = autoClosingRanges[j];
+    const autoStartColumnIndex = autoClosingRanges[j + 1];
+    // const autoEndRowIndex = autoClosingRanges[j + 2]
+    // const autoEndColumnIndex = autoClosingRanges[j + 3]
+    if (startRowIndex === autoStartRowIndex && startColumnIndex === autoStartColumnIndex) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const isAllAutoClosingPairDelete = (autoClosingRanges, selections) => {
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    if (!isAutoClosingPairDelete(autoClosingRanges, selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const deleteLeftWithAutoClose = editor => {
+  const {
+    selections,
+    lines
+  } = editor;
+  for (let i = 0; i < selections.length; i += 4) {
+    selections[i + 1]++;
+    selections[i + 3]++;
+  }
+  const changes = getChanges$3(lines, selections, twoCharactersLeft);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+const editorDeleteHorizontalLeft = (editor, getDelta) => {
+  const {
+    autoClosingRanges = [],
+    selections,
+    lines
+  } = editor;
+  if (isAllAutoClosingPairDelete(autoClosingRanges, selections)) {
+    return deleteLeftWithAutoClose(editor);
+  }
+  if (isEverySelectionEmpty(selections)) {
+    const changes = getChanges$3(lines, selections, getDelta);
+    return scheduleDocumentAndCursorsSelections(editor, changes);
+  }
+  const changes = editorReplaceSelections(editor, [''], Delete);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+const deleteAllLeft = editor => {
+  return editorDeleteHorizontalLeft(editor, lineCharacterStart);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getChanges$2 = (editor, getDelta) => {
+  const selections = editor.selections;
+  if (isEverySelectionEmpty(selections)) {
+    const changes = [];
+    const lines = editor.lines;
+    for (let i = 0; i < selections.length; i += 4) {
+      // @ts-ignore
+      const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+      const start = {
+        rowIndex: selectionStartRow,
+        columnIndex: selectionStartColumn
+      };
+      const positionRight = editorGetPositionRight(start, lines, getDelta);
+      changes.push({
+        start: start,
+        end: positionRight,
+        inserted: [''],
+        deleted: getSelectionText(editor, {
+          start: start,
+          end: positionRight
+        }),
+        origin: DeleteHorizontalRight
+      });
+    }
+    return changes;
+  }
+  const changes = editorReplaceSelections(editor, [''], DeleteHorizontalRight);
+  return changes;
+};
+
+// @ts-ignore
+const editorDeleteHorizontalRight = (editor, getDelta) => {
+  const changes = getChanges$2(editor, getDelta);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+const deleteAllRight = editor => {
+  return editorDeleteHorizontalRight(editor, lineEnd);
+};
+
+// @ts-ignore
+const deleteCharacterLeft = editor => {
+  const newEditor = editorDeleteHorizontalLeft(editor, characterLeft);
+  return {
+    newState: newEditor,
+    commands: []
+  };
+};
+
+// @ts-ignore
+const deleteCharacterRight = editor => {
+  return editorDeleteHorizontalRight(editor, characterRight);
+};
+
+// @ts-ignore
+const deleteWordLeft = editor => {
+  const newEditor = editorDeleteHorizontalLeft(editor, wordLeft);
+  return {
+    newState: newEditor,
+    commands: []
+  };
+};
+
+// @ts-ignore
+const deleteWordPartLeft = editor => {
+  const newEditor = editorDeleteHorizontalLeft(editor, wordPartLeft);
+  return {
+    newState: newEditor,
+    commands: []
+  };
+};
+
+// @ts-ignore
+const deleteWordPartRight = editor => {
+  editorDeleteHorizontalRight(editor, wordPartRight);
+};
+
+// @ts-ignore
+const deleteWordRight = editor => {
+  return editorDeleteHorizontalRight(editor, wordRight);
+};
+
+const state$2 = {
+  commands: Object.create(null)
+};
+
+// @ts-ignore
+const registerCommand = (key, fn) => {
+  state$2.commands[key] = fn;
+};
+
+// @ts-ignore
+const registerCommands = commandMap => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+
+// @ts-ignore
+const getCommand = key => {
+  return state$2.commands[key];
+};
+
+const processName = 'terminal-worker';
+
+// @ts-ignore
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`[${processName}] command not found ${command}`);
+  }
+  return fn(...args);
+};
+
+const Editor = 3;
+
+// @ts-ignore
+const handleContextMenu = async (editor, button, x, y) => {
+  await execute( /* ContextMenu.show */'ContextMenu.show', /* x */x, /* y */y, /* id */Editor);
+  return editor;
+};
+
+// @ts-ignore
+
+// match all words, including umlauts, see https://stackoverflow.com/questions/5436824/matching-accented-characters-with-javascript-regexes/#answer-11550799
+const RE_WORD_START$1 = /^[a-z\u00C0-\u017F\d]+/i;
+const RE_WORD_END$1 = /[a-z\u00C0-\u017F\d]+$/i;
+
+// @ts-ignore
+const getNewSelections$5 = (line, rowIndex, columnIndex) => {
+  const before = line.slice(0, columnIndex);
+  const after = line.slice(columnIndex);
+  const beforeMatch = before.match(RE_WORD_END$1);
+  const afterMatch = after.match(RE_WORD_START$1);
+  const columnStart = columnIndex - (beforeMatch ? beforeMatch[0].length : 0);
+  const columnEnd = columnIndex + (afterMatch ? afterMatch[0].length : 0);
+  const newSelections = new Uint32Array([rowIndex, columnStart, rowIndex, columnEnd]);
+  return newSelections;
+};
+
+// @ts-ignore
+const selectWord = (editor, rowIndex, columnIndex) => {
+  const line = getLine(editor, rowIndex);
+  const newSelections = getNewSelections$5(line, rowIndex, columnIndex);
+  return scheduleSelections(editor, newSelections);
+};
+
+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;
+    }
+  }
+  return line.length;
+};
+
+// @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;
+    }
+  }
+  return line.length;
+};
+
+const RE_ASCII = /^[\p{ASCII}]*$/u;
+const isAscii = line => {
+  return RE_ASCII.test(line);
+};
+
+// @ts-ignore
+const guessOffset = (eventX, averageCharWidth) => {
+  const guess = Math.round(eventX / averageCharWidth);
+  return guess;
+};
+
+// @ts-ignore
+const normalizeGuess = (line, guess, tabSize) => {
+  let normalizedGuess = guess;
+  for (let i = 0; i < guess; i++) {
+    if (line[i] === Tab) {
+      normalizedGuess -= tabSize - 1;
+    }
+  }
+  return normalizedGuess;
+};
+
+// @ts-ignore
+const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
+  string(line);
+  number(fontWeight);
+  number(fontSize);
+  string(fontFamily);
+  number(letterSpacing);
+  boolean(isMonospaceFont);
+  number(charWidth);
+  number(tabSize);
+  number(eventX);
+  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);
+  }
+  return getAccurateColumnIndexUnicode(line, normalizedGuess, charWidth, eventX, fontWeight, fontSize, fontFamily, letterSpacing);
+};
+
+// @ts-ignore
+const at = (editor, eventX, eventY) => {
+  object(editor);
+  number(eventX);
+  number(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
+    };
+  }
+  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
+  };
+};
+
+// @ts-ignore
+const handleDoubleClick = (editor, modifier, x, y) => {
+  const position = at(editor, x, y);
+  return {
+    newState: selectWord(editor, position.rowIndex, position.columnIndex),
+    commands: []
+  };
+};
+
+const Single = 1;
+const Double = 2;
+const Triple = 3;
+
+const Ctrl = 1;
+const Alt = 2;
+
+// @ts-ignore
+const getDefinition = async (editor, offset) => {
+  const definition = await invoke('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'
+};
+const noDefinitionFound = () => {
+  return i18nString(UiStrings.NoDefinitionFound);
+};
+
+// @ts-ignore
+const noDefinitionFoundFor = word => {
+  return i18nString(UiStrings.NoDefinitionFoundFor, {
+    PH1: word
+  });
+};
+
+const RE_WORD_START = /^\w+/;
+const RE_WORD_END = /\w+$/;
+
+// @ts-ignore
+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);
+  const after = line.slice(columnIndex);
+  const matchAfter = after.match(RE_WORD_START);
+  let word = EmptyString;
+  if (matchBefore) {
+    word += matchBefore[0];
+  }
+  if (matchAfter) {
+    word += matchAfter[0];
+  }
+  return {
+    word
+  };
+};
+
+// @ts-ignore
+// import * as RendererProcess from '../RendererProcess/RendererProcess.ts'
+
+const state$1 = {
+  timeout: -1
+};
+
+/**
+ *
+ * @param {any} editor
+ * @param {number} rowIndex
+ * @param {number} columnIndex
+ * @param {string} message
+ * @param {boolean} isError
+ * @returns
+ */
+// @ts-ignore
+const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError) => {
+  object(editor);
+  number(rowIndex);
+  number(columnIndex);
+  string(message);
+  // await RendererProcess.invoke(
+  //   /* Viewlet.send */ 'Viewlet.send',
+  //   /* id */ editor.uid,
+  //   /* method */ 'showOverlayMessage',
+  //   /* x */ x,
+  //   /* y */ y,
+  //   /* content */ displayErrorMessage,
+  // )
+
+  if (!isError) {
+    const handleTimeout = () => {
+      editorHideMessage(editor);
+    };
+
+    // TODO use wrapper timing module instead of this
+    // @ts-ignore
+    state$1.timeout = setTimeout(handleTimeout, 3_000);
+  }
+  return editor;
+};
+
+// @ts-ignore
+const editorHideMessage = async editor => {
+  clearTimeout(state$1.timeout);
+  state$1.timeout = -1;
+  // await RendererProcess.invoke(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage')
+  return editor;
+};
+
+// @ts-ignore
+const goTo = async ({
+  editor,
+  getLocation,
+  getNoLocationFoundMessage,
+  getErrorMessage,
+  isNoProviderFoundError
+}) => {
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  try {
+    const definition = await getLocation(editor, rowIndex, columnIndex);
+    // TODO if editor is already disposed at this point, do nothing
+    if (!definition) {
+      // TODO show popup that no definition was found
+      // TODO if there was an error, show popup that go to definition resulted in an error
+      const info = getWordAt(editor, rowIndex, columnIndex);
+      const message = getNoLocationFoundMessage(info);
+      return editorShowMessage(editor, rowIndex, columnIndex, message, false);
+    }
+    if (typeof definition.uri !== 'string' || typeof definition.startOffset !== 'number' || typeof definition.endOffset !== 'number') {
+      // Logger.warn('invalid definition result', definition)
+      return editor;
+    }
+    const uri = definition.uri;
+    if (uri === editor.uri) {
+      // TODO set cursor to the definition position
+      const position = positionAt(editor, definition.startOffset);
+      const selectionEdits = new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]);
+      return scheduleSelections(editor, selectionEdits);
+    }
+    // TODO if definition.file is not of type string, show a popup that definition.file must be of type string
+    // TODO open file and scroll to that position and set cursor to that position
+
+    const context = {
+      startRowIndex: definition.startRowIndex,
+      startColumnIndex: definition.startColumnIndex,
+      endRowIndex: definition.endRowIndex,
+      endColumnIndex: definition.endColumnIndex
+    };
+    await execute( /* Main.openUri */'Main.openUri', /* uri */uri, /* focus */true, context);
+    return editor;
+  } catch (error) {
+    // TODO if editor is already disposed at this point, do nothing
+    if (isNoProviderFoundError(error)) {
+      const displayErrorMessage = getErrorMessage(error);
+      await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, false);
+      return editor;
+    }
+    // @ts-ignore
+    // ErrorHandling.handleError(error, false)
+    const displayErrorMessage = getErrorMessage(error);
+    await editorShowMessage(editor, rowIndex, columnIndex, displayErrorMessage, true);
+    return editor;
+  }
+};
+
+// @ts-ignore
+
+// TODO race condition, check that editor hasn't been closed in the meantime
+
+// TODO in case of error should show message "Definition Error: Cannot ready Property x of undefined"
+
+// TODO show some kind of message maybe ("No Definition found")
+
+// TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
+
+// TODO there are still race conditions in this function:
+// - when open is called twice, previous dom nodes can either be reused or the previous dom nodes must be disposed
+
+// @ts-ignore
+const getLocation = async (editor, rowIndex, columnIndex) => {
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const definition = await getDefinition(editor, offset);
+  return definition;
+};
+
+// @ts-ignore
+const getNoLocationFoundMessage = info => {
+  if (info.word) {
+    return noDefinitionFoundFor(info.word);
+  }
+  return noDefinitionFound();
+};
+
+// @ts-ignore
+const getErrorMessage$1 = error => {
+  // if (
+  //   error &&
+  //   error.message &&
+  //   error.message.startsWith('Failed to execute definition provider: ')
+  // ) {
+  //   return error.message.replace('Failed to execute definition provider: ', '')
+  // }
+  return `${error}`;
+};
+
+// @ts-ignore
+const isNoProviderFoundError = error => {
+  return error &&
+  // @ts-ignore
+  error.message &&
+  // @ts-ignore
+  error.message.startsWith('Failed to execute definition provider: No definition provider found');
+};
+
+// @ts-ignore
+const goToDefinition = editor => {
+  return goTo({
+    editor,
+    getLocation,
+    getNoLocationFoundMessage,
+    getErrorMessage: getErrorMessage$1,
+    isNoProviderFoundError
+  });
+};
+
+// TODO first change cursor position, then run go to definition
+// cursor should appear at mousedown position immediately
+// @ts-ignore
+const handleSingleClickWithAlt = async (editor, position) => {
+  const {
+    rowIndex,
+    columnIndex
+  } = position;
+  const newEditor = {
+    ...editor,
+    selections: new Uint32Array([rowIndex, columnIndex, rowIndex, columnIndex])
+  };
+  // TODO rectangular selection with alt click,
+  // but also go to definition with alt click
+  const newEditor2 = await goToDefinition(newEditor);
+  return newEditor2;
+};
+
+// @ts-ignore
+const handleSingleClickWithCtrl = async (editor, position) => {
+  const selections = editor.selections;
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    if (selectionStartRow === position.rowIndex && selectionStartColumn === position.columnIndex && selectionEndRow === position.rowIndex && selectionEndColumn === position.columnIndex) {
+      // selection exists -> remove
+      const newSelections = new Uint32Array(selections.length - 4);
+      newSelections.set(selections.subarray(0, i), 0);
+      newSelections.set(selections.subarray(i + 4), i);
+      return scheduleSelections(editor, newSelections);
+    }
+  }
+  // TODO selection does not exist -> add
+  // TODO insert in order
+  const newSelections = new Uint32Array(selections.length + 4);
+  newSelections.set(selections, 0);
+  const insertIndex = selections.length;
+  newSelections[insertIndex] = position.rowIndex;
+  newSelections[insertIndex + 1] = position.columnIndex;
+  newSelections[insertIndex + 2] = position.rowIndex;
+  newSelections[insertIndex + 3] = position.columnIndex;
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const handleSingleClickDefault = (editor, position) => {
+  return {
+    ...editor,
+    selections: new Uint32Array([position.rowIndex, position.columnIndex, position.rowIndex, position.columnIndex]),
+    focused: true
+  };
+};
+
+// @ts-ignore
+const getFn = modifier => {
+  switch (modifier) {
+    case Alt:
+      return handleSingleClickWithAlt;
+    case Ctrl:
+      return handleSingleClickWithCtrl;
+    default:
+      return handleSingleClickDefault;
+  }
+};
+
+// @ts-ignore
+const handleSingleClick = async (editor, modifier, x, y) => {
+  object(editor);
+  number(modifier);
+  number(x);
+  number(y);
+  const position = at(editor, x, y);
+  const fn = getFn(modifier);
+  const newEditor = await fn(editor, position);
+  // switch (newEditor.completionState) {
+  //   case EditorCompletionState.None:
+  //   case EditorCompletionState.Visible:
+  //   case EditorCompletionState.Loading:
+  //     return {
+  //       newState: newEditor,
+  //       commands: [],
+  //     }
+  //   default:
+  //     break
+  // }
+  return {
+    newState: newEditor,
+    commands: []
+  };
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getNewSelections$4 = (line, rowIndex) => {
+  // TODO handle virtual space when columnIndex is greater than line length
+  return new Uint32Array([rowIndex, 0, rowIndex, line.length]);
+};
+
+// @ts-ignore
+const selectLine = editor => {
+  const selections = editor.selections;
+  const rowIndex = selections[editor.primarySelectionIndex];
+  const line = getLine(editor, rowIndex);
+  const newSelections = getNewSelections$4(line, rowIndex);
+  return scheduleSelections(editor, newSelections);
+};
+
+// TODO rowIndex and columnIndex should already be set because of singleClick which occurred before triple click
+// @ts-ignore
+const handleTripleClick = (editor, modifier, x, y) => {
+  object(editor);
+  number(x);
+  number(y);
+  return {
+    newState: selectLine(editor),
+    commands: []
+  };
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const handleMouseDown = (state, modifier, x, y, detail) => {
+  switch (detail) {
+    case Single:
+      return handleSingleClick(state, modifier, x, y);
+    case Double:
+      return handleDoubleClick(state, modifier, x, y);
+    case Triple:
+      return handleTripleClick(state, modifier, x, y);
+    default:
+      return {
+        newState: state,
+        commands: []
+      };
+  }
+};
+
+const state = {
+  touchOffsetY: 0,
+  deltaY: 0
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const cursorSet = (editor, rowIndex, columnIndex) => {
+  object(editor);
+  number(rowIndex);
+  number(columnIndex);
+  const selectionEdits = fromRange(rowIndex, columnIndex, rowIndex, columnIndex);
+  return scheduleSelections(editor, selectionEdits);
+};
+
+const LONG_TOUCH_THRESHOLD = 150;
+
+// @ts-ignore
+const handleTouchEnd = (editor, touchEvent) => {
+  if (touchEvent.changedTouches.length === 0) {
+    return;
+  }
+  const firstTouch = touchEvent.changedTouches[0];
+  const position = at(editor, firstTouch.x, firstTouch.y);
+  // @ts-ignore
+  if (undefined.position.rowIndex === position.rowIndex && undefined.position.columnIndex === position.columnIndex) {
+    // @ts-ignore
+    if (Date.now() - state.date > LONG_TOUCH_THRESHOLD) {
+      selectWord(editor, position.rowIndex, position.columnIndex);
+    } else {
+      // @ts-ignore
+      cursorSet(editor, position);
+    }
+  } else {
+    console.log('different position');
+  }
+};
+
+// @ts-ignore
+const getChanges$1 = selections => {
+  const changes = [];
+  const rowsToIndentLess = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionEndRow = selections[i + 2];
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndentLess.push(i);
+    }
+  }
+  for (const rowToIndent of rowsToIndentLess) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 2
+      },
+      inserted: [''],
+      deleted: ['  '],
+      origin: IndentLess
+    });
+  }
+  return changes;
+};
+
+// @ts-ignore
+const indentLess = editor => {
+  const selections = editor.selections;
+  const changes = getChanges$1(selections);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getChanges = selections => {
+  const rowsToIndent = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionEndRow = selections[i + 2];
+    for (let i = selectionStartRow; i <= selectionEndRow; i++) {
+      rowsToIndent.push(i);
+    }
+  }
+  const changes = [];
+  for (const rowToIndent of rowsToIndent) {
+    changes.push({
+      start: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      end: {
+        rowIndex: rowToIndent,
+        columnIndex: 0
+      },
+      inserted: ['  '],
+      deleted: [''],
+      origin: IndentMore
+    });
+  }
+  return changes;
+};
+
+// @ts-ignore
+const indentMore = editor => {
+  const selections = editor.selections;
+  const changes = getChanges(selections);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const pasteText = (editor, text) => {
+  const insertedLines = splitLines(text);
+  const changes = editorReplaceSelections(editor, insertedLines, EditorPasteText);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const selectAll = editor => {
+  const lines = editor.lines;
+  const startRowIndex = 0;
+  const startColumnIndex = 0;
+  const endRowIndex = lines.length - 1;
+  const endColumnIndex = lines.at(-1).length;
+  const newSelections = fromRange(startRowIndex, startColumnIndex, endRowIndex, endColumnIndex);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+
+// TODO interleave cursors and selection
+// then loop over selections
+// apply edit
+// if new range is empty -> add cursor
+// else if new range is overlapping -> merge ranges
+// else add cursor and selection
+
+// @ts-ignore
+const getNewSelections$3 = (selections, lines, getDelta) => {
+  const newSelections = clone(selections);
+  for (let i = 0; i < selections.length; i += 4) {
+    // @ts-ignore
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn, reversed] = getSelectionPairs(selections, i);
+    if (selectionStartRow === selectionEndRow && selectionStartColumn === selectionEndColumn) {
+      moveToPositionLeft(newSelections, i + 2, selectionStartRow, selectionStartColumn, lines, getDelta);
+      moveToPositionEqual(newSelections, i, selectionEndRow, selectionEndColumn);
+    } else {
+      moveToPositionLeft(newSelections, i + 2, selectionStartRow, selectionStartColumn, lines, getDelta);
+      moveToPositionEqual(newSelections, i, selectionEndRow, selectionEndColumn);
+    }
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const editorSelectHorizontalLeft = (editor, getDelta) => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getNewSelections$3(selections, lines, getDelta);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const editorSelectAllLeft = editor => {
+  editorSelectHorizontalLeft(editor, lineCharacterStart);
+};
+
+// @ts-ignore
+
+// TODO handle virtual space
+
+// @ts-ignore
+const getNewSelectionsSingleLineWord = (lines, word) => {
+  if (word.length === 0) {
+    throw new Error('word length must be greater than zero');
+  }
+  const newSelections = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let columnIndex = -word.length;
+    while ((columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1) {
+      newSelections.push(i, columnIndex, i, columnIndex + word.length);
+    }
+  }
+  return new Uint32Array(newSelections);
+};
+
+// @ts-ignore
+const isMultiLineMatch = (lines, rowIndex, wordParts) => {
+  let j = 0;
+  if (!lines[rowIndex + j].endsWith(wordParts[j])) {
+    return false;
+  }
+  while (++j < wordParts.length - 1) {
+    if (lines[rowIndex + j] !== wordParts[j]) {
+      return false;
+    }
+  }
+  // j--
+  if (!lines[rowIndex + j].startsWith(wordParts[j])) {
+
+    return false;
+  }
+  return true;
+};
+
+// TODO this is very expensive, there might be a better algorithm for this
+// TODO if this matches the given selections, don't schedule selections/rerender
+// @ts-ignore
+const getAllOccurrencesMultiLine = (lines, wordParts) => {
+  const newSelections = [];
+  for (let rowIndex = 0; rowIndex < lines.length - wordParts.length + 1; rowIndex) {
+    if (isMultiLineMatch(lines, rowIndex, wordParts)) {
+      newSelections.push(rowIndex, lines[rowIndex].length - wordParts[0].length, rowIndex + wordParts.length - 1, wordParts.at(-1).length);
+      rowIndex += wordParts.length - 1;
+    } else {
+      rowIndex++;
+    }
+  }
+  return new Uint32Array(newSelections);
+};
+
+// TODO duplicate code with EditorSelectNextOccurrence
+const RE_ALPHA_NUMERIC$1 = /[a-zA-Z\d]/;
+
+// @ts-ignore
+const isAlphaNumeric$1 = char => {
+  return RE_ALPHA_NUMERIC$1.test(char);
+};
+
+// @ts-ignore
+const getWordStartIndex$1 = (line, index) => {
+  for (let i = index - 1; i >= 0; i--) {
+    if (!isAlphaNumeric$1(line[i])) {
+      return i + 1;
+    }
+  }
+  return 0;
+};
+
+// @ts-ignore
+const getWordEndIndex$1 = (line, index) => {
+  for (let i = index; i < line.length; i++) {
+    if (!isAlphaNumeric$1(line[i])) {
+      return i;
+    }
+  }
+  return line.length - 1;
+};
+
+// @ts-ignore
+const getWordMatchAtPosition$1 = (lines, rowIndex, columnIndex) => {
+  const line = lines[rowIndex];
+  const start = getWordStartIndex$1(line, columnIndex);
+  const end = getWordEndIndex$1(line, columnIndex);
+  const word = line.slice(start, end);
+  return {
+    start,
+    end,
+    word
+  };
+};
+
+// @ts-ignore
+const getNewSelections$2 = (lines, selections) => {
+  if (selections.length < 4) {
+    throw new Error('selections must have at least one entry');
+  }
+  const firstSelectionIndex = 0;
+  const startRowIndex = selections[firstSelectionIndex];
+  const startColumnIndex = selections[firstSelectionIndex + 1];
+  const endRowIndex = selections[firstSelectionIndex + 2];
+  const endColumnIndex = selections[firstSelectionIndex + 3];
+  if (startRowIndex === endRowIndex) {
+    if (startColumnIndex === endColumnIndex) {
+      const wordMatch = getWordMatchAtPosition$1(lines, endRowIndex, endColumnIndex);
+      if (wordMatch.start === wordMatch.end) {
+        return selections;
+      }
+      const newSelections = getNewSelectionsSingleLineWord(lines, wordMatch.word);
+      return newSelections;
+    }
+    const line = lines[startRowIndex];
+    const word = line.slice(startColumnIndex, endColumnIndex);
+    const newSelections = getNewSelectionsSingleLineWord(lines, word);
+    return newSelections;
+  }
+  const wordParts = [];
+  wordParts.push(lines[startRowIndex].slice(startColumnIndex));
+  for (let i = startRowIndex + 1; i < endRowIndex - 1; i++) {
+    wordParts.push(lines[i]);
+  }
+  wordParts.push(lines[endRowIndex].slice(0, endColumnIndex));
+  const newSelections = getAllOccurrencesMultiLine(lines, wordParts);
+  return newSelections;
+};
+
+// @ts-ignore
+const selectAllOccurrences = editor => {
+  // when there are no selections -> first selection is word -> find all selection that include word
+  const lines = editor.lines;
+  const selections = editor.selections;
+  const newSelections = getNewSelections$2(lines, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getNewSelections$1 = (selections, lines, getDelta) => {
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    const line = lines[selectionEndRow];
+    newSelections[i] = selectionStartRow;
+    newSelections[i + 1] = selectionStartColumn;
+    if (selectionEndColumn >= line.length) {
+      newSelections[i + 2] = selectionEndRow + 1;
+      newSelections[i + 3] = 0;
+    } else {
+      const delta = getDelta(line, selectionEndColumn);
+      newSelections[i + 2] = selectionEndRow;
+      newSelections[i + 3] = selectionEndColumn + delta;
+    }
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const editorSelectHorizontalRight = (editor, getDelta) => {
+  const lines = editor.lines;
+  const selections = editor.selections;
+  const newSelections = getNewSelections$1(selections, lines, getDelta);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const editorSelectAllRight = editor => {
+  return editorSelectHorizontalRight(editor, lineEnd);
+};
+
+// @ts-ignore
+const selectCharacterLeft = editor => {
+  return editorSelectHorizontalLeft(editor, characterLeft);
+};
+
+// @ts-ignore
+const selectCharacterRight = editor => {
+  return editorSelectHorizontalRight(editor, characterRight);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getSelectUpChanges$1 = (lines, selections) => {
+  const max = lines.length - 1;
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    newSelections[i] = selectionStartRow;
+    newSelections[i + 1] = selectionStartColumn;
+    newSelections[i + 2] = Math.min(selectionEndRow + 1, max);
+    newSelections[i + 3] = selectionEndColumn;
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const selectDown = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getSelectUpChanges$1(lines, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getSelectionEditsSingleLineWord = (lines, selections) => {
+  const lastSelectionIndex = selections.length - 4;
+  const rowIndex = selections[lastSelectionIndex];
+  const lastSelectionStartColumnIndex = selections[lastSelectionIndex + 1];
+  const lastSelectionEndColumnIndex = selections[lastSelectionIndex + 3];
+  const line = lines[rowIndex];
+  const word = line.slice(lastSelectionStartColumnIndex, lastSelectionEndColumnIndex);
+  const columnIndexAfter = line.indexOf(word, lastSelectionEndColumnIndex);
+  if (columnIndexAfter !== -1) {
+    const columnIndexAfterEnd = columnIndexAfter + word.length;
+    const newSelections = push(selections, rowIndex, columnIndexAfter, rowIndex, columnIndexAfterEnd);
+    return {
+      revealRange: newSelections.length - 4,
+      selectionEdits: newSelections
+    };
+  }
+  for (let i = rowIndex + 1; i < lines.length; i++) {
+    const line = lines[i];
+    const columnIndex = line.indexOf(word);
+    if (columnIndex !== -1) {
+      const columnIndexEnd = columnIndex + word.length;
+      const newSelections = new Uint32Array(selections.length + 4);
+      newSelections.set(selections, 0);
+      const insertIndex = selections.length;
+      newSelections[insertIndex] = i;
+      newSelections[insertIndex + 1] = columnIndex;
+      newSelections[insertIndex + 2] = i;
+      newSelections[insertIndex + 3] = columnIndexEnd;
+      return {
+        revealRange: newSelections.length - 4,
+        selectionEdits: newSelections
+      };
+    }
+  }
+  let selectionIndex = 0;
+  // TODO use text document search for this
+  for (let i = 0; i <= rowIndex; i++) {
+    const line = lines[i];
+    let columnIndex = -word.length;
+    while ((columnIndex = line.indexOf(word, columnIndex + word.length)) !== -1) {
+      let startRowIndex = selections[selectionIndex];
+      while (startRowIndex < i && selectionIndex < selections.length) {
+        selectionIndex += 4;
+        startRowIndex = selections[selectionIndex];
+      }
+      if (startRowIndex === i) {
+        let endColumnIndex = selections[selectionIndex + 3];
+        while (endColumnIndex < columnIndex && selectionIndex < selections.length) {
+          selectionIndex += 4;
+          endColumnIndex = selections[endColumnIndex + 3];
+        }
+      }
+      startRowIndex = selections[selectionIndex];
+      const startColumnIndex = selections[selectionIndex + 1];
+      const endColumnIndex = selections[selectionIndex + 3];
+      if (startRowIndex === i && startColumnIndex <= columnIndex && columnIndex <= endColumnIndex) {
+        continue;
+      }
+      if (startRowIndex > i) {
+        selectionIndex -= 4;
+      }
+      const columnEndIndex = columnIndex + word.length;
+      selectionIndex += 4;
+      const newSelections = new Uint32Array(selections.length + 4);
+      newSelections.set(selections.subarray(0, selectionIndex), 0);
+      newSelections[selectionIndex] = i;
+      newSelections[selectionIndex + 1] = columnIndex;
+      newSelections[selectionIndex + 2] = i;
+      newSelections[selectionIndex + 3] = columnEndIndex;
+      newSelections.set(selections.subarray(selectionIndex), selectionIndex + 4);
+      return {
+        revealRange: newSelections.length - 4,
+        selectionEdits: newSelections
+      };
+    }
+  }
+  return undefined;
+};
+const RE_ALPHA_NUMERIC = /[a-zA-Z\d]/;
+
+// @ts-ignore
+const isAlphaNumeric = char => {
+  return RE_ALPHA_NUMERIC.test(char);
+};
+
+// @ts-ignore
+const getWordStartIndex = (line, index) => {
+  for (let i = index - 1; i >= 0; i--) {
+    if (!isAlphaNumeric(line[i])) {
+      return i + 1;
+    }
+  }
+  return 0;
+};
+
+// @ts-ignore
+const getWordEndIndex = (line, index) => {
+  for (let i = index; i < line.length; i++) {
+    if (!isAlphaNumeric(line[i])) {
+      return i;
+    }
+  }
+  return line.length - 1;
+};
+
+// @ts-ignore
+const getWordMatchAtPosition = (lines, rowIndex, columnIndex) => {
+  const line = lines[rowIndex];
+  const index = columnIndex;
+  const start = getWordStartIndex(line, index);
+  const end = getWordEndIndex(line, index);
+  const word = line.slice(start, end);
+  return {
+    start,
+    end,
+    word
+  };
+};
+
+// @ts-ignore
+const getSelectNextOccurrenceResult = editor => {
+  const lines = editor.lines;
+  const selections = editor.selections;
+  if (isEverySelectionEmpty(selections)) {
+    const newSelections = new Uint32Array(selections.length);
+    for (let i = 0; i < selections.length; i += 4) {
+      const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+      const wordMatch = getWordMatchAtPosition(lines, selectionStartRow, selectionStartColumn);
+      if (wordMatch.start === wordMatch.end) {
+        newSelections[i] = selectionStartRow;
+        newSelections[i + 1] = selectionStartColumn;
+        newSelections[i + 2] = selectionEndRow;
+        newSelections[i + 3] = selectionEndColumn;
+      } else {
+        newSelections[i] = selectionStartRow;
+        newSelections[i + 1] = wordMatch.start;
+        newSelections[i + 2] = selectionStartRow;
+        newSelections[i + 3] = wordMatch.end;
+      }
+    }
+    return {
+      selectionEdits: newSelections,
+      revealRange: newSelections.length - 4 // TODO should be primary selection
+    };
+  }
+  if (isEverySelectionSingleLine(editor.selections)) {
+    return getSelectionEditsSingleLineWord(editor.lines, editor.selections);
+  }
+  return undefined;
+};
+
+// @ts-ignore
+const isRangeInViewPort = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
+  return startRowIndex >= minLineY && endRowIndex <= maxLineY;
+};
+
+// TODO handle virtual space
+// @ts-ignore
+const selectNextOccurrence = editor => {
+  const result = getSelectNextOccurrenceResult(editor);
+  if (!result) {
+    return editor;
+  }
+  const revealRange = result.revealRange;
+  const selectionEdits = result.selectionEdits;
+  const revealRangeStartRowIndex = selectionEdits[revealRange];
+  const revealRangeEndRowIndex = selectionEdits[revealRange + 2];
+  if (isRangeInViewPort(editor.minLineY, editor.maxLineY, revealRangeStartRowIndex, revealRangeEndRowIndex)) {
+    return scheduleSelections(editor, selectionEdits);
+  }
+  // TODO what is this magic number 5?
+  // const deltaY = (revealRangeStartRowIndex - 5) * editor.rowHeight
+  // @ts-ignore
+  return scheduleDocumentAndCursorsSelections(editor, [], selectionEdits);
+};
+
+// @ts-ignore
+const selectPreviousOccurrence = editor => {
+  return editor;
+};
+
+// @ts-ignore
+
+// @ts-ignore
+const getSelectUpChanges = (lines, selections) => {
+  const newSelections = new Uint32Array(selections.length);
+  for (let i = 0; i < selections.length; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
+    newSelections[i] = Math.max(selectionStartRow - 1, 0);
+    newSelections[i + 1] = selectionStartColumn;
+    newSelections[i + 2] = selectionEndRow;
+    newSelections[i + 3] = selectionEndColumn;
+  }
+  return newSelections;
+};
+
+// @ts-ignore
+const selectUp = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const newSelections = getSelectUpChanges(lines, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const selectWordLeft = editor => {
+  return editorSelectHorizontalLeft(editor, wordLeft);
+};
+
+// @ts-ignore
+const selectWordRight = editor => {
+  return editorSelectHorizontalRight(editor, wordRight);
+};
+
+// @ts-ignore
+// @ts-ignore
+
+// import * as ExtensionHostSelection from '../ExtensionHost/ExtensionHostSelection.ts'
+
+// @ts-ignore
+const getNewSelections = async (editor, selections) => {
+  // TODO
+  // const newSelections = await ExtensionHostSelection.executeGrowSelection(editor, selections)
+  // if (newSelections.length === 0) {
+  //   return selections
+  // }
+  // return new Uint32Array(newSelections)
+  return selections;
+};
+
+// @ts-ignore
+const selectionGrow = async editor => {
+  const {
+    selections
+  } = editor;
+  const newSelections = await getNewSelections(editor, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
+// @ts-ignore
+const compareString = (a, b) => {
+  return a.localeCompare(b);
+};
+
+// @ts-ignore
+const getSortedLines = lines => {
+  const newLines = [...lines];
+  newLines.sort(compareString);
+  return newLines;
+};
+const origin = 'sort-lines-ascending';
+
+// @ts-ignore
+const getSortLinesAscendingChanges = (lines, selections) => {
+  const startRowIndex = selections[0];
+  const endRowIndex = selections[2];
+  const changes = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const selectionStartRow = selections[i];
+    const selectionStartColumn = selections[i + 1];
+    const selectionEndRow = selections[i + 2];
+    const selectionEndColumn = selections[i + 3];
+    const start = {
+      rowIndex: selectionStartRow,
+      columnIndex: selectionStartColumn
+    };
+    const end = {
+      rowIndex: selectionEndRow,
+      columnIndex: selectionEndColumn
+    };
+    const selection = {
+      start,
+      end
+    };
+    const selectionLines = lines.slice(startRowIndex, endRowIndex + 1);
+    const sortedSelectionLines = getSortedLines(selectionLines);
+    changes.push({
+      start: start,
+      end: end,
+      inserted: sortedSelectionLines,
+      deleted: getSelectionText({
+        lines
+      }, selection),
+      origin
+    });
+  }
+  return changes;
+};
+
+// @ts-ignore
+const sortLinesAscending = editor => {
+  const {
+    lines,
+    selections
+  } = editor;
+  const changes = getSortLinesAscendingChanges(lines, selections);
+  return scheduleDocumentAndCursorsSelections(editor, changes);
+};
+
+// TODO move cursor
+// TODO multiple cursors -> vscode removes multiple cursors
+// TODO with selection -> vscode moves whole selection
+const moveLineDown = editor => {
+  const rowIndex = editor.cursor.rowIndex;
+  if (rowIndex === editor.lines.length - 1) {
+    return;
+  }
+  const documentEdits = [{
+    type: /* splice */2,
+    rowIndex: rowIndex,
+    count: 2,
+    newLines: [getLine(editor.textDocument, rowIndex + 1), getLine(editor.textDocument, rowIndex)]
+  }];
+  // @ts-ignore
+  const cursorEdits = undefined(editor, (editor, cursor) => {
+    return {
+      rowIndex: cursor.rowIndex + 1,
+      columnIndex: cursor.columnIndex
+    };
+  });
+  // @ts-ignore
+  undefined(editor, documentEdits, cursorEdits);
+};
+
+const getErrorMessage = error => {
+  if (!error) {
+    return `Error: ${error}`;
+  }
+  let message = error.message;
+  while (error.cause) {
+    error = error.cause;
+    message += `: ${error}`;
+  }
+  return message;
+};
+const prepareErrorMessageWithCodeFrame = error => {
+  if (!error) {
+    return {
+      message: error,
+      stack: undefined,
+      codeFrame: undefined,
+      type: 'Error'
+    };
+  }
+  const message = getErrorMessage(error);
+  if (error.codeFrame) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: error.codeFrame,
+      type: error.constructor.name
+    };
+  }
+  return {
+    message,
+    stack: error.originalStack,
+    codeFrame: error.originalCodeFrame,
+    category: error.category,
+    stderr: error.stderr
+  };
+};
+const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
+const RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
+
+/**
+ *
+ * @param {readonly string[]} lines
+ * @returns
+ */
+const getFile = lines => {
+  for (const line of lines) {
+    if (RE_PATH_1.test(line) || RE_PATH_2.test(line)) {
+      return line;
+    }
+  }
+  return '';
+};
+const prepareErrorMessageWithoutCodeFrame = async error => {
+  try {
+    const lines = splitLines(error.stack);
+    const file = getFile(lines);
+    let match = file.match(RE_PATH_1);
+    if (!match) {
+      match = file.match(RE_PATH_2);
+    }
+    if (!match) {
+      return error;
+    }
+    const relevantStack = joinLines(lines.slice(1));
+    const message = getErrorMessage(error);
+    return {
+      message,
+      stack: relevantStack,
+      type: error.constructor.name
+    };
+  } catch (otherError) {
+    console.warn('ErrorHandling Error');
+    console.warn(otherError);
+    return error;
+  }
+};
+const prepare = async error => {
+  if (error && error.message && error.codeFrame) {
+    return prepareErrorMessageWithCodeFrame(error);
+  }
+  if (error && error.stack) {
+    return prepareErrorMessageWithoutCodeFrame(error);
+  }
+  return error;
+};
+const print = error => {
+  if (error && error.type && error.message && error.codeFrame) {
+    return `${error.type}: ${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
+  }
+  if (error && error.message && error.codeFrame) {
+    return `${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
+  }
+  if (error && error.type && error.message) {
+    return `${error.type}: ${error.message}\n${error.stack}`;
+  }
+  if (error && error.stack) {
+    return `${error.stack}`;
+  }
+  if (error === null) {
+    return null;
+  }
+  return `${error}`;
+};
+
+// @ts-nocheck
+const logError = async error => {
+  const prettyError = await prepare(error);
+  const prettyErrorString = print(prettyError);
+  console.error(prettyErrorString);
+  return prettyError;
+};
+const handleError = async error => {
+  try {
+    const prettyError = await logError(error);
+  } catch (otherError) {
+    console.warn('ErrorHandling error');
+    console.warn(otherError);
+    console.error(error);
+  }
+};
+
+// @ts-ignore
+const getNewEditor = async editor => {
+  return editor;
+};
+
+// @ts-ignore
+const save = async editor => {
+  try {
+    const uri = editor.uri;
+    const newEditor = await getNewEditor(editor);
+    const content = getText(newEditor);
+    await invoke('FileSystem.writeFile', uri, content);
+    return newEditor;
+  } catch (error) {
+    // @ts-ignore
+    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
+    await handleError(betterError);
+    return editor;
+  }
+};
+
+// TODO handle multiple cursors
+const moveLineUp = editor => {
+  const rowIndex = editor.cursor.rowIndex;
+  if (rowIndex === 0) {
+    return;
+  }
+  const documentEdits = [{
+    type: /* splice */2,
+    rowIndex: rowIndex - 1,
+    count: 2,
+    newLines: [getLine(editor.textDocument, rowIndex), getLine(editor.textDocument, rowIndex - 1)]
+  }];
+  // @ts-ignore
+  const cursorEdits = undefined(editor, (editor, cursor) => {
+    return {
+      // TODO handle bottom 0
+      rowIndex: cursor.rowIndex - 1,
+      columnIndex: cursor.columnIndex
+    };
+  });
+  // @ts-ignore
+  undefined(editor, documentEdits, cursorEdits);
+};
+
+const commandMap = {
+  'Editor.addCursorAbove': addCursorAbove,
+  'Editor.addCursorBelow': addCursorBelow,
+  'Editor.cancelSelection': cancelSelection,
+  'Editor.compositionEnd': compositionEnd,
+  'Editor.compositionStart': compositionStart,
+  'Editor.compositionUpdate': compositionUpdate,
+  'Editor.contextMenu': handleContextMenu,
+  'Editor.copy': copy,
+  'Editor.copyLineDown': copyLineDown,
+  'Editor.copyLineUp': copyLineUp,
+  'Editor.cursorCharacterLeft': cursorCharacterLeft,
+  'Editor.cursorCharacterRight': cursorCharacterRight,
+  'Editor.cursorDown': cursorDown,
+  'Editor.cursorEnd': cursorEnd,
+  'Editor.cursorHome': cursorHome,
+  'Editor.cursorLeft': cursorCharacterLeft,
+  'Editor.cursorRight': cursorCharacterRight,
+  'Editor.cursorUp': cursorUp,
+  'Editor.cursorWordLeft': cursorWordLeft,
+  'Editor.cursorWordPartLeft': cursorWordPartLeft,
+  'Editor.cursorWordPartRight': cursorWordPartRight,
+  'Editor.cursorWordRight': cursorWordRight,
+  'Editor.cut': cut,
+  'Editor.deleteAllLeft': deleteAllLeft,
+  'Editor.deleteAllRight': deleteAllRight,
+  'Editor.deleteCharacterLeft': deleteCharacterLeft,
+  'Editor.deleteCharacterRight': deleteCharacterRight,
+  'Editor.deleteHorizontalRight': editorDeleteHorizontalRight,
+  'Editor.deleteLeft': deleteCharacterLeft,
+  'Editor.deleteWordLeft': deleteWordLeft,
+  'Editor.deleteWordPartLeft': deleteWordPartLeft,
+  'Editor.deleteWordPartRight': deleteWordPartRight,
+  'Editor.deleteWordRight': deleteWordRight,
+  'Editor.handleDoubleClick': handleDoubleClick,
+  'Editor.handleMouseDown': handleMouseDown,
+  'Editor.handleTouchEnd': handleTouchEnd,
+  'Editor.indendLess': indentLess,
+  'Editor.indentMore': indentMore,
+  'Editor.moveLineDown': moveLineDown,
+  'Editor.moveLineUp': moveLineUp,
+  'Editor.pasteText': pasteText,
+  'Editor.save': save,
+  'Editor.selectAll': selectAll,
+  'Editor.selectAllLeft': editorSelectAllLeft,
+  'Editor.selectAllOccurrences': selectAllOccurrences,
+  'Editor.selectAllRight': editorSelectAllRight,
+  'Editor.selectCharacterLeft': selectCharacterLeft,
+  'Editor.selectCharacterRight': selectCharacterRight,
+  'Editor.selectDown': selectDown,
+  'Editor.selectionGrow': selectionGrow,
+  'Editor.selectNextOccurrence': selectNextOccurrence,
+  'Editor.selectPreviousOccurrence': selectPreviousOccurrence,
+  'Editor.selectUp': selectUp,
+  'Editor.selectWord': selectWord,
+  'Editor.selectWordLeft': selectWordLeft,
+  'Editor.selectWordRight': selectWordRight,
+  'Editor.sortLinesAscending': sortLinesAscending
+};
+
+// @ts-ignore
+const getErrorResponse = async (message, error) => {
+  if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
+    return {
+      jsonrpc: Two,
+      id: message.id,
+      error: {
+        code: MethodNotFound,
+        message: error.message,
+        data: error.stack
+      }
+    };
+  }
+  const prettyError = await prepare(error);
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error: {
+      code: Custom,
+      message: prettyError.message,
+      data: {
+        stack: prettyError.stack,
+        codeFrame: prettyError.codeFrame,
+        type: prettyError.type
+      }
+    }
+  };
+};
+
+// @ts-ignore
+const getSuccessResponse = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+
+// @ts-ignore
+const getResponse = async (message, execute) => {
+  try {
+    const result = await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    return getErrorResponse(message, error);
+  }
+};
+
+// @ts-ignore
+const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, execute);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        await logError(error);
+        const errorResponse = getErrorResponse(message, error);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, execute);
+    return;
+  }
+  console.log({
+    message
+  });
+  throw new JsonRpcError('unexpected message');
+};
+
+// @ts-nocheck
+
+const handleIpc = (ipc, source = 'process') => {
+  const handleMessage = message => {
+    return handleJsonRpcMessage(ipc, message, execute, resolve);
+  };
+  ipc.onmessage = handleMessage;
+};
+
+const MessagePort = 1;
+const ModuleWorker = 2;
+const ReferencePort = 3;
+const ModuleWorkerAndMessagePort = 8;
+const Auto = () => {
+  // @ts-ignore
+  if (globalThis.acceptPort) {
+    return MessagePort;
+  }
+  // @ts-ignore
+  if (globalThis.acceptReferencePort) {
+    return ReferencePort;
+  }
+  return ModuleWorkerAndMessagePort;
+};
+
+// @ts-ignore
+const getModule = method => {
+  switch (method) {
+    case MessagePort:
+      return Promise.resolve().then(function () { return IpcChildWithMessagePort; });
+    case ModuleWorker:
+      return Promise.resolve().then(function () { return IpcChildWithModuleWorker; });
+    case ReferencePort:
+      return Promise.resolve().then(function () { return IpcChildWithReferencePort; });
+    case ModuleWorkerAndMessagePort:
+      return Promise.resolve().then(function () { return IpcChildWithModuleWorkerAndMessagePort; });
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+// @ts-ignore
+const listen$5 = async ({
+  method
+}) => {
+  const module = await getModule(method);
+  const rawIpc = await module.listen();
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const listen$4 = async () => {
+  registerCommands(commandMap);
+  const ipc = await listen$5({
+    method: Auto()
+  });
+  handleIpc(ipc);
+  listen$6(ipc);
+};
+
+const main = async () => {
+  await listen$4();
+};
+
+main();
+
+// @ts-ignore
+const getData = event => {
+  return event.data;
+};
+
+// @ts-nocheck
+
+const listen$3 = () => {
+  const messageChannel = new MessageChannel();
+  const {
+    port1,
+    port2
+  } = messageChannel;
+  globalThis.acceptPort(port2);
+  return port1;
+};
+const wrap$3 = port => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      this.port.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      const wrappedListener = event => {
+        const message = getData(event);
+        listener(message);
+      };
+      this.listener = listener;
+      this.port.onmessage = wrappedListener;
+    }
+  };
+};
+
+const IpcChildWithMessagePort = {
+  __proto__: null,
+  listen: listen$3,
+  wrap: wrap$3
+};
+
+// @ts-nocheck
+const listen$2 = () => {
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  globalThis.postMessage('ready');
+  return globalThis;
+};
+const signal = global => {
+  global.postMessage('ready');
+};
+const wrap$2 = global => {
+  return {
+    global,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    send(message) {
+      this.global.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      this.global.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      const wrappedListener = event => {
+        const message = getData(event);
+        listener(message);
+      };
+      this.listener = listener;
+      this.global.onmessage = wrappedListener;
+    }
+  };
+};
+
+const IpcChildWithModuleWorker = {
+  __proto__: null,
+  listen: listen$2,
+  signal,
+  wrap: wrap$2
+};
+
+const listen$1 = () => {
+  const referencePort = {
+    onmessage(message, transferables) {},
+    postMessage() {}
+  };
+  // TODO get rid of extra data wrapper
+  // @ts-ignore
+  globalThis.acceptReferencePort(referencePort);
+  return referencePort;
+};
+const wrap$1 = referencePort => {
+  return {
+    referencePort,
+    send(message) {
+      this.referencePort.onmessage({
+        data: message
+      });
+    },
+    sendAndTransfer({
+      data: message
+    }, transferables) {
+      this.referencePort.onmessage(message, transferables);
+    },
+    get onmessage() {
+      // TODO
+      return null;
+    },
+    set onmessage(listener) {
+      // TODO
+    }
+  };
+};
+
+const IpcChildWithReferencePort = {
+  __proto__: null,
+  listen: listen$1,
+  wrap: wrap$1
+};
+
+class IpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'IpcError';
+  }
+}
+
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const cleanup = value => {
+    port.onmessage = null;
+    resolve(value);
+  };
+  const handleMessage = event => {
+    cleanup(event);
+  };
+  port.onmessage = handleMessage;
+  const event = await promise;
+  return event;
+};
+
+// @ts-nocheck
+const listen = async () => {
+  const parentIpcRaw = await listen$2();
+  const parentIpc = wrap$2(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpcRaw.postMessage({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+const wrap = port => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      this.port.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return this.wrappedListener;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        this.wrappedListener = event => {
+          const actualData = getData(event);
+          listener(actualData);
+        };
+      } else {
+        this.wrappedListener = undefined;
+      }
+      this.port.onmessage = this.wrappedListener;
+    }
+  };
+};
+
+const IpcChildWithModuleWorkerAndMessagePort = {
+  __proto__: null,
+  listen,
+  wrap
+};
+//# sourceMappingURL=editorWorkerMain.js.map