@muze-nl/simplystore 0.1.2

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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,206 @@
+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

@@ -0,0 +1,132 @@
+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
+    }
+  }
+}