blitze / phpBB-ext-sitemaker

// Distributed under an MIT license: http://codemirror.net/LICENSE

// This is CodeMirror (http://codemirror.net), a code editor

// implemented in JavaScript on top of the browser's DOM.

//

// You can find some technical background for some of the code below

// at http://marijnhaverbeke.nl/blog/#cm-internals .

(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

  (global.CodeMirror = factory());

}(this, (function () { 'use strict';

// Kludges for bugs and behavior differences that can't be feature

// detected are enabled based on userAgent etc sniffing.

var platform = navigator.platform

var gecko = /gecko\/\d/i.test(userAgent)

var ie_upto10 = /MSIE \d/.test(userAgent)

var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent)

var ie = ie_upto10 || ie_11up

var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1])

var webkit = /WebKit\//.test(userAgent)

var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent)

var chrome = /Chrome\//.test(userAgent)

var presto = /Opera\//.test(userAgent)

var safari = /Apple Computer/.test(navigator.vendor)

var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent)

var phantom = /PhantomJS/.test(userAgent)

var ios = /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent)

// This is woefully incomplete. Suggestions for alternative methods welcome.

var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)

var mac = ios || /Mac/.test(platform)

var chromeOS = /\bCrOS\b/.test(userAgent)

var windows = /win/i.test(platform)

var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/)

if (presto_version) { presto_version = Number(presto_version[1]) }

if (presto_version && presto_version >= 15) { presto = false; webkit = true }

// Some browsers use the wrong event properties to signal cmd/ctrl on OS X

var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))

var captureRightClick = gecko || (ie && ie_version >= 9)

function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }

var rmClass = function(node, cls) {

  var current = node.className

  var match = classTest(cls).exec(current)

  if (match) {

    var after = current.slice(match.index + match[0].length)

    node.className = current.slice(0, match.index) + (after ? match[1] + after : "")

  }

}

function removeChildren(e) {

  for (var count = e.childNodes.length; count > 0; --count)

    { e.removeChild(e.firstChild) }

  return e

}

function removeChildrenAndAdd(parent, e) {

  return removeChildren(parent).appendChild(e)

}

function elt(tag, content, className, style) {

  var e = document.createElement(tag)

  if (className) { e.className = className }

  if (style) { e.style.cssText = style }

  if (typeof content == "string") { e.appendChild(document.createTextNode(content)) }

  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }

  return e

}

var range

if (document.createRange) { range = function(node, start, end, endNode) {

  var r = document.createRange()

  r.setEnd(endNode || node, end)

  r.setStart(node, start)

  return r

} }

else { range = function(node, start, end) {

  var r = document.body.createTextRange()

  try { r.moveToElementText(node.parentNode) }

  catch(e) { return r }

  r.collapse(true)

  r.moveEnd("character", end)

  r.moveStart("character", start)

  return r

} }

function contains(parent, child) {

  if (child.nodeType == 3) // Android browser always returns false when child is a textnode

    { child = child.parentNode }

  if (parent.contains)

    { return parent.contains(child) }

  do {

    if (child.nodeType == 11) { child = child.host }

    if (child == parent) { return true }

}

function activeElt() {

  // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.

  // IE < 10 will throw when accessed while the page is loading or in an iframe.

  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.

  var activeElement

  try {

    activeElement = document.activeElement

  } catch(e) {

    activeElement = document.body || null

  }

  while (activeElement && activeElement.root && activeElement.root.activeElement)

    { activeElement = activeElement.root.activeElement }

  return activeElement

}

function addClass(node, cls) {

  var current = node.className

  if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls }

}

function joinClasses(a, b) {

  var as = a.split(" ")

  for (var i = 0; i < as.length; i++)

    { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i] } }

  return b

}

var selectInput = function(node) { node.select() }

if (ios) // Mobile Safari apparently has a bug where select() is broken.

  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }

else if (ie) // Suppress mysterious IE10 errors

  { selectInput = function(node) { try { node.select() } catch(_e) {} } }

function bind(f) {

  var args = Array.prototype.slice.call(arguments, 1)

  return function(){return f.apply(null, args)}

}

function copyObj(obj, target, overwrite) {

  if (!target) { target = {} }

  for (var prop in obj)

    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))

      { target[prop] = obj[prop] } }

  return target

}

