// 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 (Object.prototype.hasOwnProperty.call(obj, prop) && (overwrite !== false || !Object.prototype.hasOwnProperty.call(target, 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;

}

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

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