@muze-nl/simplystore 0.3.5 → 0.4.0

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

@@ -1,55 +0,0 @@
-import { getContextBefore, highlightLine, processLine } from "../line/highlight.js"
-import { copyState } from "../modes.js"
-import { bind } from "../util/misc.js"
-
-import { runInOp } from "./operations.js"
-import { regLineChange } from "./view_tracking.js"
-
-// HIGHLIGHT WORKER
-
-export function startWorker(cm, time) {
-  if (cm.doc.highlightFrontier < cm.display.viewTo)
-    cm.state.highlight.set(time, bind(highlightWorker, cm))
-}
-
-function highlightWorker(cm) {
-  let doc = cm.doc
-  if (doc.highlightFrontier >= cm.display.viewTo) return
-  let end = +new Date + cm.options.workTime
-  let context = getContextBefore(cm, doc.highlightFrontier)
-  let changedLines = []
-
-  doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), line => {
-    if (context.line >= cm.display.viewFrom) { // Visible
-      let oldStyles = line.styles
-      let resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null
-      let highlighted = highlightLine(cm, line, context, true)
-      if (resetState) context.state = resetState
-      line.styles = highlighted.styles
-      let oldCls = line.styleClasses, newCls = highlighted.classes
-      if (newCls) line.styleClasses = newCls
-      else if (oldCls) line.styleClasses = null
-      let ischange = !oldStyles || oldStyles.length != line.styles.length ||
-        oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)
-      for (let i = 0; !ischange && i < oldStyles.length; ++i) ischange = oldStyles[i] != line.styles[i]
-      if (ischange) changedLines.push(context.line)
-      line.stateAfter = context.save()
-      context.nextLine()
-    } else {
-      if (line.text.length <= cm.options.maxHighlightLength)
-        processLine(cm, line.text, context)
-      line.stateAfter = context.line % 5 == 0 ? context.save() : null
-      context.nextLine()
-    }
-    if (+new Date > end) {
-      startWorker(cm, cm.options.workDelay)
-      return true
-    }
-  })
-  doc.highlightFrontier = context.line
-  doc.modeFrontier = Math.max(doc.modeFrontier, context.line)
-  if (changedLines.length) runInOp(cm, () => {
-    for (let i = 0; i < changedLines.length; i++)
-      regLineChange(cm, changedLines[i], "text")
-  })
-}

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

@@ -1,48 +0,0 @@
-import { lineNumberFor } from "../line/utils_line.js"
-import { compensateForHScroll } from "../measurement/position_measurement.js"
-import { elt } from "../util/dom.js"
-
-import { updateGutterSpace } from "./update_display.js"
-
-// Re-align line numbers and gutter marks to compensate for
-// horizontal scrolling.
-export function alignHorizontally(cm) {
-  let display = cm.display, view = display.view
-  if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) return
-  let comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft
-  let gutterW = display.gutters.offsetWidth, left = comp + "px"
-  for (let i = 0; i < view.length; i++) if (!view[i].hidden) {
-    if (cm.options.fixedGutter) {
-      if (view[i].gutter)
-        view[i].gutter.style.left = left
-      if (view[i].gutterBackground)
-        view[i].gutterBackground.style.left = left
-    }
-    let align = view[i].alignable
-    if (align) for (let j = 0; j < align.length; j++)
-      align[j].style.left = left
-  }
-  if (cm.options.fixedGutter)
-    display.gutters.style.left = (comp + gutterW) + "px"
-}
-
-// Used to ensure that the line number gutter is still the right
-// size for the current document size. Returns true when an update
-// is needed.
-export function maybeUpdateLineNumberWidth(cm) {
-  if (!cm.options.lineNumbers) return false
-  let doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display
-  if (last.length != display.lineNumChars) {
-    let test = display.measure.appendChild(elt("div", [elt("div", last)],
-                                               "CodeMirror-linenumber CodeMirror-gutter-elt"))
-    let innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW
-    display.lineGutter.style.width = ""
-    display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1
-    display.lineNumWidth = display.lineNumInnerWidth + padding
-    display.lineNumChars = display.lineNumInnerWidth ? last.length : -1
-    display.lineGutter.style.width = display.lineNumWidth + "px"
-    updateGutterSpace(cm.display)
-    return true
-  }
-  return false
-}

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

