qword 0.1.0

package/modules/codemirror/src/display/update_line.js

@@ -0,0 +1,189 @@
+import { buildLineContent } from "../line/line_data.js"
+import { lineNumberFor } from "../line/utils_line.js"
+import { ie, ie_version } from "../util/browser.js"
+import { elt, classTest } from "../util/dom.js"
+import { signalLater } from "../util/operation_group.js"
+
+// When an aspect of a line changes, a string is added to
+// lineView.changes. This updates the relevant part of the line's
+// DOM structure.
+export function updateLineForChanges(cm, lineView, lineN, dims) {
+  for (let j = 0; j < lineView.changes.length; j++) {
+    let type = lineView.changes[j]
+    if (type == "text") updateLineText(cm, lineView)
+    else if (type == "gutter") updateLineGutter(cm, lineView, lineN, dims)
+    else if (type == "class") updateLineClasses(cm, lineView)
+    else if (type == "widget") updateLineWidgets(cm, lineView, dims)
+  }
+  lineView.changes = null
+}
+
+// Lines with gutter elements, widgets or a background class need to
+// be wrapped, and have the extra elements added to the wrapper div
+function ensureLineWrapped(lineView) {
+  if (lineView.node == lineView.text) {
+    lineView.node = elt("div", null, null, "position: relative")
+    if (lineView.text.parentNode)
+      lineView.text.parentNode.replaceChild(lineView.node, lineView.text)
+    lineView.node.appendChild(lineView.text)
+    if (ie && ie_version < 8) lineView.node.style.zIndex = 2
+  }
+  return lineView.node
+}
+
+function updateLineBackground(cm, lineView) {
+  let cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass
+  if (cls) cls += " CodeMirror-linebackground"
+  if (lineView.background) {
+    if (cls) lineView.background.className = cls
+    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }
+  } else if (cls) {
+    let wrap = ensureLineWrapped(lineView)
+    lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild)
+    cm.display.input.setUneditable(lineView.background)
+  }
+}
+
+// Wrapper around buildLineContent which will reuse the structure
+// in display.externalMeasured when possible.
+function getLineContent(cm, lineView) {
+  let ext = cm.display.externalMeasured
+  if (ext && ext.line == lineView.line) {
+    cm.display.externalMeasured = null
+    lineView.measure = ext.measure
+    return ext.built
+  }
+  return buildLineContent(cm, lineView)
+}
+
+// Redraw the line's text. Interacts with the background and text
+// classes because the mode may output tokens that influence these
+// classes.
+function updateLineText(cm, lineView) {
+  let cls = lineView.text.className
+  let built = getLineContent(cm, lineView)
+  if (lineView.text == lineView.node) lineView.node = built.pre
+  lineView.text.parentNode.replaceChild(built.pre, lineView.text)
+  lineView.text = built.pre
+  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
+    lineView.bgClass = built.bgClass
+    lineView.textClass = built.textClass
+    updateLineClasses(cm, lineView)
+  } else if (cls) {
+    lineView.text.className = cls
+  }
+}
+
+function updateLineClasses(cm, lineView) {
+  updateLineBackground(cm, lineView)
+  if (lineView.line.wrapClass)
+    ensureLineWrapped(lineView).className = lineView.line.wrapClass
+  else if (lineView.node != lineView.text)
+    lineView.node.className = ""
+  let textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass
+  lineView.text.className = textClass || ""
+}
+
+function updateLineGutter(cm, lineView, lineN, dims) {
+  if (lineView.gutter) {
+    lineView.node.removeChild(lineView.gutter)
+    lineView.gutter = null
+  }
+  if (lineView.gutterBackground) {
+    lineView.node.removeChild(lineView.gutterBackground)
+    lineView.gutterBackground = null
+  }
+  if (lineView.line.gutterClass) {
+    let wrap = ensureLineWrapped(lineView)
+    lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
+                                    `left: ${cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth}px; width: ${dims.gutterTotalWidth}px`)
+    cm.display.input.setUneditable(lineView.gutterBackground)
+    wrap.insertBefore(lineView.gutterBackground, lineView.text)
+  }
+  let markers = lineView.line.gutterMarkers
+  if (cm.options.lineNumbers || markers) {
+    let wrap = ensureLineWrapped(lineView)
+    let gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", `left: ${cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth}px`)
+    gutterWrap.setAttribute("aria-hidden", "true")
+    cm.display.input.setUneditable(gutterWrap)
+    wrap.insertBefore(gutterWrap, lineView.text)
+    if (lineView.line.gutterClass)
+      gutterWrap.className += " " + lineView.line.gutterClass
+    if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
+      lineView.lineNumber = gutterWrap.appendChild(
+        elt("div", lineNumberFor(cm.options, lineN),
+            "CodeMirror-linenumber CodeMirror-gutter-elt",
+            `left: ${dims.gutterLeft["CodeMirror-linenumbers"]}px; width: ${cm.display.lineNumInnerWidth}px`))
+    if (markers) for (let k = 0; k < cm.display.gutterSpecs.length; ++k) {
+      let id = cm.display.gutterSpecs[k].className, found = markers.hasOwnProperty(id) && markers[id]
+      if (found)
+        gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt",
+                                   `left: ${dims.gutterLeft[id]}px; width: ${dims.gutterWidth[id]}px`))
+    }
+  }
+}
+
+function updateLineWidgets(cm, lineView, dims) {
+  if (lineView.alignable) lineView.alignable = null
+  let isWidget = classTest("CodeMirror-linewidget")
+  for (let node = lineView.node.firstChild, next; node; node = next) {
+    next = node.nextSibling
+    if (isWidget.test(node.className)) lineView.node.removeChild(node)
+  }
+  insertLineWidgets(cm, lineView, dims)
+}
+
+// Build a line's DOM representation from scratch
+export function buildLineElement(cm, lineView, lineN, dims) {
+  let built = getLineContent(cm, lineView)
+  lineView.text = lineView.node = built.pre
+  if (built.bgClass) lineView.bgClass = built.bgClass
+  if (built.textClass) lineView.textClass = built.textClass
+
+  updateLineClasses(cm, lineView)
+  updateLineGutter(cm, lineView, lineN, dims)
+  insertLineWidgets(cm, lineView, dims)
+  return lineView.node
+}
+
+// A lineView may contain multiple logical lines (when merged by
+// collapsed spans). The widgets for all of them need to be drawn.
+function insertLineWidgets(cm, lineView, dims) {
+  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)
+  if (lineView.rest) for (let i = 0; i < lineView.rest.length; i++)
+    insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false)
+}
+
+function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
+  if (!line.widgets) return
+  let wrap = ensureLineWrapped(lineView)
+  for (let i = 0, ws = line.widgets; i < ws.length; ++i) {
+    let widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget" + (widget.className ? " " + widget.className : ""))
+    if (!widget.handleMouseEvents) node.setAttribute("cm-ignore-events", "true")
+    positionLineWidget(widget, node, lineView, dims)
+    cm.display.input.setUneditable(node)
+    if (allowAbove && widget.above)
+      wrap.insertBefore(node, lineView.gutter || lineView.text)
+    else
+      wrap.appendChild(node)
+    signalLater(widget, "redraw")
+  }
+}
+
+function positionLineWidget(widget, node, lineView, dims) {
+  if (widget.noHScroll) {
+    ;(lineView.alignable || (lineView.alignable = [])).push(node)
+    let width = dims.wrapperWidth
+    node.style.left = dims.fixedPos + "px"
+    if (!widget.coverGutter) {
+      width -= dims.gutterTotalWidth
+      node.style.paddingLeft = dims.gutterTotalWidth + "px"
+    }
+    node.style.width = width + "px"
+  }
+  if (widget.coverGutter) {
+    node.style.zIndex = 5
+    node.style.position = "relative"
+    if (!widget.noHScroll) node.style.marginLeft = -dims.gutterTotalWidth + "px"
+  }
+}

