qword 0.1.0

package/modules/codemirror/src/edit/commands.js

@@ -0,0 +1,178 @@
+import { deleteNearSelection } from "./deleteNearSelection.js"
+import { runInOp } from "../display/operations.js"
+import { ensureCursorVisible } from "../display/scrolling.js"
+import { endOfLine } from "../input/movement.js"
+import { clipPos, Pos } from "../line/pos.js"
+import { visualLine, visualLineEnd } from "../line/spans.js"
+import { getLine, lineNo } from "../line/utils_line.js"
+import { Range } from "../model/selection.js"
+import { selectAll } from "../model/selection_updates.js"
+import { countColumn, sel_dontScroll, sel_move, spaceStr } from "../util/misc.js"
+import { getOrder } from "../util/bidi.js"
+
+// Commands are parameter-less actions that can be performed on an
+// editor, mostly used for keybindings.
+export let commands = {
+  selectAll: selectAll,
+  singleSelection: cm => cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll),
+  killLine: cm => deleteNearSelection(cm, range => {
+    if (range.empty()) {
+      let len = getLine(cm.doc, range.head.line).text.length
+      if (range.head.ch == len && range.head.line < cm.lastLine())
+        return {from: range.head, to: Pos(range.head.line + 1, 0)}
+      else
+        return {from: range.head, to: Pos(range.head.line, len)}
+    } else {
+      return {from: range.from(), to: range.to()}
+    }
+  }),
+  deleteLine: cm => deleteNearSelection(cm, range => ({
+    from: Pos(range.from().line, 0),
+    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
+  })),
+  delLineLeft: cm => deleteNearSelection(cm, range => ({
+    from: Pos(range.from().line, 0), to: range.from()
+  })),
+  delWrappedLineLeft: cm => deleteNearSelection(cm, range => {
+    let top = cm.charCoords(range.head, "div").top + 5
+    let leftPos = cm.coordsChar({left: 0, top: top}, "div")
+    return {from: leftPos, to: range.from()}
+  }),
+  delWrappedLineRight: cm => deleteNearSelection(cm, range => {
+    let top = cm.charCoords(range.head, "div").top + 5
+    let rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+    return {from: range.from(), to: rightPos }
+  }),
+  undo: cm => cm.undo(),
+  redo: cm => cm.redo(),
+  undoSelection: cm => cm.undoSelection(),
+  redoSelection: cm => cm.redoSelection(),
+  goDocStart: cm => cm.extendSelection(Pos(cm.firstLine(), 0)),
+  goDocEnd: cm => cm.extendSelection(Pos(cm.lastLine())),
+  goLineStart: cm => cm.extendSelectionsBy(range => lineStart(cm, range.head.line),
+    {origin: "+move", bias: 1}
+  ),
+  goLineStartSmart: cm => cm.extendSelectionsBy(range => lineStartSmart(cm, range.head),
+    {origin: "+move", bias: 1}
+  ),
+  goLineEnd: cm => cm.extendSelectionsBy(range => lineEnd(cm, range.head.line),
+    {origin: "+move", bias: -1}
+  ),
+  goLineRight: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+  }, sel_move),
+  goLineLeft: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    return cm.coordsChar({left: 0, top: top}, "div")
+  }, sel_move),
+  goLineLeftSmart: cm => cm.extendSelectionsBy(range => {
+    let top = cm.cursorCoords(range.head, "div").top + 5
+    let pos = cm.coordsChar({left: 0, top: top}, "div")
+    if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head)
+    return pos
+  }, sel_move),
+  goLineUp: cm => cm.moveV(-1, "line"),
+  goLineDown: cm => cm.moveV(1, "line"),
+  goPageUp: cm => cm.moveV(-1, "page"),
+  goPageDown: cm => cm.moveV(1, "page"),
+  goCharLeft: cm => cm.moveH(-1, "char"),
+  goCharRight: cm => cm.moveH(1, "char"),
+  goColumnLeft: cm => cm.moveH(-1, "column"),
+  goColumnRight: cm => cm.moveH(1, "column"),
+  goWordLeft: cm => cm.moveH(-1, "word"),
+  goGroupRight: cm => cm.moveH(1, "group"),
+  goGroupLeft: cm => cm.moveH(-1, "group"),
+  goWordRight: cm => cm.moveH(1, "word"),
+  delCharBefore: cm => cm.deleteH(-1, "codepoint"),
+  delCharAfter: cm => cm.deleteH(1, "char"),
+  delWordBefore: cm => cm.deleteH(-1, "word"),
+  delWordAfter: cm => cm.deleteH(1, "word"),
+  delGroupBefore: cm => cm.deleteH(-1, "group"),
+  delGroupAfter: cm => cm.deleteH(1, "group"),
+  indentAuto: cm => cm.indentSelection("smart"),
+  indentMore: cm => cm.indentSelection("add"),
+  indentLess: cm => cm.indentSelection("subtract"),
+  insertTab: cm => cm.replaceSelection("\t"),
+  insertSoftTab: cm => {
+    let spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
+    for (let i = 0; i < ranges.length; i++) {
+      let pos = ranges[i].from()
+      let col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
+      spaces.push(spaceStr(tabSize - col % tabSize))
+    }
+    cm.replaceSelections(spaces)
+  },
+  defaultTab: cm => {
+    if (cm.somethingSelected()) cm.indentSelection("add")
+    else cm.execCommand("insertTab")
+  },
+  // Swap the two chars left and right of each selection's head.
+  // Move cursor behind the two swapped characters afterwards.
+  //
+  // Doesn't consider line feeds a character.
+  // Doesn't scan more than one line above to find a character.
+  // Doesn't do anything on an empty line.
+  // Doesn't do anything with non-empty selections.
+  transposeChars: cm => runInOp(cm, () => {
+    let ranges = cm.listSelections(), newSel = []
+    for (let i = 0; i < ranges.length; i++) {
+      if (!ranges[i].empty()) continue
+      let cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
+      if (line) {
+        if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1)
+        if (cur.ch > 0) {
+          cur = new Pos(cur.line, cur.ch + 1)
+          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
+                          Pos(cur.line, cur.ch - 2), cur, "+transpose")
+        } else if (cur.line > cm.doc.first) {
+          let prev = getLine(cm.doc, cur.line - 1).text
+          if (prev) {
+            cur = new Pos(cur.line, 1)
+            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
+                            prev.charAt(prev.length - 1),
+                            Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
+          }
+        }
+      }
+      newSel.push(new Range(cur, cur))
+    }
+    cm.setSelections(newSel)
+  }),
+  newlineAndIndent: cm => runInOp(cm, () => {
+    let sels = cm.listSelections()
+    for (let i = sels.length - 1; i >= 0; i--)
+      cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input")
+    sels = cm.listSelections()
+    for (let i = 0; i < sels.length; i++)
+      cm.indentLine(sels[i].from().line, null, true)
+    ensureCursorVisible(cm)
+  }),
+  openLine: cm => cm.replaceSelection("\n", "start"),
+  toggleOverwrite: cm => cm.toggleOverwrite()
+}
+
+
+function lineStart(cm, lineN) {
+  let line = getLine(cm.doc, lineN)
+  let visual = visualLine(line)
+  if (visual != line) lineN = lineNo(visual)
+  return endOfLine(true, cm, visual, lineN, 1)
+}
+function lineEnd(cm, lineN) {
+  let line = getLine(cm.doc, lineN)
+  let visual = visualLineEnd(line)
+  if (visual != line) lineN = lineNo(visual)
+  return endOfLine(true, cm, line, lineN, -1)
+}
+function lineStartSmart(cm, pos) {
+  let start = lineStart(cm, pos.line)
+  let line = getLine(cm.doc, start.line)
+  let order = getOrder(line, cm.doc.direction)
+  if (!order || order[0].level == 0) {
+    let firstNonWS = Math.max(start.ch, line.text.search(/\S/))
+    let inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
+    return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)
+  }
+  return start
+}