// Counts the column offset in a string, taking tabs into account.

// Used mostly to find indentation.

function countColumn(string, end, tabSize, startIndex, startValue) {

  if (end == null) {

    end = string.search(/[^\s\u00a0]/)

    if (end == -1) { end = string.length }

  }

  for (var i = startIndex || 0, n = startValue || 0;;) {

    var nextTab = string.indexOf("\t", i)

    if (nextTab < 0 || nextTab >= end)

      { return n + (end - i) }

    n += nextTab - i

    n += tabSize - (n % tabSize)

    i = nextTab + 1

  }

}

function Delayed() {this.id = null}

Delayed.prototype.set = function(ms, f) {

  clearTimeout(this.id)

  this.id = setTimeout(f, ms)

}

function indexOf(array, elt) {

  for (var i = 0; i < array.length; ++i)

    { if (array[i] == elt) { return i } }

  return -1

}

// Number of pixels added to scroller and sizer to hide scrollbar

var scrollerGap = 30

// Returned or thrown by various protocols to signal 'I'm not

// handling this'.

var Pass = {toString: function(){return "CodeMirror.Pass"}}

// Reused option objects for setSelection & friends

var sel_dontScroll = {scroll: false};

var sel_mouse = {origin: "*mouse"};

var sel_move = {origin: "+move"};

// The inverse of countColumn -- find the offset that corresponds to

// a particular column.

function findColumn(string, goal, tabSize) {

  for (var pos = 0, col = 0;;) {

    var nextTab = string.indexOf("\t", pos)

    if (nextTab == -1) { nextTab = string.length }

    var skipped = nextTab - pos

    if (nextTab == string.length || col + skipped >= goal)

      { return pos + Math.min(skipped, goal - col) }

    col += nextTab - pos

    col += tabSize - (col % tabSize)

    pos = nextTab + 1

    if (col >= goal) { return pos }

  }

}

var spaceStrs = [""]

function spaceStr(n) {

  while (spaceStrs.length <= n)

    { spaceStrs.push(lst(spaceStrs) + " ") }

  return spaceStrs[n]

}

function lst(arr) { return arr[arr.length-1] }

function map(array, f) {

  var out = []

  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }

  return out

}

function insertSorted(array, value, score) {

  var pos = 0, priority = score(value)

  while (pos < array.length && score(array[pos]) <= priority) { pos++ }

  array.splice(pos, 0, value)

}

function nothing() {}

function createObj(base, props) {

  var inst

  if (Object.create) {

    inst = Object.create(base)

  } else {

    nothing.prototype = base

  }

  if (props) { copyObj(props, inst) }

  return inst

}

var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/

function isWordCharBasic(ch) {

  return /\w/.test(ch) || ch > "\x80" &&

    (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))

}

function isWordChar(ch, helper) {

  if (!helper) { return isWordCharBasic(ch) }

  if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }

  return helper.test(ch)

}

function isEmpty(obj) {

  for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }

  return true

}

// Extending unicode characters. A series of a non-extending char +

// any number of extending chars is treated as a single unit as far

// as editing and measuring is concerned. This is not fully correct,

// since some scripts/fonts/browsers also treat other configurations

// of code points as a group.

var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/

function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }

// The display handles the DOM integration, both for input reading

// and content drawing. It holds references to DOM nodes and

// display-related state.