@@ -1,22 +0,0 @@
-import { getMode } from "../modes.js"
-
-import { startWorker } from "./highlight_worker.js"
-import { regChange } from "./view_tracking.js"
-
-// Used to get the editor into a consistent state again when options change.
-
-export function loadMode(cm) {
-  cm.doc.mode = getMode(cm.options, cm.doc.modeOption)
-  resetModeState(cm)
-}
-
-export function resetModeState(cm) {
-  cm.doc.iter(line => {
-    if (line.stateAfter) line.stateAfter = null
-    if (line.styles) line.styles = null
-  })
-  cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first
-  startWorker(cm, 100)
-  cm.state.modeGen++
-  if (cm.curOp) regChange(cm)
-}

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

@@ -1,206 +0,0 @@
-import { clipPos } from "../line/pos.js"
-import { findMaxLine } from "../line/spans.js"
-import { displayWidth, measureChar, scrollGap } from "../measurement/position_measurement.js"
-import { signal } from "../util/event.js"
-import { activeElt, doc } from "../util/dom.js"
-import { finishOperation, pushOperation } from "../util/operation_group.js"
-
-import { ensureFocus } from "./focus.js"
-import { measureForScrollbars, updateScrollbars } from "./scrollbars.js"
-import { restartBlink } from "./selection.js"
-import { maybeScrollWindow, scrollPosIntoView, setScrollLeft, setScrollTop } from "./scrolling.js"
-import { DisplayUpdate, maybeClipScrollbars, postUpdateDisplay, setDocumentHeight, updateDisplayIfNeeded } from "./update_display.js"
-import { updateHeightsInViewport } from "./update_lines.js"
-
-// Operations are used to wrap a series of changes to the editor
-// state in such a way that each change won't have to update the
-// cursor and display (which would be awkward, slow, and
-// error-prone). Instead, display updates are batched and then all
-// combined and executed at once.
-
-let nextOpId = 0
-// Start a new operation.
-export function startOperation(cm) {
-  cm.curOp = {
-    cm: cm,
-    viewChanged: false,      // Flag that indicates that lines might need to be redrawn
-    startHeight: cm.doc.height, // Used to detect need to update scrollbar
-    forceUpdate: false,      // Used to force a redraw
-    updateInput: 0,       // Whether to reset the input textarea
-    typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
-    changeObjs: null,        // Accumulated changes, for firing change events
-    cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
-    cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
-    selectionChanged: false, // Whether the selection needs to be redrawn
-    updateMaxLine: false,    // Set when the widest line needs to be determined anew
-    scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
-    scrollToPos: null,       // Used to scroll to a specific position
-    focus: false,
-    id: ++nextOpId,          // Unique ID
-    markArrays: null         // Used by addMarkedSpan
-  }
-  pushOperation(cm.curOp)
-}
-
-// Finish an operation, updating the display and signalling delayed events
-export function endOperation(cm) {
-  let op = cm.curOp
-  if (op) finishOperation(op, group => {
-    for (let i = 0; i < group.ops.length; i++)
-      group.ops[i].cm.curOp = null
-    endOperations(group)
-  })
-}
-
-// The DOM updates done when an operation finishes are batched so
-// that the minimum number of relayouts are required.
-function endOperations(group) {
-  let ops = group.ops
-  for (let i = 0; i < ops.length; i++) // Read DOM
-    endOperation_R1(ops[i])
-  for (let i = 0; i < ops.length; i++) // Write DOM (maybe)
-    endOperation_W1(ops[i])
-  for (let i = 0; i < ops.length; i++) // Read DOM
-    endOperation_R2(ops[i])
-  for (let i = 0; i < ops.length; i++) // Write DOM (maybe)
-    endOperation_W2(ops[i])
-  for (let i = 0; i < ops.length; i++) // Read DOM
-    endOperation_finish(ops[i])
-}
-
-function endOperation_R1(op) {
-  let cm = op.cm, display = cm.display
-  maybeClipScrollbars(cm)
-  if (op.updateMaxLine) findMaxLine(cm)
-
-  op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
-    op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
-                       op.scrollToPos.to.line >= display.viewTo) ||
-    display.maxLineChanged && cm.options.lineWrapping
-  op.update = op.mustUpdate &&
-    new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)
-}
-
-function endOperation_W1(op) {
-  op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)
-}
-
-function endOperation_R2(op) {
-  let cm = op.cm, display = cm.display
-  if (op.updatedDisplay) updateHeightsInViewport(cm)
-
-  op.barMeasure = measureForScrollbars(cm)
-
-  // If the max line changed since it was last measured, measure it,
-  // and ensure the document's width matches it.
-  // updateDisplay_W2 will use these properties to do the actual resizing
-  if (display.maxLineChanged && !cm.options.lineWrapping) {
-    op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3
-    cm.display.sizerWidth = op.adjustWidthTo
-    op.barMeasure.scrollWidth =
-      Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)
-    op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))
-  }
-
-  if (op.updatedDisplay || op.selectionChanged)
-    op.preparedSelection = display.input.prepareSelection()
-}
-
-function endOperation_W2(op) {
-  let cm = op.cm
-
-  if (op.adjustWidthTo != null) {
-    cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"
-    if (op.maxScrollLeft < cm.doc.scrollLeft)
-      setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true)
-    cm.display.maxLineChanged = false
-  }
-
-  let takeFocus = op.focus && op.focus == activeElt(doc(cm))
-  if (op.preparedSelection)
-    cm.display.input.showSelection(op.preparedSelection, takeFocus)
-  if (op.updatedDisplay || op.startHeight != cm.doc.height)
-    updateScrollbars(cm, op.barMeasure)
-  if (op.updatedDisplay)
-    setDocumentHeight(cm, op.barMeasure)
-
-  if (op.selectionChanged) restartBlink(cm)
-
-  if (cm.state.focused && op.updateInput)
-    cm.display.input.reset(op.typing)
-  if (takeFocus) ensureFocus(op.cm)
-}
-
-function endOperation_finish(op) {
-  let cm = op.cm, display = cm.display, doc = cm.doc
-
-  if (op.updatedDisplay) postUpdateDisplay(cm, op.update)
-
-  // Abort mouse wheel delta measurement, when scrolling explicitly
-  if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
-    display.wheelStartX = display.wheelStartY = null
-
-  // Propagate the scroll position to the actual DOM scroller
-  if (op.scrollTop != null) setScrollTop(cm, op.scrollTop, op.forceScroll)
-
-  if (op.scrollLeft != null) setScrollLeft(cm, op.scrollLeft, true, true)
-  // If we need to scroll a specific position into view, do so.
-  if (op.scrollToPos) {
-    let rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
-                                 clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)
-    maybeScrollWindow(cm, rect)
-  }
-
-  // Fire events for markers that are hidden/unidden by editing or
-  // undoing
-  let hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers
-  if (hidden) for (let i = 0; i < hidden.length; ++i)
-    if (!hidden[i].lines.length) signal(hidden[i], "hide")
-  if (unhidden) for (let i = 0; i < unhidden.length; ++i)
-    if (unhidden[i].lines.length) signal(unhidden[i], "unhide")
-
-  if (display.wrapper.offsetHeight)
-    doc.scrollTop = cm.display.scroller.scrollTop
-
-  // Fire change events, and delayed event handlers
-  if (op.changeObjs)
-    signal(cm, "changes", cm, op.changeObjs)
-  if (op.update)
-    op.update.finish()
-}
-
-// Run the given function in an operation
-export function runInOp(cm, f) {
-  if (cm.curOp) return f()
-  startOperation(cm)
-  try { return f() }
-  finally { endOperation(cm) }
-}
-// Wraps a function in an operation. Returns the wrapped function.
-export function operation(cm, f) {
-  return function() {
-    if (cm.curOp) return f.apply(cm, arguments)
-    startOperation(cm)
-    try { return f.apply(cm, arguments) }
-    finally { endOperation(cm) }
-  }
-}
-// Used to add methods to editor and doc instances, wrapping them in
-// operations.
-export function methodOp(f) {
-  return function() {
-    if (this.curOp) return f.apply(this, arguments)
-    startOperation(this)
-    try { return f.apply(this, arguments) }
-    finally { endOperation(this) }
-  }
-}
-export function docMethodOp(f) {
-  return function() {
-    let cm = this.cm
-    if (!cm || cm.curOp) return f.apply(this, arguments)
-    startOperation(cm)
-    try { return f.apply(this, arguments) }
-    finally { endOperation(cm) }
-  }
-}

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

