@muze-nl/simplystore 0.3.6 → 0.4.1

package/www/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, 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

@@ -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/www/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 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

@@ -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
-}