qword 0.1.0 → 1.0.0

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

@@ -1,189 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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)