Proyectos de Subversion Moodle

YUI.add('moodle-atto_html-codemirror', function (Y, NAME) {

var _codeMirror = window.codeMirror;

var define = null; // Remove require.js support in this context.

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

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

// This is CodeMirror (https://codemirror.net/5), 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 = global || self, 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\/(\d+)/.exec(userAgent);

  var chrome_version = chrome && +chrome[1];

  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 = safari && (/Mobile\/\w+/.test(userAgent) || navigator.maxTouchPoints > 2);

  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(rootNode) {

    // 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 doc = rootNode.ownerDocument || rootNode;

    var activeElement;

    try {

      activeElement = rootNode.activeElement;

    } catch(e) {

      activeElement = doc.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 doc(cm) { return cm.display.wrapper.ownerDocument }

  function root(cm) {

    return rootNode(cm.display.wrapper)

  }

  function rootNode(element) {

    // Detect modern browsers (2017+).

    return element.getRootNode ? element.getRootNode() : element.ownerDocument

  }

  function win(cm) { return doc(cm).defaultView }

  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;

    this.f = null;

    this.time = 0;

    this.handler = bind(this.onTimeout, this);

  };

  Delayed.prototype.onTimeout = function (self) {

    self.id = 0;

    if (self.time <= +new Date) {

      self.f();

    } else {

      setTimeout(self.handler, self.time - +new Date);

    }

  };

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

    this.f = f;

    var time = +new Date + ms;

    if (!this.id || time < this.time) {

      clearTimeout(this.id);

      this.id = setTimeout(this.handler, ms);

      this.time = time;

    }

  };

  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 = 50;

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

    }

  }

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

      // change the type of the NSM to the type of the previous

      // character. If the NSM is at the start of the level run, it will

      // get the type of sor.

      for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {

        var type = types[i$1];

        if (type == "m") { types[i$1] = prev; }

        else { prev = type; }

      }

      // W2. Search backwards from each instance of a European number

      // until the first strong type (R, L, AL, or sor) is found. If an

      // AL is found, change the type of the European number to Arabic

      // number.

      // W3. Change all ALs to R.

      for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {

        var type$1 = types[i$2];

        if (type$1 == "1" && cur == "r") { types[i$2] = "n"; }

        else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } }

      }

      // W4. A single European separator between two European numbers

      // changes to a European number. A single common separator between

      // two numbers of the same type changes to that type.

      for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {

        var type$2 = types[i$3];

        if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; }

        else if (type$2 == "," && prev$1 == types[i$3+1] &&

                 (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; }

        prev$1 = type$2;

      }

      // W5. A sequence of European terminators adjacent to European

      // numbers changes to all European numbers.

      // W6. Otherwise, separators and terminators change to Other

      // Neutral.

      for (var i$4 = 0; i$4 < len; ++i$4) {

        var type$3 = types[i$4];

        if (type$3 == ",") { types[i$4] = "N"; }

        else if (type$3 == "%") {

          var end = (void 0);

          for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}

          var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";

          for (var j = i$4; j < end; ++j) { types[j] = replace; }

          i$4 = end - 1;

        }

      }

      // W7. Search backwards from each instance of a European number

      // until the first strong type (R, L, or sor) is found. If an L is

      // found, then change the type of the European number to L.

      for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {

        var type$4 = types[i$5];

        if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; }

        else if (isStrong.test(type$4)) { cur$1 = type$4; }

      }

      // N1. A sequence of neutrals takes the direction of the

      // surrounding strong text if the text on both sides has the same

      // direction. European and Arabic numbers act as if they were R in

      // terms of their influence on neutrals. Start-of-level-run (sor)

      // and end-of-level-run (eor) are used at level run boundaries.

      // N2. Any remaining neutrals take the embedding direction.

      for (var i$6 = 0; i$6 < len; ++i$6) {

        if (isNeutral.test(types[i$6])) {

          var end$1 = (void 0);

          for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}

          var before = (i$6 ? types[i$6-1] : outerType) == "L";

          var after = (end$1 < len ? types[end$1] : outerType) == "L";

          var replace$1 = before == after ? (before ? "L" : "R") : outerType;

          for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; }

          i$6 = end$1 - 1;

        }

      }

      // Here we depart from the documented algorithm, in order to avoid

      // building up an actual levels array. Since there are only three

      // levels (0, 1, 2) in an implementation that doesn't take

      // explicit embedding into account, we can build up the order on

      // the fly, without following the level-based algorithm.

      var order = [], m;

      for (var i$7 = 0; i$7 < len;) {

        if (countsAsLeft.test(types[i$7])) {

          var start = i$7;

          for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}

          order.push(new BidiSpan(0, start, i$7));

        } else {

          var pos = i$7, at = order.length, isRTL = direction == "rtl" ? 1 : 0;

          for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}

          for (var j$2 = pos; j$2 < i$7;) {

            if (countsAsNum.test(types[j$2])) {

              if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); at += isRTL; }

              var nstart = j$2;

              for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}

              order.splice(at, 0, new BidiSpan(2, nstart, j$2));

              at += isRTL;

              pos = j$2;

            } else { ++j$2; }

          }

          if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); }

        }

      }

      if (direction == "ltr") {

        if (order[0].level == 1 && (m = str.match(/^\s+/))) {

          order[0].from = m[0].length;

          order.unshift(new BidiSpan(0, 0, m[0].length));

        }

        if (lst(order).level == 1 && (m = str.match(/\s+$/))) {

          lst(order).to -= m[0].length;

          order.push(new BidiSpan(0, len - m[0].length, len));

        }

      }

      return direction == "rtl" ? order.reverse() : order

    }

  })();

  // Get the bidi ordering for the given line (and cache it). Returns

  // false for lines that are fully left-to-right, and an array of

  // BidiSpan objects otherwise.

  function getOrder(line, direction) {

    var order = line.order;

    if (order == null) { order = line.order = bidiOrdering(line.text, direction); }

    return order

  }

  // EVENT HANDLING

  // Lightweight event framework. on/off also work on DOM nodes,

  // registering native DOM handlers.

  var noHandlers = [];

  var on = function(emitter, type, f) {

    if (emitter.addEventListener) {

      emitter.addEventListener(type, f, false);

    } else if (emitter.attachEvent) {

      emitter.attachEvent("on" + type, f);

    } else {

      var map = emitter._handlers || (emitter._handlers = {});

      map[type] = (map[type] || noHandlers).concat(f);

    }

  };

  function getHandlers(emitter, type) {

    return emitter._handlers && emitter._handlers[type] || noHandlers

  }

  function off(emitter, type, f) {

    if (emitter.removeEventListener) {

      emitter.removeEventListener(type, f, false);

    } else if (emitter.detachEvent) {

      emitter.detachEvent("on" + type, f);

    } else {

      var map = emitter._handlers, arr = map && map[type];

      if (arr) {

        var index = indexOf(arr, f);

        if (index > -1)

          { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)); }

      }

    }

  }

  function signal(emitter, type /*, values...*/) {

    var handlers = getHandlers(emitter, type);

    if (!handlers.length) { return }

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

    for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); }

  }

  // The DOM events that CodeMirror handles can be overridden by

  // registering a (non-DOM) handler on the editor for the event name,

  // and preventDefault-ing the event in that handler.

  function signalDOMEvent(cm, e, override) {

    if (typeof e == "string")

      { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; }

    signal(cm, override || e.type, cm, e);

    return e_defaultPrevented(e) || e.codemirrorIgnore

  }

  function signalCursorActivity(cm) {

    var arr = cm._handlers && cm._handlers.cursorActivity;

    if (!arr) { return }

    var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);

    for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)

      { set.push(arr[i]); } }

  }

  function hasHandler(emitter, type) {

    return getHandlers(emitter, type).length > 0

  }

  // Add on and off methods to a constructor's prototype, to make

  // registering events on such objects more convenient.

  function eventMixin(ctor) {

    ctor.prototype.on = function(type, f) {on(this, type, f);};

    ctor.prototype.off = function(type, f) {off(this, type, f);};

  }

  // Due to the fact that we still support jurassic IE versions, some

  // compatibility wrappers are needed.

  function e_preventDefault(e) {

    if (e.preventDefault) { e.preventDefault(); }

    else { e.returnValue = false; }

  }

  function e_stopPropagation(e) {

    if (e.stopPropagation) { e.stopPropagation(); }

    else { e.cancelBubble = true; }

  }

  function e_defaultPrevented(e) {

    return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false

  }

  function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}

  function e_target(e) {return e.target || e.srcElement}

  function e_button(e) {

    var b = e.which;

    if (b == null) {

      if (e.button & 1) { b = 1; }

      else if (e.button & 2) { b = 3; }

      else if (e.button & 4) { b = 2; }

    }

    if (mac && e.ctrlKey && b == 1) { b = 3; }

    return b

  }

  // Detect drag-and-drop

  var dragAndDrop = function() {

    // There is *some* kind of drag-and-drop support in IE6-8, but I

    // couldn't get it to work yet.

    if (ie && ie_version < 9) { return false }

    var div = elt('div');

    return "draggable" in div || "dragDrop" in div

  }();

  var zwspSupported;

  function zeroWidthElement(measure) {

    if (zwspSupported == null) {

      var test = elt("span", "\u200b");

      removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));

      if (measure.firstChild.offsetHeight != 0)

        { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); }

    }

    var node = zwspSupported ? elt("span", "\u200b") :

      elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");

    node.setAttribute("cm-text", "");

    return node

  }

  // Feature-detect IE's crummy client rect reporting for bidi text

  var badBidiRects;

  function hasBadBidiRects(measure) {

    if (badBidiRects != null) { return badBidiRects }

    var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));

    var r0 = range(txt, 0, 1).getBoundingClientRect();

    var r1 = range(txt, 1, 2).getBoundingClientRect();

    removeChildren(measure);

    if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)

    return badBidiRects = (r1.right - r0.right < 3)

  }

  // See if "".split is the broken IE version, if so, provide an

  // alternative way to split lines.

  var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {

    var pos = 0, result = [], l = string.length;

    while (pos <= l) {

      var nl = string.indexOf("\n", pos);

      if (nl == -1) { nl = string.length; }

      var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);

      var rt = line.indexOf("\r");

      if (rt != -1) {

        result.push(line.slice(0, rt));

        pos += rt + 1;

      } else {

        result.push(line);

        pos = nl + 1;

      }

    }

    return result

  } : function (string) { return string.split(/\r\n?|\n/); };

  var hasSelection = window.getSelection ? function (te) {

    try { return te.selectionStart != te.selectionEnd }

    catch(e) { return false }

  } : function (te) {

    var range;

    try {range = te.ownerDocument.selection.createRange();}

    catch(e) {}

    if (!range || range.parentElement() != te) { return false }

    return range.compareEndPoints("StartToEnd", range) != 0

  };

  var hasCopyEvent = (function () {

    var e = elt("div");

    if ("oncopy" in e) { return true }

    e.setAttribute("oncopy", "return;");

    return typeof e.oncopy == "function"

  })();

  var badZoomedRects = null;

  function hasBadZoomedRects(measure) {

    if (badZoomedRects != null) { return badZoomedRects }

    var node = removeChildrenAndAdd(measure, elt("span", "x"));

    var normal = node.getBoundingClientRect();

    var fromRange = range(node, 0, 1).getBoundingClientRect();

    return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1

  }

  // Known modes, by name and by MIME

  var modes = {}, mimeModes = {};

  // Extra arguments are stored as the mode's dependencies, which is

  // used by (legacy) mechanisms like loadmode.js to automatically

  // load a mode. (Preferred mechanism is the require/define calls.)

  function defineMode(name, mode) {

    if (arguments.length > 2)

      { mode.dependencies = Array.prototype.slice.call(arguments, 2); }

    modes[name] = mode;

  }

  function defineMIME(mime, spec) {

    mimeModes[mime] = spec;

  }

  // Given a MIME type, a {name, ...options} config object, or a name

  // string, return a mode config object.

  function resolveMode(spec) {

    if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {

      spec = mimeModes[spec];

    } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {

      var found = mimeModes[spec.name];

      if (typeof found == "string") { found = {name: found}; }

      spec = createObj(found, spec);

      spec.name = found.name;

    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {

      return resolveMode("application/xml")

    } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {

      return resolveMode("application/json")

    }

    if (typeof spec == "string") { return {name: spec} }

    else { return spec || {name: "null"} }

  }

  // Given a mode spec (anything that resolveMode accepts), find and

  // initialize an actual mode object.

  function getMode(options, spec) {

    spec = resolveMode(spec);

    var mfactory = modes[spec.name];

    if (!mfactory) { return getMode(options, "text/plain") }

    var modeObj = mfactory(options, spec);

    if (modeExtensions.hasOwnProperty(spec.name)) {

      var exts = modeExtensions[spec.name];

      for (var prop in exts) {

        if (!exts.hasOwnProperty(prop)) { continue }

        if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop]; }

        modeObj[prop] = exts[prop];

      }

    }

    modeObj.name = spec.name;

    if (spec.helperType) { modeObj.helperType = spec.helperType; }

    if (spec.modeProps) { for (var prop$1 in spec.modeProps)

      { modeObj[prop$1] = spec.modeProps[prop$1]; } }

    return modeObj

  }

  // This can be used to attach properties to mode objects from

  // outside the actual mode definition.

  var modeExtensions = {};

  function extendMode(mode, properties) {

    var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});

    copyObj(properties, exts);

  }

  function copyState(mode, state) {

    if (state === true) { return state }

    if (mode.copyState) { return mode.copyState(state) }

    var nstate = {};

    for (var n in state) {

      var val = state[n];

      if (val instanceof Array) { val = val.concat([]); }

      nstate[n] = val;

    }

    return nstate

  }

  // Given a mode and a state (for that mode), find the inner mode and

  // state at the position that the state refers to.

  function innerMode(mode, state) {

    var info;

    while (mode.innerMode) {

      info = mode.innerMode(state);

      if (!info || info.mode == mode) { break }

      state = info.state;

      mode = info.mode;

    }

    return info || {mode: mode, state: state}

  }

  function startState(mode, a1, a2) {

    return mode.startState ? mode.startState(a1, a2) : true

  }

  // STRING STREAM

  // Fed to the mode parsers, provides helper functions to make

  // parsers more succinct.

  var StringStream = function(string, tabSize, lineOracle) {

    this.pos = this.start = 0;

    this.string = string;

    this.tabSize = tabSize || 8;

    this.lastColumnPos = this.lastColumnValue = 0;

    this.lineStart = 0;

    this.lineOracle = lineOracle;

  };

  StringStream.prototype.eol = function () {return this.pos >= this.string.length};

  StringStream.prototype.sol = function () {return this.pos == this.lineStart};

  StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};

  StringStream.prototype.next = function () {

    if (this.pos < this.string.length)

      { return this.string.charAt(this.pos++) }

  };

  StringStream.prototype.eat = function (match) {

    var ch = this.string.charAt(this.pos);

    var ok;

    if (typeof match == "string") { ok = ch == match; }

    else { ok = ch && (match.test ? match.test(ch) : match(ch)); }

    if (ok) {++this.pos; return ch}

  };

  StringStream.prototype.eatWhile = function (match) {

    var start = this.pos;

    while (this.eat(match)){}

    return this.pos > start

  };

  StringStream.prototype.eatSpace = function () {

    var start = this.pos;

    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this.pos; }

    return this.pos > start

  };

  StringStream.prototype.skipToEnd = function () {this.pos = this.string.length;};

  StringStream.prototype.skipTo = function (ch) {

    var found = this.string.indexOf(ch, this.pos);

    if (found > -1) {this.pos = found; return true}

  };

  StringStream.prototype.backUp = function (n) {this.pos -= n;};

  StringStream.prototype.column = function () {

    if (this.lastColumnPos < this.start) {

      this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);

      this.lastColumnPos = this.start;

    }

    return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)

  };

  StringStream.prototype.indentation = function () {

    return countColumn(this.string, null, this.tabSize) -

      (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)

  };

  StringStream.prototype.match = function (pattern, consume, caseInsensitive) {

    if (typeof pattern == "string") {

      var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; };

      var substr = this.string.substr(this.pos, pattern.length);

      if (cased(substr) == cased(pattern)) {

        if (consume !== false) { this.pos += pattern.length; }

        return true

      }

    } else {

      var match = this.string.slice(this.pos).match(pattern);

      if (match && match.index > 0) { return null }

      if (match && consume !== false) { this.pos += match[0].length; }

      return match

    }

  };

  StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};

  StringStream.prototype.hideFirstChars = function (n, inner) {

    this.lineStart += n;

    try { return inner() }

    finally { this.lineStart -= n; }

  };

  StringStream.prototype.lookAhead = function (n) {

    var oracle = this.lineOracle;

    return oracle && oracle.lookAhead(n)

  };

  StringStream.prototype.baseToken = function () {

    var oracle = this.lineOracle;

    return oracle && oracle.baseToken(this.pos)

  };

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