function Display(place, doc, input) {

  var d = this

  this.input = input

  // Covers bottom-right square when both scrollbars are present.

  d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler")

  d.scrollbarFiller.setAttribute("cm-not-content", "true")

  // Covers bottom of gutter when coverGutterNextToScrollbar is on

  // and h scrollbar is present.

  d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler")

  d.gutterFiller.setAttribute("cm-not-content", "true")

  // Will contain the actual code, positioned to cover the viewport.

  d.lineDiv = elt("div", null, "CodeMirror-code")

  // Elements are added to these to represent selection and cursors.

  d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1")

  d.cursorDiv = elt("div", null, "CodeMirror-cursors")

  // A visibility: hidden element used to find the size of things.

  d.measure = elt("div", null, "CodeMirror-measure")

  // When lines outside of the viewport are measured, they are drawn in this.

  d.lineMeasure = elt("div", null, "CodeMirror-measure")

  // Wraps everything that needs to exist inside the vertically-padded coordinate system

  d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],

                    null, "position: relative; outline: none")

  // Moved around its parent to cover visible view.

  d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative")

  // Set to the height of the document, allowing scrolling.

  d.sizer = elt("div", [d.mover], "CodeMirror-sizer")

  d.sizerWidth = null

  // Behavior of elts with overflow: auto and padding is

  // inconsistent across browsers. This is used to ensure the

  // scrollable area is big enough.

  d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;")

  // Will contain the gutters, if any.

  d.gutters = elt("div", null, "CodeMirror-gutters")

  d.lineGutter = null

  // Actual scrollable element.

  d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll")

  d.scroller.setAttribute("tabIndex", "-1")

  // The element in which the editor lives.

  d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror")

  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)

  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }

  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }

  if (place) {

    if (place.appendChild) { place.appendChild(d.wrapper) }

    else { place(d.wrapper) }

  }

  // Current rendered range (may be bigger than the view window).

  d.viewFrom = d.viewTo = doc.first

  d.reportedViewFrom = d.reportedViewTo = doc.first

  // Information about the rendered lines.

  d.view = []

  d.renderedView = null

  // Holds info about a single rendered line when it was rendered

  // for measurement, while not in view.

  d.externalMeasured = null

  // Empty space (in pixels) above the view

  d.viewOffset = 0

  d.lastWrapHeight = d.lastWrapWidth = 0

  d.updateLineNumbers = null

  d.nativeBarWidth = d.barHeight = d.barWidth = 0

  d.scrollbarsClipped = false

  // Used to only resize the line number gutter when necessary (when

  // the amount of lines crosses a boundary that makes its width change)

  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null

  // Set to true when a non-horizontal-scrolling line widget is

  // added. As an optimization, line widget aligning is skipped when

  // this is false.

  d.alignWidgets = false

  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null

  // Tracks the maximum line length so that the horizontal scrollbar

  // can be kept static when scrolling.

  d.maxLine = null

  d.maxLineLength = 0

  d.maxLineChanged = false

  // Used for measuring wheel scrolling granularity

  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null

  // True when shift is held down.

  d.shift = false

  // Used to track whether anything happened since the context menu

  // was opened.

  d.selForContextMenu = null

  d.activeTouch = null

  input.init(d)

}

// Find the line object corresponding to the given line number.

function getLine(doc, n) {

  n -= doc.first

  if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }

  var chunk = doc

  while (!chunk.lines) {

    for (var i = 0;; ++i) {

      var child = chunk.children[i], sz = child.chunkSize()

      if (n < sz) { chunk = child; break }

      n -= sz

    }

  }

  return chunk.lines[n]

}

// Get the part of a document between two positions, as an array of

// strings.

function getBetween(doc, start, end) {

  var out = [], n = start.line

  doc.iter(start.line, end.line + 1, function (line) {

    var text = line.text

    if (n == end.line) { text = text.slice(0, end.ch) }

    if (n == start.line) { text = text.slice(start.ch) }

    out.push(text)

    ++n

  })

  return out

}

// Get the lines between from and to, as array of strings.

function getLines(doc, from, to) {

  var out = []

  doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value

  return out

}

// Update the height of a line, propagating the height change

// upwards to parent nodes.

function updateLineHeight(line, height) {

  var diff = height - line.height

  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }

}

// Given a line object, find its line number by walking up through

// its parent links.

function lineNo(line) {

  if (line.parent == null) { return null }

  var cur = line.parent, no = indexOf(cur.lines, line)

  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {

    for (var i = 0;; ++i) {

      if (chunk.children[i] == cur) { break }

      no += chunk.children[i].chunkSize()

    }

  }

  return no + cur.first

}

// Find the line at the given vertical position, using the height

// information in the document tree.

function lineAtHeight(chunk, h) {

  var n = chunk.first

  outer: do {

    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {

      var child = chunk.children[i$1], ch = child.height

      if (h < ch) { chunk = child; continue outer }

      h -= ch

      n += child.chunkSize()

    }

    return n

  } while (!chunk.lines)

  var i = 0

  for (; i < chunk.lines.length; ++i) {

    var line = chunk.lines[i], lh = line.height

    if (h < lh) { break }

    h -= lh

  }

  return n + i

}

function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}