package/modules/codemirror/src/edit/deleteNearSelection.js

@@ -0,0 +1,30 @@
+import { runInOp } from "../display/operations.js"
+import { ensureCursorVisible } from "../display/scrolling.js"
+import { cmp } from "../line/pos.js"
+import { replaceRange } from "../model/changes.js"
+import { lst } from "../util/misc.js"
+
+// Helper for deleting text near the selection(s), used to implement
+// backspace, delete, and similar functionality.
+export function deleteNearSelection(cm, compute) {
+  let ranges = cm.doc.sel.ranges, kill = []
+  // Build up a set of ranges to kill first, merging overlapping
+  // ranges.
+  for (let i = 0; i < ranges.length; i++) {
+    let toKill = compute(ranges[i])
+    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
+      let replaced = kill.pop()
+      if (cmp(replaced.from, toKill.from) < 0) {
+        toKill.from = replaced.from
+        break
+      }
+    }
+    kill.push(toKill)
+  }
+  // Next, remove those actual ranges.
+  runInOp(cm, () => {
+    for (let i = kill.length - 1; i >= 0; i--)
+      replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete")
+    ensureCursorVisible(cm)
+  })
+}

package/modules/codemirror/src/edit/drop_events.js

@@ -0,0 +1,130 @@
+import { drawSelectionCursor } from "../display/selection.js"
+import { operation } from "../display/operations.js"
+import { clipPos } from "../line/pos.js"
+import { posFromMouse } from "../measurement/position_measurement.js"
+import { eventInWidget } from "../measurement/widgets.js"
+import { makeChange, replaceRange } from "../model/changes.js"
+import { changeEnd } from "../model/change_measurement.js"
+import { simpleSelection } from "../model/selection.js"
+import { setSelectionNoUndo, setSelectionReplaceHistory } from "../model/selection_updates.js"
+import { ie, presto, safari } from "../util/browser.js"
+import { elt, removeChildrenAndAdd } from "../util/dom.js"
+import { e_preventDefault, e_stop, signalDOMEvent } from "../util/event.js"
+import { indexOf } from "../util/misc.js"
+
+// Kludge to work around strange IE behavior where it'll sometimes
+// re-fire a series of drag-related events right after the drop (#1551)
+let lastDrop = 0
+
+export function onDrop(e) {
+  let cm = this
+  clearDragCursor(cm)
+  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
+    return
+  e_preventDefault(e)
+  if (ie) lastDrop = +new Date
+  let pos = posFromMouse(cm, e, true), files = e.dataTransfer.files
+  if (!pos || cm.isReadOnly()) return
+  // Might be a file drop, in which case we simply extract the text
+  // and insert it.
+  if (files && files.length && window.FileReader && window.File) {
+    let n = files.length, text = Array(n), read = 0
+    const markAsReadAndPasteIfAllFilesAreRead = () => {
+      if (++read == n) {
+        operation(cm, () => {
+          pos = clipPos(cm.doc, pos)
+          let change = {from: pos, to: pos,
+                        text: cm.doc.splitLines(
+                            text.filter(t => t != null).join(cm.doc.lineSeparator())),
+                        origin: "paste"}
+          makeChange(cm.doc, change)
+          setSelectionReplaceHistory(cm.doc, simpleSelection(clipPos(cm.doc, pos), clipPos(cm.doc, changeEnd(change))))
+        })()
+      }
+    }
+    const readTextFromFile = (file, i) => {
+      if (cm.options.allowDropFileTypes &&
+          indexOf(cm.options.allowDropFileTypes, file.type) == -1) {
+        markAsReadAndPasteIfAllFilesAreRead()
+        return
+      }
+      let reader = new FileReader
+      reader.onerror = () => markAsReadAndPasteIfAllFilesAreRead()
+      reader.onload = () => {
+        let content = reader.result
+        if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) {
+          markAsReadAndPasteIfAllFilesAreRead()
+          return
+        }
+        text[i] = content
+        markAsReadAndPasteIfAllFilesAreRead()
+      }
+      reader.readAsText(file)
+    }
+    for (let i = 0; i < files.length; i++) readTextFromFile(files[i], i)
+  } else { // Normal drop
+    // Don't do a replace if the drop happened inside of the selected text.
+    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
+      cm.state.draggingText(e)
+      // Ensure the editor is re-focused
+      setTimeout(() => cm.display.input.focus(), 20)
+      return
+    }
+    try {
+      let text = e.dataTransfer.getData("Text")
+      if (text) {
+        let selected
+        if (cm.state.draggingText && !cm.state.draggingText.copy)
+          selected = cm.listSelections()
+        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))
+        if (selected) for (let i = 0; i < selected.length; ++i)
+          replaceRange(cm.doc, "", selected[i].anchor, selected[i].head, "drag")
+        cm.replaceSelection(text, "around", "paste")
+        cm.display.input.focus()
+      }
+    }
+    catch(e){}
+  }
+}
+
+export function onDragStart(cm, e) {
+  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
+  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return
+
+  e.dataTransfer.setData("Text", cm.getSelection())
+  e.dataTransfer.effectAllowed = "copyMove"
+
+  // Use dummy image instead of default browsers image.
+  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
+  if (e.dataTransfer.setDragImage && !safari) {
+    let img = elt("img", null, null, "position: fixed; left: 0; top: 0;")
+    img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
+    if (presto) {
+      img.width = img.height = 1
+      cm.display.wrapper.appendChild(img)
+      // Force a relayout, or Opera won't use our image for some obscure reason
+      img._top = img.offsetTop
+    }
+    e.dataTransfer.setDragImage(img, 0, 0)
+    if (presto) img.parentNode.removeChild(img)
+  }
+}
+
+export function onDragOver(cm, e) {
+  let pos = posFromMouse(cm, e)
+  if (!pos) return
+  let frag = document.createDocumentFragment()
+  drawSelectionCursor(cm, pos, frag)
+  if (!cm.display.dragCursor) {
+    cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors")
+    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)
+  }
+  removeChildrenAndAdd(cm.display.dragCursor, frag)
+}
+
+export function clearDragCursor(cm) {
+  if (cm.display.dragCursor) {
+    cm.display.lineSpace.removeChild(cm.display.dragCursor)
+    cm.display.dragCursor = null
+  }
+}

