@muze-nl/simplystore 0.3.5 → 0.4.0

package/www/codemirror/src/model/history.js

@@ -1,228 +0,0 @@
-import { cmp, copyPos } from "../line/pos.js"
-import { stretchSpansOverChange } from "../line/spans.js"
-import { getBetween } from "../line/utils_line.js"
-import { signal } from "../util/event.js"
-import { indexOf, lst } from "../util/misc.js"
-
-import { changeEnd } from "./change_measurement.js"
-import { linkedDocs } from "./document_data.js"
-import { Selection } from "./selection.js"
-
-export function History(prev) {
-  // Arrays of change events and selections. Doing something adds an
-  // event to done and clears undo. Undoing moves events from done
-  // to undone, redoing moves them in the other direction.
-  this.done = []; this.undone = []
-  this.undoDepth = prev ? prev.undoDepth : Infinity
-  // Used to track when changes can be merged into a single undo
-  // event
-  this.lastModTime = this.lastSelTime = 0
-  this.lastOp = this.lastSelOp = null
-  this.lastOrigin = this.lastSelOrigin = null
-  // Used by the isClean() method
-  this.generation = this.maxGeneration = prev ? prev.maxGeneration : 1
-}
-
-// Create a history change event from an updateDoc-style change
-// object.
-export function historyChangeFromChange(doc, change) {
-  let histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}
-  attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)
-  linkedDocs(doc, doc => attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1), true)
-  return histChange
-}
-
-// Pop all selection events off the end of a history array. Stop at
-// a change event.
-function clearSelectionEvents(array) {
-  while (array.length) {
-    let last = lst(array)
-    if (last.ranges) array.pop()
-    else break
-  }
-}
-
-// Find the top change event in the history. Pop off selection
-// events that are in the way.
-function lastChangeEvent(hist, force) {
-  if (force) {
-    clearSelectionEvents(hist.done)
-    return lst(hist.done)
-  } else if (hist.done.length && !lst(hist.done).ranges) {
-    return lst(hist.done)
-  } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
-    hist.done.pop()
-    return lst(hist.done)
-  }
-}
-
-// Register a change in the history. Merges changes that are within
-// a single operation, or are close together with an origin that
-// allows merging (starting with "+") into a single event.
-export function addChangeToHistory(doc, change, selAfter, opId) {
-  let hist = doc.history
-  hist.undone.length = 0
-  let time = +new Date, cur
-  let last
-
-  if ((hist.lastOp == opId ||
-       hist.lastOrigin == change.origin && change.origin &&
-       ((change.origin.charAt(0) == "+" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) ||
-        change.origin.charAt(0) == "*")) &&
-      (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
-    // Merge this change into the last event
-    last = lst(cur.changes)
-    if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
-      // Optimized case for simple insertion -- don't want to add
-      // new changesets for every character typed
-      last.to = changeEnd(change)
-    } else {
-      // Add new sub-event
-      cur.changes.push(historyChangeFromChange(doc, change))
-    }
-  } else {
-    // Can not be merged, start a new event.
-    let before = lst(hist.done)
-    if (!before || !before.ranges)
-      pushSelectionToHistory(doc.sel, hist.done)
-    cur = {changes: [historyChangeFromChange(doc, change)],
-           generation: hist.generation}
-    hist.done.push(cur)
-    while (hist.done.length > hist.undoDepth) {
-      hist.done.shift()
-      if (!hist.done[0].ranges) hist.done.shift()
-    }
-  }
-  hist.done.push(selAfter)
-  hist.generation = ++hist.maxGeneration
-  hist.lastModTime = hist.lastSelTime = time
-  hist.lastOp = hist.lastSelOp = opId
-  hist.lastOrigin = hist.lastSelOrigin = change.origin
-
-  if (!last) signal(doc, "historyAdded")
-}
-
-function selectionEventCanBeMerged(doc, origin, prev, sel) {
-  let ch = origin.charAt(0)
-  return ch == "*" ||
-    ch == "+" &&
-    prev.ranges.length == sel.ranges.length &&
-    prev.somethingSelected() == sel.somethingSelected() &&
-    new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)
-}
-
-// Called whenever the selection changes, sets the new selection as
-// the pending selection in the history, and pushes the old pending
-// selection into the 'done' array when it was significantly
-// different (in number of selected ranges, emptiness, or time).
-export function addSelectionToHistory(doc, sel, opId, options) {
-  let hist = doc.history, origin = options && options.origin
-
-  // A new event is started when the previous origin does not match
-  // the current, or the origins don't allow matching. Origins
-  // starting with * are always merged, those starting with + are
-  // merged when similar and close together in time.
-  if (opId == hist.lastSelOp ||
-      (origin && hist.lastSelOrigin == origin &&
-       (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
-        selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
-    hist.done[hist.done.length - 1] = sel
-  else
-    pushSelectionToHistory(sel, hist.done)
-
-  hist.lastSelTime = +new Date
-  hist.lastSelOrigin = origin
-  hist.lastSelOp = opId
-  if (options && options.clearRedo !== false)
-    clearSelectionEvents(hist.undone)
-}
-
-export function pushSelectionToHistory(sel, dest) {
-  let top = lst(dest)
-  if (!(top && top.ranges && top.equals(sel)))
-    dest.push(sel)
-}
-
-// Used to store marked span information in the history.
-function attachLocalSpans(doc, change, from, to) {
-  let existing = change["spans_" + doc.id], n = 0
-  doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), line => {
-    if (line.markedSpans)
-      (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans
-    ++n
-  })
-}
-
-// When un/re-doing restores text containing marked spans, those
-// that have been explicitly cleared should not be restored.
-function removeClearedSpans(spans) {
-  if (!spans) return null
-  let out
-  for (let i = 0; i < spans.length; ++i) {
-    if (spans[i].marker.explicitlyCleared) { if (!out) out = spans.slice(0, i) }
-    else if (out) out.push(spans[i])
-  }
-  return !out ? spans : out.length ? out : null
-}
-
-// Retrieve and filter the old marked spans stored in a change event.
-function getOldSpans(doc, change) {
-  let found = change["spans_" + doc.id]
-  if (!found) return null
-  let nw = []
-  for (let i = 0; i < change.text.length; ++i)
-    nw.push(removeClearedSpans(found[i]))
-  return nw
-}
-
-// Used for un/re-doing changes from the history. Combines the
-// result of computing the existing spans with the set of spans that
-// existed in the history (so that deleting around a span and then
-// undoing brings back the span).
-export function mergeOldSpans(doc, change) {
-  let old = getOldSpans(doc, change)
-  let stretched = stretchSpansOverChange(doc, change)
-  if (!old) return stretched
-  if (!stretched) return old
-
-  for (let i = 0; i < old.length; ++i) {
-    let oldCur = old[i], stretchCur = stretched[i]
-    if (oldCur && stretchCur) {
-      spans: for (let j = 0; j < stretchCur.length; ++j) {
-        let span = stretchCur[j]
-        for (let k = 0; k < oldCur.length; ++k)
-          if (oldCur[k].marker == span.marker) continue spans
-        oldCur.push(span)
-      }
-    } else if (stretchCur) {
-      old[i] = stretchCur
-    }
-  }
-  return old
-}
-
-// Used both to provide a JSON-safe object in .getHistory, and, when
-// detaching a document, to split the history in two
-export function copyHistoryArray(events, newGroup, instantiateSel) {
-  let copy = []
-  for (let i = 0; i < events.length; ++i) {
-    let event = events[i]
-    if (event.ranges) {
-      copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)
-      continue
-    }
-    let changes = event.changes, newChanges = []
-    copy.push({changes: newChanges})
-    for (let j = 0; j < changes.length; ++j) {
-      let change = changes[j], m
-      newChanges.push({from: change.from, to: change.to, text: change.text})
-      if (newGroup) for (var prop in change) if (m = prop.match(/^spans_(\d+)$/)) {
-        if (indexOf(newGroup, Number(m[1])) > -1) {
-          lst(newChanges)[prop] = change[prop]
-          delete change[prop]
-        }
-      }
-    }
-  }
-  return copy
-}

package/www/codemirror/src/model/line_widget.js

@@ -1,78 +0,0 @@
-import { runInOp } from "../display/operations.js"
-import { addToScrollTop } from "../display/scrolling.js"
-import { regLineChange } from "../display/view_tracking.js"
-import { heightAtLine, lineIsHidden } from "../line/spans.js"
-import { lineNo, updateLineHeight } from "../line/utils_line.js"
-import { widgetHeight } from "../measurement/widgets.js"
-import { changeLine } from "./changes.js"
-import { eventMixin } from "../util/event.js"
-import { signalLater } from "../util/operation_group.js"
-
-// Line widgets are block elements displayed above or below a line.
-
-export class LineWidget {
-  constructor(doc, node, options) {
-    if (options) for (let opt in options) if (options.hasOwnProperty(opt))
-      this[opt] = options[opt]
-    this.doc = doc
-    this.node = node
-  }
-
-  clear() {
-    let cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)
-    if (no == null || !ws) return
-    for (let i = 0; i < ws.length; ++i) if (ws[i] == this) ws.splice(i--, 1)
-    if (!ws.length) line.widgets = null
-    let height = widgetHeight(this)
-    updateLineHeight(line, Math.max(0, line.height - height))
-    if (cm) {
-      runInOp(cm, () => {
-        adjustScrollWhenAboveVisible(cm, line, -height)
-        regLineChange(cm, no, "widget")
-      })
-      signalLater(cm, "lineWidgetCleared", cm, this, no)
-    }
-  }
-
-  changed() {
-    let oldH = this.height, cm = this.doc.cm, line = this.line
-    this.height = null
-    let diff = widgetHeight(this) - oldH
-    if (!diff) return
-    if (!lineIsHidden(this.doc, line)) updateLineHeight(line, line.height + diff)
-    if (cm) {
-      runInOp(cm, () => {
-        cm.curOp.forceUpdate = true
-        adjustScrollWhenAboveVisible(cm, line, diff)
-        signalLater(cm, "lineWidgetChanged", cm, this, lineNo(line))
-      })
-    }
-  }
-}
-eventMixin(LineWidget)
-
-function adjustScrollWhenAboveVisible(cm, line, diff) {
-  if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
-    addToScrollTop(cm, diff)
-}
-
-export function addLineWidget(doc, handle, node, options) {
-  let widget = new LineWidget(doc, node, options)
-  let cm = doc.cm
-  if (cm && widget.noHScroll) cm.display.alignWidgets = true
-  changeLine(doc, handle, "widget", line => {
-    let widgets = line.widgets || (line.widgets = [])
-    if (widget.insertAt == null) widgets.push(widget)
-    else widgets.splice(Math.min(widgets.length, Math.max(0, widget.insertAt)), 0, widget)
-    widget.line = line
-    if (cm && !lineIsHidden(doc, line)) {
-      let aboveVisible = heightAtLine(line) < doc.scrollTop
-      updateLineHeight(line, line.height + widgetHeight(widget))
-      if (aboveVisible) addToScrollTop(cm, widget.height)
-      cm.curOp.forceUpdate = true
-    }
-    return true
-  })
-  if (cm) signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle))
-  return widget
-}

