@muze-nl/simplystore 0.3.6 → 0.4.1

package/www/codemirror/src/edit/mouse_events.js

@@ -1,417 +0,0 @@
-import { delayBlurEvent, ensureFocus } from "../display/focus.js"
-import { operation } from "../display/operations.js"
-import { visibleLines } from "../display/update_lines.js"
-import { clipPos, cmp, maxPos, minPos, Pos } from "../line/pos.js"
-import { getLine, lineAtHeight } from "../line/utils_line.js"
-import { posFromMouse } from "../measurement/position_measurement.js"
-import { eventInWidget } from "../measurement/widgets.js"
-import { normalizeSelection, Range, Selection } from "../model/selection.js"
-import { extendRange, extendSelection, replaceOneSelection, setSelection } from "../model/selection_updates.js"
-import { captureRightClick, chromeOS, ie, ie_version, mac, webkit, safari } from "../util/browser.js"
-import { getOrder, getBidiPartAt } from "../util/bidi.js"
-import { activeElt, doc as getDoc, win } from "../util/dom.js"
-import { e_button, e_defaultPrevented, e_preventDefault, e_target, hasHandler, off, on, signal, signalDOMEvent } from "../util/event.js"
-import { dragAndDrop } from "../util/feature_detection.js"
-import { bind, countColumn, findColumn, sel_mouse } from "../util/misc.js"
-import { addModifierNames } from "../input/keymap.js"
-import { Pass } from "../util/misc.js"
-
-import { dispatchKey } from "./key_events.js"
-import { commands } from "./commands.js"
-
-const DOUBLECLICK_DELAY = 400
-
-class PastClick {
-  constructor(time, pos, button) {
-    this.time = time
-    this.pos = pos
-    this.button = button
-  }
-
-  compare(time, pos, button) {
-    return this.time + DOUBLECLICK_DELAY > time &&
-      cmp(pos, this.pos) == 0 && button == this.button
-  }
-}
-
-let lastClick, lastDoubleClick
-function clickRepeat(pos, button) {
-  let now = +new Date
-  if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {
-    lastClick = lastDoubleClick = null
-    return "triple"
-  } else if (lastClick && lastClick.compare(now, pos, button)) {
-    lastDoubleClick = new PastClick(now, pos, button)
-    lastClick = null
-    return "double"
-  } else {
-    lastClick = new PastClick(now, pos, button)
-    lastDoubleClick = null
-    return "single"
-  }
-}
-
-// A mouse down can be a single click, double click, triple click,
-// start of selection drag, start of text drag, new cursor
-// (ctrl-click), rectangle drag (alt-drag), or xwin
-// middle-click-paste. Or it might be a click on something we should
-// not interfere with, such as a scrollbar or widget.
-export function onMouseDown(e) {
-  let cm = this, display = cm.display
-  if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) return
-  display.input.ensurePolled()
-  display.shift = e.shiftKey
-
-  if (eventInWidget(display, e)) {
-    if (!webkit) {
-      // Briefly turn off draggability, to allow widgets to do
-      // normal dragging things.
-      display.scroller.draggable = false
-      setTimeout(() => display.scroller.draggable = true, 100)
-    }
-    return
-  }
-  if (clickInGutter(cm, e)) return
-  let pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : "single"
-  win(cm).focus()
-
-  // #3261: make sure, that we're not starting a second selection
-  if (button == 1 && cm.state.selectingText)
-    cm.state.selectingText(e)
-
-  if (pos && handleMappedButton(cm, button, pos, repeat, e)) return
-
-  if (button == 1) {
-    if (pos) leftButtonDown(cm, pos, repeat, e)
-    else if (e_target(e) == display.scroller) e_preventDefault(e)
-  } else if (button == 2) {
-    if (pos) extendSelection(cm.doc, pos)
-    setTimeout(() => display.input.focus(), 20)
-  } else if (button == 3) {
-    if (captureRightClick) cm.display.input.onContextMenu(e)
-    else delayBlurEvent(cm)
-  }
-}
-
-function handleMappedButton(cm, button, pos, repeat, event) {
-  let name = "Click"
-  if (repeat == "double") name = "Double" + name
-  else if (repeat == "triple") name = "Triple" + name
-  name = (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name
-
-  return dispatchKey(cm,  addModifierNames(name, event), event, bound => {
-    if (typeof bound == "string") bound = commands[bound]
-    if (!bound) return false
-    let done = false
-    try {
-      if (cm.isReadOnly()) cm.state.suppressEdits = true
-      done = bound(cm, pos) != Pass
-    } finally {
-      cm.state.suppressEdits = false
-    }
-    return done
-  })
-}
-
-function configureMouse(cm, repeat, event) {
-  let option = cm.getOption("configureMouse")
-  let value = option ? option(cm, repeat, event) : {}
-  if (value.unit == null) {
-    let rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey
-    value.unit = rect ? "rectangle" : repeat == "single" ? "char" : repeat == "double" ? "word" : "line"
-  }
-  if (value.extend == null || cm.doc.extend) value.extend = cm.doc.extend || event.shiftKey
-  if (value.addNew == null) value.addNew = mac ? event.metaKey : event.ctrlKey
-  if (value.moveOnDrag == null) value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey)
-  return value
-}
-
-function leftButtonDown(cm, pos, repeat, event) {
-  if (ie) setTimeout(bind(ensureFocus, cm), 0)
-  else cm.curOp.focus = activeElt(getDoc(cm))
-
-  let behavior = configureMouse(cm, repeat, event)
-
-  let sel = cm.doc.sel, contained
-  if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
-      repeat == "single" && (contained = sel.contains(pos)) > -1 &&
-      (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) &&
-      (cmp(contained.to(), pos) > 0 || pos.xRel < 0))
-    leftButtonStartDrag(cm, event, pos, behavior)
-  else
-    leftButtonSelect(cm, event, pos, behavior)
-}
-
-// Start a text drag. When it ends, see if any dragging actually
-// happen, and treat as a click if it didn't.
-function leftButtonStartDrag(cm, event, pos, behavior) {
-  let display = cm.display, moved = false
-  let dragEnd = operation(cm, e => {
-    if (webkit) display.scroller.draggable = false
-    cm.state.draggingText = false
-    if (cm.state.delayingBlurEvent) {
-      if (cm.hasFocus()) cm.state.delayingBlurEvent = false
-      else delayBlurEvent(cm)
-    }
-    off(display.wrapper.ownerDocument, "mouseup", dragEnd)
-    off(display.wrapper.ownerDocument, "mousemove", mouseMove)
-    off(display.scroller, "dragstart", dragStart)
-    off(display.scroller, "drop", dragEnd)
-    if (!moved) {
-      e_preventDefault(e)
-      if (!behavior.addNew)
-        extendSelection(cm.doc, pos, null, null, behavior.extend)
-      // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
-      if ((webkit && !safari) || ie && ie_version == 9)
-        setTimeout(() => {display.wrapper.ownerDocument.body.focus({preventScroll: true}); display.input.focus()}, 20)
-      else
-        display.input.focus()
-    }
-  })
-  let mouseMove = function(e2) {
-    moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10
-  }
-  let dragStart = () => moved = true
-  // Let the drag handler handle this.
-  if (webkit) display.scroller.draggable = true
-  cm.state.draggingText = dragEnd
-  dragEnd.copy = !behavior.moveOnDrag
-  on(display.wrapper.ownerDocument, "mouseup", dragEnd)
-  on(display.wrapper.ownerDocument, "mousemove", mouseMove)
-  on(display.scroller, "dragstart", dragStart)
-  on(display.scroller, "drop", dragEnd)
-
-  cm.state.delayingBlurEvent = true
-  setTimeout(() => display.input.focus(), 20)
-  // IE's approach to draggable
-  if (display.scroller.dragDrop) display.scroller.dragDrop()
-}
-
-function rangeForUnit(cm, pos, unit) {
-  if (unit == "char") return new Range(pos, pos)
-  if (unit == "word") return cm.findWordAt(pos)
-  if (unit == "line") return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)))
-  let result = unit(cm, pos)
-  return new Range(result.from, result.to)
-}
-
-// Normal selection, as opposed to text dragging.
-function leftButtonSelect(cm, event, start, behavior) {
-  if (ie) delayBlurEvent(cm)
-  let display = cm.display, doc = cm.doc
-  e_preventDefault(event)
-
-  let ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges
-  if (behavior.addNew && !behavior.extend) {
-    ourIndex = doc.sel.contains(start)
-    if (ourIndex > -1)
-      ourRange = ranges[ourIndex]
-    else
-      ourRange = new Range(start, start)
-  } else {
-    ourRange = doc.sel.primary()
-    ourIndex = doc.sel.primIndex
-  }
-
-  if (behavior.unit == "rectangle") {
-    if (!behavior.addNew) ourRange = new Range(start, start)
-    start = posFromMouse(cm, event, true, true)
-    ourIndex = -1
-  } else {
-    let range = rangeForUnit(cm, start, behavior.unit)
-    if (behavior.extend)
-      ourRange = extendRange(ourRange, range.anchor, range.head, behavior.extend)
-    else
-      ourRange = range
-  }
-
-  if (!behavior.addNew) {
-    ourIndex = 0
-    setSelection(doc, new Selection([ourRange], 0), sel_mouse)
-    startSel = doc.sel
-  } else if (ourIndex == -1) {
-    ourIndex = ranges.length
-    setSelection(doc, normalizeSelection(cm, ranges.concat([ourRange]), ourIndex),
-                 {scroll: false, origin: "*mouse"})
-  } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == "char" && !behavior.extend) {
-    setSelection(doc, normalizeSelection(cm, ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
-                 {scroll: false, origin: "*mouse"})
-    startSel = doc.sel
-  } else {
-    replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)
-  }
-
-  let lastPos = start
-  function extendTo(pos) {
-    if (cmp(lastPos, pos) == 0) return
-    lastPos = pos
-
-    if (behavior.unit == "rectangle") {
-      let ranges = [], tabSize = cm.options.tabSize
-      let startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)
-      let posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)
-      let left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)
-      for (let line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
-           line <= end; line++) {
-        let text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)
-        if (left == right)
-          ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos)))
-        else if (text.length > leftPos)
-          ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize))))
-      }
-      if (!ranges.length) ranges.push(new Range(start, start))
-      setSelection(doc, normalizeSelection(cm, startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
-                   {origin: "*mouse", scroll: false})
-      cm.scrollIntoView(pos)
-    } else {
-      let oldRange = ourRange
-      let range = rangeForUnit(cm, pos, behavior.unit)
-      let anchor = oldRange.anchor, head
-      if (cmp(range.anchor, anchor) > 0) {
-        head = range.head
-        anchor = minPos(oldRange.from(), range.anchor)
-      } else {
-        head = range.anchor
-        anchor = maxPos(oldRange.to(), range.head)
-      }
-      let ranges = startSel.ranges.slice(0)
-      ranges[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head))
-      setSelection(doc, normalizeSelection(cm, ranges, ourIndex), sel_mouse)
-    }
-  }
-
-  let editorSize = display.wrapper.getBoundingClientRect()
-  // Used to ensure timeout re-tries don't fire when another extend
-  // happened in the meantime (clearTimeout isn't reliable -- at
-  // least on Chrome, the timeouts still happen even when cleared,
-  // if the clear happens after their scheduled firing time).
-  let counter = 0
-
-  function extend(e) {
-    let curCount = ++counter
-    let cur = posFromMouse(cm, e, true, behavior.unit == "rectangle")
-    if (!cur) return
-    if (cmp(cur, lastPos) != 0) {
-      cm.curOp.focus = activeElt(getDoc(cm))
-      extendTo(cur)
-      let visible = visibleLines(display, doc)
-      if (cur.line >= visible.to || cur.line < visible.from)
-        setTimeout(operation(cm, () => {if (counter == curCount) extend(e)}), 150)
-    } else {
-      let outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0
-      if (outside) setTimeout(operation(cm, () => {
-        if (counter != curCount) return
-        display.scroller.scrollTop += outside
-        extend(e)
-      }), 50)
-    }
-  }
-
-  function done(e) {
-    cm.state.selectingText = false
-    counter = Infinity
-    // If e is null or undefined we interpret this as someone trying
-    // to explicitly cancel the selection rather than the user
-    // letting go of the mouse button.
-    if (e) {
-      e_preventDefault(e)
-      display.input.focus()
-    }
-    off(display.wrapper.ownerDocument, "mousemove", move)
-    off(display.wrapper.ownerDocument, "mouseup", up)
-    doc.history.lastSelOrigin = null
-  }
-
-  let move = operation(cm, e => {
-    if (e.buttons === 0 || !e_button(e)) done(e)
-    else extend(e)
-  })
-  let up = operation(cm, done)
-  cm.state.selectingText = up
-  on(display.wrapper.ownerDocument, "mousemove", move)
-  on(display.wrapper.ownerDocument, "mouseup", up)
-}
-
-// Used when mouse-selecting to adjust the anchor to the proper side
-// of a bidi jump depending on the visual position of the head.
-function bidiSimplify(cm, range) {
-  let {anchor, head} = range, anchorLine = getLine(cm.doc, anchor.line)
-  if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) return range
-  let order = getOrder(anchorLine)
-  if (!order) return range
-  let index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index]
-  if (part.from != anchor.ch && part.to != anchor.ch) return range
-  let boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1)
-  if (boundary == 0 || boundary == order.length) return range
-
-  // Compute the relative visual position of the head compared to the
-  // anchor (<0 is to the left, >0 to the right)
-  let leftSide
-  if (head.line != anchor.line) {
-    leftSide = (head.line - anchor.line) * (cm.doc.direction == "ltr" ? 1 : -1) > 0
-  } else {
-    let headIndex = getBidiPartAt(order, head.ch, head.sticky)
-    let dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1)
-    if (headIndex == boundary - 1 || headIndex == boundary)
-      leftSide = dir < 0
-    else
-      leftSide = dir > 0
-  }
-
-  let usePart = order[boundary + (leftSide ? -1 : 0)]
-  let from = leftSide == (usePart.level == 1)
-  let ch = from ? usePart.from : usePart.to, sticky = from ? "after" : "before"
-  return anchor.ch == ch && anchor.sticky == sticky ? range : new Range(new Pos(anchor.line, ch, sticky), head)
-}
-
-
-// Determines whether an event happened in the gutter, and fires the
-// handlers for the corresponding event.
-function gutterEvent(cm, e, type, prevent) {
-  let mX, mY
-  if (e.touches) {
-    mX = e.touches[0].clientX
-    mY = e.touches[0].clientY
-  } else {
-    try { mX = e.clientX; mY = e.clientY }
-    catch(e) { return false }
-  }
-  if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) return false
-  if (prevent) e_preventDefault(e)
-
-  let display = cm.display
-  let lineBox = display.lineDiv.getBoundingClientRect()
-
-  if (mY > lineBox.bottom || !hasHandler(cm, type)) return e_defaultPrevented(e)
-  mY -= lineBox.top - display.viewOffset
-
-  for (let i = 0; i < cm.display.gutterSpecs.length; ++i) {
-    let g = display.gutters.childNodes[i]
-    if (g && g.getBoundingClientRect().right >= mX) {
-      let line = lineAtHeight(cm.doc, mY)
-      let gutter = cm.display.gutterSpecs[i]
-      signal(cm, type, cm, line, gutter.className, e)
-      return e_defaultPrevented(e)
-    }
-  }
-}
-
-export function clickInGutter(cm, e) {
-  return gutterEvent(cm, e, "gutterClick", true)
-}
-
-// CONTEXT MENU HANDLING
-
-// To make the context menu work, we need to briefly unhide the
-// textarea (making it as unobtrusive as possible) to let the
-// right-click take effect on it.
-export function onContextMenu(cm, e) {
-  if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) return
-  if (signalDOMEvent(cm, e, "contextmenu")) return
-  if (!captureRightClick) cm.display.input.onContextMenu(e)
-}
-
-function contextMenuInGutter(cm, e) {
-  if (!hasHandler(cm, "gutterContextMenu")) return false
-  return gutterEvent(cm, e, "gutterContextMenu", false)
-}

