Proyectos de Subversion Moodle

/*eslint-disable*/

// CodeMirror, copyright (c) by Marijn Haverbeke and others

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

// This is CodeMirror (https://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() :

  typeof define === 'function' && define.amd ? define(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 userAgent = navigator.userAgent;

  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 edge = /Edge\/(\d+)/.exec(userAgent);

  var ie = ie_upto10 || ie_11up || edge;

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

  var webkit = !edge && /WebKit\//.test(userAgent);

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

  var chrome = !edge && /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 = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent);

  var android = /Android/.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

  }

  // wrapper for elt, which removes the elt from the accessibility tree

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

    var e = elt(tag, content, className, style);

    e.setAttribute("role", "presentation");

    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 }

    } while (child = child.parentNode)

  }

  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.shadowRoot && activeElement.shadowRoot.activeElement)

      { activeElement = activeElement.shadowRoot.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;

    }

  }

  var Delayed = function() {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}, sel_mouse = {origin: "*mouse"}, 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;

      inst = new nothing();

    }

    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) }

  // Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.

  function skipExtendingChars(str, pos, dir) {

    while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; }

    return pos

  }

  // Returns the value from the range [`from`; `to`] that satisfies

  // `pred` and is closest to `from`. Assumes that at least `to`

  // satisfies `pred`. Supports `from` being greater than `to`.

  function findFirst(pred, from, to) {

    // At any point we are certain `to` satisfies `pred`, don't know

    // whether `from` does.

    var dir = from > to ? -1 : 1;

    for (;;) {

      if (from == to) { return from }

      var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);

      if (mid == from) { return pred(mid) ? from : to }

      if (pred(mid)) { to = mid; }

      else { from = mid + dir; }

    }

  }

  // 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 = eltP("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 = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],

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

    var lines = eltP("div", [d.lineSpace], "CodeMirror-lines");

    // Moved around its parent to cover visible view.

    d.mover = elt("div", [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, sticky) {

    if ( sticky === void 0 ) sticky = null;

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

    this.line = line;

    this.ch = ch;

    this.sticky = sticky;

  }

  // 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 equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }

  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, 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) {

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

      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]); } }

    return r

  }

  // 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).

  function markedSpansBefore(old, startCh, isInsert) {

    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));

      }

    } }

    return nw

  }

  function markedSpansAfter(old, endCh, isInsert) {

    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));

      }

    } }

    return nw

  }

  // 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(gapMarkers); }

      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;

        if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))

          { (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 - 3;

      }

    }

    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;

    if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {

      sp = sps[i];

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

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

        { found = sp.marker; }

    } }

    return found

  }

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

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

  function collapsedSpanAround(line, ch) {

    var sps = sawCollapsedSpans && line.markedSpans, found;

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

      var sp = sps[i];

      if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) &&

          (!found || compareCollapsedMarkers(found, sp.marker) < 0)) { found = sp.marker; }

    } }

    return found

  }

  // 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$$1, from, to, marker) {

    var line = getLine(doc, lineNo$$1);

    var sps = sawCollapsedSpans && line.markedSpans;

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

      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

  }

  function visualLineEnd(line) {

    var merged;

    while (merged = collapsedSpanAtEnd(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);

    }

    return lines

  }

  // 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;

    if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {

      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 }

    for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {

      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", 0) }

    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", i);

        found = true;

      }

    }

    if (!found) { f(from, to, "ltr"); }

  }

  var bidiOther = null;

  function getBidiPartAt(order, ch, sticky) {

    var found;

    bidiOther = null;

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

      var cur = order[i];

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

      if (cur.to == ch) {

        if (cur.from != cur.to && sticky == "before") { found = i; }

        else { bidiOther = i; }

      }

      if (cur.from == ch) {

        if (cur.from != cur.to && sticky != "before") { found = i; }

        else { bidiOther = i; }

      }

    }

    return found != null ? found : bidiOther

  }

  // Bidirectional ordering algorithm

  // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm

  // that this (partially) implements.

  // One-char codes used for character types:

  // L (L):   Left-to-Right

  // R (R):   Right-to-Left

  // r (AL):  Right-to-Left Arabic

  // 1 (EN):  European Number

  // + (ES):  European Number Separator

  // % (ET):  European Number Terminator

  // n (AN):  Arabic Number

  // , (CS):  Common Number Separator

  // m (NSM): Non-Spacing Mark

  // b (BN):  Boundary Neutral

  // s (B):   Paragraph Separator

  // t (S):   Segment Separator

  // w (WS):  Whitespace

  // N (ON):  Other Neutrals

  // Returns null if characters are ordered as they appear

  // (left-to-right), or an array of sections ({from, to, level}

  // objects) in the order in which they occur visually.

  var bidiOrdering = (function() {

    // Character types for codepoints 0 to 0xff

    var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";

    // Character types for codepoints 0x600 to 0x6f9

    var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111";

    function charType(code) {

      if (code <= 0xf7) { return lowTypes.charAt(code) }

      else if (0x590 <= code && code <= 0x5f4) { return "R" }

      else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }

      else if (0x6ee <= code && code <= 0x8ac) { return "r" }

      else if (0x2000 <= code && code <= 0x200b) { return "w" }

      else if (code == 0x200c) { return "b" }

      else { return "L" }

    }

    var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;

    var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;

    function BidiSpan(level, from, to) {

      this.level = level;

      this.from = from; this.to = to;

    }

    return function(str, direction) {

      var outerType = direction == "ltr" ? "L" : "R";

      if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false }

      var len = str.length, types = [];

      for (var i = 0; i < len; ++i)

        { types.push(charType(str.charCodeAt(i))); }

      // W1. Examine each non-spacing mark (NSM) in the level run, and