@muze-nl/simplystore 0.3.6 → 0.4.1

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

@@ -1,217 +0,0 @@
-import { Display } from "../display/Display.js"
-import { onFocus, onBlur } from "../display/focus.js"
-import { maybeUpdateLineNumberWidth } from "../display/line_numbers.js"
-import { endOperation, operation, startOperation } from "../display/operations.js"
-import { initScrollbars } from "../display/scrollbars.js"
-import { onScrollWheel } from "../display/scroll_events.js"
-import { setScrollLeft, updateScrollTop } from "../display/scrolling.js"
-import { clipPos, Pos } from "../line/pos.js"
-import { posFromMouse } from "../measurement/position_measurement.js"
-import { eventInWidget } from "../measurement/widgets.js"
-import Doc from "../model/Doc.js"
-import { attachDoc } from "../model/document_data.js"
-import { Range } from "../model/selection.js"
-import { extendSelection } from "../model/selection_updates.js"
-import { ie, ie_version, mobile, webkit } from "../util/browser.js"
-import { e_preventDefault, e_stop, on, signal, signalDOMEvent } from "../util/event.js"
-import { copyObj, Delayed } from "../util/misc.js"
-
-import { clearDragCursor, onDragOver, onDragStart, onDrop } from "./drop_events.js"
-import { ensureGlobalHandlers } from "./global_events.js"
-import { onKeyDown, onKeyPress, onKeyUp } from "./key_events.js"
-import { clickInGutter, onContextMenu, onMouseDown } from "./mouse_events.js"
-import { themeChanged } from "./utils.js"
-import { defaults, optionHandlers, Init } from "./options.js"
-
-// A CodeMirror instance represents an editor. This is the object
-// that user code is usually dealing with.
-
-export function CodeMirror(place, options) {
-  if (!(this instanceof CodeMirror)) return new CodeMirror(place, options)
-
-  this.options = options = options ? copyObj(options) : {}
-  // Determine effective options based on given values and defaults.
-  copyObj(defaults, options, false)
-
-  let doc = options.value
-  if (typeof doc == "string") doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction)
-  else if (options.mode) doc.modeOption = options.mode
-  this.doc = doc
-
-  let input = new CodeMirror.inputStyles[options.inputStyle](this)
-  let display = this.display = new Display(place, doc, input, options)
-  display.wrapper.CodeMirror = this
-  themeChanged(this)
-  if (options.lineWrapping)
-    this.display.wrapper.className += " CodeMirror-wrap"
-  initScrollbars(this)
-
-  this.state = {
-    keyMaps: [],  // stores maps added by addKeyMap
-    overlays: [], // highlighting overlays, as added by addOverlay
-    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
-    overwrite: false,
-    delayingBlurEvent: false,
-    focused: false,
-    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
-    pasteIncoming: -1, cutIncoming: -1, // help recognize paste/cut edits in input.poll
-    selectingText: false,
-    draggingText: false,
-    highlight: new Delayed(), // stores highlight worker timeout
-    keySeq: null,  // Unfinished key sequence
-    specialChars: null
-  }
-
-  if (options.autofocus && !mobile) display.input.focus()
-
-  // Override magic textarea content restore that IE sometimes does
-  // on our hidden textarea on reload
-  if (ie && ie_version < 11) setTimeout(() => this.display.input.reset(true), 20)
-
-  registerEventHandlers(this)
-  ensureGlobalHandlers()
-
-  startOperation(this)
-  this.curOp.forceUpdate = true
-  attachDoc(this, doc)
-
-  if ((options.autofocus && !mobile) || this.hasFocus())
-    setTimeout(() => {
-      if (this.hasFocus() && !this.state.focused) onFocus(this)
-    }, 20)
-  else
-    onBlur(this)
-
-  for (let opt in optionHandlers) if (optionHandlers.hasOwnProperty(opt))
-    optionHandlers[opt](this, options[opt], Init)
-  maybeUpdateLineNumberWidth(this)
-  if (options.finishInit) options.finishInit(this)
-  for (let i = 0; i < initHooks.length; ++i) initHooks[i](this)
-  endOperation(this)
-  // Suppress optimizelegibility in Webkit, since it breaks text
-  // measuring on line wrapping boundaries.
-  if (webkit && options.lineWrapping &&
-      getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
-    display.lineDiv.style.textRendering = "auto"
-}
-
-// The default configuration options.
-CodeMirror.defaults = defaults
-// Functions to run when options are changed.
-CodeMirror.optionHandlers = optionHandlers
-
-export default CodeMirror
-
-// Attach the necessary event handlers when initializing the editor
-function registerEventHandlers(cm) {
-  let d = cm.display
-  on(d.scroller, "mousedown", operation(cm, onMouseDown))
-  // Older IE's will not fire a second mousedown for a double click
-  if (ie && ie_version < 11)
-    on(d.scroller, "dblclick", operation(cm, e => {
-      if (signalDOMEvent(cm, e)) return
-      let pos = posFromMouse(cm, e)
-      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) return
-      e_preventDefault(e)
-      let word = cm.findWordAt(pos)
-      extendSelection(cm.doc, word.anchor, word.head)
-    }))
-  else
-    on(d.scroller, "dblclick", e => signalDOMEvent(cm, e) || e_preventDefault(e))
-  // Some browsers fire contextmenu *after* opening the menu, at
-  // which point we can't mess with it anymore. Context menu is
-  // handled in onMouseDown for these browsers.
-  on(d.scroller, "contextmenu", e => onContextMenu(cm, e))
-  on(d.input.getField(), "contextmenu", e => {
-    if (!d.scroller.contains(e.target)) onContextMenu(cm, e)
-  })
-
-  // Used to suppress mouse event handling when a touch happens
-  let touchFinished, prevTouch = {end: 0}
-  function finishTouch() {
-    if (d.activeTouch) {
-      touchFinished = setTimeout(() => d.activeTouch = null, 1000)
-      prevTouch = d.activeTouch
-      prevTouch.end = +new Date
-    }
-  }
-  function isMouseLikeTouchEvent(e) {
-    if (e.touches.length != 1) return false
-    let touch = e.touches[0]
-    return touch.radiusX <= 1 && touch.radiusY <= 1
-  }
-  function farAway(touch, other) {
-    if (other.left == null) return true
-    let dx = other.left - touch.left, dy = other.top - touch.top
-    return dx * dx + dy * dy > 20 * 20
-  }
-  on(d.scroller, "touchstart", e => {
-    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {
-      d.input.ensurePolled()
-      clearTimeout(touchFinished)
-      let now = +new Date
-      d.activeTouch = {start: now, moved: false,
-                       prev: now - prevTouch.end <= 300 ? prevTouch : null}
-      if (e.touches.length == 1) {
-        d.activeTouch.left = e.touches[0].pageX
-        d.activeTouch.top = e.touches[0].pageY
-      }
-    }
-  })
-  on(d.scroller, "touchmove", () => {
-    if (d.activeTouch) d.activeTouch.moved = true
-  })
-  on(d.scroller, "touchend", e => {
-    let touch = d.activeTouch
-    if (touch && !eventInWidget(d, e) && touch.left != null &&
-        !touch.moved && new Date - touch.start < 300) {
-      let pos = cm.coordsChar(d.activeTouch, "page"), range
-      if (!touch.prev || farAway(touch, touch.prev)) // Single tap
-        range = new Range(pos, pos)
-      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
-        range = cm.findWordAt(pos)
-      else // Triple tap
-        range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0)))
-      cm.setSelection(range.anchor, range.head)
-      cm.focus()
-      e_preventDefault(e)
-    }
-    finishTouch()
-  })
-  on(d.scroller, "touchcancel", finishTouch)
-
-  // Sync scrolling between fake scrollbars and real scrollable
-  // area, ensure viewport is updated when scrolling.
-  on(d.scroller, "scroll", () => {
-    if (d.scroller.clientHeight) {
-      updateScrollTop(cm, d.scroller.scrollTop)
-      setScrollLeft(cm, d.scroller.scrollLeft, true)
-      signal(cm, "scroll", cm)
-    }
-  })
-
-  // Listen to wheel events in order to try and update the viewport on time.
-  on(d.scroller, "mousewheel", e => onScrollWheel(cm, e))
-  on(d.scroller, "DOMMouseScroll", e => onScrollWheel(cm, e))
-
-  // Prevent wrapper from ever scrolling
-  on(d.wrapper, "scroll", () => d.wrapper.scrollTop = d.wrapper.scrollLeft = 0)
-
-  d.dragFunctions = {
-    enter: e => {if (!signalDOMEvent(cm, e)) e_stop(e)},
-    over: e => {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
-    start: e => onDragStart(cm, e),
-    drop: operation(cm, onDrop),
-    leave: e => {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
-  }
-
-  let inp = d.input.getField()
-  on(inp, "keyup", e => onKeyUp.call(cm, e))
-  on(inp, "keydown", operation(cm, onKeyDown))
-  on(inp, "keypress", operation(cm, onKeyPress))
-  on(inp, "focus", e => onFocus(cm, e))
-  on(inp, "blur", e => onBlur(cm, e))
-}
-
-let initHooks = []
-CodeMirror.defineInitHook = f => initHooks.push(f)

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

@@ -1,178 +0,0 @@
-import { deleteNearSelection } from "./deleteNearSelection.js"
-import { runInOp } from "../display/operations.js"
-import { ensureCursorVisible } from "../display/scrolling.js"
-import { endOfLine } from "../input/movement.js"
-import { clipPos, Pos } from "../line/pos.js"
-import { visualLine, visualLineEnd } from "../line/spans.js"
-import { getLine, lineNo } from "../line/utils_line.js"
-import { Range } from "../model/selection.js"
-import { selectAll } from "../model/selection_updates.js"
-import { countColumn, sel_dontScroll, sel_move, spaceStr } from "../util/misc.js"
-import { getOrder } from "../util/bidi.js"
-
-// Commands are parameter-less actions that can be performed on an
-// editor, mostly used for keybindings.
-export let commands = {
-  selectAll: selectAll,
-  singleSelection: cm => cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll),
-  killLine: cm => deleteNearSelection(cm, range => {
-    if (range.empty()) {
-      let len = getLine(cm.doc, range.head.line).text.length
-      if (range.head.ch == len && range.head.line < cm.lastLine())
-        return {from: range.head, to: Pos(range.head.line + 1, 0)}
-      else
-        return {from: range.head, to: Pos(range.head.line, len)}
-    } else {
-      return {from: range.from(), to: range.to()}
-    }
-  }),
-  deleteLine: cm => deleteNearSelection(cm, range => ({
-    from: Pos(range.from().line, 0),
-    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
-  })),
-  delLineLeft: cm => deleteNearSelection(cm, range => ({
-    from: Pos(range.from().line, 0), to: range.from()
-  })),
-  delWrappedLineLeft: cm => deleteNearSelection(cm, range => {
-    let top = cm.charCoords(range.head, "div").top + 5
-    let leftPos = cm.coordsChar({left: 0, top: top}, "div")
-    return {from: leftPos, to: range.from()}
-  }),
-  delWrappedLineRight: cm => deleteNearSelection(cm, range => {
-    let top = cm.charCoords(range.head, "div").top + 5
-    let rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
-    return {from: range.from(), to: rightPos }
-  }),
-  undo: cm => cm.undo(),
-  redo: cm => cm.redo(),
-  undoSelection: cm => cm.undoSelection(),
-  redoSelection: cm => cm.redoSelection(),
-  goDocStart: cm => cm.extendSelection(Pos(cm.firstLine(), 0)),
-  goDocEnd: cm => cm.extendSelection(Pos(cm.lastLine())),
-  goLineStart: cm => cm.extendSelectionsBy(range => lineStart(cm, range.head.line),
-    {origin: "+move", bias: 1}
-  ),
-  goLineStartSmart: cm => cm.extendSelectionsBy(range => lineStartSmart(cm, range.head),
-    {origin: "+move", bias: 1}
-  ),
-  goLineEnd: cm => cm.extendSelectionsBy(range => lineEnd(cm, range.head.line),
-    {origin: "+move", bias: -1}
-  ),
-  goLineRight: cm => cm.extendSelectionsBy(range => {
-    let top = cm.cursorCoords(range.head, "div").top + 5
-    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
-  }, sel_move),
-  goLineLeft: cm => cm.extendSelectionsBy(range => {
-    let top = cm.cursorCoords(range.head, "div").top + 5
-    return cm.coordsChar({left: 0, top: top}, "div")
-  }, sel_move),
-  goLineLeftSmart: cm => cm.extendSelectionsBy(range => {
-    let top = cm.cursorCoords(range.head, "div").top + 5
-    let pos = cm.coordsChar({left: 0, top: top}, "div")
-    if (pos.ch < cm.getLine(pos.line).search(/\S/)) return lineStartSmart(cm, range.head)
-    return pos
-  }, sel_move),
-  goLineUp: cm => cm.moveV(-1, "line"),
-  goLineDown: cm => cm.moveV(1, "line"),
-  goPageUp: cm => cm.moveV(-1, "page"),
-  goPageDown: cm => cm.moveV(1, "page"),
-  goCharLeft: cm => cm.moveH(-1, "char"),
-  goCharRight: cm => cm.moveH(1, "char"),
-  goColumnLeft: cm => cm.moveH(-1, "column"),
-  goColumnRight: cm => cm.moveH(1, "column"),
-  goWordLeft: cm => cm.moveH(-1, "word"),
-  goGroupRight: cm => cm.moveH(1, "group"),
-  goGroupLeft: cm => cm.moveH(-1, "group"),
-  goWordRight: cm => cm.moveH(1, "word"),
-  delCharBefore: cm => cm.deleteH(-1, "codepoint"),
-  delCharAfter: cm => cm.deleteH(1, "char"),
-  delWordBefore: cm => cm.deleteH(-1, "word"),
-  delWordAfter: cm => cm.deleteH(1, "word"),
-  delGroupBefore: cm => cm.deleteH(-1, "group"),
-  delGroupAfter: cm => cm.deleteH(1, "group"),
-  indentAuto: cm => cm.indentSelection("smart"),
-  indentMore: cm => cm.indentSelection("add"),
-  indentLess: cm => cm.indentSelection("subtract"),
-  insertTab: cm => cm.replaceSelection("\t"),
-  insertSoftTab: cm => {
-    let spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
-    for (let i = 0; i < ranges.length; i++) {
-      let pos = ranges[i].from()
-      let col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
-      spaces.push(spaceStr(tabSize - col % tabSize))
-    }
-    cm.replaceSelections(spaces)
-  },
-  defaultTab: cm => {
-    if (cm.somethingSelected()) cm.indentSelection("add")
-    else cm.execCommand("insertTab")
-  },
-  // Swap the two chars left and right of each selection's head.
-  // Move cursor behind the two swapped characters afterwards.
-  //
-  // Doesn't consider line feeds a character.
-  // Doesn't scan more than one line above to find a character.
-  // Doesn't do anything on an empty line.
-  // Doesn't do anything with non-empty selections.
-  transposeChars: cm => runInOp(cm, () => {
-    let ranges = cm.listSelections(), newSel = []
-    for (let i = 0; i < ranges.length; i++) {
-      if (!ranges[i].empty()) continue
-      let cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
-      if (line) {
-        if (cur.ch == line.length) cur = new Pos(cur.line, cur.ch - 1)
-        if (cur.ch > 0) {
-          cur = new Pos(cur.line, cur.ch + 1)
-          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
-                          Pos(cur.line, cur.ch - 2), cur, "+transpose")
-        } else if (cur.line > cm.doc.first) {
-          let prev = getLine(cm.doc, cur.line - 1).text
-          if (prev) {
-            cur = new Pos(cur.line, 1)
-            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
-                            prev.charAt(prev.length - 1),
-                            Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
-          }
-        }
-      }
-      newSel.push(new Range(cur, cur))
-    }
-    cm.setSelections(newSel)
-  }),
-  newlineAndIndent: cm => runInOp(cm, () => {
-    let sels = cm.listSelections()
-    for (let i = sels.length - 1; i >= 0; i--)
-      cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input")
-    sels = cm.listSelections()
-    for (let i = 0; i < sels.length; i++)
-      cm.indentLine(sels[i].from().line, null, true)
-    ensureCursorVisible(cm)
-  }),
-  openLine: cm => cm.replaceSelection("\n", "start"),
-  toggleOverwrite: cm => cm.toggleOverwrite()
-}
-
-
-function lineStart(cm, lineN) {
-  let line = getLine(cm.doc, lineN)
-  let visual = visualLine(line)
-  if (visual != line) lineN = lineNo(visual)
-  return endOfLine(true, cm, visual, lineN, 1)
-}
-function lineEnd(cm, lineN) {
-  let line = getLine(cm.doc, lineN)
-  let visual = visualLineEnd(line)
-  if (visual != line) lineN = lineNo(visual)
-  return endOfLine(true, cm, line, lineN, -1)
-}
-function lineStartSmart(cm, pos) {
-  let start = lineStart(cm, pos.line)
-  let line = getLine(cm.doc, start.line)
-  let order = getOrder(line, cm.doc.direction)
-  if (!order || order[0].level == 0) {
-    let firstNonWS = Math.max(start.ch, line.text.search(/\S/))
-    let inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
-    return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)
-  }
-  return start
-}

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