package/modules/codemirror/src/edit/fromTextArea.js

@@ -0,0 +1,61 @@
+import { CodeMirror } from "./CodeMirror.js"
+import { activeElt, rootNode } from "../util/dom.js"
+import { off, on } from "../util/event.js"
+import { copyObj } from "../util/misc.js"
+
+export function fromTextArea(textarea, options) {
+  options = options ? copyObj(options) : {}
+  options.value = textarea.value
+  if (!options.tabindex && textarea.tabIndex)
+    options.tabindex = textarea.tabIndex
+  if (!options.placeholder && textarea.placeholder)
+    options.placeholder = textarea.placeholder
+  // Set autofocus to true if this textarea is focused, or if it has
+  // autofocus and no other element is focused.
+  if (options.autofocus == null) {
+    let hasFocus = activeElt(rootNode(textarea))
+    options.autofocus = hasFocus == textarea ||
+      textarea.getAttribute("autofocus") != null && hasFocus == document.body
+  }
+
+  function save() {textarea.value = cm.getValue()}
+
+  let realSubmit
+  if (textarea.form) {
+    on(textarea.form, "submit", save)
+    // Deplorable hack to make the submit method do the right thing.
+    if (!options.leaveSubmitMethodAlone) {
+      let form = textarea.form
+      realSubmit = form.submit
+      try {
+        let wrappedSubmit = form.submit = () => {
+          save()
+          form.submit = realSubmit
+          form.submit()
+          form.submit = wrappedSubmit
+        }
+      } catch(e) {}
+    }
+  }
+
+  options.finishInit = cm => {
+    cm.save = save
+    cm.getTextArea = () => textarea
+    cm.toTextArea = () => {
+      cm.toTextArea = isNaN // Prevent this from being ran twice
+      save()
+      textarea.parentNode.removeChild(cm.getWrapperElement())
+      textarea.style.display = ""
+      if (textarea.form) {
+        off(textarea.form, "submit", save)
+        if (!options.leaveSubmitMethodAlone && typeof textarea.form.submit == "function")
+          textarea.form.submit = realSubmit
+      }
+    }
+  }
+
+  textarea.style.display = "none"
+  let cm = CodeMirror(node => textarea.parentNode.insertBefore(node, textarea.nextSibling),
+    options)
+  return cm
+}