package/www/codemirror/src/model/mark_text.js

@@ -1,293 +0,0 @@
-import { eltP } from "../util/dom.js"
-import { eventMixin, hasHandler, on } from "../util/event.js"
-import { endOperation, operation, runInOp, startOperation } from "../display/operations.js"
-import { clipPos, cmp, Pos } from "../line/pos.js"
-import { lineNo, updateLineHeight } from "../line/utils_line.js"
-import { clearLineMeasurementCacheFor, findViewForLine, textHeight } from "../measurement/position_measurement.js"
-import { seeReadOnlySpans, seeCollapsedSpans } from "../line/saw_special_spans.js"
-import { addMarkedSpan, conflictingCollapsedRange, getMarkedSpanFor, lineIsHidden, lineLength, MarkedSpan, removeMarkedSpan, visualLine } from "../line/spans.js"
-import { copyObj, indexOf, lst } from "../util/misc.js"
-import { signalLater } from "../util/operation_group.js"
-import { widgetHeight } from "../measurement/widgets.js"
-import { regChange, regLineChange } from "../display/view_tracking.js"
-
-import { linkedDocs } from "./document_data.js"
-import { addChangeToHistory } from "./history.js"
-import { reCheckSelection } from "./selection_updates.js"
-
-// TEXTMARKERS
-
-// Created with markText and setBookmark methods. A TextMarker is a
-// handle that can be used to clear or find a marked position in the
-// document. Line objects hold arrays (markedSpans) containing
-// {from, to, marker} object pointing to such marker objects, and
-// indicating that such a marker is present on that line. Multiple
-// lines may point to the same marker when it spans across lines.
-// The spans will have null for their from/to properties when the
-// marker continues beyond the start/end of the line. Markers have
-// links back to the lines they currently touch.
-
-// Collapsed markers have unique ids, in order to be able to order
-// them, which is needed for uniquely determining an outer marker
-// when they overlap (they may nest, but not partially overlap).
-let nextMarkerId = 0
-
-export class TextMarker {
-  constructor(doc, type) {
-    this.lines = []
-    this.type = type
-    this.doc = doc
-    this.id = ++nextMarkerId
-  }
-
-  // Clear the marker.
-  clear() {
-    if (this.explicitlyCleared) return
-    let cm = this.doc.cm, withOp = cm && !cm.curOp
-    if (withOp) startOperation(cm)
-    if (hasHandler(this, "clear")) {
-      let found = this.find()
-      if (found) signalLater(this, "clear", found.from, found.to)
-    }
-    let min = null, max = null
-    for (let i = 0; i < this.lines.length; ++i) {
-      let line = this.lines[i]
-      let span = getMarkedSpanFor(line.markedSpans, this)
-      if (cm && !this.collapsed) regLineChange(cm, lineNo(line), "text")
-      else if (cm) {
-        if (span.to != null) max = lineNo(line)
-        if (span.from != null) min = lineNo(line)
-      }
-      line.markedSpans = removeMarkedSpan(line.markedSpans, span)
-      if (span.from == null && this.collapsed && !lineIsHidden(this.doc, line) && cm)
-        updateLineHeight(line, textHeight(cm.display))
-    }
-    if (cm && this.collapsed && !cm.options.lineWrapping) for (let i = 0; i < this.lines.length; ++i) {
-      let visual = visualLine(this.lines[i]), len = lineLength(visual)
-      if (len > cm.display.maxLineLength) {
-        cm.display.maxLine = visual
-        cm.display.maxLineLength = len
-        cm.display.maxLineChanged = true
-      }
-    }
-
-    if (min != null && cm && this.collapsed) regChange(cm, min, max + 1)
-    this.lines.length = 0
-    this.explicitlyCleared = true
-    if (this.atomic && this.doc.cantEdit) {
-      this.doc.cantEdit = false
-      if (cm) reCheckSelection(cm.doc)
-    }
-    if (cm) signalLater(cm, "markerCleared", cm, this, min, max)
-    if (withOp) endOperation(cm)
-    if (this.parent) this.parent.clear()
-  }
-
-  // Find the position of the marker in the document. Returns a {from,
-  // to} object by default. Side can be passed to get a specific side
-  // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
-  // Pos objects returned contain a line object, rather than a line
-  // number (used to prevent looking up the same line twice).
-  find(side, lineObj) {
-    if (side == null && this.type == "bookmark") side = 1
-    let from, to
-    for (let i = 0; i < this.lines.length; ++i) {
-      let line = this.lines[i]
-      let span = getMarkedSpanFor(line.markedSpans, this)
-      if (span.from != null) {
-        from = Pos(lineObj ? line : lineNo(line), span.from)
-        if (side == -1) return from
-      }
-      if (span.to != null) {
-        to = Pos(lineObj ? line : lineNo(line), span.to)
-        if (side == 1) return to
-      }
-    }
-    return from && {from: from, to: to}
-  }
-
-  // Signals that the marker's widget changed, and surrounding layout
-  // should be recomputed.
-  changed() {
-    let pos = this.find(-1, true), widget = this, cm = this.doc.cm
-    if (!pos || !cm) return
-    runInOp(cm, () => {
-      let line = pos.line, lineN = lineNo(pos.line)
-      let view = findViewForLine(cm, lineN)
-      if (view) {
-        clearLineMeasurementCacheFor(view)
-        cm.curOp.selectionChanged = cm.curOp.forceUpdate = true
-      }
-      cm.curOp.updateMaxLine = true
-      if (!lineIsHidden(widget.doc, line) && widget.height != null) {
-        let oldHeight = widget.height
-        widget.height = null
-        let dHeight = widgetHeight(widget) - oldHeight
-        if (dHeight)
-          updateLineHeight(line, line.height + dHeight)
-      }
-      signalLater(cm, "markerChanged", cm, this)
-    })
-  }
-
-  attachLine(line) {
-    if (!this.lines.length && this.doc.cm) {
-      let op = this.doc.cm.curOp
-      if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
-        (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this)
-    }
-    this.lines.push(line)
-  }
-
-  detachLine(line) {
-    this.lines.splice(indexOf(this.lines, line), 1)
-    if (!this.lines.length && this.doc.cm) {
-      let op = this.doc.cm.curOp
-      ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)
-    }
-  }
-}
-eventMixin(TextMarker)
-
-// Create a marker, wire it up to the right lines, and
-export function markText(doc, from, to, options, type) {
-  // Shared markers (across linked documents) are handled separately
-  // (markTextShared will call out to this again, once per
-  // document).
-  if (options && options.shared) return markTextShared(doc, from, to, options, type)
-  // Ensure we are in an operation.
-  if (doc.cm && !doc.cm.curOp) return operation(doc.cm, markText)(doc, from, to, options, type)
-
-  let marker = new TextMarker(doc, type), diff = cmp(from, to)
-  if (options) copyObj(options, marker, false)
-  // Don't connect empty markers unless clearWhenEmpty is false
-  if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
-    return marker
-  if (marker.replacedWith) {
-    // Showing up as a widget implies collapsed (widget replaces text)
-    marker.collapsed = true
-    marker.widgetNode = eltP("span", [marker.replacedWith], "CodeMirror-widget")
-    if (!options.handleMouseEvents) marker.widgetNode.setAttribute("cm-ignore-events", "true")
-    if (options.insertLeft) marker.widgetNode.insertLeft = true
-  }
-  if (marker.collapsed) {
-    if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
-        from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
-      throw new Error("Inserting collapsed marker partially overlapping an existing one")
-    seeCollapsedSpans()
-  }
-
-  if (marker.addToHistory)
-    addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN)
-
-  let curLine = from.line, cm = doc.cm, updateMaxLine
-  doc.iter(curLine, to.line + 1, line => {
-    if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
-      updateMaxLine = true
-    if (marker.collapsed && curLine != from.line) updateLineHeight(line, 0)
-    addMarkedSpan(line, new MarkedSpan(marker,
-                                       curLine == from.line ? from.ch : null,
-                                       curLine == to.line ? to.ch : null), doc.cm && doc.cm.curOp)
-    ++curLine
-  })
-  // lineIsHidden depends on the presence of the spans, so needs a second pass
-  if (marker.collapsed) doc.iter(from.line, to.line + 1, line => {
-    if (lineIsHidden(doc, line)) updateLineHeight(line, 0)
-  })
-
-  if (marker.clearOnEnter) on(marker, "beforeCursorEnter", () => marker.clear())
-
-  if (marker.readOnly) {
-    seeReadOnlySpans()
-    if (doc.history.done.length || doc.history.undone.length)
-      doc.clearHistory()
-  }
-  if (marker.collapsed) {
-    marker.id = ++nextMarkerId
-    marker.atomic = true
-  }
-  if (cm) {
-    // Sync editor state
-    if (updateMaxLine) cm.curOp.updateMaxLine = true
-    if (marker.collapsed)
-      regChange(cm, from.line, to.line + 1)
-    else if (marker.className || marker.startStyle || marker.endStyle || marker.css ||
-             marker.attributes || marker.title)
-      for (let i = from.line; i <= to.line; i++) regLineChange(cm, i, "text")
-    if (marker.atomic) reCheckSelection(cm.doc)
-    signalLater(cm, "markerAdded", cm, marker)
-  }
-  return marker
-}
-
-// SHARED TEXTMARKERS
-
-// A shared marker spans multiple linked documents. It is
-// implemented as a meta-marker-object controlling multiple normal
-// markers.
-export class SharedTextMarker {
-  constructor(markers, primary) {
-    this.markers = markers
-    this.primary = primary
-    for (let i = 0; i < markers.length; ++i)
-      markers[i].parent = this
-  }
-
-  clear() {
-    if (this.explicitlyCleared) return
-    this.explicitlyCleared = true
-    for (let i = 0; i < this.markers.length; ++i)
-      this.markers[i].clear()
-    signalLater(this, "clear")
-  }
-
-  find(side, lineObj) {
-    return this.primary.find(side, lineObj)
-  }
-}
-eventMixin(SharedTextMarker)
-
-function markTextShared(doc, from, to, options, type) {
-  options = copyObj(options)
-  options.shared = false
-  let markers = [markText(doc, from, to, options, type)], primary = markers[0]
-  let widget = options.widgetNode
-  linkedDocs(doc, doc => {
-    if (widget) options.widgetNode = widget.cloneNode(true)
-    markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))
-    for (let i = 0; i < doc.linked.length; ++i)
-      if (doc.linked[i].isParent) return
-    primary = lst(markers)
-  })
-  return new SharedTextMarker(markers, primary)
-}
-
-export function findSharedMarkers(doc) {
-  return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), m => m.parent)
-}
-
-export function copySharedMarkers(doc, markers) {
-  for (let i = 0; i < markers.length; i++) {
-    let marker = markers[i], pos = marker.find()
-    let mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)
-    if (cmp(mFrom, mTo)) {
-      let subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)
-      marker.markers.push(subMark)
-      subMark.parent = marker
-    }
-  }
-}
-
-export function detachSharedMarkers(markers) {
-  for (let i = 0; i < markers.length; i++) {
-    let marker = markers[i], linked = [marker.primary.doc]
-    linkedDocs(marker.primary.doc, d => linked.push(d))
-    for (let j = 0; j < marker.markers.length; j++) {
-      let subMarker = marker.markers[j]
-      if (indexOf(linked, subMarker.doc) == -1) {
-        subMarker.parent = null
-        marker.markers.splice(j--, 1)
-      }
-    }
-  }
-}