package/modules/codemirror/src/display/update_lines.js

@@ -0,0 +1,82 @@
+import { heightAtLine } from "../line/spans.js"
+import { getLine, lineAtHeight, updateLineHeight } from "../line/utils_line.js"
+import { paddingTop, charWidth } from "../measurement/position_measurement.js"
+import { ie, ie_version } from "../util/browser.js"
+
+// Read the actual heights of the rendered lines, and update their
+// stored heights to match.
+export function updateHeightsInViewport(cm) {
+  let display = cm.display
+  let prevBottom = display.lineDiv.offsetTop
+  let viewTop = Math.max(0, display.scroller.getBoundingClientRect().top)
+  let oldHeight = display.lineDiv.getBoundingClientRect().top
+  let mustScroll = 0
+  for (let i = 0; i < display.view.length; i++) {
+    let cur = display.view[i], wrapping = cm.options.lineWrapping
+    let height, width = 0
+    if (cur.hidden) continue
+    oldHeight += cur.line.height
+    if (ie && ie_version < 8) {
+      let bot = cur.node.offsetTop + cur.node.offsetHeight
+      height = bot - prevBottom
+      prevBottom = bot
+    } else {
+      let box = cur.node.getBoundingClientRect()
+      height = box.bottom - box.top
+      // Check that lines don't extend past the right of the current
+      // editor width
+      if (!wrapping && cur.text.firstChild)
+        width = cur.text.firstChild.getBoundingClientRect().right - box.left - 1
+    }
+    let diff = cur.line.height - height
+    if (diff > .005 || diff < -.005) {
+      if (oldHeight < viewTop) mustScroll -= diff
+      updateLineHeight(cur.line, height)
+      updateWidgetHeight(cur.line)
+      if (cur.rest) for (let j = 0; j < cur.rest.length; j++)
+        updateWidgetHeight(cur.rest[j])
+    }
+    if (width > cm.display.sizerWidth) {
+      let chWidth = Math.ceil(width / charWidth(cm.display))
+      if (chWidth > cm.display.maxLineLength) {
+        cm.display.maxLineLength = chWidth
+        cm.display.maxLine = cur.line
+        cm.display.maxLineChanged = true
+      }
+    }
+  }
+  if (Math.abs(mustScroll) > 2) display.scroller.scrollTop += mustScroll
+}
+
+// Read and store the height of line widgets associated with the
+// given line.
+function updateWidgetHeight(line) {
+  if (line.widgets) for (let i = 0; i < line.widgets.length; ++i) {
+    let w = line.widgets[i], parent = w.node.parentNode
+    if (parent) w.height = parent.offsetHeight
+  }
+}
+
+// Compute the lines that are visible in a given viewport (defaults
+// the current scroll position). viewport may contain top,
+// height, and ensure (see op.scrollToPos) properties.
+export function visibleLines(display, doc, viewport) {
+  let top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop
+  top = Math.floor(top - paddingTop(display))
+  let bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight
+
+  let from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)
+  // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
+  // forces those lines into the viewport (if possible).
+  if (viewport && viewport.ensure) {
+    let ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line
+    if (ensureFrom < from) {
+      from = ensureFrom
+      to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)
+    } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
+      from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)
+      to = ensureTo
+    }
+  }
+  return {from: from, to: Math.max(to, from + 1)}
+}

