qword 0.1.0 → 1.0.0

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

@@ -1,186 +0,0 @@
-import { Pos } from "../line/pos.js"
-import { cursorCoords, displayHeight, displayWidth, estimateCoords, paddingTop, paddingVert, scrollGap, textHeight } from "../measurement/position_measurement.js"
-import { gecko, phantom } from "../util/browser.js"
-import { elt } from "../util/dom.js"
-import { signalDOMEvent } from "../util/event.js"
-
-import { startWorker } from "./highlight_worker.js"
-import { alignHorizontally } from "./line_numbers.js"
-import { updateDisplaySimple } from "./update_display.js"
-
-// SCROLLING THINGS INTO VIEW
-
-// If an editor sits on the top or bottom of the window, partially
-// scrolled out of view, this ensures that the cursor is visible.
-export function maybeScrollWindow(cm, rect) {
-  if (signalDOMEvent(cm, "scrollCursorIntoView")) return
-
-  let display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null
-  let doc = display.wrapper.ownerDocument
-  if (rect.top + box.top < 0) doScroll = true
-  else if (rect.bottom + box.top > (doc.defaultView.innerHeight || doc.documentElement.clientHeight)) doScroll = false
-  if (doScroll != null && !phantom) {
-    let scrollNode = elt("div", "\u200b", null, `position: absolute;
-                         top: ${rect.top - display.viewOffset - paddingTop(cm.display)}px;
-                         height: ${rect.bottom - rect.top + scrollGap(cm) + display.barHeight}px;
-                         left: ${rect.left}px; width: ${Math.max(2, rect.right - rect.left)}px;`)
-    cm.display.lineSpace.appendChild(scrollNode)
-    scrollNode.scrollIntoView(doScroll)
-    cm.display.lineSpace.removeChild(scrollNode)
-  }
-}
-
-// Scroll a given position into view (immediately), verifying that
-// it actually became visible (as line heights are accurately
-// measured, the position of something may 'drift' during drawing).
-export function scrollPosIntoView(cm, pos, end, margin) {
-  if (margin == null) margin = 0
-  let rect
-  if (!cm.options.lineWrapping && pos == end) {
-    // Set pos and end to the cursor positions around the character pos sticks to
-    // If pos.sticky == "before", that is around pos.ch - 1, otherwise around pos.ch
-    // If pos == Pos(_, 0, "before"), pos and end are unchanged
-    end = pos.sticky == "before" ? Pos(pos.line, pos.ch + 1, "before") : pos
-    pos = pos.ch ? Pos(pos.line, pos.sticky == "before" ? pos.ch - 1 : pos.ch, "after") : pos
-  }
-  for (let limit = 0; limit < 5; limit++) {
-    let changed = false
-    let coords = cursorCoords(cm, pos)
-    let endCoords = !end || end == pos ? coords : cursorCoords(cm, end)
-    rect = {left: Math.min(coords.left, endCoords.left),
-            top: Math.min(coords.top, endCoords.top) - margin,
-            right: Math.max(coords.left, endCoords.left),
-            bottom: Math.max(coords.bottom, endCoords.bottom) + margin}
-    let scrollPos = calculateScrollPos(cm, rect)
-    let startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft
-    if (scrollPos.scrollTop != null) {
-      updateScrollTop(cm, scrollPos.scrollTop)
-      if (Math.abs(cm.doc.scrollTop - startTop) > 1) changed = true
-    }
-    if (scrollPos.scrollLeft != null) {
-      setScrollLeft(cm, scrollPos.scrollLeft)
-      if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) changed = true
-    }
-    if (!changed) break
-  }
-  return rect
-}
-
-// Scroll a given set of coordinates into view (immediately).
-export function scrollIntoView(cm, rect) {
-  let scrollPos = calculateScrollPos(cm, rect)
-  if (scrollPos.scrollTop != null) updateScrollTop(cm, scrollPos.scrollTop)
-  if (scrollPos.scrollLeft != null) setScrollLeft(cm, scrollPos.scrollLeft)
-}
-
-// Calculate a new scroll position needed to scroll the given
-// rectangle into view. Returns an object with scrollTop and
-// scrollLeft properties. When these are undefined, the
-// vertical/horizontal position does not need to be adjusted.
-function calculateScrollPos(cm, rect) {
-  let display = cm.display, snapMargin = textHeight(cm.display)
-  if (rect.top < 0) rect.top = 0
-  let screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop
-  let screen = displayHeight(cm), result = {}
-  if (rect.bottom - rect.top > screen) rect.bottom = rect.top + screen
-  let docBottom = cm.doc.height + paddingVert(display)
-  let atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin
-  if (rect.top < screentop) {
-    result.scrollTop = atTop ? 0 : rect.top
-  } else if (rect.bottom > screentop + screen) {
-    let newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen)
-    if (newTop != screentop) result.scrollTop = newTop
-  }
-
-  let gutterSpace = cm.options.fixedGutter ? 0 : display.gutters.offsetWidth
-  let screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft - gutterSpace
-  let screenw = displayWidth(cm) - display.gutters.offsetWidth
-  let tooWide = rect.right - rect.left > screenw
-  if (tooWide) rect.right = rect.left + screenw
-  if (rect.left < 10)
-    result.scrollLeft = 0
-  else if (rect.left < screenleft)
-    result.scrollLeft = Math.max(0, rect.left + gutterSpace - (tooWide ? 0 : 10))
-  else if (rect.right > screenw + screenleft - 3)
-    result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw
-  return result
-}
-
-// Store a relative adjustment to the scroll position in the current
-// operation (to be applied when the operation finishes).
-export function addToScrollTop(cm, top) {
-  if (top == null) return
-  resolveScrollToPos(cm)
-  cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top
-}
-
-// Make sure that at the end of the operation the current cursor is
-// shown.
-export function ensureCursorVisible(cm) {
-  resolveScrollToPos(cm)
-  let cur = cm.getCursor()
-  cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin}
-}
-
-export function scrollToCoords(cm, x, y) {
-  if (x != null || y != null) resolveScrollToPos(cm)
-  if (x != null) cm.curOp.scrollLeft = x
-  if (y != null) cm.curOp.scrollTop = y
-}
-
-export function scrollToRange(cm, range) {
-  resolveScrollToPos(cm)
-  cm.curOp.scrollToPos = range
-}
-
-// When an operation has its scrollToPos property set, and another
-// scroll action is applied before the end of the operation, this
-// 'simulates' scrolling that position into view in a cheap way, so
-// that the effect of intermediate scroll commands is not ignored.
-function resolveScrollToPos(cm) {
-  let range = cm.curOp.scrollToPos
-  if (range) {
-    cm.curOp.scrollToPos = null
-    let from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)
-    scrollToCoordsRange(cm, from, to, range.margin)
-  }
-}
-
-export function scrollToCoordsRange(cm, from, to, margin) {
-  let sPos = calculateScrollPos(cm, {
-    left: Math.min(from.left, to.left),
-    top: Math.min(from.top, to.top) - margin,
-    right: Math.max(from.right, to.right),
-    bottom: Math.max(from.bottom, to.bottom) + margin
-  })
-  scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop)
-}
-
-// Sync the scrollable area and scrollbars, ensure the viewport
-// covers the visible area.
-export function updateScrollTop(cm, val) {
-  if (Math.abs(cm.doc.scrollTop - val) < 2) return
-  if (!gecko) updateDisplaySimple(cm, {top: val})
-  setScrollTop(cm, val, true)
-  if (gecko) updateDisplaySimple(cm)
-  startWorker(cm, 100)
-}
-
-export function setScrollTop(cm, val, forceScroll) {
-  val = Math.max(0, Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val))
-  if (cm.display.scroller.scrollTop == val && !forceScroll) return
-  cm.doc.scrollTop = val
-  cm.display.scrollbars.setScrollTop(val)
-  if (cm.display.scroller.scrollTop != val) cm.display.scroller.scrollTop = val
-}
-
-// Sync scroller and scrollbar, ensure the gutter elements are
-// aligned.
-export function setScrollLeft(cm, val, isScroller, forceScroll) {
-  val = Math.max(0, Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth))
-  if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) return
-  cm.doc.scrollLeft = val
-  alignHorizontally(cm)
-  if (cm.display.scroller.scrollLeft != val) cm.display.scroller.scrollLeft = val
-  cm.display.scrollbars.setScrollLeft(val)
-}

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

