https://www.museum-newtonabbot.org.uk/js/CodeMirror-master/lib/codemirror.js

1// CodeMirror, copyright (c) by Marijn Haverbeke and others
2// Distributed under an MIT license: http://codemirror.net/LICENSE
3
4// This is CodeMirror (http://codemirror.net), a code editor
5// implemented in JavaScript on top of the browser's DOM.
6//
7// You can find some technical background for some of the code below
8// at http://marijnhaverbeke.nl/blog/#cm-internals .
9
10(function (global, factory) {
11	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
12	typeof define === 'function' && define.amd ? define(factory) :
13	(global.CodeMirror = factory());
14}(this, (function () { 'use strict';
15
16// Kludges for bugs and behavior differences that can't be feature
17// detected are enabled based on userAgent etc sniffing.
18var userAgent = navigator.userAgent;
19var platform = navigator.platform;
20
21var gecko = /gecko\/\d/i.test(userAgent);
22var ie_upto10 = /MSIE \d/.test(userAgent);
23var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
24var edge = /Edge\/(\d+)/.exec(userAgent);
25var ie = ie_upto10 || ie_11up || edge;
26var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);
27var webkit = !edge && /WebKit\//.test(userAgent);
28var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
29var chrome = !edge && /Chrome\//.test(userAgent);
30var presto = /Opera\//.test(userAgent);
31var safari = /Apple Computer/.test(navigator.vendor);
32var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent);
33var phantom = /PhantomJS/.test(userAgent);
34
35var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent);
36var android = /Android/.test(userAgent);
37// This is woefully incomplete. Suggestions for alternative methods welcome.
38var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
39var mac = ios || /Mac/.test(platform);
40var chromeOS = /\bCrOS\b/.test(userAgent);
41var windows = /win/i.test(platform);
42
43var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
44if (presto_version) { presto_version = Number(presto_version[1]); }
45if (presto_version && presto_version >= 15) { presto = false; webkit = true; }
46// Some browsers use the wrong event properties to signal cmd/ctrl on OS X
47var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));
48var captureRightClick = gecko || (ie && ie_version >= 9);
49
50function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }
51
52var rmClass = function(node, cls) {
53  var current = node.className;
54  var match = classTest(cls).exec(current);
55  if (match) {
56    var after = current.slice(match.index + match[0].length);
57    node.className = current.slice(0, match.index) + (after ? match[1] + after : "");
58  }
59};
60
61function removeChildren(e) {
62  for (var count = e.childNodes.length; count > 0; --count)
63    { e.removeChild(e.firstChild); }
64  return e
65}
66
67function removeChildrenAndAdd(parent, e) {
68  return removeChildren(parent).appendChild(e)
69}
70
71function elt(tag, content, className, style) {
72  var e = document.createElement(tag);
73  if (className) { e.className = className; }
74  if (style) { e.style.cssText = style; }
75  if (typeof content == "string") { e.appendChild(document.createTextNode(content)); }
76  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]); } }
77  return e
78}
79// wrapper for elt, which removes the elt from the accessibility tree
80function eltP(tag, content, className, style) {
81  var e = elt(tag, content, className, style);
82  e.setAttribute("role", "presentation");
83  return e
84}
85
86var range;
87if (document.createRange) { range = function(node, start, end, endNode) {
88  var r = document.createRange();
89  r.setEnd(endNode || node, end);
90  r.setStart(node, start);
91  return r
92}; }
93else { range = function(node, start, end) {
94  var r = document.body.createTextRange();
95  try { r.moveToElementText(node.parentNode); }
96  catch(e) { return r }
97  r.collapse(true);
98  r.moveEnd("character", end);
99  r.moveStart("character", start);
100  return r
101}; }
102
103function contains(parent, child) {
104  if (child.nodeType == 3) // Android browser always returns false when child is a textnode
105    { child = child.parentNode; }
106  if (parent.contains)
107    { return parent.contains(child) }
108  do {
109    if (child.nodeType == 11) { child = child.host; }
110    if (child == parent) { return true }
111  } while (child = child.parentNode)
112}
113
114function activeElt() {
115  // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
116  // IE < 10 will throw when accessed while the page is loading or in an iframe.
117  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
118  var activeElement;
119  try {
120    activeElement = document.activeElement;
121  } catch(e) {
122    activeElement = document.body || null;
123  }
124  while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)
125    { activeElement = activeElement.shadowRoot.activeElement; }
126  return activeElement
127}
128
129function addClass(node, cls) {
130  var current = node.className;
131  if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls; }
132}
133function joinClasses(a, b) {
134  var as = a.split(" ");
135  for (var i = 0; i < as.length; i++)
136    { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i]; } }
137  return b
138}
139
140var selectInput = function(node) { node.select(); };
141if (ios) // Mobile Safari apparently has a bug where select() is broken.
142  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; }; }
143else if (ie) // Suppress mysterious IE10 errors
144  { selectInput = function(node) { try { node.select(); } catch(_e) {} }; }
145
146function bind(f) {
147  var args = Array.prototype.slice.call(arguments, 1);
148  return function(){return f.apply(null, args)}
149}
150
151function copyObj(obj, target, overwrite) {
152  if (!target) { target = {}; }
153  for (var prop in obj)
154    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
155      { target[prop] = obj[prop]; } }
156  return target
157}
158
159// Counts the column offset in a string, taking tabs into account.
160// Used mostly to find indentation.
161function countColumn(string, end, tabSize, startIndex, startValue) {
162  if (end == null) {
163    end = string.search(/[^\s\u00a0]/);
164    if (end == -1) { end = string.length; }
165  }
166  for (var i = startIndex || 0, n = startValue || 0;;) {
167    var nextTab = string.indexOf("\t", i);
168    if (nextTab < 0 || nextTab >= end)
169      { return n + (end - i) }
170    n += nextTab - i;
171    n += tabSize - (n % tabSize);
172    i = nextTab + 1;
173  }
174}
175
176var Delayed = function() {this.id = null;};
177Delayed.prototype.set = function (ms, f) {
178  clearTimeout(this.id);
179  this.id = setTimeout(f, ms);
180};
181
182function indexOf(array, elt) {
183  for (var i = 0; i < array.length; ++i)
184    { if (array[i] == elt) { return i } }
185  return -1
186}
187
188// Number of pixels added to scroller and sizer to hide scrollbar
189var scrollerGap = 30;
190
191// Returned or thrown by various protocols to signal 'I'm not
192// handling this'.
193var Pass = {toString: function(){return "CodeMirror.Pass"}};
194
195// Reused option objects for setSelection & friends
196var sel_dontScroll = {scroll: false};
197var sel_mouse = {origin: "*mouse"};
198var sel_move = {origin: "+move"};
199
200// The inverse of countColumn -- find the offset that corresponds to
201// a particular column.
202function findColumn(string, goal, tabSize) {
203  for (var pos = 0, col = 0;;) {
204    var nextTab = string.indexOf("\t", pos);
205    if (nextTab == -1) { nextTab = string.length; }
206    var skipped = nextTab - pos;
207    if (nextTab == string.length || col + skipped >= goal)
208      { return pos + Math.min(skipped, goal - col) }
209    col += nextTab - pos;
210    col += tabSize - (col % tabSize);
211    pos = nextTab + 1;
212    if (col >= goal) { return pos }
213  }
214}
215
216var spaceStrs = [""];
217function spaceStr(n) {
218  while (spaceStrs.length <= n)
219    { spaceStrs.push(lst(spaceStrs) + " "); }
220  return spaceStrs[n]
221}
222
223function lst(arr) { return arr[arr.length-1] }
224
225function map(array, f) {
226  var out = [];
227  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); }
228  return out
229}
230
231function insertSorted(array, value, score) {
232  var pos = 0, priority = score(value);
233  while (pos < array.length && score(array[pos]) <= priority) { pos++; }
234  array.splice(pos, 0, value);
235}
236
237function nothing() {}
238
239function createObj(base, props) {
240  var inst;
241  if (Object.create) {
242    inst = Object.create(base);
243  } else {
244    nothing.prototype = base;
245    inst = new nothing();
246  }
247  if (props) { copyObj(props, inst); }
248  return inst
249}
250
251var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
252function isWordCharBasic(ch) {
253  return /\w/.test(ch) || ch > "\x80" &&

309ors.
310  d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1");
311  d.cursorDiv = elt("div", null, "CodeMirror-cursors");
312  // A visibility: hidden element used to find the size of things.
313  d.measure = elt("div", null, "CodeMirror-measure");
314  // When lines outside of the viewport are measured, they are drawn in this.
315  d.lineMeasure = elt("div", null, "CodeMirror-measure");
316  // Wraps everything that needs to exist inside the vertically-padded coordinate system
317  d.lineSpace = eltP("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
318                    null, "position: relative; outline: none");
319  var lines = eltP("div", [d.lineSpace], "CodeMirror-lines");
320  // Moved around its parent to cover visible view.
321  d.mover = elt("div", [lines], null, "position: relative");
322  // Set to the height of the document, allowing scrolling.
323  d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
324  d.sizerWidth = null;
325  // Behavior of elts with overflow: auto and padding is
326  // inconsistent across browsers. This is used to ensure the
327  // scrollable area is big enough.
328  d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;");
329  // Will contain the gutters, if any.
330  d.gutters = elt("div", null, "CodeMirror-gutters");
331  d.lineGutter = null;
332  // Actual scrollable element.
333  d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll");
334  d.scroller.setAttribute("tabIndex", "-1");
335  // The element in which the editor lives.
336  d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror");
337
338  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
339  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }
340  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true; }
341
342  if (place) {
343    if (place.appendChild) { place.appendChild(d.wrapper); }
344    else { place(d.wrapper); }
345  }
346
347  // Current rendered range (may be bigger than the view window).
348  d.viewFrom = d.viewTo = doc.first;
349  d.reportedViewFrom = d.reportedViewTo = doc.first;
350  // Information about the rendered lines.
351  d.view = [];
352  d.renderedView = null;
353  // Holds info about a single rendered line when it was rendered
354  // for measurement, while not in view.
355  d.externalMeasured = null;
356  // Empty space (in pixels) above the view
357  d.viewOffset = 0;
358  d.lastWrapHeight = d.lastWrapWidth = 0;
359  d.updateLineNumbers = null;
360
361  d.nativeBarWidth = d.barHeight = d.barWidth = 0;
362  d.scrollbarsClipped = false;
363
364  // Used to only resize the line number gutter when necessary (when
365  // the amount of lines crosses a boundary that makes its width change)
366  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
367  // Set to true when a non-horizontal-scrolling line widget is
368  // added. As an optimization, line widget aligning is skipped when
369  // this is false.
370  d.alignWidgets = false;
371
372  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
373
374  // Tracks the maximum line length so that the horizontal scrollbar
375  // can be kept static when scrolling.
376  d.maxLine = null;
377  d.maxLineLength = 0;
378  d.maxLineChanged = false;
379
380  // Used for measuring wheel scrolling granularity
381  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
382
383  // True when shift is held down.
384  d.shift = false;
385
386  // Used to track whether anything happened since the context menu
387  // was opened.
388  d.selForContextMenu = null;
389
390  d.activeTouch = null;
391
392  input.init(d);
393}
394
395// Find the line object corresponding to the given line number.
396function getLine(doc, n) {
397  n -= doc.first;
398  if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }
399  var chunk = doc;
400  while (!chunk.lines) {
401    for (var i = 0;; ++i) {
402      var child = chunk.children[i], sz = child.chunkSize();
403      if (n < sz) { chunk = child; break }
404      n -= sz;
405    }
406  }
407  return chunk.lines[n]
408}
409
410// Get the part of a document between two positions, as an array of
411// strings.
412function getBetween(doc, start, end) {
413  var out = [], n = start.line;
414  doc.iter(start.line, end.line + 1, function (line) {
415    var text = line.text;
416    if (n == end.line) { text = text.slice(0, end.ch); }
417    if (n == start.line) { text = text.slice(start.ch); }
418    out.push(text);
419    ++n;
420  });
421  return out
422}
423// Get the lines between from and to, as array of strings.
424function getLines(doc, from, to) {
425  var out = [];
426  doc.iter(from, to, function (line) { out.push(line.text); }); // iter aborts when callback returns truthy value
427  return out
428}
429
430// Update the height of a line, propagating the height change
431// upwards to parent nodes.
432function updateLineHeight(line, height) {
433  var diff = height - line.height;
434  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff; } }
435}
436
437// Given a line object, find its line number by walking up through
438// its parent links.
439function lineNo(line) {
440  if (line.parent == null) { return null }
441  var cur = line.parent, no = indexOf(cur.lines, line);
442  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
443    for (var i = 0;; ++i) {
444      if (chunk.children[i] == cur) { break }
445      no += chunk.children[i].chunkSize();
446    }
447  }
448  return no + cur.first
449}
450
451// Find the line at the given vertical position, using the height
452// information in the document tree.
453function lineAtHeight(chunk, h) {
454  var n = chunk.first;
455  outer: do {
456    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
457      var child = chunk.children[i$1], ch = child.height;
458      if (h < ch) { chunk = child; continue outer }
459      h -= ch;
460      n += child.chunkSize();
461    }
462    return n
463  } while (!chunk.lines)
464  var i = 0;
465  for (; i < chunk.lines.length; ++i) {
466    var line = chunk.lines[i], lh = line.height;
467    if (h < lh) { break }
468    h -= lh;
469  }
470  return n + i
471}
472
473function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}
474
475function lineNumberFor(options, i) {
476  return String(options.lineNumberFormatter(i + options.firstLineNumber))
477}
478
479// A Pos instance represents a position within the text.
480function Pos(line, ch, sticky) {
481  if ( sticky === void 0 ) sticky = null;
482
483  if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }
484  this.line = line;
485  this.ch = ch;
486  this.sticky = sticky;
487}
488
489// Compare two positions, return 0 if they are the same, a negative
490// number when a is less, and a positive number otherwise.
491function cmp(a, b) { return a.line - b.line || a.ch - b.ch }
492
493function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }
494
495function copyPos(x) {return Pos(x.line, x.ch)}
496function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
497function minPos(a, b) { return cmp(a, b) < 0 ? a : b }
498
499// Most of the external API clips given positions to make sure they
500// actually exist within the document.
501function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}
502function clipPos(doc, pos) {
503  if (pos.line < doc.first) { return Pos(doc.first, 0) }
504  var last = doc.first + doc.size - 1;
505  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }
506  return clipToLen(pos, getLine(doc, pos.line).text.length)
507}
508function clipToLen(pos, linelen) {
509  var ch = pos.ch;
510  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }
511  else if (ch < 0) { return Pos(pos.line, 0) }
512  else { return pos }
513}
514function clipPosArray(doc, array) {
515  var out = [];
516  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]); }
517  return out
518}
519
520// Optimize some code when these features are not used.
521var sawReadOnlySpans = false;
522var sawCollapsedSpans = false;
523
524function seeReadOnlySpans() {
525  sawReadOnlySpans = true;
526}
527
528function seeCollapsedSpans() {
529  sawCollapsedSpans = true;
530}
531
532// TEXTMARKER SPANS
533
534function MarkedSpan(marker, from, to) {
535  this.marker = marker;
536  this.from = from; this.to = to;
537}
538
539// Search an array of spans for a span matching the given marker.
540function getMarkedSpanFor(spans, marker) {
541  if (spans) { for (var i = 0; i < spans.length; ++i) {
542    var span = spans[i];
543    if (span.marker == marker) { return span }
544  } }
545}
546// Remove a span from an array, returning undefined if no spans are
547// left (we don't store arrays for lines without spans).
548function removeMarkedSpan(spans, span) {
549  var r;
550  for (var i = 0; i < spans.length; ++i)
551    { if (spans[i] != span) { (r || (r = [])).push(spans[i]); } }
552  return r
553}
554// Add a span to a line.
555function addMarkedSpan(line, span) {
556  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];
557  span.marker.attachLine(line);
558}
559
560// Used for the algorithm that adjusts markers for a change in the
561// document. These functions cut an array of spans at a given
562// character position, returning an array of remaining chunks (or
563// undefined if nothing remains).
564function markedSpansBefore(old, startCh, isInsert) {
565  var nw;
566  if (old) { for (var i = 0; i < old.length; ++i) {
567    var span = old[i], marker = span.marker;
568    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);
569    if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
570      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));
571    }
572  } }
573  return nw
574}
575function markedSpansAfter(old, endCh, isInsert) {
576  var nw;
577  if (old) { for (var i = 0; i < old.length; ++i) {
578    var span = old[i], marker = span.marker;
579    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);
580    if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
581      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh);(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
582                                            span.to == null ? null : span.to - endCh));
583    }
584  } }
585  return nw
586}
587
588// Given a change object, compute the new set of marker spans that
589// cover the line in which the change took place. Removes spans
590// entirely within the change, reconnects spans belonging to the
591// same marker that appear on both sides of the change, and cuts off
592// spans partially within the change. Returns an array of span
593// arrays with one element for each line in (after) the change.
594function stretchSpansOverChange(doc, change) {
595  if (change.full) { return null }
596  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;
597  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;
598  if (!oldFirst && !oldLast) { return null }
599
600  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;
601  // Get the spans that 'stick out' on both sides
602  var first = markedSpansBefore(oldFirst, startCh, isInsert);
603  var last = markedSpansAfter(oldLast, endCh, isInsert);
604
605  // Next, merge those two ends
606  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);
607  if (first) {
608    // Fix up .to properties of first
609    for (var i = 0; i < first.length; ++i) {
610      var span = first[i];
611      if (span.to == null) {
612        var found = getMarkedSpanFor(last, span.marker);
613        if (!found) { span.to = startCh; }
614        else if (sameLine) { span.to = found.to == null ? null : found.to + offset; }
615      }
616    }
617  }
618  if (last) {
619    // Fix up .from in last (or move them into first in case of sameLine)
620    for (var i$1 = 0; i$1 < last.length; ++i$1) {
621      var span$1 = last[i$1];
622      if (span$1.to != null) { span$1.to += offset; }
623      if (span$1.from == null) {
624        var found$1 = getMarkedSpanFor(first, span$1.marker);
625        if (!found$1) {
626          span$1.from = offset;
627          if (sameLine) { (first || (first = [])).push(span$1); }
628        }
629      } else {
630        span$1.from += offset;
631        if (sameLine) { (first || (first = [])).push(span$1); }
632      }
633    }
634  }
635  // Make sure we didn't create any zero-length spans
636  if (first) { first = clearEmptySpans(first); }
637  if (last && last != first) { last = clearEmptySpans(last); }
638
639  var newMarkers = [first];
640  if (!sameLine) {
641    // Fill gap with whole-line-spans
642    var gap = change.text.length - 2, gapMarkers;
643    if (gap > 0 && first)
644      { for (var i$2 = 0; i$2 < first.length; ++i$2)
645        { if (first[i$2].to == null)
646          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)); } } }
647    for (var i$3 = 0; i$3 < gap; ++i$3)
648      { newMarkers.push(gapMarkers); }
649    newMarkers.push(last);
650  }
651  return newMarkers
652}
653
654// Remove spans that are empty and don't have a clearWhenEmpty
655// option of false.
656function clearEmptySpans(spans) {
657  for (var i = 0; i < spans.length; ++i) {
658    var span = spans[i];
659    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
660      { spans.splice(i--, 1); }
661  }
662  if (!spans.length) { return null }
663  return spans
664}
665
666// Used to 'clip' out readOnly ranges when making a change.
667function removeReadOnlyRanges(doc, from, to) {
668  var markers = null;
669  doc.iter(from.line, to.line + 1, function (line) {
670    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
671      var mark = line.markedSpans[i].marker;
672      if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
673        { (markers || (markers = [])).push(mark); }
674    } }
675  });
676  if (!markers) { return null }
677  var parts = [{from: from, to: to}];
678  for (var i = 0; i < markers.length; ++i) {
679    var mk = markers[i], m = mk.find(0);
680    for (var j = 0; j < parts.length; ++j) {
681      var p = parts[j];
682      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }
683      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);
684      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
685        { newParts.push({from: p.from, to: m.from}); }
686      if (dto > 0 || !mk.inclusiveRight && !dto)
687        { newParts.push({from: m.to, to: p.to}); }
688      parts.splice.apply(parts, newParts);
689      j += newParts.length - 3;
690    }
691  }
692  return parts
693}
694
695// Connect or disconnect spans from a line.
696function detachMarkedSpans(line) {
697  var spans = line.markedSpans;
698  if (!spans) { return }
699  for (var i = 0; i < spans.length; ++i)
700    { spans[i].marker.detachLine(line); }
701  line.markedSpans = null;
702}
703function attachMarkedSpans(line, spans) {
704  if (!spans) { return }
705  for (var i = 0; i < spans.length; ++i)
706    { spans[i].marker.attachLine(line); }
707  line.markedSpans = spans;
708}
709
710// Helpers used when computing which overlapping collapsed span
711// counts as the larger one.
712function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
713function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }
714
715// Returns a number indicating which of two overlapping collapsed
716// spans is larger (and thus includes the other). Falls back to
717// comparing ids when the spans cover exactly the same range.
718function compareCollapsedMarkers(a, b) {
719  var lenDiff = a.lines.length - b.lines.length;
720  if (lenDiff != 0) { return lenDiff }
721  var aPos = a.find(), bPos = b.find();
722  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
723  if (fromCmp) { return -fromCmp }
724  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
725  if (toCmp) { return toCmp }
726  return b.id - a.id
727}
728
729// Find out whether a line ends or starts in a collapsed span. If
730// so, return the marker for that span.
731function collapsedSpanAtSide(line, start) {
732  var sps = sawCollapsedSpans && line.markedSpans, found;
733  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
734    sp = sps[i];
735    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
736        (!found || compareCollapsedMarkers(found, sp.marker) < 0))
737      { found = sp.marker; }
738  } }
739  return found
740}
741function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }
742function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }
743
744// Test whether there exists a collapsed span that partially
745// overlaps (covers the start or end, but not both) of a new span.
746// Such overlap is not allowed.
747function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) {
748  var line = getLine(doc, lineNo$$1);
749  var sps = sawCollapsedSpans && line.markedSpans;
750  if (sps) { for (var i = 0; i < sps.length; ++i) {
751    var sp = sps[i];
752    if (!sp.marker.collapsed) { continue }
753    var found = sp.marker.find(0);
754    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);
755    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);
756    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }
757    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
758        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
759      { return true }
760  } }
761}
762
763// A visual line is a line as drawn on the screen. Folding, for
764// example, can cause multiple logical lines to appear on the same
765// visual line. This finds the start of the visual line that the
766// given line is part of (usually that is the line itself).
767function visualLine(line) {
768  var merged;
769  while (merged = collapsedSpanAtStart(line))
770    { line = merged.find(-1, true).line; }
771  return line
772}
773
774function visualLineEnd(line) {
775  var merged;
776  while (merged = collapsedSpanAtEnd(line))
777    { line = merged.find(1, true).line; }
778  return line
779}
780
781// Returns an array of logical lines that continue the visual line
782// started by the argument, or undefined if there are no such lines.
783function visualLineContinued(line) {
784  var merged, lines;
785  while (merged = collapsedSpanAtEnd(line)) {
786    line = merged.find(1, true).line
787    ;(lines || (lines = [])).push(line);
788  }
789  return lines
790}
791
792// Get the line number of the start of the visual line that the
793// given line number is part of.
794function visualLineNo(doc, lineN) {
795  var line = getLine(doc, lineN), vis = visualLine(line);
796  if (line == vis) { return lineN }
797  return lineNo(vis)
798}
799
800// Get the line number of the start of the next visual line after
801// the given line.
802function visualLineEndNo(doc, lineN) {
803  if (lineN > doc.lastLine()) { return lineN }
804  var line = getLine(doc, lineN), merged;
805  if (!lineIsHidden(doc, line)) { return lineN }
806  while (merged = collapsedSpanAtEnd(line))
807    { line = merged.find(1, true).line; }
808  return lineNo(line) + 1
809}
810
811// Compute whether a line is hidden. Lines count as hidden when they
812// are part of a visual line that starts with another line, or when
813// they are entirely covered by collapsed, non-widget span.
814function lineIsHidden(doc, line) {
815  var sps = sawCollapsedSpans && line.markedSpans;
816  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
817    sp = sps[i];
818    if (!sp.marker.collapsed) { continue }
819    if (sp.from == null) { return true }
820    if (sp.marker.widgetNode) { continue }
821    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
822      { return true }
823  } }
824}
825function lineIsHiddenInner(doc, line, span) {
826  if (span.to == null) {
827    var end = span.marker.find(1, true);
828    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))
829  }
830  if (span.marker.inclusiveRight && span.to == line.text.length)
831    { return true }
832  for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {
833    sp = line.markedSpans[i];
834    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
835        (sp.to == null || sp.to != span.from) &&
836        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
837        lineIsHiddenInner(doc, line, sp)) { return true }
838  }
839}
840
841// Find the height above the given line.
842function heightAtLine(lineObj) {
843  lineObj = visualLine(lineObj);
844
845  var h = 0, chunk = lineObj.parent;
846  for (var i = 0; i < chunk.lines.length; ++i) {
847    var line = chunk.lines[i];
848    if (line == lineObj) { break }
849    else { h += line.height; }
850  }
851  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
852    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {
853      var cur = p.children[i$1];
854      if (cur == chunk) { break }
855      else { h += cur.height; }
856    }
857  }
858  return h
859}
860
861// Compute the character length of a line, taking into account
862// collapsed ranges (see markText) that might hide parts, and join
863// other lines onto it.
864function lineLength(line) {
865  if (line.height == 0) { return 0 }
866  var len = line.text.length, merged, cur = line;
867  while (merged = collapsedSpanAtStart(cur)) {
868    var found = merged.find(0, true);
869    cur = found.from.line;
870    len += found.from.ch - found.to.ch;
871  }
872  cur = line;
873  while (merged = collapsedSpanAtEnd(cur)) {
874    var found$1 = merged.find(0, true);
875    len -= cur.text.length - found$1.from.ch;
876    cur = found$1.to.line;
877    len += cur.text.length - found$1.to.ch;
878  }
879  return len
880}
881
882// Find the longest line in the document.
883function findMaxLine(cm) {
884  var d = cm.display, doc = cm.doc;
885  d.maxLine = getLine(doc, doc.first);
886  d.maxLineLength = lineLength(d.maxLine);
887  d.maxLineChanged = true;
888  doc.iter(function (line) {
889    var len = lineLength(line);
890    if (len > d.maxLineLength) {
891      d.maxLineLength = len;
892      d.maxLine = line;
893    }
894  });
895}
896
897// BIDI HELPERS
898
899function iterateBidiSections(order, from, to, f) {
900  if (!order) { return f(from, to, "ltr") }
901  var found = false;
902  for (var i = 0; i < order.length; ++i) {
903    var part = order[i];
904    if (part.from < to && part.to > from || from == to && part.to == from) {
905      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr");
906      found = true;
907    }
908  }
909  if (!found) { f(from, to, "ltr"); }
910}
911
912var bidiOther = null;
913function getBidiPartAt(order, ch, sticky) {
914  var found;
915  bidiOther = null;
916  for (var i = 0; i < order.length; ++i) {
917    var cur = order[i];
918    if (cur.from < ch && cur.to > ch) { return i }
919    if (cur.to == ch) {
920      if (cur.from != cur.to && sticky == "before") { found = i; }
921      else { bidiOther = i; }
922    }
923    if (cur.from == ch) {
924      if (cur.from != cur.to && sticky != "before") { found = i; }
925      else { bidiOther = i; }
926    }
927  }
928  return found != null ? found : bidiOther
929}
930
931// Bidirectional ordering algorithm
932// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
933// that this (partially) implements.
934
935// One-char codes used for character types:
936// L (L):   Left-to-Right
937// R (R):   Right-to-Left
938// r (AL):  Right-to-Left Arabic
939// 1 (EN):  European Number
940// + (ES):  European Number Separator
941// % (ET):  European Number Terminator
942// n (AN):  Arabic Number
943// , (CS):  Common Number Separator
944// m (NSM): Non-Spacing Mark
945// b (BN):  Boundary Neutral
946// s (B):   Paragraph Separator
947// t (S):   Segment Separator
948// w (WS):  Whitespace
949// N (ON):  Other Neutrals
950
951// Returns null if characters are ordered as they appear
952// (left-to-right), or an array of sections ({from, to, level}
953// objects) in the order in which they occur visually.
954var bidiOrdering = (function() {
955  // Character types for codepoints 0 to 0xff
956  var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
957  // Character types for codepoints 0x600 to 0x6f9
958  var arabicTypes = "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111";
959  function charType(code) {
960    if (code <= 0xf7) { return lowTypes.charAt(code) }
961    else if (0x590 <= code && code <= 0x5f4) { return "R" }
962    else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }
963    else if (0x6ee <= code && code <= 0x8ac) { return "r" }
964    else if (0x2000 <= code && code <= 0x200b) { return "w" }
965    else if (code == 0x200c) { return "b" }
966    else { return "L" }
967  }
968
969  var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
970  var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;
971
972  function BidiSpan(level, from, to) {
973    this.level = level;
974    this.from = from; this.to = to;
975  }
976
977  return function(str, direction) {
978    var outerType = direction == "ltr" ? "L" : "R";
979
980    if (str.length == 0 || direction == "ltr" && !bidiRE.test(str)) { return false }
981    var len = str.length, types = [];
982    for (var i = 0; i < len; ++i)
983      { types.push(charType(str.charCodeAt(i))); }
984
985    // W1. Examine each non-spacing mark (NSM) in the level run, and
986    // change the type of the NSM to the type of the previous
987    // character. If the NSM is at the start of the level run, it will
988    // get the type of sor.
989    for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
990      var type = types[i$1];
991      if (type == "m") { types[i$1] = prev; }
992      else { prev = type; }
993    }
994
995    // W2. Search backwards from each instance of a European number
996    // until the first strong type (R, L, AL, or sor) is found. If an
997    // AL is found, change the type of the European number to Arabic
998    // number.
999    // W3. Change all ALs to R.
1000    for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
1001      var type$1 = types[i$2];
1002      if (type$1 == "1" && cur == "r") { types[i$2] = "n"; }
1003      else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R"; } }
1004    }
1005
1006    // W4. A single European separator between two European numbers
1007    // changes to a European number. A single common separator between
1008    // two numbers of the same type changes to that type.
1009    for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
1010      var type$2 = types[i$3];
1011      if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1"; }
1012      else if (type$2 == "," && prev$1 == types[i$3+1] &&
1013               (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1; }
1014      prev$1 = type$2;
1015    }
1016
1017    // W5. A sequence of European terminators adjacent to European
1018    // numbers changes to all European numbers.
1019    // W6. Otherwise, separators and terminators change to Other
1020    // Neutral.
1021    for (var i$4 = 0; i$4 < len; ++i$4) {
1022      var type$3 = types[i$4];
1023      if (type$3 == ",") { types[i$4] = "N"; }
1024      else if (type$3 == "%") {
1025        var end = (void 0);
1026        for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
1027        var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N";
1028        for (var j = i$4; j < end; ++j) { types[j] = replace; }
1029        i$4 = end - 1;
1030      }
1031    }
1032
1033    // W7. Search backwards from each instance of a European number
1034    // until the first strong type (R, L, or sor) is found. If an L is
1035    // found, then change the type of the European number to L.
1036    for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
1037      var type$4 = types[i$5];
1038      if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L"; }
1039      else if (isStrong.test(type$4)) { cur$1 = type$4; }
1040    }
1041
1042    // N1. A sequence of neutrals takes the direction of the
1043    // surrounding strong text if the text on both sides has the same
1044    // direction. European and Arabic numbers act as if they were R in
1045    // terms of their influence on neutrals. Start-of-level-run (sor)
1046    // and end-of-level-run (eor) are used at level run boundaries.
1047    // N2. Any remaining neutrals take the embedding direction.
1048    for (var i$6 = 0; i$6 < len; ++i$6) {
1049      if (isNeutral.test(types[i$6])) {
1050        var end$1 = (void 0);
1051        for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
1052        var before = (i$6 ? types[i$6-1] : outerType) == "L";
1053        var after = (end$1 < len ? types[end$1] : outerType) == "L";
1054        var replace$1 = before == after ? (before ? "L" : "R") : outerType;
1055        for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; }
1056        i$6 = end$1 - 1;
1057      }
1058    }
1059
1060    // Here we depart from the documented algorithm, in order to avoid
1061    // building up an actual levels array. Since there are only three
1062    // levels (0, 1, 2) in an implementation that doesn't take
1063    // explicit embedding into account, we can build up the order on
1064    // the fly, without following the level-based algorithm.
1065    var order = [], m;
1066    for (var i$7 = 0; i$7 < len;) {
1067      if (countsAsLeft.test(types[i$7])) {
1068        var start = i$7;
1069        for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
1070        order.push(new BidiSpan(0, start, i$7));
1071      } else {
1072        var pos = i$7, at = order.length;
1073        for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
1074        for (var j$2 = pos; j$2 < i$7;) {
1075          if (countsAsNum.test(types[j$2])) {
1076            if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); }
1077            var nstart = j$2;
1078            for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
1079            order.splice(at, 0, new BidiSpan(2, nstart, j$2));
1080            pos = j$2;
1081          } else { ++j$2; }
1082        }
1083        if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); }
1084      }
1085    }
1086    if (order[0].level == 1 && (m = str.match(/^\s+/))) {
1087      order[0].from = m[0].length;
1088      order.unshift(new BidiSpan(0, 0, m[0].length));
1089    }
1090    if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
1091      lst(order).to -= m[0].length;
1092      order.push(new BidiSpan(0, len - m[0].length, len));
1093    }
1094
1095    return direction == "rtl" ? order.reverse() : order
1096  }
1097})();
1098
1099// Get the bidi ordering for the given line (and cache it). Returns
1100// false for lines that are fully left-to-right, and an array of
1101// BidiSpan objects otherwise.
1102function getOrder(line, direction) {
1103  var order = line.order;
1104  if (order == null) { order = line.order = bidiOrdering(line.text, direction); }
1105  return order
1106}
1107
1108function moveCharLogically(line, ch, dir) {
1109  var target = skipExtendingChars(line.text, ch + dir, dir);
1110  return target < 0 || target > line.text.length ? null : target
1111}
1112
1113function moveLogically(line, start, dir) {
1114  var ch = moveCharLogically(line, start.ch, dir);
1115  return ch == null ? null : new Pos(start.line, ch, dir < 0 ? "after" : "before")
1116}
1117
1118function endOfLine(visually, cm, lineObj, lineNo, dir) {
1119  if (visually) {
1120    var order = getOrder(lineObj, cm.doc.direction);
1121    if (order) {
1122      var part = dir < 0 ? lst(order) : order[0];
1123      var moveInStorageOrder = (dir < 0) == (part.level == 1);
1124      var sticky = moveInStorageOrder ? "after" : "before";
1125      var ch;
1126      // With a wrapped rtl chunk (possibly spanning multiple bidi parts),
1127      // it could be that the last bidi part is not on the last visual line,
1128      // since visual lines contain content order-consecutive chunks.
1129      // Thus, in rtl, we are looking for the first (content-order) character
1130      // in the rtl chunk that is on the last line (that is, the same line
1131      // as the last (content-order) character).
1132      if (part.level > 0) {
1133        var prep = prepareMeasureForLine(cm, lineObj);
1134        ch = dir < 0 ? lineObj.text.length - 1 : 0;
1135        var targetTop = measureCharPrepared(cm, prep, ch).top;
1136        ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch);
1137        if (sticky == "before") { ch = moveCharLogically(lineObj, ch, 1); }
1138      } else { ch = dir < 0 ? part.to : part.from; }
1139      return new Pos(lineNo, ch, sticky)
1140    }
1141  }
1142  return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? "before" : "after")
1143}
1144
1145function moveVisually(cm, line, start, dir) {
1146  var bidi = getOrder(line, cm.doc.direction);
1147  if (!bidi) { return moveLogically(line, start, dir) }
1148  if (start.ch >= line.text.length) {
1149    start.ch = line.text.length;
1150    start.sticky = "before";
1151  } else if (start.ch <= 0) {
1152    start.ch = 0;
1153    start.sticky = "after";
1154  }
1155  var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos];
1156  if (cm.doc.direction == "ltr" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {
1157    // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines,
1158    // nothing interesting happens.
1159    return moveLogically(line, start, dir)
1160  }
1161
1162  var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); };
1163  var prep;
1164  var getWrappedLineExtent = function (ch) {
1165    if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} }
1166    prep = prep || prepareMeasureForLine(cm, line);
1167    return wrappedLineExtentChar(cm, line, prep, ch)
1168  };
1169  var wrappedLineExtent = getWrappedLineExtent(start.sticky == "before" ? mv(start, -1) : start.ch);
1170
1171  if (cm.doc.direction == "rtl" || part.level == 1) {
1172    var moveInStorageOrder = (part.level == 1) == (dir < 0);
1173    var ch = mv(start, moveInStorageOrder ? 1 : -1);
1174    if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {
1175      // Case 2: We move within an rtl part or in an rtl editor on the same visual line
1176      var sticky = moveInStorageOrder ? "before" : "after";
1177      return new Pos(start.line, ch, sticky)
1178    }
1179  }
1180
1181  // Case 3: Could not move within this bidi part in this visual line, so leave
1182  // the current bidi part
1183
1184  var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {
1185    var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder
1186      ? new Pos(start.line, mv(ch, 1), "before")
1187      : new Pos(start.line, ch, "after"); };
1188
1189    for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {
1190      var part = bidi[partPos];
1191      var moveInStorageOrder = (dir > 0) == (part.level != 1);
1192      var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1);
1193      if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }
1194      ch = moveInStorageOrder ? part.from : mv(part.to, -1);
1195      if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }
1196    }
1197  };
1198
1199  // Case 3a: Look for other bidi parts on the same visual line
1200  var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent);
1201  if (res) { return res }
1202
1203  // Case 3b: Look for other bidi parts on the next visual line
1204  var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1);
1205  if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {
1206    res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh));
1207    if (res) { return res }
1208  }
1209
1210  // Case 4: Nowhere to move
1211  return null
1212}
1213
1214// EVENT HANDLING
1215
1216// Lightweight event framework. on/off also work on DOM nodes,
1217// registering native DOM handlers.
1218
1219var noHandlers = [];
1220
1221var on = function(emitter, type, f) {
1222  if (emitter.addEventListener) {
1223    emitter.addEventListener(type, f, false);
1224  } else if (emitter.attachEvent) {
1225    emitter.attachEvent("on" + type, f);
1226  } else {
1227    var map$$1 = emitter._handlers || (emitter._handlers = {});
1228    map$$1[type] = (map$$1[type] || noHandlers).concat(f);
1229  }
1230};
1231
1232function getHandlers(emitter, type) {
1233  return emitter._handlers && emitter._handlers[type] || noHandlers
1234}
1235
1236function off(emitter, type, f) {
1237  if (emitter.removeEventListener) {
1238    emitter.removeEventListener(type, f, false);
1239  } else if (emitter.detachEvent) {
1240    emitter.detachEvent("on" + type, f);
1241  } else {
1242    var map$$1 = emitter._handlers, arr = map$$1 && map$$1[type];
1243    if (arr) {
1244      var index = indexOf(arr, f);
1245      if (index > -1)
1246        { map$$1[type] = arr.slice(0, index).concat(arr.slice(index + 1)); }
1247    }
1248  }
1249}
1250
1251function signal(emitter, type /*, values...*/) {
1252  var handlers = getHandlers(emitter, type);
1253  if (!handlers.length) { return }
1254  var args = Array.prototype.slice.call(arguments, 2);
1255  for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); }
1256}
1257
1258// The DOM events that CodeMirror handles can be overridden by
1259// registering a (non-DOM) handler on the editor for the event name,
1260// and preventDefault-ing the event in that handler.
1261function signalDOMEvent(cm, e, override) {
1262  if (typeof e == "string")
1263    { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; }
1264  signal(cm, override || e.type, cm, e);
1265  return e_defaultPrevented(e) || e.codemirrorIgnore
1266}
1267
1268function signalCursorActivity(cm) {
1269  var arr = cm._handlers && cm._handlers.cursorActivity;
1270  if (!arr) { return }
1271  var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);
1272  for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)
1273    { set.push(arr[i]); } }
1274}
1275
1276function hasHandler(emitter, type) {
1277  return getHandlers(emitter, type).length > 0
1278}
1279
1280// Add on and off methods to a constructor's prototype, to make
1281// registering events on such objects more convenient.
1282function eventMixin(ctor) {
1283  ctor.prototype.on = function(type, f) {on(this, type, f);};
1284  ctor.prototype.off = function(type, f) {off(this, type, f);};
1285}
1286
1287// Due to the fact that we still support jurassic IE versions, some
1288// compatibility wrappers are needed.
1289
1290function e_preventDefault(e) {
1291  if (e.preventDefault) { e.preventDefault(); }
1292  else { e.returnValue = false; }
1293}
1294function e_stopPropagation(e) {
1295  if (e.stopPropagation) { e.stopPropagation(); }
1296  else { e.cancelBubble = true; }
1297}
1298function e_defaultPrevented(e) {
1299  return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false
1300}
1301function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}
1302
1303function e_target(e) {return e.target || e.srcElement}
1304function e_button(e) {
1305  var b = e.which;
1306  if (b == null) {
1307    if (e.button & 1) { b = 1; }
1308    else if (e.button & 2) { b = 3; }
1309    else if (e.button & 4) { b = 2; }
1310  }
1311  if (mac && e.ctrlKey && b == 1) { b = 3; }
1312  return b
1313}
1314
1315// Detect drag-and-drop
1316var dragAndDrop = function() {
1317  // There is *some* kind of drag-and-drop support in IE6-8, but I
1318  // couldn't get it to work yet.
1319  if (ie && ie_version < 9) { return false }
1320  var div = elt('div');
1321  return "draggable" in div || "dragDrop" in div
1322}();
1323
1324var zwspSupported;
1325function zeroWidthElement(measure) {
1326  if (zwspSupported == null) {
1327    var test = elt("span", "\u200b");
1328    removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]));
1329    if (measure.firstChild.offsetHeight != 0)
1330      { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); }
1331  }
1332  var node = zwspSupported ? elt("span", "\u200b") :
1333    elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px");
1334  node.setAttribute("cm-text", "");
1335  return node
1336}
1337
1338// Feature-detect IE's crummy client rect reporting for bidi text
1339var badBidiRects;
1340function hasBadBidiRects(measure) {
1341  if (badBidiRects != null) { return badBidiRects }
1342  var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"));
1343  var r0 = range(txt, 0, 1).getBoundingClientRect();
1344  var r1 = range(txt, 1, 2).getBoundingClientRect();
1345  removeChildren(measure);
1346  if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)
1347  return badBidiRects = (r1.right - r0.right < 3)
1348}
1349
1350// See if "".split is the broken IE version, if so, provide an
1351// alternative way to split lines.
1352var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {
1353  var pos = 0, result = [], l = string.length;
1354  while (pos <= l) {
1355    var nl = string.indexOf("\n", pos);
1356    if (nl == -1) { nl = string.length; }
1357    var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl);
1358    var rt = line.indexOf("\r");
1359    if (rt != -1) {
1360      result.push(line.slice(0, rt));
1361      pos += rt + 1;
1362    } else {
1363      result.push(line);
1364      pos = nl + 1;
1365    }
1366  }
1367  return result
1368} : function (string) { return string.split(/\r\n?|\n/); };
1369
1370var hasSelection = window.getSelection ? function (te) {
1371  try { return te.selectionStart != te.selectionEnd }
1372  catch(e) { return false }
1373} : function (te) {
1374  var range$$1;
1375  try {range$$1 = te.ownerDocument.selection.createRange();}
1376  catch(e) {}
1377  if (!range$$1 || range$$1.parentElement() != te) { return false }
1378  return range$$1.compareEndPoints("StartToEnd", range$$1) != 0
1379};
1380
1381var hasCopyEvent = (function () {
1382  var e = elt("div");
1383  if ("oncopy" in e) { return true }
1384  e.setAttribute("oncopy", "return;");
1385  return typeof e.oncopy == "function"
1386})();
1387
1388var badZoomedRects = null;
1389function hasBadZoomedRects(measure) {
1390  if (badZoomedRects != null) { return badZoomedRects }
1391  var node = removeChildrenAndAdd(measure, elt("span", "x"));
1392  var normal = node.getBoundingClientRect();
1393  var fromRange = range(node, 0, 1).getBoundingClientRect();
1394  return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1
1395}
1396
1397// Known modes, by name and by MIME
1398var modes = {};
1399var mimeModes = {};
1400
1401// Extra arguments are stored as the mode's dependencies, which is
1402// used by (legacy) mechanisms like loadmode.js to automatically
1403// load a mode. (Preferred mechanism is the require/define calls.)
1404function defineMode(name, mode) {
1405  if (arguments.length > 2)
1406    { mode.dependencies = Array.prototype.slice.call(arguments, 2); }
1407  modes[name] = mode;
1408}
1409
1410function defineMIME(mime, spec) {
1411  mimeModes[mime] = spec;
1412}
1413
1414// Given a MIME type, a {name, ...options} config object, or a name
1415// string, return a mode config object.
1416function resolveMode(spec) {
1417  if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
1418    spec = mimeModes[spec];
1419  } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
1420    var found = mimeModes[spec.name];
1421    if (typeof found == "string") { found = {name: found}; }
1422    spec = createObj(found, spec);
1423    spec.name = found.name;
1424  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
1425    return resolveMode("application/xml")
1426  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {
1427    return resolveMode("application/json")
1428  }
1429  if (typeof spec == "string") { return {name: spec} }
1430  else { return spec || {name: "null"} }
1431}
1432
1433// Given a mode spec (anything that resolveMode accepts), find and
1434// initialize an actual mode object.
1435function getMode(options, spec) {
1436  spec = resolveMode(spec);
1437  var mfactory = modes[spec.name];
1438  if (!mfactory) { return getMode(options, "text/plain") }
1439  var modeObj = mfactory(options, spec);
1440  if (modeExtensions.hasOwnProperty(spec.name)) {
1441    var exts = modeExtensions[spec.name];
1442    for (var prop in exts) {
1443      if (!exts.hasOwnProperty(prop)) { continue }
1444      if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop]; }
1445      modeObj[prop] = exts[prop];
1446    }
1447  }
1448  modeObj.name = spec.name;
1449  if (spec.helperType) { modeObj.helperType = spec.helperType; }
1450  if (spec.modeProps) { for (var prop$1 in spec.modeProps)
1451    { modeObj[prop$1] = spec.modeProps[prop$1]; } }
1452
1453  return modeObj
1454}
1455
1456// This can be used to attach properties to mode objects from
1457// outside the actual mode definition.
1458var modeExtensions = {};
1459function extendMode(mode, properties) {
1460  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});
1461  copyObj(properties, exts);
1462}
1463
1464function copyState(mode, state) {
1465  if (state === true) { return state }
1466  if (mode.copyState) { return mode.copyState(state) }
1467  var nstate = {};
1468  for (var n in state) {
1469    var val = state[n];
1470    if (val instanceof Array) { val = val.concat([]); }
1471    nstate[n] = val;
1472  }
1473  return nstate
1474}
1475
1476// Given a mode and a state (for that mode), find the inner mode and
1477// state at the position that the state refers to.
1478function innerMode(mode, state) {
1479  var info;
1480  while (mode.innerMode) {
1481    info = mode.innerMode(state);
1482    if (!info || info.mode == mode) { break }
1483    state = info.state;
1484    mode = info.mode;
1485  }
1486  return info || {mode: mode, state: state}
1487}
1488
1489function startState(mode, a1, a2) {
1490  return mode.startState ? mode.startState(a1, a2) : true
1491}
1492
1493// STRING STREAM
1494
1495// Fed to the mode parsers, provides helper functions to make
1496// parsers more succinct.
1497
1498var StringStream = function(string, tabSize, lineOracle) {
1499  this.pos = this.start = 0;
1500  this.string = string;
1501  this.tabSize = tabSize || 8;
1502  this.lastColumnPos = this.lastColumnValue = 0;
1503  this.lineStart = 0;
1504  this.lineOracle = lineOracle;
1505};
1506
1507StringStream.prototype.eol = function () {return this.pos >= this.string.length};
1508StringStream.prototype.sol = function () {return this.pos == this.lineStart};
1509StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};
1510StringStream.prototype.next = function () {
1511  if (this.pos < this.string.length)
1512    { return this.string.charAt(this.pos++) }
1513};
1514StringStream.prototype.eat = function (match) {
1515  var ch = this.string.charAt(this.pos);
1516  var ok;
1517  if (typeof match == "string") { ok = ch == match; }
1518  else { ok = ch && (match.test ? match.test(ch) : match(ch)); }
1519  if (ok) {++this.pos; return ch}
1520};
1521StringStream.prototype.eatWhile = function (match) {
1522  var start = this.pos;
1523  while (this.eat(match)){}
1524  return this.pos > start
1525};
1526StringStream.prototype.eatSpace = function () {
1527    var this$1 = this;
1528
1529  var start = this.pos;
1530  while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos; }
1531  return this.pos > start
1532};
1533StringStream.prototype.skipToEnd = function () {this.pos = this.string.length;};
1534StringStream.prototype.skipTo = function (ch) {
1535  var found = this.string.indexOf(ch, this.pos);
1536  if (found > -1) {this.pos = found; return true}
1537};
1538StringStream.prototype.backUp = function (n) {this.pos -= n;};
1539StringStream.prototype.column = function () {
1540  if (this.lastColumnPos < this.start) {
1541    this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
1542    this.lastColumnPos = this.start;
1543  }
1544  return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
1545};
1546StringStream.prototype.indentation = function () {
1547  return countColumn(this.string, null, this.tabSize) -
1548    (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
1549};
1550StringStream.prototype.match = function (pattern, consume, caseInsensitive) {
1551  if (typeof pattern == "string") {
1552    var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; };
1553    var substr = this.string.substr(this.pos, pattern.length);
1554    if (cased(substr) == cased(pattern)) {
1555      if (consume !== false) { this.pos += pattern.length; }
1556      return true
1557    }
1558  } else {
1559    var match = this.string.slice(this.pos).match(pattern);
1560    if (match && match.index > 0) { return null }
1561    if (match && consume !== false) { this.pos += match[0].length; }
1562    return match
1563  }
1564};
1565StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};
1566StringStream.prototype.hideFirstChars = function (n, inner) {
1567  this.lineStart += n;
1568  try { return inner() }
1569  finally { this.lineStart -= n; }
1570};
1571StringStream.prototype.lookAhead = function (n) {
1572  var oracle = this.lineOracle;
1573  return oracle && oracle.lookAhead(n)
1574};
1575
1576var SavedContext = function(state, lookAhead) {
1577  this.state = state;
1578  this.lookAhead = lookAhead;
1579};
1580
1581var Context = function(doc, state, line, lookAhead) {
1582  this.state = state;
1583  this.doc = doc;
1584  this.line = line;
1585  this.maxLookAhead = lookAhead || 0;
1586};
1587
1588Context.prototype.lookAhead = function (n) {
1589  var line = this.doc.getLine(this.line + n);
1590  if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n; }
1591  return line
1592};
1593
1594Context.prototype.nextLine = function () {
1595  this.line++;
1596  if (this.maxLookAhead > 0) { this.maxLookAhead--; }
1597};
1598
1599Context.fromSaved = function (doc, saved, line) {
1600  if (saved instanceof SavedContext)
1601    { return new Context(doc, copyState(doc.mode, saved.saved), line, saved.lookAhead) }
1602  else
1603    { return new Context(doc, copyState(doc.mode, saved), line) }
1604};
1605
1606Context.prototype.save = function (copy) {
1607  var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state;
1608  return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state
1609};
1610
1611
1612// Compute a style array (an array starting with a mode generation
1613// -- for invalidation -- followed by pairs of end positions and
1614// style strings), which is used to highlight the tokens on the
1615// line.
1616function highlightLine(cm, line, context, forceToEnd) {
1617  // A styles array always starts with a number identifying the
1618  // mode/overlays that it is based on (for easy invalidation).
1619  var st = [cm.state.modeGen], lineClasses = {};
1620  // Compute the base array of styles
1621  runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); },
1622          lineClasses, forceToEnd);
1623  var state = context.state;
1624
1625  // Run overlays, adjust style array.
1626  var loop = function ( o ) {
1627    var overlay = cm.state.overlays[o], i = 1, at = 0;
1628    context.state = true;
1629    runMode(cm, line.text, overlay.mode, context, function (end, style) {
1630      var start = i;
1631      // Ensure there's a token end at the current position, and that i points at it
1632      while (at < end) {
1633        var i_end = st[i];
1634        if (i_end > end)
1635          { st.splice(i, 1, end, st[i+1], i_end); }
1636        i += 2;
1637        at = Math.min(end, i_end);
1638      }
1639      if (!style) { return }
1640      if (overlay.opaque) {
1641        st.splice(start, i - start, end, "overlay " + style);
1642        i = start + 2;
1643      } else {
1644        for (; start < i; start += 2) {
1645          var cur = st[start+1];
1646          st[start+1] = (cur ? cur + " " : "") + "overlay " + style;
1647        }
1648      }
1649    }, lineClasses);
1650  };
1651
1652  for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );
1653  context.state = state;
1654
1655  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
1656}
1657
1658function getLineStyles(cm, line, updateFrontier) {
1659  if (!line.styles || line.styles[0] != cm.state.modeGen) {
1660    var context = getContextBefore(cm, lineNo(line));
1661    var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state);
1662    var result = highlightLine(cm, line, context);
1663    if (resetState) { context.state = resetState; }
1664    line.stateAfter = context.save(!resetState);
1665    line.styles = result.styles;
1666    if (result.classes) { line.styleClasses = result.classes; }
1667    else if (line.styleClasses) { line.styleClasses = null; }
1668    if (updateFrontier === cm.doc.highlightFrontier)
1669      { cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier); }
1670  }
1671  return line.styles
1672}
1673
1674function getContextBefore(cm, n, precise) {
1675  var doc = cm.doc, display = cm.display;
1676  if (!doc.mode.startState) { return new Context(doc, true, n) }
1677  var start = findStartLine(cm, n, precise);
1678  var saved = start > doc.first && getLine(doc, start - 1).stateAfter;
1679  var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start);
1680
1681  doc.iter(start, n, function (line) {
1682    processLine(cm, line.text, context);
1683    var pos = context.line;
1684    line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null;
1685    context.nextLine();
1686  });
1687  if (precise) { doc.modeFrontier = context.line; }
1688  return context
1689}
1690
1691// Lightweight form of highlight -- proceed over this line and
1692// update state, but don't save a style array. Used for lines that
1693// aren't currently visible.
1694function processLine(cm, text, context, startAt) {
1695  var mode = cm.doc.mode;
1696  var stream = new StringStream(text, cm.options.tabSize, context);
1697  stream.start = stream.pos = startAt || 0;
1698  if (text == "") { callBlankLine(mode, context.state); }
1699  while (!stream.eol()) {
1700    readToken(mode, stream, context.state);
1701    stream.start = stream.pos;
1702  }
1703}
1704
1705function callBlankLine(mode, state) {
1706  if (mode.blankLine) { return mode.blankLine(state) }
1707  if (!mode.innerMode) { return }
1708  var inner = innerMode(mode, state);
1709  if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }
1710}
1711
1712function readToken(mode, stream, state, inner) {
1713  for (var i = 0; i < 10; i++) {
1714    if (inner) { inner[0] = innerMode(mode, state).mode; }
1715    var style = mode.token(stream, state);
1716    if (stream.pos > stream.start) { return style }
1717  }
1718  throw new Error("Mode " + mode.name + " failed to advance stream.")
1719}
1720
1721var Token = function(stream, type, state) {
1722  this.start = stream.start; this.end = stream.pos;
1723  this.string = stream.current();
1724  this.type = type || null;
1725  this.state = state;
1726};
1727
1728// Utility for getTokenAt and getLineTokens
1729function takeToken(cm, pos, precise, asArray) {
1730  var doc = cm.doc, mode = doc.mode, style;
1731  pos = clipPos(doc, pos);
1732  var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise);
1733  var stream = new StringStream(line.text, cm.options.tabSize, context), tokens;
1734  if (asArray) { tokens = []; }
1735  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
1736    stream.start = stream.pos;
1737    style = readToken(mode, stream, context.state);
1738    if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))); }
1739  }
1740  return asArray ? tokens : new Token(stream, style, context.state)
1741}
1742
1743function extractLineClasses(type, output) {
1744  if (type) { for (;;) {
1745    var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/);
1746    if (!lineClass) { break }
1747    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);
1748    var prop = lineClass[1] ? "bgClass" : "textClass";
1749    if (output[prop] == null)
1750      { output[prop] = lineClass[2]; }
1751    else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
1752      { output[prop] += " " + lineClass[2]; }
1753  } }
1754  return type
1755}
1756
1757// Run the given mode's parser over a line, calling f for each token.
1758function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {
1759  var flattenSpans = mode.flattenSpans;
1760  if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans; }
1761  var curStart = 0, curStyle = null;
1762  var stream = new StringStream(text, cm.options.tabSize, context), style;
1763  var inner = cm.options.addModeClass && [null];
1764  if (text == "") { extractLineClasses(callBlankLine(mode, context.state), lineClasses); }
1765  while (!stream.eol()) {
1766    if (stream.pos > cm.options.maxHighlightLength) {
1767      flattenSpans = false;
1768      if (forceToEnd) { processLine(cm, text, context, stream.pos); }
1769      stream.pos = text.length;
1770      style = null;
1771    } else {
1772      style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses);
1773    }
1774    if (inner) {
1775      var mName = inner[0].name;
1776      if (mName) { style = "m-" + (style ? mName + " " + style : mName); }
1777    }
1778    if (!flattenSpans || curStyle != style) {
1779      while (curStart < stream.start) {
1780        curStart = Math.min(stream.start, curStart + 5000);
1781        f(curStart, curStyle);
1782      }
1783      curStyle = style;
1784    }
1785    stream.start = stream.pos;
1786  }
1787  while (curStart < stream.pos) {
1788    // Webkit seems to refuse to render text nodes longer than 57444
1789    // characters, and returns inaccurate measurements in nodes
1790    // starting around 5000 chars.
1791    var pos = Math.min(stream.pos, curStart + 5000);
1792    f(pos, curStyle);
1793    curStart = pos;
1794  }
1795}
1796
1797// Finds the line to start with when starting a parse. Tries to
1798// find a line with a stateAfter, so that it can start with a
1799// valid state. If that fails, it returns the line with the
1800// smallest indentation, which tends to need the least context to
1801// parse correctly.
1802function findStartLine(cm, n, precise) {
1803  var minindent, minline, doc = cm.doc;
1804  var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);
1805  for (var search = n; search > lim; --search) {
1806    if (search <= doc.first) { return doc.first }
1807    var line = getLine(doc, search - 1), after = line.stateAfter;
1808    if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier))
1809      { return search }
1810    var indented = countColumn(line.text, null, cm.options.tabSize);
1811    if (minline == null || minindent > indented) {
1812      minline = search - 1;
1813      minindent = indented;
1814    }
1815  }
1816  return minline
1817}
1818
1819function retreatFrontier(doc, n) {
1820  doc.modeFrontier = Math.min(doc.modeFrontier, n);
1821  if (doc.highlightFrontier < n - 10) { return }
1822  var start = doc.first;
1823  for (var line = n - 1; line > start; line--) {
1824    var saved = getLine(doc, line).stateAfter;
1825    // change is on 3
1826    // state on line 1 looked ahead 2 -- so saw 3
1827    // test 1 + 2 < 3 should cover this
1828    if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) {
1829      start = line + 1;
1830      break
1831    }
1832  }
1833  doc.highlightFrontier = Math.min(doc.highlightFrontier, start);
1834}
1835
1836// LINE DATA STRUCTURE
1837
1838// Line objects. These hold state related to a line, including
1839// highlighting info (the styles array).
1840var Line = function(text, markedSpans, estimateHeight) {
1841  this.text = text;
1842  attachMarkedSpans(this, markedSpans);
1843  this.height = estimateHeight ? estimateHeight(this) : 1;
1844};
1845
1846Line.prototype.lineNo = function () { return lineNo(this) };
1847eventMixin(Line);
1848
1849// Change the content (text, markers) of a line. Automatically
1850// invalidates cached information and tries to re-estimate the
1851// line's height.
1852function updateLine(line, text, markedSpans, estimateHeight) {
1853  line.text = text;
1854  if (line.stateAfter) { line.stateAfter = null; }
1855  if (line.styles) { line.styles = null; }
1856  if (line.order != null) { line.order = null; }
1857  detachMarkedSpans(line);
1858  attachMarkedSpans(line, markedSpans);
1859  var estHeight = estimateHeight ? estimateHeight(line) : 1;
1860  if (estHeight != line.height) { updateLineHeight(line, estHeight); }
1861}
1862
1863// Detach a line from the document tree and its markers.
1864function cleanUpLine(line) {
1865  line.parent = null;
1866  detachMarkedSpans(line);
1867}
1868
1869// Convert a style as returned by a mode (either null, or a string
1870// containing one or more styles) to a CSS style. This is cached,
1871// and also looks for line-wide styles.
1872var styleToClassCache = {};
1873var styleToClassCacheWithMode = {};
1874function interpretTokenStyle(style, options) {
1875  if (!style || /^\s*$/.test(style)) { return null }
1876  var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;
1877  return cache[style] ||
1878    (cache[style] = style.replace(/\S+/g, "cm-$&"))
1879}
1880
1881// Render the DOM representation of the text of a line. Also builds
1882// up a 'line map', which points at the DOM nodes that represent
1883// specific stretches of text, and is used by the measuring code.
1884// The returned object contains the DOM node, this map, and
1885// information about line-wide styles that were set by the mode.
1886function buildLineContent(cm, lineView) {
1887  // The padding-right forces the element to have a 'border', which
1888  // is needed on Webkit to be able to get line-level bounding
1889  // rectangles for it (in measureChar).
1890  var content = eltP("span", null, null, webkit ? "padding-right: .1px" : null);
1891  var builder = {pre: eltP("pre", [content], "CodeMirror-line"), content: content,
1892                 col: 0, pos: 0, cm: cm,
1893                 trailingSpace: false,
1894                 splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")};
1895  lineView.measure = {};
1896
1897  // Iterate over the logical lines that make up this visual line.
1898  for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
1899    var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0);
1900    builder.pos = 0;
1901    builder.addToken = buildToken;
1902    // Optionally wire in some hacks into the token-rendering
1903    // algorithm, to deal with browser quirks.
1904    if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction)))
1905      { builder.addToken = buildTokenBadBidi(builder.addToken, order); }
1906    builder.map = [];
1907    var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);
1908    insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));
1909    if (line.styleClasses) {
1910      if (line.styleClasses.bgClass)
1911        { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || ""); }
1912      if (line.styleClasses.textClass)
1913        { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || ""); }
1914    }
1915
1916    // Ensure at least a single node is present, for measuring.
1917    if (builder.map.length == 0)
1918      { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))); }
1919
1920    // Store the map and a cache object for the current logical line
1921    if (i == 0) {
1922      lineView.measure.map = builder.map;
1923      lineView.measure.cache = {};
1924    } else {
1925      (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
1926      ;(lineView.measure.caches || (lineView.measure.caches = [])).push({});
1927    }
1928  }
1929
1930  // See issue #2901
1931  if (webkit) {
1932    var last = builder.content.lastChild;
1933    if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
1934      { builder.content.className = "cm-tab-wrap-hack"; }
1935  }
1936
1937  signal(cm, "renderLine", cm, lineView.line, builder.pre);
1938  if (builder.pre.className)
1939    { builder.textClass = joinClasses(builder.pre.className, builder.textClass || ""); }
1940
1941  return builder
1942}
1943
1944function defaultSpecialCharPlaceholder(ch) {
1945  var token = elt("span", "\u2022", "cm-invalidchar");
1946  token.title = "\\u" + ch.charCodeAt(0).toString(16);
1947  token.setAttribute("aria-label", token.title);
1948  return token
1949}
1950
1951// Build up the DOM representation for a single token, and add it to
1952// the line map. Takes care to render special characters separately.
1953function buildToken(builder, text, style, startStyle, endStyle, title, css) {
1954  if (!text) { return }
1955  var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text;
1956  var special = builder.cm.state.specialChars, mustWrap = false;
1957  var content;
1958  if (!special.test(text)) {
1959    builder.col += text.length;
1960    content = document.createTextNode(displayText);
1961    builder.map.push(builder.pos, builder.pos + text.length, content);
1962    if (ie && ie_version < 9) { mustWrap = true; }
1963    builder.pos += text.length;
1964  } else {
1965    content = document.createDocumentFragment();
1966    var pos = 0;
1967    while (true) {
1968      special.lastIndex = pos;
1969      var m = special.exec(text);
1970      var skipped = m ? m.index - pos : text.length - pos;
1971      if (skipped) {
1972        var txt = document.createTextNode(displayText.slice(pos, pos + skipped));
1973        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])); }
1974        else { content.appendChild(txt); }
1975        builder.map.push(builder.pos, builder.pos + skipped, txt);
1976        builder.col += skipped;
1977        builder.pos += skipped;
1978      }
1979      if (!m) { break }
1980      pos += skipped + 1;
1981      var txt$1 = (void 0);
1982      if (m[0] == "\t") {
1983        var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;
1984        txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"));
1985        txt$1.setAttribute("role", "presentation");
1986        txt$1.setAttribute("cm-text", "\t");
1987        builder.col += tabWidth;
1988      } else if (m[0] == "\r" || m[0] == "\n") {
1989        txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"));
1990        txt$1.setAttribute("cm-text", m[0]);
1991        builder.col += 1;
1992      } else {
1993        txt$1 = builder.cm.options.specialCharPlaceholder(m[0]);
1994        txt$1.setAttribute("cm-text", m[0]);
1995        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])); }
1996        else { content.appendChild(txt$1); }
1997        builder.col += 1;
1998      }
1999      builder.map.push(builder.pos, builder.pos + 1, txt$1);
2000      builder.pos++;
2001    }
2002  }
2003  builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32;
2004  if (style || startStyle || endStyle || mustWrap || css) {
2005    var fullStyle = style || "";
2006    if (startStyle) { fullStyle += startStyle; }
2007    if (endStyle) { fullStyle += endStyle; }
2008    var token = elt("span", [content], fullStyle, css);
2009    if (title) { token.title = title; }
2010    return builder.content.appendChild(token)
2011  }
2012  builder.content.appendChild(content);
2013}
2014
2015function splitSpaces(text, trailingBefore) {
2016  if (text.length > 1 && !/  /.test(text)) { return text }
2017  var spaceBefore = trailingBefore, result = "";
2018  for (var i = 0; i < text.length; i++) {
2019    var ch = text.charAt(i);
2020    if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
2021      { ch = "\u00a0"; }
2022    result += ch;
2023    spaceBefore = ch == " ";
2024  }
2025  return result
2026}
2027
2028// Work around nonsense dimensions being reported for stretches of
2029// right-to-left text.
2030function buildTokenBadBidi(inner, order) {
2031  return function (builder, text, style, startStyle, endStyle, title, css) {
2032    style = style ? style + " cm-force-border" : "cm-force-border";
2033    var start = builder.pos, end = start + text.length;
2034    for (;;) {
2035      // Find the part that overlaps with the start of this text
2036      var part = (void 0);
2037      for (var i = 0; i < order.length; i++) {
2038        part = order[i];
2039        if (part.to > start && part.from <= start) { break }
2040      }
2041      if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }
2042      inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css);
2043      startStyle = null;
2044      text = text.slice(part.to - start);
2045      start = part.to;
2046    }
2047  }
2048}
2049
2050function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
2051  var widget = !ignoreWidget && marker.widgetNode;
2052  if (widget) { builder.map.push(builder.pos, builder.pos + size, widget); }
2053  if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
2054    if (!widget)
2055      { widget = builder.content.appendChild(document.createElement("span")); }
2056    widget.setAttribute("cm-marker", marker.id);
2057  }
2058  if (widget) {
2059    builder.cm.display.input.setUneditable(widget);
2060    builder.content.appendChild(widget);
2061  }
2062  builder.pos += size;
2063  builder.trailingSpace = false;
2064}
2065
2066// Outputs a number of spans to make up a line, taking highlighting
2067// and marked text into account.
2068function insertLineContent(line, builder, styles) {
2069  var spans = line.markedSpans, allText = line.text, at = 0;
2070  if (!spans) {
2071    for (var i$1 = 1; i$1 < styles.length; i$1+=2)
2072      { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)); }
2073    return
2074  }
2075
2076  var len = allText.length, pos = 0, i = 1, text = "", style, css;
2077  var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed;
2078  for (;;) {
2079    if (nextChange == pos) { // Update current marker set
2080      spanStyle = spanEndStyle = spanStartStyle = title = css = "";
2081      collapsed = null; nextChange = Infinity;
2082      var foundBookmarks = [], endStyles = (void 0);
2083      for (var j = 0; j < spans.length; ++j) {
2084        var sp = spans[j], m = sp.marker;
2085        if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
2086          foundBookmarks.push(m);
2087        } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
2088          if (sp.to != null && sp.to != pos && nextChange > sp.to) {
2089            nextChange = sp.to;
2090            spanEndStyle = "";
2091          }
2092          if (m.className) { spanStyle += " " + m.className; }
2093          if (m.css) { css = (css ? css + ";" : "") + m.css; }
2094          if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle; }
2095          if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to); }
2096          if (m.title && !title) { title = m.title; }
2097          if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
2098            { collapsed = sp; }
2099        } else if (sp.from > pos && nextChange > sp.from) {
2100          nextChange = sp.from;
2101        }
2102      }
2103      if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)
2104        { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1]; } } }
2105
2106      if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)
2107        { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]); } }
2108      if (collapsed && (collapsed.from || 0) == pos) {
2109        buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
2110                           collapsed.marker, collapsed.from == null);
2111        if (collapsed.to == null) { return }
2112        if (collapsed.to == pos) { collapsed = false; }
2113      }
2114    }
2115    if (pos >= len) { break }
2116
2117    var upto = Math.min(len, nextChange);
2118    while (true) {
2119      if (text) {
2120        var end = pos + text.length;
2121        if (!collapsed) {
2122          var tokenText = end > upto ? text.slice(0, upto - pos) : text;
2123          builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
2124                           spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css);
2125        }
2126        if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}
2127        pos = end;
2128        spanStartStyle = "";
2129      }
2130      text = allText.slice(at, at = styles[i++]);
2131      style = interpretTokenStyle(styles[i++], builder.cm.options);
2132    }
2133  }
2134}
2135
2136
2137// These objects are used to represent the visible (currently drawn)
2138// part of the document. A LineView may correspond to multiple
2139// logical lines, if those are connected by collapsed ranges.
2140function LineView(doc, line, lineN) {
2141  // The starting line
2142  this.line = line;
2143  // Continuing lines, if any
2144  this.rest = visualLineContinued(line);
2145  // Number of logical lines in this visual line
2146  this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
2147  this.node = this.text = null;
2148  this.hidden = lineIsHidden(doc, line);
2149}
2150
2151// Create a range of LineView objects for the given lines.
2152function buildViewArray(cm, from, to) {
2153  var array = [], nextPos;
2154  for (var pos = from; pos < to; pos = nextPos) {
2155    var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);
2156    nextPos = pos + view.size;
2157    array.push(view);
2158  }
2159  return array
2160}
2161
2162var operationGroup = null;
2163
2164function pushOperation(op) {
2165  if (operationGroup) {
2166    operationGroup.ops.push(op);
2167  } else {
2168    op.ownsGroup = operationGroup = {
2169      ops: [op],
2170      delayedCallbacks: []
2171    };
2172  }
2173}
2174
2175function fireCallbacksForOps(group) {
2176  // Calls delayed callbacks and cursorActivity handlers until no
2177  // new ones appear
2178  var callbacks = group.delayedCallbacks, i = 0;
2179  do {
2180    for (; i < callbacks.length; i++)
2181      { callbacks[i].call(null); }
2182    for (var j = 0; j < group.ops.length; j++) {
2183      var op = group.ops[j];
2184      if (op.cursorActivityHandlers)
2185        { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
2186          { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm); } }
2187    }
2188  } while (i < callbacks.length)
2189}
2190
2191function finishOperation(op, endCb) {
2192  var group = op.ownsGroup;
2193  if (!group) { return }
2194
2195  try { fireCallbacksForOps(group); }
2196  finally {
2197    operationGroup = null;
2198    endCb(group);
2199  }
2200}
2201
2202var orphanDelayedCallbacks = null;
2203
2204// Often, we want to signal events at a point where we are in the
2205// middle of some work, but don't want the handler to start calling
2206// other methods on the editor, which might be in an inconsistent
2207// state or simply not expect any other events to happen.
2208// signalLater looks whether there are any handlers, and schedules
2209// them to be executed when the last operation ends, or, if no
2210// operation is active, when a timeout fires.
2211function signalLater(emitter, type /*, values...*/) {
2212  var arr = getHandlers(emitter, type);
2213  if (!arr.length) { return }
2214  var args = Array.prototype.slice.call(arguments, 2), list;
2215  if (operationGroup) {
2216    list = operationGroup.delayedCallbacks;
2217  } else if (orphanDelayedCallbacks) {
2218    list = orphanDelayedCallbacks;
2219  } else {
2220    list = orphanDelayedCallbacks = [];
2221    setTimeout(fireOrphanDelayed, 0);
2222  }
2223  var loop = function ( i ) {
2224    list.push(function () { return arr[i].apply(null, args); });
2225  };
2226
2227  for (var i = 0; i < arr.length; ++i)
2228    loop( i );
2229}
2230
2231function fireOrphanDelayed() {
2232  var delayed = orphanDelayedCallbacks;
2233  orphanDelayedCallbacks = null;
2234  for (var i = 0; i < delayed.length; ++i) { delayed[i](); }
2235}
2236
2237// When an aspect of a line changes, a string is added to
2238// lineView.changes. This updates the relevant part of the line's
2239// DOM structure.
2240function updateLineForChanges(cm, lineView, lineN, dims) {
2241  for (var j = 0; j < lineView.changes.length; j++) {
2242    var type = lineView.changes[j];
2243    if (type == "text") { updateLineText(cm, lineView); }
2244    else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims); }
2245    else if (type == "class") { updateLineClasses(cm, lineView); }
2246    else if (type == "widget") { updateLineWidgets(cm, lineView, dims); }
2247  }
2248  lineView.changes = null;
2249}
2250
2251// Lines with gutter elements, widgets or a background class need to
2252// be wrapped, and have the extra elements added to the wrapper div
2253function ensureLineWrapped(lineView) {
2254  if (lineView.node == lineView.text) {
2255    lineView.node = elt("div", null, null, "position: relative");
2256    if (lineView.text.parentNode)
2257      { lineView.text.parentNode.replaceChild(lineView.node, lineView.text); }
2258    lineView.node.appendChild(lineView.text);
2259    if (ie && ie_version < 8) { lineView.node.style.zIndex = 2; }
2260  }
2261  return lineView.node
2262}
2263
2264function updateLineBackground(cm, lineView) {
2265  var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass;
2266  if (cls) { cls += " CodeMirror-linebackground"; }
2267  if (lineView.background) {
2268    if (cls) { lineView.background.className = cls; }
2269    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; }
2270  } else if (cls) {
2271    var wrap = ensureLineWrapped(lineView);
2272    lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild);
2273    cm.display.input.setUneditable(lineView.background);
2274  }
2275}
2276
2277// Wrapper around buildLineContent which will reuse the structure
2278// in display.externalMeasured when possible.
2279function getLineContent(cm, lineView) {
2280  var ext = cm.display.externalMeasured;
2281  if (ext && ext.line == lineView.line) {
2282    cm.display.externalMeasured = null;
2283    lineView.measure = ext.measure;
2284    return ext.built
2285  }
2286  return buildLineContent(cm, lineView)
2287}
2288
2289// Redraw the line's text. Interacts with the background and text
2290// classes because the mode may output tokens that influence these
2291// classes.
2292function updateLineText(cm, lineView) {
2293  var cls = lineView.text.className;
2294  var built = getLineContent(cm, lineView);
2295  if (lineView.text == lineView.node) { lineView.node = built.pre; }
2296  lineView.text.parentNode.replaceChild(built.pre, lineView.text);
2297  lineView.text = built.pre;
2298  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
2299    lineView.bgClass = built.bgClass;
2300    lineView.textClass = built.textClass;
2301    updateLineClasses(cm, lineView);
2302  } else if (cls) {
2303    lineView.text.className = cls;
2304  }
2305}
2306
2307function updateLineClasses(cm, lineView) {
2308  updateLineBackground(cm, lineView);
2309  if (lineView.line.wrapClass)
2310    { ensureLineWrapped(lineView).className = lineView.line.wrapClass; }
2311  else if (lineView.node != lineView.text)
2312    { lineView.node.className = ""; }
2313  var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass;
2314  lineView.text.className = textClass || "";
2315}
2316
2317function updateLineGutter(cm, lineView, lineN, dims) {
2318  if (lineView.gutter) {
2319    lineView.node.removeChild(lineView.gutter);
2320    lineView.gutter = null;
2321  }
2322  if (lineView.gutterBackground) {
2323    lineView.node.removeChild(lineView.gutterBackground);
2324    lineView.gutterBackground = null;
2325  }
2326  if (lineView.line.gutterClass) {
2327    var wrap = ensureLineWrapped(lineView);
2328    lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
2329                                    ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px"));
2330    cm.display.input.setUneditable(lineView.gutterBackground);
2331    wrap.insertBefore(lineView.gutterBackground, lineView.text);
2332  }
2333  var markers = lineView.line.gutterMarkers;
2334  if (cm.options.lineNumbers || markers) {
2335    var wrap$1 = ensureLineWrapped(lineView);
2336    var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"));
2337    cm.display.input.setUneditable(gutterWrap);
2338    wrap$1.insertBefore(gutterWrap, lineView.text);
2339    if (lineView.line.gutterClass)
2340      { gutterWrap.className += " " + lineView.line.gutterClass; }
2341    if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
2342      { lineView.lineNumber = gutterWrap.appendChild(
2343        elt("div", lineNumberFor(cm.options, lineN),
2344            "CodeMirror-linenumber CodeMirror-gutter-elt",
2345            ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))); }
2346    if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {
2347      var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];
2348      if (found)
2349        { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt",
2350                                   ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))); }
2351    } }
2352  }
2353}
2354
2355function updateLineWidgets(cm, lineView, dims) {
2356  if (lineView.alignable) { lineView.alignable = null; }
2357  for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {
2358    next = node.nextSibling;
2359    if (node.className == "CodeMirror-linewidget")
2360      { lineView.node.removeChild(node); }
2361  }
2362  insertLineWidgets(cm, lineView, dims);
2363}
2364
2365// Build a line's DOM representation from scratch
2366function buildLineElement(cm, lineView, lineN, dims) {
2367  var built = getLineContent(cm, lineView);
2368  lineView.text = lineView.node = built.pre;
2369  if (built.bgClass) { lineView.bgClass = built.bgClass; }
2370  if (built.textClass) { lineView.textClass = built.textClass; }
2371
2372  updateLineClasses(cm, lineView);
2373  updateLineGutter(cm, lineView, lineN, dims);
2374  insertLineWidgets(cm, lineView, dims);
2375  return lineView.node
2376}
2377
2378// A lineView may contain multiple logical lines (when merged by
2379// collapsed spans). The widgets for all of them need to be drawn.
2380function insertLineWidgets(cm, lineView, dims) {
2381  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
2382  if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
2383    { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false); } }
2384}
2385
2386function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
2387  if (!line.widgets) { return }
2388  var wrap = ensureLineWrapped(lineView);
2389  for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
2390    var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget");
2391    if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true"); }
2392    positionLineWidget(widget, node, lineView, dims);
2393    cm.display.input.setUneditable(node);
2394    if (allowAbove && widget.above)
2395      { wrap.insertBefore(node, lineView.gutter || lineView.text); }
2396    else
2397      { wrap.appendChild(node); }
2398    signalLater(widget, "redraw");
2399  }
2400}
2401
2402function positionLineWidget(widget, node, lineView, dims) {
2403  if (widget.noHScroll) {
2404    (lineView.alignable || (lineView.alignable = [])).push(node);
2405    var width = dims.wrapperWidth;
2406    node.style.left = dims.fixedPos + "px";
2407    if (!widget.coverGutter) {
2408      width -= dims.gutterTotalWidth;
2409      node.style.paddingLeft = dims.gutterTotalWidth + "px";
2410    }
2411    node.style.width = width + "px";
2412  }
2413  if (widget.coverGutter) {
2414    node.style.zIndex = 5;
2415    node.style.position = "relative";
2416    if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px"; }
2417  }
2418}
2419
2420function widgetHeight(widget) {
2421  if (widget.height != null) { return widget.height }
2422  var cm = widget.doc.cm;
2423  if (!cm) { return 0 }
2424  if (!contains(document.body, widget.node)) {
2425    var parentStyle = "position: relative;";
2426    if (widget.coverGutter)
2427      { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;"; }
2428    if (widget.noHScroll)
2429      { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;"; }
2430    removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle));
2431  }
2432  return widget.height = widget.node.parentNode.offsetHeight
2433}
2434
2435// Return true when the given mouse event happened in a widget
2436function eventInWidget(display, e) {
2437  for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
2438    if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
2439        (n.parentNode == display.sizer && n != display.mover))
2440      { return true }
2441  }
2442}
2443
2444// POSITION MEASUREMENT
2445
2446function paddingTop(display) {return display.lineSpace.offsetTop}
2447function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}
2448function paddingH(display) {
2449  if (display.cachedPaddingH) { return display.cachedPaddingH }
2450  var e = removeChildrenAndAdd(display.measure, elt("pre", "x"));
2451  var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;
2452  var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)};
2453  if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data; }
2454  return data
2455}
2456
2457function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
2458function displayWidth(cm) {
2459  return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth
2460}
2461function displayHeight(cm) {
2462  return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight
2463}
2464
2465// Ensure the lineView.wrapping.heights array is populated. This is
2466// an array of bottom offsets for the lines that make up a drawn
2467// line. When lineWrapping is on, there might be more than one
2468// height.
2469function ensureLineHeights(cm, lineView, rect) {
2470  var wrapping = cm.options.lineWrapping;
2471  var curWidth = wrapping && displayWidth(cm);
2472  if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
2473    var heights = lineView.measure.heights = [];
2474    if (wrapping) {
2475      lineView.measure.width = curWidth;
2476      var rects = lineView.text.firstChild.getClientRects();
2477      for (var i = 0; i < rects.length - 1; i++) {
2478        var cur = rects[i], next = rects[i + 1];
2479        if (Math.abs(cur.bottom - next.bottom) > 2)
2480          { heights.push((cur.bottom + next.top) / 2 - rect.top); }
2481      }
2482    }
2483    heights.push(rect.bottom - rect.top);
2484  }
2485}
2486
2487// Find a line map (mapping character offsets to text nodes) and a
2488// measurement cache for the given line number. (A line view might
2489// contain multiple lines when collapsed ranges are present.)
2490function mapFromLineView(lineView, line, lineN) {
2491  if (lineView.line == line)
2492    { return {map: lineView.measure.map, cache: lineView.measure.cache} }
2493  for (var i = 0; i < lineView.rest.length; i++)
2494    { if (lineView.rest[i] == line)
2495      { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }
2496  for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)
2497    { if (lineNo(lineView.rest[i$1]) > lineN)
2498      { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }
2499}
2500
2501// Render a line into the hidden node display.externalMeasured. Used
2502// when measurement is needed for a line that's not in the viewport.
2503function updateExternalMeasurement(cm, line) {
2504  line = visualLine(line);
2505  var lineN = lineNo(line);
2506  var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);
2507  view.lineN = lineN;
2508  var built = view.built = buildLineContent(cm, view);
2509  view.text = built.pre;
2510  removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
2511  return view
2512}
2513
2514// Get a {top, bottom, left, right} box (in line-local coordinates)
2515// for a given character.
2516function measureChar(cm, line, ch, bias) {
2517  return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)
2518}
2519
2520// Find a line view that corresponds to the given line number.
2521function findViewForLine(cm, lineN) {
2522  if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
2523    { return cm.display.view[findViewIndex(cm, lineN)] }
2524  var ext = cm.display.externalMeasured;
2525  if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
2526    { return ext }
2527}
2528
2529// Measurement can be split in two steps, the set-up work that
2530// applies to the whole line, and the measurement of the actual
2531// character. Functions like coordsChar, that need to do a lot of
2532// measurements in a row, can thus ensure that the set-up work is
2533// only done once.
2534function prepareMeasureForLine(cm, line) {
2535  var lineN = lineNo(line);
2536  var view = findViewForLine(cm, lineN);
2537  if (view && !view.text) {
2538    view = null;
2539  } else if (view && view.changes) {
2540    updateLineForChanges(cm, view, lineN, getDimensions(cm));
2541    cm.curOp.forceUpdate = true;
2542  }
2543  if (!view)
2544    { view = updateExternalMeasurement(cm, line); }
2545
2546  var info = mapFromLineView(view, line, lineN);
2547  return {
2548    line: line, view: view, rect: null,
2549    map: info.map, cache: info.cache, before: info.before,
2550    hasHeights: false
2551  }
2552}
2553
2554// Given a prepared measurement object, measures the position of an
2555// actual character (or fetches it from the cache).
2556function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
2557  if (prepared.before) { ch = -1; }
2558  var key = ch + (bias || ""), found;
2559  if (prepared.cache.hasOwnProperty(key)) {
2560    found = prepared.cache[key];
2561  } else {
2562    if (!prepared.rect)
2563      { prepared.rect = prepared.view.text.getBoundingClientRect(); }
2564    if (!prepared.hasHeights) {
2565      ensureLineHeights(cm, prepared.view, prepared.rect);
2566      prepared.hasHeights = true;
2567    }
2568    found = measureCharInner(cm, prepared, ch, bias);
2569    if (!found.bogus) { prepared.cache[key] = found; }
2570  }
2571  return {left: found.left, right: found.right,
2572          top: varHeight ? found.rtop : found.top,
2573          bottom: varHeight ? found.rbottom : found.bottom}
2574}
2575
2576var nullRect = {left: 0, right: 0, top: 0, bottom: 0};
2577
2578function nodeAndOffsetInLineMap(map$$1, ch, bias) {
2579  var node, start, end, collapse, mStart, mEnd;
2580  // First, search the line map for the text node corresponding to,
2581  // or closest to, the target character.
2582  for (var i = 0; i < map$$1.length; i += 3) {
2583    mStart = map$$1[i];
2584    mEnd = map$$1[i + 1];
2585    if (ch < mStart) {
2586      start = 0; end = 1;
2587      collapse = "left";
2588    } else if (ch < mEnd) {
2589      start = ch - mStart;
2590      end = start + 1;
2591    } else if (i == map$$1.length - 3 || ch == mEnd && map$$1[i + 3] > ch) {
2592      end = mEnd - mStart;
2593      start = end - 1;
2594      if (ch >= mEnd) { collapse = "right"; }
2595    }
2596    if (start != null) {
2597      node = map$$1[i + 2];
2598      if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
2599        { collapse = bias; }
2600      if (bias == "left" && start == 0)
2601        { while (i && map$$1[i - 2] == map$$1[i - 3] && map$$1[i - 1].insertLeft) {
2602          node = map$$1[(i -= 3) + 2];
2603          collapse = "left";
2604        } }
2605      if (bias == "right" && start == mEnd - mStart)
2606        { while (i < map$$1.length - 3 && map$$1[i + 3] == map$$1[i + 4] && !map$$1[i + 5].insertLeft) {
2607          node = map$$1[(i += 3) + 2];
2608          collapse = "right";
2609        } }
2610      break
2611    }
2612  }
2613  return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}
2614}
2615
2616function getUsefulRect(rects, bias) {
2617  var rect = nullRect;
2618  if (bias == "left") { for (var i = 0; i < rects.length; i++) {
2619    if ((rect = rects[i]).left != rect.right) { break }
2620  } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {
2621    if ((rect = rects[i$1]).left != rect.right) { break }
2622  } }
2623  return rect
2624}
2625
2626function measureCharInner(cm, prepared, ch, bias) {
2627  var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);
2628  var node = place.node, start = place.start, end = place.end, collapse = place.collapse;
2629
2630  var rect;
2631  if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
2632    for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned
2633      while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start; }
2634      while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end; }
2635      if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
2636        { rect = node.parentNode.getBoundingClientRect(); }
2637      else
2638        { rect = getUsefulRect(range(node, start, end).getClientRects(), bias); }
2639      if (rect.left || rect.right || start == 0) { break }
2640      end = start;
2641      start = start - 1;
2642      collapse = "right";
2643    }
2644    if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect); }
2645  } else { // If it is a widget, simply get the box for the whole widget.
2646    if (start > 0) { collapse = bias = "right"; }
2647    var rects;
2648    if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
2649      { rect = rects[bias == "right" ? rects.length - 1 : 0]; }
2650    else
2651      { rect = node.getBoundingClientRect(); }
2652  }
2653  if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
2654    var rSpan = node.parentNode.getClientRects()[0];
2655    if (rSpan)
2656      { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom}; }
2657    else
2658      { rect = nullRect; }
2659  }
2660
2661  var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top;
2662  var mid = (rtop + rbot) / 2;
2663  var heights = prepared.view.measure.heights;
2664  var i = 0;
2665  for (; i < heights.length - 1; i++)
2666    { if (mid < heights[i]) { break } }
2667  var top = i ? heights[i - 1] : 0, bot = heights[i];
2668  var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
2669                right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
2670                top: top, bottom: bot};
2671  if (!rect.left && !rect.right) { result.bogus = true; }
2672  if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; }
2673
2674  return result
2675}
2676
2677// Work around problem with bounding client rects on ranges being
2678// returned incorrectly when zoomed on IE10 and below.
2679function maybeUpdateRectForZooming(measure, rect) {
2680  if (!window.screen || screen.logicalXDPI == null ||
2681      screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
2682    { return rect }
2683  var scaleX = screen.logicalXDPI / screen.deviceXDPI;
2684  var scaleY = screen.logicalYDPI / screen.deviceYDPI;
2685  return {left: rect.left * scaleX, right: rect.right * scaleX,
2686          top: rect.top * scaleY, bottom: rect.bottom * scaleY}
2687}
2688
2689function clearLineMeasurementCacheFor(lineView) {
2690  if (lineView.measure) {
2691    lineView.measure.cache = {};
2692    lineView.measure.heights = null;
2693    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
2694      { lineView.measure.caches[i] = {}; } }
2695  }
2696}
2697
2698function clearLineMeasurementCache(cm) {
2699  cm.display.externalMeasure = null;
2700  removeChildren(cm.display.lineMeasure);
2701  for (var i = 0; i < cm.display.view.length; i++)
2702    { clearLineMeasurementCacheFor(cm.display.view[i]); }
2703}
2704
2705function clearCaches(cm) {
2706  clearLineMeasurementCache(cm);
2707  cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;
2708  if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true; }
2709  cm.display.lineNumChars = null;
2710}
2711
2712function pageScrollX() {
2713  // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206
2714  // which causes page_Offset and bounding client rects to use
2715  // different reference viewports and invalidate our calculations.
2716  if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) }
2717  return window.pageXOffset || (document.documentElement || document.body).scrollLeft
2718}
2719function pageScrollY() {
2720  if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) }
2721  return window.pageYOffset || (document.documentElement || document.body).scrollTop
2722}
2723
2724// Converts a {top, bottom, left, right} box from line-local
2725// coordinates into another coordinate system. Context may be one of
2726// "line", "div" (display.lineDiv), "local"./null (editor), "window",
2727// or "page".
2728function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
2729  if (!includeWidgets && lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) {
2730    var size = widgetHeight(lineObj.widgets[i]);
2731    rect.top += size; rect.bottom += size;
2732  } } }
2733  if (context == "line") { return rect }
2734  if (!context) { context = "local"; }
2735  var yOff = heightAtLine(lineObj);
2736  if (context == "local") { yOff += paddingTop(cm.display); }
2737  else { yOff -= cm.display.viewOffset; }
2738  if (context == "page" || context == "window") {
2739    var lOff = cm.display.lineSpace.getBoundingClientRect();
2740    yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
2741    var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
2742    rect.left += xOff; rect.right += xOff;
2743  }
2744  rect.top += yOff; rect.bottom += yOff;
2745  return rect
2746}
2747
2748// Coverts a box from "div" coords to another coordinate system.
2749// Context may be "window", "page", "div", or "local"./null.
2750function fromCoordSystem(cm, coords, context) {
2751  if (context == "div") { return coords }
2752  var left = coords.left, top = coords.top;
2753  // First move into "page" coordinate system
2754  if (context == "page") {
2755    left -= pageScrollX();
2756    top -= pageScrollY();
2757  } else if (context == "local" || !context) {
2758    var localBox = cm.display.sizer.getBoundingClientRect();
2759    left += localBox.left;
2760    top += localBox.top;
2761  }
2762
2763  var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
2764  return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}
2765}
2766
2767function charCoords(cm, pos, context, lineObj, bias) {
2768  if (!lineObj) { lineObj = getLine(cm.doc, pos.line); }
2769  return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)
2770}
2771
2772// Returns a box for a given cursor position, which may have an
2773// 'other' property containing the position of the secondary cursor
2774// on a bidi boundary.
2775// A cursor Pos(line, char, "before") is on the same visual line as `char - 1`
2776// and after `char - 1` in writing order of `char - 1`
2777// A cursor Pos(line, char, "after") is on the same visual line as `char`
2778// and before `char` in writing order of `char`
2779// Examples (upper-case letters are RTL, lower-case are LTR):
2780//     Pos(0, 1, ...)
2781//     before   after
2782// ab     a|b     a|b
2783// aB     a|B     aB|
2784// Ab     |Ab     A|b
2785// AB     B|A     B|A
2786// Every position after the last character on a line is considered to stick
2787// to the last character on the line.
2788function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
2789  lineObj = lineObj || getLine(cm.doc, pos.line);
2790  if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); }
2791  function get(ch, right) {
2792    var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight);
2793    if (right) { m.left = m.right; } else { m.right = m.left; }
2794    return intoCoordSystem(cm, lineObj, m, context)
2795  }
2796  var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky;
2797  if (ch >= lineObj.text.length) {
2798    ch = lineObj.text.length;
2799    sticky = "before";
2800  } else if (ch <= 0) {
2801    ch = 0;
2802    sticky = "after";
2803  }
2804  if (!order) { return get(sticky == "before" ? ch - 1 : ch, sticky == "before") }
2805
2806  function getBidi(ch, partPos, invert) {
2807    var part = order[partPos], right = (part.level % 2) != 0;
2808    return get(invert ? ch - 1 : ch, right != invert)
2809  }
2810  var partPos = getBidiPartAt(order, ch, sticky);
2811  var other = bidiOther;
2812  var val = getBidi(ch, partPos, sticky == "before");
2813  if (other != null) { val.other = getBidi(ch, other, sticky != "before"); }
2814  return val
2815}
2816
2817// Used to cheaply estimate the coordinates for a position. Used for
2818// intermediate scroll updates.
2819function estimateCoords(cm, pos) {
2820  var left = 0;
2821  pos = clipPos(cm.doc, pos);
2822  if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch; }
2823  var lineObj = getLine(cm.doc, pos.line);
2824  var top = heightAtLine(lineObj) + paddingTop(cm.display);
2825  return {left: left, right: left, top: top, bottom: top + lineObj.height}
2826}
2827
2828// Positions returned by coordsChar contain some extra information.
2829// xRel is the relative x position of the input coordinates compared
2830// to the found position (so xRel > 0 means the coordinates are to
2831// the right of the character position, for example). When outside
2832// is true, that means the coordinates lie outside the line's
2833// vertical range.
2834function PosWithInfo(line, ch, sticky, outside, xRel) {
2835  var pos = Pos(line, ch, sticky);
2836  pos.xRel = xRel;
2837  if (outside) { pos.outside = true; }
2838  return pos
2839}
2840
2841// Compute the character position closest to the given coordinates.
2842// Input must be lineSpace-local ("div" coordinate system).
2843function coordsChar(cm, x, y) {
2844  var doc = cm.doc;