package/www/codemirror/src/edit/options.js

@@ -1,194 +0,0 @@
-import { onBlur } from "../display/focus.js"
-import { getGutters, updateGutters } from "../display/gutters.js"
-import { loadMode, resetModeState } from "../display/mode_state.js"
-import { initScrollbars, updateScrollbars } from "../display/scrollbars.js"
-import { updateSelection } from "../display/selection.js"
-import { regChange } from "../display/view_tracking.js"
-import { getKeyMap } from "../input/keymap.js"
-import { defaultSpecialCharPlaceholder } from "../line/line_data.js"
-import { Pos } from "../line/pos.js"
-import { findMaxLine } from "../line/spans.js"
-import { clearCaches, compensateForHScroll, estimateLineHeights } from "../measurement/position_measurement.js"
-import { replaceRange } from "../model/changes.js"
-import { mobile, windows } from "../util/browser.js"
-import { addClass, rmClass } from "../util/dom.js"
-import { off, on } from "../util/event.js"
-
-import { themeChanged } from "./utils.js"
-
-export let Init = {toString: function(){return "CodeMirror.Init"}}
-
-export let defaults = {}
-export let optionHandlers = {}
-
-export function defineOptions(CodeMirror) {
-  let optionHandlers = CodeMirror.optionHandlers
-
-  function option(name, deflt, handle, notOnInit) {
-    CodeMirror.defaults[name] = deflt
-    if (handle) optionHandlers[name] =
-      notOnInit ? (cm, val, old) => {if (old != Init) handle(cm, val, old)} : handle
-  }
-
-  CodeMirror.defineOption = option
-
-  // Passed to option handlers when there is no old value.
-  CodeMirror.Init = Init
-
-  // These two are, on init, called from the constructor because they
-  // have to be initialized before the editor can start at all.
-  option("value", "", (cm, val) => cm.setValue(val), true)
-  option("mode", null, (cm, val) => {
-    cm.doc.modeOption = val
-    loadMode(cm)
-  }, true)
-
-  option("indentUnit", 2, loadMode, true)
-  option("indentWithTabs", false)
-  option("smartIndent", true)
-  option("tabSize", 4, cm => {
-    resetModeState(cm)
-    clearCaches(cm)
-    regChange(cm)
-  }, true)
-
-  option("lineSeparator", null, (cm, val) => {
-    cm.doc.lineSep = val
-    if (!val) return
-    let newBreaks = [], lineNo = cm.doc.first
-    cm.doc.iter(line => {
-      for (let pos = 0;;) {
-        let found = line.text.indexOf(val, pos)
-        if (found == -1) break
-        pos = found + val.length
-        newBreaks.push(Pos(lineNo, found))
-      }
-      lineNo++
-    })
-    for (let i = newBreaks.length - 1; i >= 0; i--)
-      replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length))
-  })
-  option("specialChars", /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\u202d\u202e\u2066\u2067\u2069\ufeff\ufff9-\ufffc]/g, (cm, val, old) => {
-    cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g")
-    if (old != Init) cm.refresh()
-  })
-  option("specialCharPlaceholder", defaultSpecialCharPlaceholder, cm => cm.refresh(), true)
-  option("electricChars", true)
-  option("inputStyle", mobile ? "contenteditable" : "textarea", () => {
-    throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME
-  }, true)
-  option("spellcheck", false, (cm, val) => cm.getInputField().spellcheck = val, true)
-  option("autocorrect", false, (cm, val) => cm.getInputField().autocorrect = val, true)
-  option("autocapitalize", false, (cm, val) => cm.getInputField().autocapitalize = val, true)
-  option("rtlMoveVisually", !windows)
-  option("wholeLineUpdateBefore", true)
-
-  option("theme", "default", cm => {
-    themeChanged(cm)
-    updateGutters(cm)
-  }, true)
-  option("keyMap", "default", (cm, val, old) => {
-    let next = getKeyMap(val)
-    let prev = old != Init && getKeyMap(old)
-    if (prev && prev.detach) prev.detach(cm, next)
-    if (next.attach) next.attach(cm, prev || null)
-  })
-  option("extraKeys", null)
-  option("configureMouse", null)
-
-  option("lineWrapping", false, wrappingChanged, true)
-  option("gutters", [], (cm, val) => {
-    cm.display.gutterSpecs = getGutters(val, cm.options.lineNumbers)
-    updateGutters(cm)
-  }, true)
-  option("fixedGutter", true, (cm, val) => {
-    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"
-    cm.refresh()
-  }, true)
-  option("coverGutterNextToScrollbar", false, cm => updateScrollbars(cm), true)
-  option("scrollbarStyle", "native", cm => {
-    initScrollbars(cm)
-    updateScrollbars(cm)
-    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)
-    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)
-  }, true)
-  option("lineNumbers", false, (cm, val) => {
-    cm.display.gutterSpecs = getGutters(cm.options.gutters, val)
-    updateGutters(cm)
-  }, true)
-  option("firstLineNumber", 1, updateGutters, true)
-  option("lineNumberFormatter", integer => integer, updateGutters, true)
-  option("showCursorWhenSelecting", false, updateSelection, true)
-
-  option("resetSelectionOnContextMenu", true)
-  option("lineWiseCopyCut", true)
-  option("pasteLinesPerSelection", true)
-  option("selectionsMayTouch", false)
-
-  option("readOnly", false, (cm, val) => {
-    if (val == "nocursor") {
-      onBlur(cm)
-      cm.display.input.blur()
-    }
-    cm.display.input.readOnlyChanged(val)
-  })
-
-  option("screenReaderLabel", null, (cm, val) => {
-    val = (val === '') ? null : val
-    cm.display.input.screenReaderLabelChanged(val)
-  })
-
-  option("disableInput", false, (cm, val) => {if (!val) cm.display.input.reset()}, true)
-  option("dragDrop", true, dragDropChanged)
-  option("allowDropFileTypes", null)
-
-  option("cursorBlinkRate", 530)
-  option("cursorScrollMargin", 0)
-  option("cursorHeight", 1, updateSelection, true)
-  option("singleCursorHeightPerLine", true, updateSelection, true)
-  option("workTime", 100)
-  option("workDelay", 100)
-  option("flattenSpans", true, resetModeState, true)
-  option("addModeClass", false, resetModeState, true)
-  option("pollInterval", 100)
-  option("undoDepth", 200, (cm, val) => cm.doc.history.undoDepth = val)
-  option("historyEventDelay", 1250)
-  option("viewportMargin", 10, cm => cm.refresh(), true)
-  option("maxHighlightLength", 10000, resetModeState, true)
-  option("moveInputWithCursor", true, (cm, val) => {
-    if (!val) cm.display.input.resetPosition()
-  })
-
-  option("tabindex", null, (cm, val) => cm.display.input.getField().tabIndex = val || "")
-  option("autofocus", null)
-  option("direction", "ltr", (cm, val) => cm.doc.setDirection(val), true)
-  option("phrases", null)
-}
-
-function dragDropChanged(cm, value, old) {
-  let wasOn = old && old != Init
-  if (!value != !wasOn) {
-    let funcs = cm.display.dragFunctions
-    let toggle = value ? on : off
-    toggle(cm.display.scroller, "dragstart", funcs.start)
-    toggle(cm.display.scroller, "dragenter", funcs.enter)
-    toggle(cm.display.scroller, "dragover", funcs.over)
-    toggle(cm.display.scroller, "dragleave", funcs.leave)
-    toggle(cm.display.scroller, "drop", funcs.drop)
-  }
-}
-
-function wrappingChanged(cm) {
-  if (cm.options.lineWrapping) {
-    addClass(cm.display.wrapper, "CodeMirror-wrap")
-    cm.display.sizer.style.minWidth = ""
-    cm.display.sizerWidth = null
-  } else {
-    rmClass(cm.display.wrapper, "CodeMirror-wrap")
-    findMaxLine(cm)
-  }
-  estimateLineHeights(cm)
-  regChange(cm)
-  clearCaches(cm)
-  setTimeout(() => updateScrollbars(cm), 100)
-}

package/www/codemirror/src/edit/utils.js

@@ -1,7 +0,0 @@
-import { clearCaches } from "../measurement/position_measurement.js"
-
-export function themeChanged(cm) {
-  cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
-    cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-")
-  clearCaches(cm)
-}