package/modules/codemirror/src/edit/global_events.js

@@ -0,0 +1,45 @@
+import { onBlur } from "../display/focus.js"
+import { on } from "../util/event.js"
+
+// These must be handled carefully, because naively registering a
+// handler for each editor will cause the editors to never be
+// garbage collected.
+
+function forEachCodeMirror(f) {
+  if (!document.getElementsByClassName) return
+  let byClass = document.getElementsByClassName("CodeMirror"), editors = []
+  for (let i = 0; i < byClass.length; i++) {
+    let cm = byClass[i].CodeMirror
+    if (cm) editors.push(cm)
+  }
+  if (editors.length) editors[0].operation(() => {
+    for (let i = 0; i < editors.length; i++) f(editors[i])
+  })
+}
+
+let globalsRegistered = false
+export function ensureGlobalHandlers() {
+  if (globalsRegistered) return
+  registerGlobalHandlers()
+  globalsRegistered = true
+}
+function registerGlobalHandlers() {
+  // When the window resizes, we need to refresh active editors.
+  let resizeTimer
+  on(window, "resize", () => {
+    if (resizeTimer == null) resizeTimer = setTimeout(() => {
+      resizeTimer = null
+      forEachCodeMirror(onResize)
+    }, 100)
+  })
+  // When the window loses focus, we want to show the editor as blurred
+  on(window, "blur", () => forEachCodeMirror(onBlur))
+}
+// Called when the window resizes
+function onResize(cm) {
+  let d = cm.display
+  // Might be a text scaling operation, clear size caches.
+  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
+  d.scrollbarsClipped = false
+  cm.setSize()
+}

