@muze-nl/simplystore 0.3.6 → 0.4.1

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

@@ -1,44 +0,0 @@
-import { elt, removeChildren } from "../util/dom.js"
-import { regChange } from "./view_tracking.js"
-import { alignHorizontally } from "./line_numbers.js"
-import { updateGutterSpace } from "./update_display.js"
-
-export function getGutters(gutters, lineNumbers) {
-  let result = [], sawLineNumbers = false
-  for (let i = 0; i < gutters.length; i++) {
-    let name = gutters[i], style = null
-    if (typeof name != "string") { style = name.style; name = name.className }
-    if (name == "CodeMirror-linenumbers") {
-      if (!lineNumbers) continue
-      else sawLineNumbers = true
-    }
-    result.push({className: name, style})
-  }
-  if (lineNumbers && !sawLineNumbers) result.push({className: "CodeMirror-linenumbers", style: null})
-  return result
-}
-
-// Rebuild the gutter elements, ensure the margin to the left of the
-// code matches their width.
-export function renderGutters(display) {
-  let gutters = display.gutters, specs = display.gutterSpecs
-  removeChildren(gutters)
-  display.lineGutter = null
-  for (let i = 0; i < specs.length; ++i) {
-    let {className, style} = specs[i]
-    let gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + className))
-    if (style) gElt.style.cssText = style
-    if (className == "CodeMirror-linenumbers") {
-      display.lineGutter = gElt
-      gElt.style.width = (display.lineNumWidth || 1) + "px"
-    }
-  }
-  gutters.style.display = specs.length ? "" : "none"
-  updateGutterSpace(display)
-}
-
-export function updateGutters(cm) {
-  renderGutters(cm.display)
-  regChange(cm)
-  alignHorizontally(cm)
-}

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