qword 0.1.0 → 1.0.0

package/modules/codemirror/src/model/changes.js

@@ -1,339 +0,0 @@
-import { retreatFrontier } from "../line/highlight.js"
-import { startWorker } from "../display/highlight_worker.js"
-import { operation } from "../display/operations.js"
-import { regChange, regLineChange } from "../display/view_tracking.js"
-import { clipLine, clipPos, cmp, Pos } from "../line/pos.js"
-import { sawReadOnlySpans } from "../line/saw_special_spans.js"
-import { lineLength, removeReadOnlyRanges, stretchSpansOverChange, visualLine } from "../line/spans.js"
-import { getBetween, getLine, lineNo } from "../line/utils_line.js"
-import { estimateHeight } from "../measurement/position_measurement.js"
-import { hasHandler, signal, signalCursorActivity } from "../util/event.js"
-import { indexOf, lst, map, sel_dontScroll } from "../util/misc.js"
-import { signalLater } from "../util/operation_group.js"
-
-import { changeEnd, computeSelAfterChange } from "./change_measurement.js"
-import { isWholeLineUpdate, linkedDocs, updateDoc } from "./document_data.js"
-import { addChangeToHistory, historyChangeFromChange, mergeOldSpans, pushSelectionToHistory } from "./history.js"
-import { Range, Selection } from "./selection.js"
-import { setSelection, setSelectionNoUndo, skipAtomic } from "./selection_updates.js"
-
-// UPDATING
-
-// Allow "beforeChange" event handlers to influence a change
-function filterChange(doc, change, update) {
-  let obj = {
-    canceled: false,
-    from: change.from,
-    to: change.to,
-    text: change.text,
-    origin: change.origin,
-    cancel: () => obj.canceled = true
-  }
-  if (update) obj.update = (from, to, text, origin) => {
-    if (from) obj.from = clipPos(doc, from)
-    if (to) obj.to = clipPos(doc, to)
-    if (text) obj.text = text
-    if (origin !== undefined) obj.origin = origin
-  }
-  signal(doc, "beforeChange", doc, obj)
-  if (doc.cm) signal(doc.cm, "beforeChange", doc.cm, obj)
-
-  if (obj.canceled) {
-    if (doc.cm) doc.cm.curOp.updateInput = 2
-    return null
-  }
-  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
-}
-
-// Apply a change to a document, and add it to the document's
-// history, and propagating it to all linked documents.
-export function makeChange(doc, change, ignoreReadOnly) {
-  if (doc.cm) {
-    if (!doc.cm.curOp) return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly)
-    if (doc.cm.state.suppressEdits) return
-  }
-
-  if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
-    change = filterChange(doc, change, true)
-    if (!change) return
-  }
-
-  // Possibly split or suppress the update based on the presence
-  // of read-only spans in its range.
-  let split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)
-  if (split) {
-    for (let i = split.length - 1; i >= 0; --i)
-      makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text, origin: change.origin})
-  } else {
-    makeChangeInner(doc, change)
-  }
-}
-
-function makeChangeInner(doc, change) {
-  if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) return
-  let selAfter = computeSelAfterChange(doc, change)
-  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)
-
-  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))
-  let rebased = []
-
-  linkedDocs(doc, (doc, sharedHist) => {
-    if (!sharedHist && indexOf(rebased, doc.history) == -1) {
-      rebaseHist(doc.history, change)
-      rebased.push(doc.history)
-    }
-    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))
-  })
-}
-
-// Revert a change stored in a document's history.
-export function makeChangeFromHistory(doc, type, allowSelectionOnly) {
-  let suppress = doc.cm && doc.cm.state.suppressEdits
-  if (suppress && !allowSelectionOnly) return
-
-  let hist = doc.history, event, selAfter = doc.sel
-  let source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done
-
-  // Verify that there is a useable event (so that ctrl-z won't
-  // needlessly clear selection events)
-  let i = 0
-  for (; i < source.length; i++) {
-    event = source[i]
-    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
-      break
-  }
-  if (i == source.length) return
-  hist.lastOrigin = hist.lastSelOrigin = null
-
-  for (;;) {
-    event = source.pop()
-    if (event.ranges) {
-      pushSelectionToHistory(event, dest)
-      if (allowSelectionOnly && !event.equals(doc.sel)) {
-        setSelection(doc, event, {clearRedo: false})
-        return
-      }
-      selAfter = event
-    } else if (suppress) {
-      source.push(event)
-      return
-    } else break
-  }
-
-  // Build up a reverse change object to add to the opposite history
-  // stack (redo when undoing, and vice versa).
-  let antiChanges = []
-  pushSelectionToHistory(selAfter, dest)
-  dest.push({changes: antiChanges, generation: hist.generation})
-  hist.generation = event.generation || ++hist.maxGeneration
-
-  let filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")
-
-  for (let i = event.changes.length - 1; i >= 0; --i) {
-    let change = event.changes[i]
-    change.origin = type
-    if (filter && !filterChange(doc, change, false)) {
-      source.length = 0
-      return
-    }
-
-    antiChanges.push(historyChangeFromChange(doc, change))
-
-    let after = i ? computeSelAfterChange(doc, change) : lst(source)
-    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))
-    if (!i && doc.cm) doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)})
-    let rebased = []
-
-    // Propagate to the linked documents
-    linkedDocs(doc, (doc, sharedHist) => {
-      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
-        rebaseHist(doc.history, change)
-        rebased.push(doc.history)
-      }
-      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))
-    })
-  }
-}
-
-// Sub-views need their line numbers shifted when text is added
-// above or below them in the parent document.
-function shiftDoc(doc, distance) {
-  if (distance == 0) return
-  doc.first += distance
-  doc.sel = new Selection(map(doc.sel.ranges, range => new Range(
-    Pos(range.anchor.line + distance, range.anchor.ch),
-    Pos(range.head.line + distance, range.head.ch)
-  )), doc.sel.primIndex)
-  if (doc.cm) {
-    regChange(doc.cm, doc.first, doc.first - distance, distance)
-    for (let d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
-      regLineChange(doc.cm, l, "gutter")
-  }
-}
-
-// More lower-level change function, handling only a single document
-// (not linked ones).
-function makeChangeSingleDoc(doc, change, selAfter, spans) {
-  if (doc.cm && !doc.cm.curOp)
-    return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans)
-
-  if (change.to.line < doc.first) {
-    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))
-    return
-  }
-  if (change.from.line > doc.lastLine()) return
-
-  // Clip the change to the size of this doc
-  if (change.from.line < doc.first) {
-    let shift = change.text.length - 1 - (doc.first - change.from.line)
-    shiftDoc(doc, shift)
-    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
-              text: [lst(change.text)], origin: change.origin}
-  }
-  let last = doc.lastLine()
-  if (change.to.line > last) {
-    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
-              text: [change.text[0]], origin: change.origin}
-  }
-
-  change.removed = getBetween(doc, change.from, change.to)
-
-  if (!selAfter) selAfter = computeSelAfterChange(doc, change)
-  if (doc.cm) makeChangeSingleDocInEditor(doc.cm, change, spans)
-  else updateDoc(doc, change, spans)
-  setSelectionNoUndo(doc, selAfter, sel_dontScroll)
-
-  if (doc.cantEdit && skipAtomic(doc, Pos(doc.firstLine(), 0)))
-    doc.cantEdit = false
-}
-
-// Handle the interaction of a change to a document with the editor
-// that this document is part of.
-function makeChangeSingleDocInEditor(cm, change, spans) {
-  let doc = cm.doc, display = cm.display, from = change.from, to = change.to
-
-  let recomputeMaxLength = false, checkWidthStart = from.line
-  if (!cm.options.lineWrapping) {
-    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
-    doc.iter(checkWidthStart, to.line + 1, line => {
-      if (line == display.maxLine) {
-        recomputeMaxLength = true
-        return true
-      }
-    })
-  }
-
-  if (doc.sel.contains(change.from, change.to) > -1)
-    signalCursorActivity(cm)
-
-  updateDoc(doc, change, spans, estimateHeight(cm))
-
-  if (!cm.options.lineWrapping) {
-    doc.iter(checkWidthStart, from.line + change.text.length, line => {
-      let len = lineLength(line)
-      if (len > display.maxLineLength) {
-        display.maxLine = line
-        display.maxLineLength = len
-        display.maxLineChanged = true
-        recomputeMaxLength = false
-      }
-    })
-    if (recomputeMaxLength) cm.curOp.updateMaxLine = true
-  }
-
-  retreatFrontier(doc, from.line)
-  startWorker(cm, 400)
-
-  let lendiff = change.text.length - (to.line - from.line) - 1
-  // Remember that these lines changed, for updating the display
-  if (change.full)
-    regChange(cm)
-  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
-    regLineChange(cm, from.line, "text")
-  else
-    regChange(cm, from.line, to.line + 1, lendiff)
-
-  let changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
-  if (changeHandler || changesHandler) {
-    let obj = {
-      from: from, to: to,
-      text: change.text,
-      removed: change.removed,
-      origin: change.origin
-    }
-    if (changeHandler) signalLater(cm, "change", cm, obj)
-    if (changesHandler) (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj)
-  }
-  cm.display.selForContextMenu = null
-}
-
-export function replaceRange(doc, code, from, to, origin) {
-  if (!to) to = from
-  if (cmp(to, from) < 0) [from, to] = [to, from]
-  if (typeof code == "string") code = doc.splitLines(code)
-  makeChange(doc, {from, to, text: code, origin})
-}
-
-// Rebasing/resetting history to deal with externally-sourced changes
-
-function rebaseHistSelSingle(pos, from, to, diff) {
-  if (to < pos.line) {
-    pos.line += diff
-  } else if (from < pos.line) {
-    pos.line = from
-    pos.ch = 0
-  }
-}
-
-// Tries to rebase an array of history events given a change in the
-// document. If the change touches the same lines as the event, the
-// event, and everything 'behind' it, is discarded. If the change is
-// before the event, the event's positions are updated. Uses a
-// copy-on-write scheme for the positions, to avoid having to
-// reallocate them all on every rebase, but also avoid problems with
-// shared position objects being unsafely updated.
-function rebaseHistArray(array, from, to, diff) {
-  for (let i = 0; i < array.length; ++i) {
-    let sub = array[i], ok = true
-    if (sub.ranges) {
-      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }
-      for (let j = 0; j < sub.ranges.length; j++) {
-        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)
-        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)
-      }
-      continue
-    }
-    for (let j = 0; j < sub.changes.length; ++j) {
-      let cur = sub.changes[j]
-      if (to < cur.from.line) {
-        cur.from = Pos(cur.from.line + diff, cur.from.ch)
-        cur.to = Pos(cur.to.line + diff, cur.to.ch)
-      } else if (from <= cur.to.line) {
-        ok = false
-        break
-      }
-    }
-    if (!ok) {
-      array.splice(0, i + 1)
-      i = 0
-    }
-  }
-}
-
-function rebaseHist(hist, change) {
-  let from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1
-  rebaseHistArray(hist.done, from, to, diff)
-  rebaseHistArray(hist.undone, from, to, diff)
-}
-
-// Utility for applying a change to a line by handle or number,
-// returning the number and optionally registering the line as
-// changed.
-export function changeLine(doc, handle, changeType, op) {
-  let no = handle, line = handle
-  if (typeof handle == "number") line = getLine(doc, clipLine(doc, handle))
-  else no = lineNo(handle)
-  if (no == null) return null
-  if (op(line, no) && doc.cm) regLineChange(doc.cm, no, changeType)
-  return line
-}