package/www/codemirror/src/model/selection.js

@@ -1,84 +0,0 @@
-import { cmp, copyPos, equalCursorPos, maxPos, minPos } from "../line/pos.js"
-import { indexOf } from "../util/misc.js"
-
-// Selection objects are immutable. A new one is created every time
-// the selection changes. A selection is one or more non-overlapping
-// (and non-touching) ranges, sorted, and an integer that indicates
-// which one is the primary selection (the one that's scrolled into
-// view, that getCursor returns, etc).
-export class Selection {
-  constructor(ranges, primIndex) {
-    this.ranges = ranges
-    this.primIndex = primIndex
-  }
-
-  primary() { return this.ranges[this.primIndex] }
-
-  equals(other) {
-    if (other == this) return true
-    if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) return false
-    for (let i = 0; i < this.ranges.length; i++) {
-      let here = this.ranges[i], there = other.ranges[i]
-      if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) return false
-    }
-    return true
-  }
-
-  deepCopy() {
-    let out = []
-    for (let i = 0; i < this.ranges.length; i++)
-      out[i] = new Range(copyPos(this.ranges[i].anchor), copyPos(this.ranges[i].head))
-    return new Selection(out, this.primIndex)
-  }
-
-  somethingSelected() {
-    for (let i = 0; i < this.ranges.length; i++)
-      if (!this.ranges[i].empty()) return true
-    return false
-  }
-
-  contains(pos, end) {
-    if (!end) end = pos
-    for (let i = 0; i < this.ranges.length; i++) {
-      let range = this.ranges[i]
-      if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
-        return i
-    }
-    return -1
-  }
-}
-
-export class Range {
-  constructor(anchor, head) {
-    this.anchor = anchor; this.head = head
-  }
-
-  from() { return minPos(this.anchor, this.head) }
-  to() { return maxPos(this.anchor, this.head) }
-  empty() { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch }
-}
-
-// Take an unsorted, potentially overlapping set of ranges, and
-// build a selection out of it. 'Consumes' ranges array (modifying
-// it).
-export function normalizeSelection(cm, ranges, primIndex) {
-  let mayTouch = cm && cm.options.selectionsMayTouch
-  let prim = ranges[primIndex]
-  ranges.sort((a, b) => cmp(a.from(), b.from()))
-  primIndex = indexOf(ranges, prim)
-  for (let i = 1; i < ranges.length; i++) {
-    let cur = ranges[i], prev = ranges[i - 1]
-    let diff = cmp(prev.to(), cur.from())
-    if (mayTouch && !cur.empty() ? diff > 0 : diff >= 0) {
-      let from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())
-      let inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head
-      if (i <= primIndex) --primIndex
-      ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))
-    }
-  }
-  return new Selection(ranges, primIndex)
-}
-
-export function simpleSelection(anchor, head) {
-  return new Selection([new Range(anchor, head || anchor)], 0)
-}