@@ -1,173 +0,0 @@
-import { Pos } from "../line/pos.js"
-import { visualLine } from "../line/spans.js"
-import { getLine } from "../line/utils_line.js"
-import { charCoords, cursorCoords, displayWidth, paddingH, wrappedLineExtentChar } from "../measurement/position_measurement.js"
-import { getOrder, iterateBidiSections } from "../util/bidi.js"
-import { elt } from "../util/dom.js"
-import { onBlur } from "./focus.js"
-
-export function updateSelection(cm) {
-  cm.display.input.showSelection(cm.display.input.prepareSelection())
-}
-
-export function prepareSelection(cm, primary = true) {
-  let doc = cm.doc, result = {}
-  let curFragment = result.cursors = document.createDocumentFragment()
-  let selFragment = result.selection = document.createDocumentFragment()
-
-  let customCursor = cm.options.$customCursor
-  if (customCursor) primary = true
-  for (let i = 0; i < doc.sel.ranges.length; i++) {
-    if (!primary && i == doc.sel.primIndex) continue
-    let range = doc.sel.ranges[i]
-    if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) continue
-    let collapsed = range.empty()
-    if (customCursor) {
-      let head = customCursor(cm, range)
-      if (head) drawSelectionCursor(cm, head, curFragment)
-    } else if (collapsed || cm.options.showCursorWhenSelecting) {
-      drawSelectionCursor(cm, range.head, curFragment)
-    }
-    if (!collapsed)
-      drawSelectionRange(cm, range, selFragment)
-  }
-  return result
-}
-
-// Draws a cursor for the given range
-export function drawSelectionCursor(cm, head, output) {
-  let pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine)
-
-  let cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"))
-  cursor.style.left = pos.left + "px"
-  cursor.style.top = pos.top + "px"
-  cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"
-
-  if (/\bcm-fat-cursor\b/.test(cm.getWrapperElement().className)) {
-    let charPos = charCoords(cm, head, "div", null, null)
-    let width = charPos.right - charPos.left
-    cursor.style.width = (width > 0 ? width : cm.defaultCharWidth()) + "px"
-  }
-
-  if (pos.other) {
-    // Secondary cursor, shown when on a 'jump' in bi-directional text
-    let otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"))
-    otherCursor.style.display = ""
-    otherCursor.style.left = pos.other.left + "px"
-    otherCursor.style.top = pos.other.top + "px"
-    otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"
-  }
-}
-
-function cmpCoords(a, b) { return a.top - b.top || a.left - b.left }
-
-// Draws the given range as a highlighted selection
-function drawSelectionRange(cm, range, output) {
-  let display = cm.display, doc = cm.doc
-  let fragment = document.createDocumentFragment()
-  let padding = paddingH(cm.display), leftSide = padding.left
-  let rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right
-  let docLTR = doc.direction == "ltr"
-
-  function add(left, top, width, bottom) {
-    if (top < 0) top = 0
-    top = Math.round(top)
-    bottom = Math.round(bottom)
-    fragment.appendChild(elt("div", null, "CodeMirror-selected", `position: absolute; left: ${left}px;
-                             top: ${top}px; width: ${width == null ? rightSide - left : width}px;
-                             height: ${bottom - top}px`))
-  }
-
-  function drawForLine(line, fromArg, toArg) {
-    let lineObj = getLine(doc, line)
-    let lineLen = lineObj.text.length
-    let start, end
-    function coords(ch, bias) {
-      return charCoords(cm, Pos(line, ch), "div", lineObj, bias)
-    }
-
-    function wrapX(pos, dir, side) {
-      let extent = wrappedLineExtentChar(cm, lineObj, null, pos)
-      let prop = (dir == "ltr") == (side == "after") ? "left" : "right"
-      let ch = side == "after" ? extent.begin : extent.end - (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1)
-      return coords(ch, prop)[prop]
-    }
-
-    let order = getOrder(lineObj, doc.direction)
-    iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, (from, to, dir, i) => {
-      let ltr = dir == "ltr"
-      let fromPos = coords(from, ltr ? "left" : "right")
-      let toPos = coords(to - 1, ltr ? "right" : "left")
-
-      let openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen
-      let first = i == 0, last = !order || i == order.length - 1
-      if (toPos.top - fromPos.top <= 3) { // Single line
-        let openLeft = (docLTR ? openStart : openEnd) && first
-        let openRight = (docLTR ? openEnd : openStart) && last
-        let left = openLeft ? leftSide : (ltr ? fromPos : toPos).left
-        let right = openRight ? rightSide : (ltr ? toPos : fromPos).right
-        add(left, fromPos.top, right - left, fromPos.bottom)
-      } else { // Multiple lines
-        let topLeft, topRight, botLeft, botRight
-        if (ltr) {
-          topLeft = docLTR && openStart && first ? leftSide : fromPos.left
-          topRight = docLTR ? rightSide : wrapX(from, dir, "before")
-          botLeft = docLTR ? leftSide : wrapX(to, dir, "after")
-          botRight = docLTR && openEnd && last ? rightSide : toPos.right
-        } else {
-          topLeft = !docLTR ? leftSide : wrapX(from, dir, "before")
-          topRight = !docLTR && openStart && first ? rightSide : fromPos.right
-          botLeft = !docLTR && openEnd && last ? leftSide : toPos.left
-          botRight = !docLTR ? rightSide : wrapX(to, dir, "after")
-        }
-        add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom)
-        if (fromPos.bottom < toPos.top) add(leftSide, fromPos.bottom, null, toPos.top)
-        add(botLeft, toPos.top, botRight - botLeft, toPos.bottom)
-      }
-
-      if (!start || cmpCoords(fromPos, start) < 0) start = fromPos
-      if (cmpCoords(toPos, start) < 0) start = toPos
-      if (!end || cmpCoords(fromPos, end) < 0) end = fromPos
-      if (cmpCoords(toPos, end) < 0) end = toPos
-    })
-    return {start: start, end: end}
-  }
-
-  let sFrom = range.from(), sTo = range.to()
-  if (sFrom.line == sTo.line) {
-    drawForLine(sFrom.line, sFrom.ch, sTo.ch)
-  } else {
-    let fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)
-    let singleVLine = visualLine(fromLine) == visualLine(toLine)
-    let leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end
-    let rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start
-    if (singleVLine) {
-      if (leftEnd.top < rightStart.top - 2) {
-        add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)
-        add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)
-      } else {
-        add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)
-      }
-    }
-    if (leftEnd.bottom < rightStart.top)
-      add(leftSide, leftEnd.bottom, null, rightStart.top)
-  }
-
-  output.appendChild(fragment)
-}
-
-// Cursor-blinking
-export function restartBlink(cm) {
-  if (!cm.state.focused) return
-  let display = cm.display
-  clearInterval(display.blinker)
-  let on = true
-  display.cursorDiv.style.visibility = ""
-  if (cm.options.cursorBlinkRate > 0)
-    display.blinker = setInterval(() => {
-      if (!cm.hasFocus()) onBlur(cm)
-      display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"
-    }, cm.options.cursorBlinkRate)
-  else if (cm.options.cursorBlinkRate < 0)
-    display.cursorDiv.style.visibility = "hidden"
-}

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