@@ -1,132 +0,0 @@
-import { chrome, chrome_version, gecko, ie, mac, presto, safari, webkit } from "../util/browser.js"
-import { e_preventDefault } from "../util/event.js"
-
-import { updateDisplaySimple } from "./update_display.js"
-import { setScrollLeft, updateScrollTop } from "./scrolling.js"
-
-// Since the delta values reported on mouse wheel events are
-// unstandardized between browsers and even browser versions, and
-// generally horribly unpredictable, this code starts by measuring
-// the scroll effect that the first few mouse wheel events have,
-// and, from that, detects the way it can convert deltas to pixel
-// offsets afterwards.
-//
-// The reason we want to know the amount a wheel event will scroll
-// is that it gives us a chance to update the display before the
-// actual scrolling happens, reducing flickering.
-
-let wheelSamples = 0, wheelPixelsPerUnit = null
-// Fill in a browser-detected starting value on browsers where we
-// know one. These don't have to be accurate -- the result of them
-// being wrong would just be a slight flicker on the first wheel
-// scroll (if it is large enough).
-if (ie) wheelPixelsPerUnit = -.53
-else if (gecko) wheelPixelsPerUnit = 15
-else if (chrome) wheelPixelsPerUnit = -.7
-else if (safari) wheelPixelsPerUnit = -1/3
-
-function wheelEventDelta(e) {
-  let dx = e.wheelDeltaX, dy = e.wheelDeltaY
-  if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) dx = e.detail
-  if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) dy = e.detail
-  else if (dy == null) dy = e.wheelDelta
-  return {x: dx, y: dy}
-}
-export function wheelEventPixels(e) {
-  let delta = wheelEventDelta(e)
-  delta.x *= wheelPixelsPerUnit
-  delta.y *= wheelPixelsPerUnit
-  return delta
-}
-
-export function onScrollWheel(cm, e) {
-  // On Chrome 102, viewport updates somehow stop wheel-based
-  // scrolling. Turning off pointer events during the scroll seems
-  // to avoid the issue.
-  if (chrome && chrome_version == 102) {
-    if (cm.display.chromeScrollHack == null) cm.display.sizer.style.pointerEvents = "none"
-    else clearTimeout(cm.display.chromeScrollHack)
-    cm.display.chromeScrollHack = setTimeout(() => {
-      cm.display.chromeScrollHack = null
-      cm.display.sizer.style.pointerEvents = ""
-    }, 100)
-  }
-  let delta = wheelEventDelta(e), dx = delta.x, dy = delta.y
-  let pixelsPerUnit = wheelPixelsPerUnit
-  if (e.deltaMode === 0) {
-    dx = e.deltaX
-    dy = e.deltaY
-    pixelsPerUnit = 1
-  }
-
-  let display = cm.display, scroll = display.scroller
-  // Quit if there's nothing to scroll here
-  let canScrollX = scroll.scrollWidth > scroll.clientWidth
-  let canScrollY = scroll.scrollHeight > scroll.clientHeight
-  if (!(dx && canScrollX || dy && canScrollY)) return
-
-  // Webkit browsers on OS X abort momentum scrolls when the target
-  // of the scroll event is removed from the scrollable element.
-  // This hack (see related code in patchDisplay) makes sure the
-  // element is kept around.
-  if (dy && mac && webkit) {
-    outer: for (let cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
-      for (let i = 0; i < view.length; i++) {
-        if (view[i].node == cur) {
-          cm.display.currentWheelTarget = cur
-          break outer
-        }
-      }
-    }
-  }
-
-  // On some browsers, horizontal scrolling will cause redraws to
-  // happen before the gutter has been realigned, causing it to
-  // wriggle around in a most unseemly way. When we have an
-  // estimated pixels/delta value, we just handle horizontal
-  // scrolling entirely here. It'll be slightly off from native, but
-  // better than glitching out.
-  if (dx && !gecko && !presto && pixelsPerUnit != null) {
-    if (dy && canScrollY)
-      updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * pixelsPerUnit))
-    setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * pixelsPerUnit))
-    // Only prevent default scrolling if vertical scrolling is
-    // actually possible. Otherwise, it causes vertical scroll
-    // jitter on OSX trackpads when deltaX is small and deltaY
-    // is large (issue #3579)
-    if (!dy || (dy && canScrollY))
-      e_preventDefault(e)
-    display.wheelStartX = null // Abort measurement, if in progress
-    return
-  }
-
-  // 'Project' the visible viewport to cover the area that is being
-  // scrolled into view (if we know enough to estimate it).
-  if (dy && pixelsPerUnit != null) {
-    let pixels = dy * pixelsPerUnit
-    let top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight
-    if (pixels < 0) top = Math.max(0, top + pixels - 50)
-    else bot = Math.min(cm.doc.height, bot + pixels + 50)
-    updateDisplaySimple(cm, {top: top, bottom: bot})
-  }
-
-  if (wheelSamples < 20 && e.deltaMode !== 0) {
-    if (display.wheelStartX == null) {
-      display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop
-      display.wheelDX = dx; display.wheelDY = dy
-      setTimeout(() => {
-        if (display.wheelStartX == null) return
-        let movedX = scroll.scrollLeft - display.wheelStartX
-        let movedY = scroll.scrollTop - display.wheelStartY
-        let sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
-          (movedX && display.wheelDX && movedX / display.wheelDX)
-        display.wheelStartX = display.wheelStartY = null
-        if (!sample) return
-        wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)
-        ++wheelSamples
-      }, 200)
-    } else {
-      display.wheelDX += dx; display.wheelDY += dy
-    }
-  }
-}

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