package/modules/codemirror/src/display/view_tracking.js

@@ -0,0 +1,153 @@
+import { buildViewArray } from "../line/line_data.js"
+import { sawCollapsedSpans } from "../line/saw_special_spans.js"
+import { visualLineEndNo, visualLineNo } from "../line/spans.js"
+import { findViewIndex } from "../measurement/position_measurement.js"
+import { indexOf } from "../util/misc.js"
+
+// Updates the display.view data structure for a given change to the
+// document. From and to are in pre-change coordinates. Lendiff is
+// the amount of lines added or subtracted by the change. This is
+// used for changes that span multiple lines, or change the way
+// lines are divided into visual lines. regLineChange (below)
+// registers single-line changes.
+export function regChange(cm, from, to, lendiff) {
+  if (from == null) from = cm.doc.first
+  if (to == null) to = cm.doc.first + cm.doc.size
+  if (!lendiff) lendiff = 0
+
+  let display = cm.display
+  if (lendiff && to < display.viewTo &&
+      (display.updateLineNumbers == null || display.updateLineNumbers > from))
+    display.updateLineNumbers = from
+
+  cm.curOp.viewChanged = true
+
+  if (from >= display.viewTo) { // Change after
+    if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
+      resetView(cm)
+  } else if (to <= display.viewFrom) { // Change before
+    if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
+      resetView(cm)
+    } else {
+      display.viewFrom += lendiff
+      display.viewTo += lendiff
+    }
+  } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
+    resetView(cm)
+  } else if (from <= display.viewFrom) { // Top overlap
+    let cut = viewCuttingPoint(cm, to, to + lendiff, 1)
+    if (cut) {
+      display.view = display.view.slice(cut.index)
+      display.viewFrom = cut.lineN
+      display.viewTo += lendiff
+    } else {
+      resetView(cm)
+    }
+  } else if (to >= display.viewTo) { // Bottom overlap
+    let cut = viewCuttingPoint(cm, from, from, -1)
+    if (cut) {
+      display.view = display.view.slice(0, cut.index)
+      display.viewTo = cut.lineN
+    } else {
+      resetView(cm)
+    }
+  } else { // Gap in the middle
+    let cutTop = viewCuttingPoint(cm, from, from, -1)
+    let cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)
+    if (cutTop && cutBot) {
+      display.view = display.view.slice(0, cutTop.index)
+        .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
+        .concat(display.view.slice(cutBot.index))
+      display.viewTo += lendiff
+    } else {
+      resetView(cm)
+    }
+  }
+
+  let ext = display.externalMeasured
+  if (ext) {
+    if (to < ext.lineN)
+      ext.lineN += lendiff
+    else if (from < ext.lineN + ext.size)
+      display.externalMeasured = null
+  }
+}
+
+// Register a change to a single line. Type must be one of "text",
+// "gutter", "class", "widget"
+export function regLineChange(cm, line, type) {
+  cm.curOp.viewChanged = true
+  let display = cm.display, ext = cm.display.externalMeasured
+  if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
+    display.externalMeasured = null
+
+  if (line < display.viewFrom || line >= display.viewTo) return
+  let lineView = display.view[findViewIndex(cm, line)]
+  if (lineView.node == null) return
+  let arr = lineView.changes || (lineView.changes = [])
+  if (indexOf(arr, type) == -1) arr.push(type)
+}
+
+// Clear the view.
+export function resetView(cm) {
+  cm.display.viewFrom = cm.display.viewTo = cm.doc.first
+  cm.display.view = []
+  cm.display.viewOffset = 0
+}
+
+function viewCuttingPoint(cm, oldN, newN, dir) {
+  let index = findViewIndex(cm, oldN), diff, view = cm.display.view
+  if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
+    return {index: index, lineN: newN}
+  let n = cm.display.viewFrom
+  for (let i = 0; i < index; i++)
+    n += view[i].size
+  if (n != oldN) {
+    if (dir > 0) {
+      if (index == view.length - 1) return null
+      diff = (n + view[index].size) - oldN
+      index++
+    } else {
+      diff = n - oldN
+    }
+    oldN += diff; newN += diff
+  }
+  while (visualLineNo(cm.doc, newN) != newN) {
+    if (index == (dir < 0 ? 0 : view.length - 1)) return null
+    newN += dir * view[index - (dir < 0 ? 1 : 0)].size
+    index += dir
+  }
+  return {index: index, lineN: newN}
+}
+
+// Force the view to cover a given range, adding empty view element
+// or clipping off existing ones as needed.
+export function adjustView(cm, from, to) {
+  let display = cm.display, view = display.view
+  if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
+    display.view = buildViewArray(cm, from, to)
+    display.viewFrom = from
+  } else {
+    if (display.viewFrom > from)
+      display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view)
+    else if (display.viewFrom < from)
+      display.view = display.view.slice(findViewIndex(cm, from))
+    display.viewFrom = from
+    if (display.viewTo < to)
+      display.view = display.view.concat(buildViewArray(cm, display.viewTo, to))
+    else if (display.viewTo > to)
+      display.view = display.view.slice(0, findViewIndex(cm, to))
+  }
+  display.viewTo = to
+}
+
+// Count the number of lines in the view whose DOM representation is
+// out of date (or nonexistent).
+export function countDirtyView(cm) {
+  let view = cm.display.view, dirty = 0
+  for (let i = 0; i < view.length; i++) {
+    let lineView = view[i]
+    if (!lineView.hidden && (!lineView.node || lineView.changes)) ++dirty
+  }
+  return dirty
+}

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