package/modules/codemirror/src/edit/key_events.js

@@ -0,0 +1,163 @@
+import { signalLater } from "../util/operation_group.js"
+import { restartBlink } from "../display/selection.js"
+import { isModifierKey, keyName, lookupKey } from "../input/keymap.js"
+import { eventInWidget } from "../measurement/widgets.js"
+import { ie, ie_version, mac, presto, gecko } from "../util/browser.js"
+import { activeElt, addClass, rmClass, root } from "../util/dom.js"
+import { e_preventDefault, off, on, signalDOMEvent } from "../util/event.js"
+import { hasCopyEvent } from "../util/feature_detection.js"
+import { Delayed, Pass } from "../util/misc.js"
+
+import { commands } from "./commands.js"
+
+// Run a handler that was bound to a key.
+function doHandleBinding(cm, bound, dropShift) {
+  if (typeof bound == "string") {
+    bound = commands[bound]
+    if (!bound) return false
+  }
+  // Ensure previous input has been read, so that the handler sees a
+  // consistent view of the document
+  cm.display.input.ensurePolled()
+  let prevShift = cm.display.shift, done = false
+  try {
+    if (cm.isReadOnly()) cm.state.suppressEdits = true
+    if (dropShift) cm.display.shift = false
+    done = bound(cm) != Pass
+  } finally {
+    cm.display.shift = prevShift
+    cm.state.suppressEdits = false
+  }
+  return done
+}
+
+function lookupKeyForEditor(cm, name, handle) {
+  for (let i = 0; i < cm.state.keyMaps.length; i++) {
+    let result = lookupKey(name, cm.state.keyMaps[i], handle, cm)
+    if (result) return result
+  }
+  return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
+    || lookupKey(name, cm.options.keyMap, handle, cm)
+}
+
+// Note that, despite the name, this function is also used to check
+// for bound mouse clicks.
+
+let stopSeq = new Delayed
+
+export function dispatchKey(cm, name, e, handle) {
+  let seq = cm.state.keySeq
+  if (seq) {
+    if (isModifierKey(name)) return "handled"
+    if (/\'$/.test(name))
+      cm.state.keySeq = null
+    else
+      stopSeq.set(50, () => {
+        if (cm.state.keySeq == seq) {
+          cm.state.keySeq = null
+          cm.display.input.reset()
+        }
+      })
+    if (dispatchKeyInner(cm, seq + " " + name, e, handle)) return true
+  }
+  return dispatchKeyInner(cm, name, e, handle)
+}
+
+function dispatchKeyInner(cm, name, e, handle) {
+  let result = lookupKeyForEditor(cm, name, handle)
+
+  if (result == "multi")
+    cm.state.keySeq = name
+  if (result == "handled")
+    signalLater(cm, "keyHandled", cm, name, e)
+
+  if (result == "handled" || result == "multi") {
+    e_preventDefault(e)
+    restartBlink(cm)
+  }
+
+  return !!result
+}
+
+// Handle a key from the keydown event.
+function handleKeyBinding(cm, e) {
+  let name = keyName(e, true)
+  if (!name) return false
+
+  if (e.shiftKey && !cm.state.keySeq) {
+    // First try to resolve full name (including 'Shift-'). Failing
+    // that, see if there is a cursor-motion command (starting with
+    // 'go') bound to the keyname without 'Shift-'.
+    return dispatchKey(cm, "Shift-" + name, e, b => doHandleBinding(cm, b, true))
+        || dispatchKey(cm, name, e, b => {
+             if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
+               return doHandleBinding(cm, b)
+           })
+  } else {
+    return dispatchKey(cm, name, e, b => doHandleBinding(cm, b))
+  }
+}
+
+// Handle a key from the keypress event
+function handleCharBinding(cm, e, ch) {
+  return dispatchKey(cm, "'" + ch + "'", e, b => doHandleBinding(cm, b, true))
+}
+
+let lastStoppedKey = null
+export function onKeyDown(e) {
+  let cm = this
+  if (e.target && e.target != cm.display.input.getField()) return
+  cm.curOp.focus = activeElt(root(cm))
+  if (signalDOMEvent(cm, e)) return
+  // IE does strange things with escape.
+  if (ie && ie_version < 11 && e.keyCode == 27) e.returnValue = false
+  let code = e.keyCode
+  cm.display.shift = code == 16 || e.shiftKey
+  let handled = handleKeyBinding(cm, e)
+  if (presto) {
+    lastStoppedKey = handled ? code : null
+    // Opera has no cut event... we try to at least catch the key combo
+    if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
+      cm.replaceSelection("", null, "cut")
+  }
+  if (gecko && !mac && !handled && code == 46 && e.shiftKey && !e.ctrlKey && document.execCommand)
+    document.execCommand("cut")
+
+  // Turn mouse into crosshair when Alt is held on Mac.
+  if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
+    showCrossHair(cm)
+}
+
+function showCrossHair(cm) {
+  let lineDiv = cm.display.lineDiv
+  addClass(lineDiv, "CodeMirror-crosshair")
+
+  function up(e) {
+    if (e.keyCode == 18 || !e.altKey) {
+      rmClass(lineDiv, "CodeMirror-crosshair")
+      off(document, "keyup", up)
+      off(document, "mouseover", up)
+    }
+  }
+  on(document, "keyup", up)
+  on(document, "mouseover", up)
+}
+
+export function onKeyUp(e) {
+  if (e.keyCode == 16) this.doc.sel.shift = false
+  signalDOMEvent(this, e)
+}
+
+export function onKeyPress(e) {
+  let cm = this
+  if (e.target && e.target != cm.display.input.getField()) return
+  if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) return
+  let keyCode = e.keyCode, charCode = e.charCode
+  if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}
+  if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) return
+  let ch = String.fromCharCode(charCode == null ? keyCode : charCode)
+  // Some browsers fire keypress events for backspace
+  if (ch == "\x08") return
+  if (handleCharBinding(cm, e, ch)) return
+  cm.display.input.onKeyPress(e)
+}

