tui_editor-rails 1.0.2.0

data/vendor/assets/components/codemirror/src/model/document_data.js

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

data/vendor/assets/components/codemirror/src/model/history.js

@@ -0,0 +1,228 @@
+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(startGen) {
+  // 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 = 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 = startGen || 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) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
+        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
+}

data/vendor/assets/components/codemirror/src/model/line_widget.js

@@ -0,0 +1,78 @@
+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
+    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 - 1, 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
+  })
+  signalLater(cm, "lineWidgetAdded", cm, widget, typeof handle == "number" ? handle : lineNo(handle))
+  return widget
+}

data/vendor/assets/components/codemirror/src/model/mark_text.js

@@ -0,0 +1,292 @@
+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))
+    ++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.title || marker.startStyle || marker.endStyle || marker.css)
+      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)
+      }
+    }
+  }
+}