@lvce-editor/server 0.12.0 → 0.13.0

package/static/c808931/packages/renderer-worker/src/parts/Editor/Editor.js

@@ -0,0 +1,359 @@
+import * as Assert from '../Assert/Assert.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as ScrollBarFunctions from '../ScrollBarFunctions/ScrollBarFunctions.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as SplitLines from '../SplitLines/SplitLines.js'
+import * as Tokenizer from '../Tokenizer/Tokenizer.js'
+import * as EditorCursor from './EditorCursor.js'
+import * as EditorScrolling from './EditorScrolling.js'
+import * as EditorSelection from './EditorSelection.js'
+import * as EditorText from './EditorText.js'
+
+const MINIMUM_SLIDER_SIZE = 20
+
+// TODO
+export const create = (id, uri, languageId, content) => {
+  const tokenizer = Tokenizer.getTokenizer(languageId)
+
+  // TODO flatten structure
+  return {
+    uri,
+    languageId,
+    lines: SplitLines.splitLines(content),
+    // TODO cursor should be part of selection,
+    // codemirror has selections: Selection[]
+    //            selectionIndex: number
+
+    // TODO how to get the trigger characters here from extension host
+    completionTriggerCharacters: [],
+    primarySelectionIndex: 0,
+    selections: new Uint32Array([0, 0, 0, 0]),
+    id,
+    tokenizer,
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    numberOfVisibleLines: 0,
+    finalY: 0,
+    finalDeltaY: 0,
+    height: 0,
+    y: 0,
+    x: 0,
+    columnWidth: 0,
+    rowHeight: 0,
+    fontSize: 15, // TODO find out if it is possible to use all numeric values for settings for efficiency, maybe settings could be an array
+    letterSpacing: 0,
+    scrollBarHeight: 0,
+    undoStack: [],
+    // TODO maybe put these into separate tokenization module
+    lineCache: [],
+    validLines: [],
+    invalidStartIndex: 0,
+    decorations: [],
+    focused: false,
+    /**
+     * Offset at which scrollbar thumb has been clicked
+     */
+    handleOffset: 0,
+    itemHeight: 20,
+    fontFamily: '',
+    fontWeight: 400,
+    cursorWidth: 2,
+  }
+}
+
+export const dispose = (id) => {
+  // delete state.editors[id]
+}
+
+export const renderText = (editor) => {
+  Assert.object(editor)
+  const textInfos = EditorText.getVisible(editor)
+  RendererProcess.invoke(
+    /* Viewlet.send */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'renderText',
+    /* scrollBarY */ editor.scrollBarY,
+    /* scrollBarHeight */ editor.scrollBarHeight,
+    /* textInfos */ textInfos,
+    /* fontSize */ editor.fontSize, // TODO only send these properties once on first render
+    /* lineHeight */ editor.rowHeight,
+    /* letterSpacing */ editor.letterSpacing
+  )
+}
+
+export const renderTextAndCursorAndSelectionsCommands = (editor) => {
+  Assert.object(editor)
+  const textInfos = EditorText.getVisible(editor)
+  const { cursorInfos, selectionInfos } = EditorSelection.getVisible(editor)
+  const scrollBarHeight = editor.scrollBarHeight
+  const scrollBarY = (editor.deltaY / editor.finalDeltaY) * (editor.height - editor.scrollBarHeight)
+  return [
+    /* Viewlet.invoke */ 'Viewlet.send',
+    /* id */ 'EditorText',
+    /* method */ 'renderTextAndCursorsAndSelections',
+    /* scrollBarY */ scrollBarY,
+    /* scrollBarHeight */ scrollBarHeight,
+    /* textInfos */ textInfos,
+    /* cursorInfos */ cursorInfos,
+    /* selectionInfos */ selectionInfos,
+  ]
+}
+
+export const renderTextAndCursorAndSelections = (editor) => {
+  const commands = renderTextAndCursorAndSelectionsCommands(editor)
+  RendererProcess.send(commands)
+}
+
+export const setTokenizer = (editor, tokenizer) => {
+  editor.tokenizer = Tokenizer.getTokenizer(editor.languageId)
+  editor.invalidStartIndex = 0
+}
+
+// TODO
+export const setDeltaYFixedValue = (editor, value) => {
+  return EditorScrolling.setDeltaY(editor, value)
+  // renderTextAndCursorAndSelections(editor)
+}
+
+export const setDeltaY = (editor, value) => {
+  return setDeltaYFixedValue(editor, editor.deltaY + value)
+}
+
+export const scheduleSelections = (editor, selectionEdits) => {
+  return EditorSelection.setSelections(editor, selectionEdits)
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderCursorsAndSelections',
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const scheduleSelectionsAndScrollPosition = (editor, selectionEdits, deltaY) => {
+  const newEditor1 = EditorSelection.setSelections(editor, selectionEdits)
+  const newEditor2 = EditorScrolling.setDeltaY(newEditor1, deltaY)
+  return newEditor2
+  // EditorScrolling.setDeltaY(editor, deltaY)
+  // EditorSelection.setSelections(editor, selectionEdits)
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // const textInfos = EditorText.getVisible(editor)
+  // // TODO scrollbar calculation duplicate code
+  // const scrollBarY =
+  //   (editor.deltaY / editor.finalDeltaY) *
+  //   (editor.height - editor.scrollBarHeight)
+  // const scrollBarHeight = editor.scrollBarHeight
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderTextAndCursorsAndSelections',
+  //   /* deltaY */ scrollBarY,
+  //   /* scrollBarHeight */ scrollBarHeight,
+  //   /* textInfos */ textInfos,
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+/**
+ *
+ * @param {any} editor
+ * @param {any[]} changes
+ * @param {Uint32Array|undefined} selectionChanges
+ * @returns
+ */
+export const scheduleDocumentAndCursorsSelections = (editor, changes, selectionChanges = undefined) => {
+  Assert.object(editor)
+  Assert.array(changes)
+  if (changes.length === 0) {
+    return editor
+  }
+  const newLines = TextDocument.applyEdits(editor, changes)
+  const partialNewEditor = {
+    ...editor,
+    lines: newLines,
+  }
+  const newSelections = selectionChanges || EditorSelection.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 newEditor = {
+    ...partialNewEditor,
+    lines: newLines,
+    selections: newSelections,
+    undoStack: [...editor.undoStack, changes],
+    invalidStartIndex,
+  }
+  GlobalEventBus.emitEvent('editor.change', newEditor, changes)
+
+  return newEditor
+}
+
+export const scheduleDocumentAndCursorsSelectionIsUndo = (editor, changes) => {
+  Assert.object(editor)
+  Assert.array(changes)
+  if (changes.length === 0) {
+    return editor
+  }
+  const newLines = TextDocument.applyEdits(editor, changes)
+  const partialNewEditor = {
+    ...editor,
+    lines: newLines,
+  }
+  const newSelections = EditorSelection.applyEdit(partialNewEditor, changes)
+  const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex)
+  const newEditor = {
+    ...partialNewEditor,
+    lines: newLines,
+    selections: newSelections,
+    // undoStack: [...editor.undoStack.slice(0, -2)],
+    invalidStartIndex,
+  }
+  GlobalEventBus.emitEvent('editor.change', newEditor, changes)
+  return newEditor
+}
+
+export const scheduleDocument = async (editor, changes) => {
+  // console.log('before')
+  // console.log([...editor.lines])
+  const newLines = TextDocument.applyEdits(editor, changes)
+  // console.log('after')
+  // console.log([...editor.lines])
+  const invalidStartIndex = changes[0].start.rowIndex
+  // if (editor.undoStack) {
+  //   editor.undoStack.push(changes)
+  // }
+  // const cursorInfos = EditorCursor.getVisible(editor)
+  // const selectionInfos = EditorSelection.getVisible(editor)
+  // const textInfos = EditorText.getVisible(editor)
+  // TODO scrollbar calculation duplicate code
+  // const scrollBarY =
+  //   (editor.deltaY / editor.finalDeltaY) *
+  //   (editor.height - editor.scrollBarHeight)
+  // const scrollBarHeight = editor.scrollBarHeight
+
+  const newEditor = {
+    ...editor,
+    undoStack: [...editor.undoStack, changes],
+    lines: newLines,
+    invalidStartIndex,
+  }
+  // TODO change event should be emitted after rendering
+  GlobalEventBus.emitEvent('editor.change', editor, changes)
+  return newEditor
+  // RendererProcess.send([
+  //   /* Viewlet.invoke */ 'Viewlet.send',
+  //   /* id */ 'EditorText',
+  //   /* method */ 'renderTextAndCursorsAndSelections',
+  //   /* deltaY */ scrollBarY,
+  //   /* scrollBarHeight */ scrollBarHeight,
+  //   /* textInfos */ textInfos,
+  //   /* cursorInfos */ cursorInfos,
+  //   /* selectionInfos */ selectionInfos,
+  // ])
+}
+
+export const hasSelection = (editor) => {
+  // TODO editor.selections should always be defined
+  return editor.selections && editor.selections.length > 0
+}
+
+export const setBounds = (editor, x, y, height, columnWidth) => {
+  const { itemHeight } = editor
+  const numberOfVisibleLines = Math.floor(height / itemHeight)
+  const total = editor.lines.length
+  const maxLineY = Math.min(numberOfVisibleLines, total)
+  const finalY = Math.max(total - numberOfVisibleLines, 0)
+  const finalDeltaY = finalY * itemHeight
+  return {
+    ...editor,
+    x,
+    y,
+    height,
+    columnWidth,
+    numberOfVisibleLines,
+    maxLineY,
+    finalY,
+    finalDeltaY,
+  }
+}
+
+export const setText = (editor, text) => {
+  const lines = SplitLines.splitLines(text)
+  const { itemHeight, numberOfVisibleLines } = editor
+  const total = lines.length
+  const maxLineY = Math.min(numberOfVisibleLines, total)
+  const finalY = Math.max(total - numberOfVisibleLines, 0)
+  const finalDeltaY = finalY * itemHeight
+  const contentHeight = lines.length * editor.rowHeight
+  const scrollBarHeight = ScrollBarFunctions.getScrollBarHeight(editor.height, contentHeight, MINIMUM_SLIDER_SIZE)
+  return {
+    ...editor,
+    lines,
+    maxLineY,
+    finalY,
+    finalDeltaY,
+    scrollBarHeight,
+  }
+}
+
+const renderLines = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.lines === newState.lines &&
+      oldState.tokenizer === newState.tokenizer &&
+      oldState.minLineY === newState.minLineY &&
+      oldState.decorations === newState.decorations &&
+      oldState.embeds === newState.embeds
+    )
+  },
+  apply(oldState, newState) {
+    const textInfos = EditorText.getVisible(newState)
+    return [/* method */ 'setText', /* textInfos */ textInfos]
+  },
+}
+
+const renderSelections = {
+  isEqual(oldState, newState) {
+    return oldState.selections === newState.selections && oldState.focused === newState.focused && oldState.minLineY === newState.minLineY
+  },
+  apply(oldState, newState) {
+    const { cursorInfos, selectionInfos } = EditorSelection.getVisible(newState)
+    return [/* method */ 'setSelections', /* cursorInfos */ cursorInfos, /* selectionInfos */ selectionInfos]
+  },
+}
+
+const renderScrollBar = {
+  isEqual(oldState, newState) {
+    return oldState.deltaY === newState.deltaY && oldState.scrollBarHeight === newState.scrollBarHeight
+  },
+  apply(oldState, newState) {
+    const scrollBarY = ScrollBarFunctions.getScrollBarY(newState.deltaY, newState.finalDeltaY, newState.height, newState.scrollBarHeight)
+    return [/* method */ 'setScrollBar', /* scrollBarY */ scrollBarY, /* scrollBarHeight */ newState.scrollBarHeight]
+  },
+}
+
+const renderFocus = {
+  isEqual(oldState, newState) {
+    return oldState.focused === newState.focused
+  },
+  apply(oldState, newState) {
+    if (!newState.focused) {
+      return []
+    }
+    return [/* method */ 'focus']
+  },
+}
+
+export const render = [renderLines, renderSelections, renderScrollBar, renderFocus]

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