package/modules/codemirror/src/model/chunk.js

@@ -1,167 +0,0 @@
-import { cleanUpLine } from "../line/line_data.js"
-import { indexOf } from "../util/misc.js"
-import { signalLater } from "../util/operation_group.js"
-
-// The document is represented as a BTree consisting of leaves, with
-// chunk of lines in them, and branches, with up to ten leaves or
-// other branch nodes below them. The top node is always a branch
-// node, and is the document object itself (meaning it has
-// additional methods and properties).
-//
-// All nodes have parent links. The tree is used both to go from
-// line numbers to line objects, and to go from objects to numbers.
-// It also indexes by height, and is used to convert between height
-// and line object, and to find the total height of the document.
-//
-// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
-
-export function LeafChunk(lines) {
-  this.lines = lines
-  this.parent = null
-  let height = 0
-  for (let i = 0; i < lines.length; ++i) {
-    lines[i].parent = this
-    height += lines[i].height
-  }
-  this.height = height
-}
-
-LeafChunk.prototype = {
-  chunkSize() { return this.lines.length },
-
-  // Remove the n lines at offset 'at'.
-  removeInner(at, n) {
-    for (let i = at, e = at + n; i < e; ++i) {
-      let line = this.lines[i]
-      this.height -= line.height
-      cleanUpLine(line)
-      signalLater(line, "delete")
-    }
-    this.lines.splice(at, n)
-  },
-
-  // Helper used to collapse a small branch into a single leaf.
-  collapse(lines) {
-    lines.push.apply(lines, this.lines)
-  },
-
-  // Insert the given array of lines at offset 'at', count them as
-  // having the given height.
-  insertInner(at, lines, height) {
-    this.height += height
-    this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))
-    for (let i = 0; i < lines.length; ++i) lines[i].parent = this
-  },
-
-  // Used to iterate over a part of the tree.
-  iterN(at, n, op) {
-    for (let e = at + n; at < e; ++at)
-      if (op(this.lines[at])) return true
-  }
-}
-
-export function BranchChunk(children) {
-  this.children = children
-  let size = 0, height = 0
-  for (let i = 0; i < children.length; ++i) {
-    let ch = children[i]
-    size += ch.chunkSize(); height += ch.height
-    ch.parent = this
-  }
-  this.size = size
-  this.height = height
-  this.parent = null
-}
-
-BranchChunk.prototype = {
-  chunkSize() { return this.size },
-
-  removeInner(at, n) {
-    this.size -= n
-    for (let i = 0; i < this.children.length; ++i) {
-      let child = this.children[i], sz = child.chunkSize()
-      if (at < sz) {
-        let rm = Math.min(n, sz - at), oldHeight = child.height
-        child.removeInner(at, rm)
-        this.height -= oldHeight - child.height
-        if (sz == rm) { this.children.splice(i--, 1); child.parent = null }
-        if ((n -= rm) == 0) break
-        at = 0
-      } else at -= sz
-    }
-    // If the result is smaller than 25 lines, ensure that it is a
-    // single leaf node.
-    if (this.size - n < 25 &&
-        (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
-      let lines = []
-      this.collapse(lines)
-      this.children = [new LeafChunk(lines)]
-      this.children[0].parent = this
-    }
-  },
-
-  collapse(lines) {
-    for (let i = 0; i < this.children.length; ++i) this.children[i].collapse(lines)
-  },
-
-  insertInner(at, lines, height) {
-    this.size += lines.length
-    this.height += height
-    for (let i = 0; i < this.children.length; ++i) {
-      let child = this.children[i], sz = child.chunkSize()
-      if (at <= sz) {
-        child.insertInner(at, lines, height)
-        if (child.lines && child.lines.length > 50) {
-          // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
-          // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
-          let remaining = child.lines.length % 25 + 25
-          for (let pos = remaining; pos < child.lines.length;) {
-            let leaf = new LeafChunk(child.lines.slice(pos, pos += 25))
-            child.height -= leaf.height
-            this.children.splice(++i, 0, leaf)
-            leaf.parent = this
-          }
-          child.lines = child.lines.slice(0, remaining)
-          this.maybeSpill()
-        }
-        break
-      }
-      at -= sz
-    }
-  },
-
-  // When a node has grown, check whether it should be split.
-  maybeSpill() {
-    if (this.children.length <= 10) return
-    let me = this
-    do {
-      let spilled = me.children.splice(me.children.length - 5, 5)
-      let sibling = new BranchChunk(spilled)
-      if (!me.parent) { // Become the parent node
-        let copy = new BranchChunk(me.children)
-        copy.parent = me
-        me.children = [copy, sibling]
-        me = copy
-     } else {
-        me.size -= sibling.size
-        me.height -= sibling.height
-        let myIndex = indexOf(me.parent.children, me)
-        me.parent.children.splice(myIndex + 1, 0, sibling)
-      }
-      sibling.parent = me.parent
-    } while (me.children.length > 10)
-    me.parent.maybeSpill()
-  },
-
-  iterN(at, n, op) {
-    for (let i = 0; i < this.children.length; ++i) {
-      let child = this.children[i], sz = child.chunkSize()
-      if (at < sz) {
-        let used = Math.min(n, sz - at)
-        if (child.iterN(at, used, op)) return true
-        if ((n -= used) == 0) break
-        at = 0
-      } else at -= sz
-    }
-  }
-}

package/modules/codemirror/src/model/document_data.js

@@ -1,112 +0,0 @@
-import { loadMode } from "../display/mode_state.js"
-import { runInOp } from "../display/operations.js"
-import { regChange } from "../display/view_tracking.js"
-import { Line, updateLine } from "../line/line_data.js"
-import { findMaxLine } from "../line/spans.js"
-import { getLine } from "../line/utils_line.js"
-import { estimateLineHeights } from "../measurement/position_measurement.js"
-import { addClass, rmClass } from "../util/dom.js"
-import { lst } from "../util/misc.js"
-import { signalLater } from "../util/operation_group.js"
-
-// DOCUMENT DATA STRUCTURE
-
-// By default, updates that start and end at the beginning of a line
-// are treated specially, in order to make the association of line
-// widgets and marker elements with the text behave more intuitive.
-export function isWholeLineUpdate(doc, change) {
-  return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
-    (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
-}
-
-// Perform a change on the document data structure.
-export function updateDoc(doc, change, markedSpans, estimateHeight) {
-  function spansFor(n) {return markedSpans ? markedSpans[n] : null}
-  function update(line, text, spans) {
-    updateLine(line, text, spans, estimateHeight)
-    signalLater(line, "change", line, change)
-  }
-  function linesFor(start, end) {
-    let result = []
-    for (let i = start; i < end; ++i)
-      result.push(new Line(text[i], spansFor(i), estimateHeight))
-    return result
-  }
-
-  let from = change.from, to = change.to, text = change.text
-  let firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)
-  let lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line
-
-  // Adjust the line structure
-  if (change.full) {
-    doc.insert(0, linesFor(0, text.length))
-    doc.remove(text.length, doc.size - text.length)
-  } else if (isWholeLineUpdate(doc, change)) {
-    // This is a whole-line replace. Treated specially to make
-    // sure line objects move the way they are supposed to.
-    let added = linesFor(0, text.length - 1)
-    update(lastLine, lastLine.text, lastSpans)
-    if (nlines) doc.remove(from.line, nlines)
-    if (added.length) doc.insert(from.line, added)
-  } else if (firstLine == lastLine) {
-    if (text.length == 1) {
-      update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)
-    } else {
-      let added = linesFor(1, text.length - 1)
-      added.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))
-      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
-      doc.insert(from.line + 1, added)
-    }
-  } else if (text.length == 1) {
-    update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))
-    doc.remove(from.line + 1, nlines)
-  } else {
-    update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
-    update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)
-    let added = linesFor(1, text.length - 1)
-    if (nlines > 1) doc.remove(from.line + 1, nlines - 1)
-    doc.insert(from.line + 1, added)
-  }
-
-  signalLater(doc, "change", doc, change)
-}
-
-// Call f for all linked documents.
-export function linkedDocs(doc, f, sharedHistOnly) {
-  function propagate(doc, skip, sharedHist) {
-    if (doc.linked) for (let i = 0; i < doc.linked.length; ++i) {
-      let rel = doc.linked[i]
-      if (rel.doc == skip) continue
-      let shared = sharedHist && rel.sharedHist
-      if (sharedHistOnly && !shared) continue
-      f(rel.doc, shared)
-      propagate(rel.doc, doc, shared)
-    }
-  }
-  propagate(doc, null, true)
-}
-
-// Attach a document to an editor.
-export function attachDoc(cm, doc) {
-  if (doc.cm) throw new Error("This document is already in use.")
-  cm.doc = doc
-  doc.cm = cm
-  estimateLineHeights(cm)
-  loadMode(cm)
-  setDirectionClass(cm)
-  cm.options.direction = doc.direction
-  if (!cm.options.lineWrapping) findMaxLine(cm)
-  cm.options.mode = doc.modeOption
-  regChange(cm)
-}
-
-function setDirectionClass(cm) {
-  ;(cm.doc.direction == "rtl" ? addClass : rmClass)(cm.display.lineDiv, "CodeMirror-rtl")
-}
-
-export function directionChanged(cm) {
-  runInOp(cm, () => {
-    setDirectionClass(cm)
-    regChange(cm)
-  })
-}