package/modules/codemirror/src/edit/legacy.js

@@ -0,0 +1,62 @@
+import { scrollbarModel } from "../display/scrollbars.js"
+import { wheelEventPixels } from "../display/scroll_events.js"
+import { keyMap, keyName, isModifierKey, lookupKey, normalizeKeyMap } from "../input/keymap.js"
+import { keyNames } from "../input/keynames.js"
+import { Line } from "../line/line_data.js"
+import { cmp, Pos } from "../line/pos.js"
+import { changeEnd } from "../model/change_measurement.js"
+import Doc from "../model/Doc.js"
+import { LineWidget } from "../model/line_widget.js"
+import { SharedTextMarker, TextMarker } from "../model/mark_text.js"
+import { copyState, extendMode, getMode, innerMode, mimeModes, modeExtensions, modes, resolveMode, startState } from "../modes.js"
+import { addClass, contains, rmClass } from "../util/dom.js"
+import { e_preventDefault, e_stop, e_stopPropagation, off, on, signal } from "../util/event.js"
+import { splitLinesAuto } from "../util/feature_detection.js"
+import { countColumn, findColumn, isWordCharBasic, Pass } from "../util/misc.js"
+import StringStream from "../util/StringStream.js"
+
+import { commands } from "./commands.js"
+
+export function addLegacyProps(CodeMirror) {
+  CodeMirror.off = off
+  CodeMirror.on = on
+  CodeMirror.wheelEventPixels = wheelEventPixels
+  CodeMirror.Doc = Doc
+  CodeMirror.splitLines = splitLinesAuto
+  CodeMirror.countColumn = countColumn
+  CodeMirror.findColumn = findColumn
+  CodeMirror.isWordChar = isWordCharBasic
+  CodeMirror.Pass = Pass
+  CodeMirror.signal = signal
+  CodeMirror.Line = Line
+  CodeMirror.changeEnd = changeEnd
+  CodeMirror.scrollbarModel = scrollbarModel
+  CodeMirror.Pos = Pos
+  CodeMirror.cmpPos = cmp
+  CodeMirror.modes = modes
+  CodeMirror.mimeModes = mimeModes
+  CodeMirror.resolveMode = resolveMode
+  CodeMirror.getMode = getMode
+  CodeMirror.modeExtensions = modeExtensions
+  CodeMirror.extendMode = extendMode
+  CodeMirror.copyState = copyState
+  CodeMirror.startState = startState
+  CodeMirror.innerMode = innerMode
+  CodeMirror.commands = commands
+  CodeMirror.keyMap = keyMap
+  CodeMirror.keyName = keyName
+  CodeMirror.isModifierKey = isModifierKey
+  CodeMirror.lookupKey = lookupKey
+  CodeMirror.normalizeKeyMap = normalizeKeyMap
+  CodeMirror.StringStream = StringStream
+  CodeMirror.SharedTextMarker = SharedTextMarker
+  CodeMirror.TextMarker = TextMarker
+  CodeMirror.LineWidget = LineWidget
+  CodeMirror.e_preventDefault = e_preventDefault
+  CodeMirror.e_stopPropagation = e_stopPropagation
+  CodeMirror.e_stop = e_stop
+  CodeMirror.addClass = addClass
+  CodeMirror.contains = contains
+  CodeMirror.rmClass = rmClass
+  CodeMirror.keyNames = keyNames
+}