@@ -0,0 +1,209 @@
+import * as GetDecorationClassName from '../GetDecorationClassName/GetDecorationClassName.js'
+import * as GetTokensViewport from '../GetTokensViewport/GetTokensViewport.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Tokenizer from '../Tokenizer/Tokenizer.js'
+
+// 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
+// }
+
+// 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
+
+export const loadTokenizers = async (languageIds) => {
+  for (const languageId of languageIds) {
+    await Tokenizer.loadTokenizer(languageId)
+  }
+}
+
+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 getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line) => {
+  let start = 0
+  let end = 0
+  const lineInfo = []
+  const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex]
+  const embeddedTokens = embeddedResult.result.tokens
+  const embeddedTokenMap = embeddedResult.TokenMap
+  for (let i = 0; i < embeddedTokens.length; i += 2) {
+    const tokenType = embeddedTokens[i]
+    const tokenLength = embeddedTokens[i + 1]
+    let extraClassName = ''
+    end += tokenLength
+    const text = line.slice(start, end)
+    const className = `Token ${extraClassName || embeddedTokenMap[tokenType] || 'Unknown'}`
+    lineInfo.push(text, className)
+    start = end
+  }
+  return lineInfo
+}
+
+const getLineInfoDefault = (line, tokenResults, embeddedResults, 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
+    }
+  }
+  const tokens = tokenResults.tokens
+  // console.log({ tokens, decorations })
+  for (let i = 0; i < tokens.length; i += 2) {
+    const tokenType = tokens[i]
+    const tokenLength = tokens[i + 1]
+    const decorationOffset = decorations[decorationIndex]
+    let extraClassName = ''
+    if (decorationOffset !== undefined && 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.getDecorationClassName(decorationType)
+    }
+
+    end += tokenLength
+    const text = line.slice(start, end)
+
+    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`
+    lineInfo.push(text, className)
+    start = end
+  }
+  return lineInfo
+}
+
+const getLineInfo = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset) => {
+  if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
+    const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex]
+    if (embeddedResult && embeddedResult.isFull) {
+      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line)
+    }
+  }
+  return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset)
+}
+
+// TODO need lots of tests for this
+const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset) => {
+  const result = []
+  const { lines, tokenizer, decorations } = editor
+  const { TokenMap } = tokenizer
+  let offset = minLineOffset
+  for (let i = minLineY; i < maxLineY; i++) {
+    const line = lines[i]
+    result.push(getLineInfo(line, tokens[i - minLineY], embeddedResults, 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, numberOfVisibleLines, lines } = editor
+  const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length)
+  const { tokens, tokenizersToLoad, embeddedResults } = GetTokensViewport.getTokensViewport(editor, minLineY, maxLineY)
+  const minLineOffset = TextDocument.offsetAt(editor, minLineY, 0)
+  const textInfos = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset)
+  if (tokenizersToLoad.length > 0) {
+    loadTokenizers(tokenizersToLoad)
+  }
+  return textInfos
+}

package/static/c808931/packages/renderer-worker/src/parts/EditorCommand/EditorCommandCopy.js

@@ -0,0 +1,30 @@
+import * as Command from '../Command/Command.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Editor from '../Editor/Editor.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+
+// TODO add test
+export const copy = async (editor) => {
+  if (!Editor.hasSelection(editor)) {
+    // TODO copy line where cursor is
+    return editor
+  }
+  const selectionStartRowIndex = editor.selections[0]
+  const selectionStartColumnIndex = editor.selections[1]
+  const selectionEndRowIndex = editor.selections[2]
+  const selectionEndColumnIndex = editor.selections[3]
+  const range = {
+    start: {
+      rowIndex: selectionStartRowIndex,
+      columnIndex: selectionStartColumnIndex,
+    },
+    end: {
+      rowIndex: selectionEndRowIndex,
+      columnIndex: selectionEndColumnIndex,
+    },
+  }
+  const selectedLines = TextDocument.getSelectionText(editor, range)
+  const text = JoinLines.joinLines(selectedLines)
+  await Command.execute(/* ClipBoard.writeText */ 'ClipBoard.writeText', /* text */ text)
+  return editor
+}

package/static/c808931/packages/renderer-worker/src/parts/EditorCommand/EditorCommandCut.js

@@ -0,0 +1,19 @@
+import * as Command from '../Command/Command.js'
+import * as Editor from '../Editor/Editor.js'
+import * as EditOrigin from '../EditOrigin/EditOrigin.js'
+import { editorReplaceSelections } from './EditorCommandReplaceSelection.js'
+import * as JoinLines from '../JoinLines/JoinLines.js'
+
+export const cut = async (editor) => {
+  const selection = editor.selections[0]
+  if (selection.start === selection.end) {
+    // TODO cut line where cursor is
+  } else {
+    // cut selection
+  }
+  const changes = editorReplaceSelections(editor, [''], EditOrigin.EditorCut)
+  const text = JoinLines.joinLines(changes[0].deleted)
+  // TODO remove selected text from document
+  await Command.execute(/* ClipBoard.writeText */ 'ClipBoard.writeText', /* text */ text)
+  return Editor.scheduleDocumentAndCursorsSelections(editor, changes)
+}