@@ -1,267 +0,0 @@
-import { sawCollapsedSpans } from "../line/saw_special_spans.js"
-import { heightAtLine, visualLineEndNo, visualLineNo } from "../line/spans.js"
-import { getLine, lineNumberFor } from "../line/utils_line.js"
-import { displayHeight, displayWidth, getDimensions, paddingVert, scrollGap } from "../measurement/position_measurement.js"
-import { mac, webkit } from "../util/browser.js"
-import { activeElt, removeChildren, contains, win, root, rootNode } from "../util/dom.js"
-import { hasHandler, signal } from "../util/event.js"
-import { signalLater } from "../util/operation_group.js"
-import { indexOf } from "../util/misc.js"
-
-import { buildLineElement, updateLineForChanges } from "./update_line.js"
-import { startWorker } from "./highlight_worker.js"
-import { maybeUpdateLineNumberWidth } from "./line_numbers.js"
-import { measureForScrollbars, updateScrollbars } from "./scrollbars.js"
-import { updateSelection } from "./selection.js"
-import { updateHeightsInViewport, visibleLines } from "./update_lines.js"
-import { adjustView, countDirtyView, resetView } from "./view_tracking.js"
-
-// DISPLAY DRAWING
-
-export class DisplayUpdate {
-  constructor(cm, viewport, force) {
-    let display = cm.display
-
-    this.viewport = viewport
-    // Store some values that we'll need later (but don't want to force a relayout for)
-    this.visible = visibleLines(display, cm.doc, viewport)
-    this.editorIsHidden = !display.wrapper.offsetWidth
-    this.wrapperHeight = display.wrapper.clientHeight
-    this.wrapperWidth = display.wrapper.clientWidth
-    this.oldDisplayWidth = displayWidth(cm)
-    this.force = force
-    this.dims = getDimensions(cm)
-    this.events = []
-  }
-
-  signal(emitter, type) {
-    if (hasHandler(emitter, type))
-      this.events.push(arguments)
-  }
-  finish() {
-    for (let i = 0; i < this.events.length; i++)
-      signal.apply(null, this.events[i])
-  }
-}
-
-export function maybeClipScrollbars(cm) {
-  let display = cm.display
-  if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
-    display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth
-    display.heightForcer.style.height = scrollGap(cm) + "px"
-    display.sizer.style.marginBottom = -display.nativeBarWidth + "px"
-    display.sizer.style.borderRightWidth = scrollGap(cm) + "px"
-    display.scrollbarsClipped = true
-  }
-}
-
-function selectionSnapshot(cm) {
-  if (cm.hasFocus()) return null
-  let active = activeElt(root(cm))
-  if (!active || !contains(cm.display.lineDiv, active)) return null
-  let result = {activeElt: active}
-  if (window.getSelection) {
-    let sel = win(cm).getSelection()
-    if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) {
-      result.anchorNode = sel.anchorNode
-      result.anchorOffset = sel.anchorOffset
-      result.focusNode = sel.focusNode
-      result.focusOffset = sel.focusOffset
-    }
-  }
-  return result
-}
-
-function restoreSelection(snapshot) {
-  if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt(rootNode(snapshot.activeElt))) return
-  snapshot.activeElt.focus()
-  if (!/^(INPUT|TEXTAREA)$/.test(snapshot.activeElt.nodeName) &&
-      snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) {
-    let doc = snapshot.activeElt.ownerDocument
-    let sel = doc.defaultView.getSelection(), range = doc.createRange()
-    range.setEnd(snapshot.anchorNode, snapshot.anchorOffset)
-    range.collapse(false)
-    sel.removeAllRanges()
-    sel.addRange(range)
-    sel.extend(snapshot.focusNode, snapshot.focusOffset)
-  }
-}
-
-// Does the actual updating of the line display. Bails out
-// (returning false) when there is nothing to be done and forced is
-// false.
-export function updateDisplayIfNeeded(cm, update) {
-  let display = cm.display, doc = cm.doc
-
-  if (update.editorIsHidden) {
-    resetView(cm)
-    return false
-  }
-
-  // Bail out if the visible area is already rendered and nothing changed.
-  if (!update.force &&
-      update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
-      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
-      display.renderedView == display.view && countDirtyView(cm) == 0)
-    return false
-
-  if (maybeUpdateLineNumberWidth(cm)) {
-    resetView(cm)
-    update.dims = getDimensions(cm)
-  }
-
-  // Compute a suitable new viewport (from & to)
-  let end = doc.first + doc.size
-  let from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)
-  let to = Math.min(end, update.visible.to + cm.options.viewportMargin)
-  if (display.viewFrom < from && from - display.viewFrom < 20) from = Math.max(doc.first, display.viewFrom)
-  if (display.viewTo > to && display.viewTo - to < 20) to = Math.min(end, display.viewTo)
-  if (sawCollapsedSpans) {
-    from = visualLineNo(cm.doc, from)
-    to = visualLineEndNo(cm.doc, to)
-  }
-
-  let different = from != display.viewFrom || to != display.viewTo ||
-    display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth
-  adjustView(cm, from, to)
-
-  display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))
-  // Position the mover div to align with the current scroll position
-  cm.display.mover.style.top = display.viewOffset + "px"
-
-  let toUpdate = countDirtyView(cm)
-  if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
-      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
-    return false
-
-  // For big changes, we hide the enclosing element during the
-  // update, since that speeds up the operations on most browsers.
-  let selSnapshot = selectionSnapshot(cm)
-  if (toUpdate > 4) display.lineDiv.style.display = "none"
-  patchDisplay(cm, display.updateLineNumbers, update.dims)
-  if (toUpdate > 4) display.lineDiv.style.display = ""
-  display.renderedView = display.view
-  // There might have been a widget with a focused element that got
-  // hidden or updated, if so re-focus it.
-  restoreSelection(selSnapshot)
-
-  // Prevent selection and cursors from interfering with the scroll
-  // width and height.
-  removeChildren(display.cursorDiv)
-  removeChildren(display.selectionDiv)
-  display.gutters.style.height = display.sizer.style.minHeight = 0
-
-  if (different) {
-    display.lastWrapHeight = update.wrapperHeight
-    display.lastWrapWidth = update.wrapperWidth
-    startWorker(cm, 400)
-  }
-
-  display.updateLineNumbers = null
-
-  return true
-}
-
-export function postUpdateDisplay(cm, update) {
-  let viewport = update.viewport
-
-  for (let first = true;; first = false) {
-    if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
-      // Clip forced viewport to actual scrollable area.
-      if (viewport && viewport.top != null)
-        viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)}
-      // Updated line heights might result in the drawn area not
-      // actually covering the viewport. Keep looping until it does.
-      update.visible = visibleLines(cm.display, cm.doc, viewport)
-      if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
-        break
-    } else if (first) {
-      update.visible = visibleLines(cm.display, cm.doc, viewport)
-    }
-    if (!updateDisplayIfNeeded(cm, update)) break
-    updateHeightsInViewport(cm)
-    let barMeasure = measureForScrollbars(cm)
-    updateSelection(cm)
-    updateScrollbars(cm, barMeasure)
-    setDocumentHeight(cm, barMeasure)
-    update.force = false
-  }
-
-  update.signal(cm, "update", cm)
-  if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
-    update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo)
-    cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo
-  }
-}
-
-export function updateDisplaySimple(cm, viewport) {
-  let update = new DisplayUpdate(cm, viewport)
-  if (updateDisplayIfNeeded(cm, update)) {
-    updateHeightsInViewport(cm)
-    postUpdateDisplay(cm, update)
-    let barMeasure = measureForScrollbars(cm)
-    updateSelection(cm)
-    updateScrollbars(cm, barMeasure)
-    setDocumentHeight(cm, barMeasure)
-    update.finish()
-  }
-}
-
-// Sync the actual display DOM structure with display.view, removing
-// nodes for lines that are no longer in view, and creating the ones
-// that are not there yet, and updating the ones that are out of
-// date.
-function patchDisplay(cm, updateNumbersFrom, dims) {
-  let display = cm.display, lineNumbers = cm.options.lineNumbers
-  let container = display.lineDiv, cur = container.firstChild
-
-  function rm(node) {
-    let next = node.nextSibling
-    // Works around a throw-scroll bug in OS X Webkit
-    if (webkit && mac && cm.display.currentWheelTarget == node)
-      node.style.display = "none"
-    else
-      node.parentNode.removeChild(node)
-    return next
-  }
-
-  let view = display.view, lineN = display.viewFrom
-  // Loop over the elements in the view, syncing cur (the DOM nodes
-  // in display.lineDiv) with the view as we go.
-  for (let i = 0; i < view.length; i++) {
-    let lineView = view[i]
-    if (lineView.hidden) {
-    } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
-      let node = buildLineElement(cm, lineView, lineN, dims)
-      container.insertBefore(node, cur)
-    } else { // Already drawn
-      while (cur != lineView.node) cur = rm(cur)
-      let updateNumber = lineNumbers && updateNumbersFrom != null &&
-        updateNumbersFrom <= lineN && lineView.lineNumber
-      if (lineView.changes) {
-        if (indexOf(lineView.changes, "gutter") > -1) updateNumber = false
-        updateLineForChanges(cm, lineView, lineN, dims)
-      }
-      if (updateNumber) {
-        removeChildren(lineView.lineNumber)
-        lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))
-      }
-      cur = lineView.node.nextSibling
-    }
-    lineN += lineView.size
-  }
-  while (cur) cur = rm(cur)
-}
-
-export function updateGutterSpace(display) {
-  let width = display.gutters.offsetWidth
-  display.sizer.style.marginLeft = width + "px"
-  // Send an event to consumers responding to changes in gutter width.
-  signalLater(display, "gutterChanged", display)
-}
-
-export function setDocumentHeight(cm, measure) {
-  cm.display.sizer.style.minHeight = measure.docHeight + "px"
-  cm.display.heightForcer.style.top = measure.docHeight + "px"
-  cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"
-}