function lineNumberFor(options, i) {

  return String(options.lineNumberFormatter(i + options.firstLineNumber))

}

// A Pos instance represents a position within the text.

function Pos (line, ch) {

  if (!(this instanceof Pos)) { return new Pos(line, ch) }

}

// Compare two positions, return 0 if they are the same, a negative

// number when a is less, and a positive number otherwise.

function cmp(a, b) { return a.line - b.line || a.ch - b.ch }

function copyPos(x) {return Pos(x.line, x.ch)}

function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }

function minPos(a, b) { return cmp(a, b) < 0 ? a : b }

// Most of the external API clips given positions to make sure they

// actually exist within the document.

function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}

function clipPos(doc, pos) {

  if (pos.line < doc.first) { return Pos(doc.first, 0) }

  var last = doc.first + doc.size - 1

  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }

  return clipToLen(pos, getLine(doc, pos.line).text.length)

}

function clipToLen(pos, linelen) {

  var ch = pos.ch

  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }

  else if (ch < 0) { return Pos(pos.line, 0) }

  else { return pos }

}

function clipPosArray(doc, array) {

  var out = []

  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }

  return out

}

// Optimize some code when these features are not used.

var sawReadOnlySpans = false;

var sawCollapsedSpans = false;

function seeReadOnlySpans() {

  sawReadOnlySpans = true

}

function seeCollapsedSpans() {

  sawCollapsedSpans = true

}

// TEXTMARKER SPANS

function MarkedSpan(marker, from, to) {

  this.marker = marker

  this.from = from; this.to = to

}

// Search an array of spans for a span matching the given marker.

function getMarkedSpanFor(spans, marker) {

    var span = spans[i]

    if (span.marker == marker) { return span }

}

// Remove a span from an array, returning undefined if no spans are

// left (we don't store arrays for lines without spans).

function removeMarkedSpan(spans, span) {

  var r

  for (var i = 0; i < spans.length; ++i)

    { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }

}

// Add a span to a line.

function addMarkedSpan(line, span) {

  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]

  span.marker.attachLine(line)

}

// Used for the algorithm that adjusts markers for a change in the

// document. These functions cut an array of spans at a given

// character position, returning an array of remaining chunks (or

// undefined if nothing remains).

  var nw

  if (old) { for (var i = 0; i < old.length; ++i) {

    var span = old[i], marker = span.marker

    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)

    if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {

      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)

      ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))

    }

  } }

}

  var nw

  if (old) { for (var i = 0; i < old.length; ++i) {

    var span = old[i], marker = span.marker

    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)

    if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {

      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)

      ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,

                                            span.to == null ? null : span.to - endCh))

    }

  } }

}

// Given a change object, compute the new set of marker spans that

// cover the line in which the change took place. Removes spans

// entirely within the change, reconnects spans belonging to the

// same marker that appear on both sides of the change, and cuts off

// spans partially within the change. Returns an array of span

// arrays with one element for each line in (after) the change.

function stretchSpansOverChange(doc, change) {

  if (change.full) { return null }

  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans

  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans

  if (!oldFirst && !oldLast) { return null }

  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0

  // Get the spans that 'stick out' on both sides

  var first = markedSpansBefore(oldFirst, startCh, isInsert)

  var last = markedSpansAfter(oldLast, endCh, isInsert)

  // Next, merge those two ends

  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)

  if (first) {

    // Fix up .to properties of first

    for (var i = 0; i < first.length; ++i) {

      var span = first[i]

      if (span.to == null) {

        var found = getMarkedSpanFor(last, span.marker)

        if (!found) { span.to = startCh }

        else if (sameLine) { span.to = found.to == null ? null : found.to + offset }

      }

    }

  }

  if (last) {

    // Fix up .from in last (or move them into first in case of sameLine)

    for (var i$1 = 0; i$1 < last.length; ++i$1) {

      var span$1 = last[i$1]

      if (span$1.to != null) { span$1.to += offset }

      if (span$1.from == null) {

        var found$1 = getMarkedSpanFor(first, span$1.marker)

        if (!found$1) {

          span$1.from = offset

          if (sameLine) { (first || (first = [])).push(span$1) }

        }

      } else {

        span$1.from += offset

        if (sameLine) { (first || (first = [])).push(span$1) }

      }

    }

  }

  // Make sure we didn't create any zero-length spans

  if (first) { first = clearEmptySpans(first) }

  if (last && last != first) { last = clearEmptySpans(last) }

  var newMarkers = [first]

  if (!sameLine) {

    // Fill gap with whole-line-spans

    var gap = change.text.length - 2, gapMarkers

    if (gap > 0 && first)

      { for (var i$2 = 0; i$2 < first.length; ++i$2)

        { if (first[i$2].to == null)

          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }

    for (var i$3 = 0; i$3 < gap; ++i$3)

    newMarkers.push(last)

  }

  return newMarkers

}