@@ -1,30 +0,0 @@
-import { runInOp } from "../display/operations.js"
-import { ensureCursorVisible } from "../display/scrolling.js"
-import { cmp } from "../line/pos.js"
-import { replaceRange } from "../model/changes.js"
-import { lst } from "../util/misc.js"
-
-// Helper for deleting text near the selection(s), used to implement
-// backspace, delete, and similar functionality.
-export function deleteNearSelection(cm, compute) {
-  let ranges = cm.doc.sel.ranges, kill = []
-  // Build up a set of ranges to kill first, merging overlapping
-  // ranges.
-  for (let i = 0; i < ranges.length; i++) {
-    let toKill = compute(ranges[i])
-    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
-      let replaced = kill.pop()
-      if (cmp(replaced.from, toKill.from) < 0) {
-        toKill.from = replaced.from
-        break
-      }
-    }
-    kill.push(toKill)
-  }
-  // Next, remove those actual ranges.
-  runInOp(cm, () => {
-    for (let i = kill.length - 1; i >= 0; i--)
-      replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete")
-    ensureCursorVisible(cm)
-  })
-}

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

@@ -1,130 +0,0 @@
-import { drawSelectionCursor } from "../display/selection.js"
-import { operation } from "../display/operations.js"
-import { clipPos } from "../line/pos.js"
-import { posFromMouse } from "../measurement/position_measurement.js"
-import { eventInWidget } from "../measurement/widgets.js"
-import { makeChange, replaceRange } from "../model/changes.js"
-import { changeEnd } from "../model/change_measurement.js"
-import { simpleSelection } from "../model/selection.js"
-import { setSelectionNoUndo, setSelectionReplaceHistory } from "../model/selection_updates.js"
-import { ie, presto, safari } from "../util/browser.js"
-import { elt, removeChildrenAndAdd } from "../util/dom.js"
-import { e_preventDefault, e_stop, signalDOMEvent } from "../util/event.js"
-import { indexOf } from "../util/misc.js"
-
-// Kludge to work around strange IE behavior where it'll sometimes
-// re-fire a series of drag-related events right after the drop (#1551)
-let lastDrop = 0
-
-export function onDrop(e) {
-  let cm = this
-  clearDragCursor(cm)
-  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
-    return
-  e_preventDefault(e)
-  if (ie) lastDrop = +new Date
-  let pos = posFromMouse(cm, e, true), files = e.dataTransfer.files
-  if (!pos || cm.isReadOnly()) return
-  // Might be a file drop, in which case we simply extract the text
-  // and insert it.
-  if (files && files.length && window.FileReader && window.File) {
-    let n = files.length, text = Array(n), read = 0
-    const markAsReadAndPasteIfAllFilesAreRead = () => {
-      if (++read == n) {
-        operation(cm, () => {
-          pos = clipPos(cm.doc, pos)
-          let change = {from: pos, to: pos,
-                        text: cm.doc.splitLines(
-                            text.filter(t => t != null).join(cm.doc.lineSeparator())),
-                        origin: "paste"}
-          makeChange(cm.doc, change)
-          setSelectionReplaceHistory(cm.doc, simpleSelection(clipPos(cm.doc, pos), clipPos(cm.doc, changeEnd(change))))
-        })()
-      }
-    }
-    const readTextFromFile = (file, i) => {
-      if (cm.options.allowDropFileTypes &&
-          indexOf(cm.options.allowDropFileTypes, file.type) == -1) {
-        markAsReadAndPasteIfAllFilesAreRead()
-        return
-      }
-      let reader = new FileReader
-      reader.onerror = () => markAsReadAndPasteIfAllFilesAreRead()
-      reader.onload = () => {
-        let content = reader.result
-        if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) {
-          markAsReadAndPasteIfAllFilesAreRead()
-          return
-        }
-        text[i] = content
-        markAsReadAndPasteIfAllFilesAreRead()
-      }
-      reader.readAsText(file)
-    }
-    for (let i = 0; i < files.length; i++) readTextFromFile(files[i], i)
-  } else { // Normal drop
-    // Don't do a replace if the drop happened inside of the selected text.
-    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
-      cm.state.draggingText(e)
-      // Ensure the editor is re-focused
-      setTimeout(() => cm.display.input.focus(), 20)
-      return
-    }
-    try {
-      let text = e.dataTransfer.getData("Text")
-      if (text) {
-        let selected
-        if (cm.state.draggingText && !cm.state.draggingText.copy)
-          selected = cm.listSelections()
-        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))
-        if (selected) for (let i = 0; i < selected.length; ++i)
-          replaceRange(cm.doc, "", selected[i].anchor, selected[i].head, "drag")
-        cm.replaceSelection(text, "around", "paste")
-        cm.display.input.focus()
-      }
-    }
-    catch(e){}
-  }
-}
-
-export function onDragStart(cm, e) {
-  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
-  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) return
-
-  e.dataTransfer.setData("Text", cm.getSelection())
-  e.dataTransfer.effectAllowed = "copyMove"
-
-  // Use dummy image instead of default browsers image.
-  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
-  if (e.dataTransfer.setDragImage && !safari) {
-    let img = elt("img", null, null, "position: fixed; left: 0; top: 0;")
-    img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
-    if (presto) {
-      img.width = img.height = 1
-      cm.display.wrapper.appendChild(img)
-      // Force a relayout, or Opera won't use our image for some obscure reason
-      img._top = img.offsetTop
-    }
-    e.dataTransfer.setDragImage(img, 0, 0)
-    if (presto) img.parentNode.removeChild(img)
-  }
-}
-
-export function onDragOver(cm, e) {
-  let pos = posFromMouse(cm, e)
-  if (!pos) return
-  let frag = document.createDocumentFragment()
-  drawSelectionCursor(cm, pos, frag)
-  if (!cm.display.dragCursor) {
-    cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors")
-    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)
-  }
-  removeChildrenAndAdd(cm.display.dragCursor, frag)
-}
-
-export function clearDragCursor(cm) {
-  if (cm.display.dragCursor) {
-    cm.display.lineSpace.removeChild(cm.display.dragCursor)
-    cm.display.dragCursor = null
-  }
-}

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