@@ -1,194 +0,0 @@
-import { addClass, elt, rmClass } from "../util/dom.js"
-import { on } from "../util/event.js"
-import { scrollGap, paddingVert } from "../measurement/position_measurement.js"
-import { ie, ie_version, mac, mac_geMountainLion } from "../util/browser.js"
-import { updateHeightsInViewport } from "./update_lines.js"
-import { Delayed } from "../util/misc.js"
-
-import { setScrollLeft, updateScrollTop } from "./scrolling.js"
-
-// SCROLLBARS
-
-// Prepare DOM reads needed to update the scrollbars. Done in one
-// shot to minimize update/measure roundtrips.
-export function measureForScrollbars(cm) {
-  let d = cm.display, gutterW = d.gutters.offsetWidth
-  let docH = Math.round(cm.doc.height + paddingVert(cm.display))
-  return {
-    clientHeight: d.scroller.clientHeight,
-    viewHeight: d.wrapper.clientHeight,
-    scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
-    viewWidth: d.wrapper.clientWidth,
-    barLeft: cm.options.fixedGutter ? gutterW : 0,
-    docHeight: docH,
-    scrollHeight: docH + scrollGap(cm) + d.barHeight,
-    nativeBarWidth: d.nativeBarWidth,
-    gutterWidth: gutterW
-  }
-}
-
-class NativeScrollbars {
-  constructor(place, scroll, cm) {
-    this.cm = cm
-    let vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar")
-    let horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar")
-    vert.tabIndex = horiz.tabIndex = -1
-    place(vert); place(horiz)
-
-    on(vert, "scroll", () => {
-      if (vert.clientHeight) scroll(vert.scrollTop, "vertical")
-    })
-    on(horiz, "scroll", () => {
-      if (horiz.clientWidth) scroll(horiz.scrollLeft, "horizontal")
-    })
-
-    this.checkedZeroWidth = false
-    // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
-    if (ie && ie_version < 8) this.horiz.style.minHeight = this.vert.style.minWidth = "18px"
-  }
-
-  update(measure) {
-    let needsH = measure.scrollWidth > measure.clientWidth + 1
-    let needsV = measure.scrollHeight > measure.clientHeight + 1
-    let sWidth = measure.nativeBarWidth
-
-    if (needsV) {
-      this.vert.style.display = "block"
-      this.vert.style.bottom = needsH ? sWidth + "px" : "0"
-      let totalHeight = measure.viewHeight - (needsH ? sWidth : 0)
-      // A bug in IE8 can cause this value to be negative, so guard it.
-      this.vert.firstChild.style.height =
-        Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"
-    } else {
-      this.vert.scrollTop = 0
-      this.vert.style.display = ""
-      this.vert.firstChild.style.height = "0"
-    }
-
-    if (needsH) {
-      this.horiz.style.display = "block"
-      this.horiz.style.right = needsV ? sWidth + "px" : "0"
-      this.horiz.style.left = measure.barLeft + "px"
-      let totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)
-      this.horiz.firstChild.style.width =
-        Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + "px"
-    } else {
-      this.horiz.style.display = ""
-      this.horiz.firstChild.style.width = "0"
-    }
-
-    if (!this.checkedZeroWidth && measure.clientHeight > 0) {
-      if (sWidth == 0) this.zeroWidthHack()
-      this.checkedZeroWidth = true
-    }
-
-    return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}
-  }
-
-  setScrollLeft(pos) {
-    if (this.horiz.scrollLeft != pos) this.horiz.scrollLeft = pos
-    if (this.disableHoriz) this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz")
-  }
-
-  setScrollTop(pos) {
-    if (this.vert.scrollTop != pos) this.vert.scrollTop = pos
-    if (this.disableVert) this.enableZeroWidthBar(this.vert, this.disableVert, "vert")
-  }
-
-  zeroWidthHack() {
-    let w = mac && !mac_geMountainLion ? "12px" : "18px"
-    this.horiz.style.height = this.vert.style.width = w
-    this.horiz.style.visibility = this.vert.style.visibility = "hidden"
-    this.disableHoriz = new Delayed
-    this.disableVert = new Delayed
-  }
-
-  enableZeroWidthBar(bar, delay, type) {
-    bar.style.visibility = ""
-    function maybeDisable() {
-      // To find out whether the scrollbar is still visible, we
-      // check whether the element under the pixel in the bottom
-      // right corner of the scrollbar box is the scrollbar box
-      // itself (when the bar is still visible) or its filler child
-      // (when the bar is hidden). If it is still visible, we keep
-      // it enabled, if it's hidden, we disable pointer events.
-      let box = bar.getBoundingClientRect()
-      let elt = type == "vert" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2)
-          : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1)
-      if (elt != bar) bar.style.visibility = "hidden"
-      else delay.set(1000, maybeDisable)
-    }
-    delay.set(1000, maybeDisable)
-  }
-
-  clear() {
-    let parent = this.horiz.parentNode
-    parent.removeChild(this.horiz)
-    parent.removeChild(this.vert)
-  }
-}
-
-class NullScrollbars {
-  update() { return {bottom: 0, right: 0} }
-  setScrollLeft() {}
-  setScrollTop() {}
-  clear() {}
-}
-
-export function updateScrollbars(cm, measure) {
-  if (!measure) measure = measureForScrollbars(cm)
-  let startWidth = cm.display.barWidth, startHeight = cm.display.barHeight
-  updateScrollbarsInner(cm, measure)
-  for (let i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
-    if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
-      updateHeightsInViewport(cm)
-    updateScrollbarsInner(cm, measureForScrollbars(cm))
-    startWidth = cm.display.barWidth; startHeight = cm.display.barHeight
-  }
-}
-
-// Re-synchronize the fake scrollbars with the actual size of the
-// content.
-function updateScrollbarsInner(cm, measure) {
-  let d = cm.display
-  let sizes = d.scrollbars.update(measure)
-
-  d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"
-  d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"
-  d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"
-
-  if (sizes.right && sizes.bottom) {
-    d.scrollbarFiller.style.display = "block"
-    d.scrollbarFiller.style.height = sizes.bottom + "px"
-    d.scrollbarFiller.style.width = sizes.right + "px"
-  } else d.scrollbarFiller.style.display = ""
-  if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
-    d.gutterFiller.style.display = "block"
-    d.gutterFiller.style.height = sizes.bottom + "px"
-    d.gutterFiller.style.width = measure.gutterWidth + "px"
-  } else d.gutterFiller.style.display = ""
-}
-
-export let scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}
-
-export function initScrollbars(cm) {
-  if (cm.display.scrollbars) {
-    cm.display.scrollbars.clear()
-    if (cm.display.scrollbars.addClass)
-      rmClass(cm.display.wrapper, cm.display.scrollbars.addClass)
-  }
-
-  cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](node => {
-    cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)
-    // Prevent clicks in the scrollbars from killing focus
-    on(node, "mousedown", () => {
-      if (cm.state.focused) setTimeout(() => cm.display.input.focus(), 0)
-    })
-    node.setAttribute("cm-not-content", "true")
-  }, (pos, axis) => {
-    if (axis == "horizontal") setScrollLeft(cm, pos)
-    else updateScrollTop(cm, pos)
-  }, cm)
-  if (cm.display.scrollbars.addClass)
-    addClass(cm.display.wrapper, cm.display.scrollbars.addClass)
-}