// Remove spans that are empty and don't have a clearWhenEmpty

// option of false.

function clearEmptySpans(spans) {

  for (var i = 0; i < spans.length; ++i) {

    var span = spans[i]

    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)

      { spans.splice(i--, 1) }

  }

  if (!spans.length) { return null }

  return spans

}

// Used to 'clip' out readOnly ranges when making a change.

function removeReadOnlyRanges(doc, from, to) {

  var markers = null

  doc.iter(from.line, to.line + 1, function (line) {

    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {

      var mark = line.markedSpans[i].marker

        { (markers || (markers = [])).push(mark) }

    } }

  })

  if (!markers) { return null }

  var parts = [{from: from, to: to}]

  for (var i = 0; i < markers.length; ++i) {

    var mk = markers[i], m = mk.find(0)

    for (var j = 0; j < parts.length; ++j) {

      var p = parts[j]

      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }

      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)

      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)

        { newParts.push({from: p.from, to: m.from}) }

      if (dto > 0 || !mk.inclusiveRight && !dto)

        { newParts.push({from: m.to, to: p.to}) }

      parts.splice.apply(parts, newParts)

      j += newParts.length - 1

    }

  }

  return parts

}

// Connect or disconnect spans from a line.

function detachMarkedSpans(line) {

  var spans = line.markedSpans

  if (!spans) { return }

  for (var i = 0; i < spans.length; ++i)

    { spans[i].marker.detachLine(line) }

  line.markedSpans = null

}

function attachMarkedSpans(line, spans) {

  if (!spans) { return }

  for (var i = 0; i < spans.length; ++i)

    { spans[i].marker.attachLine(line) }

  line.markedSpans = spans

}

// Helpers used when computing which overlapping collapsed span

// counts as the larger one.

function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }

function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }

// Returns a number indicating which of two overlapping collapsed

// spans is larger (and thus includes the other). Falls back to

// comparing ids when the spans cover exactly the same range.

function compareCollapsedMarkers(a, b) {

  var lenDiff = a.lines.length - b.lines.length

  if (lenDiff != 0) { return lenDiff }

  var aPos = a.find(), bPos = b.find()

  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)

  if (fromCmp) { return -fromCmp }

  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)

  if (toCmp) { return toCmp }

  return b.id - a.id

}

// Find out whether a line ends or starts in a collapsed span. If

// so, return the marker for that span.

function collapsedSpanAtSide(line, start) {

  var sps = sawCollapsedSpans && line.markedSpans, found

    sp = sps[i]

    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&

        (!found || compareCollapsedMarkers(found, sp.marker) < 0))

      { found = sp.marker }

  } }

}

function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }

function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }

// Test whether there exists a collapsed span that partially

// overlaps (covers the start or end, but not both) of a new span.

// Such overlap is not allowed.

function conflictingCollapsedRange(doc, lineNo, from, to, marker) {

  var line = getLine(doc, lineNo)

  var sps = sawCollapsedSpans && line.markedSpans

    var sp = sps[i]

    if (!sp.marker.collapsed) { continue }

    var found = sp.marker.find(0)

    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)

    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)

    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }

    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||

        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))

      { return true }

}

// A visual line is a line as drawn on the screen. Folding, for

// example, can cause multiple logical lines to appear on the same

// visual line. This finds the start of the visual line that the

// given line is part of (usually that is the line itself).

function visualLine(line) {

  var merged

  while (merged = collapsedSpanAtStart(line))

    { line = merged.find(-1, true).line }

  return line

}

// Returns an array of logical lines that continue the visual line

// started by the argument, or undefined if there are no such lines.