@@ -1,61 +0,0 @@
-import { CodeMirror } from "./CodeMirror.js"
-import { activeElt } from "../util/dom.js"
-import { off, on } from "../util/event.js"
-import { copyObj } from "../util/misc.js"
-
-export function fromTextArea(textarea, options) {
-  options = options ? copyObj(options) : {}
-  options.value = textarea.value
-  if (!options.tabindex && textarea.tabIndex)
-    options.tabindex = textarea.tabIndex
-  if (!options.placeholder && textarea.placeholder)
-    options.placeholder = textarea.placeholder
-  // Set autofocus to true if this textarea is focused, or if it has
-  // autofocus and no other element is focused.
-  if (options.autofocus == null) {
-    let hasFocus = activeElt(textarea.ownerDocument)
-    options.autofocus = hasFocus == textarea ||
-      textarea.getAttribute("autofocus") != null && hasFocus == document.body
-  }
-
-  function save() {textarea.value = cm.getValue()}
-
-  let realSubmit
-  if (textarea.form) {
-    on(textarea.form, "submit", save)
-    // Deplorable hack to make the submit method do the right thing.
-    if (!options.leaveSubmitMethodAlone) {
-      let form = textarea.form
-      realSubmit = form.submit
-      try {
-        let wrappedSubmit = form.submit = () => {
-          save()
-          form.submit = realSubmit
-          form.submit()
-          form.submit = wrappedSubmit
-        }
-      } catch(e) {}
-    }
-  }
-
-  options.finishInit = cm => {
-    cm.save = save
-    cm.getTextArea = () => textarea
-    cm.toTextArea = () => {
-      cm.toTextArea = isNaN // Prevent this from being ran twice
-      save()
-      textarea.parentNode.removeChild(cm.getWrapperElement())
-      textarea.style.display = ""
-      if (textarea.form) {
-        off(textarea.form, "submit", save)
-        if (!options.leaveSubmitMethodAlone && typeof textarea.form.submit == "function")
-          textarea.form.submit = realSubmit
-      }
-    }
-  }
-
-  textarea.style.display = "none"
-  let cm = CodeMirror(node => textarea.parentNode.insertBefore(node, textarea.nextSibling),
-    options)
-  return cm
-}

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