@@ -0,0 +1,217 @@
+import { Display } from "../display/Display.js"
+import { onFocus, onBlur } from "../display/focus.js"
+import { maybeUpdateLineNumberWidth } from "../display/line_numbers.js"
+import { endOperation, operation, startOperation } from "../display/operations.js"
+import { initScrollbars } from "../display/scrollbars.js"
+import { onScrollWheel } from "../display/scroll_events.js"
+import { setScrollLeft, updateScrollTop } from "../display/scrolling.js"
+import { clipPos, Pos } from "../line/pos.js"
+import { posFromMouse } from "../measurement/position_measurement.js"
+import { eventInWidget } from "../measurement/widgets.js"
+import Doc from "../model/Doc.js"
+import { attachDoc } from "../model/document_data.js"
+import { Range } from "../model/selection.js"
+import { extendSelection } from "../model/selection_updates.js"
+import { ie, ie_version, mobile, webkit } from "../util/browser.js"
+import { e_preventDefault, e_stop, on, signal, signalDOMEvent } from "../util/event.js"
+import { copyObj, Delayed } from "../util/misc.js"
+
+import { clearDragCursor, onDragOver, onDragStart, onDrop } from "./drop_events.js"
+import { ensureGlobalHandlers } from "./global_events.js"
+import { onKeyDown, onKeyPress, onKeyUp } from "./key_events.js"
+import { clickInGutter, onContextMenu, onMouseDown } from "./mouse_events.js"
+import { themeChanged } from "./utils.js"
+import { defaults, optionHandlers, Init } from "./options.js"
+
+// A CodeMirror instance represents an editor. This is the object
+// that user code is usually dealing with.
+
+export function CodeMirror(place, options) {
+  if (!(this instanceof CodeMirror)) return new CodeMirror(place, options)
+
+  this.options = options = options ? copyObj(options) : {}
+  // Determine effective options based on given values and defaults.
+  copyObj(defaults, options, false)
+
+  let doc = options.value
+  if (typeof doc == "string") doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction)
+  else if (options.mode) doc.modeOption = options.mode
+  this.doc = doc
+
+  let input = new CodeMirror.inputStyles[options.inputStyle](this)
+  let display = this.display = new Display(place, doc, input, options)
+  display.wrapper.CodeMirror = this
+  themeChanged(this)
+  if (options.lineWrapping)
+    this.display.wrapper.className += " CodeMirror-wrap"
+  initScrollbars(this)
+
+  this.state = {
+    keyMaps: [],  // stores maps added by addKeyMap
+    overlays: [], // highlighting overlays, as added by addOverlay
+    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
+    overwrite: false,
+    delayingBlurEvent: false,
+    focused: false,
+    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
+    pasteIncoming: -1, cutIncoming: -1, // help recognize paste/cut edits in input.poll
+    selectingText: false,
+    draggingText: false,
+    highlight: new Delayed(), // stores highlight worker timeout
+    keySeq: null,  // Unfinished key sequence
+    specialChars: null
+  }
+
+  if (options.autofocus && !mobile) display.input.focus()
+
+  // Override magic textarea content restore that IE sometimes does
+  // on our hidden textarea on reload
+  if (ie && ie_version < 11) setTimeout(() => this.display.input.reset(true), 20)
+
+  registerEventHandlers(this)
+  ensureGlobalHandlers()
+
+  startOperation(this)
+  this.curOp.forceUpdate = true
+  attachDoc(this, doc)
+
+  if ((options.autofocus && !mobile) || this.hasFocus())
+    setTimeout(() => {
+      if (this.hasFocus() && !this.state.focused) onFocus(this)
+    }, 20)
+  else
+    onBlur(this)
+
+  for (let opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
+    optionHandlers[opt](this, options[opt], Init)
+  maybeUpdateLineNumberWidth(this)
+  if (options.finishInit) options.finishInit(this)
+  for (let i = 0; i < initHooks.length; ++i) initHooks[i](this)
+  endOperation(this)
+  // Suppress optimizelegibility in Webkit, since it breaks text
+  // measuring on line wrapping boundaries.
+  if (webkit && options.lineWrapping &&
+      getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
+    display.lineDiv.style.textRendering = "auto"
+}
+
+// The default configuration options.
+CodeMirror.defaults = defaults
+// Functions to run when options are changed.
+CodeMirror.optionHandlers = optionHandlers
+
+export default CodeMirror
+
+// Attach the necessary event handlers when initializing the editor
+function registerEventHandlers(cm) {
+  let d = cm.display
+  on(d.scroller, "mousedown", operation(cm, onMouseDown))
+  // Older IE's will not fire a second mousedown for a double click
+  if (ie && ie_version < 11)
+    on(d.scroller, "dblclick", operation(cm, e => {
+      if (signalDOMEvent(cm, e)) return
+      let pos = posFromMouse(cm, e)
+      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return
+      e_preventDefault(e)
+      let word = cm.findWordAt(pos)
+      extendSelection(cm.doc, word.anchor, word.head)
+    }))
+  else
+    on(d.scroller, "dblclick", e => signalDOMEvent(cm, e) || e_preventDefault(e))
+  // Some browsers fire contextmenu *after* opening the menu, at
+  // which point we can't mess with it anymore. Context menu is
+  // handled in onMouseDown for these browsers.
+  on(d.scroller, "contextmenu", e => onContextMenu(cm, e))
+  on(d.input.getField(), "contextmenu", e => {
+    if (!d.scroller.contains(e.target)) onContextMenu(cm, e)
+  })
+
+  // Used to suppress mouse event handling when a touch happens
+  let touchFinished, prevTouch = {end: 0}
+  function finishTouch() {
+    if (d.activeTouch) {
+      touchFinished = setTimeout(() => d.activeTouch = null, 1000)
+      prevTouch = d.activeTouch
+      prevTouch.end = +new Date
+    }
+  }
+  function isMouseLikeTouchEvent(e) {
+    if (e.touches.length != 1) return false
+    let touch = e.touches[0]
+    return touch.radiusX <= 1 && touch.radiusY <= 1
+  }
+  function farAway(touch, other) {
+    if (other.left == null) return true
+    let dx = other.left - touch.left, dy = other.top - touch.top
+    return dx * dx + dy * dy > 20 * 20
+  }
+  on(d.scroller, "touchstart", e => {
+    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {
+      d.input.ensurePolled()
+      clearTimeout(touchFinished)
+      let now = +new Date
+      d.activeTouch = {start: now, moved: false,
+                       prev: now - prevTouch.end <= 300 ? prevTouch : null}
+      if (e.touches.length == 1) {
+        d.activeTouch.left = e.touches[0].pageX
+        d.activeTouch.top = e.touches[0].pageY
+      }
+    }
+  })
+  on(d.scroller, "touchmove", () => {
+    if (d.activeTouch) d.activeTouch.moved = true
+  })
+  on(d.scroller, "touchend", e => {
+    let touch = d.activeTouch
+    if (touch && !eventInWidget(d, e) && touch.left != null &&
+        !touch.moved && new Date - touch.start < 300) {
+      let pos = cm.coordsChar(d.activeTouch, "page"), range
+      if (!touch.prev || farAway(touch, touch.prev)) // Single tap
+        range = new Range(pos, pos)
+      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
+        range = cm.findWordAt(pos)
+      else // Triple tap
+        range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)))
+      cm.setSelection(range.anchor, range.head)
+      cm.focus()
+      e_preventDefault(e)
+    }
+    finishTouch()
+  })
+  on(d.scroller, "touchcancel", finishTouch)
+
+  // Sync scrolling between fake scrollbars and real scrollable
+  // area, ensure viewport is updated when scrolling.
+  on(d.scroller, "scroll", () => {
+    if (d.scroller.clientHeight) {
+      updateScrollTop(cm, d.scroller.scrollTop)
+      setScrollLeft(cm, d.scroller.scrollLeft, true)
+      signal(cm, "scroll", cm)
+    }
+  })
+
+  // Listen to wheel events in order to try and update the viewport on time.
+  on(d.scroller, "mousewheel", e => onScrollWheel(cm, e))
+  on(d.scroller, "DOMMouseScroll", e => onScrollWheel(cm, e))
+
+  // Prevent wrapper from ever scrolling
+  on(d.wrapper, "scroll", () => d.wrapper.scrollTop = d.wrapper.scrollLeft = 0)
+
+  d.dragFunctions = {
+    enter: e => {if (!signalDOMEvent(cm, e)) e_stop(e)},
+    over: e => {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
+    start: e => onDragStart(cm, e),
+    drop: operation(cm, onDrop),
+    leave: e => {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
+  }
+
+  let inp = d.input.getField()
+  on(inp, "keyup", e => onKeyUp.call(cm, e))
+  on(inp, "keydown", operation(cm, onKeyDown))
+  on(inp, "keypress", operation(cm, onKeyPress))
+  on(inp, "focus", e => onFocus(cm, e))
+  on(inp, "blur", e => onBlur(cm, e))
+}
+
+let initHooks = []
+CodeMirror.defineInitHook = f => initHooks.push(f)