function visualLineContinued(line) {

  var merged, lines

  while (merged = collapsedSpanAtEnd(line)) {

    line = merged.find(1, true).line

    ;(lines || (lines = [])).push(line)

  }

}

// Get the line number of the start of the visual line that the

// given line number is part of.

function visualLineNo(doc, lineN) {

  var line = getLine(doc, lineN), vis = visualLine(line)

  if (line == vis) { return lineN }

  return lineNo(vis)

}

// Get the line number of the start of the next visual line after

// the given line.

function visualLineEndNo(doc, lineN) {

  if (lineN > doc.lastLine()) { return lineN }

  var line = getLine(doc, lineN), merged

  if (!lineIsHidden(doc, line)) { return lineN }

  while (merged = collapsedSpanAtEnd(line))

    { line = merged.find(1, true).line }

  return lineNo(line) + 1

}

// Compute whether a line is hidden. Lines count as hidden when they

// are part of a visual line that starts with another line, or when

// they are entirely covered by collapsed, non-widget span.

function lineIsHidden(doc, line) {

  var sps = sawCollapsedSpans && line.markedSpans

    sp = sps[i]

    if (!sp.marker.collapsed) { continue }

    if (sp.from == null) { return true }

    if (sp.marker.widgetNode) { continue }

    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))

      { return true }

}

function lineIsHiddenInner(doc, line, span) {

  if (span.to == null) {

    var end = span.marker.find(1, true)

    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))

  }

  if (span.marker.inclusiveRight && span.to == line.text.length)

    { return true }

    sp = line.markedSpans[i]

    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&

        (sp.to == null || sp.to != span.from) &&

        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&

        lineIsHiddenInner(doc, line, sp)) { return true }

}

// Find the height above the given line.

function heightAtLine(lineObj) {

  lineObj = visualLine(lineObj)

  var h = 0, chunk = lineObj.parent

  for (var i = 0; i < chunk.lines.length; ++i) {

    var line = chunk.lines[i]

    if (line == lineObj) { break }

    else { h += line.height }

  }

  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {

    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {

      var cur = p.children[i$1]

      if (cur == chunk) { break }

      else { h += cur.height }

    }

  }

  return h

}

// Compute the character length of a line, taking into account

// collapsed ranges (see markText) that might hide parts, and join

// other lines onto it.

function lineLength(line) {

  if (line.height == 0) { return 0 }

  var len = line.text.length, merged, cur = line

  while (merged = collapsedSpanAtStart(cur)) {

    var found = merged.find(0, true)

    cur = found.from.line

    len += found.from.ch - found.to.ch

  }

  cur = line

  while (merged = collapsedSpanAtEnd(cur)) {

    var found$1 = merged.find(0, true)

    len -= cur.text.length - found$1.from.ch

    cur = found$1.to.line

    len += cur.text.length - found$1.to.ch

  }

  return len

}

// Find the longest line in the document.

function findMaxLine(cm) {

  var d = cm.display, doc = cm.doc

  d.maxLine = getLine(doc, doc.first)

  d.maxLineLength = lineLength(d.maxLine)

  d.maxLineChanged = true

  doc.iter(function (line) {

    var len = lineLength(line)

    if (len > d.maxLineLength) {

      d.maxLineLength = len

      d.maxLine = line

    }

  })

}

// BIDI HELPERS

function iterateBidiSections(order, from, to, f) {

  if (!order) { return f(from, to, "ltr") }

  var found = false

  for (var i = 0; i < order.length; ++i) {

    var part = order[i]

    if (part.from < to && part.to > from || from == to && part.to == from) {

      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr")

      found = true

    }

  }

}

function bidiLeft(part) { return part.level % 2 ? part.to : part.from }

function bidiRight(part) { return part.level % 2 ? part.from : part.to }

function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0 }

function lineRight(line) {

  var order = getOrder(line)

  if (!order) { return line.text.length }

  return bidiRight(lst(order))

}

function compareBidiLevel(order, a, b) {

  var linedir = order[0].level

  if (a == linedir) { return true }

  if (b == linedir) { return false }

  return a < b

}

var bidiOther = null

function getBidiPartAt(order, pos) {

  var found

  bidiOther = null

  for (var i = 0; i < order.length; ++i) {

    var cur = order[i]

    if (cur.from < pos && cur.to > pos) { return i }

    if ((cur.from == pos || cur.to == pos)) {