@@ -1,45 +0,0 @@
-import { onBlur } from "../display/focus.js"
-import { on } from "../util/event.js"
-
-// These must be handled carefully, because naively registering a
-// handler for each editor will cause the editors to never be
-// garbage collected.
-
-function forEachCodeMirror(f) {
-  if (!document.getElementsByClassName) return
-  let byClass = document.getElementsByClassName("CodeMirror"), editors = []
-  for (let i = 0; i < byClass.length; i++) {
-    let cm = byClass[i].CodeMirror
-    if (cm) editors.push(cm)
-  }
-  if (editors.length) editors[0].operation(() => {
-    for (let i = 0; i < editors.length; i++) f(editors[i])
-  })
-}
-
-let globalsRegistered = false
-export function ensureGlobalHandlers() {
-  if (globalsRegistered) return
-  registerGlobalHandlers()
-  globalsRegistered = true
-}
-function registerGlobalHandlers() {
-  // When the window resizes, we need to refresh active editors.
-  let resizeTimer
-  on(window, "resize", () => {
-    if (resizeTimer == null) resizeTimer = setTimeout(() => {
-      resizeTimer = null
-      forEachCodeMirror(onResize)
-    }, 100)
-  })
-  // When the window loses focus, we want to show the editor as blurred
-  on(window, "blur", () => forEachCodeMirror(onBlur))
-}
-// Called when the window resizes
-function onResize(cm) {
-  let d = cm.display
-  // Might be a text scaling operation, clear size caches.
-  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
-  d.scrollbarsClipped = false
-  cm.setSize()
-}