@lvce-editor/server 0.0.2

package/static/1914fad/packages/renderer-worker/src/parts/Editor/EditorText.js

@@ -0,0 +1,306 @@
+import * as TextDocument from '../TextDocument/TextDocument.js'
+
+/**
+ *
+ * @param {(line:string, lineState)=>any} tokenizeLine
+ * @param {string} line
+ * @param {any} lineState
+ * @returns
+ */
+const safeTokenizeLine = (tokenizeLine, line, lineState) => {
+  try {
+    lineState = tokenizeLine(line, lineState)
+    if (!lineState || !lineState.tokens || !lineState.state) {
+      throw new Error('invalid tokenization result')
+    }
+  } catch (error) {
+    console.error(error)
+    return {
+      tokens: [{ length: line.length, type: 0 }],
+      lineState,
+    }
+  }
+  return lineState
+}
+
+// const getTokens = (editor) => {
+//   const tokens = []
+//   const lines = editor.lines
+//   let lineState = editor.tokenizer.initialLineState
+//   // TODO lineCache should probably only store endOfLineState
+//   // because storing tokens could maybe result in high
+//   // memory usage (e.g. 10000 lines * 10 tokens per line = 100 000 objects stored)
+//   // on the other hand, scrolling should be really fast, and needlessly
+//   // recomputing tokens would be a waste of cpu time and cause lots of garbage collection
+//   const lineCache = editor.lineCache
+//   // TODO only compute tokens in viewport
+//   // console.log('minmax', editor.minLineY, editor.maxLineY)
+//   // const cachedLineStates = Object.create(null)
+//   // if(cachedLineStates[i])
+//   const tokenizeLine = editor.tokenizer.tokenizeLine
+//   for (let i = 0; i < lines.length; i++) {
+//     if (lineCache[i]) {
+//       // console.log('cached line')
+//       tokens.push(lineCache[i].tokens)
+//       continue
+//     }
+//     // TODO use TextDocument.getLine so that text document buffer implementation
+//     // can be changed (e.g. vscode has piece tree, codemirror has something like chunked arrays / string[][])
+//     const line = lines[i]
+//     lineState = safeTokenizeLine(tokenizeLine, line, lineState)
+//     const newTokens = lineState.tokens
+//     lineCache[i] = lineState
+//     tokens.push(newTokens)
+//   }
+//   return tokens
+// }
+
+const getTokensFromCache = (result) => {
+  return result.tokens
+}
+
+// TODO vscode has an interesting approach for tokenizing:
+// first, the viewport is tokenized from startLine to endLine
+// the first iteration might not be accurate because for example
+// there can be a open multiline comment at the start of the file
+// which is not taken into account for this first tokenization
+// but after some time (onIdle), the background tokenizer is invoked
+// that gives accurate results (but can take much longer since it
+// might need to parse from the start of the file)
+//
+// another approach would be to show plain text (non-highlighted)
+// when scrolling fast and the tokenizer is too slow to parse from
+// the start of the file
+//
+// the approach implemented below for tokenizing the viewport
+// is just to parse from the start of the file if necessary
+// that doesn't scale well for large files but it is simpler
+// to implement for now
+
+// TODO only send changed lines to renderer process instead of all lines in viewport
+const getTokensViewport = (editor, startLineIndex, endLineIndex) => {
+  const invalidStartIndex = editor.invalidStartIndex
+  const lineCache = editor.lineCache
+  if (endLineIndex <= invalidStartIndex) {
+    return lineCache
+      .slice(startLineIndex + 1, endLineIndex + 1)
+      .map(getTokensFromCache)
+  }
+  const tokenizeLine = editor.tokenizer.tokenizeLine
+  if (startLineIndex <= invalidStartIndex) {
+    for (let i = invalidStartIndex; i < endLineIndex; i++) {
+      const lineState =
+        i === 0 ? editor.tokenizer.initialLineState : editor.lineCache[i]
+      const line = editor.lines[i]
+      const result = safeTokenizeLine(tokenizeLine, line, lineState)
+      // TODO if lineCacheEnd matches the one before, skip tokenizing lines after
+      lineCache[i + 1] = result
+    }
+    editor.invalidStartIndex = endLineIndex
+    return lineCache
+      .slice(startLineIndex + 1, endLineIndex + 1)
+      .map(getTokensFromCache)
+  }
+  // TODO combine for loops
+  for (let i = invalidStartIndex; i < startLineIndex; i++) {
+    const lineState = editor.lineCache[i]
+    const line = editor.lines[i]
+    const result = safeTokenizeLine(tokenizeLine, line, lineState)
+    lineCache[i + 1] = result
+  }
+  for (let i = startLineIndex; i < endLineIndex; i++) {
+    const lineState = editor.lineCache[i]
+    const line = editor.lines[i]
+    const result = safeTokenizeLine(tokenizeLine, line, lineState)
+    lineCache[i + 1] = result
+    editor.invalidStartIndex = endLineIndex
+  }
+  return lineCache
+    .slice(startLineIndex + 1, endLineIndex + 1)
+    .map(getTokensFromCache)
+}
+
+const invalidateLine = (editor, index) => {
+  editor.validLines[index] = false
+  if (index < editor.invalidStartIndex) {
+    editor.invalidStartIndex = index
+  }
+}
+
+const applyChangesToSyntaxHighlighting = (editor, changes) => {
+  // TODO invalidate lines that are affected
+}
+
+// const getTokensIncremental = (editor, min, max) => {
+//   const currentLength = editor.lineStateCache.length
+//   const tokens = []
+//   const lines = editor.lines
+//   let lineState = editor.tokenizer.initialLineState
+//   for (let i = currentLength; i < max; i++) {
+//     const line = lines[i]
+//     try {
+//       lineState = editor.tokenizer.tokenizeLine(line, lineState)
+//       if (!lineState || !lineState.tokens || !lineState.state) {
+//         throw new Error('invalid tokenization result')
+//       }
+//     } catch (error) {
+//       tokens.push([{ length: line.length, type: 0 }])
+//       console.error(error)
+//       // renderWithoutSyntaxHighlighting(state, firstRow, lastRow)
+//       continue
+//     }
+//     const newTokens = lineState.tokens
+//     tokens.push(newTokens)
+//   }
+//   return tokens
+// }
+
+// const getLineInfosIncremental = (editor, tokens, minLineY, maxLineY) => {
+//   const result = []
+//   const lines = editor.lines
+//   const TokenMap = editor.tokenizer.TokenMap
+//   for (let i = minLineY; i < maxLineY; i++) {
+//     result.push(getLineInfo(lines[i], tokens[i], TokenMap))
+//   }
+//   return result
+// }
+
+const getDecorationClassName = (type) => {
+  switch (type) {
+    case 2816:
+    case 2817:
+    case 2825:
+    case 2824:
+    case 2856:
+    case 2857:
+    case 3072:
+    case 3073:
+    case 3077:
+    case 3088:
+      return 'Function'
+    case 1792:
+    case 1793:
+      return 'Parameter'
+    case 512:
+    case 513:
+    case 769:
+    case 1024:
+    case 1536:
+    case 1537:
+    case 1544:
+    case 1545:
+      return 'Type'
+    case 2048:
+    case 2049:
+    case 2056:
+    case 2057:
+    case 2064:
+    case 2080:
+    case 2081:
+    case 2088:
+    case 2089:
+    case 2313:
+    case 2560:
+    case 2569:
+    case 2561:
+    case 2584:
+      return 'VariableName'
+    case 256:
+    case 257:
+    case 272:
+      return 'Class'
+    default:
+      return `Unknown-${type}`
+  }
+}
+
+const getLineInfo = (line, tokens, decorations, TokenMap, lineOffset) => {
+  let start = 0
+  let end = 0
+  const lineInfo = []
+  let decorationIndex = 0
+  for (; decorationIndex < decorations.length; decorationIndex += 3) {
+    const decorationOffset = decorations[decorationIndex]
+    if (decorationOffset >= lineOffset) {
+      break
+    }
+  }
+
+  // console.log({ tokens, decorations })
+  for (const token of tokens) {
+    const decorationOffset = decorations[decorationIndex]
+    let extraClassName = ''
+    if (decorationOffset !== undefined) {
+      if (decorationOffset - lineOffset === start) {
+        const decorationLength = decorations[++decorationIndex]
+        const decorationType = decorations[++decorationIndex]
+        const decorationModifiers = decorations[++decorationIndex]
+        // console.log('MATCHING DECORATION', {
+        //   decorationIndex,
+        //   decorationLength,
+        //   decorationType,
+        //   decorationModifiers,
+        // })
+        extraClassName = getDecorationClassName(decorationType)
+      }
+    }
+
+    end += token.length
+    const text = line.slice(start, end)
+    const className = `Token ${
+      extraClassName || TokenMap[token.type] || 'Unknown'
+    }`
+    lineInfo.push(text, className)
+    start = end
+  }
+  return lineInfo
+}
+
+// TODO need lots of tests for this
+const getLineInfosViewport = (
+  editor,
+  tokens,
+  minLineY,
+  maxLineY,
+  minLineOffset
+) => {
+  const result = []
+  const lines = editor.lines
+  const TokenMap = editor.tokenizer.TokenMap
+  const decorations = editor.decorations
+  let offset = minLineOffset
+  for (let i = minLineY; i < maxLineY; i++) {
+    const line = lines[i]
+    result.push(
+      getLineInfo(line, tokens[i - minLineY], decorations, TokenMap, offset)
+    )
+    offset += line.length + 1
+  }
+  return result
+}
+
+export const getVisible = (editor) => {
+  // console.log({ editor })
+  // TODO should separate rendering from business logic somehow
+  // currently hard to test because need to mock editor height, top, left,
+  // invalidStartIndex, lineCache, etc. just for testing editorType
+  // editor.invalidStartIndex = changes[0].start.rowIndex
+  const minLineY = editor.minLineY
+  const maxLineY = Math.min(
+    editor.minLineY + editor.numberOfVisibleLines,
+    editor.lines.length
+  )
+  const tokens = getTokensViewport(editor, minLineY, maxLineY)
+  const minLineOffset = TextDocument.offsetAt(editor, {
+    rowIndex: minLineY,
+    columnIndex: 0,
+  })
+  const textInfos = getLineInfosViewport(
+    editor,
+    tokens,
+    minLineY,
+    maxLineY,
+    minLineOffset
+  )
+  return textInfos
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommand.ipc.js

@@ -0,0 +1,165 @@
+import * as Command from '../Command/Command.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as EditorBlur from './EditorCommandBlur.js'
+import * as EditorCancelSelection from './EditorCommandCancelSelection.js'
+import * as EditorCompletion from './EditorCommandCompletion.js'
+import * as EditorComposition from './EditorCommandComposition.js'
+import * as EditorCopy from './EditorCommandCopy.js'
+import * as EditorCopyLineDown from './EditorCommandCopyLineDown.js'
+import * as EditorCopyLineUp from './EditorCommandCopyLineUp.js'
+import * as EditorCursorCharacterLeft from './EditorCommandCursorCharacterLeft.js'
+import * as EditorCursorCharacterRight from './EditorCommandCursorCharacterRight.js'
+import * as EditorCursorDown from './EditorCommandCursorDown.js'
+import * as EditorCursorEnd from './EditorCommandCursorEnd.js'
+import * as EditorCursorHome from './EditorCommandCursorHome.js'
+import * as EditorCursorSet from './EditorCommandCursorSet.js'
+import * as EditorCursorUp from './EditorCommandCursorUp.js'
+import * as EditorCursorWordLeft from './EditorCommandCursorWordLeft.js'
+import * as EditorCursorWordPartLeft from './EditorCommandCursorWordPartLeft.js'
+import * as EditorCursorWordPartRight from './EditorCommandCursorWordPartRight.js'
+import * as EditorCursorWordRight from './EditorCommandCursorWordRight.js'
+import * as EditorCut from './EditorCommandCut.js'
+import * as EditorDeleteAllLeft from './EditorCommandDeleteAllLeft.js'
+import * as EditorDeleteAllRight from './EditorCommandDeleteAllRight.js'
+import * as EditorDeleteLeft from './EditorCommandDeleteCharacterLeft.js'
+import * as EditorDeleteRight from './EditorCommandDeleteCharacterRight.js'
+import * as EditorDeleteWordLeft from './EditorCommandDeleteWordLeft.js'
+import * as EditorDeleteWordPartLeft from './EditorCommandDeleteWordPartLeft.js'
+import * as EditorDeleteWordPartRight from './EditorCommandDeleteWordPartRight.js'
+import * as EditorDeleteWordRight from './EditorCommandDeleteWordRight.js'
+import * as EditorFormat from './EditorCommandFormat.js'
+import * as EditorGoToDefinition from './EditorCommandGoToDefinition.js'
+import * as EditorHandleContextMenu from './EditorCommandHandleContextMenu.js'
+import * as EditorHandleDoubleClick from './EditorCommandHandleDoubleClick.js'
+import * as EditorHandleMouseMove from './EditorCommandHandleMouseMove.js'
+import * as EditorHandleBeforeInputFromContentEditable from './EditorCommandHandleNativeBeforeInputFromContentEditable.js'
+import * as EditorHandleNativeSelectionChange from './EditorCommandHandleNativeSelectionChange.js'
+import * as EditorHandleScrollBarClick from './EditorCommandHandleScrollBarClick.js'
+import * as EditorHandleScrollBarMove from './EditorCommandHandleScrollBarMove.js'
+import * as EditorHandleSingleClick from './EditorCommandHandleSingleClick.js'
+import * as EditorHandleTab from './EditorCommandHandleTab.js'
+import * as EditorHandleTouchEnd from './EditorCommandHandleTouchEnd.js'
+import * as EditorHandleTouchMove from './EditorCommandHandleTouchMove.js'
+import * as EditorHandleTouchStart from './EditorCommandHandleTouchStart.js'
+import * as EditorHandleTripleClick from './EditorCommandHandleTripleClick.js'
+import * as EditorCommandIndentLess from './EditorCommandIndentLess.js'
+import * as EditorCommandIndentMore from './EditorCommandIndentMore.js'
+import * as EditorInsertLineBreak from './EditorCommandInsertLineBreak.js'
+import * as EditorMoveLineDown from './EditorCommandMoveLineDown.js'
+import * as EditorMoveLineUp from './EditorCommandMoveLineUp.js'
+import * as EditorMoveRectangleSelection from './EditorCommandMoveRectangleSelection.js'
+import * as EditorMoveRectangleSelectionPx from './EditorCommandMoveRectangleSelectionPx.js'
+import * as EditorMoveSelection from './EditorCommandMoveSelection.js'
+import * as EditorMoveSelectionPx from './EditorCommandMoveSelectionPx.js'
+import * as EditorPaste from './EditorCommandPaste.js'
+import * as EditorPasteText from './EditorCommandPasteText.js'
+import * as EditorSave from './EditorCommandSave.js'
+import * as EditorSelectAll from './EditorCommandSelectAll.js'
+import * as EditorSelectAllOccurrences from './EditorCommandSelectAllOccurrences.js'
+import * as EditorSelectCharacterLeft from './EditorCommandSelectCharacterLeft.js'
+import * as EditorSelectCharacterRight from './EditorCommandSelectCharacterRight.js'
+import * as EditorSelectInsideString from './EditorCommandSelectInsideString.js'
+import * as EditorSelectLine from './EditorCommandSelectLine.js'
+import * as EditorSelectNextOccurrence from './EditorCommandSelectNextOccurrence.js'
+import * as EditorSelectWord from './EditorCommandSelectWord.js'
+import * as EditorSelectWordLeft from './EditorCommandSelectWordLeft.js'
+import * as EditorSelectWordRight from './EditorCommandSelectWordRight.js'
+import * as EditorSetDeltaY from './EditorCommandSetDeltaY.js'
+import * as EditorTabCompletion from './EditorCommandTabCompletion.js'
+import * as EditorToggleBlockComment from './EditorCommandToggleBlockComment.js'
+import * as EditorToggleComment from './EditorCommandToggleComment.js'
+import * as EditorType from './EditorCommandType.js'
+import * as EditorUndo from './EditorCommandUndo.js'
+import * as EditorUnindent from './EditorCommandUnindent.js'
+import * as EditorSetLanguageId from './EditorCommandSetLanguageId.js'
+import * as EditorHandleMouseMoveWithAltKey from './EditorCommandHandleMouseMoveWithAltKey.js'
+import * as EditorGoToTypeDefinition from './EditorCommandGoToTypeDefinition.js'
+import * as EditorApplyEdit from './EditorCommandApplyEdit.js'
+import * as EditorSetDecorations from './EditorCommandSetDecorations.js'
+
+export const __initialize__ = () => {
+  Command.register(341, Viewlet.wrapViewletCommand('EditorText', EditorCursorDown.editorCursorsDown))
+  Command.register(342, Viewlet.wrapViewletCommand('EditorText', EditorCursorCharacterLeft.editorCursorCharacterLeft))
+  Command.register(343, Viewlet.wrapViewletCommand('EditorText', EditorCursorCharacterRight.editorCursorsCharacterRight))
+  Command.register(344, Viewlet.wrapViewletCommand('EditorText', EditorCursorUp.editorCursorsUp))
+  Command.register(345, Viewlet.wrapViewletCommand('EditorText', EditorType.editorType))
+  Command.register(346, Viewlet.wrapViewletCommand('EditorText', EditorDeleteLeft.editorDeleteCharacterLeft))
+  Command.register(347, Viewlet.wrapViewletCommand('EditorText', EditorDeleteRight.editorDeleteCharacterRight))
+  Command.register(348, Viewlet.wrapViewletCommand('EditorText', EditorInsertLineBreak.editorInsertLineBreak))
+  Command.register(349, Viewlet.wrapViewletCommand('EditorText', EditorCopyLineUp.editorCopyLineUp))
+  Command.register(350, Viewlet.wrapViewletCommand('EditorText', EditorCopyLineDown.editorCopyLineDown))
+  Command.register(351, Viewlet.wrapViewletCommand('EditorText', EditorMoveLineDown.editorMoveLineDown))
+  Command.register(352, Viewlet.wrapViewletCommand('EditorText', EditorCursorWordLeft.editorCursorWordLeft))
+  Command.register(353, Viewlet.wrapViewletCommand('EditorText', EditorCursorWordRight.editorCursorWordRight))
+  Command.register(354, Viewlet.wrapViewletCommand('EditorText', EditorDeleteWordLeft.editorDeleteWordLeft))
+  Command.register(355, Viewlet.wrapViewletCommand('EditorText', EditorDeleteWordRight.editorDeleteWordRight))
+  Command.register(356, Viewlet.wrapViewletCommand('EditorText', EditorMoveLineUp.editorMoveLineUp))
+  Command.register(357, Viewlet.wrapViewletCommand('EditorText', EditorTabCompletion.editorTabCompletion))
+  Command.register(358, Viewlet.wrapViewletCommand('EditorText', EditorCursorHome.editorCursorsHome))
+  Command.register(359, Viewlet.wrapViewletCommand('EditorText', EditorCursorEnd.editorCursorEnd))
+  Command.register(360, Viewlet.wrapViewletCommand('EditorText', EditorHandleSingleClick.editorHandleSingleClick))
+  Command.register(361, Viewlet.wrapViewletCommand('EditorText', EditorSelectWord.editorSelectWord))
+  Command.register(362, Viewlet.wrapViewletCommand('EditorText', EditorToggleBlockComment.editorToggleBlockComment))
+  Command.register(363, Viewlet.wrapViewletCommand('EditorText', EditorMoveSelection.editorMoveSelection))
+  Command.register(364, Viewlet.wrapViewletCommand('EditorText', EditorCut.editorCut))
+  Command.register(365, Viewlet.wrapViewletCommand('EditorText', EditorCopy.editorCopy))
+  Command.register(366, Viewlet.wrapViewletCommand('EditorText', EditorSelectAll.editorSelectAll))
+  Command.register(367, Viewlet.wrapViewletCommand('EditorText', EditorMoveRectangleSelection.editorMoveRectangleSelection))
+  Command.register(368, Viewlet.wrapViewletCommand('EditorText', EditorCursorWordPartRight.editorCursorWordPartRight))
+  Command.register(369, Viewlet.wrapViewletCommand('EditorText', EditorCursorWordPartLeft.editorCursorWordPartLeft))
+  Command.register(370, Viewlet.wrapViewletCommand('EditorText', EditorBlur.editorBlur)) // TODO needed?
+  Command.register(373, Viewlet.wrapViewletCommand('EditorText', EditorToggleComment.editorToggleComment))
+  Command.register(374, Viewlet.wrapViewletCommand('EditorText', EditorDeleteAllLeft.editorDeleteAllLeft))
+  Command.register(375, Viewlet.wrapViewletCommand('EditorText', EditorDeleteAllRight.editorDeleteAllRight))
+  Command.register(376, Viewlet.wrapViewletCommand('EditorText', EditorHandleTripleClick.editorHandleTripleClick))
+  Command.register(377, Viewlet.wrapViewletCommand('EditorText', EditorSelectLine.editorSelectLine))
+  Command.register(378, Viewlet.wrapViewletCommand('EditorText', EditorSave.editorSave))
+  Command.register(379, Viewlet.wrapViewletCommand('EditorText', EditorHandleContextMenu.editorHandleContextMenu))
+  Command.register(380, Viewlet.wrapViewletCommand('EditorText', EditorSelectCharacterLeft.editorSelectCharacterLeft))
+  Command.register(381, Viewlet.wrapViewletCommand('EditorText', EditorSelectCharacterRight.editorSelectCharacterRight))
+  Command.register(382, Viewlet.wrapViewletCommand('EditorText', EditorPasteText.editorPasteText))
+  Command.register(383, Viewlet.wrapViewletCommand('EditorText', EditorPaste.editorPaste))
+  Command.register(384, Viewlet.wrapViewletCommand('EditorText', EditorSetDeltaY.editorSetDeltaY))
+  Command.register(385, Viewlet.wrapViewletCommand('EditorText', EditorHandleDoubleClick.editorHandleDoubleClick))
+  Command.register(386, Viewlet.wrapViewletCommand('EditorText', EditorMoveSelectionPx.editorMoveSelectionPx))
+  Command.register(387, Viewlet.wrapViewletCommand('EditorText', EditorMoveRectangleSelectionPx.editorMoveRectangleSelectionPx))
+  Command.register(388, Viewlet.wrapViewletCommand('EditorText', EditorFormat.editorFormat))
+  Command.register(389, Viewlet.wrapViewletCommand('EditorText', EditorHandleMouseMove.editorHandleMouseMove))
+  Command.register(390, Viewlet.wrapViewletCommand('EditorText', EditorSelectNextOccurrence.editorSelectNextOccurrence))
+  Command.register(391, Viewlet.wrapViewletCommand('EditorText', EditorSelectAllOccurrences.editorSelectAllOccurrences))
+  Command.register(392, Viewlet.wrapViewletCommand('EditorText', EditorHandleTab.editorHandleTab))
+  Command.register(393, Viewlet.wrapViewletCommand('EditorText', EditorCancelSelection.editorCancelSelection))
+  Command.register(394, Viewlet.wrapViewletCommand('EditorText', EditorUnindent.editorUnindent))
+  Command.register(395, Viewlet.wrapViewletCommand('EditorText', EditorUndo.editorUndo))
+  Command.register(396, Viewlet.wrapViewletCommand('EditorText', EditorCursorSet.editorCursorSet))
+  Command.register(397, Viewlet.wrapViewletCommand('EditorText', EditorDeleteWordPartLeft.editorDeleteWordPartLeft))
+  Command.register(398, Viewlet.wrapViewletCommand('EditorText', EditorDeleteWordPartRight.editorDeleteWordPartRight))
+  Command.register(399, Viewlet.wrapViewletCommand('EditorText', EditorHandleScrollBarMove.editorHandleScrollBarMove))
+  Command.register(400, Viewlet.wrapViewletCommand('EditorText', EditorHandleScrollBarClick.editorHandleScrollBarClick))
+  Command.register(401, Viewlet.wrapViewletCommand('EditorText', EditorSelectWordRight.editorSelectWordRight))
+  Command.register(402, Viewlet.wrapViewletCommand('EditorText', EditorSelectWordLeft.editorSelectWordLeft))
+  Command.register(403, Viewlet.wrapViewletCommand('EditorText', EditorSelectInsideString.editorSelectInsideString))
+  Command.register(404, Viewlet.wrapViewletCommand('EditorText', EditorHandleTouchStart.editorHandleTouchStart))
+  Command.register(405, Viewlet.wrapViewletCommand('EditorText', EditorHandleTouchMove.editorHandleTouchMove))
+  Command.register(406, Viewlet.wrapViewletCommand('EditorText', EditorHandleTouchEnd.editorHandleTouchEnd))
+  Command.register(407, Viewlet.wrapViewletCommand('EditorText', EditorHandleBeforeInputFromContentEditable.handleBeforeInputFromContentEditable))
+  Command.register(408, Viewlet.wrapViewletCommand('EditorText', EditorHandleNativeSelectionChange.editorHandleNativeSelectionChange))
+  Command.register(409, Viewlet.wrapViewletCommand('EditorText', EditorCommandIndentMore.editorIndentMore))
+  Command.register(410, Viewlet.wrapViewletCommand('EditorText', EditorCommandIndentLess.editorIndentLess))
+  Command.register(411, Viewlet.wrapViewletCommand('EditorText', EditorComposition.editorCompositionStart))
+  Command.register(412, Viewlet.wrapViewletCommand('EditorText', EditorComposition.editorCompositionUpdate))
+  Command.register(413, Viewlet.wrapViewletCommand('EditorText', EditorComposition.editorCompositionEnd))
+  Command.register(414, Viewlet.wrapViewletCommand('EditorText', EditorGoToDefinition.editorGoToDefinition))
+  Command.register(415, Viewlet.wrapViewletCommand('EditorText', EditorHandleMouseMoveWithAltKey.editorHandleMouseMoveWithAltKey))
+  // TODO command to set cursor position
+  // TODO command copy line up/down
+  // TODO command move line up/down
+
+  Command.register(980, Viewlet.wrapViewletCommand('EditorText', EditorCompletion.open))
+  Command.register(981, Viewlet.wrapViewletCommand('EditorText', EditorCompletion.close))
+  Command.register(988, Viewlet.wrapViewletCommand('EditorText', EditorCompletion.openFromType))
+  Command.register(989, Viewlet.wrapViewletCommand('EditorText', EditorSetLanguageId.setLanguageId))
+  Command.register(990, Viewlet.wrapViewletCommand('EditorText', EditorGoToTypeDefinition.editorGoToTypeDefinition))
+  Command.register(991, Viewlet.wrapViewletCommand('EditorText', EditorApplyEdit.editorApplyEdit))
+  Command.register(992, Viewlet.wrapViewletCommand('EditorText', EditorSetDecorations.setDecorations))
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandApplyEdit.js

@@ -0,0 +1,8 @@
+import * as Editor from '../Editor/Editor.js'
+import * as Assert from '../Assert/Assert.js'
+
+export const editorApplyEdit = async (editor, changes) => {
+  Assert.object(editor)
+  Assert.array(changes)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandBlur.js

@@ -0,0 +1,20 @@
+export const state = {
+  blurListeners: [],
+}
+
+export const editorBlur = (editor) => {
+  for (const listener of state.blurListeners) {
+    listener(editor)
+  }
+  // TODO save on blur
+  // Command.execute(/* Main.save */ 89)
+  return editor
+}
+
+export const registerListener = (fn) => {
+  state.blurListeners.push(fn)
+}
+
+export const removeListener = (fn) => {
+  state.blurListeners.splice(state.blurListeners.indexOf(fn), 1)
+}

package/static/1914fad/packages/renderer-worker/src/parts/EditorCommand/EditorCommandCancelSelection.js

@@ -0,0 +1,15 @@
+import * as Editor from '../Editor/Editor.js'
+
+export const editorCancelSelection = (editor) => {
+  const selection = editor.selections[0]
+  if (editor.selections.length === 1 && selection.start === selection.end) {
+    return editor
+  }
+  const selectionEdits = [
+    {
+      start: selection.start,
+      end: selection.start,
+    },
+  ]
+  return Editor.scheduleSelections(editor, selectionEdits)
+}