kampos
Version:
Tiny and fast effects compositor on WebGL
1,460 lines (1,354 loc) • 525 kB
JavaScript
// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE
// This is CodeMirror (https://codemirror.net), a code editor
// implemented in JavaScript on top of the browser's DOM.
//
// You can find some technical background for some of the code below
// at http://marijnhaverbeke.nl/blog/#cm-internals .
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined'
? (module.exports = factory())
: typeof define === 'function' && define.amd
? define(factory)
: (global.CodeMirror = factory());
})(this, function () {
'use strict';
// Kludges for bugs and behavior differences that can't be feature
// detected are enabled based on userAgent etc sniffing.
var userAgent = navigator.userAgent;
var platform = navigator.platform;
var gecko = /gecko\/\d/i.test(userAgent);
var ie_upto10 = /MSIE \d/.test(userAgent);
var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
var edge = /Edge\/(\d+)/.exec(userAgent);
var ie = ie_upto10 || ie_11up || edge;
var ie_version =
ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);
var webkit = !edge && /WebKit\//.test(userAgent);
var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
var chrome = !edge && /Chrome\//.test(userAgent);
var presto = /Opera\//.test(userAgent);
var safari = /Apple Computer/.test(navigator.vendor);
var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent);
var phantom = /PhantomJS/.test(userAgent);
var ios =
!edge && /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent);
var android = /Android/.test(userAgent);
// This is woefully incomplete. Suggestions for alternative methods welcome.
var mobile =
ios ||
android ||
/webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
var mac = ios || /Mac/.test(platform);
var chromeOS = /\bCrOS\b/.test(userAgent);
var windows = /win/i.test(platform);
var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
if (presto_version) {
presto_version = Number(presto_version[1]);
}
if (presto_version && presto_version >= 15) {
presto = false;
webkit = true;
}
// Some browsers use the wrong event properties to signal cmd/ctrl on OS X
var flipCtrlCmd =
mac &&
(qtwebkit ||
(presto && (presto_version == null || presto_version < 12.11)));
var captureRightClick = gecko || (ie && ie_version >= 9);
function classTest(cls) {
return new RegExp('(^|\\s)' + cls + '(?:$|\\s)\\s*');
}
var rmClass = function (node, cls) {
var current = node.className;
var match = classTest(cls).exec(current);
if (match) {
var after = current.slice(match.index + match[0].length);
node.className =
current.slice(0, match.index) + (after ? match[1] + after : '');
}
};
function removeChildren(e) {
for (var count = e.childNodes.length; count > 0; --count) {
e.removeChild(e.firstChild);
}
return e;
}
function removeChildrenAndAdd(parent, e) {
return removeChildren(parent).appendChild(e);
}
function elt(tag, content, className, style) {
var e = document.createElement(tag);
if (className) {
e.className = className;
}
if (style) {
e.style.cssText = style;
}
if (typeof content == 'string') {
e.appendChild(document.createTextNode(content));
} else if (content) {
for (var i = 0; i < content.length; ++i) {
e.appendChild(content[i]);
}
}
return e;
}
// wrapper for elt, which removes the elt from the accessibility tree
function eltP(tag, content, className, style) {
var e = elt(tag, content, className, style);
e.setAttribute('role', 'presentation');
return e;
}
var range;
if (document.createRange) {
range = function (node, start, end, endNode) {
var r = document.createRange();
r.setEnd(endNode || node, end);
r.setStart(node, start);
return r;
};
} else {
range = function (node, start, end) {
var r = document.body.createTextRange();
try {
r.moveToElementText(node.parentNode);
} catch (e) {
return r;
}
r.collapse(true);
r.moveEnd('character', end);
r.moveStart('character', start);
return r;
};
}
function contains(parent, child) {
if (child.nodeType == 3) {
// Android browser always returns false when child is a textnode
child = child.parentNode;
}
if (parent.contains) {
return parent.contains(child);
}
do {
if (child.nodeType == 11) {
child = child.host;
}
if (child == parent) {
return true;
}
} while ((child = child.parentNode));
}
function activeElt() {
// IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
// IE < 10 will throw when accessed while the page is loading or in an iframe.
// IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
var activeElement;
try {
activeElement = document.activeElement;
} catch (e) {
activeElement = document.body || null;
}
while (
activeElement &&
activeElement.shadowRoot &&
activeElement.shadowRoot.activeElement
) {
activeElement = activeElement.shadowRoot.activeElement;
}
return activeElement;
}
function addClass(node, cls) {
var current = node.className;
if (!classTest(cls).test(current)) {
node.className += (current ? ' ' : '') + cls;
}
}
function joinClasses(a, b) {
var as = a.split(' ');
for (var i = 0; i < as.length; i++) {
if (as[i] && !classTest(as[i]).test(b)) {
b += ' ' + as[i];
}
}
return b;
}
var selectInput = function (node) {
node.select();
};
if (ios) {
// Mobile Safari apparently has a bug where select() is broken.
selectInput = function (node) {
node.selectionStart = 0;
node.selectionEnd = node.value.length;
};
} else if (ie) {
// Suppress mysterious IE10 errors
selectInput = function (node) {
try {
node.select();
} catch (_e) {}
};
}
function bind(f) {
var args = Array.prototype.slice.call(arguments, 1);
return function () {
return f.apply(null, args);
};
}
function copyObj(obj, target, overwrite) {
if (!target) {
target = {};
}
for (var prop in obj) {
if (
obj.hasOwnProperty(prop) &&
(overwrite !== false || !target.hasOwnProperty(prop))
) {
target[prop] = obj[prop];
}
}
return target;
}
// Counts the column offset in a string, taking tabs into account.
// Used mostly to find indentation.
function countColumn(string, end, tabSize, startIndex, startValue) {
if (end == null) {
end = string.search(/[^\s\u00a0]/);
if (end == -1) {
end = string.length;
}
}
for (var i = startIndex || 0, n = startValue || 0; ; ) {
var nextTab = string.indexOf('\t', i);
if (nextTab < 0 || nextTab >= end) {
return n + (end - i);
}
n += nextTab - i;
n += tabSize - (n % tabSize);
i = nextTab + 1;
}
}
var Delayed = function () {
this.id = null;
};
Delayed.prototype.set = function (ms, f) {
clearTimeout(this.id);
this.id = setTimeout(f, ms);
};
function indexOf(array, elt) {
for (var i = 0; i < array.length; ++i) {
if (array[i] == elt) {
return i;
}
}
return -1;
}
// Number of pixels added to scroller and sizer to hide scrollbar
var scrollerGap = 30;
// Returned or thrown by various protocols to signal 'I'm not
// handling this'.
var Pass = {
toString: function () {
return 'CodeMirror.Pass';
},
};
// Reused option objects for setSelection & friends
var sel_dontScroll = { scroll: false },
sel_mouse = { origin: '*mouse' },
sel_move = { origin: '+move' };
// The inverse of countColumn -- find the offset that corresponds to
// a particular column.
function findColumn(string, goal, tabSize) {
for (var pos = 0, col = 0; ; ) {
var nextTab = string.indexOf('\t', pos);
if (nextTab == -1) {
nextTab = string.length;
}
var skipped = nextTab - pos;
if (nextTab == string.length || col + skipped >= goal) {
return pos + Math.min(skipped, goal - col);
}
col += nextTab - pos;
col += tabSize - (col % tabSize);
pos = nextTab + 1;
if (col >= goal) {
return pos;
}
}
}
var spaceStrs = [''];
function spaceStr(n) {
while (spaceStrs.length <= n) {
spaceStrs.push(lst(spaceStrs) + ' ');
}
return spaceStrs[n];
}
function lst(arr) {
return arr[arr.length - 1];
}
function map(array, f) {
var out = [];
for (var i = 0; i < array.length; i++) {
out[i] = f(array[i], i);
}
return out;
}
function insertSorted(array, value, score) {
var pos = 0,
priority = score(value);
while (pos < array.length && score(array[pos]) <= priority) {
pos++;
}
array.splice(pos, 0, value);
}
function nothing() {}
function createObj(base, props) {
var inst;
if (Object.create) {
inst = Object.create(base);
} else {
nothing.prototype = base;
inst = new nothing();
}
if (props) {
copyObj(props, inst);
}
return inst;
}
var nonASCIISingleCaseWordChar =
/[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
function isWordCharBasic(ch) {
return (
/\w/.test(ch) ||
(ch > '\x80' &&
(ch.toUpperCase() != ch.toLowerCase() ||
nonASCIISingleCaseWordChar.test(ch)))
);
}
function isWordChar(ch, helper) {
if (!helper) {
return isWordCharBasic(ch);
}
if (helper.source.indexOf('\\w') > -1 && isWordCharBasic(ch)) {
return true;
}
return helper.test(ch);
}
function isEmpty(obj) {
for (var n in obj) {
if (obj.hasOwnProperty(n) && obj[n]) {
return false;
}
}
return true;
}
// Extending unicode characters. A series of a non-extending char +
// any number of extending chars is treated as a single unit as far
// as editing and measuring is concerned. This is not fully correct,
// since some scripts/fonts/browsers also treat other configurations
// of code points as a group.
var extendingChars =
/[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
function isExtendingChar(ch) {
return ch.charCodeAt(0) >= 768 && extendingChars.test(ch);
}
// Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.
function skipExtendingChars(str, pos, dir) {
while (
(dir < 0 ? pos > 0 : pos < str.length) &&
isExtendingChar(str.charAt(pos))
) {
pos += dir;
}
return pos;
}
// Returns the value from the range [`from`; `to`] that satisfies
// `pred` and is closest to `from`. Assumes that at least `to`
// satisfies `pred`. Supports `from` being greater than `to`.
function findFirst(pred, from, to) {
// At any point we are certain `to` satisfies `pred`, don't know
// whether `from` does.
var dir = from > to ? -1 : 1;
for (;;) {
if (from == to) {
return from;
}
var midF = (from + to) / 2,
mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);
if (mid == from) {
return pred(mid) ? from : to;
}
if (pred(mid)) {
to = mid;
} else {
from = mid + dir;
}
}
}
// BIDI HELPERS
function iterateBidiSections(order, from, to, f) {
if (!order) {
return f(from, to, 'ltr', 0);
}
var found = false;
for (var i = 0; i < order.length; ++i) {
var part = order[i];
if (
(part.from < to && part.to > from) ||
(from == to && part.to == from)
) {
f(
Math.max(part.from, from),
Math.min(part.to, to),
part.level == 1 ? 'rtl' : 'ltr',
i,
);
found = true;
}
}
if (!found) {
f(from, to, 'ltr');
}
}
var bidiOther = null;
function getBidiPartAt(order, ch, sticky) {
var found;
bidiOther = null;
for (var i = 0; i < order.length; ++i) {
var cur = order[i];
if (cur.from < ch && cur.to > ch) {
return i;
}
if (cur.to == ch) {
if (cur.from != cur.to && sticky == 'before') {
found = i;
} else {
bidiOther = i;
}
}
if (cur.from == ch) {
if (cur.from != cur.to && sticky != 'before') {
found = i;
} else {
bidiOther = i;
}
}
}
return found != null ? found : bidiOther;
}
// Bidirectional ordering algorithm
// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
// that this (partially) implements.
// One-char codes used for character types:
// L (L): Left-to-Right
// R (R): Right-to-Left
// r (AL): Right-to-Left Arabic
// 1 (EN): European Number
// + (ES): European Number Separator
// % (ET): European Number Terminator
// n (AN): Arabic Number
// , (CS): Common Number Separator
// m (NSM): Non-Spacing Mark
// b (BN): Boundary Neutral
// s (B): Paragraph Separator
// t (S): Segment Separator
// w (WS): Whitespace
// N (ON): Other Neutrals
// Returns null if characters are ordered as they appear
// (left-to-right), or an array of sections ({from, to, level}
// objects) in the order in which they occur visually.
var bidiOrdering = (function () {
// Character types for codepoints 0 to 0xff
var lowTypes =
'bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN';
// Character types for codepoints 0x600 to 0x6f9
var arabicTypes =
'nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111';
function charType(code) {
if (code <= 0xf7) {
return lowTypes.charAt(code);
} else if (0x590 <= code && code <= 0x5f4) {
return 'R';
} else if (0x600 <= code && code <= 0x6f9) {
return arabicTypes.charAt(code - 0x600);
} else if (0x6ee <= code && code <= 0x8ac) {
return 'r';
} else if (0x2000 <= code && code <= 0x200b) {
return 'w';
} else if (code == 0x200c) {
return 'b';
} else {
return 'L';
}
}
var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
var isNeutral = /[stwN]/,
isStrong = /[LRr]/,
countsAsLeft = /[Lb1n]/,
countsAsNum = /[1n]/;
function BidiSpan(level, from, to) {
this.level = level;
this.from = from;
this.to = to;
}
return function (str, direction) {
var outerType = direction == 'ltr' ? 'L' : 'R';
if (str.length == 0 || (direction == 'ltr' && !bidiRE.test(str))) {
return false;
}
var len = str.length,
types = [];
for (var i = 0; i < len; ++i) {
types.push(charType(str.charCodeAt(i)));
}
// W1. Examine each non-spacing mark (NSM) in the level run, and
// change the type of the NSM to the type of the previous
// character. If the NSM is at the start of the level run, it will
// get the type of sor.
for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
var type = types[i$1];
if (type == 'm') {
types[i$1] = prev;
} else {
prev = type;
}
}
// W2. Search backwards from each instance of a European number
// until the first strong type (R, L, AL, or sor) is found. If an
// AL is found, change the type of the European number to Arabic
// number.
// W3. Change all ALs to R.
for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
var type$1 = types[i$2];
if (type$1 == '1' && cur == 'r') {
types[i$2] = 'n';
} else if (isStrong.test(type$1)) {
cur = type$1;
if (type$1 == 'r') {
types[i$2] = 'R';
}
}
}
// W4. A single European separator between two European numbers
// changes to a European number. A single common separator between
// two numbers of the same type changes to that type.
for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
var type$2 = types[i$3];
if (type$2 == '+' && prev$1 == '1' && types[i$3 + 1] == '1') {
types[i$3] = '1';
} else if (
type$2 == ',' &&
prev$1 == types[i$3 + 1] &&
(prev$1 == '1' || prev$1 == 'n')
) {
types[i$3] = prev$1;
}
prev$1 = type$2;
}
// W5. A sequence of European terminators adjacent to European
// numbers changes to all European numbers.
// W6. Otherwise, separators and terminators change to Other
// Neutral.
for (var i$4 = 0; i$4 < len; ++i$4) {
var type$3 = types[i$4];
if (type$3 == ',') {
types[i$4] = 'N';
} else if (type$3 == '%') {
var end = void 0;
for (
end = i$4 + 1;
end < len && types[end] == '%';
++end
) {}
var replace =
(i$4 && types[i$4 - 1] == '!') ||
(end < len && types[end] == '1')
? '1'
: 'N';
for (var j = i$4; j < end; ++j) {
types[j] = replace;
}
i$4 = end - 1;
}
}
// W7. Search backwards from each instance of a European number
// until the first strong type (R, L, or sor) is found. If an L is
// found, then change the type of the European number to L.
for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
var type$4 = types[i$5];
if (cur$1 == 'L' && type$4 == '1') {
types[i$5] = 'L';
} else if (isStrong.test(type$4)) {
cur$1 = type$4;
}
}
// N1. A sequence of neutrals takes the direction of the
// surrounding strong text if the text on both sides has the same
// direction. European and Arabic numbers act as if they were R in
// terms of their influence on neutrals. Start-of-level-run (sor)
// and end-of-level-run (eor) are used at level run boundaries.
// N2. Any remaining neutrals take the embedding direction.
for (var i$6 = 0; i$6 < len; ++i$6) {
if (isNeutral.test(types[i$6])) {
var end$1 = void 0;
for (
end$1 = i$6 + 1;
end$1 < len && isNeutral.test(types[end$1]);
++end$1
) {}
var before = (i$6 ? types[i$6 - 1] : outerType) == 'L';
var after = (end$1 < len ? types[end$1] : outerType) == 'L';
var replace$1 =
before == after ? (before ? 'L' : 'R') : outerType;
for (var j$1 = i$6; j$1 < end$1; ++j$1) {
types[j$1] = replace$1;
}
i$6 = end$1 - 1;
}
}
// Here we depart from the documented algorithm, in order to avoid
// building up an actual levels array. Since there are only three
// levels (0, 1, 2) in an implementation that doesn't take
// explicit embedding into account, we can build up the order on
// the fly, without following the level-based algorithm.
var order = [],
m;
for (var i$7 = 0; i$7 < len; ) {
if (countsAsLeft.test(types[i$7])) {
var start = i$7;
for (
++i$7;
i$7 < len && countsAsLeft.test(types[i$7]);
++i$7
) {}
order.push(new BidiSpan(0, start, i$7));
} else {
var pos = i$7,
at = order.length;
for (++i$7; i$7 < len && types[i$7] != 'L'; ++i$7) {}
for (var j$2 = pos; j$2 < i$7; ) {
if (countsAsNum.test(types[j$2])) {
if (pos < j$2) {
order.splice(at, 0, new BidiSpan(1, pos, j$2));
}
var nstart = j$2;
for (
++j$2;
j$2 < i$7 && countsAsNum.test(types[j$2]);
++j$2
) {}
order.splice(at, 0, new BidiSpan(2, nstart, j$2));
pos = j$2;
} else {
++j$2;
}
}
if (pos < i$7) {
order.splice(at, 0, new BidiSpan(1, pos, i$7));
}
}
}
if (direction == 'ltr') {
if (order[0].level == 1 && (m = str.match(/^\s+/))) {
order[0].from = m[0].length;
order.unshift(new BidiSpan(0, 0, m[0].length));
}
if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
lst(order).to -= m[0].length;
order.push(new BidiSpan(0, len - m[0].length, len));
}
}
return direction == 'rtl' ? order.reverse() : order;
};
})();
// Get the bidi ordering for the given line (and cache it). Returns
// false for lines that are fully left-to-right, and an array of
// BidiSpan objects otherwise.
function getOrder(line, direction) {
var order = line.order;
if (order == null) {
order = line.order = bidiOrdering(line.text, direction);
}
return order;
}
// EVENT HANDLING
// Lightweight event framework. on/off also work on DOM nodes,
// registering native DOM handlers.
var noHandlers = [];
var on = function (emitter, type, f) {
if (emitter.addEventListener) {
emitter.addEventListener(type, f, false);
} else if (emitter.attachEvent) {
emitter.attachEvent('on' + type, f);
} else {
var map$$1 = emitter._handlers || (emitter._handlers = {});
map$$1[type] = (map$$1[type] || noHandlers).concat(f);
}
};
function getHandlers(emitter, type) {
return (emitter._handlers && emitter._handlers[type]) || noHandlers;
}
function off(emitter, type, f) {
if (emitter.removeEventListener) {
emitter.removeEventListener(type, f, false);
} else if (emitter.detachEvent) {
emitter.detachEvent('on' + type, f);
} else {
var map$$1 = emitter._handlers,
arr = map$$1 && map$$1[type];
if (arr) {
var index = indexOf(arr, f);
if (index > -1) {
map$$1[type] = arr
.slice(0, index)
.concat(arr.slice(index + 1));
}
}
}
}
function signal(emitter, type /*, values...*/) {
var handlers = getHandlers(emitter, type);
if (!handlers.length) {
return;
}
var args = Array.prototype.slice.call(arguments, 2);
for (var i = 0; i < handlers.length; ++i) {
handlers[i].apply(null, args);
}
}
// The DOM events that CodeMirror handles can be overridden by
// registering a (non-DOM) handler on the editor for the event name,
// and preventDefault-ing the event in that handler.
function signalDOMEvent(cm, e, override) {
if (typeof e == 'string') {
e = {
type: e,
preventDefault: function () {
this.defaultPrevented = true;
},
};
}
signal(cm, override || e.type, cm, e);
return e_defaultPrevented(e) || e.codemirrorIgnore;
}
function signalCursorActivity(cm) {
var arr = cm._handlers && cm._handlers.cursorActivity;
if (!arr) {
return;
}
var set =
cm.curOp.cursorActivityHandlers ||
(cm.curOp.cursorActivityHandlers = []);
for (var i = 0; i < arr.length; ++i) {
if (indexOf(set, arr[i]) == -1) {
set.push(arr[i]);
}
}
}
function hasHandler(emitter, type) {
return getHandlers(emitter, type).length > 0;
}
// Add on and off methods to a constructor's prototype, to make
// registering events on such objects more convenient.
function eventMixin(ctor) {
ctor.prototype.on = function (type, f) {
on(this, type, f);
};
ctor.prototype.off = function (type, f) {
off(this, type, f);
};
}
// Due to the fact that we still support jurassic IE versions, some
// compatibility wrappers are needed.
function e_preventDefault(e) {
if (e.preventDefault) {
e.preventDefault();
} else {
e.returnValue = false;
}
}
function e_stopPropagation(e) {
if (e.stopPropagation) {
e.stopPropagation();
} else {
e.cancelBubble = true;
}
}
function e_defaultPrevented(e) {
return e.defaultPrevented != null
? e.defaultPrevented
: e.returnValue == false;
}
function e_stop(e) {
e_preventDefault(e);
e_stopPropagation(e);
}
function e_target(e) {
return e.target || e.srcElement;
}
function e_button(e) {
var b = e.which;
if (b == null) {
if (e.button & 1) {
b = 1;
} else if (e.button & 2) {
b = 3;
} else if (e.button & 4) {
b = 2;
}
}
if (mac && e.ctrlKey && b == 1) {
b = 3;
}
return b;
}
// Detect drag-and-drop
var dragAndDrop = (function () {
// There is *some* kind of drag-and-drop support in IE6-8, but I
// couldn't get it to work yet.
if (ie && ie_version < 9) {
return false;
}
var div = elt('div');
return 'draggable' in div || 'dragDrop' in div;
})();
var zwspSupported;
function zeroWidthElement(measure) {
if (zwspSupported == null) {
var test = elt('span', '\u200b');
removeChildrenAndAdd(
measure,
elt('span', [test, document.createTextNode('x')]),
);
if (measure.firstChild.offsetHeight != 0) {
zwspSupported =
test.offsetWidth <= 1 &&
test.offsetHeight > 2 &&
!(ie && ie_version < 8);
}
}
var node = zwspSupported
? elt('span', '\u200b')
: elt(
'span',
'\u00a0',
null,
'display: inline-block; width: 1px; margin-right: -1px',
);
node.setAttribute('cm-text', '');
return node;
}
// Feature-detect IE's crummy client rect reporting for bidi text
var badBidiRects;
function hasBadBidiRects(measure) {
if (badBidiRects != null) {
return badBidiRects;
}
var txt = removeChildrenAndAdd(
measure,
document.createTextNode('A\u062eA'),
);
var r0 = range(txt, 0, 1).getBoundingClientRect();
var r1 = range(txt, 1, 2).getBoundingClientRect();
removeChildren(measure);
if (!r0 || r0.left == r0.right) {
return false;
} // Safari returns null in some cases (#2780)
return (badBidiRects = r1.right - r0.right < 3);
}
// See if "".split is the broken IE version, if so, provide an
// alternative way to split lines.
var splitLinesAuto =
'\n\nb'.split(/\n/).length != 3
? function (string) {
var pos = 0,
result = [],
l = string.length;
while (pos <= l) {
var nl = string.indexOf('\n', pos);
if (nl == -1) {
nl = string.length;
}
var line = string.slice(
pos,
string.charAt(nl - 1) == '\r' ? nl - 1 : nl,
);
var rt = line.indexOf('\r');
if (rt != -1) {
result.push(line.slice(0, rt));
pos += rt + 1;
} else {
result.push(line);
pos = nl + 1;
}
}
return result;
}
: function (string) {
return string.split(/\r\n?|\n/);
};
var hasSelection = window.getSelection
? function (te) {
try {
return te.selectionStart != te.selectionEnd;
} catch (e) {
return false;
}
}
: function (te) {
var range$$1;
try {
range$$1 = te.ownerDocument.selection.createRange();
} catch (e) {}
if (!range$$1 || range$$1.parentElement() != te) {
return false;
}
return range$$1.compareEndPoints('StartToEnd', range$$1) != 0;
};
var hasCopyEvent = (function () {
var e = elt('div');
if ('oncopy' in e) {
return true;
}
e.setAttribute('oncopy', 'return;');
return typeof e.oncopy == 'function';
})();
var badZoomedRects = null;
function hasBadZoomedRects(measure) {
if (badZoomedRects != null) {
return badZoomedRects;
}
var node = removeChildrenAndAdd(measure, elt('span', 'x'));
var normal = node.getBoundingClientRect();
var fromRange = range(node, 0, 1).getBoundingClientRect();
return (badZoomedRects = Math.abs(normal.left - fromRange.left) > 1);
}
// Known modes, by name and by MIME
var modes = {},
mimeModes = {};
// Extra arguments are stored as the mode's dependencies, which is
// used by (legacy) mechanisms like loadmode.js to automatically
// load a mode. (Preferred mechanism is the require/define calls.)
function defineMode(name, mode) {
if (arguments.length > 2) {
mode.dependencies = Array.prototype.slice.call(arguments, 2);
}
modes[name] = mode;
}
function defineMIME(mime, spec) {
mimeModes[mime] = spec;
}
// Given a MIME type, a {name, ...options} config object, or a name
// string, return a mode config object.
function resolveMode(spec) {
if (typeof spec == 'string' && mimeModes.hasOwnProperty(spec)) {
spec = mimeModes[spec];
} else if (
spec &&
typeof spec.name == 'string' &&
mimeModes.hasOwnProperty(spec.name)
) {
var found = mimeModes[spec.name];
if (typeof found == 'string') {
found = { name: found };
}
spec = createObj(found, spec);
spec.name = found.name;
} else if (
typeof spec == 'string' &&
/^[\w\-]+\/[\w\-]+\+xml$/.test(spec)
) {
return resolveMode('application/xml');
} else if (
typeof spec == 'string' &&
/^[\w\-]+\/[\w\-]+\+json$/.test(spec)
) {
return resolveMode('application/json');
}
if (typeof spec == 'string') {
return { name: spec };
} else {
return spec || { name: 'null' };
}
}
// Given a mode spec (anything that resolveMode accepts), find and
// initialize an actual mode object.
function getMode(options, spec) {
spec = resolveMode(spec);
var mfactory = modes[spec.name];
if (!mfactory) {
return getMode(options, 'text/plain');
}
var modeObj = mfactory(options, spec);
if (modeExtensions.hasOwnProperty(spec.name)) {
var exts = modeExtensions[spec.name];
for (var prop in exts) {
if (!exts.hasOwnProperty(prop)) {
continue;
}
if (modeObj.hasOwnProperty(prop)) {
modeObj['_' + prop] = modeObj[prop];
}
modeObj[prop] = exts[prop];
}
}
modeObj.name = spec.name;
if (spec.helperType) {
modeObj.helperType = spec.helperType;
}
if (spec.modeProps) {
for (var prop$1 in spec.modeProps) {
modeObj[prop$1] = spec.modeProps[prop$1];
}
}
return modeObj;
}
// This can be used to attach properties to mode objects from
// outside the actual mode definition.
var modeExtensions = {};
function extendMode(mode, properties) {
var exts = modeExtensions.hasOwnProperty(mode)
? modeExtensions[mode]
: (modeExtensions[mode] = {});
copyObj(properties, exts);
}
function copyState(mode, state) {
if (state === true) {
return state;
}
if (mode.copyState) {
return mode.copyState(state);
}
var nstate = {};
for (var n in state) {
var val = state[n];
if (val instanceof Array) {
val = val.concat([]);
}
nstate[n] = val;
}
return nstate;
}
// Given a mode and a state (for that mode), find the inner mode and
// state at the position that the state refers to.
function innerMode(mode, state) {
var info;
while (mode.innerMode) {
info = mode.innerMode(state);
if (!info || info.mode == mode) {
break;
}
state = info.state;
mode = info.mode;
}
return info || { mode: mode, state: state };
}
function startState(mode, a1, a2) {
return mode.startState ? mode.startState(a1, a2) : true;
}
// STRING STREAM
// Fed to the mode parsers, provides helper functions to make
// parsers more succinct.
var StringStream = function (string, tabSize, lineOracle) {
this.pos = this.start = 0;
this.string = string;
this.tabSize = tabSize || 8;
this.lastColumnPos = this.lastColumnValue = 0;
this.lineStart = 0;
this.lineOracle = lineOracle;
};
StringStream.prototype.eol = function () {
return this.pos >= this.string.length;
};
StringStream.prototype.sol = function () {
return this.pos == this.lineStart;
};
StringStream.prototype.peek = function () {
return this.string.charAt(this.pos) || undefined;
};
StringStream.prototype.next = function () {
if (this.pos < this.string.length) {
return this.string.charAt(this.pos++);
}
};
StringStream.prototype.eat = function (match) {
var ch = this.string.charAt(this.pos);
var ok;
if (typeof match == 'string') {
ok = ch == match;
} else {
ok = ch && (match.test ? match.test(ch) : match(ch));
}
if (ok) {
++this.pos;
return ch;
}
};
StringStream.prototype.eatWhile = function (match) {
var start = this.pos;
while (this.eat(match)) {}
return this.pos > start;
};
StringStream.prototype.eatSpace = function () {
var this$1 = this;
var start = this.pos;
while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) {
++this$1.pos;
}
return this.pos > start;
};
StringStream.prototype.skipToEnd = function () {
this.pos = this.string.length;
};
StringStream.prototype.skipTo = function (ch) {
var found = this.string.indexOf(ch, this.pos);
if (found > -1) {
this.pos = found;
return true;
}
};
StringStream.prototype.backUp = function (n) {
this.pos -= n;
};
StringStream.prototype.column = function () {
if (this.lastColumnPos < this.start) {
this.lastColumnValue = countColumn(
this.string,
this.start,
this.tabSize,
this.lastColumnPos,
this.lastColumnValue,
);
this.lastColumnPos = this.start;
}
return (
this.lastColumnValue -
(this.lineStart
? countColumn(this.string, this.lineStart, this.tabSize)
: 0)
);
};
StringStream.prototype.indentation = function () {
return (
countColumn(this.string, null, this.tabSize) -
(this.lineStart
? countColumn(this.string, this.lineStart, this.tabSize)
: 0)
);
};
StringStream.prototype.match = function (
pattern,
consume,
caseInsensitive,
) {
if (typeof pattern == 'string') {
var cased = function (str) {
return caseInsensitive ? str.toLowerCase() : str;
};
var substr = this.string.substr(this.pos, pattern.length);
if (cased(substr) == cased(pattern)) {
if (consume !== false) {
this.pos += pattern.length;
}
return true;
}
} else {
var match = this.string.slice(this.pos).match(pattern);
if (match && match.index > 0) {
return null;
}
if (match && consume !== false) {
this.pos += match[0].length;
}
return match;
}
};
StringStream.prototype.current = function () {
return this.string.slice(this.start, this.pos);
};
StringStream.prototype.hideFirstChars = function (n, inner) {
this.lineStart += n;
try {
return inner();
} finally {
this.lineStart -= n;
}
};
StringStream.prototype.lookAhead = function (n) {
var oracle = this.lineOracle;
return oracle && oracle.lookAhead(n);
};
StringStream.prototype.baseToken = function () {
var oracle = this.lineOracle;
return oracle && oracle.baseToken(this.pos);
};
// Find the line object corresponding to the given line number.
function getLine(doc, n) {
n -= doc.first;
if (n < 0 || n >= doc.size) {
throw new Error(
'There is no line ' + (n + doc.first) + ' in the document.',
);
}
var chunk = doc;
while (!chunk.lines) {
for (var i = 0; ; ++i) {
var child = chunk.children[i],
sz = child.chunkSize();
if (n < sz) {
chunk = child;
break;
}
n -= sz;
}
}
return chunk.lines[n];
}
// Get the part of a document between two positions, as an array of
// strings.
function getBetween(doc, start, end) {
var out = [],
n = start.line;
doc.iter(start.line, end.line + 1, function (line) {
var text = line.text;
if (n == end.line) {
text = text.slice(0, end.ch);
}
if (n == start.line) {
text = text.slice(start.ch);
}
out.push(text);
++n;
});
return out;
}
// Get the lines between from and to, as array of strings.
function getLines(doc, from, to) {
var out = [];
doc.iter(from, to, function (line) {
out.push(line.text);
}); // iter aborts when callback returns truthy value
return out;
}
// Update the height of a line, propagating the height change
// upwards to parent nodes.
function updateLineHeight(line, height) {
var diff = height - line.height;
if (diff) {
for (var n = line; n; n = n.parent) {
n.height += diff;
}
}
}
// Given a line object, find its line number by walking up through
// its parent links.
function lineNo(line) {
if (line.parent == null) {
return null;
}
var cur = line.parent,
no = indexOf(cur.lines, line);
for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
for (var i = 0; ; ++i) {
if (chunk.children[i] == cur) {
break;
}
no += chunk.children[i].chunkSize();
}
}
return no + cur.first;
}
// Find the line at the given vertical position, using the height
// information in the document tree.
function lineAtHeight(chunk, h) {
var n = chunk.first;
outer: do {
for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
var child = chunk.children[i$1],
ch = child.height;
if (h < ch) {
chunk = child;
continue outer;
}
h -= ch;
n += child.chunkSize();
}
return n;
} while (!chunk.lines);
var i = 0;
for (; i < chunk.lines.length; ++i) {
var line = chunk.lines[i],
lh = line.height;
if (h < lh) {
break;
}
h -= lh;
}
return n + i;
}
function isLine(doc, l) {
return l >= doc.first && l < doc.first + doc.size;
}
function lineNumberFor(options, i) {
return String(options.lineNumberFormatter(i + options.firstLineNumber));
}
// A Pos instance represents a position within the text.
function Pos(line, ch, sticky) {
if (sticky === void 0) sticky = null;
if (!(this instanceof Pos)) {
return new Pos(line, ch, sticky);
}
this.line = line;
this.ch = ch;
this.sticky = sticky;
}
// Compare two positions, return 0 if they are the same, a negative
// number when a is less, and a positive number otherwise.
function cmp(a, b) {
return a.line - b.line || a.ch - b.ch;
}
function equalCursorPos(a, b) {
return a.sticky == b.sticky && cmp(a, b) == 0;
}
function copyPos(x) {
return Pos(x.line, x.ch);
}
function maxPos(a, b) {
return cmp(a, b) < 0 ? b : a;
}
function minPos(a, b) {
return cmp(a, b) < 0 ? a : b;
}
// Most of the external API clips given positions to make sure they
// actually exist within the document.
function clipLine(doc, n) {
return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1));
}
function clipPos(doc, pos) {
if (pos.line < doc.first) {
return Pos(doc.first, 0);
}
var last = doc.first + doc.size - 1;
if (pos.line > last) {
return Pos(last, getLine(doc, last).text.length);
}
return clipToLen(pos, getLine(doc, pos.line).text.length);
}
function clipToLen(pos, linelen) {
var ch = pos.ch;
if (ch == null || ch > linelen) {
return Pos(pos.line, linelen);
} else if (ch < 0) {
return Pos(pos.line, 0);
} else {
return pos;
}
}
function clipPosArray(doc, array) {
var out = [];
for (var i = 0; i < array.length; i++) {
out[i] = clipPos(doc, array[i]);
}
return out;
}