@muze-nl/simplystore 0.1.2

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

@@ -0,0 +1,267 @@
+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, doc } 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(doc(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(snapshot.activeElt.ownerDocument)) 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"
+}

package/www/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/www/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 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/www/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
+}