\n\n\n\n\n\n\n\n// WEBPACK FOOTER //\n// src/js/module/components/secondaryMenu/secondaryMenu.vue","/*\n * Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport store from '@/conf/home/store'\nimport router from '@/conf/home/router'\n\nexport default {\n data () {\n return {\n router,\n store,\n isDetails: false\n }\n },\n created () {\n this.isDetails = this.store.state.dag.isDetails\n },\n methods: {\n },\n computed: {\n _isDetails () {\n return this.isDetails ? 'icon-disabled' : ''\n }\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/js/module/mixin/disabledState.js","// CodeMirror, copyright (c) by Marijn Haverbeke and others\n// Distributed under an MIT license: https://codemirror.net/LICENSE\n\n// This is CodeMirror (https://codemirror.net), a code editor\n// implemented in JavaScript on top of the browser's DOM.\n//\n// You can find some technical background for some of the code below\n// at http://marijnhaverbeke.nl/blog/#cm-internals .\n\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global.CodeMirror = factory());\n}(this, (function () { 'use strict';\n\n // Kludges for bugs and behavior differences that can't be feature\n // detected are enabled based on userAgent etc sniffing.\n var userAgent = navigator.userAgent;\n var platform = navigator.platform;\n\n var gecko = /gecko\\/\\d/i.test(userAgent);\n var ie_upto10 = /MSIE \\d/.test(userAgent);\n var ie_11up = /Trident\\/(?:[7-9]|\\d{2,})\\..*rv:(\\d+)/.exec(userAgent);\n var edge = /Edge\\/(\\d+)/.exec(userAgent);\n var ie = ie_upto10 || ie_11up || edge;\n var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);\n var webkit = !edge && /WebKit\\//.test(userAgent);\n var qtwebkit = webkit && /Qt\\/\\d+\\.\\d+/.test(userAgent);\n var chrome = !edge && /Chrome\\//.test(userAgent);\n var presto = /Opera\\//.test(userAgent);\n var safari = /Apple Computer/.test(navigator.vendor);\n var mac_geMountainLion = /Mac OS X 1\\d\\D([8-9]|\\d\\d)\\D/.test(userAgent);\n var phantom = /PhantomJS/.test(userAgent);\n\n var ios = !edge && /AppleWebKit/.test(userAgent) && /Mobile\\/\\w+/.test(userAgent);\n var android = /Android/.test(userAgent);\n // This is woefully incomplete. Suggestions for alternative methods welcome.\n var mobile = ios || android || /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);\n var mac = ios || /Mac/.test(platform);\n var chromeOS = /\\bCrOS\\b/.test(userAgent);\n var windows = /win/i.test(platform);\n\n var presto_version = presto && userAgent.match(/Version\\/(\\d*\\.\\d*)/);\n if (presto_version) { presto_version = Number(presto_version[1]); }\n if (presto_version && presto_version >= 15) { presto = false; webkit = true; }\n // Some browsers use the wrong event properties to signal cmd/ctrl on OS X\n var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11));\n var captureRightClick = gecko || (ie && ie_version >= 9);\n\n function classTest(cls) { return new RegExp(\"(^|\\\\s)\" + cls + \"(?:$|\\\\s)\\\\s*\") }\n\n var rmClass = function(node, cls) {\n var current = node.className;\n var match = classTest(cls).exec(current);\n if (match) {\n var after = current.slice(match.index + match[0].length);\n node.className = current.slice(0, match.index) + (after ? match[1] + after : \"\");\n }\n };\n\n function removeChildren(e) {\n for (var count = e.childNodes.length; count > 0; --count)\n { e.removeChild(e.firstChild); }\n return e\n }\n\n function removeChildrenAndAdd(parent, e) {\n return removeChildren(parent).appendChild(e)\n }\n\n function elt(tag, content, className, style) {\n var e = document.createElement(tag);\n if (className) { e.className = className; }\n if (style) { e.style.cssText = style; }\n if (typeof content == \"string\") { e.appendChild(document.createTextNode(content)); }\n else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]); } }\n return e\n }\n // wrapper for elt, which removes the elt from the accessibility tree\n function eltP(tag, content, className, style) {\n var e = elt(tag, content, className, style);\n e.setAttribute(\"role\", \"presentation\");\n return e\n }\n\n var range;\n if (document.createRange) { range = function(node, start, end, endNode) {\n var r = document.createRange();\n r.setEnd(endNode || node, end);\n r.setStart(node, start);\n return r\n }; }\n else { range = function(node, start, end) {\n var r = document.body.createTextRange();\n try { r.moveToElementText(node.parentNode); }\n catch(e) { return r }\n r.collapse(true);\n r.moveEnd(\"character\", end);\n r.moveStart(\"character\", start);\n return r\n }; }\n\n function contains(parent, child) {\n if (child.nodeType == 3) // Android browser always returns false when child is a textnode\n { child = child.parentNode; }\n if (parent.contains)\n { return parent.contains(child) }\n do {\n if (child.nodeType == 11) { child = child.host; }\n if (child == parent) { return true }\n } while (child = child.parentNode)\n }\n\n function activeElt() {\n // IE and Edge may throw an \"Unspecified Error\" when accessing document.activeElement.\n // IE < 10 will throw when accessed while the page is loading or in an iframe.\n // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.\n var activeElement;\n try {\n activeElement = document.activeElement;\n } catch(e) {\n activeElement = document.body || null;\n }\n while (activeElement && activeElement.shadowRoot && activeElement.shadowRoot.activeElement)\n { activeElement = activeElement.shadowRoot.activeElement; }\n return activeElement\n }\n\n function addClass(node, cls) {\n var current = node.className;\n if (!classTest(cls).test(current)) { node.className += (current ? \" \" : \"\") + cls; }\n }\n function joinClasses(a, b) {\n var as = a.split(\" \");\n for (var i = 0; i < as.length; i++)\n { if (as[i] && !classTest(as[i]).test(b)) { b += \" \" + as[i]; } }\n return b\n }\n\n var selectInput = function(node) { node.select(); };\n if (ios) // Mobile Safari apparently has a bug where select() is broken.\n { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length; }; }\n else if (ie) // Suppress mysterious IE10 errors\n { selectInput = function(node) { try { node.select(); } catch(_e) {} }; }\n\n function bind(f) {\n var args = Array.prototype.slice.call(arguments, 1);\n return function(){return f.apply(null, args)}\n }\n\n function copyObj(obj, target, overwrite) {\n if (!target) { target = {}; }\n for (var prop in obj)\n { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))\n { target[prop] = obj[prop]; } }\n return target\n }\n\n // Counts the column offset in a string, taking tabs into account.\n // Used mostly to find indentation.\n function countColumn(string, end, tabSize, startIndex, startValue) {\n if (end == null) {\n end = string.search(/[^\\s\\u00a0]/);\n if (end == -1) { end = string.length; }\n }\n for (var i = startIndex || 0, n = startValue || 0;;) {\n var nextTab = string.indexOf(\"\\t\", i);\n if (nextTab < 0 || nextTab >= end)\n { return n + (end - i) }\n n += nextTab - i;\n n += tabSize - (n % tabSize);\n i = nextTab + 1;\n }\n }\n\n var Delayed = function() {this.id = null;};\n Delayed.prototype.set = function (ms, f) {\n clearTimeout(this.id);\n this.id = setTimeout(f, ms);\n };\n\n function indexOf(array, elt) {\n for (var i = 0; i < array.length; ++i)\n { if (array[i] == elt) { return i } }\n return -1\n }\n\n // Number of pixels added to scroller and sizer to hide scrollbar\n var scrollerGap = 30;\n\n // Returned or thrown by various protocols to signal 'I'm not\n // handling this'.\n var Pass = {toString: function(){return \"CodeMirror.Pass\"}};\n\n // Reused option objects for setSelection & friends\n var sel_dontScroll = {scroll: false}, sel_mouse = {origin: \"*mouse\"}, sel_move = {origin: \"+move\"};\n\n // The inverse of countColumn -- find the offset that corresponds to\n // a particular column.\n function findColumn(string, goal, tabSize) {\n for (var pos = 0, col = 0;;) {\n var nextTab = string.indexOf(\"\\t\", pos);\n if (nextTab == -1) { nextTab = string.length; }\n var skipped = nextTab - pos;\n if (nextTab == string.length || col + skipped >= goal)\n { return pos + Math.min(skipped, goal - col) }\n col += nextTab - pos;\n col += tabSize - (col % tabSize);\n pos = nextTab + 1;\n if (col >= goal) { return pos }\n }\n }\n\n var spaceStrs = [\"\"];\n function spaceStr(n) {\n while (spaceStrs.length <= n)\n { spaceStrs.push(lst(spaceStrs) + \" \"); }\n return spaceStrs[n]\n }\n\n function lst(arr) { return arr[arr.length-1] }\n\n function map(array, f) {\n var out = [];\n for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i); }\n return out\n }\n\n function insertSorted(array, value, score) {\n var pos = 0, priority = score(value);\n while (pos < array.length && score(array[pos]) <= priority) { pos++; }\n array.splice(pos, 0, value);\n }\n\n function nothing() {}\n\n function createObj(base, props) {\n var inst;\n if (Object.create) {\n inst = Object.create(base);\n } else {\n nothing.prototype = base;\n inst = new nothing();\n }\n if (props) { copyObj(props, inst); }\n return inst\n }\n\n var nonASCIISingleCaseWordChar = /[\\u00df\\u0587\\u0590-\\u05f4\\u0600-\\u06ff\\u3040-\\u309f\\u30a0-\\u30ff\\u3400-\\u4db5\\u4e00-\\u9fcc\\uac00-\\ud7af]/;\n function isWordCharBasic(ch) {\n return /\\w/.test(ch) || ch > \"\\x80\" &&\n (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))\n }\n function isWordChar(ch, helper) {\n if (!helper) { return isWordCharBasic(ch) }\n if (helper.source.indexOf(\"\\\\w\") > -1 && isWordCharBasic(ch)) { return true }\n return helper.test(ch)\n }\n\n function isEmpty(obj) {\n for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }\n return true\n }\n\n // Extending unicode characters. A series of a non-extending char +\n // any number of extending chars is treated as a single unit as far\n // as editing and measuring is concerned. This is not fully correct,\n // since some scripts/fonts/browsers also treat other configurations\n // of code points as a group.\n 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]/;\n function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }\n\n // Returns a number from the range [`0`; `str.length`] unless `pos` is outside that range.\n function skipExtendingChars(str, pos, dir) {\n while ((dir < 0 ? pos > 0 : pos < str.length) && isExtendingChar(str.charAt(pos))) { pos += dir; }\n return pos\n }\n\n // Returns the value from the range [`from`; `to`] that satisfies\n // `pred` and is closest to `from`. Assumes that at least `to`\n // satisfies `pred`. Supports `from` being greater than `to`.\n function findFirst(pred, from, to) {\n // At any point we are certain `to` satisfies `pred`, don't know\n // whether `from` does.\n var dir = from > to ? -1 : 1;\n for (;;) {\n if (from == to) { return from }\n var midF = (from + to) / 2, mid = dir < 0 ? Math.ceil(midF) : Math.floor(midF);\n if (mid == from) { return pred(mid) ? from : to }\n if (pred(mid)) { to = mid; }\n else { from = mid + dir; }\n }\n }\n\n // The display handles the DOM integration, both for input reading\n // and content drawing. It holds references to DOM nodes and\n // display-related state.\n\n function Display(place, doc, input) {\n var d = this;\n this.input = input;\n\n // Covers bottom-right square when both scrollbars are present.\n d.scrollbarFiller = elt(\"div\", null, \"CodeMirror-scrollbar-filler\");\n d.scrollbarFiller.setAttribute(\"cm-not-content\", \"true\");\n // Covers bottom of gutter when coverGutterNextToScrollbar is on\n // and h scrollbar is present.\n d.gutterFiller = elt(\"div\", null, \"CodeMirror-gutter-filler\");\n d.gutterFiller.setAttribute(\"cm-not-content\", \"true\");\n // Will contain the actual code, positioned to cover the viewport.\n d.lineDiv = eltP(\"div\", null, \"CodeMirror-code\");\n // Elements are added to these to represent selection and cursors.\n d.selectionDiv = elt(\"div\", null, null, \"position: relative; z-index: 1\");\n d.cursorDiv = elt(\"div\", null, \"CodeMirror-cursors\");\n // A visibility: hidden element used to find the size of things.\n d.measure = elt(\"div\", null, \"CodeMirror-measure\");\n // When lines outside of the viewport are measured, they are drawn in this.\n d.lineMeasure = elt(\"div\", null, \"CodeMirror-measure\");\n // Wraps everything that needs to exist inside the vertically-padded coordinate system\n d.lineSpace = eltP(\"div\", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],\n null, \"position: relative; outline: none\");\n var lines = eltP(\"div\", [d.lineSpace], \"CodeMirror-lines\");\n // Moved around its parent to cover visible view.\n d.mover = elt(\"div\", [lines], null, \"position: relative\");\n // Set to the height of the document, allowing scrolling.\n d.sizer = elt(\"div\", [d.mover], \"CodeMirror-sizer\");\n d.sizerWidth = null;\n // Behavior of elts with overflow: auto and padding is\n // inconsistent across browsers. This is used to ensure the\n // scrollable area is big enough.\n d.heightForcer = elt(\"div\", null, null, \"position: absolute; height: \" + scrollerGap + \"px; width: 1px;\");\n // Will contain the gutters, if any.\n d.gutters = elt(\"div\", null, \"CodeMirror-gutters\");\n d.lineGutter = null;\n // Actual scrollable element.\n d.scroller = elt(\"div\", [d.sizer, d.heightForcer, d.gutters], \"CodeMirror-scroll\");\n d.scroller.setAttribute(\"tabIndex\", \"-1\");\n // The element in which the editor lives.\n d.wrapper = elt(\"div\", [d.scrollbarFiller, d.gutterFiller, d.scroller], \"CodeMirror\");\n\n // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)\n if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0; }\n if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true; }\n\n if (place) {\n if (place.appendChild) { place.appendChild(d.wrapper); }\n else { place(d.wrapper); }\n }\n\n // Current rendered range (may be bigger than the view window).\n d.viewFrom = d.viewTo = doc.first;\n d.reportedViewFrom = d.reportedViewTo = doc.first;\n // Information about the rendered lines.\n d.view = [];\n d.renderedView = null;\n // Holds info about a single rendered line when it was rendered\n // for measurement, while not in view.\n d.externalMeasured = null;\n // Empty space (in pixels) above the view\n d.viewOffset = 0;\n d.lastWrapHeight = d.lastWrapWidth = 0;\n d.updateLineNumbers = null;\n\n d.nativeBarWidth = d.barHeight = d.barWidth = 0;\n d.scrollbarsClipped = false;\n\n // Used to only resize the line number gutter when necessary (when\n // the amount of lines crosses a boundary that makes its width change)\n d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;\n // Set to true when a non-horizontal-scrolling line widget is\n // added. As an optimization, line widget aligning is skipped when\n // this is false.\n d.alignWidgets = false;\n\n d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;\n\n // Tracks the maximum line length so that the horizontal scrollbar\n // can be kept static when scrolling.\n d.maxLine = null;\n d.maxLineLength = 0;\n d.maxLineChanged = false;\n\n // Used for measuring wheel scrolling granularity\n d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;\n\n // True when shift is held down.\n d.shift = false;\n\n // Used to track whether anything happened since the context menu\n // was opened.\n d.selForContextMenu = null;\n\n d.activeTouch = null;\n\n input.init(d);\n }\n\n // Find the line object corresponding to the given line number.\n function getLine(doc, n) {\n n -= doc.first;\n if (n < 0 || n >= doc.size) { throw new Error(\"There is no line \" + (n + doc.first) + \" in the document.\") }\n var chunk = doc;\n while (!chunk.lines) {\n for (var i = 0;; ++i) {\n var child = chunk.children[i], sz = child.chunkSize();\n if (n < sz) { chunk = child; break }\n n -= sz;\n }\n }\n return chunk.lines[n]\n }\n\n // Get the part of a document between two positions, as an array of\n // strings.\n function getBetween(doc, start, end) {\n var out = [], n = start.line;\n doc.iter(start.line, end.line + 1, function (line) {\n var text = line.text;\n if (n == end.line) { text = text.slice(0, end.ch); }\n if (n == start.line) { text = text.slice(start.ch); }\n out.push(text);\n ++n;\n });\n return out\n }\n // Get the lines between from and to, as array of strings.\n function getLines(doc, from, to) {\n var out = [];\n doc.iter(from, to, function (line) { out.push(line.text); }); // iter aborts when callback returns truthy value\n return out\n }\n\n // Update the height of a line, propagating the height change\n // upwards to parent nodes.\n function updateLineHeight(line, height) {\n var diff = height - line.height;\n if (diff) { for (var n = line; n; n = n.parent) { n.height += diff; } }\n }\n\n // Given a line object, find its line number by walking up through\n // its parent links.\n function lineNo(line) {\n if (line.parent == null) { return null }\n var cur = line.parent, no = indexOf(cur.lines, line);\n for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {\n for (var i = 0;; ++i) {\n if (chunk.children[i] == cur) { break }\n no += chunk.children[i].chunkSize();\n }\n }\n return no + cur.first\n }\n\n // Find the line at the given vertical position, using the height\n // information in the document tree.\n function lineAtHeight(chunk, h) {\n var n = chunk.first;\n outer: do {\n for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {\n var child = chunk.children[i$1], ch = child.height;\n if (h < ch) { chunk = child; continue outer }\n h -= ch;\n n += child.chunkSize();\n }\n return n\n } while (!chunk.lines)\n var i = 0;\n for (; i < chunk.lines.length; ++i) {\n var line = chunk.lines[i], lh = line.height;\n if (h < lh) { break }\n h -= lh;\n }\n return n + i\n }\n\n function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}\n\n function lineNumberFor(options, i) {\n return String(options.lineNumberFormatter(i + options.firstLineNumber))\n }\n\n // A Pos instance represents a position within the text.\n function Pos(line, ch, sticky) {\n if ( sticky === void 0 ) sticky = null;\n\n if (!(this instanceof Pos)) { return new Pos(line, ch, sticky) }\n this.line = line;\n this.ch = ch;\n this.sticky = sticky;\n }\n\n // Compare two positions, return 0 if they are the same, a negative\n // number when a is less, and a positive number otherwise.\n function cmp(a, b) { return a.line - b.line || a.ch - b.ch }\n\n function equalCursorPos(a, b) { return a.sticky == b.sticky && cmp(a, b) == 0 }\n\n function copyPos(x) {return Pos(x.line, x.ch)}\n function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }\n function minPos(a, b) { return cmp(a, b) < 0 ? a : b }\n\n // Most of the external API clips given positions to make sure they\n // actually exist within the document.\n function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}\n function clipPos(doc, pos) {\n if (pos.line < doc.first) { return Pos(doc.first, 0) }\n var last = doc.first + doc.size - 1;\n if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }\n return clipToLen(pos, getLine(doc, pos.line).text.length)\n }\n function clipToLen(pos, linelen) {\n var ch = pos.ch;\n if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }\n else if (ch < 0) { return Pos(pos.line, 0) }\n else { return pos }\n }\n function clipPosArray(doc, array) {\n var out = [];\n for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]); }\n return out\n }\n\n // Optimize some code when these features are not used.\n var sawReadOnlySpans = false, sawCollapsedSpans = false;\n\n function seeReadOnlySpans() {\n sawReadOnlySpans = true;\n }\n\n function seeCollapsedSpans() {\n sawCollapsedSpans = true;\n }\n\n // TEXTMARKER SPANS\n\n function MarkedSpan(marker, from, to) {\n this.marker = marker;\n this.from = from; this.to = to;\n }\n\n // Search an array of spans for a span matching the given marker.\n function getMarkedSpanFor(spans, marker) {\n if (spans) { for (var i = 0; i < spans.length; ++i) {\n var span = spans[i];\n if (span.marker == marker) { return span }\n } }\n }\n // Remove a span from an array, returning undefined if no spans are\n // left (we don't store arrays for lines without spans).\n function removeMarkedSpan(spans, span) {\n var r;\n for (var i = 0; i < spans.length; ++i)\n { if (spans[i] != span) { (r || (r = [])).push(spans[i]); } }\n return r\n }\n // Add a span to a line.\n function addMarkedSpan(line, span) {\n line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span];\n span.marker.attachLine(line);\n }\n\n // Used for the algorithm that adjusts markers for a change in the\n // document. These functions cut an array of spans at a given\n // character position, returning an array of remaining chunks (or\n // undefined if nothing remains).\n function markedSpansBefore(old, startCh, isInsert) {\n var nw;\n if (old) { for (var i = 0; i < old.length; ++i) {\n var span = old[i], marker = span.marker;\n var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh);\n if (startsBefore || span.from == startCh && marker.type == \"bookmark\" && (!isInsert || !span.marker.insertLeft)) {\n var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)\n ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to));\n }\n } }\n return nw\n }\n function markedSpansAfter(old, endCh, isInsert) {\n var nw;\n if (old) { for (var i = 0; i < old.length; ++i) {\n var span = old[i], marker = span.marker;\n var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh);\n if (endsAfter || span.from == endCh && marker.type == \"bookmark\" && (!isInsert || span.marker.insertLeft)) {\n var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)\n ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,\n span.to == null ? null : span.to - endCh));\n }\n } }\n return nw\n }\n\n // Given a change object, compute the new set of marker spans that\n // cover the line in which the change took place. Removes spans\n // entirely within the change, reconnects spans belonging to the\n // same marker that appear on both sides of the change, and cuts off\n // spans partially within the change. Returns an array of span\n // arrays with one element for each line in (after) the change.\n function stretchSpansOverChange(doc, change) {\n if (change.full) { return null }\n var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans;\n var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans;\n if (!oldFirst && !oldLast) { return null }\n\n var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0;\n // Get the spans that 'stick out' on both sides\n var first = markedSpansBefore(oldFirst, startCh, isInsert);\n var last = markedSpansAfter(oldLast, endCh, isInsert);\n\n // Next, merge those two ends\n var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0);\n if (first) {\n // Fix up .to properties of first\n for (var i = 0; i < first.length; ++i) {\n var span = first[i];\n if (span.to == null) {\n var found = getMarkedSpanFor(last, span.marker);\n if (!found) { span.to = startCh; }\n else if (sameLine) { span.to = found.to == null ? null : found.to + offset; }\n }\n }\n }\n if (last) {\n // Fix up .from in last (or move them into first in case of sameLine)\n for (var i$1 = 0; i$1 < last.length; ++i$1) {\n var span$1 = last[i$1];\n if (span$1.to != null) { span$1.to += offset; }\n if (span$1.from == null) {\n var found$1 = getMarkedSpanFor(first, span$1.marker);\n if (!found$1) {\n span$1.from = offset;\n if (sameLine) { (first || (first = [])).push(span$1); }\n }\n } else {\n span$1.from += offset;\n if (sameLine) { (first || (first = [])).push(span$1); }\n }\n }\n }\n // Make sure we didn't create any zero-length spans\n if (first) { first = clearEmptySpans(first); }\n if (last && last != first) { last = clearEmptySpans(last); }\n\n var newMarkers = [first];\n if (!sameLine) {\n // Fill gap with whole-line-spans\n var gap = change.text.length - 2, gapMarkers;\n if (gap > 0 && first)\n { for (var i$2 = 0; i$2 < first.length; ++i$2)\n { if (first[i$2].to == null)\n { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)); } } }\n for (var i$3 = 0; i$3 < gap; ++i$3)\n { newMarkers.push(gapMarkers); }\n newMarkers.push(last);\n }\n return newMarkers\n }\n\n // Remove spans that are empty and don't have a clearWhenEmpty\n // option of false.\n function clearEmptySpans(spans) {\n for (var i = 0; i < spans.length; ++i) {\n var span = spans[i];\n if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)\n { spans.splice(i--, 1); }\n }\n if (!spans.length) { return null }\n return spans\n }\n\n // Used to 'clip' out readOnly ranges when making a change.\n function removeReadOnlyRanges(doc, from, to) {\n var markers = null;\n doc.iter(from.line, to.line + 1, function (line) {\n if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n var mark = line.markedSpans[i].marker;\n if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))\n { (markers || (markers = [])).push(mark); }\n } }\n });\n if (!markers) { return null }\n var parts = [{from: from, to: to}];\n for (var i = 0; i < markers.length; ++i) {\n var mk = markers[i], m = mk.find(0);\n for (var j = 0; j < parts.length; ++j) {\n var p = parts[j];\n if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }\n var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to);\n if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)\n { newParts.push({from: p.from, to: m.from}); }\n if (dto > 0 || !mk.inclusiveRight && !dto)\n { newParts.push({from: m.to, to: p.to}); }\n parts.splice.apply(parts, newParts);\n j += newParts.length - 3;\n }\n }\n return parts\n }\n\n // Connect or disconnect spans from a line.\n function detachMarkedSpans(line) {\n var spans = line.markedSpans;\n if (!spans) { return }\n for (var i = 0; i < spans.length; ++i)\n { spans[i].marker.detachLine(line); }\n line.markedSpans = null;\n }\n function attachMarkedSpans(line, spans) {\n if (!spans) { return }\n for (var i = 0; i < spans.length; ++i)\n { spans[i].marker.attachLine(line); }\n line.markedSpans = spans;\n }\n\n // Helpers used when computing which overlapping collapsed span\n // counts as the larger one.\n function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }\n function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }\n\n // Returns a number indicating which of two overlapping collapsed\n // spans is larger (and thus includes the other). Falls back to\n // comparing ids when the spans cover exactly the same range.\n function compareCollapsedMarkers(a, b) {\n var lenDiff = a.lines.length - b.lines.length;\n if (lenDiff != 0) { return lenDiff }\n var aPos = a.find(), bPos = b.find();\n var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);\n if (fromCmp) { return -fromCmp }\n var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);\n if (toCmp) { return toCmp }\n return b.id - a.id\n }\n\n // Find out whether a line ends or starts in a collapsed span. If\n // so, return the marker for that span.\n function collapsedSpanAtSide(line, start) {\n var sps = sawCollapsedSpans && line.markedSpans, found;\n if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n sp = sps[i];\n if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&\n (!found || compareCollapsedMarkers(found, sp.marker) < 0))\n { found = sp.marker; }\n } }\n return found\n }\n function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }\n function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }\n\n function collapsedSpanAround(line, ch) {\n var sps = sawCollapsedSpans && line.markedSpans, found;\n if (sps) { for (var i = 0; i < sps.length; ++i) {\n var sp = sps[i];\n if (sp.marker.collapsed && (sp.from == null || sp.from < ch) && (sp.to == null || sp.to > ch) &&\n (!found || compareCollapsedMarkers(found, sp.marker) < 0)) { found = sp.marker; }\n } }\n return found\n }\n\n // Test whether there exists a collapsed span that partially\n // overlaps (covers the start or end, but not both) of a new span.\n // Such overlap is not allowed.\n function conflictingCollapsedRange(doc, lineNo$$1, from, to, marker) {\n var line = getLine(doc, lineNo$$1);\n var sps = sawCollapsedSpans && line.markedSpans;\n if (sps) { for (var i = 0; i < sps.length; ++i) {\n var sp = sps[i];\n if (!sp.marker.collapsed) { continue }\n var found = sp.marker.find(0);\n var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker);\n var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker);\n if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }\n if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||\n fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))\n { return true }\n } }\n }\n\n // A visual line is a line as drawn on the screen. Folding, for\n // example, can cause multiple logical lines to appear on the same\n // visual line. This finds the start of the visual line that the\n // given line is part of (usually that is the line itself).\n function visualLine(line) {\n var merged;\n while (merged = collapsedSpanAtStart(line))\n { line = merged.find(-1, true).line; }\n return line\n }\n\n function visualLineEnd(line) {\n var merged;\n while (merged = collapsedSpanAtEnd(line))\n { line = merged.find(1, true).line; }\n return line\n }\n\n // Returns an array of logical lines that continue the visual line\n // started by the argument, or undefined if there are no such lines.\n function visualLineContinued(line) {\n var merged, lines;\n while (merged = collapsedSpanAtEnd(line)) {\n line = merged.find(1, true).line\n ;(lines || (lines = [])).push(line);\n }\n return lines\n }\n\n // Get the line number of the start of the visual line that the\n // given line number is part of.\n function visualLineNo(doc, lineN) {\n var line = getLine(doc, lineN), vis = visualLine(line);\n if (line == vis) { return lineN }\n return lineNo(vis)\n }\n\n // Get the line number of the start of the next visual line after\n // the given line.\n function visualLineEndNo(doc, lineN) {\n if (lineN > doc.lastLine()) { return lineN }\n var line = getLine(doc, lineN), merged;\n if (!lineIsHidden(doc, line)) { return lineN }\n while (merged = collapsedSpanAtEnd(line))\n { line = merged.find(1, true).line; }\n return lineNo(line) + 1\n }\n\n // Compute whether a line is hidden. Lines count as hidden when they\n // are part of a visual line that starts with another line, or when\n // they are entirely covered by collapsed, non-widget span.\n function lineIsHidden(doc, line) {\n var sps = sawCollapsedSpans && line.markedSpans;\n if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {\n sp = sps[i];\n if (!sp.marker.collapsed) { continue }\n if (sp.from == null) { return true }\n if (sp.marker.widgetNode) { continue }\n if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))\n { return true }\n } }\n }\n function lineIsHiddenInner(doc, line, span) {\n if (span.to == null) {\n var end = span.marker.find(1, true);\n return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))\n }\n if (span.marker.inclusiveRight && span.to == line.text.length)\n { return true }\n for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {\n sp = line.markedSpans[i];\n if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&\n (sp.to == null || sp.to != span.from) &&\n (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&\n lineIsHiddenInner(doc, line, sp)) { return true }\n }\n }\n\n // Find the height above the given line.\n function heightAtLine(lineObj) {\n lineObj = visualLine(lineObj);\n\n var h = 0, chunk = lineObj.parent;\n for (var i = 0; i < chunk.lines.length; ++i) {\n var line = chunk.lines[i];\n if (line == lineObj) { break }\n else { h += line.height; }\n }\n for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {\n for (var i$1 = 0; i$1 < p.children.length; ++i$1) {\n var cur = p.children[i$1];\n if (cur == chunk) { break }\n else { h += cur.height; }\n }\n }\n return h\n }\n\n // Compute the character length of a line, taking into account\n // collapsed ranges (see markText) that might hide parts, and join\n // other lines onto it.\n function lineLength(line) {\n if (line.height == 0) { return 0 }\n var len = line.text.length, merged, cur = line;\n while (merged = collapsedSpanAtStart(cur)) {\n var found = merged.find(0, true);\n cur = found.from.line;\n len += found.from.ch - found.to.ch;\n }\n cur = line;\n while (merged = collapsedSpanAtEnd(cur)) {\n var found$1 = merged.find(0, true);\n len -= cur.text.length - found$1.from.ch;\n cur = found$1.to.line;\n len += cur.text.length - found$1.to.ch;\n }\n return len\n }\n\n // Find the longest line in the document.\n function findMaxLine(cm) {\n var d = cm.display, doc = cm.doc;\n d.maxLine = getLine(doc, doc.first);\n d.maxLineLength = lineLength(d.maxLine);\n d.maxLineChanged = true;\n doc.iter(function (line) {\n var len = lineLength(line);\n if (len > d.maxLineLength) {\n d.maxLineLength = len;\n d.maxLine = line;\n }\n });\n }\n\n // BIDI HELPERS\n\n function iterateBidiSections(order, from, to, f) {\n if (!order) { return f(from, to, \"ltr\", 0) }\n var found = false;\n for (var i = 0; i < order.length; ++i) {\n var part = order[i];\n if (part.from < to && part.to > from || from == to && part.to == from) {\n f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? \"rtl\" : \"ltr\", i);\n found = true;\n }\n }\n if (!found) { f(from, to, \"ltr\"); }\n }\n\n var bidiOther = null;\n function getBidiPartAt(order, ch, sticky) {\n var found;\n bidiOther = null;\n for (var i = 0; i < order.length; ++i) {\n var cur = order[i];\n if (cur.from < ch && cur.to > ch) { return i }\n if (cur.to == ch) {\n if (cur.from != cur.to && sticky == \"before\") { found = i; }\n else { bidiOther = i; }\n }\n if (cur.from == ch) {\n if (cur.from != cur.to && sticky != \"before\") { found = i; }\n else { bidiOther = i; }\n }\n }\n return found != null ? found : bidiOther\n }\n\n // Bidirectional ordering algorithm\n // See http://unicode.org/reports/tr9/tr9-13.html for the algorithm\n // that this (partially) implements.\n\n // One-char codes used for character types:\n // L (L): Left-to-Right\n // R (R): Right-to-Left\n // r (AL): Right-to-Left Arabic\n // 1 (EN): European Number\n // + (ES): European Number Separator\n // % (ET): European Number Terminator\n // n (AN): Arabic Number\n // , (CS): Common Number Separator\n // m (NSM): Non-Spacing Mark\n // b (BN): Boundary Neutral\n // s (B): Paragraph Separator\n // t (S): Segment Separator\n // w (WS): Whitespace\n // N (ON): Other Neutrals\n\n // Returns null if characters are ordered as they appear\n // (left-to-right), or an array of sections ({from, to, level}\n // objects) in the order in which they occur visually.\n var bidiOrdering = (function() {\n // Character types for codepoints 0 to 0xff\n var lowTypes = \"bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN\";\n // Character types for codepoints 0x600 to 0x6f9\n var arabicTypes = \"nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111\";\n function charType(code) {\n if (code <= 0xf7) { return lowTypes.charAt(code) }\n else if (0x590 <= code && code <= 0x5f4) { return \"R\" }\n else if (0x600 <= code && code <= 0x6f9) { return arabicTypes.charAt(code - 0x600) }\n else if (0x6ee <= code && code <= 0x8ac) { return \"r\" }\n else if (0x2000 <= code && code <= 0x200b) { return \"w\" }\n else if (code == 0x200c) { return \"b\" }\n else { return \"L\" }\n }\n\n var bidiRE = /[\\u0590-\\u05f4\\u0600-\\u06ff\\u0700-\\u08ac]/;\n var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/;\n\n function BidiSpan(level, from, to) {\n this.level = level;\n this.from = from; this.to = to;\n }\n\n return function(str, direction) {\n var outerType = direction == \"ltr\" ? \"L\" : \"R\";\n\n if (str.length == 0 || direction == \"ltr\" && !bidiRE.test(str)) { return false }\n var len = str.length, types = [];\n for (var i = 0; i < len; ++i)\n { types.push(charType(str.charCodeAt(i))); }\n\n // W1. Examine each non-spacing mark (NSM) in the level run, and\n // change the type of the NSM to the type of the previous\n // character. If the NSM is at the start of the level run, it will\n // get the type of sor.\n for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {\n var type = types[i$1];\n if (type == \"m\") { types[i$1] = prev; }\n else { prev = type; }\n }\n\n // W2. Search backwards from each instance of a European number\n // until the first strong type (R, L, AL, or sor) is found. If an\n // AL is found, change the type of the European number to Arabic\n // number.\n // W3. Change all ALs to R.\n for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {\n var type$1 = types[i$2];\n if (type$1 == \"1\" && cur == \"r\") { types[i$2] = \"n\"; }\n else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == \"r\") { types[i$2] = \"R\"; } }\n }\n\n // W4. A single European separator between two European numbers\n // changes to a European number. A single common separator between\n // two numbers of the same type changes to that type.\n for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {\n var type$2 = types[i$3];\n if (type$2 == \"+\" && prev$1 == \"1\" && types[i$3+1] == \"1\") { types[i$3] = \"1\"; }\n else if (type$2 == \",\" && prev$1 == types[i$3+1] &&\n (prev$1 == \"1\" || prev$1 == \"n\")) { types[i$3] = prev$1; }\n prev$1 = type$2;\n }\n\n // W5. A sequence of European terminators adjacent to European\n // numbers changes to all European numbers.\n // W6. Otherwise, separators and terminators change to Other\n // Neutral.\n for (var i$4 = 0; i$4 < len; ++i$4) {\n var type$3 = types[i$4];\n if (type$3 == \",\") { types[i$4] = \"N\"; }\n else if (type$3 == \"%\") {\n var end = (void 0);\n for (end = i$4 + 1; end < len && types[end] == \"%\"; ++end) {}\n var replace = (i$4 && types[i$4-1] == \"!\") || (end < len && types[end] == \"1\") ? \"1\" : \"N\";\n for (var j = i$4; j < end; ++j) { types[j] = replace; }\n i$4 = end - 1;\n }\n }\n\n // W7. Search backwards from each instance of a European number\n // until the first strong type (R, L, or sor) is found. If an L is\n // found, then change the type of the European number to L.\n for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {\n var type$4 = types[i$5];\n if (cur$1 == \"L\" && type$4 == \"1\") { types[i$5] = \"L\"; }\n else if (isStrong.test(type$4)) { cur$1 = type$4; }\n }\n\n // N1. A sequence of neutrals takes the direction of the\n // surrounding strong text if the text on both sides has the same\n // direction. European and Arabic numbers act as if they were R in\n // terms of their influence on neutrals. Start-of-level-run (sor)\n // and end-of-level-run (eor) are used at level run boundaries.\n // N2. Any remaining neutrals take the embedding direction.\n for (var i$6 = 0; i$6 < len; ++i$6) {\n if (isNeutral.test(types[i$6])) {\n var end$1 = (void 0);\n for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}\n var before = (i$6 ? types[i$6-1] : outerType) == \"L\";\n var after = (end$1 < len ? types[end$1] : outerType) == \"L\";\n var replace$1 = before == after ? (before ? \"L\" : \"R\") : outerType;\n for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1; }\n i$6 = end$1 - 1;\n }\n }\n\n // Here we depart from the documented algorithm, in order to avoid\n // building up an actual levels array. Since there are only three\n // levels (0, 1, 2) in an implementation that doesn't take\n // explicit embedding into account, we can build up the order on\n // the fly, without following the level-based algorithm.\n var order = [], m;\n for (var i$7 = 0; i$7 < len;) {\n if (countsAsLeft.test(types[i$7])) {\n var start = i$7;\n for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}\n order.push(new BidiSpan(0, start, i$7));\n } else {\n var pos = i$7, at = order.length;\n for (++i$7; i$7 < len && types[i$7] != \"L\"; ++i$7) {}\n for (var j$2 = pos; j$2 < i$7;) {\n if (countsAsNum.test(types[j$2])) {\n if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)); }\n var nstart = j$2;\n for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}\n order.splice(at, 0, new BidiSpan(2, nstart, j$2));\n pos = j$2;\n } else { ++j$2; }\n }\n if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)); }\n }\n }\n if (direction == \"ltr\") {\n if (order[0].level == 1 && (m = str.match(/^\\s+/))) {\n order[0].from = m[0].length;\n order.unshift(new BidiSpan(0, 0, m[0].length));\n }\n if (lst(order).level == 1 && (m = str.match(/\\s+$/))) {\n lst(order).to -= m[0].length;\n order.push(new BidiSpan(0, len - m[0].length, len));\n }\n }\n\n return direction == \"rtl\" ? order.reverse() : order\n }\n })();\n\n // Get the bidi ordering for the given line (and cache it). Returns\n // false for lines that are fully left-to-right, and an array of\n // BidiSpan objects otherwise.\n function getOrder(line, direction) {\n var order = line.order;\n if (order == null) { order = line.order = bidiOrdering(line.text, direction); }\n return order\n }\n\n // EVENT HANDLING\n\n // Lightweight event framework. on/off also work on DOM nodes,\n // registering native DOM handlers.\n\n var noHandlers = [];\n\n var on = function(emitter, type, f) {\n if (emitter.addEventListener) {\n emitter.addEventListener(type, f, false);\n } else if (emitter.attachEvent) {\n emitter.attachEvent(\"on\" + type, f);\n } else {\n var map$$1 = emitter._handlers || (emitter._handlers = {});\n map$$1[type] = (map$$1[type] || noHandlers).concat(f);\n }\n };\n\n function getHandlers(emitter, type) {\n return emitter._handlers && emitter._handlers[type] || noHandlers\n }\n\n function off(emitter, type, f) {\n if (emitter.removeEventListener) {\n emitter.removeEventListener(type, f, false);\n } else if (emitter.detachEvent) {\n emitter.detachEvent(\"on\" + type, f);\n } else {\n var map$$1 = emitter._handlers, arr = map$$1 && map$$1[type];\n if (arr) {\n var index = indexOf(arr, f);\n if (index > -1)\n { map$$1[type] = arr.slice(0, index).concat(arr.slice(index + 1)); }\n }\n }\n }\n\n function signal(emitter, type /*, values...*/) {\n var handlers = getHandlers(emitter, type);\n if (!handlers.length) { return }\n var args = Array.prototype.slice.call(arguments, 2);\n for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args); }\n }\n\n // The DOM events that CodeMirror handles can be overridden by\n // registering a (non-DOM) handler on the editor for the event name,\n // and preventDefault-ing the event in that handler.\n function signalDOMEvent(cm, e, override) {\n if (typeof e == \"string\")\n { e = {type: e, preventDefault: function() { this.defaultPrevented = true; }}; }\n signal(cm, override || e.type, cm, e);\n return e_defaultPrevented(e) || e.codemirrorIgnore\n }\n\n function signalCursorActivity(cm) {\n var arr = cm._handlers && cm._handlers.cursorActivity;\n if (!arr) { return }\n var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = []);\n for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)\n { set.push(arr[i]); } }\n }\n\n function hasHandler(emitter, type) {\n return getHandlers(emitter, type).length > 0\n }\n\n // Add on and off methods to a constructor's prototype, to make\n // registering events on such objects more convenient.\n function eventMixin(ctor) {\n ctor.prototype.on = function(type, f) {on(this, type, f);};\n ctor.prototype.off = function(type, f) {off(this, type, f);};\n }\n\n // Due to the fact that we still support jurassic IE versions, some\n // compatibility wrappers are needed.\n\n function e_preventDefault(e) {\n if (e.preventDefault) { e.preventDefault(); }\n else { e.returnValue = false; }\n }\n function e_stopPropagation(e) {\n if (e.stopPropagation) { e.stopPropagation(); }\n else { e.cancelBubble = true; }\n }\n function e_defaultPrevented(e) {\n return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false\n }\n function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}\n\n function e_target(e) {return e.target || e.srcElement}\n function e_button(e) {\n var b = e.which;\n if (b == null) {\n if (e.button & 1) { b = 1; }\n else if (e.button & 2) { b = 3; }\n else if (e.button & 4) { b = 2; }\n }\n if (mac && e.ctrlKey && b == 1) { b = 3; }\n return b\n }\n\n // Detect drag-and-drop\n var dragAndDrop = function() {\n // There is *some* kind of drag-and-drop support in IE6-8, but I\n // couldn't get it to work yet.\n if (ie && ie_version < 9) { return false }\n var div = elt('div');\n return \"draggable\" in div || \"dragDrop\" in div\n }();\n\n var zwspSupported;\n function zeroWidthElement(measure) {\n if (zwspSupported == null) {\n var test = elt(\"span\", \"\\u200b\");\n removeChildrenAndAdd(measure, elt(\"span\", [test, document.createTextNode(\"x\")]));\n if (measure.firstChild.offsetHeight != 0)\n { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8); }\n }\n var node = zwspSupported ? elt(\"span\", \"\\u200b\") :\n elt(\"span\", \"\\u00a0\", null, \"display: inline-block; width: 1px; margin-right: -1px\");\n node.setAttribute(\"cm-text\", \"\");\n return node\n }\n\n // Feature-detect IE's crummy client rect reporting for bidi text\n var badBidiRects;\n function hasBadBidiRects(measure) {\n if (badBidiRects != null) { return badBidiRects }\n var txt = removeChildrenAndAdd(measure, document.createTextNode(\"A\\u062eA\"));\n var r0 = range(txt, 0, 1).getBoundingClientRect();\n var r1 = range(txt, 1, 2).getBoundingClientRect();\n removeChildren(measure);\n if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)\n return badBidiRects = (r1.right - r0.right < 3)\n }\n\n // See if \"\".split is the broken IE version, if so, provide an\n // alternative way to split lines.\n var splitLinesAuto = \"\\n\\nb\".split(/\\n/).length != 3 ? function (string) {\n var pos = 0, result = [], l = string.length;\n while (pos <= l) {\n var nl = string.indexOf(\"\\n\", pos);\n if (nl == -1) { nl = string.length; }\n var line = string.slice(pos, string.charAt(nl - 1) == \"\\r\" ? nl - 1 : nl);\n var rt = line.indexOf(\"\\r\");\n if (rt != -1) {\n result.push(line.slice(0, rt));\n pos += rt + 1;\n } else {\n result.push(line);\n pos = nl + 1;\n }\n }\n return result\n } : function (string) { return string.split(/\\r\\n?|\\n/); };\n\n var hasSelection = window.getSelection ? function (te) {\n try { return te.selectionStart != te.selectionEnd }\n catch(e) { return false }\n } : function (te) {\n var range$$1;\n try {range$$1 = te.ownerDocument.selection.createRange();}\n catch(e) {}\n if (!range$$1 || range$$1.parentElement() != te) { return false }\n return range$$1.compareEndPoints(\"StartToEnd\", range$$1) != 0\n };\n\n var hasCopyEvent = (function () {\n var e = elt(\"div\");\n if (\"oncopy\" in e) { return true }\n e.setAttribute(\"oncopy\", \"return;\");\n return typeof e.oncopy == \"function\"\n })();\n\n var badZoomedRects = null;\n function hasBadZoomedRects(measure) {\n if (badZoomedRects != null) { return badZoomedRects }\n var node = removeChildrenAndAdd(measure, elt(\"span\", \"x\"));\n var normal = node.getBoundingClientRect();\n var fromRange = range(node, 0, 1).getBoundingClientRect();\n return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1\n }\n\n // Known modes, by name and by MIME\n var modes = {}, mimeModes = {};\n\n // Extra arguments are stored as the mode's dependencies, which is\n // used by (legacy) mechanisms like loadmode.js to automatically\n // load a mode. (Preferred mechanism is the require/define calls.)\n function defineMode(name, mode) {\n if (arguments.length > 2)\n { mode.dependencies = Array.prototype.slice.call(arguments, 2); }\n modes[name] = mode;\n }\n\n function defineMIME(mime, spec) {\n mimeModes[mime] = spec;\n }\n\n // Given a MIME type, a {name, ...options} config object, or a name\n // string, return a mode config object.\n function resolveMode(spec) {\n if (typeof spec == \"string\" && mimeModes.hasOwnProperty(spec)) {\n spec = mimeModes[spec];\n } else if (spec && typeof spec.name == \"string\" && mimeModes.hasOwnProperty(spec.name)) {\n var found = mimeModes[spec.name];\n if (typeof found == \"string\") { found = {name: found}; }\n spec = createObj(found, spec);\n spec.name = found.name;\n } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+xml$/.test(spec)) {\n return resolveMode(\"application/xml\")\n } else if (typeof spec == \"string\" && /^[\\w\\-]+\\/[\\w\\-]+\\+json$/.test(spec)) {\n return resolveMode(\"application/json\")\n }\n if (typeof spec == \"string\") { return {name: spec} }\n else { return spec || {name: \"null\"} }\n }\n\n // Given a mode spec (anything that resolveMode accepts), find and\n // initialize an actual mode object.\n function getMode(options, spec) {\n spec = resolveMode(spec);\n var mfactory = modes[spec.name];\n if (!mfactory) { return getMode(options, \"text/plain\") }\n var modeObj = mfactory(options, spec);\n if (modeExtensions.hasOwnProperty(spec.name)) {\n var exts = modeExtensions[spec.name];\n for (var prop in exts) {\n if (!exts.hasOwnProperty(prop)) { continue }\n if (modeObj.hasOwnProperty(prop)) { modeObj[\"_\" + prop] = modeObj[prop]; }\n modeObj[prop] = exts[prop];\n }\n }\n modeObj.name = spec.name;\n if (spec.helperType) { modeObj.helperType = spec.helperType; }\n if (spec.modeProps) { for (var prop$1 in spec.modeProps)\n { modeObj[prop$1] = spec.modeProps[prop$1]; } }\n\n return modeObj\n }\n\n // This can be used to attach properties to mode objects from\n // outside the actual mode definition.\n var modeExtensions = {};\n function extendMode(mode, properties) {\n var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {});\n copyObj(properties, exts);\n }\n\n function copyState(mode, state) {\n if (state === true) { return state }\n if (mode.copyState) { return mode.copyState(state) }\n var nstate = {};\n for (var n in state) {\n var val = state[n];\n if (val instanceof Array) { val = val.concat([]); }\n nstate[n] = val;\n }\n return nstate\n }\n\n // Given a mode and a state (for that mode), find the inner mode and\n // state at the position that the state refers to.\n function innerMode(mode, state) {\n var info;\n while (mode.innerMode) {\n info = mode.innerMode(state);\n if (!info || info.mode == mode) { break }\n state = info.state;\n mode = info.mode;\n }\n return info || {mode: mode, state: state}\n }\n\n function startState(mode, a1, a2) {\n return mode.startState ? mode.startState(a1, a2) : true\n }\n\n // STRING STREAM\n\n // Fed to the mode parsers, provides helper functions to make\n // parsers more succinct.\n\n var StringStream = function(string, tabSize, lineOracle) {\n this.pos = this.start = 0;\n this.string = string;\n this.tabSize = tabSize || 8;\n this.lastColumnPos = this.lastColumnValue = 0;\n this.lineStart = 0;\n this.lineOracle = lineOracle;\n };\n\n StringStream.prototype.eol = function () {return this.pos >= this.string.length};\n StringStream.prototype.sol = function () {return this.pos == this.lineStart};\n StringStream.prototype.peek = function () {return this.string.charAt(this.pos) || undefined};\n StringStream.prototype.next = function () {\n if (this.pos < this.string.length)\n { return this.string.charAt(this.pos++) }\n };\n StringStream.prototype.eat = function (match) {\n var ch = this.string.charAt(this.pos);\n var ok;\n if (typeof match == \"string\") { ok = ch == match; }\n else { ok = ch && (match.test ? match.test(ch) : match(ch)); }\n if (ok) {++this.pos; return ch}\n };\n StringStream.prototype.eatWhile = function (match) {\n var start = this.pos;\n while (this.eat(match)){}\n return this.pos > start\n };\n StringStream.prototype.eatSpace = function () {\n var this$1 = this;\n\n var start = this.pos;\n while (/[\\s\\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos; }\n return this.pos > start\n };\n StringStream.prototype.skipToEnd = function () {this.pos = this.string.length;};\n StringStream.prototype.skipTo = function (ch) {\n var found = this.string.indexOf(ch, this.pos);\n if (found > -1) {this.pos = found; return true}\n };\n StringStream.prototype.backUp = function (n) {this.pos -= n;};\n StringStream.prototype.column = function () {\n if (this.lastColumnPos < this.start) {\n this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);\n this.lastColumnPos = this.start;\n }\n return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n };\n StringStream.prototype.indentation = function () {\n return countColumn(this.string, null, this.tabSize) -\n (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)\n };\n StringStream.prototype.match = function (pattern, consume, caseInsensitive) {\n if (typeof pattern == \"string\") {\n var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; };\n var substr = this.string.substr(this.pos, pattern.length);\n if (cased(substr) == cased(pattern)) {\n if (consume !== false) { this.pos += pattern.length; }\n return true\n }\n } else {\n var match = this.string.slice(this.pos).match(pattern);\n if (match && match.index > 0) { return null }\n if (match && consume !== false) { this.pos += match[0].length; }\n return match\n }\n };\n StringStream.prototype.current = function (){return this.string.slice(this.start, this.pos)};\n StringStream.prototype.hideFirstChars = function (n, inner) {\n this.lineStart += n;\n try { return inner() }\n finally { this.lineStart -= n; }\n };\n StringStream.prototype.lookAhead = function (n) {\n var oracle = this.lineOracle;\n return oracle && oracle.lookAhead(n)\n };\n StringStream.prototype.baseToken = function () {\n var oracle = this.lineOracle;\n return oracle && oracle.baseToken(this.pos)\n };\n\n var SavedContext = function(state, lookAhead) {\n this.state = state;\n this.lookAhead = lookAhead;\n };\n\n var Context = function(doc, state, line, lookAhead) {\n this.state = state;\n this.doc = doc;\n this.line = line;\n this.maxLookAhead = lookAhead || 0;\n this.baseTokens = null;\n this.baseTokenPos = 1;\n };\n\n Context.prototype.lookAhead = function (n) {\n var line = this.doc.getLine(this.line + n);\n if (line != null && n > this.maxLookAhead) { this.maxLookAhead = n; }\n return line\n };\n\n Context.prototype.baseToken = function (n) {\n var this$1 = this;\n\n if (!this.baseTokens) { return null }\n while (this.baseTokens[this.baseTokenPos] <= n)\n { this$1.baseTokenPos += 2; }\n var type = this.baseTokens[this.baseTokenPos + 1];\n return {type: type && type.replace(/( |^)overlay .*/, \"\"),\n size: this.baseTokens[this.baseTokenPos] - n}\n };\n\n Context.prototype.nextLine = function () {\n this.line++;\n if (this.maxLookAhead > 0) { this.maxLookAhead--; }\n };\n\n Context.fromSaved = function (doc, saved, line) {\n if (saved instanceof SavedContext)\n { return new Context(doc, copyState(doc.mode, saved.state), line, saved.lookAhead) }\n else\n { return new Context(doc, copyState(doc.mode, saved), line) }\n };\n\n Context.prototype.save = function (copy) {\n var state = copy !== false ? copyState(this.doc.mode, this.state) : this.state;\n return this.maxLookAhead > 0 ? new SavedContext(state, this.maxLookAhead) : state\n };\n\n\n // Compute a style array (an array starting with a mode generation\n // -- for invalidation -- followed by pairs of end positions and\n // style strings), which is used to highlight the tokens on the\n // line.\n function highlightLine(cm, line, context, forceToEnd) {\n // A styles array always starts with a number identifying the\n // mode/overlays that it is based on (for easy invalidation).\n var st = [cm.state.modeGen], lineClasses = {};\n // Compute the base array of styles\n runMode(cm, line.text, cm.doc.mode, context, function (end, style) { return st.push(end, style); },\n lineClasses, forceToEnd);\n var state = context.state;\n\n // Run overlays, adjust style array.\n var loop = function ( o ) {\n context.baseTokens = st;\n var overlay = cm.state.overlays[o], i = 1, at = 0;\n context.state = true;\n runMode(cm, line.text, overlay.mode, context, function (end, style) {\n var start = i;\n // Ensure there's a token end at the current position, and that i points at it\n while (at < end) {\n var i_end = st[i];\n if (i_end > end)\n { st.splice(i, 1, end, st[i+1], i_end); }\n i += 2;\n at = Math.min(end, i_end);\n }\n if (!style) { return }\n if (overlay.opaque) {\n st.splice(start, i - start, end, \"overlay \" + style);\n i = start + 2;\n } else {\n for (; start < i; start += 2) {\n var cur = st[start+1];\n st[start+1] = (cur ? cur + \" \" : \"\") + \"overlay \" + style;\n }\n }\n }, lineClasses);\n context.state = state;\n context.baseTokens = null;\n context.baseTokenPos = 1;\n };\n\n for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );\n\n return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}\n }\n\n function getLineStyles(cm, line, updateFrontier) {\n if (!line.styles || line.styles[0] != cm.state.modeGen) {\n var context = getContextBefore(cm, lineNo(line));\n var resetState = line.text.length > cm.options.maxHighlightLength && copyState(cm.doc.mode, context.state);\n var result = highlightLine(cm, line, context);\n if (resetState) { context.state = resetState; }\n line.stateAfter = context.save(!resetState);\n line.styles = result.styles;\n if (result.classes) { line.styleClasses = result.classes; }\n else if (line.styleClasses) { line.styleClasses = null; }\n if (updateFrontier === cm.doc.highlightFrontier)\n { cm.doc.modeFrontier = Math.max(cm.doc.modeFrontier, ++cm.doc.highlightFrontier); }\n }\n return line.styles\n }\n\n function getContextBefore(cm, n, precise) {\n var doc = cm.doc, display = cm.display;\n if (!doc.mode.startState) { return new Context(doc, true, n) }\n var start = findStartLine(cm, n, precise);\n var saved = start > doc.first && getLine(doc, start - 1).stateAfter;\n var context = saved ? Context.fromSaved(doc, saved, start) : new Context(doc, startState(doc.mode), start);\n\n doc.iter(start, n, function (line) {\n processLine(cm, line.text, context);\n var pos = context.line;\n line.stateAfter = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo ? context.save() : null;\n context.nextLine();\n });\n if (precise) { doc.modeFrontier = context.line; }\n return context\n }\n\n // Lightweight form of highlight -- proceed over this line and\n // update state, but don't save a style array. Used for lines that\n // aren't currently visible.\n function processLine(cm, text, context, startAt) {\n var mode = cm.doc.mode;\n var stream = new StringStream(text, cm.options.tabSize, context);\n stream.start = stream.pos = startAt || 0;\n if (text == \"\") { callBlankLine(mode, context.state); }\n while (!stream.eol()) {\n readToken(mode, stream, context.state);\n stream.start = stream.pos;\n }\n }\n\n function callBlankLine(mode, state) {\n if (mode.blankLine) { return mode.blankLine(state) }\n if (!mode.innerMode) { return }\n var inner = innerMode(mode, state);\n if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }\n }\n\n function readToken(mode, stream, state, inner) {\n for (var i = 0; i < 10; i++) {\n if (inner) { inner[0] = innerMode(mode, state).mode; }\n var style = mode.token(stream, state);\n if (stream.pos > stream.start) { return style }\n }\n throw new Error(\"Mode \" + mode.name + \" failed to advance stream.\")\n }\n\n var Token = function(stream, type, state) {\n this.start = stream.start; this.end = stream.pos;\n this.string = stream.current();\n this.type = type || null;\n this.state = state;\n };\n\n // Utility for getTokenAt and getLineTokens\n function takeToken(cm, pos, precise, asArray) {\n var doc = cm.doc, mode = doc.mode, style;\n pos = clipPos(doc, pos);\n var line = getLine(doc, pos.line), context = getContextBefore(cm, pos.line, precise);\n var stream = new StringStream(line.text, cm.options.tabSize, context), tokens;\n if (asArray) { tokens = []; }\n while ((asArray || stream.pos < pos.ch) && !stream.eol()) {\n stream.start = stream.pos;\n style = readToken(mode, stream, context.state);\n if (asArray) { tokens.push(new Token(stream, style, copyState(doc.mode, context.state))); }\n }\n return asArray ? tokens : new Token(stream, style, context.state)\n }\n\n function extractLineClasses(type, output) {\n if (type) { for (;;) {\n var lineClass = type.match(/(?:^|\\s+)line-(background-)?(\\S+)/);\n if (!lineClass) { break }\n type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length);\n var prop = lineClass[1] ? \"bgClass\" : \"textClass\";\n if (output[prop] == null)\n { output[prop] = lineClass[2]; }\n else if (!(new RegExp(\"(?:^|\\s)\" + lineClass[2] + \"(?:$|\\s)\")).test(output[prop]))\n { output[prop] += \" \" + lineClass[2]; }\n } }\n return type\n }\n\n // Run the given mode's parser over a line, calling f for each token.\n function runMode(cm, text, mode, context, f, lineClasses, forceToEnd) {\n var flattenSpans = mode.flattenSpans;\n if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans; }\n var curStart = 0, curStyle = null;\n var stream = new StringStream(text, cm.options.tabSize, context), style;\n var inner = cm.options.addModeClass && [null];\n if (text == \"\") { extractLineClasses(callBlankLine(mode, context.state), lineClasses); }\n while (!stream.eol()) {\n if (stream.pos > cm.options.maxHighlightLength) {\n flattenSpans = false;\n if (forceToEnd) { processLine(cm, text, context, stream.pos); }\n stream.pos = text.length;\n style = null;\n } else {\n style = extractLineClasses(readToken(mode, stream, context.state, inner), lineClasses);\n }\n if (inner) {\n var mName = inner[0].name;\n if (mName) { style = \"m-\" + (style ? mName + \" \" + style : mName); }\n }\n if (!flattenSpans || curStyle != style) {\n while (curStart < stream.start) {\n curStart = Math.min(stream.start, curStart + 5000);\n f(curStart, curStyle);\n }\n curStyle = style;\n }\n stream.start = stream.pos;\n }\n while (curStart < stream.pos) {\n // Webkit seems to refuse to render text nodes longer than 57444\n // characters, and returns inaccurate measurements in nodes\n // starting around 5000 chars.\n var pos = Math.min(stream.pos, curStart + 5000);\n f(pos, curStyle);\n curStart = pos;\n }\n }\n\n // Finds the line to start with when starting a parse. Tries to\n // find a line with a stateAfter, so that it can start with a\n // valid state. If that fails, it returns the line with the\n // smallest indentation, which tends to need the least context to\n // parse correctly.\n function findStartLine(cm, n, precise) {\n var minindent, minline, doc = cm.doc;\n var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100);\n for (var search = n; search > lim; --search) {\n if (search <= doc.first) { return doc.first }\n var line = getLine(doc, search - 1), after = line.stateAfter;\n if (after && (!precise || search + (after instanceof SavedContext ? after.lookAhead : 0) <= doc.modeFrontier))\n { return search }\n var indented = countColumn(line.text, null, cm.options.tabSize);\n if (minline == null || minindent > indented) {\n minline = search - 1;\n minindent = indented;\n }\n }\n return minline\n }\n\n function retreatFrontier(doc, n) {\n doc.modeFrontier = Math.min(doc.modeFrontier, n);\n if (doc.highlightFrontier < n - 10) { return }\n var start = doc.first;\n for (var line = n - 1; line > start; line--) {\n var saved = getLine(doc, line).stateAfter;\n // change is on 3\n // state on line 1 looked ahead 2 -- so saw 3\n // test 1 + 2 < 3 should cover this\n if (saved && (!(saved instanceof SavedContext) || line + saved.lookAhead < n)) {\n start = line + 1;\n break\n }\n }\n doc.highlightFrontier = Math.min(doc.highlightFrontier, start);\n }\n\n // LINE DATA STRUCTURE\n\n // Line objects. These hold state related to a line, including\n // highlighting info (the styles array).\n var Line = function(text, markedSpans, estimateHeight) {\n this.text = text;\n attachMarkedSpans(this, markedSpans);\n this.height = estimateHeight ? estimateHeight(this) : 1;\n };\n\n Line.prototype.lineNo = function () { return lineNo(this) };\n eventMixin(Line);\n\n // Change the content (text, markers) of a line. Automatically\n // invalidates cached information and tries to re-estimate the\n // line's height.\n function updateLine(line, text, markedSpans, estimateHeight) {\n line.text = text;\n if (line.stateAfter) { line.stateAfter = null; }\n if (line.styles) { line.styles = null; }\n if (line.order != null) { line.order = null; }\n detachMarkedSpans(line);\n attachMarkedSpans(line, markedSpans);\n var estHeight = estimateHeight ? estimateHeight(line) : 1;\n if (estHeight != line.height) { updateLineHeight(line, estHeight); }\n }\n\n // Detach a line from the document tree and its markers.\n function cleanUpLine(line) {\n line.parent = null;\n detachMarkedSpans(line);\n }\n\n // Convert a style as returned by a mode (either null, or a string\n // containing one or more styles) to a CSS style. This is cached,\n // and also looks for line-wide styles.\n var styleToClassCache = {}, styleToClassCacheWithMode = {};\n function interpretTokenStyle(style, options) {\n if (!style || /^\\s*$/.test(style)) { return null }\n var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache;\n return cache[style] ||\n (cache[style] = style.replace(/\\S+/g, \"cm-$&\"))\n }\n\n // Render the DOM representation of the text of a line. Also builds\n // up a 'line map', which points at the DOM nodes that represent\n // specific stretches of text, and is used by the measuring code.\n // The returned object contains the DOM node, this map, and\n // information about line-wide styles that were set by the mode.\n function buildLineContent(cm, lineView) {\n // The padding-right forces the element to have a 'border', which\n // is needed on Webkit to be able to get line-level bounding\n // rectangles for it (in measureChar).\n var content = eltP(\"span\", null, null, webkit ? \"padding-right: .1px\" : null);\n var builder = {pre: eltP(\"pre\", [content], \"CodeMirror-line\"), content: content,\n col: 0, pos: 0, cm: cm,\n trailingSpace: false,\n splitSpaces: cm.getOption(\"lineWrapping\")};\n lineView.measure = {};\n\n // Iterate over the logical lines that make up this visual line.\n for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {\n var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0);\n builder.pos = 0;\n builder.addToken = buildToken;\n // Optionally wire in some hacks into the token-rendering\n // algorithm, to deal with browser quirks.\n if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line, cm.doc.direction)))\n { builder.addToken = buildTokenBadBidi(builder.addToken, order); }\n builder.map = [];\n var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line);\n insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate));\n if (line.styleClasses) {\n if (line.styleClasses.bgClass)\n { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || \"\"); }\n if (line.styleClasses.textClass)\n { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || \"\"); }\n }\n\n // Ensure at least a single node is present, for measuring.\n if (builder.map.length == 0)\n { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))); }\n\n // Store the map and a cache object for the current logical line\n if (i == 0) {\n lineView.measure.map = builder.map;\n lineView.measure.cache = {};\n } else {\n (lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)\n ;(lineView.measure.caches || (lineView.measure.caches = [])).push({});\n }\n }\n\n // See issue #2901\n if (webkit) {\n var last = builder.content.lastChild;\n if (/\\bcm-tab\\b/.test(last.className) || (last.querySelector && last.querySelector(\".cm-tab\")))\n { builder.content.className = \"cm-tab-wrap-hack\"; }\n }\n\n signal(cm, \"renderLine\", cm, lineView.line, builder.pre);\n if (builder.pre.className)\n { builder.textClass = joinClasses(builder.pre.className, builder.textClass || \"\"); }\n\n return builder\n }\n\n function defaultSpecialCharPlaceholder(ch) {\n var token = elt(\"span\", \"\\u2022\", \"cm-invalidchar\");\n token.title = \"\\\\u\" + ch.charCodeAt(0).toString(16);\n token.setAttribute(\"aria-label\", token.title);\n return token\n }\n\n // Build up the DOM representation for a single token, and add it to\n // the line map. Takes care to render special characters separately.\n function buildToken(builder, text, style, startStyle, endStyle, css, attributes) {\n if (!text) { return }\n var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text;\n var special = builder.cm.state.specialChars, mustWrap = false;\n var content;\n if (!special.test(text)) {\n builder.col += text.length;\n content = document.createTextNode(displayText);\n builder.map.push(builder.pos, builder.pos + text.length, content);\n if (ie && ie_version < 9) { mustWrap = true; }\n builder.pos += text.length;\n } else {\n content = document.createDocumentFragment();\n var pos = 0;\n while (true) {\n special.lastIndex = pos;\n var m = special.exec(text);\n var skipped = m ? m.index - pos : text.length - pos;\n if (skipped) {\n var txt = document.createTextNode(displayText.slice(pos, pos + skipped));\n if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt])); }\n else { content.appendChild(txt); }\n builder.map.push(builder.pos, builder.pos + skipped, txt);\n builder.col += skipped;\n builder.pos += skipped;\n }\n if (!m) { break }\n pos += skipped + 1;\n var txt$1 = (void 0);\n if (m[0] == \"\\t\") {\n var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize;\n txt$1 = content.appendChild(elt(\"span\", spaceStr(tabWidth), \"cm-tab\"));\n txt$1.setAttribute(\"role\", \"presentation\");\n txt$1.setAttribute(\"cm-text\", \"\\t\");\n builder.col += tabWidth;\n } else if (m[0] == \"\\r\" || m[0] == \"\\n\") {\n txt$1 = content.appendChild(elt(\"span\", m[0] == \"\\r\" ? \"\\u240d\" : \"\\u2424\", \"cm-invalidchar\"));\n txt$1.setAttribute(\"cm-text\", m[0]);\n builder.col += 1;\n } else {\n txt$1 = builder.cm.options.specialCharPlaceholder(m[0]);\n txt$1.setAttribute(\"cm-text\", m[0]);\n if (ie && ie_version < 9) { content.appendChild(elt(\"span\", [txt$1])); }\n else { content.appendChild(txt$1); }\n builder.col += 1;\n }\n builder.map.push(builder.pos, builder.pos + 1, txt$1);\n builder.pos++;\n }\n }\n builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32;\n if (style || startStyle || endStyle || mustWrap || css) {\n var fullStyle = style || \"\";\n if (startStyle) { fullStyle += startStyle; }\n if (endStyle) { fullStyle += endStyle; }\n var token = elt(\"span\", [content], fullStyle, css);\n if (attributes) {\n for (var attr in attributes) { if (attributes.hasOwnProperty(attr) && attr != \"style\" && attr != \"class\")\n { token.setAttribute(attr, attributes[attr]); } }\n }\n return builder.content.appendChild(token)\n }\n builder.content.appendChild(content);\n }\n\n // Change some spaces to NBSP to prevent the browser from collapsing\n // trailing spaces at the end of a line when rendering text (issue #1362).\n function splitSpaces(text, trailingBefore) {\n if (text.length > 1 && !/ /.test(text)) { return text }\n var spaceBefore = trailingBefore, result = \"\";\n for (var i = 0; i < text.length; i++) {\n var ch = text.charAt(i);\n if (ch == \" \" && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))\n { ch = \"\\u00a0\"; }\n result += ch;\n spaceBefore = ch == \" \";\n }\n return result\n }\n\n // Work around nonsense dimensions being reported for stretches of\n // right-to-left text.\n function buildTokenBadBidi(inner, order) {\n return function (builder, text, style, startStyle, endStyle, css, attributes) {\n style = style ? style + \" cm-force-border\" : \"cm-force-border\";\n var start = builder.pos, end = start + text.length;\n for (;;) {\n // Find the part that overlaps with the start of this text\n var part = (void 0);\n for (var i = 0; i < order.length; i++) {\n part = order[i];\n if (part.to > start && part.from <= start) { break }\n }\n if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, css, attributes) }\n inner(builder, text.slice(0, part.to - start), style, startStyle, null, css, attributes);\n startStyle = null;\n text = text.slice(part.to - start);\n start = part.to;\n }\n }\n }\n\n function buildCollapsedSpan(builder, size, marker, ignoreWidget) {\n var widget = !ignoreWidget && marker.widgetNode;\n if (widget) { builder.map.push(builder.pos, builder.pos + size, widget); }\n if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {\n if (!widget)\n { widget = builder.content.appendChild(document.createElement(\"span\")); }\n widget.setAttribute(\"cm-marker\", marker.id);\n }\n if (widget) {\n builder.cm.display.input.setUneditable(widget);\n builder.content.appendChild(widget);\n }\n builder.pos += size;\n builder.trailingSpace = false;\n }\n\n // Outputs a number of spans to make up a line, taking highlighting\n // and marked text into account.\n function insertLineContent(line, builder, styles) {\n var spans = line.markedSpans, allText = line.text, at = 0;\n if (!spans) {\n for (var i$1 = 1; i$1 < styles.length; i$1+=2)\n { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)); }\n return\n }\n\n var len = allText.length, pos = 0, i = 1, text = \"\", style, css;\n var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, collapsed, attributes;\n for (;;) {\n if (nextChange == pos) { // Update current marker set\n spanStyle = spanEndStyle = spanStartStyle = css = \"\";\n attributes = null;\n collapsed = null; nextChange = Infinity;\n var foundBookmarks = [], endStyles = (void 0);\n for (var j = 0; j < spans.length; ++j) {\n var sp = spans[j], m = sp.marker;\n if (m.type == \"bookmark\" && sp.from == pos && m.widgetNode) {\n foundBookmarks.push(m);\n } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {\n if (sp.to != null && sp.to != pos && nextChange > sp.to) {\n nextChange = sp.to;\n spanEndStyle = \"\";\n }\n if (m.className) { spanStyle += \" \" + m.className; }\n if (m.css) { css = (css ? css + \";\" : \"\") + m.css; }\n if (m.startStyle && sp.from == pos) { spanStartStyle += \" \" + m.startStyle; }\n if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to); }\n // support for the old title property\n // https://github.com/codemirror/CodeMirror/pull/5673\n if (m.title) { (attributes || (attributes = {})).title = m.title; }\n if (m.attributes) {\n for (var attr in m.attributes)\n { (attributes || (attributes = {}))[attr] = m.attributes[attr]; }\n }\n if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))\n { collapsed = sp; }\n } else if (sp.from > pos && nextChange > sp.from) {\n nextChange = sp.from;\n }\n }\n if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)\n { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += \" \" + endStyles[j$1]; } } }\n\n if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)\n { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]); } }\n if (collapsed && (collapsed.from || 0) == pos) {\n buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,\n collapsed.marker, collapsed.from == null);\n if (collapsed.to == null) { return }\n if (collapsed.to == pos) { collapsed = false; }\n }\n }\n if (pos >= len) { break }\n\n var upto = Math.min(len, nextChange);\n while (true) {\n if (text) {\n var end = pos + text.length;\n if (!collapsed) {\n var tokenText = end > upto ? text.slice(0, upto - pos) : text;\n builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,\n spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : \"\", css, attributes);\n }\n if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}\n pos = end;\n spanStartStyle = \"\";\n }\n text = allText.slice(at, at = styles[i++]);\n style = interpretTokenStyle(styles[i++], builder.cm.options);\n }\n }\n }\n\n\n // These objects are used to represent the visible (currently drawn)\n // part of the document. A LineView may correspond to multiple\n // logical lines, if those are connected by collapsed ranges.\n function LineView(doc, line, lineN) {\n // The starting line\n this.line = line;\n // Continuing lines, if any\n this.rest = visualLineContinued(line);\n // Number of logical lines in this visual line\n this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;\n this.node = this.text = null;\n this.hidden = lineIsHidden(doc, line);\n }\n\n // Create a range of LineView objects for the given lines.\n function buildViewArray(cm, from, to) {\n var array = [], nextPos;\n for (var pos = from; pos < to; pos = nextPos) {\n var view = new LineView(cm.doc, getLine(cm.doc, pos), pos);\n nextPos = pos + view.size;\n array.push(view);\n }\n return array\n }\n\n var operationGroup = null;\n\n function pushOperation(op) {\n if (operationGroup) {\n operationGroup.ops.push(op);\n } else {\n op.ownsGroup = operationGroup = {\n ops: [op],\n delayedCallbacks: []\n };\n }\n }\n\n function fireCallbacksForOps(group) {\n // Calls delayed callbacks and cursorActivity handlers until no\n // new ones appear\n var callbacks = group.delayedCallbacks, i = 0;\n do {\n for (; i < callbacks.length; i++)\n { callbacks[i].call(null); }\n for (var j = 0; j < group.ops.length; j++) {\n var op = group.ops[j];\n if (op.cursorActivityHandlers)\n { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)\n { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm); } }\n }\n } while (i < callbacks.length)\n }\n\n function finishOperation(op, endCb) {\n var group = op.ownsGroup;\n if (!group) { return }\n\n try { fireCallbacksForOps(group); }\n finally {\n operationGroup = null;\n endCb(group);\n }\n }\n\n var orphanDelayedCallbacks = null;\n\n // Often, we want to signal events at a point where we are in the\n // middle of some work, but don't want the handler to start calling\n // other methods on the editor, which might be in an inconsistent\n // state or simply not expect any other events to happen.\n // signalLater looks whether there are any handlers, and schedules\n // them to be executed when the last operation ends, or, if no\n // operation is active, when a timeout fires.\n function signalLater(emitter, type /*, values...*/) {\n var arr = getHandlers(emitter, type);\n if (!arr.length) { return }\n var args = Array.prototype.slice.call(arguments, 2), list;\n if (operationGroup) {\n list = operationGroup.delayedCallbacks;\n } else if (orphanDelayedCallbacks) {\n list = orphanDelayedCallbacks;\n } else {\n list = orphanDelayedCallbacks = [];\n setTimeout(fireOrphanDelayed, 0);\n }\n var loop = function ( i ) {\n list.push(function () { return arr[i].apply(null, args); });\n };\n\n for (var i = 0; i < arr.length; ++i)\n loop( i );\n }\n\n function fireOrphanDelayed() {\n var delayed = orphanDelayedCallbacks;\n orphanDelayedCallbacks = null;\n for (var i = 0; i < delayed.length; ++i) { delayed[i](); }\n }\n\n // When an aspect of a line changes, a string is added to\n // lineView.changes. This updates the relevant part of the line's\n // DOM structure.\n function updateLineForChanges(cm, lineView, lineN, dims) {\n for (var j = 0; j < lineView.changes.length; j++) {\n var type = lineView.changes[j];\n if (type == \"text\") { updateLineText(cm, lineView); }\n else if (type == \"gutter\") { updateLineGutter(cm, lineView, lineN, dims); }\n else if (type == \"class\") { updateLineClasses(cm, lineView); }\n else if (type == \"widget\") { updateLineWidgets(cm, lineView, dims); }\n }\n lineView.changes = null;\n }\n\n // Lines with gutter elements, widgets or a background class need to\n // be wrapped, and have the extra elements added to the wrapper div\n function ensureLineWrapped(lineView) {\n if (lineView.node == lineView.text) {\n lineView.node = elt(\"div\", null, null, \"position: relative\");\n if (lineView.text.parentNode)\n { lineView.text.parentNode.replaceChild(lineView.node, lineView.text); }\n lineView.node.appendChild(lineView.text);\n if (ie && ie_version < 8) { lineView.node.style.zIndex = 2; }\n }\n return lineView.node\n }\n\n function updateLineBackground(cm, lineView) {\n var cls = lineView.bgClass ? lineView.bgClass + \" \" + (lineView.line.bgClass || \"\") : lineView.line.bgClass;\n if (cls) { cls += \" CodeMirror-linebackground\"; }\n if (lineView.background) {\n if (cls) { lineView.background.className = cls; }\n else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null; }\n } else if (cls) {\n var wrap = ensureLineWrapped(lineView);\n lineView.background = wrap.insertBefore(elt(\"div\", null, cls), wrap.firstChild);\n cm.display.input.setUneditable(lineView.background);\n }\n }\n\n // Wrapper around buildLineContent which will reuse the structure\n // in display.externalMeasured when possible.\n function getLineContent(cm, lineView) {\n var ext = cm.display.externalMeasured;\n if (ext && ext.line == lineView.line) {\n cm.display.externalMeasured = null;\n lineView.measure = ext.measure;\n return ext.built\n }\n return buildLineContent(cm, lineView)\n }\n\n // Redraw the line's text. Interacts with the background and text\n // classes because the mode may output tokens that influence these\n // classes.\n function updateLineText(cm, lineView) {\n var cls = lineView.text.className;\n var built = getLineContent(cm, lineView);\n if (lineView.text == lineView.node) { lineView.node = built.pre; }\n lineView.text.parentNode.replaceChild(built.pre, lineView.text);\n lineView.text = built.pre;\n if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {\n lineView.bgClass = built.bgClass;\n lineView.textClass = built.textClass;\n updateLineClasses(cm, lineView);\n } else if (cls) {\n lineView.text.className = cls;\n }\n }\n\n function updateLineClasses(cm, lineView) {\n updateLineBackground(cm, lineView);\n if (lineView.line.wrapClass)\n { ensureLineWrapped(lineView).className = lineView.line.wrapClass; }\n else if (lineView.node != lineView.text)\n { lineView.node.className = \"\"; }\n var textClass = lineView.textClass ? lineView.textClass + \" \" + (lineView.line.textClass || \"\") : lineView.line.textClass;\n lineView.text.className = textClass || \"\";\n }\n\n function updateLineGutter(cm, lineView, lineN, dims) {\n if (lineView.gutter) {\n lineView.node.removeChild(lineView.gutter);\n lineView.gutter = null;\n }\n if (lineView.gutterBackground) {\n lineView.node.removeChild(lineView.gutterBackground);\n lineView.gutterBackground = null;\n }\n if (lineView.line.gutterClass) {\n var wrap = ensureLineWrapped(lineView);\n lineView.gutterBackground = elt(\"div\", null, \"CodeMirror-gutter-background \" + lineView.line.gutterClass,\n (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px; width: \" + (dims.gutterTotalWidth) + \"px\"));\n cm.display.input.setUneditable(lineView.gutterBackground);\n wrap.insertBefore(lineView.gutterBackground, lineView.text);\n }\n var markers = lineView.line.gutterMarkers;\n if (cm.options.lineNumbers || markers) {\n var wrap$1 = ensureLineWrapped(lineView);\n var gutterWrap = lineView.gutter = elt(\"div\", null, \"CodeMirror-gutter-wrapper\", (\"left: \" + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + \"px\"));\n cm.display.input.setUneditable(gutterWrap);\n wrap$1.insertBefore(gutterWrap, lineView.text);\n if (lineView.line.gutterClass)\n { gutterWrap.className += \" \" + lineView.line.gutterClass; }\n if (cm.options.lineNumbers && (!markers || !markers[\"CodeMirror-linenumbers\"]))\n { lineView.lineNumber = gutterWrap.appendChild(\n elt(\"div\", lineNumberFor(cm.options, lineN),\n \"CodeMirror-linenumber CodeMirror-gutter-elt\",\n (\"left: \" + (dims.gutterLeft[\"CodeMirror-linenumbers\"]) + \"px; width: \" + (cm.display.lineNumInnerWidth) + \"px\"))); }\n if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {\n var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id];\n if (found)\n { gutterWrap.appendChild(elt(\"div\", [found], \"CodeMirror-gutter-elt\",\n (\"left: \" + (dims.gutterLeft[id]) + \"px; width: \" + (dims.gutterWidth[id]) + \"px\"))); }\n } }\n }\n }\n\n function updateLineWidgets(cm, lineView, dims) {\n if (lineView.alignable) { lineView.alignable = null; }\n for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {\n next = node.nextSibling;\n if (node.className == \"CodeMirror-linewidget\")\n { lineView.node.removeChild(node); }\n }\n insertLineWidgets(cm, lineView, dims);\n }\n\n // Build a line's DOM representation from scratch\n function buildLineElement(cm, lineView, lineN, dims) {\n var built = getLineContent(cm, lineView);\n lineView.text = lineView.node = built.pre;\n if (built.bgClass) { lineView.bgClass = built.bgClass; }\n if (built.textClass) { lineView.textClass = built.textClass; }\n\n updateLineClasses(cm, lineView);\n updateLineGutter(cm, lineView, lineN, dims);\n insertLineWidgets(cm, lineView, dims);\n return lineView.node\n }\n\n // A lineView may contain multiple logical lines (when merged by\n // collapsed spans). The widgets for all of them need to be drawn.\n function insertLineWidgets(cm, lineView, dims) {\n insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);\n if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false); } }\n }\n\n function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {\n if (!line.widgets) { return }\n var wrap = ensureLineWrapped(lineView);\n for (var i = 0, ws = line.widgets; i < ws.length; ++i) {\n var widget = ws[i], node = elt(\"div\", [widget.node], \"CodeMirror-linewidget\");\n if (!widget.handleMouseEvents) { node.setAttribute(\"cm-ignore-events\", \"true\"); }\n positionLineWidget(widget, node, lineView, dims);\n cm.display.input.setUneditable(node);\n if (allowAbove && widget.above)\n { wrap.insertBefore(node, lineView.gutter || lineView.text); }\n else\n { wrap.appendChild(node); }\n signalLater(widget, \"redraw\");\n }\n }\n\n function positionLineWidget(widget, node, lineView, dims) {\n if (widget.noHScroll) {\n (lineView.alignable || (lineView.alignable = [])).push(node);\n var width = dims.wrapperWidth;\n node.style.left = dims.fixedPos + \"px\";\n if (!widget.coverGutter) {\n width -= dims.gutterTotalWidth;\n node.style.paddingLeft = dims.gutterTotalWidth + \"px\";\n }\n node.style.width = width + \"px\";\n }\n if (widget.coverGutter) {\n node.style.zIndex = 5;\n node.style.position = \"relative\";\n if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + \"px\"; }\n }\n }\n\n function widgetHeight(widget) {\n if (widget.height != null) { return widget.height }\n var cm = widget.doc.cm;\n if (!cm) { return 0 }\n if (!contains(document.body, widget.node)) {\n var parentStyle = \"position: relative;\";\n if (widget.coverGutter)\n { parentStyle += \"margin-left: -\" + cm.display.gutters.offsetWidth + \"px;\"; }\n if (widget.noHScroll)\n { parentStyle += \"width: \" + cm.display.wrapper.clientWidth + \"px;\"; }\n removeChildrenAndAdd(cm.display.measure, elt(\"div\", [widget.node], null, parentStyle));\n }\n return widget.height = widget.node.parentNode.offsetHeight\n }\n\n // Return true when the given mouse event happened in a widget\n function eventInWidget(display, e) {\n for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {\n if (!n || (n.nodeType == 1 && n.getAttribute(\"cm-ignore-events\") == \"true\") ||\n (n.parentNode == display.sizer && n != display.mover))\n { return true }\n }\n }\n\n // POSITION MEASUREMENT\n\n function paddingTop(display) {return display.lineSpace.offsetTop}\n function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}\n function paddingH(display) {\n if (display.cachedPaddingH) { return display.cachedPaddingH }\n var e = removeChildrenAndAdd(display.measure, elt(\"pre\", \"x\"));\n var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle;\n var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)};\n if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data; }\n return data\n }\n\n function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }\n function displayWidth(cm) {\n return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth\n }\n function displayHeight(cm) {\n return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight\n }\n\n // Ensure the lineView.wrapping.heights array is populated. This is\n // an array of bottom offsets for the lines that make up a drawn\n // line. When lineWrapping is on, there might be more than one\n // height.\n function ensureLineHeights(cm, lineView, rect) {\n var wrapping = cm.options.lineWrapping;\n var curWidth = wrapping && displayWidth(cm);\n if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {\n var heights = lineView.measure.heights = [];\n if (wrapping) {\n lineView.measure.width = curWidth;\n var rects = lineView.text.firstChild.getClientRects();\n for (var i = 0; i < rects.length - 1; i++) {\n var cur = rects[i], next = rects[i + 1];\n if (Math.abs(cur.bottom - next.bottom) > 2)\n { heights.push((cur.bottom + next.top) / 2 - rect.top); }\n }\n }\n heights.push(rect.bottom - rect.top);\n }\n }\n\n // Find a line map (mapping character offsets to text nodes) and a\n // measurement cache for the given line number. (A line view might\n // contain multiple lines when collapsed ranges are present.)\n function mapFromLineView(lineView, line, lineN) {\n if (lineView.line == line)\n { return {map: lineView.measure.map, cache: lineView.measure.cache} }\n for (var i = 0; i < lineView.rest.length; i++)\n { if (lineView.rest[i] == line)\n { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }\n for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)\n { if (lineNo(lineView.rest[i$1]) > lineN)\n { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }\n }\n\n // Render a line into the hidden node display.externalMeasured. Used\n // when measurement is needed for a line that's not in the viewport.\n function updateExternalMeasurement(cm, line) {\n line = visualLine(line);\n var lineN = lineNo(line);\n var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN);\n view.lineN = lineN;\n var built = view.built = buildLineContent(cm, view);\n view.text = built.pre;\n removeChildrenAndAdd(cm.display.lineMeasure, built.pre);\n return view\n }\n\n // Get a {top, bottom, left, right} box (in line-local coordinates)\n // for a given character.\n function measureChar(cm, line, ch, bias) {\n return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)\n }\n\n // Find a line view that corresponds to the given line number.\n function findViewForLine(cm, lineN) {\n if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)\n { return cm.display.view[findViewIndex(cm, lineN)] }\n var ext = cm.display.externalMeasured;\n if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)\n { return ext }\n }\n\n // Measurement can be split in two steps, the set-up work that\n // applies to the whole line, and the measurement of the actual\n // character. Functions like coordsChar, that need to do a lot of\n // measurements in a row, can thus ensure that the set-up work is\n // only done once.\n function prepareMeasureForLine(cm, line) {\n var lineN = lineNo(line);\n var view = findViewForLine(cm, lineN);\n if (view && !view.text) {\n view = null;\n } else if (view && view.changes) {\n updateLineForChanges(cm, view, lineN, getDimensions(cm));\n cm.curOp.forceUpdate = true;\n }\n if (!view)\n { view = updateExternalMeasurement(cm, line); }\n\n var info = mapFromLineView(view, line, lineN);\n return {\n line: line, view: view, rect: null,\n map: info.map, cache: info.cache, before: info.before,\n hasHeights: false\n }\n }\n\n // Given a prepared measurement object, measures the position of an\n // actual character (or fetches it from the cache).\n function measureCharPrepared(cm, prepared, ch, bias, varHeight) {\n if (prepared.before) { ch = -1; }\n var key = ch + (bias || \"\"), found;\n if (prepared.cache.hasOwnProperty(key)) {\n found = prepared.cache[key];\n } else {\n if (!prepared.rect)\n { prepared.rect = prepared.view.text.getBoundingClientRect(); }\n if (!prepared.hasHeights) {\n ensureLineHeights(cm, prepared.view, prepared.rect);\n prepared.hasHeights = true;\n }\n found = measureCharInner(cm, prepared, ch, bias);\n if (!found.bogus) { prepared.cache[key] = found; }\n }\n return {left: found.left, right: found.right,\n top: varHeight ? found.rtop : found.top,\n bottom: varHeight ? found.rbottom : found.bottom}\n }\n\n var nullRect = {left: 0, right: 0, top: 0, bottom: 0};\n\n function nodeAndOffsetInLineMap(map$$1, ch, bias) {\n var node, start, end, collapse, mStart, mEnd;\n // First, search the line map for the text node corresponding to,\n // or closest to, the target character.\n for (var i = 0; i < map$$1.length; i += 3) {\n mStart = map$$1[i];\n mEnd = map$$1[i + 1];\n if (ch < mStart) {\n start = 0; end = 1;\n collapse = \"left\";\n } else if (ch < mEnd) {\n start = ch - mStart;\n end = start + 1;\n } else if (i == map$$1.length - 3 || ch == mEnd && map$$1[i + 3] > ch) {\n end = mEnd - mStart;\n start = end - 1;\n if (ch >= mEnd) { collapse = \"right\"; }\n }\n if (start != null) {\n node = map$$1[i + 2];\n if (mStart == mEnd && bias == (node.insertLeft ? \"left\" : \"right\"))\n { collapse = bias; }\n if (bias == \"left\" && start == 0)\n { while (i && map$$1[i - 2] == map$$1[i - 3] && map$$1[i - 1].insertLeft) {\n node = map$$1[(i -= 3) + 2];\n collapse = \"left\";\n } }\n if (bias == \"right\" && start == mEnd - mStart)\n { while (i < map$$1.length - 3 && map$$1[i + 3] == map$$1[i + 4] && !map$$1[i + 5].insertLeft) {\n node = map$$1[(i += 3) + 2];\n collapse = \"right\";\n } }\n break\n }\n }\n return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}\n }\n\n function getUsefulRect(rects, bias) {\n var rect = nullRect;\n if (bias == \"left\") { for (var i = 0; i < rects.length; i++) {\n if ((rect = rects[i]).left != rect.right) { break }\n } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {\n if ((rect = rects[i$1]).left != rect.right) { break }\n } }\n return rect\n }\n\n function measureCharInner(cm, prepared, ch, bias) {\n var place = nodeAndOffsetInLineMap(prepared.map, ch, bias);\n var node = place.node, start = place.start, end = place.end, collapse = place.collapse;\n\n var rect;\n if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.\n for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned\n while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start; }\n while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end; }\n if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)\n { rect = node.parentNode.getBoundingClientRect(); }\n else\n { rect = getUsefulRect(range(node, start, end).getClientRects(), bias); }\n if (rect.left || rect.right || start == 0) { break }\n end = start;\n start = start - 1;\n collapse = \"right\";\n }\n if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect); }\n } else { // If it is a widget, simply get the box for the whole widget.\n if (start > 0) { collapse = bias = \"right\"; }\n var rects;\n if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)\n { rect = rects[bias == \"right\" ? rects.length - 1 : 0]; }\n else\n { rect = node.getBoundingClientRect(); }\n }\n if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {\n var rSpan = node.parentNode.getClientRects()[0];\n if (rSpan)\n { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom}; }\n else\n { rect = nullRect; }\n }\n\n var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top;\n var mid = (rtop + rbot) / 2;\n var heights = prepared.view.measure.heights;\n var i = 0;\n for (; i < heights.length - 1; i++)\n { if (mid < heights[i]) { break } }\n var top = i ? heights[i - 1] : 0, bot = heights[i];\n var result = {left: (collapse == \"right\" ? rect.right : rect.left) - prepared.rect.left,\n right: (collapse == \"left\" ? rect.left : rect.right) - prepared.rect.left,\n top: top, bottom: bot};\n if (!rect.left && !rect.right) { result.bogus = true; }\n if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot; }\n\n return result\n }\n\n // Work around problem with bounding client rects on ranges being\n // returned incorrectly when zoomed on IE10 and below.\n function maybeUpdateRectForZooming(measure, rect) {\n if (!window.screen || screen.logicalXDPI == null ||\n screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))\n { return rect }\n var scaleX = screen.logicalXDPI / screen.deviceXDPI;\n var scaleY = screen.logicalYDPI / screen.deviceYDPI;\n return {left: rect.left * scaleX, right: rect.right * scaleX,\n top: rect.top * scaleY, bottom: rect.bottom * scaleY}\n }\n\n function clearLineMeasurementCacheFor(lineView) {\n if (lineView.measure) {\n lineView.measure.cache = {};\n lineView.measure.heights = null;\n if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)\n { lineView.measure.caches[i] = {}; } }\n }\n }\n\n function clearLineMeasurementCache(cm) {\n cm.display.externalMeasure = null;\n removeChildren(cm.display.lineMeasure);\n for (var i = 0; i < cm.display.view.length; i++)\n { clearLineMeasurementCacheFor(cm.display.view[i]); }\n }\n\n function clearCaches(cm) {\n clearLineMeasurementCache(cm);\n cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null;\n if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true; }\n cm.display.lineNumChars = null;\n }\n\n function pageScrollX() {\n // Work around https://bugs.chromium.org/p/chromium/issues/detail?id=489206\n // which causes page_Offset and bounding client rects to use\n // different reference viewports and invalidate our calculations.\n if (chrome && android) { return -(document.body.getBoundingClientRect().left - parseInt(getComputedStyle(document.body).marginLeft)) }\n return window.pageXOffset || (document.documentElement || document.body).scrollLeft\n }\n function pageScrollY() {\n if (chrome && android) { return -(document.body.getBoundingClientRect().top - parseInt(getComputedStyle(document.body).marginTop)) }\n return window.pageYOffset || (document.documentElement || document.body).scrollTop\n }\n\n function widgetTopHeight(lineObj) {\n var height = 0;\n if (lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above)\n { height += widgetHeight(lineObj.widgets[i]); } } }\n return height\n }\n\n // Converts a {top, bottom, left, right} box from line-local\n // coordinates into another coordinate system. Context may be one of\n // \"line\", \"div\" (display.lineDiv), \"local\"./null (editor), \"window\",\n // or \"page\".\n function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {\n if (!includeWidgets) {\n var height = widgetTopHeight(lineObj);\n rect.top += height; rect.bottom += height;\n }\n if (context == \"line\") { return rect }\n if (!context) { context = \"local\"; }\n var yOff = heightAtLine(lineObj);\n if (context == \"local\") { yOff += paddingTop(cm.display); }\n else { yOff -= cm.display.viewOffset; }\n if (context == \"page\" || context == \"window\") {\n var lOff = cm.display.lineSpace.getBoundingClientRect();\n yOff += lOff.top + (context == \"window\" ? 0 : pageScrollY());\n var xOff = lOff.left + (context == \"window\" ? 0 : pageScrollX());\n rect.left += xOff; rect.right += xOff;\n }\n rect.top += yOff; rect.bottom += yOff;\n return rect\n }\n\n // Coverts a box from \"div\" coords to another coordinate system.\n // Context may be \"window\", \"page\", \"div\", or \"local\"./null.\n function fromCoordSystem(cm, coords, context) {\n if (context == \"div\") { return coords }\n var left = coords.left, top = coords.top;\n // First move into \"page\" coordinate system\n if (context == \"page\") {\n left -= pageScrollX();\n top -= pageScrollY();\n } else if (context == \"local\" || !context) {\n var localBox = cm.display.sizer.getBoundingClientRect();\n left += localBox.left;\n top += localBox.top;\n }\n\n var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();\n return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}\n }\n\n function charCoords(cm, pos, context, lineObj, bias) {\n if (!lineObj) { lineObj = getLine(cm.doc, pos.line); }\n return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)\n }\n\n // Returns a box for a given cursor position, which may have an\n // 'other' property containing the position of the secondary cursor\n // on a bidi boundary.\n // A cursor Pos(line, char, \"before\") is on the same visual line as `char - 1`\n // and after `char - 1` in writing order of `char - 1`\n // A cursor Pos(line, char, \"after\") is on the same visual line as `char`\n // and before `char` in writing order of `char`\n // Examples (upper-case letters are RTL, lower-case are LTR):\n // Pos(0, 1, ...)\n // before after\n // ab a|b a|b\n // aB a|B aB|\n // Ab |Ab A|b\n // AB B|A B|A\n // Every position after the last character on a line is considered to stick\n // to the last character on the line.\n function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {\n lineObj = lineObj || getLine(cm.doc, pos.line);\n if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); }\n function get(ch, right) {\n var m = measureCharPrepared(cm, preparedMeasure, ch, right ? \"right\" : \"left\", varHeight);\n if (right) { m.left = m.right; } else { m.right = m.left; }\n return intoCoordSystem(cm, lineObj, m, context)\n }\n var order = getOrder(lineObj, cm.doc.direction), ch = pos.ch, sticky = pos.sticky;\n if (ch >= lineObj.text.length) {\n ch = lineObj.text.length;\n sticky = \"before\";\n } else if (ch <= 0) {\n ch = 0;\n sticky = \"after\";\n }\n if (!order) { return get(sticky == \"before\" ? ch - 1 : ch, sticky == \"before\") }\n\n function getBidi(ch, partPos, invert) {\n var part = order[partPos], right = part.level == 1;\n return get(invert ? ch - 1 : ch, right != invert)\n }\n var partPos = getBidiPartAt(order, ch, sticky);\n var other = bidiOther;\n var val = getBidi(ch, partPos, sticky == \"before\");\n if (other != null) { val.other = getBidi(ch, other, sticky != \"before\"); }\n return val\n }\n\n // Used to cheaply estimate the coordinates for a position. Used for\n // intermediate scroll updates.\n function estimateCoords(cm, pos) {\n var left = 0;\n pos = clipPos(cm.doc, pos);\n if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch; }\n var lineObj = getLine(cm.doc, pos.line);\n var top = heightAtLine(lineObj) + paddingTop(cm.display);\n return {left: left, right: left, top: top, bottom: top + lineObj.height}\n }\n\n // Positions returned by coordsChar contain some extra information.\n // xRel is the relative x position of the input coordinates compared\n // to the found position (so xRel > 0 means the coordinates are to\n // the right of the character position, for example). When outside\n // is true, that means the coordinates lie outside the line's\n // vertical range.\n function PosWithInfo(line, ch, sticky, outside, xRel) {\n var pos = Pos(line, ch, sticky);\n pos.xRel = xRel;\n if (outside) { pos.outside = true; }\n return pos\n }\n\n // Compute the character position closest to the given coordinates.\n // Input must be lineSpace-local (\"div\" coordinate system).\n function coordsChar(cm, x, y) {\n var doc = cm.doc;\n y += cm.display.viewOffset;\n if (y < 0) { return PosWithInfo(doc.first, 0, null, true, -1) }\n var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1;\n if (lineN > last)\n { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, null, true, 1) }\n if (x < 0) { x = 0; }\n\n var lineObj = getLine(doc, lineN);\n for (;;) {\n var found = coordsCharInner(cm, lineObj, lineN, x, y);\n var collapsed = collapsedSpanAround(lineObj, found.ch + (found.xRel > 0 ? 1 : 0));\n if (!collapsed) { return found }\n var rangeEnd = collapsed.find(1);\n if (rangeEnd.line == lineN) { return rangeEnd }\n lineObj = getLine(doc, lineN = rangeEnd.line);\n }\n }\n\n function wrappedLineExtent(cm, lineObj, preparedMeasure, y) {\n y -= widgetTopHeight(lineObj);\n var end = lineObj.text.length;\n var begin = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch - 1).bottom <= y; }, end, 0);\n end = findFirst(function (ch) { return measureCharPrepared(cm, preparedMeasure, ch).top > y; }, begin, end);\n return {begin: begin, end: end}\n }\n\n function wrappedLineExtentChar(cm, lineObj, preparedMeasure, target) {\n if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj); }\n var targetTop = intoCoordSystem(cm, lineObj, measureCharPrepared(cm, preparedMeasure, target), \"line\").top;\n return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop)\n }\n\n // Returns true if the given side of a box is after the given\n // coordinates, in top-to-bottom, left-to-right order.\n function boxIsAfter(box, x, y, left) {\n return box.bottom <= y ? false : box.top > y ? true : (left ? box.left : box.right) > x\n }\n\n function coordsCharInner(cm, lineObj, lineNo$$1, x, y) {\n // Move y into line-local coordinate space\n y -= heightAtLine(lineObj);\n var preparedMeasure = prepareMeasureForLine(cm, lineObj);\n // When directly calling `measureCharPrepared`, we have to adjust\n // for the widgets at this line.\n var widgetHeight$$1 = widgetTopHeight(lineObj);\n var begin = 0, end = lineObj.text.length, ltr = true;\n\n var order = getOrder(lineObj, cm.doc.direction);\n // If the line isn't plain left-to-right text, first figure out\n // which bidi section the coordinates fall into.\n if (order) {\n var part = (cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart)\n (cm, lineObj, lineNo$$1, preparedMeasure, order, x, y);\n ltr = part.level != 1;\n // The awkward -1 offsets are needed because findFirst (called\n // on these below) will treat its first bound as inclusive,\n // second as exclusive, but we want to actually address the\n // characters in the part's range\n begin = ltr ? part.from : part.to - 1;\n end = ltr ? part.to : part.from - 1;\n }\n\n // A binary search to find the first character whose bounding box\n // starts after the coordinates. If we run across any whose box wrap\n // the coordinates, store that.\n var chAround = null, boxAround = null;\n var ch = findFirst(function (ch) {\n var box = measureCharPrepared(cm, preparedMeasure, ch);\n box.top += widgetHeight$$1; box.bottom += widgetHeight$$1;\n if (!boxIsAfter(box, x, y, false)) { return false }\n if (box.top <= y && box.left <= x) {\n chAround = ch;\n boxAround = box;\n }\n return true\n }, begin, end);\n\n var baseX, sticky, outside = false;\n // If a box around the coordinates was found, use that\n if (boxAround) {\n // Distinguish coordinates nearer to the left or right side of the box\n var atLeft = x - boxAround.left < boxAround.right - x, atStart = atLeft == ltr;\n ch = chAround + (atStart ? 0 : 1);\n sticky = atStart ? \"after\" : \"before\";\n baseX = atLeft ? boxAround.left : boxAround.right;\n } else {\n // (Adjust for extended bound, if necessary.)\n if (!ltr && (ch == end || ch == begin)) { ch++; }\n // To determine which side to associate with, get the box to the\n // left of the character and compare it's vertical position to the\n // coordinates\n sticky = ch == 0 ? \"after\" : ch == lineObj.text.length ? \"before\" :\n (measureCharPrepared(cm, preparedMeasure, ch - (ltr ? 1 : 0)).bottom + widgetHeight$$1 <= y) == ltr ?\n \"after\" : \"before\";\n // Now get accurate coordinates for this place, in order to get a\n // base X position\n var coords = cursorCoords(cm, Pos(lineNo$$1, ch, sticky), \"line\", lineObj, preparedMeasure);\n baseX = coords.left;\n outside = y < coords.top || y >= coords.bottom;\n }\n\n ch = skipExtendingChars(lineObj.text, ch, 1);\n return PosWithInfo(lineNo$$1, ch, sticky, outside, x - baseX)\n }\n\n function coordsBidiPart(cm, lineObj, lineNo$$1, preparedMeasure, order, x, y) {\n // Bidi parts are sorted left-to-right, and in a non-line-wrapping\n // situation, we can take this ordering to correspond to the visual\n // ordering. This finds the first part whose end is after the given\n // coordinates.\n var index = findFirst(function (i) {\n var part = order[i], ltr = part.level != 1;\n return boxIsAfter(cursorCoords(cm, Pos(lineNo$$1, ltr ? part.to : part.from, ltr ? \"before\" : \"after\"),\n \"line\", lineObj, preparedMeasure), x, y, true)\n }, 0, order.length - 1);\n var part = order[index];\n // If this isn't the first part, the part's start is also after\n // the coordinates, and the coordinates aren't on the same line as\n // that start, move one part back.\n if (index > 0) {\n var ltr = part.level != 1;\n var start = cursorCoords(cm, Pos(lineNo$$1, ltr ? part.from : part.to, ltr ? \"after\" : \"before\"),\n \"line\", lineObj, preparedMeasure);\n if (boxIsAfter(start, x, y, true) && start.top > y)\n { part = order[index - 1]; }\n }\n return part\n }\n\n function coordsBidiPartWrapped(cm, lineObj, _lineNo, preparedMeasure, order, x, y) {\n // In a wrapped line, rtl text on wrapping boundaries can do things\n // that don't correspond to the ordering in our `order` array at\n // all, so a binary search doesn't work, and we want to return a\n // part that only spans one line so that the binary search in\n // coordsCharInner is safe. As such, we first find the extent of the\n // wrapped line, and then do a flat search in which we discard any\n // spans that aren't on the line.\n var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y);\n var begin = ref.begin;\n var end = ref.end;\n if (/\\s/.test(lineObj.text.charAt(end - 1))) { end--; }\n var part = null, closestDist = null;\n for (var i = 0; i < order.length; i++) {\n var p = order[i];\n if (p.from >= end || p.to <= begin) { continue }\n var ltr = p.level != 1;\n var endX = measureCharPrepared(cm, preparedMeasure, ltr ? Math.min(end, p.to) - 1 : Math.max(begin, p.from)).right;\n // Weigh against spans ending before this, so that they are only\n // picked if nothing ends after\n var dist = endX < x ? x - endX + 1e9 : endX - x;\n if (!part || closestDist > dist) {\n part = p;\n closestDist = dist;\n }\n }\n if (!part) { part = order[order.length - 1]; }\n // Clip the part to the wrapped line.\n if (part.from < begin) { part = {from: begin, to: part.to, level: part.level}; }\n if (part.to > end) { part = {from: part.from, to: end, level: part.level}; }\n return part\n }\n\n var measureText;\n // Compute the default text height.\n function textHeight(display) {\n if (display.cachedTextHeight != null) { return display.cachedTextHeight }\n if (measureText == null) {\n measureText = elt(\"pre\");\n // Measure a bunch of lines, for browsers that compute\n // fractional heights.\n for (var i = 0; i < 49; ++i) {\n measureText.appendChild(document.createTextNode(\"x\"));\n measureText.appendChild(elt(\"br\"));\n }\n measureText.appendChild(document.createTextNode(\"x\"));\n }\n removeChildrenAndAdd(display.measure, measureText);\n var height = measureText.offsetHeight / 50;\n if (height > 3) { display.cachedTextHeight = height; }\n removeChildren(display.measure);\n return height || 1\n }\n\n // Compute the default character width.\n function charWidth(display) {\n if (display.cachedCharWidth != null) { return display.cachedCharWidth }\n var anchor = elt(\"span\", \"xxxxxxxxxx\");\n var pre = elt(\"pre\", [anchor]);\n removeChildrenAndAdd(display.measure, pre);\n var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10;\n if (width > 2) { display.cachedCharWidth = width; }\n return width || 10\n }\n\n // Do a bulk-read of the DOM positions and sizes needed to draw the\n // view, so that we don't interleave reading and writing to the DOM.\n function getDimensions(cm) {\n var d = cm.display, left = {}, width = {};\n var gutterLeft = d.gutters.clientLeft;\n for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {\n left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft;\n width[cm.options.gutters[i]] = n.clientWidth;\n }\n return {fixedPos: compensateForHScroll(d),\n gutterTotalWidth: d.gutters.offsetWidth,\n gutterLeft: left,\n gutterWidth: width,\n wrapperWidth: d.wrapper.clientWidth}\n }\n\n // Computes display.scroller.scrollLeft + display.gutters.offsetWidth,\n // but using getBoundingClientRect to get a sub-pixel-accurate\n // result.\n function compensateForHScroll(display) {\n return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left\n }\n\n // Returns a function that estimates the height of a line, to use as\n // first approximation until the line becomes visible (and is thus\n // properly measurable).\n function estimateHeight(cm) {\n var th = textHeight(cm.display), wrapping = cm.options.lineWrapping;\n var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3);\n return function (line) {\n if (lineIsHidden(cm.doc, line)) { return 0 }\n\n var widgetsHeight = 0;\n if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {\n if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height; }\n } }\n\n if (wrapping)\n { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }\n else\n { return widgetsHeight + th }\n }\n }\n\n function estimateLineHeights(cm) {\n var doc = cm.doc, est = estimateHeight(cm);\n doc.iter(function (line) {\n var estHeight = est(line);\n if (estHeight != line.height) { updateLineHeight(line, estHeight); }\n });\n }\n\n // Given a mouse event, find the corresponding position. If liberal\n // is false, it checks whether a gutter or scrollbar was clicked,\n // and returns null if it was. forRect is used by rectangular\n // selections, and tries to estimate a character position even for\n // coordinates beyond the right of the text.\n function posFromMouse(cm, e, liberal, forRect) {\n var display = cm.display;\n if (!liberal && e_target(e).getAttribute(\"cm-not-content\") == \"true\") { return null }\n\n var x, y, space = display.lineSpace.getBoundingClientRect();\n // Fails unpredictably on IE[67] when mouse is dragged around quickly.\n try { x = e.clientX - space.left; y = e.clientY - space.top; }\n catch (e) { return null }\n var coords = coordsChar(cm, x, y), line;\n if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {\n var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length;\n coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff));\n }\n return coords\n }\n\n // Find the view element corresponding to a given line. Return null\n // when the line isn't visible.\n function findViewIndex(cm, n) {\n if (n >= cm.display.viewTo) { return null }\n n -= cm.display.viewFrom;\n if (n < 0) { return null }\n var view = cm.display.view;\n for (var i = 0; i < view.length; i++) {\n n -= view[i].size;\n if (n < 0) { return i }\n }\n }\n\n function updateSelection(cm) {\n cm.display.input.showSelection(cm.display.input.prepareSelection());\n }\n\n function prepareSelection(cm, primary) {\n if ( primary === void 0 ) primary = true;\n\n var doc = cm.doc, result = {};\n var curFragment = result.cursors = document.createDocumentFragment();\n var selFragment = result.selection = document.createDocumentFragment();\n\n for (var i = 0; i < doc.sel.ranges.length; i++) {\n if (!primary && i == doc.sel.primIndex) { continue }\n var range$$1 = doc.sel.ranges[i];\n if (range$$1.from().line >= cm.display.viewTo || range$$1.to().line < cm.display.viewFrom) { continue }\n var collapsed = range$$1.empty();\n if (collapsed || cm.options.showCursorWhenSelecting)\n { drawSelectionCursor(cm, range$$1.head, curFragment); }\n if (!collapsed)\n { drawSelectionRange(cm, range$$1, selFragment); }\n }\n return result\n }\n\n // Draws a cursor for the given range\n function drawSelectionCursor(cm, head, output) {\n var pos = cursorCoords(cm, head, \"div\", null, null, !cm.options.singleCursorHeightPerLine);\n\n var cursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor\"));\n cursor.style.left = pos.left + \"px\";\n cursor.style.top = pos.top + \"px\";\n cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + \"px\";\n\n if (pos.other) {\n // Secondary cursor, shown when on a 'jump' in bi-directional text\n var otherCursor = output.appendChild(elt(\"div\", \"\\u00a0\", \"CodeMirror-cursor CodeMirror-secondarycursor\"));\n otherCursor.style.display = \"\";\n otherCursor.style.left = pos.other.left + \"px\";\n otherCursor.style.top = pos.other.top + \"px\";\n otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + \"px\";\n }\n }\n\n function cmpCoords(a, b) { return a.top - b.top || a.left - b.left }\n\n // Draws the given range as a highlighted selection\n function drawSelectionRange(cm, range$$1, output) {\n var display = cm.display, doc = cm.doc;\n var fragment = document.createDocumentFragment();\n var padding = paddingH(cm.display), leftSide = padding.left;\n var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right;\n var docLTR = doc.direction == \"ltr\";\n\n function add(left, top, width, bottom) {\n if (top < 0) { top = 0; }\n top = Math.round(top);\n bottom = Math.round(bottom);\n fragment.appendChild(elt(\"div\", null, \"CodeMirror-selected\", (\"position: absolute; left: \" + left + \"px;\\n top: \" + top + \"px; width: \" + (width == null ? rightSide - left : width) + \"px;\\n height: \" + (bottom - top) + \"px\")));\n }\n\n function drawForLine(line, fromArg, toArg) {\n var lineObj = getLine(doc, line);\n var lineLen = lineObj.text.length;\n var start, end;\n function coords(ch, bias) {\n return charCoords(cm, Pos(line, ch), \"div\", lineObj, bias)\n }\n\n function wrapX(pos, dir, side) {\n var extent = wrappedLineExtentChar(cm, lineObj, null, pos);\n var prop = (dir == \"ltr\") == (side == \"after\") ? \"left\" : \"right\";\n var ch = side == \"after\" ? extent.begin : extent.end - (/\\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1);\n return coords(ch, prop)[prop]\n }\n\n var order = getOrder(lineObj, doc.direction);\n iterateBidiSections(order, fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir, i) {\n var ltr = dir == \"ltr\";\n var fromPos = coords(from, ltr ? \"left\" : \"right\");\n var toPos = coords(to - 1, ltr ? \"right\" : \"left\");\n\n var openStart = fromArg == null && from == 0, openEnd = toArg == null && to == lineLen;\n var first = i == 0, last = !order || i == order.length - 1;\n if (toPos.top - fromPos.top <= 3) { // Single line\n var openLeft = (docLTR ? openStart : openEnd) && first;\n var openRight = (docLTR ? openEnd : openStart) && last;\n var left = openLeft ? leftSide : (ltr ? fromPos : toPos).left;\n var right = openRight ? rightSide : (ltr ? toPos : fromPos).right;\n add(left, fromPos.top, right - left, fromPos.bottom);\n } else { // Multiple lines\n var topLeft, topRight, botLeft, botRight;\n if (ltr) {\n topLeft = docLTR && openStart && first ? leftSide : fromPos.left;\n topRight = docLTR ? rightSide : wrapX(from, dir, \"before\");\n botLeft = docLTR ? leftSide : wrapX(to, dir, \"after\");\n botRight = docLTR && openEnd && last ? rightSide : toPos.right;\n } else {\n topLeft = !docLTR ? leftSide : wrapX(from, dir, \"before\");\n topRight = !docLTR && openStart && first ? rightSide : fromPos.right;\n botLeft = !docLTR && openEnd && last ? leftSide : toPos.left;\n botRight = !docLTR ? rightSide : wrapX(to, dir, \"after\");\n }\n add(topLeft, fromPos.top, topRight - topLeft, fromPos.bottom);\n if (fromPos.bottom < toPos.top) { add(leftSide, fromPos.bottom, null, toPos.top); }\n add(botLeft, toPos.top, botRight - botLeft, toPos.bottom);\n }\n\n if (!start || cmpCoords(fromPos, start) < 0) { start = fromPos; }\n if (cmpCoords(toPos, start) < 0) { start = toPos; }\n if (!end || cmpCoords(fromPos, end) < 0) { end = fromPos; }\n if (cmpCoords(toPos, end) < 0) { end = toPos; }\n });\n return {start: start, end: end}\n }\n\n var sFrom = range$$1.from(), sTo = range$$1.to();\n if (sFrom.line == sTo.line) {\n drawForLine(sFrom.line, sFrom.ch, sTo.ch);\n } else {\n var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line);\n var singleVLine = visualLine(fromLine) == visualLine(toLine);\n var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end;\n var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start;\n if (singleVLine) {\n if (leftEnd.top < rightStart.top - 2) {\n add(leftEnd.right, leftEnd.top, null, leftEnd.bottom);\n add(leftSide, rightStart.top, rightStart.left, rightStart.bottom);\n } else {\n add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom);\n }\n }\n if (leftEnd.bottom < rightStart.top)\n { add(leftSide, leftEnd.bottom, null, rightStart.top); }\n }\n\n output.appendChild(fragment);\n }\n\n // Cursor-blinking\n function restartBlink(cm) {\n if (!cm.state.focused) { return }\n var display = cm.display;\n clearInterval(display.blinker);\n var on = true;\n display.cursorDiv.style.visibility = \"\";\n if (cm.options.cursorBlinkRate > 0)\n { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? \"\" : \"hidden\"; },\n cm.options.cursorBlinkRate); }\n else if (cm.options.cursorBlinkRate < 0)\n { display.cursorDiv.style.visibility = \"hidden\"; }\n }\n\n function ensureFocus(cm) {\n if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm); }\n }\n\n function delayBlurEvent(cm) {\n cm.state.delayingBlurEvent = true;\n setTimeout(function () { if (cm.state.delayingBlurEvent) {\n cm.state.delayingBlurEvent = false;\n onBlur(cm);\n } }, 100);\n }\n\n function onFocus(cm, e) {\n if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false; }\n\n if (cm.options.readOnly == \"nocursor\") { return }\n if (!cm.state.focused) {\n signal(cm, \"focus\", cm, e);\n cm.state.focused = true;\n addClass(cm.display.wrapper, \"CodeMirror-focused\");\n // This test prevents this from firing when a context\n // menu is closed (since the input reset would kill the\n // select-all detection hack)\n if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {\n cm.display.input.reset();\n if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20); } // Issue #1730\n }\n cm.display.input.receivedFocus();\n }\n restartBlink(cm);\n }\n function onBlur(cm, e) {\n if (cm.state.delayingBlurEvent) { return }\n\n if (cm.state.focused) {\n signal(cm, \"blur\", cm, e);\n cm.state.focused = false;\n rmClass(cm.display.wrapper, \"CodeMirror-focused\");\n }\n clearInterval(cm.display.blinker);\n setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false; } }, 150);\n }\n\n // Read the actual heights of the rendered lines, and update their\n // stored heights to match.\n function updateHeightsInViewport(cm) {\n var display = cm.display;\n var prevBottom = display.lineDiv.offsetTop;\n for (var i = 0; i < display.view.length; i++) {\n var cur = display.view[i], wrapping = cm.options.lineWrapping;\n var height = (void 0), width = 0;\n if (cur.hidden) { continue }\n if (ie && ie_version < 8) {\n var bot = cur.node.offsetTop + cur.node.offsetHeight;\n height = bot - prevBottom;\n prevBottom = bot;\n } else {\n var box = cur.node.getBoundingClientRect();\n height = box.bottom - box.top;\n // Check that lines don't extend past the right of the current\n // editor width\n if (!wrapping && cur.text.firstChild)\n { width = cur.text.firstChild.getBoundingClientRect().right - box.left - 1; }\n }\n var diff = cur.line.height - height;\n if (diff > .005 || diff < -.005) {\n updateLineHeight(cur.line, height);\n updateWidgetHeight(cur.line);\n if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)\n { updateWidgetHeight(cur.rest[j]); } }\n }\n if (width > cm.display.sizerWidth) {\n var chWidth = Math.ceil(width / charWidth(cm.display));\n if (chWidth > cm.display.maxLineLength) {\n cm.display.maxLineLength = chWidth;\n cm.display.maxLine = cur.line;\n cm.display.maxLineChanged = true;\n }\n }\n }\n }\n\n // Read and store the height of line widgets associated with the\n // given line.\n function updateWidgetHeight(line) {\n if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i) {\n var w = line.widgets[i], parent = w.node.parentNode;\n if (parent) { w.height = parent.offsetHeight; }\n } }\n }\n\n // Compute the lines that are visible in a given viewport (defaults\n // the the current scroll position). viewport may contain top,\n // height, and ensure (see op.scrollToPos) properties.\n function visibleLines(display, doc, viewport) {\n var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop;\n top = Math.floor(top - paddingTop(display));\n var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight;\n\n var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom);\n // Ensure is a {from: {line, ch}, to: {line, ch}} object, and\n // forces those lines into the viewport (if possible).\n if (viewport && viewport.ensure) {\n var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line;\n if (ensureFrom < from) {\n from = ensureFrom;\n to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight);\n } else if (Math.min(ensureTo, doc.lastLine()) >= to) {\n from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight);\n to = ensureTo;\n }\n }\n return {from: from, to: Math.max(to, from + 1)}\n }\n\n // Re-align line numbers and gutter marks to compensate for\n // horizontal scrolling.\n function alignHorizontally(cm) {\n var display = cm.display, view = display.view;\n if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }\n var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft;\n var gutterW = display.gutters.offsetWidth, left = comp + \"px\";\n for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {\n if (cm.options.fixedGutter) {\n if (view[i].gutter)\n { view[i].gutter.style.left = left; }\n if (view[i].gutterBackground)\n { view[i].gutterBackground.style.left = left; }\n }\n var align = view[i].alignable;\n if (align) { for (var j = 0; j < align.length; j++)\n { align[j].style.left = left; } }\n } }\n if (cm.options.fixedGutter)\n { display.gutters.style.left = (comp + gutterW) + \"px\"; }\n }\n\n // Used to ensure that the line number gutter is still the right\n // size for the current document size. Returns true when an update\n // is needed.\n function maybeUpdateLineNumberWidth(cm) {\n if (!cm.options.lineNumbers) { return false }\n var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display;\n if (last.length != display.lineNumChars) {\n var test = display.measure.appendChild(elt(\"div\", [elt(\"div\", last)],\n \"CodeMirror-linenumber CodeMirror-gutter-elt\"));\n var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW;\n display.lineGutter.style.width = \"\";\n display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;\n display.lineNumWidth = display.lineNumInnerWidth + padding;\n display.lineNumChars = display.lineNumInnerWidth ? last.length : -1;\n display.lineGutter.style.width = display.lineNumWidth + \"px\";\n updateGutterSpace(cm);\n return true\n }\n return false\n }\n\n // SCROLLING THINGS INTO VIEW\n\n // If an editor sits on the top or bottom of the window, partially\n // scrolled out of view, this ensures that the cursor is visible.\n function maybeScrollWindow(cm, rect) {\n if (signalDOMEvent(cm, \"scrollCursorIntoView\")) { return }\n\n var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null;\n if (rect.top + box.top < 0) { doScroll = true; }\n else if (rect.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false; }\n if (doScroll != null && !phantom) {\n var scrollNode = elt(\"div\", \"\\u200b\", null, (\"position: absolute;\\n top: \" + (rect.top - display.viewOffset - paddingTop(cm.display)) + \"px;\\n height: \" + (rect.bottom - rect.top + scrollGap(cm) + display.barHeight) + \"px;\\n left: \" + (rect.left) + \"px; width: \" + (Math.max(2, rect.right - rect.left)) + \"px;\"));\n cm.display.lineSpace.appendChild(scrollNode);\n scrollNode.scrollIntoView(doScroll);\n cm.display.lineSpace.removeChild(scrollNode);\n }\n }\n\n // Scroll a given position into view (immediately), verifying that\n // it actually became visible (as line heights are accurately\n // measured, the position of something may 'drift' during drawing).\n function scrollPosIntoView(cm, pos, end, margin) {\n if (margin == null) { margin = 0; }\n var rect;\n if (!cm.options.lineWrapping && pos == end) {\n // Set pos and end to the cursor positions around the character pos sticks to\n // If pos.sticky == \"before\", that is around pos.ch - 1, otherwise around pos.ch\n // If pos == Pos(_, 0, \"before\"), pos and end are unchanged\n pos = pos.ch ? Pos(pos.line, pos.sticky == \"before\" ? pos.ch - 1 : pos.ch, \"after\") : pos;\n end = pos.sticky == \"before\" ? Pos(pos.line, pos.ch + 1, \"before\") : pos;\n }\n for (var limit = 0; limit < 5; limit++) {\n var changed = false;\n var coords = cursorCoords(cm, pos);\n var endCoords = !end || end == pos ? coords : cursorCoords(cm, end);\n rect = {left: Math.min(coords.left, endCoords.left),\n top: Math.min(coords.top, endCoords.top) - margin,\n right: Math.max(coords.left, endCoords.left),\n bottom: Math.max(coords.bottom, endCoords.bottom) + margin};\n var scrollPos = calculateScrollPos(cm, rect);\n var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft;\n if (scrollPos.scrollTop != null) {\n updateScrollTop(cm, scrollPos.scrollTop);\n if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true; }\n }\n if (scrollPos.scrollLeft != null) {\n setScrollLeft(cm, scrollPos.scrollLeft);\n if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true; }\n }\n if (!changed) { break }\n }\n return rect\n }\n\n // Scroll a given set of coordinates into view (immediately).\n function scrollIntoView(cm, rect) {\n var scrollPos = calculateScrollPos(cm, rect);\n if (scrollPos.scrollTop != null) { updateScrollTop(cm, scrollPos.scrollTop); }\n if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft); }\n }\n\n // Calculate a new scroll position needed to scroll the given\n // rectangle into view. Returns an object with scrollTop and\n // scrollLeft properties. When these are undefined, the\n // vertical/horizontal position does not need to be adjusted.\n function calculateScrollPos(cm, rect) {\n var display = cm.display, snapMargin = textHeight(cm.display);\n if (rect.top < 0) { rect.top = 0; }\n var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop;\n var screen = displayHeight(cm), result = {};\n if (rect.bottom - rect.top > screen) { rect.bottom = rect.top + screen; }\n var docBottom = cm.doc.height + paddingVert(display);\n var atTop = rect.top < snapMargin, atBottom = rect.bottom > docBottom - snapMargin;\n if (rect.top < screentop) {\n result.scrollTop = atTop ? 0 : rect.top;\n } else if (rect.bottom > screentop + screen) {\n var newTop = Math.min(rect.top, (atBottom ? docBottom : rect.bottom) - screen);\n if (newTop != screentop) { result.scrollTop = newTop; }\n }\n\n var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft;\n var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0);\n var tooWide = rect.right - rect.left > screenw;\n if (tooWide) { rect.right = rect.left + screenw; }\n if (rect.left < 10)\n { result.scrollLeft = 0; }\n else if (rect.left < screenleft)\n { result.scrollLeft = Math.max(0, rect.left - (tooWide ? 0 : 10)); }\n else if (rect.right > screenw + screenleft - 3)\n { result.scrollLeft = rect.right + (tooWide ? 0 : 10) - screenw; }\n return result\n }\n\n // Store a relative adjustment to the scroll position in the current\n // operation (to be applied when the operation finishes).\n function addToScrollTop(cm, top) {\n if (top == null) { return }\n resolveScrollToPos(cm);\n cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top;\n }\n\n // Make sure that at the end of the operation the current cursor is\n // shown.\n function ensureCursorVisible(cm) {\n resolveScrollToPos(cm);\n var cur = cm.getCursor();\n cm.curOp.scrollToPos = {from: cur, to: cur, margin: cm.options.cursorScrollMargin};\n }\n\n function scrollToCoords(cm, x, y) {\n if (x != null || y != null) { resolveScrollToPos(cm); }\n if (x != null) { cm.curOp.scrollLeft = x; }\n if (y != null) { cm.curOp.scrollTop = y; }\n }\n\n function scrollToRange(cm, range$$1) {\n resolveScrollToPos(cm);\n cm.curOp.scrollToPos = range$$1;\n }\n\n // When an operation has its scrollToPos property set, and another\n // scroll action is applied before the end of the operation, this\n // 'simulates' scrolling that position into view in a cheap way, so\n // that the effect of intermediate scroll commands is not ignored.\n function resolveScrollToPos(cm) {\n var range$$1 = cm.curOp.scrollToPos;\n if (range$$1) {\n cm.curOp.scrollToPos = null;\n var from = estimateCoords(cm, range$$1.from), to = estimateCoords(cm, range$$1.to);\n scrollToCoordsRange(cm, from, to, range$$1.margin);\n }\n }\n\n function scrollToCoordsRange(cm, from, to, margin) {\n var sPos = calculateScrollPos(cm, {\n left: Math.min(from.left, to.left),\n top: Math.min(from.top, to.top) - margin,\n right: Math.max(from.right, to.right),\n bottom: Math.max(from.bottom, to.bottom) + margin\n });\n scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop);\n }\n\n // Sync the scrollable area and scrollbars, ensure the viewport\n // covers the visible area.\n function updateScrollTop(cm, val) {\n if (Math.abs(cm.doc.scrollTop - val) < 2) { return }\n if (!gecko) { updateDisplaySimple(cm, {top: val}); }\n setScrollTop(cm, val, true);\n if (gecko) { updateDisplaySimple(cm); }\n startWorker(cm, 100);\n }\n\n function setScrollTop(cm, val, forceScroll) {\n val = Math.min(cm.display.scroller.scrollHeight - cm.display.scroller.clientHeight, val);\n if (cm.display.scroller.scrollTop == val && !forceScroll) { return }\n cm.doc.scrollTop = val;\n cm.display.scrollbars.setScrollTop(val);\n if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val; }\n }\n\n // Sync scroller and scrollbar, ensure the gutter elements are\n // aligned.\n function setScrollLeft(cm, val, isScroller, forceScroll) {\n val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth);\n if ((isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) && !forceScroll) { return }\n cm.doc.scrollLeft = val;\n alignHorizontally(cm);\n if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val; }\n cm.display.scrollbars.setScrollLeft(val);\n }\n\n // SCROLLBARS\n\n // Prepare DOM reads needed to update the scrollbars. Done in one\n // shot to minimize update/measure roundtrips.\n function measureForScrollbars(cm) {\n var d = cm.display, gutterW = d.gutters.offsetWidth;\n var docH = Math.round(cm.doc.height + paddingVert(cm.display));\n return {\n clientHeight: d.scroller.clientHeight,\n viewHeight: d.wrapper.clientHeight,\n scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,\n viewWidth: d.wrapper.clientWidth,\n barLeft: cm.options.fixedGutter ? gutterW : 0,\n docHeight: docH,\n scrollHeight: docH + scrollGap(cm) + d.barHeight,\n nativeBarWidth: d.nativeBarWidth,\n gutterWidth: gutterW\n }\n }\n\n var NativeScrollbars = function(place, scroll, cm) {\n this.cm = cm;\n var vert = this.vert = elt(\"div\", [elt(\"div\", null, null, \"min-width: 1px\")], \"CodeMirror-vscrollbar\");\n var horiz = this.horiz = elt(\"div\", [elt(\"div\", null, null, \"height: 100%; min-height: 1px\")], \"CodeMirror-hscrollbar\");\n vert.tabIndex = horiz.tabIndex = -1;\n place(vert); place(horiz);\n\n on(vert, \"scroll\", function () {\n if (vert.clientHeight) { scroll(vert.scrollTop, \"vertical\"); }\n });\n on(horiz, \"scroll\", function () {\n if (horiz.clientWidth) { scroll(horiz.scrollLeft, \"horizontal\"); }\n });\n\n this.checkedZeroWidth = false;\n // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).\n if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = \"18px\"; }\n };\n\n NativeScrollbars.prototype.update = function (measure) {\n var needsH = measure.scrollWidth > measure.clientWidth + 1;\n var needsV = measure.scrollHeight > measure.clientHeight + 1;\n var sWidth = measure.nativeBarWidth;\n\n if (needsV) {\n this.vert.style.display = \"block\";\n this.vert.style.bottom = needsH ? sWidth + \"px\" : \"0\";\n var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);\n // A bug in IE8 can cause this value to be negative, so guard it.\n this.vert.firstChild.style.height =\n Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + \"px\";\n } else {\n this.vert.style.display = \"\";\n this.vert.firstChild.style.height = \"0\";\n }\n\n if (needsH) {\n this.horiz.style.display = \"block\";\n this.horiz.style.right = needsV ? sWidth + \"px\" : \"0\";\n this.horiz.style.left = measure.barLeft + \"px\";\n var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);\n this.horiz.firstChild.style.width =\n Math.max(0, measure.scrollWidth - measure.clientWidth + totalWidth) + \"px\";\n } else {\n this.horiz.style.display = \"\";\n this.horiz.firstChild.style.width = \"0\";\n }\n\n if (!this.checkedZeroWidth && measure.clientHeight > 0) {\n if (sWidth == 0) { this.zeroWidthHack(); }\n this.checkedZeroWidth = true;\n }\n\n return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}\n };\n\n NativeScrollbars.prototype.setScrollLeft = function (pos) {\n if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos; }\n if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz, \"horiz\"); }\n };\n\n NativeScrollbars.prototype.setScrollTop = function (pos) {\n if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos; }\n if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert, \"vert\"); }\n };\n\n NativeScrollbars.prototype.zeroWidthHack = function () {\n var w = mac && !mac_geMountainLion ? \"12px\" : \"18px\";\n this.horiz.style.height = this.vert.style.width = w;\n this.horiz.style.pointerEvents = this.vert.style.pointerEvents = \"none\";\n this.disableHoriz = new Delayed;\n this.disableVert = new Delayed;\n };\n\n NativeScrollbars.prototype.enableZeroWidthBar = function (bar, delay, type) {\n bar.style.pointerEvents = \"auto\";\n function maybeDisable() {\n // To find out whether the scrollbar is still visible, we\n // check whether the element under the pixel in the bottom\n // right corner of the scrollbar box is the scrollbar box\n // itself (when the bar is still visible) or its filler child\n // (when the bar is hidden). If it is still visible, we keep\n // it enabled, if it's hidden, we disable pointer events.\n var box = bar.getBoundingClientRect();\n var elt$$1 = type == \"vert\" ? document.elementFromPoint(box.right - 1, (box.top + box.bottom) / 2)\n : document.elementFromPoint((box.right + box.left) / 2, box.bottom - 1);\n if (elt$$1 != bar) { bar.style.pointerEvents = \"none\"; }\n else { delay.set(1000, maybeDisable); }\n }\n delay.set(1000, maybeDisable);\n };\n\n NativeScrollbars.prototype.clear = function () {\n var parent = this.horiz.parentNode;\n parent.removeChild(this.horiz);\n parent.removeChild(this.vert);\n };\n\n var NullScrollbars = function () {};\n\n NullScrollbars.prototype.update = function () { return {bottom: 0, right: 0} };\n NullScrollbars.prototype.setScrollLeft = function () {};\n NullScrollbars.prototype.setScrollTop = function () {};\n NullScrollbars.prototype.clear = function () {};\n\n function updateScrollbars(cm, measure) {\n if (!measure) { measure = measureForScrollbars(cm); }\n var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight;\n updateScrollbarsInner(cm, measure);\n for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {\n if (startWidth != cm.display.barWidth && cm.options.lineWrapping)\n { updateHeightsInViewport(cm); }\n updateScrollbarsInner(cm, measureForScrollbars(cm));\n startWidth = cm.display.barWidth; startHeight = cm.display.barHeight;\n }\n }\n\n // Re-synchronize the fake scrollbars with the actual size of the\n // content.\n function updateScrollbarsInner(cm, measure) {\n var d = cm.display;\n var sizes = d.scrollbars.update(measure);\n\n d.sizer.style.paddingRight = (d.barWidth = sizes.right) + \"px\";\n d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + \"px\";\n d.heightForcer.style.borderBottom = sizes.bottom + \"px solid transparent\";\n\n if (sizes.right && sizes.bottom) {\n d.scrollbarFiller.style.display = \"block\";\n d.scrollbarFiller.style.height = sizes.bottom + \"px\";\n d.scrollbarFiller.style.width = sizes.right + \"px\";\n } else { d.scrollbarFiller.style.display = \"\"; }\n if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {\n d.gutterFiller.style.display = \"block\";\n d.gutterFiller.style.height = sizes.bottom + \"px\";\n d.gutterFiller.style.width = measure.gutterWidth + \"px\";\n } else { d.gutterFiller.style.display = \"\"; }\n }\n\n var scrollbarModel = {\"native\": NativeScrollbars, \"null\": NullScrollbars};\n\n function initScrollbars(cm) {\n if (cm.display.scrollbars) {\n cm.display.scrollbars.clear();\n if (cm.display.scrollbars.addClass)\n { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass); }\n }\n\n cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {\n cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller);\n // Prevent clicks in the scrollbars from killing focus\n on(node, \"mousedown\", function () {\n if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0); }\n });\n node.setAttribute(\"cm-not-content\", \"true\");\n }, function (pos, axis) {\n if (axis == \"horizontal\") { setScrollLeft(cm, pos); }\n else { updateScrollTop(cm, pos); }\n }, cm);\n if (cm.display.scrollbars.addClass)\n { addClass(cm.display.wrapper, cm.display.scrollbars.addClass); }\n }\n\n // Operations are used to wrap a series of changes to the editor\n // state in such a way that each change won't have to update the\n // cursor and display (which would be awkward, slow, and\n // error-prone). Instead, display updates are batched and then all\n // combined and executed at once.\n\n var nextOpId = 0;\n // Start a new operation.\n function startOperation(cm) {\n cm.curOp = {\n cm: cm,\n viewChanged: false, // Flag that indicates that lines might need to be redrawn\n startHeight: cm.doc.height, // Used to detect need to update scrollbar\n forceUpdate: false, // Used to force a redraw\n updateInput: 0, // Whether to reset the input textarea\n typing: false, // Whether this reset should be careful to leave existing text (for compositing)\n changeObjs: null, // Accumulated changes, for firing change events\n cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on\n cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already\n selectionChanged: false, // Whether the selection needs to be redrawn\n updateMaxLine: false, // Set when the widest line needs to be determined anew\n scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet\n scrollToPos: null, // Used to scroll to a specific position\n focus: false,\n id: ++nextOpId // Unique ID\n };\n pushOperation(cm.curOp);\n }\n\n // Finish an operation, updating the display and signalling delayed events\n function endOperation(cm) {\n var op = cm.curOp;\n if (op) { finishOperation(op, function (group) {\n for (var i = 0; i < group.ops.length; i++)\n { group.ops[i].cm.curOp = null; }\n endOperations(group);\n }); }\n }\n\n // The DOM updates done when an operation finishes are batched so\n // that the minimum number of relayouts are required.\n function endOperations(group) {\n var ops = group.ops;\n for (var i = 0; i < ops.length; i++) // Read DOM\n { endOperation_R1(ops[i]); }\n for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)\n { endOperation_W1(ops[i$1]); }\n for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM\n { endOperation_R2(ops[i$2]); }\n for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)\n { endOperation_W2(ops[i$3]); }\n for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM\n { endOperation_finish(ops[i$4]); }\n }\n\n function endOperation_R1(op) {\n var cm = op.cm, display = cm.display;\n maybeClipScrollbars(cm);\n if (op.updateMaxLine) { findMaxLine(cm); }\n\n op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||\n op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||\n op.scrollToPos.to.line >= display.viewTo) ||\n display.maxLineChanged && cm.options.lineWrapping;\n op.update = op.mustUpdate &&\n new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate);\n }\n\n function endOperation_W1(op) {\n op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);\n }\n\n function endOperation_R2(op) {\n var cm = op.cm, display = cm.display;\n if (op.updatedDisplay) { updateHeightsInViewport(cm); }\n\n op.barMeasure = measureForScrollbars(cm);\n\n // If the max line changed since it was last measured, measure it,\n // and ensure the document's width matches it.\n // updateDisplay_W2 will use these properties to do the actual resizing\n if (display.maxLineChanged && !cm.options.lineWrapping) {\n op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3;\n cm.display.sizerWidth = op.adjustWidthTo;\n op.barMeasure.scrollWidth =\n Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth);\n op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm));\n }\n\n if (op.updatedDisplay || op.selectionChanged)\n { op.preparedSelection = display.input.prepareSelection(); }\n }\n\n function endOperation_W2(op) {\n var cm = op.cm;\n\n if (op.adjustWidthTo != null) {\n cm.display.sizer.style.minWidth = op.adjustWidthTo + \"px\";\n if (op.maxScrollLeft < cm.doc.scrollLeft)\n { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true); }\n cm.display.maxLineChanged = false;\n }\n\n var takeFocus = op.focus && op.focus == activeElt();\n if (op.preparedSelection)\n { cm.display.input.showSelection(op.preparedSelection, takeFocus); }\n if (op.updatedDisplay || op.startHeight != cm.doc.height)\n { updateScrollbars(cm, op.barMeasure); }\n if (op.updatedDisplay)\n { setDocumentHeight(cm, op.barMeasure); }\n\n if (op.selectionChanged) { restartBlink(cm); }\n\n if (cm.state.focused && op.updateInput)\n { cm.display.input.reset(op.typing); }\n if (takeFocus) { ensureFocus(op.cm); }\n }\n\n function endOperation_finish(op) {\n var cm = op.cm, display = cm.display, doc = cm.doc;\n\n if (op.updatedDisplay) { postUpdateDisplay(cm, op.update); }\n\n // Abort mouse wheel delta measurement, when scrolling explicitly\n if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))\n { display.wheelStartX = display.wheelStartY = null; }\n\n // Propagate the scroll position to the actual DOM scroller\n if (op.scrollTop != null) { setScrollTop(cm, op.scrollTop, op.forceScroll); }\n\n if (op.scrollLeft != null) { setScrollLeft(cm, op.scrollLeft, true, true); }\n // If we need to scroll a specific position into view, do so.\n if (op.scrollToPos) {\n var rect = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),\n clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin);\n maybeScrollWindow(cm, rect);\n }\n\n // Fire events for markers that are hidden/unidden by editing or\n // undoing\n var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers;\n if (hidden) { for (var i = 0; i < hidden.length; ++i)\n { if (!hidden[i].lines.length) { signal(hidden[i], \"hide\"); } } }\n if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)\n { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], \"unhide\"); } } }\n\n if (display.wrapper.offsetHeight)\n { doc.scrollTop = cm.display.scroller.scrollTop; }\n\n // Fire change events, and delayed event handlers\n if (op.changeObjs)\n { signal(cm, \"changes\", cm, op.changeObjs); }\n if (op.update)\n { op.update.finish(); }\n }\n\n // Run the given function in an operation\n function runInOp(cm, f) {\n if (cm.curOp) { return f() }\n startOperation(cm);\n try { return f() }\n finally { endOperation(cm); }\n }\n // Wraps a function in an operation. Returns the wrapped function.\n function operation(cm, f) {\n return function() {\n if (cm.curOp) { return f.apply(cm, arguments) }\n startOperation(cm);\n try { return f.apply(cm, arguments) }\n finally { endOperation(cm); }\n }\n }\n // Used to add methods to editor and doc instances, wrapping them in\n // operations.\n function methodOp(f) {\n return function() {\n if (this.curOp) { return f.apply(this, arguments) }\n startOperation(this);\n try { return f.apply(this, arguments) }\n finally { endOperation(this); }\n }\n }\n function docMethodOp(f) {\n return function() {\n var cm = this.cm;\n if (!cm || cm.curOp) { return f.apply(this, arguments) }\n startOperation(cm);\n try { return f.apply(this, arguments) }\n finally { endOperation(cm); }\n }\n }\n\n // Updates the display.view data structure for a given change to the\n // document. From and to are in pre-change coordinates. Lendiff is\n // the amount of lines added or subtracted by the change. This is\n // used for changes that span multiple lines, or change the way\n // lines are divided into visual lines. regLineChange (below)\n // registers single-line changes.\n function regChange(cm, from, to, lendiff) {\n if (from == null) { from = cm.doc.first; }\n if (to == null) { to = cm.doc.first + cm.doc.size; }\n if (!lendiff) { lendiff = 0; }\n\n var display = cm.display;\n if (lendiff && to < display.viewTo &&\n (display.updateLineNumbers == null || display.updateLineNumbers > from))\n { display.updateLineNumbers = from; }\n\n cm.curOp.viewChanged = true;\n\n if (from >= display.viewTo) { // Change after\n if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)\n { resetView(cm); }\n } else if (to <= display.viewFrom) { // Change before\n if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {\n resetView(cm);\n } else {\n display.viewFrom += lendiff;\n display.viewTo += lendiff;\n }\n } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap\n resetView(cm);\n } else if (from <= display.viewFrom) { // Top overlap\n var cut = viewCuttingPoint(cm, to, to + lendiff, 1);\n if (cut) {\n display.view = display.view.slice(cut.index);\n display.viewFrom = cut.lineN;\n display.viewTo += lendiff;\n } else {\n resetView(cm);\n }\n } else if (to >= display.viewTo) { // Bottom overlap\n var cut$1 = viewCuttingPoint(cm, from, from, -1);\n if (cut$1) {\n display.view = display.view.slice(0, cut$1.index);\n display.viewTo = cut$1.lineN;\n } else {\n resetView(cm);\n }\n } else { // Gap in the middle\n var cutTop = viewCuttingPoint(cm, from, from, -1);\n var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);\n if (cutTop && cutBot) {\n display.view = display.view.slice(0, cutTop.index)\n .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))\n .concat(display.view.slice(cutBot.index));\n display.viewTo += lendiff;\n } else {\n resetView(cm);\n }\n }\n\n var ext = display.externalMeasured;\n if (ext) {\n if (to < ext.lineN)\n { ext.lineN += lendiff; }\n else if (from < ext.lineN + ext.size)\n { display.externalMeasured = null; }\n }\n }\n\n // Register a change to a single line. Type must be one of \"text\",\n // \"gutter\", \"class\", \"widget\"\n function regLineChange(cm, line, type) {\n cm.curOp.viewChanged = true;\n var display = cm.display, ext = cm.display.externalMeasured;\n if (ext && line >= ext.lineN && line < ext.lineN + ext.size)\n { display.externalMeasured = null; }\n\n if (line < display.viewFrom || line >= display.viewTo) { return }\n var lineView = display.view[findViewIndex(cm, line)];\n if (lineView.node == null) { return }\n var arr = lineView.changes || (lineView.changes = []);\n if (indexOf(arr, type) == -1) { arr.push(type); }\n }\n\n // Clear the view.\n function resetView(cm) {\n cm.display.viewFrom = cm.display.viewTo = cm.doc.first;\n cm.display.view = [];\n cm.display.viewOffset = 0;\n }\n\n function viewCuttingPoint(cm, oldN, newN, dir) {\n var index = findViewIndex(cm, oldN), diff, view = cm.display.view;\n if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)\n { return {index: index, lineN: newN} }\n var n = cm.display.viewFrom;\n for (var i = 0; i < index; i++)\n { n += view[i].size; }\n if (n != oldN) {\n if (dir > 0) {\n if (index == view.length - 1) { return null }\n diff = (n + view[index].size) - oldN;\n index++;\n } else {\n diff = n - oldN;\n }\n oldN += diff; newN += diff;\n }\n while (visualLineNo(cm.doc, newN) != newN) {\n if (index == (dir < 0 ? 0 : view.length - 1)) { return null }\n newN += dir * view[index - (dir < 0 ? 1 : 0)].size;\n index += dir;\n }\n return {index: index, lineN: newN}\n }\n\n // Force the view to cover a given range, adding empty view element\n // or clipping off existing ones as needed.\n function adjustView(cm, from, to) {\n var display = cm.display, view = display.view;\n if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {\n display.view = buildViewArray(cm, from, to);\n display.viewFrom = from;\n } else {\n if (display.viewFrom > from)\n { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view); }\n else if (display.viewFrom < from)\n { display.view = display.view.slice(findViewIndex(cm, from)); }\n display.viewFrom = from;\n if (display.viewTo < to)\n { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)); }\n else if (display.viewTo > to)\n { display.view = display.view.slice(0, findViewIndex(cm, to)); }\n }\n display.viewTo = to;\n }\n\n // Count the number of lines in the view whose DOM representation is\n // out of date (or nonexistent).\n function countDirtyView(cm) {\n var view = cm.display.view, dirty = 0;\n for (var i = 0; i < view.length; i++) {\n var lineView = view[i];\n if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty; }\n }\n return dirty\n }\n\n // HIGHLIGHT WORKER\n\n function startWorker(cm, time) {\n if (cm.doc.highlightFrontier < cm.display.viewTo)\n { cm.state.highlight.set(time, bind(highlightWorker, cm)); }\n }\n\n function highlightWorker(cm) {\n var doc = cm.doc;\n if (doc.highlightFrontier >= cm.display.viewTo) { return }\n var end = +new Date + cm.options.workTime;\n var context = getContextBefore(cm, doc.highlightFrontier);\n var changedLines = [];\n\n doc.iter(context.line, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {\n if (context.line >= cm.display.viewFrom) { // Visible\n var oldStyles = line.styles;\n var resetState = line.text.length > cm.options.maxHighlightLength ? copyState(doc.mode, context.state) : null;\n var highlighted = highlightLine(cm, line, context, true);\n if (resetState) { context.state = resetState; }\n line.styles = highlighted.styles;\n var oldCls = line.styleClasses, newCls = highlighted.classes;\n if (newCls) { line.styleClasses = newCls; }\n else if (oldCls) { line.styleClasses = null; }\n var ischange = !oldStyles || oldStyles.length != line.styles.length ||\n oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass);\n for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i]; }\n if (ischange) { changedLines.push(context.line); }\n line.stateAfter = context.save();\n context.nextLine();\n } else {\n if (line.text.length <= cm.options.maxHighlightLength)\n { processLine(cm, line.text, context); }\n line.stateAfter = context.line % 5 == 0 ? context.save() : null;\n context.nextLine();\n }\n if (+new Date > end) {\n startWorker(cm, cm.options.workDelay);\n return true\n }\n });\n doc.highlightFrontier = context.line;\n doc.modeFrontier = Math.max(doc.modeFrontier, context.line);\n if (changedLines.length) { runInOp(cm, function () {\n for (var i = 0; i < changedLines.length; i++)\n { regLineChange(cm, changedLines[i], \"text\"); }\n }); }\n }\n\n // DISPLAY DRAWING\n\n var DisplayUpdate = function(cm, viewport, force) {\n var display = cm.display;\n\n this.viewport = viewport;\n // Store some values that we'll need later (but don't want to force a relayout for)\n this.visible = visibleLines(display, cm.doc, viewport);\n this.editorIsHidden = !display.wrapper.offsetWidth;\n this.wrapperHeight = display.wrapper.clientHeight;\n this.wrapperWidth = display.wrapper.clientWidth;\n this.oldDisplayWidth = displayWidth(cm);\n this.force = force;\n this.dims = getDimensions(cm);\n this.events = [];\n };\n\n DisplayUpdate.prototype.signal = function (emitter, type) {\n if (hasHandler(emitter, type))\n { this.events.push(arguments); }\n };\n DisplayUpdate.prototype.finish = function () {\n var this$1 = this;\n\n for (var i = 0; i < this.events.length; i++)\n { signal.apply(null, this$1.events[i]); }\n };\n\n function maybeClipScrollbars(cm) {\n var display = cm.display;\n if (!display.scrollbarsClipped && display.scroller.offsetWidth) {\n display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth;\n display.heightForcer.style.height = scrollGap(cm) + \"px\";\n display.sizer.style.marginBottom = -display.nativeBarWidth + \"px\";\n display.sizer.style.borderRightWidth = scrollGap(cm) + \"px\";\n display.scrollbarsClipped = true;\n }\n }\n\n function selectionSnapshot(cm) {\n if (cm.hasFocus()) { return null }\n var active = activeElt();\n if (!active || !contains(cm.display.lineDiv, active)) { return null }\n var result = {activeElt: active};\n if (window.getSelection) {\n var sel = window.getSelection();\n if (sel.anchorNode && sel.extend && contains(cm.display.lineDiv, sel.anchorNode)) {\n result.anchorNode = sel.anchorNode;\n result.anchorOffset = sel.anchorOffset;\n result.focusNode = sel.focusNode;\n result.focusOffset = sel.focusOffset;\n }\n }\n return result\n }\n\n function restoreSelection(snapshot) {\n if (!snapshot || !snapshot.activeElt || snapshot.activeElt == activeElt()) { return }\n snapshot.activeElt.focus();\n if (snapshot.anchorNode && contains(document.body, snapshot.anchorNode) && contains(document.body, snapshot.focusNode)) {\n var sel = window.getSelection(), range$$1 = document.createRange();\n range$$1.setEnd(snapshot.anchorNode, snapshot.anchorOffset);\n range$$1.collapse(false);\n sel.removeAllRanges();\n sel.addRange(range$$1);\n sel.extend(snapshot.focusNode, snapshot.focusOffset);\n }\n }\n\n // Does the actual updating of the line display. Bails out\n // (returning false) when there is nothing to be done and forced is\n // false.\n function updateDisplayIfNeeded(cm, update) {\n var display = cm.display, doc = cm.doc;\n\n if (update.editorIsHidden) {\n resetView(cm);\n return false\n }\n\n // Bail out if the visible area is already rendered and nothing changed.\n if (!update.force &&\n update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&\n (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&\n display.renderedView == display.view && countDirtyView(cm) == 0)\n { return false }\n\n if (maybeUpdateLineNumberWidth(cm)) {\n resetView(cm);\n update.dims = getDimensions(cm);\n }\n\n // Compute a suitable new viewport (from & to)\n var end = doc.first + doc.size;\n var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first);\n var to = Math.min(end, update.visible.to + cm.options.viewportMargin);\n if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom); }\n if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo); }\n if (sawCollapsedSpans) {\n from = visualLineNo(cm.doc, from);\n to = visualLineEndNo(cm.doc, to);\n }\n\n var different = from != display.viewFrom || to != display.viewTo ||\n display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth;\n adjustView(cm, from, to);\n\n display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom));\n // Position the mover div to align with the current scroll position\n cm.display.mover.style.top = display.viewOffset + \"px\";\n\n var toUpdate = countDirtyView(cm);\n if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&\n (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))\n { return false }\n\n // For big changes, we hide the enclosing element during the\n // update, since that speeds up the operations on most browsers.\n var selSnapshot = selectionSnapshot(cm);\n if (toUpdate > 4) { display.lineDiv.style.display = \"none\"; }\n patchDisplay(cm, display.updateLineNumbers, update.dims);\n if (toUpdate > 4) { display.lineDiv.style.display = \"\"; }\n display.renderedView = display.view;\n // There might have been a widget with a focused element that got\n // hidden or updated, if so re-focus it.\n restoreSelection(selSnapshot);\n\n // Prevent selection and cursors from interfering with the scroll\n // width and height.\n removeChildren(display.cursorDiv);\n removeChildren(display.selectionDiv);\n display.gutters.style.height = display.sizer.style.minHeight = 0;\n\n if (different) {\n display.lastWrapHeight = update.wrapperHeight;\n display.lastWrapWidth = update.wrapperWidth;\n startWorker(cm, 400);\n }\n\n display.updateLineNumbers = null;\n\n return true\n }\n\n function postUpdateDisplay(cm, update) {\n var viewport = update.viewport;\n\n for (var first = true;; first = false) {\n if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {\n // Clip forced viewport to actual scrollable area.\n if (viewport && viewport.top != null)\n { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)}; }\n // Updated line heights might result in the drawn area not\n // actually covering the viewport. Keep looping until it does.\n update.visible = visibleLines(cm.display, cm.doc, viewport);\n if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)\n { break }\n }\n if (!updateDisplayIfNeeded(cm, update)) { break }\n updateHeightsInViewport(cm);\n var barMeasure = measureForScrollbars(cm);\n updateSelection(cm);\n updateScrollbars(cm, barMeasure);\n setDocumentHeight(cm, barMeasure);\n update.force = false;\n }\n\n update.signal(cm, \"update\", cm);\n if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {\n update.signal(cm, \"viewportChange\", cm, cm.display.viewFrom, cm.display.viewTo);\n cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo;\n }\n }\n\n function updateDisplaySimple(cm, viewport) {\n var update = new DisplayUpdate(cm, viewport);\n if (updateDisplayIfNeeded(cm, update)) {\n updateHeightsInViewport(cm);\n postUpdateDisplay(cm, update);\n var barMeasure = measureForScrollbars(cm);\n updateSelection(cm);\n updateScrollbars(cm, barMeasure);\n setDocumentHeight(cm, barMeasure);\n update.finish();\n }\n }\n\n // Sync the actual display DOM structure with display.view, removing\n // nodes for lines that are no longer in view, and creating the ones\n // that are not there yet, and updating the ones that are out of\n // date.\n function patchDisplay(cm, updateNumbersFrom, dims) {\n var display = cm.display, lineNumbers = cm.options.lineNumbers;\n var container = display.lineDiv, cur = container.firstChild;\n\n function rm(node) {\n var next = node.nextSibling;\n // Works around a throw-scroll bug in OS X Webkit\n if (webkit && mac && cm.display.currentWheelTarget == node)\n { node.style.display = \"none\"; }\n else\n { node.parentNode.removeChild(node); }\n return next\n }\n\n var view = display.view, lineN = display.viewFrom;\n // Loop over the elements in the view, syncing cur (the DOM nodes\n // in display.lineDiv) with the view as we go.\n for (var i = 0; i < view.length; i++) {\n var lineView = view[i];\n if (lineView.hidden) ; else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet\n var node = buildLineElement(cm, lineView, lineN, dims);\n container.insertBefore(node, cur);\n } else { // Already drawn\n while (cur != lineView.node) { cur = rm(cur); }\n var updateNumber = lineNumbers && updateNumbersFrom != null &&\n updateNumbersFrom <= lineN && lineView.lineNumber;\n if (lineView.changes) {\n if (indexOf(lineView.changes, \"gutter\") > -1) { updateNumber = false; }\n updateLineForChanges(cm, lineView, lineN, dims);\n }\n if (updateNumber) {\n removeChildren(lineView.lineNumber);\n lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)));\n }\n cur = lineView.node.nextSibling;\n }\n lineN += lineView.size;\n }\n while (cur) { cur = rm(cur); }\n }\n\n function updateGutterSpace(cm) {\n var width = cm.display.gutters.offsetWidth;\n cm.display.sizer.style.marginLeft = width + \"px\";\n }\n\n function setDocumentHeight(cm, measure) {\n cm.display.sizer.style.minHeight = measure.docHeight + \"px\";\n cm.display.heightForcer.style.top = measure.docHeight + \"px\";\n cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + \"px\";\n }\n\n // Rebuild the gutter elements, ensure the margin to the left of the\n // code matches their width.\n function updateGutters(cm) {\n var gutters = cm.display.gutters, specs = cm.options.gutters;\n removeChildren(gutters);\n var i = 0;\n for (; i < specs.length; ++i) {\n var gutterClass = specs[i];\n var gElt = gutters.appendChild(elt(\"div\", null, \"CodeMirror-gutter \" + gutterClass));\n if (gutterClass == \"CodeMirror-linenumbers\") {\n cm.display.lineGutter = gElt;\n gElt.style.width = (cm.display.lineNumWidth || 1) + \"px\";\n }\n }\n gutters.style.display = i ? \"\" : \"none\";\n updateGutterSpace(cm);\n }\n\n // Make sure the gutters options contains the element\n // \"CodeMirror-linenumbers\" when the lineNumbers option is true.\n function setGuttersForLineNumbers(options) {\n var found = indexOf(options.gutters, \"CodeMirror-linenumbers\");\n if (found == -1 && options.lineNumbers) {\n options.gutters = options.gutters.concat([\"CodeMirror-linenumbers\"]);\n } else if (found > -1 && !options.lineNumbers) {\n options.gutters = options.gutters.slice(0);\n options.gutters.splice(found, 1);\n }\n }\n\n // Since the delta values reported on mouse wheel events are\n // unstandardized between browsers and even browser versions, and\n // generally horribly unpredictable, this code starts by measuring\n // the scroll effect that the first few mouse wheel events have,\n // and, from that, detects the way it can convert deltas to pixel\n // offsets afterwards.\n //\n // The reason we want to know the amount a wheel event will scroll\n // is that it gives us a chance to update the display before the\n // actual scrolling happens, reducing flickering.\n\n var wheelSamples = 0, wheelPixelsPerUnit = null;\n // Fill in a browser-detected starting value on browsers where we\n // know one. These don't have to be accurate -- the result of them\n // being wrong would just be a slight flicker on the first wheel\n // scroll (if it is large enough).\n if (ie) { wheelPixelsPerUnit = -.53; }\n else if (gecko) { wheelPixelsPerUnit = 15; }\n else if (chrome) { wheelPixelsPerUnit = -.7; }\n else if (safari) { wheelPixelsPerUnit = -1/3; }\n\n function wheelEventDelta(e) {\n var dx = e.wheelDeltaX, dy = e.wheelDeltaY;\n if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail; }\n if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail; }\n else if (dy == null) { dy = e.wheelDelta; }\n return {x: dx, y: dy}\n }\n function wheelEventPixels(e) {\n var delta = wheelEventDelta(e);\n delta.x *= wheelPixelsPerUnit;\n delta.y *= wheelPixelsPerUnit;\n return delta\n }\n\n function onScrollWheel(cm, e) {\n var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y;\n\n var display = cm.display, scroll = display.scroller;\n // Quit if there's nothing to scroll here\n var canScrollX = scroll.scrollWidth > scroll.clientWidth;\n var canScrollY = scroll.scrollHeight > scroll.clientHeight;\n if (!(dx && canScrollX || dy && canScrollY)) { return }\n\n // Webkit browsers on OS X abort momentum scrolls when the target\n // of the scroll event is removed from the scrollable element.\n // This hack (see related code in patchDisplay) makes sure the\n // element is kept around.\n if (dy && mac && webkit) {\n outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {\n for (var i = 0; i < view.length; i++) {\n if (view[i].node == cur) {\n cm.display.currentWheelTarget = cur;\n break outer\n }\n }\n }\n }\n\n // On some browsers, horizontal scrolling will cause redraws to\n // happen before the gutter has been realigned, causing it to\n // wriggle around in a most unseemly way. When we have an\n // estimated pixels/delta value, we just handle horizontal\n // scrolling entirely here. It'll be slightly off from native, but\n // better than glitching out.\n if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {\n if (dy && canScrollY)\n { updateScrollTop(cm, Math.max(0, scroll.scrollTop + dy * wheelPixelsPerUnit)); }\n setScrollLeft(cm, Math.max(0, scroll.scrollLeft + dx * wheelPixelsPerUnit));\n // Only prevent default scrolling if vertical scrolling is\n // actually possible. Otherwise, it causes vertical scroll\n // jitter on OSX trackpads when deltaX is small and deltaY\n // is large (issue #3579)\n if (!dy || (dy && canScrollY))\n { e_preventDefault(e); }\n display.wheelStartX = null; // Abort measurement, if in progress\n return\n }\n\n // 'Project' the visible viewport to cover the area that is being\n // scrolled into view (if we know enough to estimate it).\n if (dy && wheelPixelsPerUnit != null) {\n var pixels = dy * wheelPixelsPerUnit;\n var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight;\n if (pixels < 0) { top = Math.max(0, top + pixels - 50); }\n else { bot = Math.min(cm.doc.height, bot + pixels + 50); }\n updateDisplaySimple(cm, {top: top, bottom: bot});\n }\n\n if (wheelSamples < 20) {\n if (display.wheelStartX == null) {\n display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop;\n display.wheelDX = dx; display.wheelDY = dy;\n setTimeout(function () {\n if (display.wheelStartX == null) { return }\n var movedX = scroll.scrollLeft - display.wheelStartX;\n var movedY = scroll.scrollTop - display.wheelStartY;\n var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||\n (movedX && display.wheelDX && movedX / display.wheelDX);\n display.wheelStartX = display.wheelStartY = null;\n if (!sample) { return }\n wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1);\n ++wheelSamples;\n }, 200);\n } else {\n display.wheelDX += dx; display.wheelDY += dy;\n }\n }\n }\n\n // Selection objects are immutable. A new one is created every time\n // the selection changes. A selection is one or more non-overlapping\n // (and non-touching) ranges, sorted, and an integer that indicates\n // which one is the primary selection (the one that's scrolled into\n // view, that getCursor returns, etc).\n var Selection = function(ranges, primIndex) {\n this.ranges = ranges;\n this.primIndex = primIndex;\n };\n\n Selection.prototype.primary = function () { return this.ranges[this.primIndex] };\n\n Selection.prototype.equals = function (other) {\n var this$1 = this;\n\n if (other == this) { return true }\n if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }\n for (var i = 0; i < this.ranges.length; i++) {\n var here = this$1.ranges[i], there = other.ranges[i];\n if (!equalCursorPos(here.anchor, there.anchor) || !equalCursorPos(here.head, there.head)) { return false }\n }\n return true\n };\n\n Selection.prototype.deepCopy = function () {\n var this$1 = this;\n\n var out = [];\n for (var i = 0; i < this.ranges.length; i++)\n { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)); }\n return new Selection(out, this.primIndex)\n };\n\n Selection.prototype.somethingSelected = function () {\n var this$1 = this;\n\n for (var i = 0; i < this.ranges.length; i++)\n { if (!this$1.ranges[i].empty()) { return true } }\n return false\n };\n\n Selection.prototype.contains = function (pos, end) {\n var this$1 = this;\n\n if (!end) { end = pos; }\n for (var i = 0; i < this.ranges.length; i++) {\n var range = this$1.ranges[i];\n if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)\n { return i }\n }\n return -1\n };\n\n var Range = function(anchor, head) {\n this.anchor = anchor; this.head = head;\n };\n\n Range.prototype.from = function () { return minPos(this.anchor, this.head) };\n Range.prototype.to = function () { return maxPos(this.anchor, this.head) };\n Range.prototype.empty = function () { return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch };\n\n // Take an unsorted, potentially overlapping set of ranges, and\n // build a selection out of it. 'Consumes' ranges array (modifying\n // it).\n function normalizeSelection(cm, ranges, primIndex) {\n var mayTouch = cm && cm.options.selectionsMayTouch;\n var prim = ranges[primIndex];\n ranges.sort(function (a, b) { return cmp(a.from(), b.from()); });\n primIndex = indexOf(ranges, prim);\n for (var i = 1; i < ranges.length; i++) {\n var cur = ranges[i], prev = ranges[i - 1];\n var diff = cmp(prev.to(), cur.from());\n if (mayTouch && !cur.empty() ? diff > 0 : diff >= 0) {\n var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to());\n var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head;\n if (i <= primIndex) { --primIndex; }\n ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to));\n }\n }\n return new Selection(ranges, primIndex)\n }\n\n function simpleSelection(anchor, head) {\n return new Selection([new Range(anchor, head || anchor)], 0)\n }\n\n // Compute the position of the end of a change (its 'to' property\n // refers to the pre-change end).\n function changeEnd(change) {\n if (!change.text) { return change.to }\n return Pos(change.from.line + change.text.length - 1,\n lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))\n }\n\n // Adjust a position to refer to the post-change position of the\n // same text, or the end of the change if the change covers it.\n function adjustForChange(pos, change) {\n if (cmp(pos, change.from) < 0) { return pos }\n if (cmp(pos, change.to) <= 0) { return changeEnd(change) }\n\n var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch;\n if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch; }\n return Pos(line, ch)\n }\n\n function computeSelAfterChange(doc, change) {\n var out = [];\n for (var i = 0; i < doc.sel.ranges.length; i++) {\n var range = doc.sel.ranges[i];\n out.push(new Range(adjustForChange(range.anchor, change),\n adjustForChange(range.head, change)));\n }\n return normalizeSelection(doc.cm, out, doc.sel.primIndex)\n }\n\n function offsetPos(pos, old, nw) {\n if (pos.line == old.line)\n { return Pos(nw.line, pos.ch - old.ch + nw.ch) }\n else\n { return Pos(nw.line + (pos.line - old.line), pos.ch) }\n }\n\n // Used by replaceSelections to allow moving the selection to the\n // start or around the replaced test. Hint may be \"start\" or \"around\".\n function computeReplacedSel(doc, changes, hint) {\n var out = [];\n var oldPrev = Pos(doc.first, 0), newPrev = oldPrev;\n for (var i = 0; i < changes.length; i++) {\n var change = changes[i];\n var from = offsetPos(change.from, oldPrev, newPrev);\n var to = offsetPos(changeEnd(change), oldPrev, newPrev);\n oldPrev = change.to;\n newPrev = to;\n if (hint == \"around\") {\n var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0;\n out[i] = new Range(inv ? to : from, inv ? from : to);\n } else {\n out[i] = new Range(from, from);\n }\n }\n return new Selection(out, doc.sel.primIndex)\n }\n\n // Used to get the editor into a consistent state again when options change.\n\n function loadMode(cm) {\n cm.doc.mode = getMode(cm.options, cm.doc.modeOption);\n resetModeState(cm);\n }\n\n function resetModeState(cm) {\n cm.doc.iter(function (line) {\n if (line.stateAfter) { line.stateAfter = null; }\n if (line.styles) { line.styles = null; }\n });\n cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first;\n startWorker(cm, 100);\n cm.state.modeGen++;\n if (cm.curOp) { regChange(cm); }\n }\n\n // DOCUMENT DATA STRUCTURE\n\n // By default, updates that start and end at the beginning of a line\n // are treated specially, in order to make the association of line\n // widgets and marker elements with the text behave more intuitive.\n function isWholeLineUpdate(doc, change) {\n return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == \"\" &&\n (!doc.cm || doc.cm.options.wholeLineUpdateBefore)\n }\n\n // Perform a change on the document data structure.\n function updateDoc(doc, change, markedSpans, estimateHeight$$1) {\n function spansFor(n) {return markedSpans ? markedSpans[n] : null}\n function update(line, text, spans) {\n updateLine(line, text, spans, estimateHeight$$1);\n signalLater(line, \"change\", line, change);\n }\n function linesFor(start, end) {\n var result = [];\n for (var i = start; i < end; ++i)\n { result.push(new Line(text[i], spansFor(i), estimateHeight$$1)); }\n return result\n }\n\n var from = change.from, to = change.to, text = change.text;\n var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line);\n var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line;\n\n // Adjust the line structure\n if (change.full) {\n doc.insert(0, linesFor(0, text.length));\n doc.remove(text.length, doc.size - text.length);\n } else if (isWholeLineUpdate(doc, change)) {\n // This is a whole-line replace. Treated specially to make\n // sure line objects move the way they are supposed to.\n var added = linesFor(0, text.length - 1);\n update(lastLine, lastLine.text, lastSpans);\n if (nlines) { doc.remove(from.line, nlines); }\n if (added.length) { doc.insert(from.line, added); }\n } else if (firstLine == lastLine) {\n if (text.length == 1) {\n update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans);\n } else {\n var added$1 = linesFor(1, text.length - 1);\n added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight$$1));\n update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));\n doc.insert(from.line + 1, added$1);\n }\n } else if (text.length == 1) {\n update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0));\n doc.remove(from.line + 1, nlines);\n } else {\n update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0));\n update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans);\n var added$2 = linesFor(1, text.length - 1);\n if (nlines > 1) { doc.remove(from.line + 1, nlines - 1); }\n doc.insert(from.line + 1, added$2);\n }\n\n signalLater(doc, \"change\", doc, change);\n }\n\n // Call f for all linked documents.\n function linkedDocs(doc, f, sharedHistOnly) {\n function propagate(doc, skip, sharedHist) {\n if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {\n var rel = doc.linked[i];\n if (rel.doc == skip) { continue }\n var shared = sharedHist && rel.sharedHist;\n if (sharedHistOnly && !shared) { continue }\n f(rel.doc, shared);\n propagate(rel.doc, doc, shared);\n } }\n }\n propagate(doc, null, true);\n }\n\n // Attach a document to an editor.\n function attachDoc(cm, doc) {\n if (doc.cm) { throw new Error(\"This document is already in use.\") }\n cm.doc = doc;\n doc.cm = cm;\n estimateLineHeights(cm);\n loadMode(cm);\n setDirectionClass(cm);\n if (!cm.options.lineWrapping) { findMaxLine(cm); }\n cm.options.mode = doc.modeOption;\n regChange(cm);\n }\n\n function setDirectionClass(cm) {\n (cm.doc.direction == \"rtl\" ? addClass : rmClass)(cm.display.lineDiv, \"CodeMirror-rtl\");\n }\n\n function directionChanged(cm) {\n runInOp(cm, function () {\n setDirectionClass(cm);\n regChange(cm);\n });\n }\n\n function History(startGen) {\n // Arrays of change events and selections. Doing something adds an\n // event to done and clears undo. Undoing moves events from done\n // to undone, redoing moves them in the other direction.\n this.done = []; this.undone = [];\n this.undoDepth = Infinity;\n // Used to track when changes can be merged into a single undo\n // event\n this.lastModTime = this.lastSelTime = 0;\n this.lastOp = this.lastSelOp = null;\n this.lastOrigin = this.lastSelOrigin = null;\n // Used by the isClean() method\n this.generation = this.maxGeneration = startGen || 1;\n }\n\n // Create a history change event from an updateDoc-style change\n // object.\n function historyChangeFromChange(doc, change) {\n var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)};\n attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1);\n linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true);\n return histChange\n }\n\n // Pop all selection events off the end of a history array. Stop at\n // a change event.\n function clearSelectionEvents(array) {\n while (array.length) {\n var last = lst(array);\n if (last.ranges) { array.pop(); }\n else { break }\n }\n }\n\n // Find the top change event in the history. Pop off selection\n // events that are in the way.\n function lastChangeEvent(hist, force) {\n if (force) {\n clearSelectionEvents(hist.done);\n return lst(hist.done)\n } else if (hist.done.length && !lst(hist.done).ranges) {\n return lst(hist.done)\n } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {\n hist.done.pop();\n return lst(hist.done)\n }\n }\n\n // Register a change in the history. Merges changes that are within\n // a single operation, or are close together with an origin that\n // allows merging (starting with \"+\") into a single event.\n function addChangeToHistory(doc, change, selAfter, opId) {\n var hist = doc.history;\n hist.undone.length = 0;\n var time = +new Date, cur;\n var last;\n\n if ((hist.lastOp == opId ||\n hist.lastOrigin == change.origin && change.origin &&\n ((change.origin.charAt(0) == \"+\" && hist.lastModTime > time - (doc.cm ? doc.cm.options.historyEventDelay : 500)) ||\n change.origin.charAt(0) == \"*\")) &&\n (cur = lastChangeEvent(hist, hist.lastOp == opId))) {\n // Merge this change into the last event\n last = lst(cur.changes);\n if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {\n // Optimized case for simple insertion -- don't want to add\n // new changesets for every character typed\n last.to = changeEnd(change);\n } else {\n // Add new sub-event\n cur.changes.push(historyChangeFromChange(doc, change));\n }\n } else {\n // Can not be merged, start a new event.\n var before = lst(hist.done);\n if (!before || !before.ranges)\n { pushSelectionToHistory(doc.sel, hist.done); }\n cur = {changes: [historyChangeFromChange(doc, change)],\n generation: hist.generation};\n hist.done.push(cur);\n while (hist.done.length > hist.undoDepth) {\n hist.done.shift();\n if (!hist.done[0].ranges) { hist.done.shift(); }\n }\n }\n hist.done.push(selAfter);\n hist.generation = ++hist.maxGeneration;\n hist.lastModTime = hist.lastSelTime = time;\n hist.lastOp = hist.lastSelOp = opId;\n hist.lastOrigin = hist.lastSelOrigin = change.origin;\n\n if (!last) { signal(doc, \"historyAdded\"); }\n }\n\n function selectionEventCanBeMerged(doc, origin, prev, sel) {\n var ch = origin.charAt(0);\n return ch == \"*\" ||\n ch == \"+\" &&\n prev.ranges.length == sel.ranges.length &&\n prev.somethingSelected() == sel.somethingSelected() &&\n new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)\n }\n\n // Called whenever the selection changes, sets the new selection as\n // the pending selection in the history, and pushes the old pending\n // selection into the 'done' array when it was significantly\n // different (in number of selected ranges, emptiness, or time).\n function addSelectionToHistory(doc, sel, opId, options) {\n var hist = doc.history, origin = options && options.origin;\n\n // A new event is started when the previous origin does not match\n // the current, or the origins don't allow matching. Origins\n // starting with * are always merged, those starting with + are\n // merged when similar and close together in time.\n if (opId == hist.lastSelOp ||\n (origin && hist.lastSelOrigin == origin &&\n (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||\n selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))\n { hist.done[hist.done.length - 1] = sel; }\n else\n { pushSelectionToHistory(sel, hist.done); }\n\n hist.lastSelTime = +new Date;\n hist.lastSelOrigin = origin;\n hist.lastSelOp = opId;\n if (options && options.clearRedo !== false)\n { clearSelectionEvents(hist.undone); }\n }\n\n function pushSelectionToHistory(sel, dest) {\n var top = lst(dest);\n if (!(top && top.ranges && top.equals(sel)))\n { dest.push(sel); }\n }\n\n // Used to store marked span information in the history.\n function attachLocalSpans(doc, change, from, to) {\n var existing = change[\"spans_\" + doc.id], n = 0;\n doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {\n if (line.markedSpans)\n { (existing || (existing = change[\"spans_\" + doc.id] = {}))[n] = line.markedSpans; }\n ++n;\n });\n }\n\n // When un/re-doing restores text containing marked spans, those\n // that have been explicitly cleared should not be restored.\n function removeClearedSpans(spans) {\n if (!spans) { return null }\n var out;\n for (var i = 0; i < spans.length; ++i) {\n if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i); } }\n else if (out) { out.push(spans[i]); }\n }\n return !out ? spans : out.length ? out : null\n }\n\n // Retrieve and filter the old marked spans stored in a change event.\n function getOldSpans(doc, change) {\n var found = change[\"spans_\" + doc.id];\n if (!found) { return null }\n var nw = [];\n for (var i = 0; i < change.text.length; ++i)\n { nw.push(removeClearedSpans(found[i])); }\n return nw\n }\n\n // Used for un/re-doing changes from the history. Combines the\n // result of computing the existing spans with the set of spans that\n // existed in the history (so that deleting around a span and then\n // undoing brings back the span).\n function mergeOldSpans(doc, change) {\n var old = getOldSpans(doc, change);\n var stretched = stretchSpansOverChange(doc, change);\n if (!old) { return stretched }\n if (!stretched) { return old }\n\n for (var i = 0; i < old.length; ++i) {\n var oldCur = old[i], stretchCur = stretched[i];\n if (oldCur && stretchCur) {\n spans: for (var j = 0; j < stretchCur.length; ++j) {\n var span = stretchCur[j];\n for (var k = 0; k < oldCur.length; ++k)\n { if (oldCur[k].marker == span.marker) { continue spans } }\n oldCur.push(span);\n }\n } else if (stretchCur) {\n old[i] = stretchCur;\n }\n }\n return old\n }\n\n // Used both to provide a JSON-safe object in .getHistory, and, when\n // detaching a document, to split the history in two\n function copyHistoryArray(events, newGroup, instantiateSel) {\n var copy = [];\n for (var i = 0; i < events.length; ++i) {\n var event = events[i];\n if (event.ranges) {\n copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event);\n continue\n }\n var changes = event.changes, newChanges = [];\n copy.push({changes: newChanges});\n for (var j = 0; j < changes.length; ++j) {\n var change = changes[j], m = (void 0);\n newChanges.push({from: change.from, to: change.to, text: change.text});\n if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\\d+)$/)) {\n if (indexOf(newGroup, Number(m[1])) > -1) {\n lst(newChanges)[prop] = change[prop];\n delete change[prop];\n }\n } } }\n }\n }\n return copy\n }\n\n // The 'scroll' parameter given to many of these indicated whether\n // the new cursor position should be scrolled into view after\n // modifying the selection.\n\n // If shift is held or the extend flag is set, extends a range to\n // include a given position (and optionally a second position).\n // Otherwise, simply returns the range between the given positions.\n // Used for cursor motion and such.\n function extendRange(range, head, other, extend) {\n if (extend) {\n var anchor = range.anchor;\n if (other) {\n var posBefore = cmp(head, anchor) < 0;\n if (posBefore != (cmp(other, anchor) < 0)) {\n anchor = head;\n head = other;\n } else if (posBefore != (cmp(head, other) < 0)) {\n head = other;\n }\n }\n return new Range(anchor, head)\n } else {\n return new Range(other || head, head)\n }\n }\n\n // Extend the primary selection range, discard the rest.\n function extendSelection(doc, head, other, options, extend) {\n if (extend == null) { extend = doc.cm && (doc.cm.display.shift || doc.extend); }\n setSelection(doc, new Selection([extendRange(doc.sel.primary(), head, other, extend)], 0), options);\n }\n\n // Extend all selections (pos is an array of selections with length\n // equal the number of selections)\n function extendSelections(doc, heads, options) {\n var out = [];\n var extend = doc.cm && (doc.cm.display.shift || doc.extend);\n for (var i = 0; i < doc.sel.ranges.length; i++)\n { out[i] = extendRange(doc.sel.ranges[i], heads[i], null, extend); }\n var newSel = normalizeSelection(doc.cm, out, doc.sel.primIndex);\n setSelection(doc, newSel, options);\n }\n\n // Updates a single range in the selection.\n function replaceOneSelection(doc, i, range, options) {\n var ranges = doc.sel.ranges.slice(0);\n ranges[i] = range;\n setSelection(doc, normalizeSelection(doc.cm, ranges, doc.sel.primIndex), options);\n }\n\n // Reset the selection to a single range.\n function setSimpleSelection(doc, anchor, head, options) {\n setSelection(doc, simpleSelection(anchor, head), options);\n }\n\n // Give beforeSelectionChange handlers a change to influence a\n // selection update.\n function filterSelectionChange(doc, sel, options) {\n var obj = {\n ranges: sel.ranges,\n update: function(ranges) {\n var this$1 = this;\n\n this.ranges = [];\n for (var i = 0; i < ranges.length; i++)\n { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),\n clipPos(doc, ranges[i].head)); }\n },\n origin: options && options.origin\n };\n signal(doc, \"beforeSelectionChange\", doc, obj);\n if (doc.cm) { signal(doc.cm, \"beforeSelectionChange\", doc.cm, obj); }\n if (obj.ranges != sel.ranges) { return normalizeSelection(doc.cm, obj.ranges, obj.ranges.length - 1) }\n else { return sel }\n }\n\n function setSelectionReplaceHistory(doc, sel, options) {\n var done = doc.history.done, last = lst(done);\n if (last && last.ranges) {\n done[done.length - 1] = sel;\n setSelectionNoUndo(doc, sel, options);\n } else {\n setSelection(doc, sel, options);\n }\n }\n\n // Set a new selection.\n function setSelection(doc, sel, options) {\n setSelectionNoUndo(doc, sel, options);\n addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options);\n }\n\n function setSelectionNoUndo(doc, sel, options) {\n if (hasHandler(doc, \"beforeSelectionChange\") || doc.cm && hasHandler(doc.cm, \"beforeSelectionChange\"))\n { sel = filterSelectionChange(doc, sel, options); }\n\n var bias = options && options.bias ||\n (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);\n setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));\n\n if (!(options && options.scroll === false) && doc.cm)\n { ensureCursorVisible(doc.cm); }\n }\n\n function setSelectionInner(doc, sel) {\n if (sel.equals(doc.sel)) { return }\n\n doc.sel = sel;\n\n if (doc.cm) {\n doc.cm.curOp.updateInput = 1;\n doc.cm.curOp.selectionChanged = true;\n signalCursorActivity(doc.cm);\n }\n signalLater(doc, \"cursorActivity\", doc);\n }\n\n // Verify that the selection does not partially select any atomic\n // marked ranges.\n function reCheckSelection(doc) {\n setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false));\n }\n\n // Return a selection that does not partially select any atomic\n // ranges.\n function skipAtomicInSelection(doc, sel, bias, mayClear) {\n var out;\n for (var i = 0; i < sel.ranges.length; i++) {\n var range = sel.ranges[i];\n var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i];\n var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear);\n var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear);\n if (out || newAnchor != range.anchor || newHead != range.head) {\n if (!out) { out = sel.ranges.slice(0, i); }\n out[i] = new Range(newAnchor, newHead);\n }\n }\n return out ? normalizeSelection(doc.cm, out, sel.primIndex) : sel\n }\n\n function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {\n var line = getLine(doc, pos.line);\n if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {\n var sp = line.markedSpans[i], m = sp.marker;\n if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&\n (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {\n if (mayClear) {\n signal(m, \"beforeCursorEnter\");\n if (m.explicitlyCleared) {\n if (!line.markedSpans) { break }\n else {--i; continue}\n }\n }\n if (!m.atomic) { continue }\n\n if (oldPos) {\n var near = m.find(dir < 0 ? 1 : -1), diff = (void 0);\n if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)\n { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null); }\n if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))\n { return skipAtomicInner(doc, near, pos, dir, mayClear) }\n }\n\n var far = m.find(dir < 0 ? -1 : 1);\n if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)\n { far = movePos(doc, far, dir, far.line == pos.line ? line : null); }\n return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null\n }\n } }\n return pos\n }\n\n // Ensure a given position is not inside an atomic range.\n function skipAtomic(doc, pos, oldPos, bias, mayClear) {\n var dir = bias || 1;\n var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||\n (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||\n skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||\n (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true));\n if (!found) {\n doc.cantEdit = true;\n return Pos(doc.first, 0)\n }\n return found\n }\n\n function movePos(doc, pos, dir, line) {\n if (dir < 0 && pos.ch == 0) {\n if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }\n else { return null }\n } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {\n if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }\n else { return null }\n } else {\n return new Pos(pos.line, pos.ch + dir)\n }\n }\n\n function selectAll(cm) {\n cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll);\n }\n\n // UPDATING\n\n // Allow \"beforeChange\" event handlers to influence a change\n function filterChange(doc, change, update) {\n var obj = {\n canceled: false,\n from: change.from,\n to: change.to,\n text: change.text,\n origin: change.origin,\n cancel: function () { return obj.canceled = true; }\n };\n if (update) { obj.update = function (from, to, text, origin) {\n if (from) { obj.from = clipPos(doc, from); }\n if (to) { obj.to = clipPos(doc, to); }\n if (text) { obj.text = text; }\n if (origin !== undefined) { obj.origin = origin; }\n }; }\n signal(doc, \"beforeChange\", doc, obj);\n if (doc.cm) { signal(doc.cm, \"beforeChange\", doc.cm, obj); }\n\n if (obj.canceled) {\n if (doc.cm) { doc.cm.curOp.updateInput = 2; }\n return null\n }\n return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}\n }\n\n // Apply a change to a document, and add it to the document's\n // history, and propagating it to all linked documents.\n function makeChange(doc, change, ignoreReadOnly) {\n if (doc.cm) {\n if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }\n if (doc.cm.state.suppressEdits) { return }\n }\n\n if (hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\")) {\n change = filterChange(doc, change, true);\n if (!change) { return }\n }\n\n // Possibly split or suppress the update based on the presence\n // of read-only spans in its range.\n var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to);\n if (split) {\n for (var i = split.length - 1; i >= 0; --i)\n { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [\"\"] : change.text, origin: change.origin}); }\n } else {\n makeChangeInner(doc, change);\n }\n }\n\n function makeChangeInner(doc, change) {\n if (change.text.length == 1 && change.text[0] == \"\" && cmp(change.from, change.to) == 0) { return }\n var selAfter = computeSelAfterChange(doc, change);\n addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN);\n\n makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change));\n var rebased = [];\n\n linkedDocs(doc, function (doc, sharedHist) {\n if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n rebaseHist(doc.history, change);\n rebased.push(doc.history);\n }\n makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change));\n });\n }\n\n // Revert a change stored in a document's history.\n function makeChangeFromHistory(doc, type, allowSelectionOnly) {\n var suppress = doc.cm && doc.cm.state.suppressEdits;\n if (suppress && !allowSelectionOnly) { return }\n\n var hist = doc.history, event, selAfter = doc.sel;\n var source = type == \"undo\" ? hist.done : hist.undone, dest = type == \"undo\" ? hist.undone : hist.done;\n\n // Verify that there is a useable event (so that ctrl-z won't\n // needlessly clear selection events)\n var i = 0;\n for (; i < source.length; i++) {\n event = source[i];\n if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)\n { break }\n }\n if (i == source.length) { return }\n hist.lastOrigin = hist.lastSelOrigin = null;\n\n for (;;) {\n event = source.pop();\n if (event.ranges) {\n pushSelectionToHistory(event, dest);\n if (allowSelectionOnly && !event.equals(doc.sel)) {\n setSelection(doc, event, {clearRedo: false});\n return\n }\n selAfter = event;\n } else if (suppress) {\n source.push(event);\n return\n } else { break }\n }\n\n // Build up a reverse change object to add to the opposite history\n // stack (redo when undoing, and vice versa).\n var antiChanges = [];\n pushSelectionToHistory(selAfter, dest);\n dest.push({changes: antiChanges, generation: hist.generation});\n hist.generation = event.generation || ++hist.maxGeneration;\n\n var filter = hasHandler(doc, \"beforeChange\") || doc.cm && hasHandler(doc.cm, \"beforeChange\");\n\n var loop = function ( i ) {\n var change = event.changes[i];\n change.origin = type;\n if (filter && !filterChange(doc, change, false)) {\n source.length = 0;\n return {}\n }\n\n antiChanges.push(historyChangeFromChange(doc, change));\n\n var after = i ? computeSelAfterChange(doc, change) : lst(source);\n makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change));\n if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}); }\n var rebased = [];\n\n // Propagate to the linked documents\n linkedDocs(doc, function (doc, sharedHist) {\n if (!sharedHist && indexOf(rebased, doc.history) == -1) {\n rebaseHist(doc.history, change);\n rebased.push(doc.history);\n }\n makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change));\n });\n };\n\n for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {\n var returned = loop( i$1 );\n\n if ( returned ) return returned.v;\n }\n }\n\n // Sub-views need their line numbers shifted when text is added\n // above or below them in the parent document.\n function shiftDoc(doc, distance) {\n if (distance == 0) { return }\n doc.first += distance;\n doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(\n Pos(range.anchor.line + distance, range.anchor.ch),\n Pos(range.head.line + distance, range.head.ch)\n ); }), doc.sel.primIndex);\n if (doc.cm) {\n regChange(doc.cm, doc.first, doc.first - distance, distance);\n for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)\n { regLineChange(doc.cm, l, \"gutter\"); }\n }\n }\n\n // More lower-level change function, handling only a single document\n // (not linked ones).\n function makeChangeSingleDoc(doc, change, selAfter, spans) {\n if (doc.cm && !doc.cm.curOp)\n { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }\n\n if (change.to.line < doc.first) {\n shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line));\n return\n }\n if (change.from.line > doc.lastLine()) { return }\n\n // Clip the change to the size of this doc\n if (change.from.line < doc.first) {\n var shift = change.text.length - 1 - (doc.first - change.from.line);\n shiftDoc(doc, shift);\n change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),\n text: [lst(change.text)], origin: change.origin};\n }\n var last = doc.lastLine();\n if (change.to.line > last) {\n change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),\n text: [change.text[0]], origin: change.origin};\n }\n\n change.removed = getBetween(doc, change.from, change.to);\n\n if (!selAfter) { selAfter = computeSelAfterChange(doc, change); }\n if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans); }\n else { updateDoc(doc, change, spans); }\n setSelectionNoUndo(doc, selAfter, sel_dontScroll);\n }\n\n // Handle the interaction of a change to a document with the editor\n // that this document is part of.\n function makeChangeSingleDocInEditor(cm, change, spans) {\n var doc = cm.doc, display = cm.display, from = change.from, to = change.to;\n\n var recomputeMaxLength = false, checkWidthStart = from.line;\n if (!cm.options.lineWrapping) {\n checkWidthStart = lineNo(visualLine(getLine(doc, from.line)));\n doc.iter(checkWidthStart, to.line + 1, function (line) {\n if (line == display.maxLine) {\n recomputeMaxLength = true;\n return true\n }\n });\n }\n\n if (doc.sel.contains(change.from, change.to) > -1)\n { signalCursorActivity(cm); }\n\n updateDoc(doc, change, spans, estimateHeight(cm));\n\n if (!cm.options.lineWrapping) {\n doc.iter(checkWidthStart, from.line + change.text.length, function (line) {\n var len = lineLength(line);\n if (len > display.maxLineLength) {\n display.maxLine = line;\n display.maxLineLength = len;\n display.maxLineChanged = true;\n recomputeMaxLength = false;\n }\n });\n if (recomputeMaxLength) { cm.curOp.updateMaxLine = true; }\n }\n\n retreatFrontier(doc, from.line);\n startWorker(cm, 400);\n\n var lendiff = change.text.length - (to.line - from.line) - 1;\n // Remember that these lines changed, for updating the display\n if (change.full)\n { regChange(cm); }\n else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))\n { regLineChange(cm, from.line, \"text\"); }\n else\n { regChange(cm, from.line, to.line + 1, lendiff); }\n\n var changesHandler = hasHandler(cm, \"changes\"), changeHandler = hasHandler(cm, \"change\");\n if (changeHandler || changesHandler) {\n var obj = {\n from: from, to: to,\n text: change.text,\n removed: change.removed,\n origin: change.origin\n };\n if (changeHandler) { signalLater(cm, \"change\", cm, obj); }\n if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj); }\n }\n cm.display.selForContextMenu = null;\n }\n\n function replaceRange(doc, code, from, to, origin) {\n var assign;\n\n if (!to) { to = from; }\n if (cmp(to, from) < 0) { (assign = [to, from], from = assign[0], to = assign[1]); }\n if (typeof code == \"string\") { code = doc.splitLines(code); }\n makeChange(doc, {from: from, to: to, text: code, origin: origin});\n }\n\n // Rebasing/resetting history to deal with externally-sourced changes\n\n function rebaseHistSelSingle(pos, from, to, diff) {\n if (to < pos.line) {\n pos.line += diff;\n } else if (from < pos.line) {\n pos.line = from;\n pos.ch = 0;\n }\n }\n\n // Tries to rebase an array of history events given a change in the\n // document. If the change touches the same lines as the event, the\n // event, and everything 'behind' it, is discarded. If the change is\n // before the event, the event's positions are updated. Uses a\n // copy-on-write scheme for the positions, to avoid having to\n // reallocate them all on every rebase, but also avoid problems with\n // shared position objects being unsafely updated.\n function rebaseHistArray(array, from, to, diff) {\n for (var i = 0; i < array.length; ++i) {\n var sub = array[i], ok = true;\n if (sub.ranges) {\n if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true; }\n for (var j = 0; j < sub.ranges.length; j++) {\n rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff);\n rebaseHistSelSingle(sub.ranges[j].head, from, to, diff);\n }\n continue\n }\n for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {\n var cur = sub.changes[j$1];\n if (to < cur.from.line) {\n cur.from = Pos(cur.from.line + diff, cur.from.ch);\n cur.to = Pos(cur.to.line + diff, cur.to.ch);\n } else if (from <= cur.to.line) {\n ok = false;\n break\n }\n }\n if (!ok) {\n array.splice(0, i + 1);\n i = 0;\n }\n }\n }\n\n function rebaseHist(hist, change) {\n var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1;\n rebaseHistArray(hist.done, from, to, diff);\n rebaseHistArray(hist.undone, from, to, diff);\n }\n\n // Utility for applying a change to a line by handle or number,\n // returning the number and optionally registering the line as\n // changed.\n function changeLine(doc, handle, changeType, op) {\n var no = handle, line = handle;\n if (typeof handle == \"number\") { line = getLine(doc, clipLine(doc, handle)); }\n else { no = lineNo(handle); }\n if (no == null) { return null }\n if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType); }\n return line\n }\n\n // The document is represented as a BTree consisting of leaves, with\n // chunk of lines in them, and branches, with up to ten leaves or\n // other branch nodes below them. The top node is always a branch\n // node, and is the document object itself (meaning it has\n // additional methods and properties).\n //\n // All nodes have parent links. The tree is used both to go from\n // line numbers to line objects, and to go from objects to numbers.\n // It also indexes by height, and is used to convert between height\n // and line object, and to find the total height of the document.\n //\n // See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html\n\n function LeafChunk(lines) {\n var this$1 = this;\n\n this.lines = lines;\n this.parent = null;\n var height = 0;\n for (var i = 0; i < lines.length; ++i) {\n lines[i].parent = this$1;\n height += lines[i].height;\n }\n this.height = height;\n }\n\n LeafChunk.prototype = {\n chunkSize: function() { return this.lines.length },\n\n // Remove the n lines at offset 'at'.\n removeInner: function(at, n) {\n var this$1 = this;\n\n for (var i = at, e = at + n; i < e; ++i) {\n var line = this$1.lines[i];\n this$1.height -= line.height;\n cleanUpLine(line);\n signalLater(line, \"delete\");\n }\n this.lines.splice(at, n);\n },\n\n // Helper used to collapse a small branch into a single leaf.\n collapse: function(lines) {\n lines.push.apply(lines, this.lines);\n },\n\n // Insert the given array of lines at offset 'at', count them as\n // having the given height.\n insertInner: function(at, lines, height) {\n var this$1 = this;\n\n this.height += height;\n this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at));\n for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1; }\n },\n\n // Used to iterate over a part of the tree.\n iterN: function(at, n, op) {\n var this$1 = this;\n\n for (var e = at + n; at < e; ++at)\n { if (op(this$1.lines[at])) { return true } }\n }\n };\n\n function BranchChunk(children) {\n var this$1 = this;\n\n this.children = children;\n var size = 0, height = 0;\n for (var i = 0; i < children.length; ++i) {\n var ch = children[i];\n size += ch.chunkSize(); height += ch.height;\n ch.parent = this$1;\n }\n this.size = size;\n this.height = height;\n this.parent = null;\n }\n\n BranchChunk.prototype = {\n chunkSize: function() { return this.size },\n\n removeInner: function(at, n) {\n var this$1 = this;\n\n this.size -= n;\n for (var i = 0; i < this.children.length; ++i) {\n var child = this$1.children[i], sz = child.chunkSize();\n if (at < sz) {\n var rm = Math.min(n, sz - at), oldHeight = child.height;\n child.removeInner(at, rm);\n this$1.height -= oldHeight - child.height;\n if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null; }\n if ((n -= rm) == 0) { break }\n at = 0;\n } else { at -= sz; }\n }\n // If the result is smaller than 25 lines, ensure that it is a\n // single leaf node.\n if (this.size - n < 25 &&\n (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {\n var lines = [];\n this.collapse(lines);\n this.children = [new LeafChunk(lines)];\n this.children[0].parent = this;\n }\n },\n\n collapse: function(lines) {\n var this$1 = this;\n\n for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines); }\n },\n\n insertInner: function(at, lines, height) {\n var this$1 = this;\n\n this.size += lines.length;\n this.height += height;\n for (var i = 0; i < this.children.length; ++i) {\n var child = this$1.children[i], sz = child.chunkSize();\n if (at <= sz) {\n child.insertInner(at, lines, height);\n if (child.lines && child.lines.length > 50) {\n // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.\n // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.\n var remaining = child.lines.length % 25 + 25;\n for (var pos = remaining; pos < child.lines.length;) {\n var leaf = new LeafChunk(child.lines.slice(pos, pos += 25));\n child.height -= leaf.height;\n this$1.children.splice(++i, 0, leaf);\n leaf.parent = this$1;\n }\n child.lines = child.lines.slice(0, remaining);\n this$1.maybeSpill();\n }\n break\n }\n at -= sz;\n }\n },\n\n // When a node has grown, check whether it should be split.\n maybeSpill: function() {\n if (this.children.length <= 10) { return }\n var me = this;\n do {\n var spilled = me.children.splice(me.children.length - 5, 5);\n var sibling = new BranchChunk(spilled);\n if (!me.parent) { // Become the parent node\n var copy = new BranchChunk(me.children);\n copy.parent = me;\n me.children = [copy, sibling];\n me = copy;\n } else {\n me.size -= sibling.size;\n me.height -= sibling.height;\n var myIndex = indexOf(me.parent.children, me);\n me.parent.children.splice(myIndex + 1, 0, sibling);\n }\n sibling.parent = me.parent;\n } while (me.children.length > 10)\n me.parent.maybeSpill();\n },\n\n iterN: function(at, n, op) {\n var this$1 = this;\n\n for (var i = 0; i < this.children.length; ++i) {\n var child = this$1.children[i], sz = child.chunkSize();\n if (at < sz) {\n var used = Math.min(n, sz - at);\n if (child.iterN(at, used, op)) { return true }\n if ((n -= used) == 0) { break }\n at = 0;\n } else { at -= sz; }\n }\n }\n };\n\n // Line widgets are block elements displayed above or below a line.\n\n var LineWidget = function(doc, node, options) {\n var this$1 = this;\n\n if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))\n { this$1[opt] = options[opt]; } } }\n this.doc = doc;\n this.node = node;\n };\n\n LineWidget.prototype.clear = function () {\n var this$1 = this;\n\n var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line);\n if (no == null || !ws) { return }\n for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1); } }\n if (!ws.length) { line.widgets = null; }\n var height = widgetHeight(this);\n updateLineHeight(line, Math.max(0, line.height - height));\n if (cm) {\n runInOp(cm, function () {\n adjustScrollWhenAboveVisible(cm, line, -height);\n regLineChange(cm, no, \"widget\");\n });\n signalLater(cm, \"lineWidgetCleared\", cm, this, no);\n }\n };\n\n LineWidget.prototype.changed = function () {\n var this$1 = this;\n\n var oldH = this.height, cm = this.doc.cm, line = this.line;\n this.height = null;\n var diff = widgetHeight(this) - oldH;\n if (!diff) { return }\n if (!lineIsHidden(this.doc, line)) { updateLineHeight(line, line.height + diff); }\n if (cm) {\n runInOp(cm, function () {\n cm.curOp.forceUpdate = true;\n adjustScrollWhenAboveVisible(cm, line, diff);\n signalLater(cm, \"lineWidgetChanged\", cm, this$1, lineNo(line));\n });\n }\n };\n eventMixin(LineWidget);\n\n function adjustScrollWhenAboveVisible(cm, line, diff) {\n if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))\n { addToScrollTop(cm, diff); }\n }\n\n function addLineWidget(doc, handle, node, options) {\n var widget = new LineWidget(doc, node, options);\n var cm = doc.cm;\n if (cm && widget.noHScroll) { cm.display.alignWidgets = true; }\n changeLine(doc, handle, \"widget\", function (line) {\n var widgets = line.widgets || (line.widgets = []);\n if (widget.insertAt == null) { widgets.push(widget); }\n else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget); }\n widget.line = line;\n if (cm && !lineIsHidden(doc, line)) {\n var aboveVisible = heightAtLine(line) < doc.scrollTop;\n updateLineHeight(line, line.height + widgetHeight(widget));\n if (aboveVisible) { addToScrollTop(cm, widget.height); }\n cm.curOp.forceUpdate = true;\n }\n return true\n });\n if (cm) { signalLater(cm, \"lineWidgetAdded\", cm, widget, typeof handle == \"number\" ? handle : lineNo(handle)); }\n return widget\n }\n\n // TEXTMARKERS\n\n // Created with markText and setBookmark methods. A TextMarker is a\n // handle that can be used to clear or find a marked position in the\n // document. Line objects hold arrays (markedSpans) containing\n // {from, to, marker} object pointing to such marker objects, and\n // indicating that such a marker is present on that line. Multiple\n // lines may point to the same marker when it spans across lines.\n // The spans will have null for their from/to properties when the\n // marker continues beyond the start/end of the line. Markers have\n // links back to the lines they currently touch.\n\n // Collapsed markers have unique ids, in order to be able to order\n // them, which is needed for uniquely determining an outer marker\n // when they overlap (they may nest, but not partially overlap).\n var nextMarkerId = 0;\n\n var TextMarker = function(doc, type) {\n this.lines = [];\n this.type = type;\n this.doc = doc;\n this.id = ++nextMarkerId;\n };\n\n // Clear the marker.\n TextMarker.prototype.clear = function () {\n var this$1 = this;\n\n if (this.explicitlyCleared) { return }\n var cm = this.doc.cm, withOp = cm && !cm.curOp;\n if (withOp) { startOperation(cm); }\n if (hasHandler(this, \"clear\")) {\n var found = this.find();\n if (found) { signalLater(this, \"clear\", found.from, found.to); }\n }\n var min = null, max = null;\n for (var i = 0; i < this.lines.length; ++i) {\n var line = this$1.lines[i];\n var span = getMarkedSpanFor(line.markedSpans, this$1);\n if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), \"text\"); }\n else if (cm) {\n if (span.to != null) { max = lineNo(line); }\n if (span.from != null) { min = lineNo(line); }\n }\n line.markedSpans = removeMarkedSpan(line.markedSpans, span);\n if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)\n { updateLineHeight(line, textHeight(cm.display)); }\n }\n if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {\n var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual);\n if (len > cm.display.maxLineLength) {\n cm.display.maxLine = visual;\n cm.display.maxLineLength = len;\n cm.display.maxLineChanged = true;\n }\n } }\n\n if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1); }\n this.lines.length = 0;\n this.explicitlyCleared = true;\n if (this.atomic && this.doc.cantEdit) {\n this.doc.cantEdit = false;\n if (cm) { reCheckSelection(cm.doc); }\n }\n if (cm) { signalLater(cm, \"markerCleared\", cm, this, min, max); }\n if (withOp) { endOperation(cm); }\n if (this.parent) { this.parent.clear(); }\n };\n\n // Find the position of the marker in the document. Returns a {from,\n // to} object by default. Side can be passed to get a specific side\n // -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the\n // Pos objects returned contain a line object, rather than a line\n // number (used to prevent looking up the same line twice).\n TextMarker.prototype.find = function (side, lineObj) {\n var this$1 = this;\n\n if (side == null && this.type == \"bookmark\") { side = 1; }\n var from, to;\n for (var i = 0; i < this.lines.length; ++i) {\n var line = this$1.lines[i];\n var span = getMarkedSpanFor(line.markedSpans, this$1);\n if (span.from != null) {\n from = Pos(lineObj ? line : lineNo(line), span.from);\n if (side == -1) { return from }\n }\n if (span.to != null) {\n to = Pos(lineObj ? line : lineNo(line), span.to);\n if (side == 1) { return to }\n }\n }\n return from && {from: from, to: to}\n };\n\n // Signals that the marker's widget changed, and surrounding layout\n // should be recomputed.\n TextMarker.prototype.changed = function () {\n var this$1 = this;\n\n var pos = this.find(-1, true), widget = this, cm = this.doc.cm;\n if (!pos || !cm) { return }\n runInOp(cm, function () {\n var line = pos.line, lineN = lineNo(pos.line);\n var view = findViewForLine(cm, lineN);\n if (view) {\n clearLineMeasurementCacheFor(view);\n cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;\n }\n cm.curOp.updateMaxLine = true;\n if (!lineIsHidden(widget.doc, line) && widget.height != null) {\n var oldHeight = widget.height;\n widget.height = null;\n var dHeight = widgetHeight(widget) - oldHeight;\n if (dHeight)\n { updateLineHeight(line, line.height + dHeight); }\n }\n signalLater(cm, \"markerChanged\", cm, this$1);\n });\n };\n\n TextMarker.prototype.attachLine = function (line) {\n if (!this.lines.length && this.doc.cm) {\n var op = this.doc.cm.curOp;\n if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)\n { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this); }\n }\n this.lines.push(line);\n };\n\n TextMarker.prototype.detachLine = function (line) {\n this.lines.splice(indexOf(this.lines, line), 1);\n if (!this.lines.length && this.doc.cm) {\n var op = this.doc.cm.curOp\n ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this);\n }\n };\n eventMixin(TextMarker);\n\n // Create a marker, wire it up to the right lines, and\n function markText(doc, from, to, options, type) {\n // Shared markers (across linked documents) are handled separately\n // (markTextShared will call out to this again, once per\n // document).\n if (options && options.shared) { return markTextShared(doc, from, to, options, type) }\n // Ensure we are in an operation.\n if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }\n\n var marker = new TextMarker(doc, type), diff = cmp(from, to);\n if (options) { copyObj(options, marker, false); }\n // Don't connect empty markers unless clearWhenEmpty is false\n if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)\n { return marker }\n if (marker.replacedWith) {\n // Showing up as a widget implies collapsed (widget replaces text)\n marker.collapsed = true;\n marker.widgetNode = eltP(\"span\", [marker.replacedWith], \"CodeMirror-widget\");\n if (!options.handleMouseEvents) { marker.widgetNode.setAttribute(\"cm-ignore-events\", \"true\"); }\n if (options.insertLeft) { marker.widgetNode.insertLeft = true; }\n }\n if (marker.collapsed) {\n if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||\n from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))\n { throw new Error(\"Inserting collapsed marker partially overlapping an existing one\") }\n seeCollapsedSpans();\n }\n\n if (marker.addToHistory)\n { addChangeToHistory(doc, {from: from, to: to, origin: \"markText\"}, doc.sel, NaN); }\n\n var curLine = from.line, cm = doc.cm, updateMaxLine;\n doc.iter(curLine, to.line + 1, function (line) {\n if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)\n { updateMaxLine = true; }\n if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0); }\n addMarkedSpan(line, new MarkedSpan(marker,\n curLine == from.line ? from.ch : null,\n curLine == to.line ? to.ch : null));\n ++curLine;\n });\n // lineIsHidden depends on the presence of the spans, so needs a second pass\n if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {\n if (lineIsHidden(doc, line)) { updateLineHeight(line, 0); }\n }); }\n\n if (marker.clearOnEnter) { on(marker, \"beforeCursorEnter\", function () { return marker.clear(); }); }\n\n if (marker.readOnly) {\n seeReadOnlySpans();\n if (doc.history.done.length || doc.history.undone.length)\n { doc.clearHistory(); }\n }\n if (marker.collapsed) {\n marker.id = ++nextMarkerId;\n marker.atomic = true;\n }\n if (cm) {\n // Sync editor state\n if (updateMaxLine) { cm.curOp.updateMaxLine = true; }\n if (marker.collapsed)\n { regChange(cm, from.line, to.line + 1); }\n else if (marker.className || marker.startStyle || marker.endStyle || marker.css ||\n marker.attributes || marker.title)\n { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, \"text\"); } }\n if (marker.atomic) { reCheckSelection(cm.doc); }\n signalLater(cm, \"markerAdded\", cm, marker);\n }\n return marker\n }\n\n // SHARED TEXTMARKERS\n\n // A shared marker spans multiple linked documents. It is\n // implemented as a meta-marker-object controlling multiple normal\n // markers.\n var SharedTextMarker = function(markers, primary) {\n var this$1 = this;\n\n this.markers = markers;\n this.primary = primary;\n for (var i = 0; i < markers.length; ++i)\n { markers[i].parent = this$1; }\n };\n\n SharedTextMarker.prototype.clear = function () {\n var this$1 = this;\n\n if (this.explicitlyCleared) { return }\n this.explicitlyCleared = true;\n for (var i = 0; i < this.markers.length; ++i)\n { this$1.markers[i].clear(); }\n signalLater(this, \"clear\");\n };\n\n SharedTextMarker.prototype.find = function (side, lineObj) {\n return this.primary.find(side, lineObj)\n };\n eventMixin(SharedTextMarker);\n\n function markTextShared(doc, from, to, options, type) {\n options = copyObj(options);\n options.shared = false;\n var markers = [markText(doc, from, to, options, type)], primary = markers[0];\n var widget = options.widgetNode;\n linkedDocs(doc, function (doc) {\n if (widget) { options.widgetNode = widget.cloneNode(true); }\n markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type));\n for (var i = 0; i < doc.linked.length; ++i)\n { if (doc.linked[i].isParent) { return } }\n primary = lst(markers);\n });\n return new SharedTextMarker(markers, primary)\n }\n\n function findSharedMarkers(doc) {\n return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })\n }\n\n function copySharedMarkers(doc, markers) {\n for (var i = 0; i < markers.length; i++) {\n var marker = markers[i], pos = marker.find();\n var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to);\n if (cmp(mFrom, mTo)) {\n var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type);\n marker.markers.push(subMark);\n subMark.parent = marker;\n }\n }\n }\n\n function detachSharedMarkers(markers) {\n var loop = function ( i ) {\n var marker = markers[i], linked = [marker.primary.doc];\n linkedDocs(marker.primary.doc, function (d) { return linked.push(d); });\n for (var j = 0; j < marker.markers.length; j++) {\n var subMarker = marker.markers[j];\n if (indexOf(linked, subMarker.doc) == -1) {\n subMarker.parent = null;\n marker.markers.splice(j--, 1);\n }\n }\n };\n\n for (var i = 0; i < markers.length; i++) loop( i );\n }\n\n var nextDocId = 0;\n var Doc = function(text, mode, firstLine, lineSep, direction) {\n if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep, direction) }\n if (firstLine == null) { firstLine = 0; }\n\n BranchChunk.call(this, [new LeafChunk([new Line(\"\", null)])]);\n this.first = firstLine;\n this.scrollTop = this.scrollLeft = 0;\n this.cantEdit = false;\n this.cleanGeneration = 1;\n this.modeFrontier = this.highlightFrontier = firstLine;\n var start = Pos(firstLine, 0);\n this.sel = simpleSelection(start);\n this.history = new History(null);\n this.id = ++nextDocId;\n this.modeOption = mode;\n this.lineSep = lineSep;\n this.direction = (direction == \"rtl\") ? \"rtl\" : \"ltr\";\n this.extend = false;\n\n if (typeof text == \"string\") { text = this.splitLines(text); }\n updateDoc(this, {from: start, to: start, text: text});\n setSelection(this, simpleSelection(start), sel_dontScroll);\n };\n\n Doc.prototype = createObj(BranchChunk.prototype, {\n constructor: Doc,\n // Iterate over the document. Supports two forms -- with only one\n // argument, it calls that for each line in the document. With\n // three, it iterates over the range given by the first two (with\n // the second being non-inclusive).\n iter: function(from, to, op) {\n if (op) { this.iterN(from - this.first, to - from, op); }\n else { this.iterN(this.first, this.first + this.size, from); }\n },\n\n // Non-public interface for adding and removing lines.\n insert: function(at, lines) {\n var height = 0;\n for (var i = 0; i < lines.length; ++i) { height += lines[i].height; }\n this.insertInner(at - this.first, lines, height);\n },\n remove: function(at, n) { this.removeInner(at - this.first, n); },\n\n // From here, the methods are part of the public interface. Most\n // are also available from CodeMirror (editor) instances.\n\n getValue: function(lineSep) {\n var lines = getLines(this, this.first, this.first + this.size);\n if (lineSep === false) { return lines }\n return lines.join(lineSep || this.lineSeparator())\n },\n setValue: docMethodOp(function(code) {\n var top = Pos(this.first, 0), last = this.first + this.size - 1;\n makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),\n text: this.splitLines(code), origin: \"setValue\", full: true}, true);\n if (this.cm) { scrollToCoords(this.cm, 0, 0); }\n setSelection(this, simpleSelection(top), sel_dontScroll);\n }),\n replaceRange: function(code, from, to, origin) {\n from = clipPos(this, from);\n to = to ? clipPos(this, to) : from;\n replaceRange(this, code, from, to, origin);\n },\n getRange: function(from, to, lineSep) {\n var lines = getBetween(this, clipPos(this, from), clipPos(this, to));\n if (lineSep === false) { return lines }\n return lines.join(lineSep || this.lineSeparator())\n },\n\n getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},\n\n getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},\n getLineNumber: function(line) {return lineNo(line)},\n\n getLineHandleVisualStart: function(line) {\n if (typeof line == \"number\") { line = getLine(this, line); }\n return visualLine(line)\n },\n\n lineCount: function() {return this.size},\n firstLine: function() {return this.first},\n lastLine: function() {return this.first + this.size - 1},\n\n clipPos: function(pos) {return clipPos(this, pos)},\n\n getCursor: function(start) {\n var range$$1 = this.sel.primary(), pos;\n if (start == null || start == \"head\") { pos = range$$1.head; }\n else if (start == \"anchor\") { pos = range$$1.anchor; }\n else if (start == \"end\" || start == \"to\" || start === false) { pos = range$$1.to(); }\n else { pos = range$$1.from(); }\n return pos\n },\n listSelections: function() { return this.sel.ranges },\n somethingSelected: function() {return this.sel.somethingSelected()},\n\n setCursor: docMethodOp(function(line, ch, options) {\n setSimpleSelection(this, clipPos(this, typeof line == \"number\" ? Pos(line, ch || 0) : line), null, options);\n }),\n setSelection: docMethodOp(function(anchor, head, options) {\n setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options);\n }),\n extendSelection: docMethodOp(function(head, other, options) {\n extendSelection(this, clipPos(this, head), other && clipPos(this, other), options);\n }),\n extendSelections: docMethodOp(function(heads, options) {\n extendSelections(this, clipPosArray(this, heads), options);\n }),\n extendSelectionsBy: docMethodOp(function(f, options) {\n var heads = map(this.sel.ranges, f);\n extendSelections(this, clipPosArray(this, heads), options);\n }),\n setSelections: docMethodOp(function(ranges, primary, options) {\n var this$1 = this;\n\n if (!ranges.length) { return }\n var out = [];\n for (var i = 0; i < ranges.length; i++)\n { out[i] = new Range(clipPos(this$1, ranges[i].anchor),\n clipPos(this$1, ranges[i].head)); }\n if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex); }\n setSelection(this, normalizeSelection(this.cm, out, primary), options);\n }),\n addSelection: docMethodOp(function(anchor, head, options) {\n var ranges = this.sel.ranges.slice(0);\n ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)));\n setSelection(this, normalizeSelection(this.cm, ranges, ranges.length - 1), options);\n }),\n\n getSelection: function(lineSep) {\n var this$1 = this;\n\n var ranges = this.sel.ranges, lines;\n for (var i = 0; i < ranges.length; i++) {\n var sel = getBetween(this$1, ranges[i].from(), ranges[i].to());\n lines = lines ? lines.concat(sel) : sel;\n }\n if (lineSep === false) { return lines }\n else { return lines.join(lineSep || this.lineSeparator()) }\n },\n getSelections: function(lineSep) {\n var this$1 = this;\n\n var parts = [], ranges = this.sel.ranges;\n for (var i = 0; i < ranges.length; i++) {\n var sel = getBetween(this$1, ranges[i].from(), ranges[i].to());\n if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()); }\n parts[i] = sel;\n }\n return parts\n },\n replaceSelection: function(code, collapse, origin) {\n var dup = [];\n for (var i = 0; i < this.sel.ranges.length; i++)\n { dup[i] = code; }\n this.replaceSelections(dup, collapse, origin || \"+input\");\n },\n replaceSelections: docMethodOp(function(code, collapse, origin) {\n var this$1 = this;\n\n var changes = [], sel = this.sel;\n for (var i = 0; i < sel.ranges.length; i++) {\n var range$$1 = sel.ranges[i];\n changes[i] = {from: range$$1.from(), to: range$$1.to(), text: this$1.splitLines(code[i]), origin: origin};\n }\n var newSel = collapse && collapse != \"end\" && computeReplacedSel(this, changes, collapse);\n for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)\n { makeChange(this$1, changes[i$1]); }\n if (newSel) { setSelectionReplaceHistory(this, newSel); }\n else if (this.cm) { ensureCursorVisible(this.cm); }\n }),\n undo: docMethodOp(function() {makeChangeFromHistory(this, \"undo\");}),\n redo: docMethodOp(function() {makeChangeFromHistory(this, \"redo\");}),\n undoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"undo\", true);}),\n redoSelection: docMethodOp(function() {makeChangeFromHistory(this, \"redo\", true);}),\n\n setExtending: function(val) {this.extend = val;},\n getExtending: function() {return this.extend},\n\n historySize: function() {\n var hist = this.history, done = 0, undone = 0;\n for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done; } }\n for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone; } }\n return {undo: done, redo: undone}\n },\n clearHistory: function() {this.history = new History(this.history.maxGeneration);},\n\n markClean: function() {\n this.cleanGeneration = this.changeGeneration(true);\n },\n changeGeneration: function(forceSplit) {\n if (forceSplit)\n { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null; }\n return this.history.generation\n },\n isClean: function (gen) {\n return this.history.generation == (gen || this.cleanGeneration)\n },\n\n getHistory: function() {\n return {done: copyHistoryArray(this.history.done),\n undone: copyHistoryArray(this.history.undone)}\n },\n setHistory: function(histData) {\n var hist = this.history = new History(this.history.maxGeneration);\n hist.done = copyHistoryArray(histData.done.slice(0), null, true);\n hist.undone = copyHistoryArray(histData.undone.slice(0), null, true);\n },\n\n setGutterMarker: docMethodOp(function(line, gutterID, value) {\n return changeLine(this, line, \"gutter\", function (line) {\n var markers = line.gutterMarkers || (line.gutterMarkers = {});\n markers[gutterID] = value;\n if (!value && isEmpty(markers)) { line.gutterMarkers = null; }\n return true\n })\n }),\n\n clearGutter: docMethodOp(function(gutterID) {\n var this$1 = this;\n\n this.iter(function (line) {\n if (line.gutterMarkers && line.gutterMarkers[gutterID]) {\n changeLine(this$1, line, \"gutter\", function () {\n line.gutterMarkers[gutterID] = null;\n if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null; }\n return true\n });\n }\n });\n }),\n\n lineInfo: function(line) {\n var n;\n if (typeof line == \"number\") {\n if (!isLine(this, line)) { return null }\n n = line;\n line = getLine(this, line);\n if (!line) { return null }\n } else {\n n = lineNo(line);\n if (n == null) { return null }\n }\n return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,\n textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,\n widgets: line.widgets}\n },\n\n addLineClass: docMethodOp(function(handle, where, cls) {\n return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n var prop = where == \"text\" ? \"textClass\"\n : where == \"background\" ? \"bgClass\"\n : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\";\n if (!line[prop]) { line[prop] = cls; }\n else if (classTest(cls).test(line[prop])) { return false }\n else { line[prop] += \" \" + cls; }\n return true\n })\n }),\n removeLineClass: docMethodOp(function(handle, where, cls) {\n return changeLine(this, handle, where == \"gutter\" ? \"gutter\" : \"class\", function (line) {\n var prop = where == \"text\" ? \"textClass\"\n : where == \"background\" ? \"bgClass\"\n : where == \"gutter\" ? \"gutterClass\" : \"wrapClass\";\n var cur = line[prop];\n if (!cur) { return false }\n else if (cls == null) { line[prop] = null; }\n else {\n var found = cur.match(classTest(cls));\n if (!found) { return false }\n var end = found.index + found[0].length;\n line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? \"\" : \" \") + cur.slice(end) || null;\n }\n return true\n })\n }),\n\n addLineWidget: docMethodOp(function(handle, node, options) {\n return addLineWidget(this, handle, node, options)\n }),\n removeLineWidget: function(widget) { widget.clear(); },\n\n markText: function(from, to, options) {\n return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || \"range\")\n },\n setBookmark: function(pos, options) {\n var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),\n insertLeft: options && options.insertLeft,\n clearWhenEmpty: false, shared: options && options.shared,\n handleMouseEvents: options && options.handleMouseEvents};\n pos = clipPos(this, pos);\n return markText(this, pos, pos, realOpts, \"bookmark\")\n },\n findMarksAt: function(pos) {\n pos = clipPos(this, pos);\n var markers = [], spans = getLine(this, pos.line).markedSpans;\n if (spans) { for (var i = 0; i < spans.length; ++i) {\n var span = spans[i];\n if ((span.from == null || span.from <= pos.ch) &&\n (span.to == null || span.to >= pos.ch))\n { markers.push(span.marker.parent || span.marker); }\n } }\n return markers\n },\n findMarks: function(from, to, filter) {\n from = clipPos(this, from); to = clipPos(this, to);\n var found = [], lineNo$$1 = from.line;\n this.iter(from.line, to.line + 1, function (line) {\n var spans = line.markedSpans;\n if (spans) { for (var i = 0; i < spans.length; i++) {\n var span = spans[i];\n if (!(span.to != null && lineNo$$1 == from.line && from.ch >= span.to ||\n span.from == null && lineNo$$1 != from.line ||\n span.from != null && lineNo$$1 == to.line && span.from >= to.ch) &&\n (!filter || filter(span.marker)))\n { found.push(span.marker.parent || span.marker); }\n } }\n ++lineNo$$1;\n });\n return found\n },\n getAllMarks: function() {\n var markers = [];\n this.iter(function (line) {\n var sps = line.markedSpans;\n if (sps) { for (var i = 0; i < sps.length; ++i)\n { if (sps[i].from != null) { markers.push(sps[i].marker); } } }\n });\n return markers\n },\n\n posFromIndex: function(off) {\n var ch, lineNo$$1 = this.first, sepSize = this.lineSeparator().length;\n this.iter(function (line) {\n var sz = line.text.length + sepSize;\n if (sz > off) { ch = off; return true }\n off -= sz;\n ++lineNo$$1;\n });\n return clipPos(this, Pos(lineNo$$1, ch))\n },\n indexFromPos: function (coords) {\n coords = clipPos(this, coords);\n var index = coords.ch;\n if (coords.line < this.first || coords.ch < 0) { return 0 }\n var sepSize = this.lineSeparator().length;\n this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value\n index += line.text.length + sepSize;\n });\n return index\n },\n\n copy: function(copyHistory) {\n var doc = new Doc(getLines(this, this.first, this.first + this.size),\n this.modeOption, this.first, this.lineSep, this.direction);\n doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft;\n doc.sel = this.sel;\n doc.extend = false;\n if (copyHistory) {\n doc.history.undoDepth = this.history.undoDepth;\n doc.setHistory(this.getHistory());\n }\n return doc\n },\n\n linkedDoc: function(options) {\n if (!options) { options = {}; }\n var from = this.first, to = this.first + this.size;\n if (options.from != null && options.from > from) { from = options.from; }\n if (options.to != null && options.to < to) { to = options.to; }\n var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep, this.direction);\n if (options.sharedHist) { copy.history = this.history\n ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist});\n copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}];\n copySharedMarkers(copy, findSharedMarkers(this));\n return copy\n },\n unlinkDoc: function(other) {\n var this$1 = this;\n\n if (other instanceof CodeMirror) { other = other.doc; }\n if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {\n var link = this$1.linked[i];\n if (link.doc != other) { continue }\n this$1.linked.splice(i, 1);\n other.unlinkDoc(this$1);\n detachSharedMarkers(findSharedMarkers(this$1));\n break\n } }\n // If the histories were shared, split them again\n if (other.history == this.history) {\n var splitIds = [other.id];\n linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true);\n other.history = new History(null);\n other.history.done = copyHistoryArray(this.history.done, splitIds);\n other.history.undone = copyHistoryArray(this.history.undone, splitIds);\n }\n },\n iterLinkedDocs: function(f) {linkedDocs(this, f);},\n\n getMode: function() {return this.mode},\n getEditor: function() {return this.cm},\n\n splitLines: function(str) {\n if (this.lineSep) { return str.split(this.lineSep) }\n return splitLinesAuto(str)\n },\n lineSeparator: function() { return this.lineSep || \"\\n\" },\n\n setDirection: docMethodOp(function (dir) {\n if (dir != \"rtl\") { dir = \"ltr\"; }\n if (dir == this.direction) { return }\n this.direction = dir;\n this.iter(function (line) { return line.order = null; });\n if (this.cm) { directionChanged(this.cm); }\n })\n });\n\n // Public alias.\n Doc.prototype.eachLine = Doc.prototype.iter;\n\n // Kludge to work around strange IE behavior where it'll sometimes\n // re-fire a series of drag-related events right after the drop (#1551)\n var lastDrop = 0;\n\n function onDrop(e) {\n var cm = this;\n clearDragCursor(cm);\n if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))\n { return }\n e_preventDefault(e);\n if (ie) { lastDrop = +new Date; }\n var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files;\n if (!pos || cm.isReadOnly()) { return }\n // Might be a file drop, in which case we simply extract the text\n // and insert it.\n if (files && files.length && window.FileReader && window.File) {\n var n = files.length, text = Array(n), read = 0;\n var loadFile = function (file, i) {\n if (cm.options.allowDropFileTypes &&\n indexOf(cm.options.allowDropFileTypes, file.type) == -1)\n { return }\n\n var reader = new FileReader;\n reader.onload = operation(cm, function () {\n var content = reader.result;\n if (/[\\x00-\\x08\\x0e-\\x1f]{2}/.test(content)) { content = \"\"; }\n text[i] = content;\n if (++read == n) {\n pos = clipPos(cm.doc, pos);\n var change = {from: pos, to: pos,\n text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),\n origin: \"paste\"};\n makeChange(cm.doc, change);\n setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)));\n }\n });\n reader.readAsText(file);\n };\n for (var i = 0; i < n; ++i) { loadFile(files[i], i); }\n } else { // Normal drop\n // Don't do a replace if the drop happened inside of the selected text.\n if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {\n cm.state.draggingText(e);\n // Ensure the editor is re-focused\n setTimeout(function () { return cm.display.input.focus(); }, 20);\n return\n }\n try {\n var text$1 = e.dataTransfer.getData(\"Text\");\n if (text$1) {\n var selected;\n if (cm.state.draggingText && !cm.state.draggingText.copy)\n { selected = cm.listSelections(); }\n setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));\n if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)\n { replaceRange(cm.doc, \"\", selected[i$1].anchor, selected[i$1].head, \"drag\"); } }\n cm.replaceSelection(text$1, \"around\", \"paste\");\n cm.display.input.focus();\n }\n }\n catch(e){}\n }\n }\n\n function onDragStart(cm, e) {\n if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }\n if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }\n\n e.dataTransfer.setData(\"Text\", cm.getSelection());\n e.dataTransfer.effectAllowed = \"copyMove\";\n\n // Use dummy image instead of default browsers image.\n // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.\n if (e.dataTransfer.setDragImage && !safari) {\n var img = elt(\"img\", null, null, \"position: fixed; left: 0; top: 0;\");\n img.src = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n if (presto) {\n img.width = img.height = 1;\n cm.display.wrapper.appendChild(img);\n // Force a relayout, or Opera won't use our image for some obscure reason\n img._top = img.offsetTop;\n }\n e.dataTransfer.setDragImage(img, 0, 0);\n if (presto) { img.parentNode.removeChild(img); }\n }\n }\n\n function onDragOver(cm, e) {\n var pos = posFromMouse(cm, e);\n if (!pos) { return }\n var frag = document.createDocumentFragment();\n drawSelectionCursor(cm, pos, frag);\n if (!cm.display.dragCursor) {\n cm.display.dragCursor = elt(\"div\", null, \"CodeMirror-cursors CodeMirror-dragcursors\");\n cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv);\n }\n removeChildrenAndAdd(cm.display.dragCursor, frag);\n }\n\n function clearDragCursor(cm) {\n if (cm.display.dragCursor) {\n cm.display.lineSpace.removeChild(cm.display.dragCursor);\n cm.display.dragCursor = null;\n }\n }\n\n // These must be handled carefully, because naively registering a\n // handler for each editor will cause the editors to never be\n // garbage collected.\n\n function forEachCodeMirror(f) {\n if (!document.getElementsByClassName) { return }\n var byClass = document.getElementsByClassName(\"CodeMirror\"), editors = [];\n for (var i = 0; i < byClass.length; i++) {\n var cm = byClass[i].CodeMirror;\n if (cm) { editors.push(cm); }\n }\n if (editors.length) { editors[0].operation(function () {\n for (var i = 0; i < editors.length; i++) { f(editors[i]); }\n }); }\n }\n\n var globalsRegistered = false;\n function ensureGlobalHandlers() {\n if (globalsRegistered) { return }\n registerGlobalHandlers();\n globalsRegistered = true;\n }\n function registerGlobalHandlers() {\n // When the window resizes, we need to refresh active editors.\n var resizeTimer;\n on(window, \"resize\", function () {\n if (resizeTimer == null) { resizeTimer = setTimeout(function () {\n resizeTimer = null;\n forEachCodeMirror(onResize);\n }, 100); }\n });\n // When the window loses focus, we want to show the editor as blurred\n on(window, \"blur\", function () { return forEachCodeMirror(onBlur); });\n }\n // Called when the window resizes\n function onResize(cm) {\n var d = cm.display;\n // Might be a text scaling operation, clear size caches.\n d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;\n d.scrollbarsClipped = false;\n cm.setSize();\n }\n\n var keyNames = {\n 3: \"Pause\", 8: \"Backspace\", 9: \"Tab\", 13: \"Enter\", 16: \"Shift\", 17: \"Ctrl\", 18: \"Alt\",\n 19: \"Pause\", 20: \"CapsLock\", 27: \"Esc\", 32: \"Space\", 33: \"PageUp\", 34: \"PageDown\", 35: \"End\",\n 36: \"Home\", 37: \"Left\", 38: \"Up\", 39: \"Right\", 40: \"Down\", 44: \"PrintScrn\", 45: \"Insert\",\n 46: \"Delete\", 59: \";\", 61: \"=\", 91: \"Mod\", 92: \"Mod\", 93: \"Mod\",\n 106: \"*\", 107: \"=\", 109: \"-\", 110: \".\", 111: \"/\", 127: \"Delete\", 145: \"ScrollLock\",\n 173: \"-\", 186: \";\", 187: \"=\", 188: \",\", 189: \"-\", 190: \".\", 191: \"/\", 192: \"`\", 219: \"[\", 220: \"\\\\\",\n 221: \"]\", 222: \"'\", 63232: \"Up\", 63233: \"Down\", 63234: \"Left\", 63235: \"Right\", 63272: \"Delete\",\n 63273: \"Home\", 63275: \"End\", 63276: \"PageUp\", 63277: \"PageDown\", 63302: \"Insert\"\n };\n\n // Number keys\n for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i); }\n // Alphabetic keys\n for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1); }\n // Function keys\n for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = \"F\" + i$2; }\n\n var keyMap = {};\n\n keyMap.basic = {\n \"Left\": \"goCharLeft\", \"Right\": \"goCharRight\", \"Up\": \"goLineUp\", \"Down\": \"goLineDown\",\n \"End\": \"goLineEnd\", \"Home\": \"goLineStartSmart\", \"PageUp\": \"goPageUp\", \"PageDown\": \"goPageDown\",\n \"Delete\": \"delCharAfter\", \"Backspace\": \"delCharBefore\", \"Shift-Backspace\": \"delCharBefore\",\n \"Tab\": \"defaultTab\", \"Shift-Tab\": \"indentAuto\",\n \"Enter\": \"newlineAndIndent\", \"Insert\": \"toggleOverwrite\",\n \"Esc\": \"singleSelection\"\n };\n // Note that the save and find-related commands aren't defined by\n // default. User code or addons can define them. Unknown commands\n // are simply ignored.\n keyMap.pcDefault = {\n \"Ctrl-A\": \"selectAll\", \"Ctrl-D\": \"deleteLine\", \"Ctrl-Z\": \"undo\", \"Shift-Ctrl-Z\": \"redo\", \"Ctrl-Y\": \"redo\",\n \"Ctrl-Home\": \"goDocStart\", \"Ctrl-End\": \"goDocEnd\", \"Ctrl-Up\": \"goLineUp\", \"Ctrl-Down\": \"goLineDown\",\n \"Ctrl-Left\": \"goGroupLeft\", \"Ctrl-Right\": \"goGroupRight\", \"Alt-Left\": \"goLineStart\", \"Alt-Right\": \"goLineEnd\",\n \"Ctrl-Backspace\": \"delGroupBefore\", \"Ctrl-Delete\": \"delGroupAfter\", \"Ctrl-S\": \"save\", \"Ctrl-F\": \"find\",\n \"Ctrl-G\": \"findNext\", \"Shift-Ctrl-G\": \"findPrev\", \"Shift-Ctrl-F\": \"replace\", \"Shift-Ctrl-R\": \"replaceAll\",\n \"Ctrl-[\": \"indentLess\", \"Ctrl-]\": \"indentMore\",\n \"Ctrl-U\": \"undoSelection\", \"Shift-Ctrl-U\": \"redoSelection\", \"Alt-U\": \"redoSelection\",\n \"fallthrough\": \"basic\"\n };\n // Very basic readline/emacs-style bindings, which are standard on Mac.\n keyMap.emacsy = {\n \"Ctrl-F\": \"goCharRight\", \"Ctrl-B\": \"goCharLeft\", \"Ctrl-P\": \"goLineUp\", \"Ctrl-N\": \"goLineDown\",\n \"Alt-F\": \"goWordRight\", \"Alt-B\": \"goWordLeft\", \"Ctrl-A\": \"goLineStart\", \"Ctrl-E\": \"goLineEnd\",\n \"Ctrl-V\": \"goPageDown\", \"Shift-Ctrl-V\": \"goPageUp\", \"Ctrl-D\": \"delCharAfter\", \"Ctrl-H\": \"delCharBefore\",\n \"Alt-D\": \"delWordAfter\", \"Alt-Backspace\": \"delWordBefore\", \"Ctrl-K\": \"killLine\", \"Ctrl-T\": \"transposeChars\",\n \"Ctrl-O\": \"openLine\"\n };\n keyMap.macDefault = {\n \"Cmd-A\": \"selectAll\", \"Cmd-D\": \"deleteLine\", \"Cmd-Z\": \"undo\", \"Shift-Cmd-Z\": \"redo\", \"Cmd-Y\": \"redo\",\n \"Cmd-Home\": \"goDocStart\", \"Cmd-Up\": \"goDocStart\", \"Cmd-End\": \"goDocEnd\", \"Cmd-Down\": \"goDocEnd\", \"Alt-Left\": \"goGroupLeft\",\n \"Alt-Right\": \"goGroupRight\", \"Cmd-Left\": \"goLineLeft\", \"Cmd-Right\": \"goLineRight\", \"Alt-Backspace\": \"delGroupBefore\",\n \"Ctrl-Alt-Backspace\": \"delGroupAfter\", \"Alt-Delete\": \"delGroupAfter\", \"Cmd-S\": \"save\", \"Cmd-F\": \"find\",\n \"Cmd-G\": \"findNext\", \"Shift-Cmd-G\": \"findPrev\", \"Cmd-Alt-F\": \"replace\", \"Shift-Cmd-Alt-F\": \"replaceAll\",\n \"Cmd-[\": \"indentLess\", \"Cmd-]\": \"indentMore\", \"Cmd-Backspace\": \"delWrappedLineLeft\", \"Cmd-Delete\": \"delWrappedLineRight\",\n \"Cmd-U\": \"undoSelection\", \"Shift-Cmd-U\": \"redoSelection\", \"Ctrl-Up\": \"goDocStart\", \"Ctrl-Down\": \"goDocEnd\",\n \"fallthrough\": [\"basic\", \"emacsy\"]\n };\n keyMap[\"default\"] = mac ? keyMap.macDefault : keyMap.pcDefault;\n\n // KEYMAP DISPATCH\n\n function normalizeKeyName(name) {\n var parts = name.split(/-(?!$)/);\n name = parts[parts.length - 1];\n var alt, ctrl, shift, cmd;\n for (var i = 0; i < parts.length - 1; i++) {\n var mod = parts[i];\n if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true; }\n else if (/^a(lt)?$/i.test(mod)) { alt = true; }\n else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true; }\n else if (/^s(hift)?$/i.test(mod)) { shift = true; }\n else { throw new Error(\"Unrecognized modifier name: \" + mod) }\n }\n if (alt) { name = \"Alt-\" + name; }\n if (ctrl) { name = \"Ctrl-\" + name; }\n if (cmd) { name = \"Cmd-\" + name; }\n if (shift) { name = \"Shift-\" + name; }\n return name\n }\n\n // This is a kludge to keep keymaps mostly working as raw objects\n // (backwards compatibility) while at the same time support features\n // like normalization and multi-stroke key bindings. It compiles a\n // new normalized keymap, and then updates the old object to reflect\n // this.\n function normalizeKeyMap(keymap) {\n var copy = {};\n for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {\n var value = keymap[keyname];\n if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }\n if (value == \"...\") { delete keymap[keyname]; continue }\n\n var keys = map(keyname.split(\" \"), normalizeKeyName);\n for (var i = 0; i < keys.length; i++) {\n var val = (void 0), name = (void 0);\n if (i == keys.length - 1) {\n name = keys.join(\" \");\n val = value;\n } else {\n name = keys.slice(0, i + 1).join(\" \");\n val = \"...\";\n }\n var prev = copy[name];\n if (!prev) { copy[name] = val; }\n else if (prev != val) { throw new Error(\"Inconsistent bindings for \" + name) }\n }\n delete keymap[keyname];\n } }\n for (var prop in copy) { keymap[prop] = copy[prop]; }\n return keymap\n }\n\n function lookupKey(key, map$$1, handle, context) {\n map$$1 = getKeyMap(map$$1);\n var found = map$$1.call ? map$$1.call(key, context) : map$$1[key];\n if (found === false) { return \"nothing\" }\n if (found === \"...\") { return \"multi\" }\n if (found != null && handle(found)) { return \"handled\" }\n\n if (map$$1.fallthrough) {\n if (Object.prototype.toString.call(map$$1.fallthrough) != \"[object Array]\")\n { return lookupKey(key, map$$1.fallthrough, handle, context) }\n for (var i = 0; i < map$$1.fallthrough.length; i++) {\n var result = lookupKey(key, map$$1.fallthrough[i], handle, context);\n if (result) { return result }\n }\n }\n }\n\n // Modifier key presses don't count as 'real' key presses for the\n // purpose of keymap fallthrough.\n function isModifierKey(value) {\n var name = typeof value == \"string\" ? value : keyNames[value.keyCode];\n return name == \"Ctrl\" || name == \"Alt\" || name == \"Shift\" || name == \"Mod\"\n }\n\n function addModifierNames(name, event, noShift) {\n var base = name;\n if (event.altKey && base != \"Alt\") { name = \"Alt-\" + name; }\n if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != \"Ctrl\") { name = \"Ctrl-\" + name; }\n if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != \"Cmd\") { name = \"Cmd-\" + name; }\n if (!noShift && event.shiftKey && base != \"Shift\") { name = \"Shift-\" + name; }\n return name\n }\n\n // Look up the name of a key as indicated by an event object.\n function keyName(event, noShift) {\n if (presto && event.keyCode == 34 && event[\"char\"]) { return false }\n var name = keyNames[event.keyCode];\n if (name == null || event.altGraphKey) { return false }\n // Ctrl-ScrollLock has keyCode 3, same as Ctrl-Pause,\n // so we'll use event.code when available (Chrome 48+, FF 38+, Safari 10.1+)\n if (event.keyCode == 3 && event.code) { name = event.code; }\n return addModifierNames(name, event, noShift)\n }\n\n function getKeyMap(val) {\n return typeof val == \"string\" ? keyMap[val] : val\n }\n\n // Helper for deleting text near the selection(s), used to implement\n // backspace, delete, and similar functionality.\n function deleteNearSelection(cm, compute) {\n var ranges = cm.doc.sel.ranges, kill = [];\n // Build up a set of ranges to kill first, merging overlapping\n // ranges.\n for (var i = 0; i < ranges.length; i++) {\n var toKill = compute(ranges[i]);\n while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {\n var replaced = kill.pop();\n if (cmp(replaced.from, toKill.from) < 0) {\n toKill.from = replaced.from;\n break\n }\n }\n kill.push(toKill);\n }\n // Next, remove those actual ranges.\n runInOp(cm, function () {\n for (var i = kill.length - 1; i >= 0; i--)\n { replaceRange(cm.doc, \"\", kill[i].from, kill[i].to, \"+delete\"); }\n ensureCursorVisible(cm);\n });\n }\n\n function moveCharLogically(line, ch, dir) {\n var target = skipExtendingChars(line.text, ch + dir, dir);\n return target < 0 || target > line.text.length ? null : target\n }\n\n function moveLogically(line, start, dir) {\n var ch = moveCharLogically(line, start.ch, dir);\n return ch == null ? null : new Pos(start.line, ch, dir < 0 ? \"after\" : \"before\")\n }\n\n function endOfLine(visually, cm, lineObj, lineNo, dir) {\n if (visually) {\n var order = getOrder(lineObj, cm.doc.direction);\n if (order) {\n var part = dir < 0 ? lst(order) : order[0];\n var moveInStorageOrder = (dir < 0) == (part.level == 1);\n var sticky = moveInStorageOrder ? \"after\" : \"before\";\n var ch;\n // With a wrapped rtl chunk (possibly spanning multiple bidi parts),\n // it could be that the last bidi part is not on the last visual line,\n // since visual lines contain content order-consecutive chunks.\n // Thus, in rtl, we are looking for the first (content-order) character\n // in the rtl chunk that is on the last line (that is, the same line\n // as the last (content-order) character).\n if (part.level > 0 || cm.doc.direction == \"rtl\") {\n var prep = prepareMeasureForLine(cm, lineObj);\n ch = dir < 0 ? lineObj.text.length - 1 : 0;\n var targetTop = measureCharPrepared(cm, prep, ch).top;\n ch = findFirst(function (ch) { return measureCharPrepared(cm, prep, ch).top == targetTop; }, (dir < 0) == (part.level == 1) ? part.from : part.to - 1, ch);\n if (sticky == \"before\") { ch = moveCharLogically(lineObj, ch, 1); }\n } else { ch = dir < 0 ? part.to : part.from; }\n return new Pos(lineNo, ch, sticky)\n }\n }\n return new Pos(lineNo, dir < 0 ? lineObj.text.length : 0, dir < 0 ? \"before\" : \"after\")\n }\n\n function moveVisually(cm, line, start, dir) {\n var bidi = getOrder(line, cm.doc.direction);\n if (!bidi) { return moveLogically(line, start, dir) }\n if (start.ch >= line.text.length) {\n start.ch = line.text.length;\n start.sticky = \"before\";\n } else if (start.ch <= 0) {\n start.ch = 0;\n start.sticky = \"after\";\n }\n var partPos = getBidiPartAt(bidi, start.ch, start.sticky), part = bidi[partPos];\n if (cm.doc.direction == \"ltr\" && part.level % 2 == 0 && (dir > 0 ? part.to > start.ch : part.from < start.ch)) {\n // Case 1: We move within an ltr part in an ltr editor. Even with wrapped lines,\n // nothing interesting happens.\n return moveLogically(line, start, dir)\n }\n\n var mv = function (pos, dir) { return moveCharLogically(line, pos instanceof Pos ? pos.ch : pos, dir); };\n var prep;\n var getWrappedLineExtent = function (ch) {\n if (!cm.options.lineWrapping) { return {begin: 0, end: line.text.length} }\n prep = prep || prepareMeasureForLine(cm, line);\n return wrappedLineExtentChar(cm, line, prep, ch)\n };\n var wrappedLineExtent = getWrappedLineExtent(start.sticky == \"before\" ? mv(start, -1) : start.ch);\n\n if (cm.doc.direction == \"rtl\" || part.level == 1) {\n var moveInStorageOrder = (part.level == 1) == (dir < 0);\n var ch = mv(start, moveInStorageOrder ? 1 : -1);\n if (ch != null && (!moveInStorageOrder ? ch >= part.from && ch >= wrappedLineExtent.begin : ch <= part.to && ch <= wrappedLineExtent.end)) {\n // Case 2: We move within an rtl part or in an rtl editor on the same visual line\n var sticky = moveInStorageOrder ? \"before\" : \"after\";\n return new Pos(start.line, ch, sticky)\n }\n }\n\n // Case 3: Could not move within this bidi part in this visual line, so leave\n // the current bidi part\n\n var searchInVisualLine = function (partPos, dir, wrappedLineExtent) {\n var getRes = function (ch, moveInStorageOrder) { return moveInStorageOrder\n ? new Pos(start.line, mv(ch, 1), \"before\")\n : new Pos(start.line, ch, \"after\"); };\n\n for (; partPos >= 0 && partPos < bidi.length; partPos += dir) {\n var part = bidi[partPos];\n var moveInStorageOrder = (dir > 0) == (part.level != 1);\n var ch = moveInStorageOrder ? wrappedLineExtent.begin : mv(wrappedLineExtent.end, -1);\n if (part.from <= ch && ch < part.to) { return getRes(ch, moveInStorageOrder) }\n ch = moveInStorageOrder ? part.from : mv(part.to, -1);\n if (wrappedLineExtent.begin <= ch && ch < wrappedLineExtent.end) { return getRes(ch, moveInStorageOrder) }\n }\n };\n\n // Case 3a: Look for other bidi parts on the same visual line\n var res = searchInVisualLine(partPos + dir, dir, wrappedLineExtent);\n if (res) { return res }\n\n // Case 3b: Look for other bidi parts on the next visual line\n var nextCh = dir > 0 ? wrappedLineExtent.end : mv(wrappedLineExtent.begin, -1);\n if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {\n res = searchInVisualLine(dir > 0 ? 0 : bidi.length - 1, dir, getWrappedLineExtent(nextCh));\n if (res) { return res }\n }\n\n // Case 4: Nowhere to move\n return null\n }\n\n // Commands are parameter-less actions that can be performed on an\n // editor, mostly used for keybindings.\n var commands = {\n selectAll: selectAll,\n singleSelection: function (cm) { return cm.setSelection(cm.getCursor(\"anchor\"), cm.getCursor(\"head\"), sel_dontScroll); },\n killLine: function (cm) { return deleteNearSelection(cm, function (range) {\n if (range.empty()) {\n var len = getLine(cm.doc, range.head.line).text.length;\n if (range.head.ch == len && range.head.line < cm.lastLine())\n { return {from: range.head, to: Pos(range.head.line + 1, 0)} }\n else\n { return {from: range.head, to: Pos(range.head.line, len)} }\n } else {\n return {from: range.from(), to: range.to()}\n }\n }); },\n deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n from: Pos(range.from().line, 0),\n to: clipPos(cm.doc, Pos(range.to().line + 1, 0))\n }); }); },\n delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({\n from: Pos(range.from().line, 0), to: range.from()\n }); }); },\n delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {\n var top = cm.charCoords(range.head, \"div\").top + 5;\n var leftPos = cm.coordsChar({left: 0, top: top}, \"div\");\n return {from: leftPos, to: range.from()}\n }); },\n delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {\n var top = cm.charCoords(range.head, \"div\").top + 5;\n var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\");\n return {from: range.from(), to: rightPos }\n }); },\n undo: function (cm) { return cm.undo(); },\n redo: function (cm) { return cm.redo(); },\n undoSelection: function (cm) { return cm.undoSelection(); },\n redoSelection: function (cm) { return cm.redoSelection(); },\n goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },\n goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },\n goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },\n {origin: \"+move\", bias: 1}\n ); },\n goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },\n {origin: \"+move\", bias: 1}\n ); },\n goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },\n {origin: \"+move\", bias: -1}\n ); },\n goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {\n var top = cm.cursorCoords(range.head, \"div\").top + 5;\n return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, \"div\")\n }, sel_move); },\n goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {\n var top = cm.cursorCoords(range.head, \"div\").top + 5;\n return cm.coordsChar({left: 0, top: top}, \"div\")\n }, sel_move); },\n goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {\n var top = cm.cursorCoords(range.head, \"div\").top + 5;\n var pos = cm.coordsChar({left: 0, top: top}, \"div\");\n if (pos.ch < cm.getLine(pos.line).search(/\\S/)) { return lineStartSmart(cm, range.head) }\n return pos\n }, sel_move); },\n goLineUp: function (cm) { return cm.moveV(-1, \"line\"); },\n goLineDown: function (cm) { return cm.moveV(1, \"line\"); },\n goPageUp: function (cm) { return cm.moveV(-1, \"page\"); },\n goPageDown: function (cm) { return cm.moveV(1, \"page\"); },\n goCharLeft: function (cm) { return cm.moveH(-1, \"char\"); },\n goCharRight: function (cm) { return cm.moveH(1, \"char\"); },\n goColumnLeft: function (cm) { return cm.moveH(-1, \"column\"); },\n goColumnRight: function (cm) { return cm.moveH(1, \"column\"); },\n goWordLeft: function (cm) { return cm.moveH(-1, \"word\"); },\n goGroupRight: function (cm) { return cm.moveH(1, \"group\"); },\n goGroupLeft: function (cm) { return cm.moveH(-1, \"group\"); },\n goWordRight: function (cm) { return cm.moveH(1, \"word\"); },\n delCharBefore: function (cm) { return cm.deleteH(-1, \"char\"); },\n delCharAfter: function (cm) { return cm.deleteH(1, \"char\"); },\n delWordBefore: function (cm) { return cm.deleteH(-1, \"word\"); },\n delWordAfter: function (cm) { return cm.deleteH(1, \"word\"); },\n delGroupBefore: function (cm) { return cm.deleteH(-1, \"group\"); },\n delGroupAfter: function (cm) { return cm.deleteH(1, \"group\"); },\n indentAuto: function (cm) { return cm.indentSelection(\"smart\"); },\n indentMore: function (cm) { return cm.indentSelection(\"add\"); },\n indentLess: function (cm) { return cm.indentSelection(\"subtract\"); },\n insertTab: function (cm) { return cm.replaceSelection(\"\\t\"); },\n insertSoftTab: function (cm) {\n var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize;\n for (var i = 0; i < ranges.length; i++) {\n var pos = ranges[i].from();\n var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);\n spaces.push(spaceStr(tabSize - col % tabSize));\n }\n cm.replaceSelections(spaces);\n },\n defaultTab: function (cm) {\n if (cm.somethingSelected()) { cm.indentSelection(\"add\"); }\n else { cm.execCommand(\"insertTab\"); }\n },\n // Swap the two chars left and right of each selection's head.\n // Move cursor behind the two swapped characters afterwards.\n //\n // Doesn't consider line feeds a character.\n // Doesn't scan more than one line above to find a character.\n // Doesn't do anything on an empty line.\n // Doesn't do anything with non-empty selections.\n transposeChars: function (cm) { return runInOp(cm, function () {\n var ranges = cm.listSelections(), newSel = [];\n for (var i = 0; i < ranges.length; i++) {\n if (!ranges[i].empty()) { continue }\n var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text;\n if (line) {\n if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1); }\n if (cur.ch > 0) {\n cur = new Pos(cur.line, cur.ch + 1);\n cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),\n Pos(cur.line, cur.ch - 2), cur, \"+transpose\");\n } else if (cur.line > cm.doc.first) {\n var prev = getLine(cm.doc, cur.line - 1).text;\n if (prev) {\n cur = new Pos(cur.line, 1);\n cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +\n prev.charAt(prev.length - 1),\n Pos(cur.line - 1, prev.length - 1), cur, \"+transpose\");\n }\n }\n }\n newSel.push(new Range(cur, cur));\n }\n cm.setSelections(newSel);\n }); },\n newlineAndIndent: function (cm) { return runInOp(cm, function () {\n var sels = cm.listSelections();\n for (var i = sels.length - 1; i >= 0; i--)\n { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, \"+input\"); }\n sels = cm.listSelections();\n for (var i$1 = 0; i$1 < sels.length; i$1++)\n { cm.indentLine(sels[i$1].from().line, null, true); }\n ensureCursorVisible(cm);\n }); },\n openLine: function (cm) { return cm.replaceSelection(\"\\n\", \"start\"); },\n toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }\n };\n\n\n function lineStart(cm, lineN) {\n var line = getLine(cm.doc, lineN);\n var visual = visualLine(line);\n if (visual != line) { lineN = lineNo(visual); }\n return endOfLine(true, cm, visual, lineN, 1)\n }\n function lineEnd(cm, lineN) {\n var line = getLine(cm.doc, lineN);\n var visual = visualLineEnd(line);\n if (visual != line) { lineN = lineNo(visual); }\n return endOfLine(true, cm, line, lineN, -1)\n }\n function lineStartSmart(cm, pos) {\n var start = lineStart(cm, pos.line);\n var line = getLine(cm.doc, start.line);\n var order = getOrder(line, cm.doc.direction);\n if (!order || order[0].level == 0) {\n var firstNonWS = Math.max(0, line.text.search(/\\S/));\n var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch;\n return Pos(start.line, inWS ? 0 : firstNonWS, start.sticky)\n }\n return start\n }\n\n // Run a handler that was bound to a key.\n function doHandleBinding(cm, bound, dropShift) {\n if (typeof bound == \"string\") {\n bound = commands[bound];\n if (!bound) { return false }\n }\n // Ensure previous input has been read, so that the handler sees a\n // consistent view of the document\n cm.display.input.ensurePolled();\n var prevShift = cm.display.shift, done = false;\n try {\n if (cm.isReadOnly()) { cm.state.suppressEdits = true; }\n if (dropShift) { cm.display.shift = false; }\n done = bound(cm) != Pass;\n } finally {\n cm.display.shift = prevShift;\n cm.state.suppressEdits = false;\n }\n return done\n }\n\n function lookupKeyForEditor(cm, name, handle) {\n for (var i = 0; i < cm.state.keyMaps.length; i++) {\n var result = lookupKey(name, cm.state.keyMaps[i], handle, cm);\n if (result) { return result }\n }\n return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))\n || lookupKey(name, cm.options.keyMap, handle, cm)\n }\n\n // Note that, despite the name, this function is also used to check\n // for bound mouse clicks.\n\n var stopSeq = new Delayed;\n\n function dispatchKey(cm, name, e, handle) {\n var seq = cm.state.keySeq;\n if (seq) {\n if (isModifierKey(name)) { return \"handled\" }\n if (/\\'$/.test(name))\n { cm.state.keySeq = null; }\n else\n { stopSeq.set(50, function () {\n if (cm.state.keySeq == seq) {\n cm.state.keySeq = null;\n cm.display.input.reset();\n }\n }); }\n if (dispatchKeyInner(cm, seq + \" \" + name, e, handle)) { return true }\n }\n return dispatchKeyInner(cm, name, e, handle)\n }\n\n function dispatchKeyInner(cm, name, e, handle) {\n var result = lookupKeyForEditor(cm, name, handle);\n\n if (result == \"multi\")\n { cm.state.keySeq = name; }\n if (result == \"handled\")\n { signalLater(cm, \"keyHandled\", cm, name, e); }\n\n if (result == \"handled\" || result == \"multi\") {\n e_preventDefault(e);\n restartBlink(cm);\n }\n\n return !!result\n }\n\n // Handle a key from the keydown event.\n function handleKeyBinding(cm, e) {\n var name = keyName(e, true);\n if (!name) { return false }\n\n if (e.shiftKey && !cm.state.keySeq) {\n // First try to resolve full name (including 'Shift-'). Failing\n // that, see if there is a cursor-motion command (starting with\n // 'go') bound to the keyname without 'Shift-'.\n return dispatchKey(cm, \"Shift-\" + name, e, function (b) { return doHandleBinding(cm, b, true); })\n || dispatchKey(cm, name, e, function (b) {\n if (typeof b == \"string\" ? /^go[A-Z]/.test(b) : b.motion)\n { return doHandleBinding(cm, b) }\n })\n } else {\n return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })\n }\n }\n\n // Handle a key from the keypress event\n function handleCharBinding(cm, e, ch) {\n return dispatchKey(cm, \"'\" + ch + \"'\", e, function (b) { return doHandleBinding(cm, b, true); })\n }\n\n var lastStoppedKey = null;\n function onKeyDown(e) {\n var cm = this;\n cm.curOp.focus = activeElt();\n if (signalDOMEvent(cm, e)) { return }\n // IE does strange things with escape.\n if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false; }\n var code = e.keyCode;\n cm.display.shift = code == 16 || e.shiftKey;\n var handled = handleKeyBinding(cm, e);\n if (presto) {\n lastStoppedKey = handled ? code : null;\n // Opera has no cut event... we try to at least catch the key combo\n if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))\n { cm.replaceSelection(\"\", null, \"cut\"); }\n }\n\n // Turn mouse into crosshair when Alt is held on Mac.\n if (code == 18 && !/\\bCodeMirror-crosshair\\b/.test(cm.display.lineDiv.className))\n { showCrossHair(cm); }\n }\n\n function showCrossHair(cm) {\n var lineDiv = cm.display.lineDiv;\n addClass(lineDiv, \"CodeMirror-crosshair\");\n\n function up(e) {\n if (e.keyCode == 18 || !e.altKey) {\n rmClass(lineDiv, \"CodeMirror-crosshair\");\n off(document, \"keyup\", up);\n off(document, \"mouseover\", up);\n }\n }\n on(document, \"keyup\", up);\n on(document, \"mouseover\", up);\n }\n\n function onKeyUp(e) {\n if (e.keyCode == 16) { this.doc.sel.shift = false; }\n signalDOMEvent(this, e);\n }\n\n function onKeyPress(e) {\n var cm = this;\n if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }\n var keyCode = e.keyCode, charCode = e.charCode;\n if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}\n if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }\n var ch = String.fromCharCode(charCode == null ? keyCode : charCode);\n // Some browsers fire keypress events for backspace\n if (ch == \"\\x08\") { return }\n if (handleCharBinding(cm, e, ch)) { return }\n cm.display.input.onKeyPress(e);\n }\n\n var DOUBLECLICK_DELAY = 400;\n\n var PastClick = function(time, pos, button) {\n this.time = time;\n this.pos = pos;\n this.button = button;\n };\n\n PastClick.prototype.compare = function (time, pos, button) {\n return this.time + DOUBLECLICK_DELAY > time &&\n cmp(pos, this.pos) == 0 && button == this.button\n };\n\n var lastClick, lastDoubleClick;\n function clickRepeat(pos, button) {\n var now = +new Date;\n if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {\n lastClick = lastDoubleClick = null;\n return \"triple\"\n } else if (lastClick && lastClick.compare(now, pos, button)) {\n lastDoubleClick = new PastClick(now, pos, button);\n lastClick = null;\n return \"double\"\n } else {\n lastClick = new PastClick(now, pos, button);\n lastDoubleClick = null;\n return \"single\"\n }\n }\n\n // A mouse down can be a single click, double click, triple click,\n // start of selection drag, start of text drag, new cursor\n // (ctrl-click), rectangle drag (alt-drag), or xwin\n // middle-click-paste. Or it might be a click on something we should\n // not interfere with, such as a scrollbar or widget.\n function onMouseDown(e) {\n var cm = this, display = cm.display;\n if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }\n display.input.ensurePolled();\n display.shift = e.shiftKey;\n\n if (eventInWidget(display, e)) {\n if (!webkit) {\n // Briefly turn off draggability, to allow widgets to do\n // normal dragging things.\n display.scroller.draggable = false;\n setTimeout(function () { return display.scroller.draggable = true; }, 100);\n }\n return\n }\n if (clickInGutter(cm, e)) { return }\n var pos = posFromMouse(cm, e), button = e_button(e), repeat = pos ? clickRepeat(pos, button) : \"single\";\n window.focus();\n\n // #3261: make sure, that we're not starting a second selection\n if (button == 1 && cm.state.selectingText)\n { cm.state.selectingText(e); }\n\n if (pos && handleMappedButton(cm, button, pos, repeat, e)) { return }\n\n if (button == 1) {\n if (pos) { leftButtonDown(cm, pos, repeat, e); }\n else if (e_target(e) == display.scroller) { e_preventDefault(e); }\n } else if (button == 2) {\n if (pos) { extendSelection(cm.doc, pos); }\n setTimeout(function () { return display.input.focus(); }, 20);\n } else if (button == 3) {\n if (captureRightClick) { cm.display.input.onContextMenu(e); }\n else { delayBlurEvent(cm); }\n }\n }\n\n function handleMappedButton(cm, button, pos, repeat, event) {\n var name = \"Click\";\n if (repeat == \"double\") { name = \"Double\" + name; }\n else if (repeat == \"triple\") { name = \"Triple\" + name; }\n name = (button == 1 ? \"Left\" : button == 2 ? \"Middle\" : \"Right\") + name;\n\n return dispatchKey(cm, addModifierNames(name, event), event, function (bound) {\n if (typeof bound == \"string\") { bound = commands[bound]; }\n if (!bound) { return false }\n var done = false;\n try {\n if (cm.isReadOnly()) { cm.state.suppressEdits = true; }\n done = bound(cm, pos) != Pass;\n } finally {\n cm.state.suppressEdits = false;\n }\n return done\n })\n }\n\n function configureMouse(cm, repeat, event) {\n var option = cm.getOption(\"configureMouse\");\n var value = option ? option(cm, repeat, event) : {};\n if (value.unit == null) {\n var rect = chromeOS ? event.shiftKey && event.metaKey : event.altKey;\n value.unit = rect ? \"rectangle\" : repeat == \"single\" ? \"char\" : repeat == \"double\" ? \"word\" : \"line\";\n }\n if (value.extend == null || cm.doc.extend) { value.extend = cm.doc.extend || event.shiftKey; }\n if (value.addNew == null) { value.addNew = mac ? event.metaKey : event.ctrlKey; }\n if (value.moveOnDrag == null) { value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey); }\n return value\n }\n\n function leftButtonDown(cm, pos, repeat, event) {\n if (ie) { setTimeout(bind(ensureFocus, cm), 0); }\n else { cm.curOp.focus = activeElt(); }\n\n var behavior = configureMouse(cm, repeat, event);\n\n var sel = cm.doc.sel, contained;\n if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&\n repeat == \"single\" && (contained = sel.contains(pos)) > -1 &&\n (cmp((contained = sel.ranges[contained]).from(), pos) < 0 || pos.xRel > 0) &&\n (cmp(contained.to(), pos) > 0 || pos.xRel < 0))\n { leftButtonStartDrag(cm, event, pos, behavior); }\n else\n { leftButtonSelect(cm, event, pos, behavior); }\n }\n\n // Start a text drag. When it ends, see if any dragging actually\n // happen, and treat as a click if it didn't.\n function leftButtonStartDrag(cm, event, pos, behavior) {\n var display = cm.display, moved = false;\n var dragEnd = operation(cm, function (e) {\n if (webkit) { display.scroller.draggable = false; }\n cm.state.draggingText = false;\n off(display.wrapper.ownerDocument, \"mouseup\", dragEnd);\n off(display.wrapper.ownerDocument, \"mousemove\", mouseMove);\n off(display.scroller, \"dragstart\", dragStart);\n off(display.scroller, \"drop\", dragEnd);\n if (!moved) {\n e_preventDefault(e);\n if (!behavior.addNew)\n { extendSelection(cm.doc, pos, null, null, behavior.extend); }\n // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)\n if (webkit || ie && ie_version == 9)\n { setTimeout(function () {display.wrapper.ownerDocument.body.focus(); display.input.focus();}, 20); }\n else\n { display.input.focus(); }\n }\n });\n var mouseMove = function(e2) {\n moved = moved || Math.abs(event.clientX - e2.clientX) + Math.abs(event.clientY - e2.clientY) >= 10;\n };\n var dragStart = function () { return moved = true; };\n // Let the drag handler handle this.\n if (webkit) { display.scroller.draggable = true; }\n cm.state.draggingText = dragEnd;\n dragEnd.copy = !behavior.moveOnDrag;\n // IE's approach to draggable\n if (display.scroller.dragDrop) { display.scroller.dragDrop(); }\n on(display.wrapper.ownerDocument, \"mouseup\", dragEnd);\n on(display.wrapper.ownerDocument, \"mousemove\", mouseMove);\n on(display.scroller, \"dragstart\", dragStart);\n on(display.scroller, \"drop\", dragEnd);\n\n delayBlurEvent(cm);\n setTimeout(function () { return display.input.focus(); }, 20);\n }\n\n function rangeForUnit(cm, pos, unit) {\n if (unit == \"char\") { return new Range(pos, pos) }\n if (unit == \"word\") { return cm.findWordAt(pos) }\n if (unit == \"line\") { return new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }\n var result = unit(cm, pos);\n return new Range(result.from, result.to)\n }\n\n // Normal selection, as opposed to text dragging.\n function leftButtonSelect(cm, event, start, behavior) {\n var display = cm.display, doc = cm.doc;\n e_preventDefault(event);\n\n var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges;\n if (behavior.addNew && !behavior.extend) {\n ourIndex = doc.sel.contains(start);\n if (ourIndex > -1)\n { ourRange = ranges[ourIndex]; }\n else\n { ourRange = new Range(start, start); }\n } else {\n ourRange = doc.sel.primary();\n ourIndex = doc.sel.primIndex;\n }\n\n if (behavior.unit == \"rectangle\") {\n if (!behavior.addNew) { ourRange = new Range(start, start); }\n start = posFromMouse(cm, event, true, true);\n ourIndex = -1;\n } else {\n var range$$1 = rangeForUnit(cm, start, behavior.unit);\n if (behavior.extend)\n { ourRange = extendRange(ourRange, range$$1.anchor, range$$1.head, behavior.extend); }\n else\n { ourRange = range$$1; }\n }\n\n if (!behavior.addNew) {\n ourIndex = 0;\n setSelection(doc, new Selection([ourRange], 0), sel_mouse);\n startSel = doc.sel;\n } else if (ourIndex == -1) {\n ourIndex = ranges.length;\n setSelection(doc, normalizeSelection(cm, ranges.concat([ourRange]), ourIndex),\n {scroll: false, origin: \"*mouse\"});\n } else if (ranges.length > 1 && ranges[ourIndex].empty() && behavior.unit == \"char\" && !behavior.extend) {\n setSelection(doc, normalizeSelection(cm, ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),\n {scroll: false, origin: \"*mouse\"});\n startSel = doc.sel;\n } else {\n replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);\n }\n\n var lastPos = start;\n function extendTo(pos) {\n if (cmp(lastPos, pos) == 0) { return }\n lastPos = pos;\n\n if (behavior.unit == \"rectangle\") {\n var ranges = [], tabSize = cm.options.tabSize;\n var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize);\n var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize);\n var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol);\n for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));\n line <= end; line++) {\n var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize);\n if (left == right)\n { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))); }\n else if (text.length > leftPos)\n { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))); }\n }\n if (!ranges.length) { ranges.push(new Range(start, start)); }\n setSelection(doc, normalizeSelection(cm, startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),\n {origin: \"*mouse\", scroll: false});\n cm.scrollIntoView(pos);\n } else {\n var oldRange = ourRange;\n var range$$1 = rangeForUnit(cm, pos, behavior.unit);\n var anchor = oldRange.anchor, head;\n if (cmp(range$$1.anchor, anchor) > 0) {\n head = range$$1.head;\n anchor = minPos(oldRange.from(), range$$1.anchor);\n } else {\n head = range$$1.anchor;\n anchor = maxPos(oldRange.to(), range$$1.head);\n }\n var ranges$1 = startSel.ranges.slice(0);\n ranges$1[ourIndex] = bidiSimplify(cm, new Range(clipPos(doc, anchor), head));\n setSelection(doc, normalizeSelection(cm, ranges$1, ourIndex), sel_mouse);\n }\n }\n\n var editorSize = display.wrapper.getBoundingClientRect();\n // Used to ensure timeout re-tries don't fire when another extend\n // happened in the meantime (clearTimeout isn't reliable -- at\n // least on Chrome, the timeouts still happen even when cleared,\n // if the clear happens after their scheduled firing time).\n var counter = 0;\n\n function extend(e) {\n var curCount = ++counter;\n var cur = posFromMouse(cm, e, true, behavior.unit == \"rectangle\");\n if (!cur) { return }\n if (cmp(cur, lastPos) != 0) {\n cm.curOp.focus = activeElt();\n extendTo(cur);\n var visible = visibleLines(display, doc);\n if (cur.line >= visible.to || cur.line < visible.from)\n { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e); }}), 150); }\n } else {\n var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0;\n if (outside) { setTimeout(operation(cm, function () {\n if (counter != curCount) { return }\n display.scroller.scrollTop += outside;\n extend(e);\n }), 50); }\n }\n }\n\n function done(e) {\n cm.state.selectingText = false;\n counter = Infinity;\n e_preventDefault(e);\n display.input.focus();\n off(display.wrapper.ownerDocument, \"mousemove\", move);\n off(display.wrapper.ownerDocument, \"mouseup\", up);\n doc.history.lastSelOrigin = null;\n }\n\n var move = operation(cm, function (e) {\n if (e.buttons === 0 || !e_button(e)) { done(e); }\n else { extend(e); }\n });\n var up = operation(cm, done);\n cm.state.selectingText = up;\n on(display.wrapper.ownerDocument, \"mousemove\", move);\n on(display.wrapper.ownerDocument, \"mouseup\", up);\n }\n\n // Used when mouse-selecting to adjust the anchor to the proper side\n // of a bidi jump depending on the visual position of the head.\n function bidiSimplify(cm, range$$1) {\n var anchor = range$$1.anchor;\n var head = range$$1.head;\n var anchorLine = getLine(cm.doc, anchor.line);\n if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) { return range$$1 }\n var order = getOrder(anchorLine);\n if (!order) { return range$$1 }\n var index = getBidiPartAt(order, anchor.ch, anchor.sticky), part = order[index];\n if (part.from != anchor.ch && part.to != anchor.ch) { return range$$1 }\n var boundary = index + ((part.from == anchor.ch) == (part.level != 1) ? 0 : 1);\n if (boundary == 0 || boundary == order.length) { return range$$1 }\n\n // Compute the relative visual position of the head compared to the\n // anchor (<0 is to the left, >0 to the right)\n var leftSide;\n if (head.line != anchor.line) {\n leftSide = (head.line - anchor.line) * (cm.doc.direction == \"ltr\" ? 1 : -1) > 0;\n } else {\n var headIndex = getBidiPartAt(order, head.ch, head.sticky);\n var dir = headIndex - index || (head.ch - anchor.ch) * (part.level == 1 ? -1 : 1);\n if (headIndex == boundary - 1 || headIndex == boundary)\n { leftSide = dir < 0; }\n else\n { leftSide = dir > 0; }\n }\n\n var usePart = order[boundary + (leftSide ? -1 : 0)];\n var from = leftSide == (usePart.level == 1);\n var ch = from ? usePart.from : usePart.to, sticky = from ? \"after\" : \"before\";\n return anchor.ch == ch && anchor.sticky == sticky ? range$$1 : new Range(new Pos(anchor.line, ch, sticky), head)\n }\n\n\n // Determines whether an event happened in the gutter, and fires the\n // handlers for the corresponding event.\n function gutterEvent(cm, e, type, prevent) {\n var mX, mY;\n if (e.touches) {\n mX = e.touches[0].clientX;\n mY = e.touches[0].clientY;\n } else {\n try { mX = e.clientX; mY = e.clientY; }\n catch(e) { return false }\n }\n if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }\n if (prevent) { e_preventDefault(e); }\n\n var display = cm.display;\n var lineBox = display.lineDiv.getBoundingClientRect();\n\n if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }\n mY -= lineBox.top - display.viewOffset;\n\n for (var i = 0; i < cm.options.gutters.length; ++i) {\n var g = display.gutters.childNodes[i];\n if (g && g.getBoundingClientRect().right >= mX) {\n var line = lineAtHeight(cm.doc, mY);\n var gutter = cm.options.gutters[i];\n signal(cm, type, cm, line, gutter, e);\n return e_defaultPrevented(e)\n }\n }\n }\n\n function clickInGutter(cm, e) {\n return gutterEvent(cm, e, \"gutterClick\", true)\n }\n\n // CONTEXT MENU HANDLING\n\n // To make the context menu work, we need to briefly unhide the\n // textarea (making it as unobtrusive as possible) to let the\n // right-click take effect on it.\n function onContextMenu(cm, e) {\n if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }\n if (signalDOMEvent(cm, e, \"contextmenu\")) { return }\n if (!captureRightClick) { cm.display.input.onContextMenu(e); }\n }\n\n function contextMenuInGutter(cm, e) {\n if (!hasHandler(cm, \"gutterContextMenu\")) { return false }\n return gutterEvent(cm, e, \"gutterContextMenu\", false)\n }\n\n function themeChanged(cm) {\n cm.display.wrapper.className = cm.display.wrapper.className.replace(/\\s*cm-s-\\S+/g, \"\") +\n cm.options.theme.replace(/(^|\\s)\\s*/g, \" cm-s-\");\n clearCaches(cm);\n }\n\n var Init = {toString: function(){return \"CodeMirror.Init\"}};\n\n var defaults = {};\n var optionHandlers = {};\n\n function defineOptions(CodeMirror) {\n var optionHandlers = CodeMirror.optionHandlers;\n\n function option(name, deflt, handle, notOnInit) {\n CodeMirror.defaults[name] = deflt;\n if (handle) { optionHandlers[name] =\n notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old); }} : handle; }\n }\n\n CodeMirror.defineOption = option;\n\n // Passed to option handlers when there is no old value.\n CodeMirror.Init = Init;\n\n // These two are, on init, called from the constructor because they\n // have to be initialized before the editor can start at all.\n option(\"value\", \"\", function (cm, val) { return cm.setValue(val); }, true);\n option(\"mode\", null, function (cm, val) {\n cm.doc.modeOption = val;\n loadMode(cm);\n }, true);\n\n option(\"indentUnit\", 2, loadMode, true);\n option(\"indentWithTabs\", false);\n option(\"smartIndent\", true);\n option(\"tabSize\", 4, function (cm) {\n resetModeState(cm);\n clearCaches(cm);\n regChange(cm);\n }, true);\n\n option(\"lineSeparator\", null, function (cm, val) {\n cm.doc.lineSep = val;\n if (!val) { return }\n var newBreaks = [], lineNo = cm.doc.first;\n cm.doc.iter(function (line) {\n for (var pos = 0;;) {\n var found = line.text.indexOf(val, pos);\n if (found == -1) { break }\n pos = found + val.length;\n newBreaks.push(Pos(lineNo, found));\n }\n lineNo++;\n });\n for (var i = newBreaks.length - 1; i >= 0; i--)\n { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)); }\n });\n option(\"specialChars\", /[\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u061c\\u200b-\\u200f\\u2028\\u2029\\ufeff]/g, function (cm, val, old) {\n cm.state.specialChars = new RegExp(val.source + (val.test(\"\\t\") ? \"\" : \"|\\t\"), \"g\");\n if (old != Init) { cm.refresh(); }\n });\n option(\"specialCharPlaceholder\", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true);\n option(\"electricChars\", true);\n option(\"inputStyle\", mobile ? \"contenteditable\" : \"textarea\", function () {\n throw new Error(\"inputStyle can not (yet) be changed in a running editor\") // FIXME\n }, true);\n option(\"spellcheck\", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true);\n option(\"autocorrect\", false, function (cm, val) { return cm.getInputField().autocorrect = val; }, true);\n option(\"autocapitalize\", false, function (cm, val) { return cm.getInputField().autocapitalize = val; }, true);\n option(\"rtlMoveVisually\", !windows);\n option(\"wholeLineUpdateBefore\", true);\n\n option(\"theme\", \"default\", function (cm) {\n themeChanged(cm);\n guttersChanged(cm);\n }, true);\n option(\"keyMap\", \"default\", function (cm, val, old) {\n var next = getKeyMap(val);\n var prev = old != Init && getKeyMap(old);\n if (prev && prev.detach) { prev.detach(cm, next); }\n if (next.attach) { next.attach(cm, prev || null); }\n });\n option(\"extraKeys\", null);\n option(\"configureMouse\", null);\n\n option(\"lineWrapping\", false, wrappingChanged, true);\n option(\"gutters\", [], function (cm) {\n setGuttersForLineNumbers(cm.options);\n guttersChanged(cm);\n }, true);\n option(\"fixedGutter\", true, function (cm, val) {\n cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + \"px\" : \"0\";\n cm.refresh();\n }, true);\n option(\"coverGutterNextToScrollbar\", false, function (cm) { return updateScrollbars(cm); }, true);\n option(\"scrollbarStyle\", \"native\", function (cm) {\n initScrollbars(cm);\n updateScrollbars(cm);\n cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);\n cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);\n }, true);\n option(\"lineNumbers\", false, function (cm) {\n setGuttersForLineNumbers(cm.options);\n guttersChanged(cm);\n }, true);\n option(\"firstLineNumber\", 1, guttersChanged, true);\n option(\"lineNumberFormatter\", function (integer) { return integer; }, guttersChanged, true);\n option(\"showCursorWhenSelecting\", false, updateSelection, true);\n\n option(\"resetSelectionOnContextMenu\", true);\n option(\"lineWiseCopyCut\", true);\n option(\"pasteLinesPerSelection\", true);\n option(\"selectionsMayTouch\", false);\n\n option(\"readOnly\", false, function (cm, val) {\n if (val == \"nocursor\") {\n onBlur(cm);\n cm.display.input.blur();\n }\n cm.display.input.readOnlyChanged(val);\n });\n option(\"disableInput\", false, function (cm, val) {if (!val) { cm.display.input.reset(); }}, true);\n option(\"dragDrop\", true, dragDropChanged);\n option(\"allowDropFileTypes\", null);\n\n option(\"cursorBlinkRate\", 530);\n option(\"cursorScrollMargin\", 0);\n option(\"cursorHeight\", 1, updateSelection, true);\n option(\"singleCursorHeightPerLine\", true, updateSelection, true);\n option(\"workTime\", 100);\n option(\"workDelay\", 100);\n option(\"flattenSpans\", true, resetModeState, true);\n option(\"addModeClass\", false, resetModeState, true);\n option(\"pollInterval\", 100);\n option(\"undoDepth\", 200, function (cm, val) { return cm.doc.history.undoDepth = val; });\n option(\"historyEventDelay\", 1250);\n option(\"viewportMargin\", 10, function (cm) { return cm.refresh(); }, true);\n option(\"maxHighlightLength\", 10000, resetModeState, true);\n option(\"moveInputWithCursor\", true, function (cm, val) {\n if (!val) { cm.display.input.resetPosition(); }\n });\n\n option(\"tabindex\", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || \"\"; });\n option(\"autofocus\", null);\n option(\"direction\", \"ltr\", function (cm, val) { return cm.doc.setDirection(val); }, true);\n option(\"phrases\", null);\n }\n\n function guttersChanged(cm) {\n updateGutters(cm);\n regChange(cm);\n alignHorizontally(cm);\n }\n\n function dragDropChanged(cm, value, old) {\n var wasOn = old && old != Init;\n if (!value != !wasOn) {\n var funcs = cm.display.dragFunctions;\n var toggle = value ? on : off;\n toggle(cm.display.scroller, \"dragstart\", funcs.start);\n toggle(cm.display.scroller, \"dragenter\", funcs.enter);\n toggle(cm.display.scroller, \"dragover\", funcs.over);\n toggle(cm.display.scroller, \"dragleave\", funcs.leave);\n toggle(cm.display.scroller, \"drop\", funcs.drop);\n }\n }\n\n function wrappingChanged(cm) {\n if (cm.options.lineWrapping) {\n addClass(cm.display.wrapper, \"CodeMirror-wrap\");\n cm.display.sizer.style.minWidth = \"\";\n cm.display.sizerWidth = null;\n } else {\n rmClass(cm.display.wrapper, \"CodeMirror-wrap\");\n findMaxLine(cm);\n }\n estimateLineHeights(cm);\n regChange(cm);\n clearCaches(cm);\n setTimeout(function () { return updateScrollbars(cm); }, 100);\n }\n\n // A CodeMirror instance represents an editor. This is the object\n // that user code is usually dealing with.\n\n function CodeMirror(place, options) {\n var this$1 = this;\n\n if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }\n\n this.options = options = options ? copyObj(options) : {};\n // Determine effective options based on given values and defaults.\n copyObj(defaults, options, false);\n setGuttersForLineNumbers(options);\n\n var doc = options.value;\n if (typeof doc == \"string\") { doc = new Doc(doc, options.mode, null, options.lineSeparator, options.direction); }\n else if (options.mode) { doc.modeOption = options.mode; }\n this.doc = doc;\n\n var input = new CodeMirror.inputStyles[options.inputStyle](this);\n var display = this.display = new Display(place, doc, input);\n display.wrapper.CodeMirror = this;\n updateGutters(this);\n themeChanged(this);\n if (options.lineWrapping)\n { this.display.wrapper.className += \" CodeMirror-wrap\"; }\n initScrollbars(this);\n\n this.state = {\n keyMaps: [], // stores maps added by addKeyMap\n overlays: [], // highlighting overlays, as added by addOverlay\n modeGen: 0, // bumped when mode/overlay changes, used to invalidate highlighting info\n overwrite: false,\n delayingBlurEvent: false,\n focused: false,\n suppressEdits: false, // used to disable editing during key handlers when in readOnly mode\n pasteIncoming: -1, cutIncoming: -1, // help recognize paste/cut edits in input.poll\n selectingText: false,\n draggingText: false,\n highlight: new Delayed(), // stores highlight worker timeout\n keySeq: null, // Unfinished key sequence\n specialChars: null\n };\n\n if (options.autofocus && !mobile) { display.input.focus(); }\n\n // Override magic textarea content restore that IE sometimes does\n // on our hidden textarea on reload\n if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20); }\n\n registerEventHandlers(this);\n ensureGlobalHandlers();\n\n startOperation(this);\n this.curOp.forceUpdate = true;\n attachDoc(this, doc);\n\n if ((options.autofocus && !mobile) || this.hasFocus())\n { setTimeout(bind(onFocus, this), 20); }\n else\n { onBlur(this); }\n\n for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))\n { optionHandlers[opt](this$1, options[opt], Init); } }\n maybeUpdateLineNumberWidth(this);\n if (options.finishInit) { options.finishInit(this); }\n for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1); }\n endOperation(this);\n // Suppress optimizelegibility in Webkit, since it breaks text\n // measuring on line wrapping boundaries.\n if (webkit && options.lineWrapping &&\n getComputedStyle(display.lineDiv).textRendering == \"optimizelegibility\")\n { display.lineDiv.style.textRendering = \"auto\"; }\n }\n\n // The default configuration options.\n CodeMirror.defaults = defaults;\n // Functions to run when options are changed.\n CodeMirror.optionHandlers = optionHandlers;\n\n // Attach the necessary event handlers when initializing the editor\n function registerEventHandlers(cm) {\n var d = cm.display;\n on(d.scroller, \"mousedown\", operation(cm, onMouseDown));\n // Older IE's will not fire a second mousedown for a double click\n if (ie && ie_version < 11)\n { on(d.scroller, \"dblclick\", operation(cm, function (e) {\n if (signalDOMEvent(cm, e)) { return }\n var pos = posFromMouse(cm, e);\n if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }\n e_preventDefault(e);\n var word = cm.findWordAt(pos);\n extendSelection(cm.doc, word.anchor, word.head);\n })); }\n else\n { on(d.scroller, \"dblclick\", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }); }\n // Some browsers fire contextmenu *after* opening the menu, at\n // which point we can't mess with it anymore. Context menu is\n // handled in onMouseDown for these browsers.\n on(d.scroller, \"contextmenu\", function (e) { return onContextMenu(cm, e); });\n\n // Used to suppress mouse event handling when a touch happens\n var touchFinished, prevTouch = {end: 0};\n function finishTouch() {\n if (d.activeTouch) {\n touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000);\n prevTouch = d.activeTouch;\n prevTouch.end = +new Date;\n }\n }\n function isMouseLikeTouchEvent(e) {\n if (e.touches.length != 1) { return false }\n var touch = e.touches[0];\n return touch.radiusX <= 1 && touch.radiusY <= 1\n }\n function farAway(touch, other) {\n if (other.left == null) { return true }\n var dx = other.left - touch.left, dy = other.top - touch.top;\n return dx * dx + dy * dy > 20 * 20\n }\n on(d.scroller, \"touchstart\", function (e) {\n if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e) && !clickInGutter(cm, e)) {\n d.input.ensurePolled();\n clearTimeout(touchFinished);\n var now = +new Date;\n d.activeTouch = {start: now, moved: false,\n prev: now - prevTouch.end <= 300 ? prevTouch : null};\n if (e.touches.length == 1) {\n d.activeTouch.left = e.touches[0].pageX;\n d.activeTouch.top = e.touches[0].pageY;\n }\n }\n });\n on(d.scroller, \"touchmove\", function () {\n if (d.activeTouch) { d.activeTouch.moved = true; }\n });\n on(d.scroller, \"touchend\", function (e) {\n var touch = d.activeTouch;\n if (touch && !eventInWidget(d, e) && touch.left != null &&\n !touch.moved && new Date - touch.start < 300) {\n var pos = cm.coordsChar(d.activeTouch, \"page\"), range;\n if (!touch.prev || farAway(touch, touch.prev)) // Single tap\n { range = new Range(pos, pos); }\n else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap\n { range = cm.findWordAt(pos); }\n else // Triple tap\n { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))); }\n cm.setSelection(range.anchor, range.head);\n cm.focus();\n e_preventDefault(e);\n }\n finishTouch();\n });\n on(d.scroller, \"touchcancel\", finishTouch);\n\n // Sync scrolling between fake scrollbars and real scrollable\n // area, ensure viewport is updated when scrolling.\n on(d.scroller, \"scroll\", function () {\n if (d.scroller.clientHeight) {\n updateScrollTop(cm, d.scroller.scrollTop);\n setScrollLeft(cm, d.scroller.scrollLeft, true);\n signal(cm, \"scroll\", cm);\n }\n });\n\n // Listen to wheel events in order to try and update the viewport on time.\n on(d.scroller, \"mousewheel\", function (e) { return onScrollWheel(cm, e); });\n on(d.scroller, \"DOMMouseScroll\", function (e) { return onScrollWheel(cm, e); });\n\n // Prevent wrapper from ever scrolling\n on(d.wrapper, \"scroll\", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; });\n\n d.dragFunctions = {\n enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e); }},\n over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e); }},\n start: function (e) { return onDragStart(cm, e); },\n drop: operation(cm, onDrop),\n leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm); }}\n };\n\n var inp = d.input.getField();\n on(inp, \"keyup\", function (e) { return onKeyUp.call(cm, e); });\n on(inp, \"keydown\", operation(cm, onKeyDown));\n on(inp, \"keypress\", operation(cm, onKeyPress));\n on(inp, \"focus\", function (e) { return onFocus(cm, e); });\n on(inp, \"blur\", function (e) { return onBlur(cm, e); });\n }\n\n var initHooks = [];\n CodeMirror.defineInitHook = function (f) { return initHooks.push(f); };\n\n // Indent the given line. The how parameter can be \"smart\",\n // \"add\"/null, \"subtract\", or \"prev\". When aggressive is false\n // (typically set to true for forced single-line indents), empty\n // lines are not indented, and places where the mode returns Pass\n // are left alone.\n function indentLine(cm, n, how, aggressive) {\n var doc = cm.doc, state;\n if (how == null) { how = \"add\"; }\n if (how == \"smart\") {\n // Fall back to \"prev\" when the mode doesn't have an indentation\n // method.\n if (!doc.mode.indent) { how = \"prev\"; }\n else { state = getContextBefore(cm, n).state; }\n }\n\n var tabSize = cm.options.tabSize;\n var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize);\n if (line.stateAfter) { line.stateAfter = null; }\n var curSpaceString = line.text.match(/^\\s*/)[0], indentation;\n if (!aggressive && !/\\S/.test(line.text)) {\n indentation = 0;\n how = \"not\";\n } else if (how == \"smart\") {\n indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text);\n if (indentation == Pass || indentation > 150) {\n if (!aggressive) { return }\n how = \"prev\";\n }\n }\n if (how == \"prev\") {\n if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize); }\n else { indentation = 0; }\n } else if (how == \"add\") {\n indentation = curSpace + cm.options.indentUnit;\n } else if (how == \"subtract\") {\n indentation = curSpace - cm.options.indentUnit;\n } else if (typeof how == \"number\") {\n indentation = curSpace + how;\n }\n indentation = Math.max(0, indentation);\n\n var indentString = \"\", pos = 0;\n if (cm.options.indentWithTabs)\n { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += \"\\t\";} }\n if (pos < indentation) { indentString += spaceStr(indentation - pos); }\n\n if (indentString != curSpaceString) {\n replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), \"+input\");\n line.stateAfter = null;\n return true\n } else {\n // Ensure that, if the cursor was in the whitespace at the start\n // of the line, it is moved to the end of that space.\n for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {\n var range = doc.sel.ranges[i$1];\n if (range.head.line == n && range.head.ch < curSpaceString.length) {\n var pos$1 = Pos(n, curSpaceString.length);\n replaceOneSelection(doc, i$1, new Range(pos$1, pos$1));\n break\n }\n }\n }\n }\n\n // This will be set to a {lineWise: bool, text: [string]} object, so\n // that, when pasting, we know what kind of selections the copied\n // text was made out of.\n var lastCopied = null;\n\n function setLastCopied(newLastCopied) {\n lastCopied = newLastCopied;\n }\n\n function applyTextInput(cm, inserted, deleted, sel, origin) {\n var doc = cm.doc;\n cm.display.shift = false;\n if (!sel) { sel = doc.sel; }\n\n var recent = +new Date - 200;\n var paste = origin == \"paste\" || cm.state.pasteIncoming > recent;\n var textLines = splitLinesAuto(inserted), multiPaste = null;\n // When pasting N lines into N selections, insert one line per selection\n if (paste && sel.ranges.length > 1) {\n if (lastCopied && lastCopied.text.join(\"\\n\") == inserted) {\n if (sel.ranges.length % lastCopied.text.length == 0) {\n multiPaste = [];\n for (var i = 0; i < lastCopied.text.length; i++)\n { multiPaste.push(doc.splitLines(lastCopied.text[i])); }\n }\n } else if (textLines.length == sel.ranges.length && cm.options.pasteLinesPerSelection) {\n multiPaste = map(textLines, function (l) { return [l]; });\n }\n }\n\n var updateInput = cm.curOp.updateInput;\n // Normal behavior is to insert the new text into every selection\n for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {\n var range$$1 = sel.ranges[i$1];\n var from = range$$1.from(), to = range$$1.to();\n if (range$$1.empty()) {\n if (deleted && deleted > 0) // Handle deletion\n { from = Pos(from.line, from.ch - deleted); }\n else if (cm.state.overwrite && !paste) // Handle overwrite\n { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)); }\n else if (paste && lastCopied && lastCopied.lineWise && lastCopied.text.join(\"\\n\") == inserted)\n { from = to = Pos(from.line, 0); }\n }\n var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,\n origin: origin || (paste ? \"paste\" : cm.state.cutIncoming > recent ? \"cut\" : \"+input\")};\n makeChange(cm.doc, changeEvent);\n signalLater(cm, \"inputRead\", cm, changeEvent);\n }\n if (inserted && !paste)\n { triggerElectric(cm, inserted); }\n\n ensureCursorVisible(cm);\n if (cm.curOp.updateInput < 2) { cm.curOp.updateInput = updateInput; }\n cm.curOp.typing = true;\n cm.state.pasteIncoming = cm.state.cutIncoming = -1;\n }\n\n function handlePaste(e, cm) {\n var pasted = e.clipboardData && e.clipboardData.getData(\"Text\");\n if (pasted) {\n e.preventDefault();\n if (!cm.isReadOnly() && !cm.options.disableInput)\n { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, \"paste\"); }); }\n return true\n }\n }\n\n function triggerElectric(cm, inserted) {\n // When an 'electric' character is inserted, immediately trigger a reindent\n if (!cm.options.electricChars || !cm.options.smartIndent) { return }\n var sel = cm.doc.sel;\n\n for (var i = sel.ranges.length - 1; i >= 0; i--) {\n var range$$1 = sel.ranges[i];\n if (range$$1.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range$$1.head.line)) { continue }\n var mode = cm.getModeAt(range$$1.head);\n var indented = false;\n if (mode.electricChars) {\n for (var j = 0; j < mode.electricChars.length; j++)\n { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {\n indented = indentLine(cm, range$$1.head.line, \"smart\");\n break\n } }\n } else if (mode.electricInput) {\n if (mode.electricInput.test(getLine(cm.doc, range$$1.head.line).text.slice(0, range$$1.head.ch)))\n { indented = indentLine(cm, range$$1.head.line, \"smart\"); }\n }\n if (indented) { signalLater(cm, \"electricInput\", cm, range$$1.head.line); }\n }\n }\n\n function copyableRanges(cm) {\n var text = [], ranges = [];\n for (var i = 0; i < cm.doc.sel.ranges.length; i++) {\n var line = cm.doc.sel.ranges[i].head.line;\n var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)};\n ranges.push(lineRange);\n text.push(cm.getRange(lineRange.anchor, lineRange.head));\n }\n return {text: text, ranges: ranges}\n }\n\n function disableBrowserMagic(field, spellcheck, autocorrect, autocapitalize) {\n field.setAttribute(\"autocorrect\", !!autocorrect);\n field.setAttribute(\"autocapitalize\", !!autocapitalize);\n field.setAttribute(\"spellcheck\", !!spellcheck);\n }\n\n function hiddenTextarea() {\n var te = elt(\"textarea\", null, null, \"position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none\");\n var div = elt(\"div\", [te], null, \"overflow: hidden; position: relative; width: 3px; height: 0px;\");\n // The textarea is kept positioned near the cursor to prevent the\n // fact that it'll be scrolled into view on input from scrolling\n // our fake cursor out of view. On webkit, when wrap=off, paste is\n // very slow. So make the area wide instead.\n if (webkit) { te.style.width = \"1000px\"; }\n else { te.setAttribute(\"wrap\", \"off\"); }\n // If border: 0; -- iOS fails to open keyboard (issue #1287)\n if (ios) { te.style.border = \"1px solid black\"; }\n disableBrowserMagic(te);\n return div\n }\n\n // The publicly visible API. Note that methodOp(f) means\n // 'wrap f in an operation, performed on its `this` parameter'.\n\n // This is not the complete set of editor methods. Most of the\n // methods defined on the Doc type are also injected into\n // CodeMirror.prototype, for backwards compatibility and\n // convenience.\n\n function addEditorMethods(CodeMirror) {\n var optionHandlers = CodeMirror.optionHandlers;\n\n var helpers = CodeMirror.helpers = {};\n\n CodeMirror.prototype = {\n constructor: CodeMirror,\n focus: function(){window.focus(); this.display.input.focus();},\n\n setOption: function(option, value) {\n var options = this.options, old = options[option];\n if (options[option] == value && option != \"mode\") { return }\n options[option] = value;\n if (optionHandlers.hasOwnProperty(option))\n { operation(this, optionHandlers[option])(this, value, old); }\n signal(this, \"optionChange\", this, option);\n },\n\n getOption: function(option) {return this.options[option]},\n getDoc: function() {return this.doc},\n\n addKeyMap: function(map$$1, bottom) {\n this.state.keyMaps[bottom ? \"push\" : \"unshift\"](getKeyMap(map$$1));\n },\n removeKeyMap: function(map$$1) {\n var maps = this.state.keyMaps;\n for (var i = 0; i < maps.length; ++i)\n { if (maps[i] == map$$1 || maps[i].name == map$$1) {\n maps.splice(i, 1);\n return true\n } }\n },\n\n addOverlay: methodOp(function(spec, options) {\n var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec);\n if (mode.startState) { throw new Error(\"Overlays may not be stateful.\") }\n insertSorted(this.state.overlays,\n {mode: mode, modeSpec: spec, opaque: options && options.opaque,\n priority: (options && options.priority) || 0},\n function (overlay) { return overlay.priority; });\n this.state.modeGen++;\n regChange(this);\n }),\n removeOverlay: methodOp(function(spec) {\n var this$1 = this;\n\n var overlays = this.state.overlays;\n for (var i = 0; i < overlays.length; ++i) {\n var cur = overlays[i].modeSpec;\n if (cur == spec || typeof spec == \"string\" && cur.name == spec) {\n overlays.splice(i, 1);\n this$1.state.modeGen++;\n regChange(this$1);\n return\n }\n }\n }),\n\n indentLine: methodOp(function(n, dir, aggressive) {\n if (typeof dir != \"string\" && typeof dir != \"number\") {\n if (dir == null) { dir = this.options.smartIndent ? \"smart\" : \"prev\"; }\n else { dir = dir ? \"add\" : \"subtract\"; }\n }\n if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive); }\n }),\n indentSelection: methodOp(function(how) {\n var this$1 = this;\n\n var ranges = this.doc.sel.ranges, end = -1;\n for (var i = 0; i < ranges.length; i++) {\n var range$$1 = ranges[i];\n if (!range$$1.empty()) {\n var from = range$$1.from(), to = range$$1.to();\n var start = Math.max(end, from.line);\n end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;\n for (var j = start; j < end; ++j)\n { indentLine(this$1, j, how); }\n var newRanges = this$1.doc.sel.ranges;\n if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)\n { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll); }\n } else if (range$$1.head.line > end) {\n indentLine(this$1, range$$1.head.line, how, true);\n end = range$$1.head.line;\n if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1); }\n }\n }\n }),\n\n // Fetch the parser token for a given character. Useful for hacks\n // that want to inspect the mode state (say, for completion).\n getTokenAt: function(pos, precise) {\n return takeToken(this, pos, precise)\n },\n\n getLineTokens: function(line, precise) {\n return takeToken(this, Pos(line), precise, true)\n },\n\n getTokenTypeAt: function(pos) {\n pos = clipPos(this.doc, pos);\n var styles = getLineStyles(this, getLine(this.doc, pos.line));\n var before = 0, after = (styles.length - 1) / 2, ch = pos.ch;\n var type;\n if (ch == 0) { type = styles[2]; }\n else { for (;;) {\n var mid = (before + after) >> 1;\n if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid; }\n else if (styles[mid * 2 + 1] < ch) { before = mid + 1; }\n else { type = styles[mid * 2 + 2]; break }\n } }\n var cut = type ? type.indexOf(\"overlay \") : -1;\n return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)\n },\n\n getModeAt: function(pos) {\n var mode = this.doc.mode;\n if (!mode.innerMode) { return mode }\n return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode\n },\n\n getHelper: function(pos, type) {\n return this.getHelpers(pos, type)[0]\n },\n\n getHelpers: function(pos, type) {\n var this$1 = this;\n\n var found = [];\n if (!helpers.hasOwnProperty(type)) { return found }\n var help = helpers[type], mode = this.getModeAt(pos);\n if (typeof mode[type] == \"string\") {\n if (help[mode[type]]) { found.push(help[mode[type]]); }\n } else if (mode[type]) {\n for (var i = 0; i < mode[type].length; i++) {\n var val = help[mode[type][i]];\n if (val) { found.push(val); }\n }\n } else if (mode.helperType && help[mode.helperType]) {\n found.push(help[mode.helperType]);\n } else if (help[mode.name]) {\n found.push(help[mode.name]);\n }\n for (var i$1 = 0; i$1 < help._global.length; i$1++) {\n var cur = help._global[i$1];\n if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)\n { found.push(cur.val); }\n }\n return found\n },\n\n getStateAfter: function(line, precise) {\n var doc = this.doc;\n line = clipLine(doc, line == null ? doc.first + doc.size - 1: line);\n return getContextBefore(this, line + 1, precise).state\n },\n\n cursorCoords: function(start, mode) {\n var pos, range$$1 = this.doc.sel.primary();\n if (start == null) { pos = range$$1.head; }\n else if (typeof start == \"object\") { pos = clipPos(this.doc, start); }\n else { pos = start ? range$$1.from() : range$$1.to(); }\n return cursorCoords(this, pos, mode || \"page\")\n },\n\n charCoords: function(pos, mode) {\n return charCoords(this, clipPos(this.doc, pos), mode || \"page\")\n },\n\n coordsChar: function(coords, mode) {\n coords = fromCoordSystem(this, coords, mode || \"page\");\n return coordsChar(this, coords.left, coords.top)\n },\n\n lineAtHeight: function(height, mode) {\n height = fromCoordSystem(this, {top: height, left: 0}, mode || \"page\").top;\n return lineAtHeight(this.doc, height + this.display.viewOffset)\n },\n heightAtLine: function(line, mode, includeWidgets) {\n var end = false, lineObj;\n if (typeof line == \"number\") {\n var last = this.doc.first + this.doc.size - 1;\n if (line < this.doc.first) { line = this.doc.first; }\n else if (line > last) { line = last; end = true; }\n lineObj = getLine(this.doc, line);\n } else {\n lineObj = line;\n }\n return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || \"page\", includeWidgets || end).top +\n (end ? this.doc.height - heightAtLine(lineObj) : 0)\n },\n\n defaultTextHeight: function() { return textHeight(this.display) },\n defaultCharWidth: function() { return charWidth(this.display) },\n\n getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},\n\n addWidget: function(pos, node, scroll, vert, horiz) {\n var display = this.display;\n pos = cursorCoords(this, clipPos(this.doc, pos));\n var top = pos.bottom, left = pos.left;\n node.style.position = \"absolute\";\n node.setAttribute(\"cm-ignore-events\", \"true\");\n this.display.input.setUneditable(node);\n display.sizer.appendChild(node);\n if (vert == \"over\") {\n top = pos.top;\n } else if (vert == \"above\" || vert == \"near\") {\n var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),\n hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth);\n // Default to positioning above (if specified and possible); otherwise default to positioning below\n if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)\n { top = pos.top - node.offsetHeight; }\n else if (pos.bottom + node.offsetHeight <= vspace)\n { top = pos.bottom; }\n if (left + node.offsetWidth > hspace)\n { left = hspace - node.offsetWidth; }\n }\n node.style.top = top + \"px\";\n node.style.left = node.style.right = \"\";\n if (horiz == \"right\") {\n left = display.sizer.clientWidth - node.offsetWidth;\n node.style.right = \"0px\";\n } else {\n if (horiz == \"left\") { left = 0; }\n else if (horiz == \"middle\") { left = (display.sizer.clientWidth - node.offsetWidth) / 2; }\n node.style.left = left + \"px\";\n }\n if (scroll)\n { scrollIntoView(this, {left: left, top: top, right: left + node.offsetWidth, bottom: top + node.offsetHeight}); }\n },\n\n triggerOnKeyDown: methodOp(onKeyDown),\n triggerOnKeyPress: methodOp(onKeyPress),\n triggerOnKeyUp: onKeyUp,\n triggerOnMouseDown: methodOp(onMouseDown),\n\n execCommand: function(cmd) {\n if (commands.hasOwnProperty(cmd))\n { return commands[cmd].call(null, this) }\n },\n\n triggerElectric: methodOp(function(text) { triggerElectric(this, text); }),\n\n findPosH: function(from, amount, unit, visually) {\n var this$1 = this;\n\n var dir = 1;\n if (amount < 0) { dir = -1; amount = -amount; }\n var cur = clipPos(this.doc, from);\n for (var i = 0; i < amount; ++i) {\n cur = findPosH(this$1.doc, cur, dir, unit, visually);\n if (cur.hitSide) { break }\n }\n return cur\n },\n\n moveH: methodOp(function(dir, unit) {\n var this$1 = this;\n\n this.extendSelectionsBy(function (range$$1) {\n if (this$1.display.shift || this$1.doc.extend || range$$1.empty())\n { return findPosH(this$1.doc, range$$1.head, dir, unit, this$1.options.rtlMoveVisually) }\n else\n { return dir < 0 ? range$$1.from() : range$$1.to() }\n }, sel_move);\n }),\n\n deleteH: methodOp(function(dir, unit) {\n var sel = this.doc.sel, doc = this.doc;\n if (sel.somethingSelected())\n { doc.replaceSelection(\"\", null, \"+delete\"); }\n else\n { deleteNearSelection(this, function (range$$1) {\n var other = findPosH(doc, range$$1.head, dir, unit, false);\n return dir < 0 ? {from: other, to: range$$1.head} : {from: range$$1.head, to: other}\n }); }\n }),\n\n findPosV: function(from, amount, unit, goalColumn) {\n var this$1 = this;\n\n var dir = 1, x = goalColumn;\n if (amount < 0) { dir = -1; amount = -amount; }\n var cur = clipPos(this.doc, from);\n for (var i = 0; i < amount; ++i) {\n var coords = cursorCoords(this$1, cur, \"div\");\n if (x == null) { x = coords.left; }\n else { coords.left = x; }\n cur = findPosV(this$1, coords, dir, unit);\n if (cur.hitSide) { break }\n }\n return cur\n },\n\n moveV: methodOp(function(dir, unit) {\n var this$1 = this;\n\n var doc = this.doc, goals = [];\n var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected();\n doc.extendSelectionsBy(function (range$$1) {\n if (collapse)\n { return dir < 0 ? range$$1.from() : range$$1.to() }\n var headPos = cursorCoords(this$1, range$$1.head, \"div\");\n if (range$$1.goalColumn != null) { headPos.left = range$$1.goalColumn; }\n goals.push(headPos.left);\n var pos = findPosV(this$1, headPos, dir, unit);\n if (unit == \"page\" && range$$1 == doc.sel.primary())\n { addToScrollTop(this$1, charCoords(this$1, pos, \"div\").top - headPos.top); }\n return pos\n }, sel_move);\n if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)\n { doc.sel.ranges[i].goalColumn = goals[i]; } }\n }),\n\n // Find the word at the given position (as returned by coordsChar).\n findWordAt: function(pos) {\n var doc = this.doc, line = getLine(doc, pos.line).text;\n var start = pos.ch, end = pos.ch;\n if (line) {\n var helper = this.getHelper(pos, \"wordChars\");\n if ((pos.sticky == \"before\" || end == line.length) && start) { --start; } else { ++end; }\n var startChar = line.charAt(start);\n var check = isWordChar(startChar, helper)\n ? function (ch) { return isWordChar(ch, helper); }\n : /\\s/.test(startChar) ? function (ch) { return /\\s/.test(ch); }\n : function (ch) { return (!/\\s/.test(ch) && !isWordChar(ch)); };\n while (start > 0 && check(line.charAt(start - 1))) { --start; }\n while (end < line.length && check(line.charAt(end))) { ++end; }\n }\n return new Range(Pos(pos.line, start), Pos(pos.line, end))\n },\n\n toggleOverwrite: function(value) {\n if (value != null && value == this.state.overwrite) { return }\n if (this.state.overwrite = !this.state.overwrite)\n { addClass(this.display.cursorDiv, \"CodeMirror-overwrite\"); }\n else\n { rmClass(this.display.cursorDiv, \"CodeMirror-overwrite\"); }\n\n signal(this, \"overwriteToggle\", this, this.state.overwrite);\n },\n hasFocus: function() { return this.display.input.getField() == activeElt() },\n isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },\n\n scrollTo: methodOp(function (x, y) { scrollToCoords(this, x, y); }),\n getScrollInfo: function() {\n var scroller = this.display.scroller;\n return {left: scroller.scrollLeft, top: scroller.scrollTop,\n height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,\n width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,\n clientHeight: displayHeight(this), clientWidth: displayWidth(this)}\n },\n\n scrollIntoView: methodOp(function(range$$1, margin) {\n if (range$$1 == null) {\n range$$1 = {from: this.doc.sel.primary().head, to: null};\n if (margin == null) { margin = this.options.cursorScrollMargin; }\n } else if (typeof range$$1 == \"number\") {\n range$$1 = {from: Pos(range$$1, 0), to: null};\n } else if (range$$1.from == null) {\n range$$1 = {from: range$$1, to: null};\n }\n if (!range$$1.to) { range$$1.to = range$$1.from; }\n range$$1.margin = margin || 0;\n\n if (range$$1.from.line != null) {\n scrollToRange(this, range$$1);\n } else {\n scrollToCoordsRange(this, range$$1.from, range$$1.to, range$$1.margin);\n }\n }),\n\n setSize: methodOp(function(width, height) {\n var this$1 = this;\n\n var interpret = function (val) { return typeof val == \"number\" || /^\\d+$/.test(String(val)) ? val + \"px\" : val; };\n if (width != null) { this.display.wrapper.style.width = interpret(width); }\n if (height != null) { this.display.wrapper.style.height = interpret(height); }\n if (this.options.lineWrapping) { clearLineMeasurementCache(this); }\n var lineNo$$1 = this.display.viewFrom;\n this.doc.iter(lineNo$$1, this.display.viewTo, function (line) {\n if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)\n { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo$$1, \"widget\"); break } } }\n ++lineNo$$1;\n });\n this.curOp.forceUpdate = true;\n signal(this, \"refresh\", this);\n }),\n\n operation: function(f){return runInOp(this, f)},\n startOperation: function(){return startOperation(this)},\n endOperation: function(){return endOperation(this)},\n\n refresh: methodOp(function() {\n var oldHeight = this.display.cachedTextHeight;\n regChange(this);\n this.curOp.forceUpdate = true;\n clearCaches(this);\n scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop);\n updateGutterSpace(this);\n if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)\n { estimateLineHeights(this); }\n signal(this, \"refresh\", this);\n }),\n\n swapDoc: methodOp(function(doc) {\n var old = this.doc;\n old.cm = null;\n attachDoc(this, doc);\n clearCaches(this);\n this.display.input.reset();\n scrollToCoords(this, doc.scrollLeft, doc.scrollTop);\n this.curOp.forceScroll = true;\n signalLater(this, \"swapDoc\", this, old);\n return old\n }),\n\n phrase: function(phraseText) {\n var phrases = this.options.phrases;\n return phrases && Object.prototype.hasOwnProperty.call(phrases, phraseText) ? phrases[phraseText] : phraseText\n },\n\n getInputField: function(){return this.display.input.getField()},\n getWrapperElement: function(){return this.display.wrapper},\n getScrollerElement: function(){return this.display.scroller},\n getGutterElement: function(){return this.display.gutters}\n };\n eventMixin(CodeMirror);\n\n CodeMirror.registerHelper = function(type, name, value) {\n if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []}; }\n helpers[type][name] = value;\n };\n CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {\n CodeMirror.registerHelper(type, name, value);\n helpers[type]._global.push({pred: predicate, val: value});\n };\n }\n\n // Used for horizontal relative motion. Dir is -1 or 1 (left or\n // right), unit can be \"char\", \"column\" (like char, but doesn't\n // cross line boundaries), \"word\" (across next word), or \"group\" (to\n // the start of next group of word or non-word-non-whitespace\n // chars). The visually param controls whether, in right-to-left\n // text, direction 1 means to move towards the next index in the\n // string, or towards the character to the right of the current\n // position. The resulting position will have a hitSide=true\n // property if it reached the end of the document.\n function findPosH(doc, pos, dir, unit, visually) {\n var oldPos = pos;\n var origDir = dir;\n var lineObj = getLine(doc, pos.line);\n function findNextLine() {\n var l = pos.line + dir;\n if (l < doc.first || l >= doc.first + doc.size) { return false }\n pos = new Pos(l, pos.ch, pos.sticky);\n return lineObj = getLine(doc, l)\n }\n function moveOnce(boundToLine) {\n var next;\n if (visually) {\n next = moveVisually(doc.cm, lineObj, pos, dir);\n } else {\n next = moveLogically(lineObj, pos, dir);\n }\n if (next == null) {\n if (!boundToLine && findNextLine())\n { pos = endOfLine(visually, doc.cm, lineObj, pos.line, dir); }\n else\n { return false }\n } else {\n pos = next;\n }\n return true\n }\n\n if (unit == \"char\") {\n moveOnce();\n } else if (unit == \"column\") {\n moveOnce(true);\n } else if (unit == \"word\" || unit == \"group\") {\n var sawType = null, group = unit == \"group\";\n var helper = doc.cm && doc.cm.getHelper(pos, \"wordChars\");\n for (var first = true;; first = false) {\n if (dir < 0 && !moveOnce(!first)) { break }\n var cur = lineObj.text.charAt(pos.ch) || \"\\n\";\n var type = isWordChar(cur, helper) ? \"w\"\n : group && cur == \"\\n\" ? \"n\"\n : !group || /\\s/.test(cur) ? null\n : \"p\";\n if (group && !first && !type) { type = \"s\"; }\n if (sawType && sawType != type) {\n if (dir < 0) {dir = 1; moveOnce(); pos.sticky = \"after\";}\n break\n }\n\n if (type) { sawType = type; }\n if (dir > 0 && !moveOnce(!first)) { break }\n }\n }\n var result = skipAtomic(doc, pos, oldPos, origDir, true);\n if (equalCursorPos(oldPos, result)) { result.hitSide = true; }\n return result\n }\n\n // For relative vertical movement. Dir may be -1 or 1. Unit can be\n // \"page\" or \"line\". The resulting position will have a hitSide=true\n // property if it reached the end of the document.\n function findPosV(cm, pos, dir, unit) {\n var doc = cm.doc, x = pos.left, y;\n if (unit == \"page\") {\n var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight);\n var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3);\n y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount;\n\n } else if (unit == \"line\") {\n y = dir > 0 ? pos.bottom + 3 : pos.top - 3;\n }\n var target;\n for (;;) {\n target = coordsChar(cm, x, y);\n if (!target.outside) { break }\n if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }\n y += dir * 5;\n }\n return target\n }\n\n // CONTENTEDITABLE INPUT STYLE\n\n var ContentEditableInput = function(cm) {\n this.cm = cm;\n this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null;\n this.polling = new Delayed();\n this.composing = null;\n this.gracePeriod = false;\n this.readDOMTimeout = null;\n };\n\n ContentEditableInput.prototype.init = function (display) {\n var this$1 = this;\n\n var input = this, cm = input.cm;\n var div = input.div = display.lineDiv;\n disableBrowserMagic(div, cm.options.spellcheck, cm.options.autocorrect, cm.options.autocapitalize);\n\n on(div, \"paste\", function (e) {\n if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n // IE doesn't fire input events, so we schedule a read for the pasted content in this way\n if (ie_version <= 11) { setTimeout(operation(cm, function () { return this$1.updateFromDOM(); }), 20); }\n });\n\n on(div, \"compositionstart\", function (e) {\n this$1.composing = {data: e.data, done: false};\n });\n on(div, \"compositionupdate\", function (e) {\n if (!this$1.composing) { this$1.composing = {data: e.data, done: false}; }\n });\n on(div, \"compositionend\", function (e) {\n if (this$1.composing) {\n if (e.data != this$1.composing.data) { this$1.readFromDOMSoon(); }\n this$1.composing.done = true;\n }\n });\n\n on(div, \"touchstart\", function () { return input.forceCompositionEnd(); });\n\n on(div, \"input\", function () {\n if (!this$1.composing) { this$1.readFromDOMSoon(); }\n });\n\n function onCopyCut(e) {\n if (signalDOMEvent(cm, e)) { return }\n if (cm.somethingSelected()) {\n setLastCopied({lineWise: false, text: cm.getSelections()});\n if (e.type == \"cut\") { cm.replaceSelection(\"\", null, \"cut\"); }\n } else if (!cm.options.lineWiseCopyCut) {\n return\n } else {\n var ranges = copyableRanges(cm);\n setLastCopied({lineWise: true, text: ranges.text});\n if (e.type == \"cut\") {\n cm.operation(function () {\n cm.setSelections(ranges.ranges, 0, sel_dontScroll);\n cm.replaceSelection(\"\", null, \"cut\");\n });\n }\n }\n if (e.clipboardData) {\n e.clipboardData.clearData();\n var content = lastCopied.text.join(\"\\n\");\n // iOS exposes the clipboard API, but seems to discard content inserted into it\n e.clipboardData.setData(\"Text\", content);\n if (e.clipboardData.getData(\"Text\") == content) {\n e.preventDefault();\n return\n }\n }\n // Old-fashioned briefly-focus-a-textarea hack\n var kludge = hiddenTextarea(), te = kludge.firstChild;\n cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild);\n te.value = lastCopied.text.join(\"\\n\");\n var hadFocus = document.activeElement;\n selectInput(te);\n setTimeout(function () {\n cm.display.lineSpace.removeChild(kludge);\n hadFocus.focus();\n if (hadFocus == div) { input.showPrimarySelection(); }\n }, 50);\n }\n on(div, \"copy\", onCopyCut);\n on(div, \"cut\", onCopyCut);\n };\n\n ContentEditableInput.prototype.prepareSelection = function () {\n var result = prepareSelection(this.cm, false);\n result.focus = this.cm.state.focused;\n return result\n };\n\n ContentEditableInput.prototype.showSelection = function (info, takeFocus) {\n if (!info || !this.cm.display.view.length) { return }\n if (info.focus || takeFocus) { this.showPrimarySelection(); }\n this.showMultipleSelections(info);\n };\n\n ContentEditableInput.prototype.getSelection = function () {\n return this.cm.display.wrapper.ownerDocument.getSelection()\n };\n\n ContentEditableInput.prototype.showPrimarySelection = function () {\n var sel = this.getSelection(), cm = this.cm, prim = cm.doc.sel.primary();\n var from = prim.from(), to = prim.to();\n\n if (cm.display.viewTo == cm.display.viewFrom || from.line >= cm.display.viewTo || to.line < cm.display.viewFrom) {\n sel.removeAllRanges();\n return\n }\n\n var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);\n var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset);\n if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&\n cmp(minPos(curAnchor, curFocus), from) == 0 &&\n cmp(maxPos(curAnchor, curFocus), to) == 0)\n { return }\n\n var view = cm.display.view;\n var start = (from.line >= cm.display.viewFrom && posToDOM(cm, from)) ||\n {node: view[0].measure.map[2], offset: 0};\n var end = to.line < cm.display.viewTo && posToDOM(cm, to);\n if (!end) {\n var measure = view[view.length - 1].measure;\n var map$$1 = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map;\n end = {node: map$$1[map$$1.length - 1], offset: map$$1[map$$1.length - 2] - map$$1[map$$1.length - 3]};\n }\n\n if (!start || !end) {\n sel.removeAllRanges();\n return\n }\n\n var old = sel.rangeCount && sel.getRangeAt(0), rng;\n try { rng = range(start.node, start.offset, end.offset, end.node); }\n catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible\n if (rng) {\n if (!gecko && cm.state.focused) {\n sel.collapse(start.node, start.offset);\n if (!rng.collapsed) {\n sel.removeAllRanges();\n sel.addRange(rng);\n }\n } else {\n sel.removeAllRanges();\n sel.addRange(rng);\n }\n if (old && sel.anchorNode == null) { sel.addRange(old); }\n else if (gecko) { this.startGracePeriod(); }\n }\n this.rememberSelection();\n };\n\n ContentEditableInput.prototype.startGracePeriod = function () {\n var this$1 = this;\n\n clearTimeout(this.gracePeriod);\n this.gracePeriod = setTimeout(function () {\n this$1.gracePeriod = false;\n if (this$1.selectionChanged())\n { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }); }\n }, 20);\n };\n\n ContentEditableInput.prototype.showMultipleSelections = function (info) {\n removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors);\n removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection);\n };\n\n ContentEditableInput.prototype.rememberSelection = function () {\n var sel = this.getSelection();\n this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset;\n this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset;\n };\n\n ContentEditableInput.prototype.selectionInEditor = function () {\n var sel = this.getSelection();\n if (!sel.rangeCount) { return false }\n var node = sel.getRangeAt(0).commonAncestorContainer;\n return contains(this.div, node)\n };\n\n ContentEditableInput.prototype.focus = function () {\n if (this.cm.options.readOnly != \"nocursor\") {\n if (!this.selectionInEditor())\n { this.showSelection(this.prepareSelection(), true); }\n this.div.focus();\n }\n };\n ContentEditableInput.prototype.blur = function () { this.div.blur(); };\n ContentEditableInput.prototype.getField = function () { return this.div };\n\n ContentEditableInput.prototype.supportsTouch = function () { return true };\n\n ContentEditableInput.prototype.receivedFocus = function () {\n var input = this;\n if (this.selectionInEditor())\n { this.pollSelection(); }\n else\n { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }); }\n\n function poll() {\n if (input.cm.state.focused) {\n input.pollSelection();\n input.polling.set(input.cm.options.pollInterval, poll);\n }\n }\n this.polling.set(this.cm.options.pollInterval, poll);\n };\n\n ContentEditableInput.prototype.selectionChanged = function () {\n var sel = this.getSelection();\n return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||\n sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset\n };\n\n ContentEditableInput.prototype.pollSelection = function () {\n if (this.readDOMTimeout != null || this.gracePeriod || !this.selectionChanged()) { return }\n var sel = this.getSelection(), cm = this.cm;\n // On Android Chrome (version 56, at least), backspacing into an\n // uneditable block element will put the cursor in that element,\n // and then, because it's not editable, hide the virtual keyboard.\n // Because Android doesn't allow us to actually detect backspace\n // presses in a sane way, this code checks for when that happens\n // and simulates a backspace press in this case.\n if (android && chrome && this.cm.options.gutters.length && isInGutter(sel.anchorNode)) {\n this.cm.triggerOnKeyDown({type: \"keydown\", keyCode: 8, preventDefault: Math.abs});\n this.blur();\n this.focus();\n return\n }\n if (this.composing) { return }\n this.rememberSelection();\n var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);\n var head = domToPos(cm, sel.focusNode, sel.focusOffset);\n if (anchor && head) { runInOp(cm, function () {\n setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll);\n if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true; }\n }); }\n };\n\n ContentEditableInput.prototype.pollContent = function () {\n if (this.readDOMTimeout != null) {\n clearTimeout(this.readDOMTimeout);\n this.readDOMTimeout = null;\n }\n\n var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary();\n var from = sel.from(), to = sel.to();\n if (from.ch == 0 && from.line > cm.firstLine())\n { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length); }\n if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())\n { to = Pos(to.line + 1, 0); }\n if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }\n\n var fromIndex, fromLine, fromNode;\n if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {\n fromLine = lineNo(display.view[0].line);\n fromNode = display.view[0].node;\n } else {\n fromLine = lineNo(display.view[fromIndex].line);\n fromNode = display.view[fromIndex - 1].node.nextSibling;\n }\n var toIndex = findViewIndex(cm, to.line);\n var toLine, toNode;\n if (toIndex == display.view.length - 1) {\n toLine = display.viewTo - 1;\n toNode = display.lineDiv.lastChild;\n } else {\n toLine = lineNo(display.view[toIndex + 1].line) - 1;\n toNode = display.view[toIndex + 1].node.previousSibling;\n }\n\n if (!fromNode) { return false }\n var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine));\n var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length));\n while (newText.length > 1 && oldText.length > 1) {\n if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine--; }\n else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++; }\n else { break }\n }\n\n var cutFront = 0, cutEnd = 0;\n var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length);\n while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))\n { ++cutFront; }\n var newBot = lst(newText), oldBot = lst(oldText);\n var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),\n oldBot.length - (oldText.length == 1 ? cutFront : 0));\n while (cutEnd < maxCutEnd &&\n newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))\n { ++cutEnd; }\n // Try to move start of change to start of selection if ambiguous\n if (newText.length == 1 && oldText.length == 1 && fromLine == from.line) {\n while (cutFront && cutFront > from.ch &&\n newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1)) {\n cutFront--;\n cutEnd++;\n }\n }\n\n newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\\u200b+/, \"\");\n newText[0] = newText[0].slice(cutFront).replace(/\\u200b+$/, \"\");\n\n var chFrom = Pos(fromLine, cutFront);\n var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0);\n if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {\n replaceRange(cm.doc, newText, chFrom, chTo, \"+input\");\n return true\n }\n };\n\n ContentEditableInput.prototype.ensurePolled = function () {\n this.forceCompositionEnd();\n };\n ContentEditableInput.prototype.reset = function () {\n this.forceCompositionEnd();\n };\n ContentEditableInput.prototype.forceCompositionEnd = function () {\n if (!this.composing) { return }\n clearTimeout(this.readDOMTimeout);\n this.composing = null;\n this.updateFromDOM();\n this.div.blur();\n this.div.focus();\n };\n ContentEditableInput.prototype.readFromDOMSoon = function () {\n var this$1 = this;\n\n if (this.readDOMTimeout != null) { return }\n this.readDOMTimeout = setTimeout(function () {\n this$1.readDOMTimeout = null;\n if (this$1.composing) {\n if (this$1.composing.done) { this$1.composing = null; }\n else { return }\n }\n this$1.updateFromDOM();\n }, 80);\n };\n\n ContentEditableInput.prototype.updateFromDOM = function () {\n var this$1 = this;\n\n if (this.cm.isReadOnly() || !this.pollContent())\n { runInOp(this.cm, function () { return regChange(this$1.cm); }); }\n };\n\n ContentEditableInput.prototype.setUneditable = function (node) {\n node.contentEditable = \"false\";\n };\n\n ContentEditableInput.prototype.onKeyPress = function (e) {\n if (e.charCode == 0 || this.composing) { return }\n e.preventDefault();\n if (!this.cm.isReadOnly())\n { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0); }\n };\n\n ContentEditableInput.prototype.readOnlyChanged = function (val) {\n this.div.contentEditable = String(val != \"nocursor\");\n };\n\n ContentEditableInput.prototype.onContextMenu = function () {};\n ContentEditableInput.prototype.resetPosition = function () {};\n\n ContentEditableInput.prototype.needsContentAttribute = true;\n\n function posToDOM(cm, pos) {\n var view = findViewForLine(cm, pos.line);\n if (!view || view.hidden) { return null }\n var line = getLine(cm.doc, pos.line);\n var info = mapFromLineView(view, line, pos.line);\n\n var order = getOrder(line, cm.doc.direction), side = \"left\";\n if (order) {\n var partPos = getBidiPartAt(order, pos.ch);\n side = partPos % 2 ? \"right\" : \"left\";\n }\n var result = nodeAndOffsetInLineMap(info.map, pos.ch, side);\n result.offset = result.collapse == \"right\" ? result.end : result.start;\n return result\n }\n\n function isInGutter(node) {\n for (var scan = node; scan; scan = scan.parentNode)\n { if (/CodeMirror-gutter-wrapper/.test(scan.className)) { return true } }\n return false\n }\n\n function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }\n\n function domTextBetween(cm, from, to, fromLine, toLine) {\n var text = \"\", closing = false, lineSep = cm.doc.lineSeparator(), extraLinebreak = false;\n function recognizeMarker(id) { return function (marker) { return marker.id == id; } }\n function close() {\n if (closing) {\n text += lineSep;\n if (extraLinebreak) { text += lineSep; }\n closing = extraLinebreak = false;\n }\n }\n function addText(str) {\n if (str) {\n close();\n text += str;\n }\n }\n function walk(node) {\n if (node.nodeType == 1) {\n var cmText = node.getAttribute(\"cm-text\");\n if (cmText) {\n addText(cmText);\n return\n }\n var markerID = node.getAttribute(\"cm-marker\"), range$$1;\n if (markerID) {\n var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID));\n if (found.length && (range$$1 = found[0].find(0)))\n { addText(getBetween(cm.doc, range$$1.from, range$$1.to).join(lineSep)); }\n return\n }\n if (node.getAttribute(\"contenteditable\") == \"false\") { return }\n var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName);\n if (!/^br$/i.test(node.nodeName) && node.textContent.length == 0) { return }\n\n if (isBlock) { close(); }\n for (var i = 0; i < node.childNodes.length; i++)\n { walk(node.childNodes[i]); }\n\n if (/^(pre|p)$/i.test(node.nodeName)) { extraLinebreak = true; }\n if (isBlock) { closing = true; }\n } else if (node.nodeType == 3) {\n addText(node.nodeValue.replace(/\\u200b/g, \"\").replace(/\\u00a0/g, \" \"));\n }\n }\n for (;;) {\n walk(from);\n if (from == to) { break }\n from = from.nextSibling;\n extraLinebreak = false;\n }\n return text\n }\n\n function domToPos(cm, node, offset) {\n var lineNode;\n if (node == cm.display.lineDiv) {\n lineNode = cm.display.lineDiv.childNodes[offset];\n if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }\n node = null; offset = 0;\n } else {\n for (lineNode = node;; lineNode = lineNode.parentNode) {\n if (!lineNode || lineNode == cm.display.lineDiv) { return null }\n if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }\n }\n }\n for (var i = 0; i < cm.display.view.length; i++) {\n var lineView = cm.display.view[i];\n if (lineView.node == lineNode)\n { return locateNodeInLineView(lineView, node, offset) }\n }\n }\n\n function locateNodeInLineView(lineView, node, offset) {\n var wrapper = lineView.text.firstChild, bad = false;\n if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }\n if (node == wrapper) {\n bad = true;\n node = wrapper.childNodes[offset];\n offset = 0;\n if (!node) {\n var line = lineView.rest ? lst(lineView.rest) : lineView.line;\n return badPos(Pos(lineNo(line), line.text.length), bad)\n }\n }\n\n var textNode = node.nodeType == 3 ? node : null, topNode = node;\n if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {\n textNode = node.firstChild;\n if (offset) { offset = textNode.nodeValue.length; }\n }\n while (topNode.parentNode != wrapper) { topNode = topNode.parentNode; }\n var measure = lineView.measure, maps = measure.maps;\n\n function find(textNode, topNode, offset) {\n for (var i = -1; i < (maps ? maps.length : 0); i++) {\n var map$$1 = i < 0 ? measure.map : maps[i];\n for (var j = 0; j < map$$1.length; j += 3) {\n var curNode = map$$1[j + 2];\n if (curNode == textNode || curNode == topNode) {\n var line = lineNo(i < 0 ? lineView.line : lineView.rest[i]);\n var ch = map$$1[j] + offset;\n if (offset < 0 || curNode != textNode) { ch = map$$1[j + (offset ? 1 : 0)]; }\n return Pos(line, ch)\n }\n }\n }\n }\n var found = find(textNode, topNode, offset);\n if (found) { return badPos(found, bad) }\n\n // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems\n for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {\n found = find(after, after.firstChild, 0);\n if (found)\n { return badPos(Pos(found.line, found.ch - dist), bad) }\n else\n { dist += after.textContent.length; }\n }\n for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {\n found = find(before, before.firstChild, -1);\n if (found)\n { return badPos(Pos(found.line, found.ch + dist$1), bad) }\n else\n { dist$1 += before.textContent.length; }\n }\n }\n\n // TEXTAREA INPUT STYLE\n\n var TextareaInput = function(cm) {\n this.cm = cm;\n // See input.poll and input.reset\n this.prevInput = \"\";\n\n // Flag that indicates whether we expect input to appear real soon\n // now (after some event like 'keypress' or 'input') and are\n // polling intensively.\n this.pollingFast = false;\n // Self-resetting timeout for the poller\n this.polling = new Delayed();\n // Used to work around IE issue with selection being forgotten when focus moves away from textarea\n this.hasSelection = false;\n this.composing = null;\n };\n\n TextareaInput.prototype.init = function (display) {\n var this$1 = this;\n\n var input = this, cm = this.cm;\n this.createField(display);\n var te = this.textarea;\n\n display.wrapper.insertBefore(this.wrapper, display.wrapper.firstChild);\n\n // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)\n if (ios) { te.style.width = \"0px\"; }\n\n on(te, \"input\", function () {\n if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null; }\n input.poll();\n });\n\n on(te, \"paste\", function (e) {\n if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }\n\n cm.state.pasteIncoming = +new Date;\n input.fastPoll();\n });\n\n function prepareCopyCut(e) {\n if (signalDOMEvent(cm, e)) { return }\n if (cm.somethingSelected()) {\n setLastCopied({lineWise: false, text: cm.getSelections()});\n } else if (!cm.options.lineWiseCopyCut) {\n return\n } else {\n var ranges = copyableRanges(cm);\n setLastCopied({lineWise: true, text: ranges.text});\n if (e.type == \"cut\") {\n cm.setSelections(ranges.ranges, null, sel_dontScroll);\n } else {\n input.prevInput = \"\";\n te.value = ranges.text.join(\"\\n\");\n selectInput(te);\n }\n }\n if (e.type == \"cut\") { cm.state.cutIncoming = +new Date; }\n }\n on(te, \"cut\", prepareCopyCut);\n on(te, \"copy\", prepareCopyCut);\n\n on(display.scroller, \"paste\", function (e) {\n if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }\n if (!te.dispatchEvent) {\n cm.state.pasteIncoming = +new Date;\n input.focus();\n return\n }\n\n // Pass the `paste` event to the textarea so it's handled by its event listener.\n var event = new Event(\"paste\");\n event.clipboardData = e.clipboardData;\n te.dispatchEvent(event);\n });\n\n // Prevent normal selection in the editor (we handle our own)\n on(display.lineSpace, \"selectstart\", function (e) {\n if (!eventInWidget(display, e)) { e_preventDefault(e); }\n });\n\n on(te, \"compositionstart\", function () {\n var start = cm.getCursor(\"from\");\n if (input.composing) { input.composing.range.clear(); }\n input.composing = {\n start: start,\n range: cm.markText(start, cm.getCursor(\"to\"), {className: \"CodeMirror-composing\"})\n };\n });\n on(te, \"compositionend\", function () {\n if (input.composing) {\n input.poll();\n input.composing.range.clear();\n input.composing = null;\n }\n });\n };\n\n TextareaInput.prototype.createField = function (_display) {\n // Wraps and hides input textarea\n this.wrapper = hiddenTextarea();\n // The semihidden textarea that is focused when the editor is\n // focused, and receives input.\n this.textarea = this.wrapper.firstChild;\n };\n\n TextareaInput.prototype.prepareSelection = function () {\n // Redraw the selection and/or cursor\n var cm = this.cm, display = cm.display, doc = cm.doc;\n var result = prepareSelection(cm);\n\n // Move the hidden textarea near the cursor to prevent scrolling artifacts\n if (cm.options.moveInputWithCursor) {\n var headPos = cursorCoords(cm, doc.sel.primary().head, \"div\");\n var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect();\n result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,\n headPos.top + lineOff.top - wrapOff.top));\n result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,\n headPos.left + lineOff.left - wrapOff.left));\n }\n\n return result\n };\n\n TextareaInput.prototype.showSelection = function (drawn) {\n var cm = this.cm, display = cm.display;\n removeChildrenAndAdd(display.cursorDiv, drawn.cursors);\n removeChildrenAndAdd(display.selectionDiv, drawn.selection);\n if (drawn.teTop != null) {\n this.wrapper.style.top = drawn.teTop + \"px\";\n this.wrapper.style.left = drawn.teLeft + \"px\";\n }\n };\n\n // Reset the input to correspond to the selection (or to be empty,\n // when not typing and nothing is selected)\n TextareaInput.prototype.reset = function (typing) {\n if (this.contextMenuPending || this.composing) { return }\n var cm = this.cm;\n if (cm.somethingSelected()) {\n this.prevInput = \"\";\n var content = cm.getSelection();\n this.textarea.value = content;\n if (cm.state.focused) { selectInput(this.textarea); }\n if (ie && ie_version >= 9) { this.hasSelection = content; }\n } else if (!typing) {\n this.prevInput = this.textarea.value = \"\";\n if (ie && ie_version >= 9) { this.hasSelection = null; }\n }\n };\n\n TextareaInput.prototype.getField = function () { return this.textarea };\n\n TextareaInput.prototype.supportsTouch = function () { return false };\n\n TextareaInput.prototype.focus = function () {\n if (this.cm.options.readOnly != \"nocursor\" && (!mobile || activeElt() != this.textarea)) {\n try { this.textarea.focus(); }\n catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM\n }\n };\n\n TextareaInput.prototype.blur = function () { this.textarea.blur(); };\n\n TextareaInput.prototype.resetPosition = function () {\n this.wrapper.style.top = this.wrapper.style.left = 0;\n };\n\n TextareaInput.prototype.receivedFocus = function () { this.slowPoll(); };\n\n // Poll for input changes, using the normal rate of polling. This\n // runs as long as the editor is focused.\n TextareaInput.prototype.slowPoll = function () {\n var this$1 = this;\n\n if (this.pollingFast) { return }\n this.polling.set(this.cm.options.pollInterval, function () {\n this$1.poll();\n if (this$1.cm.state.focused) { this$1.slowPoll(); }\n });\n };\n\n // When an event has just come in that is likely to add or change\n // something in the input textarea, we poll faster, to ensure that\n // the change appears on the screen quickly.\n TextareaInput.prototype.fastPoll = function () {\n var missed = false, input = this;\n input.pollingFast = true;\n function p() {\n var changed = input.poll();\n if (!changed && !missed) {missed = true; input.polling.set(60, p);}\n else {input.pollingFast = false; input.slowPoll();}\n }\n input.polling.set(20, p);\n };\n\n // Read input from the textarea, and update the document to match.\n // When something is selected, it is present in the textarea, and\n // selected (unless it is huge, in which case a placeholder is\n // used). When nothing is selected, the cursor sits after previously\n // seen text (can be empty), which is stored in prevInput (we must\n // not reset the textarea when typing, because that breaks IME).\n TextareaInput.prototype.poll = function () {\n var this$1 = this;\n\n var cm = this.cm, input = this.textarea, prevInput = this.prevInput;\n // Since this is called a *lot*, try to bail out as cheaply as\n // possible when it is clear that nothing happened. hasSelection\n // will be the case when there is a lot of text in the textarea,\n // in which case reading its value would be expensive.\n if (this.contextMenuPending || !cm.state.focused ||\n (hasSelection(input) && !prevInput && !this.composing) ||\n cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)\n { return false }\n\n var text = input.value;\n // If nothing changed, bail.\n if (text == prevInput && !cm.somethingSelected()) { return false }\n // Work around nonsensical selection resetting in IE9/10, and\n // inexplicable appearance of private area unicode characters on\n // some key combos in Mac (#2689).\n if (ie && ie_version >= 9 && this.hasSelection === text ||\n mac && /[\\uf700-\\uf7ff]/.test(text)) {\n cm.display.input.reset();\n return false\n }\n\n if (cm.doc.sel == cm.display.selForContextMenu) {\n var first = text.charCodeAt(0);\n if (first == 0x200b && !prevInput) { prevInput = \"\\u200b\"; }\n if (first == 0x21da) { this.reset(); return this.cm.execCommand(\"undo\") }\n }\n // Find the part of the input that is actually new\n var same = 0, l = Math.min(prevInput.length, text.length);\n while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same; }\n\n runInOp(cm, function () {\n applyTextInput(cm, text.slice(same), prevInput.length - same,\n null, this$1.composing ? \"*compose\" : null);\n\n // Don't leave long text in the textarea, since it makes further polling slow\n if (text.length > 1000 || text.indexOf(\"\\n\") > -1) { input.value = this$1.prevInput = \"\"; }\n else { this$1.prevInput = text; }\n\n if (this$1.composing) {\n this$1.composing.range.clear();\n this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor(\"to\"),\n {className: \"CodeMirror-composing\"});\n }\n });\n return true\n };\n\n TextareaInput.prototype.ensurePolled = function () {\n if (this.pollingFast && this.poll()) { this.pollingFast = false; }\n };\n\n TextareaInput.prototype.onKeyPress = function () {\n if (ie && ie_version >= 9) { this.hasSelection = null; }\n this.fastPoll();\n };\n\n TextareaInput.prototype.onContextMenu = function (e) {\n var input = this, cm = input.cm, display = cm.display, te = input.textarea;\n if (input.contextMenuPending) { input.contextMenuPending(); }\n var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop;\n if (!pos || presto) { return } // Opera is difficult.\n\n // Reset the current text selection only if the click is done outside of the selection\n // and 'resetSelectionOnContextMenu' option is true.\n var reset = cm.options.resetSelectionOnContextMenu;\n if (reset && cm.doc.sel.contains(pos) == -1)\n { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll); }\n\n var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText;\n var wrapperBox = input.wrapper.offsetParent.getBoundingClientRect();\n input.wrapper.style.cssText = \"position: static\";\n te.style.cssText = \"position: absolute; width: 30px; height: 30px;\\n top: \" + (e.clientY - wrapperBox.top - 5) + \"px; left: \" + (e.clientX - wrapperBox.left - 5) + \"px;\\n z-index: 1000; background: \" + (ie ? \"rgba(255, 255, 255, .05)\" : \"transparent\") + \";\\n outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);\";\n var oldScrollY;\n if (webkit) { oldScrollY = window.scrollY; } // Work around Chrome issue (#2712)\n display.input.focus();\n if (webkit) { window.scrollTo(null, oldScrollY); }\n display.input.reset();\n // Adds \"Select all\" to context menu in FF\n if (!cm.somethingSelected()) { te.value = input.prevInput = \" \"; }\n input.contextMenuPending = rehide;\n display.selForContextMenu = cm.doc.sel;\n clearTimeout(display.detectingSelectAll);\n\n // Select-all will be greyed out if there's nothing to select, so\n // this adds a zero-width space so that we can later check whether\n // it got selected.\n function prepareSelectAllHack() {\n if (te.selectionStart != null) {\n var selected = cm.somethingSelected();\n var extval = \"\\u200b\" + (selected ? te.value : \"\");\n te.value = \"\\u21da\"; // Used to catch context-menu undo\n te.value = extval;\n input.prevInput = selected ? \"\" : \"\\u200b\";\n te.selectionStart = 1; te.selectionEnd = extval.length;\n // Re-set this, in case some other handler touched the\n // selection in the meantime.\n display.selForContextMenu = cm.doc.sel;\n }\n }\n function rehide() {\n if (input.contextMenuPending != rehide) { return }\n input.contextMenuPending = false;\n input.wrapper.style.cssText = oldWrapperCSS;\n te.style.cssText = oldCSS;\n if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos); }\n\n // Try to detect the user choosing select-all\n if (te.selectionStart != null) {\n if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack(); }\n var i = 0, poll = function () {\n if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&\n te.selectionEnd > 0 && input.prevInput == \"\\u200b\") {\n operation(cm, selectAll)(cm);\n } else if (i++ < 10) {\n display.detectingSelectAll = setTimeout(poll, 500);\n } else {\n display.selForContextMenu = null;\n display.input.reset();\n }\n };\n display.detectingSelectAll = setTimeout(poll, 200);\n }\n }\n\n if (ie && ie_version >= 9) { prepareSelectAllHack(); }\n if (captureRightClick) {\n e_stop(e);\n var mouseup = function () {\n off(window, \"mouseup\", mouseup);\n setTimeout(rehide, 20);\n };\n on(window, \"mouseup\", mouseup);\n } else {\n setTimeout(rehide, 50);\n }\n };\n\n TextareaInput.prototype.readOnlyChanged = function (val) {\n if (!val) { this.reset(); }\n this.textarea.disabled = val == \"nocursor\";\n };\n\n TextareaInput.prototype.setUneditable = function () {};\n\n TextareaInput.prototype.needsContentAttribute = false;\n\n function fromTextArea(textarea, options) {\n options = options ? copyObj(options) : {};\n options.value = textarea.value;\n if (!options.tabindex && textarea.tabIndex)\n { options.tabindex = textarea.tabIndex; }\n if (!options.placeholder && textarea.placeholder)\n { options.placeholder = textarea.placeholder; }\n // Set autofocus to true if this textarea is focused, or if it has\n // autofocus and no other element is focused.\n if (options.autofocus == null) {\n var hasFocus = activeElt();\n options.autofocus = hasFocus == textarea ||\n textarea.getAttribute(\"autofocus\") != null && hasFocus == document.body;\n }\n\n function save() {textarea.value = cm.getValue();}\n\n var realSubmit;\n if (textarea.form) {\n on(textarea.form, \"submit\", save);\n // Deplorable hack to make the submit method do the right thing.\n if (!options.leaveSubmitMethodAlone) {\n var form = textarea.form;\n realSubmit = form.submit;\n try {\n var wrappedSubmit = form.submit = function () {\n save();\n form.submit = realSubmit;\n form.submit();\n form.submit = wrappedSubmit;\n };\n } catch(e) {}\n }\n }\n\n options.finishInit = function (cm) {\n cm.save = save;\n cm.getTextArea = function () { return textarea; };\n cm.toTextArea = function () {\n cm.toTextArea = isNaN; // Prevent this from being ran twice\n save();\n textarea.parentNode.removeChild(cm.getWrapperElement());\n textarea.style.display = \"\";\n if (textarea.form) {\n off(textarea.form, \"submit\", save);\n if (typeof textarea.form.submit == \"function\")\n { textarea.form.submit = realSubmit; }\n }\n };\n };\n\n textarea.style.display = \"none\";\n var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },\n options);\n return cm\n }\n\n function addLegacyProps(CodeMirror) {\n CodeMirror.off = off;\n CodeMirror.on = on;\n CodeMirror.wheelEventPixels = wheelEventPixels;\n CodeMirror.Doc = Doc;\n CodeMirror.splitLines = splitLinesAuto;\n CodeMirror.countColumn = countColumn;\n CodeMirror.findColumn = findColumn;\n CodeMirror.isWordChar = isWordCharBasic;\n CodeMirror.Pass = Pass;\n CodeMirror.signal = signal;\n CodeMirror.Line = Line;\n CodeMirror.changeEnd = changeEnd;\n CodeMirror.scrollbarModel = scrollbarModel;\n CodeMirror.Pos = Pos;\n CodeMirror.cmpPos = cmp;\n CodeMirror.modes = modes;\n CodeMirror.mimeModes = mimeModes;\n CodeMirror.resolveMode = resolveMode;\n CodeMirror.getMode = getMode;\n CodeMirror.modeExtensions = modeExtensions;\n CodeMirror.extendMode = extendMode;\n CodeMirror.copyState = copyState;\n CodeMirror.startState = startState;\n CodeMirror.innerMode = innerMode;\n CodeMirror.commands = commands;\n CodeMirror.keyMap = keyMap;\n CodeMirror.keyName = keyName;\n CodeMirror.isModifierKey = isModifierKey;\n CodeMirror.lookupKey = lookupKey;\n CodeMirror.normalizeKeyMap = normalizeKeyMap;\n CodeMirror.StringStream = StringStream;\n CodeMirror.SharedTextMarker = SharedTextMarker;\n CodeMirror.TextMarker = TextMarker;\n CodeMirror.LineWidget = LineWidget;\n CodeMirror.e_preventDefault = e_preventDefault;\n CodeMirror.e_stopPropagation = e_stopPropagation;\n CodeMirror.e_stop = e_stop;\n CodeMirror.addClass = addClass;\n CodeMirror.contains = contains;\n CodeMirror.rmClass = rmClass;\n CodeMirror.keyNames = keyNames;\n }\n\n // EDITOR CONSTRUCTOR\n\n defineOptions(CodeMirror);\n\n addEditorMethods(CodeMirror);\n\n // Set up methods on CodeMirror's prototype to redirect to the editor's document.\n var dontDelegate = \"iter insert remove copy getEditor constructor\".split(\" \");\n for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)\n { CodeMirror.prototype[prop] = (function(method) {\n return function() {return method.apply(this.doc, arguments)}\n })(Doc.prototype[prop]); } }\n\n eventMixin(Doc);\n CodeMirror.inputStyles = {\"textarea\": TextareaInput, \"contenteditable\": ContentEditableInput};\n\n // Extra arguments are stored as the mode's dependencies, which is\n // used by (legacy) mechanisms like loadmode.js to automatically\n // load a mode. (Preferred mechanism is the require/define calls.)\n CodeMirror.defineMode = function(name/*, mode, …*/) {\n if (!CodeMirror.defaults.mode && name != \"null\") { CodeMirror.defaults.mode = name; }\n defineMode.apply(this, arguments);\n };\n\n CodeMirror.defineMIME = defineMIME;\n\n // Minimal default mode.\n CodeMirror.defineMode(\"null\", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); });\n CodeMirror.defineMIME(\"text/plain\", \"null\");\n\n // EXTENSIONS\n\n CodeMirror.defineExtension = function (name, func) {\n CodeMirror.prototype[name] = func;\n };\n CodeMirror.defineDocExtension = function (name, func) {\n Doc.prototype[name] = func;\n };\n\n CodeMirror.fromTextArea = fromTextArea;\n\n addLegacyProps(CodeMirror);\n\n CodeMirror.version = \"5.45.0\";\n\n return CodeMirror;\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/codemirror/lib/codemirror.js\n// module id = 644\n// module chunks = 3 4 5 7 8 14","!function(t,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):t.dayjs=n()}(this,function(){\"use strict\";var t=\"millisecond\",n=\"second\",e=\"minute\",i=\"hour\",r=\"day\",s=\"week\",u=\"month\",a=\"quarter\",o=\"year\",h=/^(\\d{4})-?(\\d{1,2})-?(\\d{0,2})[^0-9]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?.?(\\d{1,3})?$/,f=/\\[([^\\]]+)]|Y{2,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,c=function(t,n,e){var i=String(t);return!i||i.length>=n?t:\"\"+Array(n+1-i.length).join(e)+t},d={s:c,z:function(t){var n=-t.utcOffset(),e=Math.abs(n),i=Math.floor(e/60),r=e%60;return(n<=0?\"+\":\"-\")+c(i,2,\"0\")+\":\"+c(r,2,\"0\")},m:function(t,n){var e=12*(n.year()-t.year())+(n.month()-t.month()),i=t.clone().add(e,u),r=n-i<0,s=t.clone().add(e+(r?-1:1),u);return Number(-(e+(n-i)/(r?i-s:s-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(h){return{M:u,y:o,w:s,d:r,h:i,m:e,s:n,ms:t,Q:a}[h]||String(h||\"\").toLowerCase().replace(/s$/,\"\")},u:function(t){return void 0===t}},$={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\")},l=\"en\",m={};m[l]=$;var y=function(t){return t instanceof S},M=function(t,n,e){var i;if(!t)return null;if(\"string\"==typeof t)m[t]&&(i=t),n&&(m[t]=n,i=t);else{var r=t.name;m[r]=t,i=r}return e||(l=i),i},g=function(t,n,e){if(y(t))return t.clone();var i=n?\"string\"==typeof n?{format:n,pl:e}:n:{};return i.date=t,new S(i)},D=d;D.l=M,D.i=y,D.w=function(t,n){return g(t,{locale:n.$L,utc:n.$u})};var S=function(){function c(t){this.$L=this.$L||M(t.locale,null,!0)||l,this.parse(t)}var d=c.prototype;return d.parse=function(t){this.$d=function(t){var n=t.date,e=t.utc;if(null===n)return new Date(NaN);if(D.u(n))return new Date;if(n instanceof Date)return new Date(n);if(\"string\"==typeof n&&!/Z$/i.test(n)){var i=n.match(h);if(i)return e?new Date(Date.UTC(i[1],i[2]-1,i[3]||1,i[4]||0,i[5]||0,i[6]||0,i[7]||0)):new Date(i[1],i[2]-1,i[3]||1,i[4]||0,i[5]||0,i[6]||0,i[7]||0)}return new Date(n)}(t),this.init()},d.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},d.$utils=function(){return D},d.isValid=function(){return!(\"Invalid Date\"===this.$d.toString())},d.isSame=function(t,n){var e=g(t);return this.startOf(n)<=e&&e<=this.endOf(n)},d.isAfter=function(t,n){return g(t) tag\n\n// load the styles\nvar content = require(\"!!../../../../../node_modules/css-loader/index.js?minimize!../../../../../node_modules/vue-loader/lib/style-compiler/index.js?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-16cfa774\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!../../../../../node_modules/sass-loader/lib/loader.js!../../../../../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./spin.vue\");\nif(typeof content === 'string') content = [[module.id, content, '']];\nif(content.locals) module.exports = content.locals;\n// add the styles to the DOM\nvar update = require(\"!../../../../../node_modules/vue-loader/node_modules/vue-style-loader/lib/addStylesClient.js\")(\"3d76622a\", content, true, {});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/node_modules/vue-style-loader!./node_modules/css-loader?minimize!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-16cfa774\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/lib/loader.js!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/js/module/components/spin/spin.vue\n// module id = 647\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 26","exports = module.exports = require(\"../../../../../node_modules/css-loader/lib/css-base.js\")(false);\n// imports\n\n\n// module\nexports.push([module.id, \"#spin-model{position:fixed;left:20px;top:80px;background:#fff;z-index:99;border-radius:3px}#spin-model .svg-box{width:100px;height:66px;position:absolute;left:50%;top:50%;margin-left:-50px;margin-top:-33px;text-align:center}#spin-model .svg-box .sp1{display:block;font-size:12px;color:#999;padding-top:4px}#spin-model.spin-sp1{width:calc(100% - 40px);height:calc(100% - 100px)}#spin-model.spin-sp2{width:calc(100% - 240px);height:calc(100% - 100px);left:220px}\", \"\"]);\n\n// exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/css-loader?minimize!./node_modules/vue-loader/lib/style-compiler?{\"vue\":true,\"id\":\"data-v-16cfa774\",\"scoped\":false,\"hasInlineConfig\":false}!./node_modules/sass-loader/lib/loader.js!./node_modules/vue-loader/lib/selector.js?type=styles&index=0!./src/js/module/components/spin/spin.vue\n// module id = 648\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 26","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return (_vm.isSpin)?_c('div',{class:_vm.isLeft ? 'spin-sp2' : 'spin-sp1',attrs:{\"id\":\"spin-model\"}},[_c('div',{staticClass:\"svg-box\"},[_c('svg',{staticClass:\"lds-gears\",staticStyle:{\"background\":\"none\"},attrs:{\"width\":\"54px\",\"height\":\"54px\",\"xmlns\":\"http://www.w3.org/2000/svg\",\"xmlns:xlink\":\"http://www.w3.org/1999/xlink\",\"viewBox\":\"0 0 100 100\",\"preserveAspectRatio\":\"xMidYMid\"}},[_c('g',{attrs:{\"transform\":\"translate(50 50)\"}},[_c('g',{attrs:{\"transform\":\"translate(-19 -19) scale(0.6)\"}},[_c('g',{attrs:{\"transform\":\"rotate(107.866)\"}},[_c('animateTransform',{attrs:{\"attributeName\":\"transform\",\"type\":\"rotate\",\"values\":\"0;360\",\"keyTimes\":\"0;1\",\"dur\":\"1s\",\"begin\":\"0s\",\"repeatCount\":\"indefinite\"}}),_c('path',{attrs:{\"d\":\"M37.3496987939662 -7 L47.3496987939662 -7 L47.3496987939662 7 L37.3496987939662 7 A38 38 0 0 1 31.359972760794346 21.46047782418268 L31.359972760794346 21.46047782418268 L38.431040572659825 28.531545636048154 L28.531545636048154 38.431040572659825 L21.46047782418268 31.359972760794346 A38 38 0 0 1 7.0000000000000036 37.3496987939662 L7.0000000000000036 37.3496987939662 L7.000000000000004 47.3496987939662 L-6.999999999999999 47.3496987939662 L-7 37.3496987939662 A38 38 0 0 1 -21.46047782418268 31.35997276079435 L-21.46047782418268 31.35997276079435 L-28.531545636048154 38.431040572659825 L-38.43104057265982 28.531545636048158 L-31.359972760794346 21.460477824182682 A38 38 0 0 1 -37.3496987939662 7.000000000000007 L-37.3496987939662 7.000000000000007 L-47.3496987939662 7.000000000000008 L-47.3496987939662 -6.9999999999999964 L-37.3496987939662 -6.999999999999997 A38 38 0 0 1 -31.35997276079435 -21.460477824182675 L-31.35997276079435 -21.460477824182675 L-38.431040572659825 -28.531545636048147 L-28.53154563604818 -38.4310405726598 L-21.4604778241827 -31.35997276079433 A38 38 0 0 1 -6.999999999999992 -37.3496987939662 L-6.999999999999992 -37.3496987939662 L-6.999999999999994 -47.3496987939662 L6.999999999999977 -47.3496987939662 L6.999999999999979 -37.3496987939662 A38 38 0 0 1 21.460477824182686 -31.359972760794342 L21.460477824182686 -31.359972760794342 L28.531545636048158 -38.43104057265982 L38.4310405726598 -28.53154563604818 L31.35997276079433 -21.4604778241827 A38 38 0 0 1 37.3496987939662 -6.999999999999995 M0 -23A23 23 0 1 0 0 23 A23 23 0 1 0 0 -23\",\"fill\":\"#0097e0\"}})],1)]),_vm._v(\" \"),_c('g',{attrs:{\"transform\":\"translate(19 19) scale(0.6)\"}},[_c('g',{attrs:{\"transform\":\"rotate(229.634)\"}},[_c('animateTransform',{attrs:{\"attributeName\":\"transform\",\"type\":\"rotate\",\"values\":\"360;0\",\"keyTimes\":\"0;1\",\"dur\":\"1s\",\"begin\":\"-0.0625s\",\"repeatCount\":\"indefinite\"}}),_c('path',{attrs:{\"d\":\"M37.3496987939662 -7 L47.3496987939662 -7 L47.3496987939662 7 L37.3496987939662 7 A38 38 0 0 1 31.359972760794346 21.46047782418268 L31.359972760794346 21.46047782418268 L38.431040572659825 28.531545636048154 L28.531545636048154 38.431040572659825 L21.46047782418268 31.359972760794346 A38 38 0 0 1 7.0000000000000036 37.3496987939662 L7.0000000000000036 37.3496987939662 L7.000000000000004 47.3496987939662 L-6.999999999999999 47.3496987939662 L-7 37.3496987939662 A38 38 0 0 1 -21.46047782418268 31.35997276079435 L-21.46047782418268 31.35997276079435 L-28.531545636048154 38.431040572659825 L-38.43104057265982 28.531545636048158 L-31.359972760794346 21.460477824182682 A38 38 0 0 1 -37.3496987939662 7.000000000000007 L-37.3496987939662 7.000000000000007 L-47.3496987939662 7.000000000000008 L-47.3496987939662 -6.9999999999999964 L-37.3496987939662 -6.999999999999997 A38 38 0 0 1 -31.35997276079435 -21.460477824182675 L-31.35997276079435 -21.460477824182675 L-38.431040572659825 -28.531545636048147 L-28.53154563604818 -38.4310405726598 L-21.4604778241827 -31.35997276079433 A38 38 0 0 1 -6.999999999999992 -37.3496987939662 L-6.999999999999992 -37.3496987939662 L-6.999999999999994 -47.3496987939662 L6.999999999999977 -47.3496987939662 L6.999999999999979 -37.3496987939662 A38 38 0 0 1 21.460477824182686 -31.359972760794342 L21.460477824182686 -31.359972760794342 L28.531545636048158 -38.43104057265982 L38.4310405726598 -28.53154563604818 L31.35997276079433 -21.4604778241827 A38 38 0 0 1 37.3496987939662 -6.999999999999995 M0 -23A23 23 0 1 0 0 23 A23 23 0 1 0 0 -23\",\"fill\":\"#7f8b95\"}})],1)])])]),_vm._v(\" \"),_c('span',{staticClass:\"sp1\"},[_vm._v(_vm._s(_vm.$t('正在努力加载中...')))])])]):_vm._e()}\nvar staticRenderFns = []\nvar esExports = { render: render, staticRenderFns: staticRenderFns }\nexport default esExports\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/vue-loader/lib/template-compiler?{\"id\":\"data-v-16cfa774\",\"hasScoped\":false,\"buble\":{\"transforms\":{}}}!./node_modules/vue-loader/lib/selector.js?type=template&index=0!./src/js/module/components/spin/spin.vue\n// module id = 649\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 26","function injectStyle (ssrContext) {\n require(\"!!vue-loader/node_modules/vue-style-loader!css-loader?minimize!../../../../../node_modules/vue-loader/lib/style-compiler/index?{\\\"vue\\\":true,\\\"id\\\":\\\"data-v-f72bdd3a\\\",\\\"scoped\\\":false,\\\"hasInlineConfig\\\":false}!sass-loader!../../../../../node_modules/vue-loader/lib/selector?type=styles&index=0!./secondaryMenu.vue\")\n}\nvar normalizeComponent = require(\"!../../../../../node_modules/vue-loader/lib/component-normalizer\")\n/* script */\nexport * from \"!!babel-loader!../../../../../node_modules/vue-loader/lib/selector?type=script&index=0!./secondaryMenu.vue\"\nimport __vue_script__ from \"!!babel-loader!../../../../../node_modules/vue-loader/lib/selector?type=script&index=0!./secondaryMenu.vue\"\n/* template */\nimport __vue_template__ from \"!!../../../../../node_modules/vue-loader/lib/template-compiler/index?{\\\"id\\\":\\\"data-v-f72bdd3a\\\",\\\"hasScoped\\\":false,\\\"buble\\\":{\\\"transforms\\\":{}}}!../../../../../node_modules/vue-loader/lib/selector?type=template&index=0!./secondaryMenu.vue\"\n/* template functional */\nvar __vue_template_functional__ = false\n/* styles */\nvar __vue_styles__ = injectStyle\n/* scopeId */\nvar __vue_scopeId__ = null\n/* moduleIdentifier (server only) */\nvar __vue_module_identifier__ = null\nvar Component = normalizeComponent(\n __vue_script__,\n __vue_template__,\n __vue_template_functional__,\n __vue_styles__,\n __vue_scopeId__,\n __vue_module_identifier__\n)\n\nexport default Component.exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./src/js/module/components/secondaryMenu/secondaryMenu.vue\n// module id = 654\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 25 27","// style-loader: Adds some css to the DOM by adding a \n\n\n\n// WEBPACK FOOTER //\n// src/js/conf/home/pages/projects/pages/definition/pages/list/_source/email.vue","\n
\n\n\n\n\n\n\n\n// WEBPACK FOOTER //\n// src/js/module/components/priority/priority.vue","/*\n * Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport _ from 'lodash'\nimport $ from 'jquery'\nimport i18n from '@/module/i18n'\nimport store from '@/conf/home/store'\n\n/**\n * Node, to array\n */\nconst rtTargetarrArr = (id) => {\n let a = $(`#${id}`).attr('data-targetarr')\n return a ? a.split(',') : []\n}\n\n/**\n * Store node id to targetarr\n */\nconst saveTargetarr = (valId, domId) => {\n let $target = $(`#${domId}`)\n let targetStr = $target.attr('data-targetarr') ? $target.attr('data-targetarr') + `,${valId}` : `${valId}`\n $target.attr('data-targetarr', targetStr)\n}\n\nconst rtBantpl = () => {\n return ``\n}\n\n/**\n * return node html\n */\nconst rtTasksTpl = ({ id, name, x, y, targetarr, isAttachment, taskType,runFlag }) => {\n let tpl = ``\n tpl += `
\n\n\n\n\n\n\n\n// WEBPACK FOOTER //\n// src/js/conf/home/pages/projects/pages/definition/pages/list/_source/start.vue","/**\n * jsBezier\n *\n * Copyright (c) 2010 - 2017 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * licensed under the MIT license.\n *\n * a set of Bezier curve functions that deal with Beziers, used by jsPlumb, and perhaps useful for other people. These functions work with Bezier\n * curves of arbitrary degree.\n *\n * - functions are all in the 'jsBezier' namespace.\n *\n * - all input points should be in the format {x:.., y:..}. all output points are in this format too.\n *\n * - all input curves should be in the format [ {x:.., y:..}, {x:.., y:..}, {x:.., y:..}, {x:.., y:..} ]\n *\n * - 'location' as used as an input here refers to a decimal in the range 0-1 inclusive, which indicates a point some proportion along the length\n * of the curve. location as output has the same format and meaning.\n *\n *\n * Function List:\n * --------------\n *\n * distanceFromCurve(point, curve)\n *\n * \tCalculates the distance that the given point lies from the given Bezier. Note that it is computed relative to the center of the Bezier,\n * so if you have stroked the curve with a wide pen you may wish to take that into account! The distance returned is relative to the values\n * of the curve and the point - it will most likely be pixels.\n *\n * gradientAtPoint(curve, location)\n *\n * \tCalculates the gradient to the curve at the given location, as a decimal between 0 and 1 inclusive.\n *\n * gradientAtPointAlongCurveFrom (curve, location)\n *\n *\tCalculates the gradient at the point on the given curve that is 'distance' units from location.\n *\n * nearestPointOnCurve(point, curve)\n *\n *\tCalculates the nearest point to the given point on the given curve. The return value of this is a JS object literal, containing both the\n *point's coordinates and also the 'location' of the point (see above), for example: { point:{x:551,y:150}, location:0.263365 }.\n *\n * pointOnCurve(curve, location)\n *\n * \tCalculates the coordinates of the point on the given Bezier curve at the given location.\n *\n * pointAlongCurveFrom(curve, location, distance)\n *\n * \tCalculates the coordinates of the point on the given curve that is 'distance' units from location. 'distance' should be in the same coordinate\n * space as that used to construct the Bezier curve. For an HTML Canvas usage, for example, distance would be a measure of pixels.\n *\n * locationAlongCurveFrom(curve, location, distance)\n *\n * \tCalculates the location on the given curve that is 'distance' units from location. 'distance' should be in the same coordinate\n * space as that used to construct the Bezier curve. For an HTML Canvas usage, for example, distance would be a measure of pixels.\n *\n * perpendicularToCurveAt(curve, location, length, distance)\n *\n * \tCalculates the perpendicular to the given curve at the given location. length is the length of the line you wish for (it will be centered\n * on the point at 'location'). distance is optional, and allows you to specify a point along the path from the given location as the center of\n * the perpendicular returned. The return value of this is an array of two points: [ {x:...,y:...}, {x:...,y:...} ].\n *\n *\n */\n\n(function() {\n\n var root = this;\n\n if(typeof Math.sgn == \"undefined\") {\n Math.sgn = function(x) { return x == 0 ? 0 : x > 0 ? 1 :-1; };\n }\n\n var Vectors = {\n subtract \t: \tfunction(v1, v2) { return {x:v1.x - v2.x, y:v1.y - v2.y }; },\n dotProduct\t: \tfunction(v1, v2) { return (v1.x * v2.x) + (v1.y * v2.y); },\n square\t\t:\tfunction(v) { return Math.sqrt((v.x * v.x) + (v.y * v.y)); },\n scale\t\t:\tfunction(v, s) { return {x:v.x * s, y:v.y * s }; }\n },\n\n maxRecursion = 64,\n flatnessTolerance = Math.pow(2.0,-maxRecursion-1);\n\n /**\n * Calculates the distance that the point lies from the curve.\n *\n * @param point a point in the form {x:567, y:3342}\n * @param curve a Bezier curve in the form [{x:..., y:...}, {x:..., y:...}, {x:..., y:...}, {x:..., y:...}]. note that this is currently\n * hardcoded to assume cubiz beziers, but would be better off supporting any degree.\n * @return a JS object literal containing location and distance, for example: {location:0.35, distance:10}. Location is analogous to the location\n * argument you pass to the pointOnPath function: it is a ratio of distance travelled along the curve. Distance is the distance in pixels from\n * the point to the curve.\n */\n var _distanceFromCurve = function(point, curve) {\n var candidates = [],\n w = _convertToBezier(point, curve),\n degree = curve.length - 1, higherDegree = (2 * degree) - 1,\n numSolutions = _findRoots(w, higherDegree, candidates, 0),\n v = Vectors.subtract(point, curve[0]), dist = Vectors.square(v), t = 0.0;\n\n for (var i = 0; i < numSolutions; i++) {\n v = Vectors.subtract(point, _bezier(curve, degree, candidates[i], null, null));\n var newDist = Vectors.square(v);\n if (newDist < dist) {\n dist = newDist;\n t = candidates[i];\n }\n }\n v = Vectors.subtract(point, curve[degree]);\n newDist = Vectors.square(v);\n if (newDist < dist) {\n dist = newDist;\n t = 1.0;\n }\n return {location:t, distance:dist};\n };\n /**\n * finds the nearest point on the curve to the given point.\n */\n var _nearestPointOnCurve = function(point, curve) {\n var td = _distanceFromCurve(point, curve);\n return {point:_bezier(curve, curve.length - 1, td.location, null, null), location:td.location};\n };\n var _convertToBezier = function(point, curve) {\n var degree = curve.length - 1, higherDegree = (2 * degree) - 1,\n c = [], d = [], cdTable = [], w = [],\n z = [ [1.0, 0.6, 0.3, 0.1], [0.4, 0.6, 0.6, 0.4], [0.1, 0.3, 0.6, 1.0] ];\n\n for (var i = 0; i <= degree; i++) c[i] = Vectors.subtract(curve[i], point);\n for (var i = 0; i <= degree - 1; i++) {\n d[i] = Vectors.subtract(curve[i+1], curve[i]);\n d[i] = Vectors.scale(d[i], 3.0);\n }\n for (var row = 0; row <= degree - 1; row++) {\n for (var column = 0; column <= degree; column++) {\n if (!cdTable[row]) cdTable[row] = [];\n cdTable[row][column] = Vectors.dotProduct(d[row], c[column]);\n }\n }\n for (i = 0; i <= higherDegree; i++) {\n if (!w[i]) w[i] = [];\n w[i].y = 0.0;\n w[i].x = parseFloat(i) / higherDegree;\n }\n var n = degree, m = degree-1;\n for (var k = 0; k <= n + m; k++) {\n var lb = Math.max(0, k - m),\n ub = Math.min(k, n);\n for (i = lb; i <= ub; i++) {\n var j = k - i;\n w[i+j].y += cdTable[j][i] * z[j][i];\n }\n }\n return w;\n };\n /**\n * counts how many roots there are.\n */\n var _findRoots = function(w, degree, t, depth) {\n var left = [], right = [],\n left_count, right_count,\n left_t = [], right_t = [];\n\n switch (_getCrossingCount(w, degree)) {\n case 0 : {\n return 0;\n }\n case 1 : {\n if (depth >= maxRecursion) {\n t[0] = (w[0].x + w[degree].x) / 2.0;\n return 1;\n }\n if (_isFlatEnough(w, degree)) {\n t[0] = _computeXIntercept(w, degree);\n return 1;\n }\n break;\n }\n }\n _bezier(w, degree, 0.5, left, right);\n left_count = _findRoots(left, degree, left_t, depth+1);\n right_count = _findRoots(right, degree, right_t, depth+1);\n for (var i = 0; i < left_count; i++) t[i] = left_t[i];\n for (var i = 0; i < right_count; i++) t[i+left_count] = right_t[i];\n return (left_count+right_count);\n };\n var _getCrossingCount = function(curve, degree) {\n var n_crossings = 0, sign, old_sign;\n sign = old_sign = Math.sgn(curve[0].y);\n for (var i = 1; i <= degree; i++) {\n sign = Math.sgn(curve[i].y);\n if (sign != old_sign) n_crossings++;\n old_sign = sign;\n }\n return n_crossings;\n };\n var _isFlatEnough = function(curve, degree) {\n var error,\n intercept_1, intercept_2, left_intercept, right_intercept,\n a, b, c, det, dInv, a1, b1, c1, a2, b2, c2;\n a = curve[0].y - curve[degree].y;\n b = curve[degree].x - curve[0].x;\n c = curve[0].x * curve[degree].y - curve[degree].x * curve[0].y;\n\n var max_distance_above, max_distance_below;\n max_distance_above = max_distance_below = 0.0;\n\n for (var i = 1; i < degree; i++) {\n var value = a * curve[i].x + b * curve[i].y + c;\n if (value > max_distance_above)\n max_distance_above = value;\n else if (value < max_distance_below)\n max_distance_below = value;\n }\n\n a1 = 0.0; b1 = 1.0; c1 = 0.0; a2 = a; b2 = b;\n c2 = c - max_distance_above;\n det = a1 * b2 - a2 * b1;\n dInv = 1.0/det;\n intercept_1 = (b1 * c2 - b2 * c1) * dInv;\n a2 = a; b2 = b; c2 = c - max_distance_below;\n det = a1 * b2 - a2 * b1;\n dInv = 1.0/det;\n intercept_2 = (b1 * c2 - b2 * c1) * dInv;\n left_intercept = Math.min(intercept_1, intercept_2);\n right_intercept = Math.max(intercept_1, intercept_2);\n error = right_intercept - left_intercept;\n return (error < flatnessTolerance)? 1 : 0;\n };\n var _computeXIntercept = function(curve, degree) {\n var XLK = 1.0, YLK = 0.0,\n XNM = curve[degree].x - curve[0].x, YNM = curve[degree].y - curve[0].y,\n XMK = curve[0].x - 0.0, YMK = curve[0].y - 0.0,\n det = XNM*YLK - YNM*XLK, detInv = 1.0/det,\n S = (XNM*YMK - YNM*XMK) * detInv;\n return 0.0 + XLK * S;\n };\n var _bezier = function(curve, degree, t, left, right) {\n var temp = [[]];\n for (var j =0; j <= degree; j++) temp[0][j] = curve[j];\n for (var i = 1; i <= degree; i++) {\n for (var j =0 ; j <= degree - i; j++) {\n if (!temp[i]) temp[i] = [];\n if (!temp[i][j]) temp[i][j] = {};\n temp[i][j].x = (1.0 - t) * temp[i-1][j].x + t * temp[i-1][j+1].x;\n temp[i][j].y = (1.0 - t) * temp[i-1][j].y + t * temp[i-1][j+1].y;\n }\n }\n if (left != null)\n for (j = 0; j <= degree; j++) left[j] = temp[j][0];\n if (right != null)\n for (j = 0; j <= degree; j++) right[j] = temp[degree-j][j];\n\n return (temp[degree][0]);\n };\n\n var _curveFunctionCache = {};\n var _getCurveFunctions = function(order) {\n var fns = _curveFunctionCache[order];\n if (!fns) {\n fns = [];\n var f_term = function() { return function(t) { return Math.pow(t, order); }; },\n l_term = function() { return function(t) { return Math.pow((1-t), order); }; },\n c_term = function(c) { return function(t) { return c; }; },\n t_term = function() { return function(t) { return t; }; },\n one_minus_t_term = function() { return function(t) { return 1-t; }; },\n _termFunc = function(terms) {\n return function(t) {\n var p = 1;\n for (var i = 0; i < terms.length; i++) p = p * terms[i](t);\n return p;\n };\n };\n\n fns.push(new f_term()); // first is t to the power of the curve order\n for (var i = 1; i < order; i++) {\n var terms = [new c_term(order)];\n for (var j = 0 ; j < (order - i); j++) terms.push(new t_term());\n for (var j = 0 ; j < i; j++) terms.push(new one_minus_t_term());\n fns.push(new _termFunc(terms));\n }\n fns.push(new l_term()); // last is (1-t) to the power of the curve order\n\n _curveFunctionCache[order] = fns;\n }\n\n return fns;\n };\n\n\n /**\n * calculates a point on the curve, for a Bezier of arbitrary order.\n * @param curve an array of control points, eg [{x:10,y:20}, {x:50,y:50}, {x:100,y:100}, {x:120,y:100}]. For a cubic bezier this should have four points.\n * @param location a decimal indicating the distance along the curve the point should be located at. this is the distance along the curve as it travels, taking the way it bends into account. should be a number from 0 to 1, inclusive.\n */\n var _pointOnPath = function(curve, location) {\n var cc = _getCurveFunctions(curve.length - 1),\n _x = 0, _y = 0;\n for (var i = 0; i < curve.length ; i++) {\n _x = _x + (curve[i].x * cc[i](location));\n _y = _y + (curve[i].y * cc[i](location));\n }\n\n return {x:_x, y:_y};\n };\n\n var _dist = function(p1,p2) {\n return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));\n };\n\n var _isPoint = function(curve) {\n return curve[0].x === curve[1].x && curve[0].y === curve[1].y;\n };\n\n /**\n * finds the point that is 'distance' along the path from 'location'. this method returns both the x,y location of the point and also\n * its 'location' (proportion of travel along the path); the method below - _pointAlongPathFrom - calls this method and just returns the\n * point.\n */\n var _pointAlongPath = function(curve, location, distance) {\n\n if (_isPoint(curve)) {\n return {\n point:curve[0],\n location:location\n };\n }\n\n var prev = _pointOnPath(curve, location),\n tally = 0,\n curLoc = location,\n direction = distance > 0 ? 1 : -1,\n cur = null;\n\n while (tally < Math.abs(distance)) {\n curLoc += (0.005 * direction);\n cur = _pointOnPath(curve, curLoc);\n tally += _dist(cur, prev);\n prev = cur;\n }\n return {point:cur, location:curLoc};\n };\n\n var _length = function(curve) {\n if (_isPoint(curve)) return 0;\n\n var prev = _pointOnPath(curve, 0),\n tally = 0,\n curLoc = 0,\n direction = 1,\n cur = null;\n\n while (curLoc < 1) {\n curLoc += (0.005 * direction);\n cur = _pointOnPath(curve, curLoc);\n tally += _dist(cur, prev);\n prev = cur;\n }\n return tally;\n };\n\n /**\n * finds the point that is 'distance' along the path from 'location'.\n */\n var _pointAlongPathFrom = function(curve, location, distance) {\n return _pointAlongPath(curve, location, distance).point;\n };\n\n /**\n * finds the location that is 'distance' along the path from 'location'.\n */\n var _locationAlongPathFrom = function(curve, location, distance) {\n return _pointAlongPath(curve, location, distance).location;\n };\n\n /**\n * returns the gradient of the curve at the given location, which is a decimal between 0 and 1 inclusive.\n *\n * thanks // http://bimixual.org/AnimationLibrary/beziertangents.html\n */\n var _gradientAtPoint = function(curve, location) {\n var p1 = _pointOnPath(curve, location),\n p2 = _pointOnPath(curve.slice(0, curve.length - 1), location),\n dy = p2.y - p1.y, dx = p2.x - p1.x;\n return dy === 0 ? Infinity : Math.atan(dy / dx);\n };\n\n /**\n returns the gradient of the curve at the point which is 'distance' from the given location.\n if this point is greater than location 1, the gradient at location 1 is returned.\n if this point is less than location 0, the gradient at location 0 is returned.\n */\n var _gradientAtPointAlongPathFrom = function(curve, location, distance) {\n var p = _pointAlongPath(curve, location, distance);\n if (p.location > 1) p.location = 1;\n if (p.location < 0) p.location = 0;\n return _gradientAtPoint(curve, p.location);\n };\n\n /**\n * calculates a line that is 'length' pixels long, perpendicular to, and centered on, the path at 'distance' pixels from the given location.\n * if distance is not supplied, the perpendicular for the given location is computed (ie. we set distance to zero).\n */\n var _perpendicularToPathAt = function(curve, location, length, distance) {\n distance = distance == null ? 0 : distance;\n var p = _pointAlongPath(curve, location, distance),\n m = _gradientAtPoint(curve, p.location),\n _theta2 = Math.atan(-1 / m),\n y = length / 2 * Math.sin(_theta2),\n x = length / 2 * Math.cos(_theta2);\n return [{x:p.point.x + x, y:p.point.y + y}, {x:p.point.x - x, y:p.point.y - y}];\n };\n\n /**\n * Calculates all intersections of the given line with the given curve.\n * @param x1\n * @param y1\n * @param x2\n * @param y2\n * @param curve\n * @returns {Array}\n */\n var _lineIntersection = function(x1, y1, x2, y2, curve) {\n var a = y2 - y1,\n b = x1 - x2,\n c = (x1 * (y1 - y2)) + (y1 * (x2-x1)),\n coeffs = _computeCoefficients(curve),\n p = [\n (a*coeffs[0][0]) + (b * coeffs[1][0]),\n (a*coeffs[0][1])+(b*coeffs[1][1]),\n (a*coeffs[0][2])+(b*coeffs[1][2]),\n (a*coeffs[0][3])+(b*coeffs[1][3]) + c\n ],\n r = _cubicRoots.apply(null, p),\n intersections = [];\n\n if (r != null) {\n\n for (var i = 0; i < 3; i++) {\n var t = r[i],\n t2 = Math.pow(t, 2),\n t3 = Math.pow(t, 3),\n x = [\n (coeffs[0][0] * t3) + (coeffs[0][1] * t2) + (coeffs[0][2] * t) + coeffs[0][3],\n (coeffs[1][0] * t3) + (coeffs[1][1] * t2) + (coeffs[1][2] * t) + coeffs[1][3]\n ];\n\n // check bounds of the line\n var s;\n if ((x2 - x1) !== 0) {\n s = (x[0] - x1) / (x2 - x1);\n }\n else {\n s = (x[1] - y1) / (y2 - y1);\n }\n\n if (t >= 0 && t <= 1.0 && s >= 0 && s <= 1.0) {\n intersections.push(x);\n }\n }\n }\n\n return intersections;\n };\n\n /**\n * Calculates all intersections of the given box with the given curve.\n * @param x X position of top left corner of box\n * @param y Y position of top left corner of box\n * @param w width of box\n * @param h height of box\n * @param curve\n * @returns {Array}\n */\n var _boxIntersection = function(x, y, w, h, curve) {\n var i = [];\n i.push.apply(i, _lineIntersection(x, y, x + w, y, curve));\n i.push.apply(i, _lineIntersection(x + w, y, x + w, y + h, curve));\n i.push.apply(i, _lineIntersection(x + w, y + h, x, y + h, curve));\n i.push.apply(i, _lineIntersection(x, y + h, x, y, curve));\n return i;\n };\n\n /**\n * Calculates all intersections of the given bounding box with the given curve.\n * @param boundingBox Bounding box, in { x:.., y:..., w:..., h:... } format.\n * @param curve\n * @returns {Array}\n */\n var _boundingBoxIntersection = function(boundingBox, curve) {\n var i = [];\n i.push.apply(i, _lineIntersection(boundingBox.x, boundingBox.y, boundingBox.x + boundingBox.w, boundingBox.y, curve));\n i.push.apply(i, _lineIntersection(boundingBox.x + boundingBox.w, boundingBox.y, boundingBox.x + boundingBox.w, boundingBox.y + boundingBox.h, curve));\n i.push.apply(i, _lineIntersection(boundingBox.x + boundingBox.w, boundingBox.y + boundingBox.h, boundingBox.x, boundingBox.y + boundingBox.h, curve));\n i.push.apply(i, _lineIntersection(boundingBox.x, boundingBox.y + boundingBox.h, boundingBox.x, boundingBox.y, curve));\n return i;\n };\n\n\n function _computeCoefficientsForAxis(curve, axis) {\n return [\n -(curve[0][axis]) + (3*curve[1][axis]) + (-3 * curve[2][axis]) + curve[3][axis],\n (3*(curve[0][axis])) - (6*(curve[1][axis])) + (3*(curve[2][axis])),\n -3*curve[0][axis] + 3*curve[1][axis],\n curve[0][axis]\n ];\n }\n\n function _computeCoefficients(curve)\n {\n return [\n _computeCoefficientsForAxis(curve, \"x\"),\n _computeCoefficientsForAxis(curve, \"y\")\n ];\n }\n\n function sgn(x) {\n return x < 0 ? -1 : x > 0 ? 1 : 0;\n }\n\n function _cubicRoots(a, b, c, d) {\n var A = b / a,\n B = c / a,\n C = d / a,\n Q = (3*B - Math.pow(A, 2))/9,\n R = (9*A*B - 27*C - 2*Math.pow(A, 3))/54,\n D = Math.pow(Q, 3) + Math.pow(R, 2),\n S,\n T,\n t = [];\n\n if (D >= 0) // complex or duplicate roots\n {\n S = sgn(R + Math.sqrt(D))*Math.pow(Math.abs(R + Math.sqrt(D)),(1/3));\n T = sgn(R - Math.sqrt(D))*Math.pow(Math.abs(R - Math.sqrt(D)),(1/3));\n\n t[0] = -A/3 + (S + T);\n t[1] = -A/3 - (S + T)/2;\n t[2] = -A/3 - (S + T)/2;\n\n /*discard complex roots*/\n if (Math.abs(Math.sqrt(3)*(S - T)/2) !== 0) {\n t[1] = -1;\n t[2] = -1;\n }\n }\n else // distinct real roots\n {\n var th = Math.acos(R/Math.sqrt(-Math.pow(Q, 3)));\n t[0] = 2*Math.sqrt(-Q)*Math.cos(th/3) - A/3;\n t[1] = 2*Math.sqrt(-Q)*Math.cos((th + 2*Math.PI)/3) - A/3;\n t[2] = 2*Math.sqrt(-Q)*Math.cos((th + 4*Math.PI)/3) - A/3;\n }\n\n // discard out of spec roots\n for (var i = 0; i < 3; i++) {\n if (t[i] < 0 || t[i] > 1.0) {\n t[i] = -1;\n }\n }\n\n return t;\n }\n\n var jsBezier = this.jsBezier = {\n distanceFromCurve : _distanceFromCurve,\n gradientAtPoint : _gradientAtPoint,\n gradientAtPointAlongCurveFrom : _gradientAtPointAlongPathFrom,\n nearestPointOnCurve : _nearestPointOnCurve,\n pointOnCurve : _pointOnPath,\n pointAlongCurveFrom : _pointAlongPathFrom,\n perpendicularToCurveAt : _perpendicularToPathAt,\n locationAlongCurveFrom:_locationAlongPathFrom,\n getLength:_length,\n lineIntersection:_lineIntersection,\n boxIntersection:_boxIntersection,\n boundingBoxIntersection:_boundingBoxIntersection,\n version:\"0.9.0\"\n };\n\n if (typeof exports !== \"undefined\") {\n exports.jsBezier = jsBezier;\n }\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n/**\n * Biltong v0.4.0\n *\n * Various geometry functions written as part of jsPlumb and perhaps useful for others.\n *\n * Copyright (c) 2017 jsPlumb\n * https://jsplumbtoolkit.com\n *\n * Permission is hereby granted, free of charge, to any person\n * obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without\n * restriction, including without limitation the rights to use,\n * copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following\n * conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n */\n;(function() {\n\n \"use strict\";\n var root = this;\n\n var Biltong = root.Biltong = {\n version:\"0.4.0\"\n };\n\n if (typeof exports !== \"undefined\") {\n exports.Biltong = Biltong;\n }\n\n var _isa = function(a) { return Object.prototype.toString.call(a) === \"[object Array]\"; },\n _pointHelper = function(p1, p2, fn) {\n p1 = _isa(p1) ? p1 : [p1.x, p1.y];\n p2 = _isa(p2) ? p2 : [p2.x, p2.y];\n return fn(p1, p2);\n },\n /**\n * @name Biltong.gradient\n * @function\n * @desc Calculates the gradient of a line between the two points.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Float} The gradient of a line between the two points.\n */\n _gradient = Biltong.gradient = function(p1, p2) {\n return _pointHelper(p1, p2, function(_p1, _p2) {\n if (_p2[0] == _p1[0])\n return _p2[1] > _p1[1] ? Infinity : -Infinity;\n else if (_p2[1] == _p1[1])\n return _p2[0] > _p1[0] ? 0 : -0;\n else\n return (_p2[1] - _p1[1]) / (_p2[0] - _p1[0]);\n });\n },\n /**\n * @name Biltong.normal\n * @function\n * @desc Calculates the gradient of a normal to a line between the two points.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Float} The gradient of a normal to a line between the two points.\n */\n _normal = Biltong.normal = function(p1, p2) {\n return -1 / _gradient(p1, p2);\n },\n /**\n * @name Biltong.lineLength\n * @function\n * @desc Calculates the length of a line between the two points.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Float} The length of a line between the two points.\n */\n _lineLength = Biltong.lineLength = function(p1, p2) {\n return _pointHelper(p1, p2, function(_p1, _p2) {\n return Math.sqrt(Math.pow(_p2[1] - _p1[1], 2) + Math.pow(_p2[0] - _p1[0], 2));\n });\n },\n /**\n * @name Biltong.quadrant\n * @function\n * @desc Calculates the quadrant in which the angle between the two points lies.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Integer} The quadrant - 1 for upper right, 2 for lower right, 3 for lower left, 4 for upper left.\n */\n _quadrant = Biltong.quadrant = function(p1, p2) {\n return _pointHelper(p1, p2, function(_p1, _p2) {\n if (_p2[0] > _p1[0]) {\n return (_p2[1] > _p1[1]) ? 2 : 1;\n }\n else if (_p2[0] == _p1[0]) {\n return _p2[1] > _p1[1] ? 2 : 1;\n }\n else {\n return (_p2[1] > _p1[1]) ? 3 : 4;\n }\n });\n },\n /**\n * @name Biltong.theta\n * @function\n * @desc Calculates the angle between the two points.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Float} The angle between the two points.\n */\n _theta = Biltong.theta = function(p1, p2) {\n return _pointHelper(p1, p2, function(_p1, _p2) {\n var m = _gradient(_p1, _p2),\n t = Math.atan(m),\n s = _quadrant(_p1, _p2);\n if ((s == 4 || s== 3)) t += Math.PI;\n if (t < 0) t += (2 * Math.PI);\n\n return t;\n });\n },\n /**\n * @name Biltong.intersects\n * @function\n * @desc Calculates whether or not the two rectangles intersect.\n * @param {Rectangle} r1 First rectangle, as a js object in the form `{x:.., y:.., w:.., h:..}`\n * @param {Rectangle} r2 Second rectangle, as a js object in the form `{x:.., y:.., w:.., h:..}`\n * @return {Boolean} True if the rectangles intersect, false otherwise.\n */\n _intersects = Biltong.intersects = function(r1, r2) {\n var x1 = r1.x, x2 = r1.x + r1.w, y1 = r1.y, y2 = r1.y + r1.h,\n a1 = r2.x, a2 = r2.x + r2.w, b1 = r2.y, b2 = r2.y + r2.h;\n\n return ( (x1 <= a1 && a1 <= x2) && (y1 <= b1 && b1 <= y2) ) ||\n ( (x1 <= a2 && a2 <= x2) && (y1 <= b1 && b1 <= y2) ) ||\n ( (x1 <= a1 && a1 <= x2) && (y1 <= b2 && b2 <= y2) ) ||\n ( (x1 <= a2 && a1 <= x2) && (y1 <= b2 && b2 <= y2) ) ||\n ( (a1 <= x1 && x1 <= a2) && (b1 <= y1 && y1 <= b2) ) ||\n ( (a1 <= x2 && x2 <= a2) && (b1 <= y1 && y1 <= b2) ) ||\n ( (a1 <= x1 && x1 <= a2) && (b1 <= y2 && y2 <= b2) ) ||\n ( (a1 <= x2 && x1 <= a2) && (b1 <= y2 && y2 <= b2) );\n },\n /**\n * @name Biltong.encloses\n * @function\n * @desc Calculates whether or not r2 is completely enclosed by r1.\n * @param {Rectangle} r1 First rectangle, as a js object in the form `{x:.., y:.., w:.., h:..}`\n * @param {Rectangle} r2 Second rectangle, as a js object in the form `{x:.., y:.., w:.., h:..}`\n * @param {Boolean} [allowSharedEdges=false] If true, the concept of enclosure allows for one or more edges to be shared by the two rectangles.\n * @return {Boolean} True if r1 encloses r2, false otherwise.\n */\n _encloses = Biltong.encloses = function(r1, r2, allowSharedEdges) {\n var x1 = r1.x, x2 = r1.x + r1.w, y1 = r1.y, y2 = r1.y + r1.h,\n a1 = r2.x, a2 = r2.x + r2.w, b1 = r2.y, b2 = r2.y + r2.h,\n c = function(v1, v2, v3, v4) { return allowSharedEdges ? v1 <= v2 && v3>= v4 : v1 < v2 && v3 > v4; };\n\n return c(x1,a1,x2,a2) && c(y1,b1,y2,b2);\n },\n _segmentMultipliers = [null, [1, -1], [1, 1], [-1, 1], [-1, -1] ],\n _inverseSegmentMultipliers = [null, [-1, -1], [-1, 1], [1, 1], [1, -1] ],\n /**\n * @name Biltong.pointOnLine\n * @function\n * @desc Calculates a point on the line from `fromPoint` to `toPoint` that is `distance` units along the length of the line.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Point} Point on the line, in the form `{ x:..., y:... }`.\n */\n _pointOnLine = Biltong.pointOnLine = function(fromPoint, toPoint, distance) {\n var m = _gradient(fromPoint, toPoint),\n s = _quadrant(fromPoint, toPoint),\n segmentMultiplier = distance > 0 ? _segmentMultipliers[s] : _inverseSegmentMultipliers[s],\n theta = Math.atan(m),\n y = Math.abs(distance * Math.sin(theta)) * segmentMultiplier[1],\n x = Math.abs(distance * Math.cos(theta)) * segmentMultiplier[0];\n return { x:fromPoint.x + x, y:fromPoint.y + y };\n },\n /**\n * @name Biltong.perpendicularLineTo\n * @function\n * @desc Calculates a line of length `length` that is perpendicular to the line from `fromPoint` to `toPoint` and passes through `toPoint`.\n * @param {Point} p1 First point, either as a 2 entry array or object with `left` and `top` properties.\n * @param {Point} p2 Second point, either as a 2 entry array or object with `left` and `top` properties.\n * @return {Line} Perpendicular line, in the form `[ { x:..., y:... }, { x:..., y:... } ]`.\n */\n _perpendicularLineTo = Biltong.perpendicularLineTo = function(fromPoint, toPoint, length) {\n var m = _gradient(fromPoint, toPoint),\n theta2 = Math.atan(-1 / m),\n y = length / 2 * Math.sin(theta2),\n x = length / 2 * Math.cos(theta2);\n return [{x:toPoint.x + x, y:toPoint.y + y}, {x:toPoint.x - x, y:toPoint.y - y}];\n };\n}).call(typeof window !== 'undefined' ? window : this);\n;\n(function () {\n\n \"use strict\";\n\n /**\n * Creates a Touch object.\n * @param view\n * @param target\n * @param pageX\n * @param pageY\n * @param screenX\n * @param screenY\n * @param clientX\n * @param clientY\n * @returns {Touch}\n * @private\n */\n function _touch(view, target, pageX, pageY, screenX, screenY, clientX, clientY) {\n\n return new Touch({\n target:target,\n identifier:_uuid(),\n pageX: pageX,\n pageY: pageY,\n screenX: screenX,\n screenY: screenY,\n clientX: clientX || screenX,\n clientY: clientY || screenY\n });\n }\n\n /**\n * Create a synthetic touch list from the given list of Touch objects.\n * @returns {Array}\n * @private\n */\n function _touchList() {\n var list = [];\n Array.prototype.push.apply(list, arguments);\n list.item = function(index) { return this[index]; };\n return list;\n }\n\n /**\n * Create a Touch object and then insert it into a synthetic touch list, returning the list.s\n * @param view\n * @param target\n * @param pageX\n * @param pageY\n * @param screenX\n * @param screenY\n * @param clientX\n * @param clientY\n * @returns {Array}\n * @private\n */\n function _touchAndList(view, target, pageX, pageY, screenX, screenY, clientX, clientY) {\n return _touchList(_touch.apply(null, arguments));\n }\n\n var root = this,\n matchesSelector = function (el, selector, ctx) {\n ctx = ctx || el.parentNode;\n var possibles = ctx.querySelectorAll(selector);\n for (var i = 0; i < possibles.length; i++) {\n if (possibles[i] === el) {\n return true;\n }\n }\n return false;\n },\n _gel = function (el) {\n return (typeof el == \"string\" || el.constructor === String) ? document.getElementById(el) : el;\n },\n _t = function (e) {\n return e.srcElement || e.target;\n },\n //\n // gets path info for the given event - the path from target to obj, in the event's bubble chain. if doCompute\n // is false we just return target for the path.\n //\n _pi = function(e, target, obj, doCompute) {\n if (!doCompute) return { path:[target], end:1 };\n else if (typeof e.path !== \"undefined\" && e.path.indexOf) {\n return { path: e.path, end: e.path.indexOf(obj) };\n } else {\n var out = { path:[], end:-1 }, _one = function(el) {\n out.path.push(el);\n if (el === obj) {\n out.end = out.path.length - 1;\n }\n else if (el.parentNode != null) {\n _one(el.parentNode)\n }\n };\n _one(target);\n return out;\n }\n },\n _d = function (l, fn) {\n for (var i = 0, j = l.length; i < j; i++) {\n if (l[i] == fn) break;\n }\n if (i < l.length) l.splice(i, 1);\n },\n guid = 1,\n //\n // this function generates a guid for every handler, sets it on the handler, then adds\n // it to the associated object's map of handlers for the given event. this is what enables us\n // to unbind all events of some type, or all events (the second of which can be requested by the user,\n // but it also used by Mottle when an element is removed.)\n _store = function (obj, event, fn) {\n var g = guid++;\n obj.__ta = obj.__ta || {};\n obj.__ta[event] = obj.__ta[event] || {};\n // store each handler with a unique guid.\n obj.__ta[event][g] = fn;\n // set the guid on the handler.\n fn.__tauid = g;\n return g;\n },\n _unstore = function (obj, event, fn) {\n obj.__ta && obj.__ta[event] && delete obj.__ta[event][fn.__tauid];\n // a handler might have attached extra functions, so we unbind those too.\n if (fn.__taExtra) {\n for (var i = 0; i < fn.__taExtra.length; i++) {\n _unbind(obj, fn.__taExtra[i][0], fn.__taExtra[i][1]);\n }\n fn.__taExtra.length = 0;\n }\n // a handler might have attached an unstore callback\n fn.__taUnstore && fn.__taUnstore();\n },\n _curryChildFilter = function (children, obj, fn, evt) {\n if (children == null) return fn;\n else {\n var c = children.split(\",\"),\n _fn = function (e) {\n _fn.__tauid = fn.__tauid;\n var t = _t(e), target = t; // t is the target element on which the event occurred. it is the\n // element we will wish to pass to any callbacks.\n var pathInfo = _pi(e, t, obj, children != null)\n if (pathInfo.end != -1) {\n for (var p = 0; p < pathInfo.end; p++) {\n target = pathInfo.path[p];\n for (var i = 0; i < c.length; i++) {\n if (matchesSelector(target, c[i], obj)) {\n fn.apply(target, arguments);\n }\n }\n }\n }\n };\n registerExtraFunction(fn, evt, _fn);\n return _fn;\n }\n },\n //\n // registers an 'extra' function on some event listener function we were given - a function that we\n // created and bound to the element as part of our housekeeping, and which we want to unbind and remove\n // whenever the given function is unbound.\n registerExtraFunction = function (fn, evt, newFn) {\n fn.__taExtra = fn.__taExtra || [];\n fn.__taExtra.push([evt, newFn]);\n },\n DefaultHandler = function (obj, evt, fn, children) {\n if (isTouchDevice && touchMap[evt]) {\n var tfn = _curryChildFilter(children, obj, fn, touchMap[evt]);\n _bind(obj, touchMap[evt], tfn , fn);\n }\n if (evt === \"focus\" && obj.getAttribute(\"tabindex\") == null) {\n obj.setAttribute(\"tabindex\", \"1\");\n }\n _bind(obj, evt, _curryChildFilter(children, obj, fn, evt), fn);\n },\n SmartClickHandler = function (obj, evt, fn, children) {\n if (obj.__taSmartClicks == null) {\n var down = function (e) {\n obj.__tad = _pageLocation(e);\n },\n up = function (e) {\n obj.__tau = _pageLocation(e);\n },\n click = function (e) {\n if (obj.__tad && obj.__tau && obj.__tad[0] === obj.__tau[0] && obj.__tad[1] === obj.__tau[1]) {\n for (var i = 0; i < obj.__taSmartClicks.length; i++)\n obj.__taSmartClicks[i].apply(_t(e), [ e ]);\n }\n };\n DefaultHandler(obj, \"mousedown\", down, children);\n DefaultHandler(obj, \"mouseup\", up, children);\n DefaultHandler(obj, \"click\", click, children);\n obj.__taSmartClicks = [];\n }\n\n // store in the list of callbacks\n obj.__taSmartClicks.push(fn);\n // the unstore function removes this function from the object's listener list for this type.\n fn.__taUnstore = function () {\n _d(obj.__taSmartClicks, fn);\n };\n },\n _tapProfiles = {\n \"tap\": {touches: 1, taps: 1},\n \"dbltap\": {touches: 1, taps: 2},\n \"contextmenu\": {touches: 2, taps: 1}\n },\n TapHandler = function (clickThreshold, dblClickThreshold) {\n return function (obj, evt, fn, children) {\n // if event is contextmenu, for devices which are mouse only, we want to\n // use the default bind.\n if (evt == \"contextmenu\" && isMouseDevice)\n DefaultHandler(obj, evt, fn, children);\n else {\n // the issue here is that this down handler gets registered only for the\n // child nodes in the first registration. in fact it should be registered with\n // no child selector and then on down we should cycle through the registered\n // functions to see if one of them matches. on mouseup we should execute ALL of\n // the functions whose children are either null or match the element.\n if (obj.__taTapHandler == null) {\n var tt = obj.__taTapHandler = {\n tap: [],\n dbltap: [],\n contextmenu: [],\n down: false,\n taps: 0,\n downSelectors: []\n };\n var down = function (e) {\n var target = _t(e), pathInfo = _pi(e, target, obj, children != null), finished = false;\n for (var p = 0; p < pathInfo.end; p++) {\n if (finished) return;\n target = pathInfo.path[p];\n for (var i = 0; i < tt.downSelectors.length; i++) {\n if (tt.downSelectors[i] == null || matchesSelector(target, tt.downSelectors[i], obj)) {\n tt.down = true;\n setTimeout(clearSingle, clickThreshold);\n setTimeout(clearDouble, dblClickThreshold);\n finished = true;\n break; // we only need one match on mousedown\n }\n }\n }\n },\n up = function (e) {\n if (tt.down) {\n var target = _t(e), currentTarget, pathInfo;\n tt.taps++;\n var tc = _touchCount(e);\n for (var eventId in _tapProfiles) {\n if (_tapProfiles.hasOwnProperty(eventId)) {\n var p = _tapProfiles[eventId];\n if (p.touches === tc && (p.taps === 1 || p.taps === tt.taps)) {\n for (var i = 0; i < tt[eventId].length; i++) {\n pathInfo = _pi(e, target, obj, tt[eventId][i][1] != null);\n for (var pLoop = 0; pLoop < pathInfo.end; pLoop++) {\n currentTarget = pathInfo.path[pLoop];\n // this is a single event registration handler.\n if (tt[eventId][i][1] == null || matchesSelector(currentTarget, tt[eventId][i][1], obj)) {\n tt[eventId][i][0].apply(currentTarget, [ e ]);\n break;\n }\n }\n }\n }\n }\n }\n }\n },\n clearSingle = function () {\n tt.down = false;\n },\n clearDouble = function () {\n tt.taps = 0;\n };\n\n DefaultHandler(obj, \"mousedown\", down);\n DefaultHandler(obj, \"mouseup\", up);\n }\n // add this child selector (it can be null, that's fine).\n obj.__taTapHandler.downSelectors.push(children);\n\n obj.__taTapHandler[evt].push([fn, children]);\n // the unstore function removes this function from the object's listener list for this type.\n fn.__taUnstore = function () {\n _d(obj.__taTapHandler[evt], fn);\n };\n }\n };\n },\n meeHelper = function (type, evt, obj, target) {\n for (var i in obj.__tamee[type]) {\n if (obj.__tamee[type].hasOwnProperty(i)) {\n obj.__tamee[type][i].apply(target, [ evt ]);\n }\n }\n },\n MouseEnterExitHandler = function () {\n var activeElements = [];\n return function (obj, evt, fn, children) {\n if (!obj.__tamee) {\n // __tamee holds a flag saying whether the mouse is currently \"in\" the element, and a list of\n // both mouseenter and mouseexit functions.\n obj.__tamee = { over: false, mouseenter: [], mouseexit: [] };\n // register over and out functions\n var over = function (e) {\n var t = _t(e);\n if ((children == null && (t == obj && !obj.__tamee.over)) || (matchesSelector(t, children, obj) && (t.__tamee == null || !t.__tamee.over))) {\n meeHelper(\"mouseenter\", e, obj, t);\n t.__tamee = t.__tamee || {};\n t.__tamee.over = true;\n activeElements.push(t);\n }\n },\n out = function (e) {\n var t = _t(e);\n // is the current target one of the activeElements? and is the\n // related target NOT a descendant of it?\n for (var i = 0; i < activeElements.length; i++) {\n if (t == activeElements[i] && !matchesSelector((e.relatedTarget || e.toElement), \"*\", t)) {\n t.__tamee.over = false;\n activeElements.splice(i, 1);\n meeHelper(\"mouseexit\", e, obj, t);\n }\n }\n };\n\n _bind(obj, \"mouseover\", _curryChildFilter(children, obj, over, \"mouseover\"), over);\n _bind(obj, \"mouseout\", _curryChildFilter(children, obj, out, \"mouseout\"), out);\n }\n\n fn.__taUnstore = function () {\n delete obj.__tamee[evt][fn.__tauid];\n };\n\n _store(obj, evt, fn);\n obj.__tamee[evt][fn.__tauid] = fn;\n };\n },\n isTouchDevice = \"ontouchstart\" in document.documentElement,\n isMouseDevice = \"onmousedown\" in document.documentElement,\n touchMap = { \"mousedown\": \"touchstart\", \"mouseup\": \"touchend\", \"mousemove\": \"touchmove\" },\n touchstart = \"touchstart\", touchend = \"touchend\", touchmove = \"touchmove\",\n iev = (function () {\n var rv = -1;\n if (navigator.appName == 'Microsoft Internet Explorer') {\n var ua = navigator.userAgent,\n re = new RegExp(\"MSIE ([0-9]{1,}[\\.0-9]{0,})\");\n if (re.exec(ua) != null)\n rv = parseFloat(RegExp.$1);\n }\n return rv;\n })(),\n isIELT9 = iev > -1 && iev < 9,\n _genLoc = function (e, prefix) {\n if (e == null) return [ 0, 0 ];\n var ts = _touches(e), t = _getTouch(ts, 0);\n return [t[prefix + \"X\"], t[prefix + \"Y\"]];\n },\n _pageLocation = function (e) {\n if (e == null) return [ 0, 0 ];\n if (isIELT9) {\n return [ e.clientX + document.documentElement.scrollLeft, e.clientY + document.documentElement.scrollTop ];\n }\n else {\n return _genLoc(e, \"page\");\n }\n },\n _screenLocation = function (e) {\n return _genLoc(e, \"screen\");\n },\n _clientLocation = function (e) {\n return _genLoc(e, \"client\");\n },\n _getTouch = function (touches, idx) {\n return touches.item ? touches.item(idx) : touches[idx];\n },\n _touches = function (e) {\n return e.touches && e.touches.length > 0 ? e.touches :\n e.changedTouches && e.changedTouches.length > 0 ? e.changedTouches :\n e.targetTouches && e.targetTouches.length > 0 ? e.targetTouches :\n [ e ];\n },\n _touchCount = function (e) {\n return _touches(e).length;\n },\n //http://www.quirksmode.org/blog/archives/2005/10/_and_the_winner_1.html\n _bind = function (obj, type, fn, originalFn) {\n _store(obj, type, fn);\n originalFn.__tauid = fn.__tauid;\n if (obj.addEventListener)\n obj.addEventListener(type, fn, false);\n else if (obj.attachEvent) {\n var key = type + fn.__tauid;\n obj[\"e\" + key] = fn;\n // TODO look at replacing with .call(..)\n obj[key] = function () {\n obj[\"e\" + key] && obj[\"e\" + key](window.event);\n };\n obj.attachEvent(\"on\" + type, obj[key]);\n }\n },\n _unbind = function (obj, type, fn) {\n if (fn == null) return;\n _each(obj, function () {\n var _el = _gel(this);\n _unstore(_el, type, fn);\n // it has been bound if there is a tauid. otherwise it was not bound and we can ignore it.\n if (fn.__tauid != null) {\n if (_el.removeEventListener) {\n _el.removeEventListener(type, fn, false);\n if (isTouchDevice && touchMap[type]) _el.removeEventListener(touchMap[type], fn, false);\n }\n else if (this.detachEvent) {\n var key = type + fn.__tauid;\n _el[key] && _el.detachEvent(\"on\" + type, _el[key]);\n _el[key] = null;\n _el[\"e\" + key] = null;\n }\n }\n\n // if a touch event was also registered, deregister now.\n if (fn.__taTouchProxy) {\n _unbind(obj, fn.__taTouchProxy[1], fn.__taTouchProxy[0]);\n }\n });\n },\n _each = function (obj, fn) {\n if (obj == null) return;\n // if a list (or list-like), use it. if a string, get a list\n // by running the string through querySelectorAll. else, assume\n // it's an Element.\n // obj.top is \"unknown\" in IE8.\n obj = (typeof Window !== \"undefined\" && (typeof obj.top !== \"unknown\" && obj == obj.top)) ? [ obj ] :\n (typeof obj !== \"string\") && (obj.tagName == null && obj.length != null) ? obj :\n typeof obj === \"string\" ? document.querySelectorAll(obj)\n : [ obj ];\n\n for (var i = 0; i < obj.length; i++)\n fn.apply(obj[i]);\n },\n _uuid = function () {\n return ('xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);\n return v.toString(16);\n }));\n };\n\n /**\n * Mottle offers support for abstracting out the differences\n * between touch and mouse devices, plus \"smart click\" functionality\n * (don't fire click if the mouse has moved between mousedown and mouseup),\n * and synthesized click/tap events.\n * @class Mottle\n * @constructor\n * @param {Object} params Constructor params\n * @param {Number} [params.clickThreshold=250] Threshold, in milliseconds beyond which a touchstart followed by a touchend is not considered to be a click.\n * @param {Number} [params.dblClickThreshold=450] Threshold, in milliseconds beyond which two successive tap events are not considered to be a click.\n * @param {Boolean} [params.smartClicks=false] If true, won't fire click events if the mouse has moved between mousedown and mouseup. Note that this functionality\n * requires that Mottle consume the mousedown event, and so may not be viable in all use cases.\n */\n root.Mottle = function (params) {\n params = params || {};\n var clickThreshold = params.clickThreshold || 250,\n dblClickThreshold = params.dblClickThreshold || 450,\n mouseEnterExitHandler = new MouseEnterExitHandler(),\n tapHandler = new TapHandler(clickThreshold, dblClickThreshold),\n _smartClicks = params.smartClicks,\n _doBind = function (obj, evt, fn, children) {\n if (fn == null) return;\n _each(obj, function () {\n var _el = _gel(this);\n if (_smartClicks && evt === \"click\")\n SmartClickHandler(_el, evt, fn, children);\n else if (evt === \"tap\" || evt === \"dbltap\" || evt === \"contextmenu\") {\n tapHandler(_el, evt, fn, children);\n }\n else if (evt === \"mouseenter\" || evt == \"mouseexit\")\n mouseEnterExitHandler(_el, evt, fn, children);\n else\n DefaultHandler(_el, evt, fn, children);\n });\n };\n\n /**\n * Removes an element from the DOM, and deregisters all event handlers for it. You should use this\n * to ensure you don't leak memory.\n * @method remove\n * @param {String|Element} el Element, or id of the element, to remove.\n * @return {Mottle} The current Mottle instance; you can chain this method.\n */\n this.remove = function (el) {\n _each(el, function () {\n var _el = _gel(this);\n if (_el.__ta) {\n for (var evt in _el.__ta) {\n if (_el.__ta.hasOwnProperty(evt)) {\n for (var h in _el.__ta[evt]) {\n if (_el.__ta[evt].hasOwnProperty(h))\n _unbind(_el, evt, _el.__ta[evt][h]);\n }\n }\n }\n }\n _el.parentNode && _el.parentNode.removeChild(_el);\n });\n return this;\n };\n\n /**\n * Register an event handler, optionally as a delegate for some set of descendant elements. Note\n * that this method takes either 3 or 4 arguments - if you supply 3 arguments it is assumed you have\n * omitted the `children` parameter, and that the event handler should be bound directly to the given element.\n * @method on\n * @param {Element[]|Element|String} el Either an Element, or a CSS spec for a list of elements, or an array of Elements.\n * @param {String} [children] Comma-delimited list of selectors identifying allowed children.\n * @param {String} event Event ID.\n * @param {Function} fn Event handler function.\n * @return {Mottle} The current Mottle instance; you can chain this method.\n */\n this.on = function (el, event, children, fn) {\n var _el = arguments[0],\n _c = arguments.length == 4 ? arguments[2] : null,\n _e = arguments[1],\n _f = arguments[arguments.length - 1];\n\n _doBind(_el, _e, _f, _c);\n return this;\n };\n\n /**\n * Cancel delegate event handling for the given function. Note that unlike with 'on' you do not supply\n * a list of child selectors here: it removes event delegation from all of the child selectors for which the\n * given function was registered (if any).\n * @method off\n * @param {Element[]|Element|String} el Element - or ID of element - from which to remove event listener.\n * @param {String} event Event ID.\n * @param {Function} fn Event handler function.\n * @return {Mottle} The current Mottle instance; you can chain this method.\n */\n this.off = function (el, event, fn) {\n _unbind(el, event, fn);\n return this;\n };\n\n /**\n * Triggers some event for a given element.\n * @method trigger\n * @param {Element} el Element for which to trigger the event.\n * @param {String} event Event ID.\n * @param {Event} originalEvent The original event. Should be optional of course, but currently is not, due\n * to the jsPlumb use case that caused this method to be added.\n * @param {Object} [payload] Optional object to set as `payload` on the generated event; useful for message passing.\n * @return {Mottle} The current Mottle instance; you can chain this method.\n */\n this.trigger = function (el, event, originalEvent, payload) {\n // MouseEvent undefined in old IE; that's how we know it's a mouse event. A fine Microsoft paradox.\n var originalIsMouse = isMouseDevice && (typeof MouseEvent === \"undefined\" || originalEvent == null || originalEvent.constructor === MouseEvent);\n\n var eventToBind = (isTouchDevice && !isMouseDevice && touchMap[event]) ? touchMap[event] : event,\n bindingAMouseEvent = !(isTouchDevice && !isMouseDevice && touchMap[event]);\n\n var pl = _pageLocation(originalEvent), sl = _screenLocation(originalEvent), cl = _clientLocation(originalEvent);\n _each(el, function () {\n var _el = _gel(this), evt;\n originalEvent = originalEvent || {\n screenX: sl[0],\n screenY: sl[1],\n clientX: cl[0],\n clientY: cl[1]\n };\n\n var _decorate = function (_evt) {\n if (payload) _evt.payload = payload;\n };\n\n var eventGenerators = {\n \"TouchEvent\": function (evt) {\n\n var touchList = _touchAndList(window, _el, 0, pl[0], pl[1], sl[0], sl[1], cl[0], cl[1]),\n init = evt.initTouchEvent || evt.initEvent;\n\n init(eventToBind, true, true, window, null, sl[0], sl[1],\n cl[0], cl[1], false, false, false, false,\n touchList, touchList, touchList, 1, 0);\n },\n \"MouseEvents\": function (evt) {\n evt.initMouseEvent(eventToBind, true, true, window, 0,\n sl[0], sl[1],\n cl[0], cl[1],\n false, false, false, false, 1, _el);\n }\n };\n\n if (document.createEvent) {\n\n var ite = !bindingAMouseEvent && !originalIsMouse && (isTouchDevice && touchMap[event]),\n evtName = ite ? \"TouchEvent\" : \"MouseEvents\";\n\n evt = document.createEvent(evtName);\n eventGenerators[evtName](evt);\n _decorate(evt);\n _el.dispatchEvent(evt);\n }\n else if (document.createEventObject) {\n evt = document.createEventObject();\n evt.eventType = evt.eventName = eventToBind;\n evt.screenX = sl[0];\n evt.screenY = sl[1];\n evt.clientX = cl[0];\n evt.clientY = cl[1];\n _decorate(evt);\n _el.fireEvent('on' + eventToBind, evt);\n }\n });\n return this;\n }\n };\n\n /**\n * Static method to assist in 'consuming' an element: uses `stopPropagation` where available, or sets\n * `e.returnValue=false` where it is not.\n * @method Mottle.consume\n * @param {Event} e Event to consume\n * @param {Boolean} [doNotPreventDefault=false] If true, does not call `preventDefault()` on the event.\n */\n root.Mottle.consume = function (e, doNotPreventDefault) {\n if (e.stopPropagation)\n e.stopPropagation();\n else\n e.returnValue = false;\n\n if (!doNotPreventDefault && e.preventDefault)\n e.preventDefault();\n };\n\n /**\n * Gets the page location corresponding to the given event. For touch events this means get the page location of the first touch.\n * @method Mottle.pageLocation\n * @param {Event} e Event to get page location for.\n * @return {Number[]} [left, top] for the given event.\n */\n root.Mottle.pageLocation = _pageLocation;\n\n /**\n * Forces touch events to be turned \"on\". Useful for testing: even if you don't have a touch device, you can still\n * trigger a touch event when this is switched on and it will be captured and acted on.\n * @method setForceTouchEvents\n * @param {Boolean} value If true, force touch events to be on.\n */\n root.Mottle.setForceTouchEvents = function (value) {\n isTouchDevice = value;\n };\n\n /**\n * Forces mouse events to be turned \"on\". Useful for testing: even if you don't have a mouse, you can still\n * trigger a mouse event when this is switched on and it will be captured and acted on.\n * @method setForceMouseEvents\n * @param {Boolean} value If true, force mouse events to be on.\n */\n root.Mottle.setForceMouseEvents = function (value) {\n isMouseDevice = value;\n };\n\n root.Mottle.version = \"0.8.0\";\n\n if (typeof exports !== \"undefined\") {\n exports.Mottle = root.Mottle;\n }\n\n}).call(typeof window === \"undefined\" ? this : window);\n\n/**\n drag/drop functionality for use with jsPlumb but with\n no knowledge of jsPlumb. supports multiple scopes (separated by whitespace), dragging\n multiple elements, constrain to parent, drop filters, drag start filters, custom\n css classes.\n\n a lot of the functionality of this script is expected to be plugged in:\n\n addClass\n removeClass\n\n addEvent\n removeEvent\n\n getPosition\n setPosition\n getSize\n\n indexOf\n intersects\n\n the name came from here:\n\n http://mrsharpoblunto.github.io/foswig.js/\n\n copyright 2016 jsPlumb\n */\n\n;(function() {\n\n \"use strict\";\n var root = this;\n\n var _suggest = function(list, item, head) {\n if (list.indexOf(item) === -1) {\n head ? list.unshift(item) : list.push(item);\n return true;\n }\n return false;\n };\n\n var _vanquish = function(list, item) {\n var idx = list.indexOf(item);\n if (idx !== -1) list.splice(idx, 1);\n };\n\n var _difference = function(l1, l2) {\n var d = [];\n for (var i = 0; i < l1.length; i++) {\n if (l2.indexOf(l1[i]) === -1)\n d.push(l1[i]);\n }\n return d;\n };\n\n var _isString = function(f) {\n return f == null ? false : (typeof f === \"string\" || f.constructor === String);\n };\n\n var getOffsetRect = function (elem) {\n // (1)\n var box = elem.getBoundingClientRect(),\n body = document.body,\n docElem = document.documentElement,\n // (2)\n scrollTop = window.pageYOffset || docElem.scrollTop || body.scrollTop,\n scrollLeft = window.pageXOffset || docElem.scrollLeft || body.scrollLeft,\n // (3)\n clientTop = docElem.clientTop || body.clientTop || 0,\n clientLeft = docElem.clientLeft || body.clientLeft || 0,\n // (4)\n top = box.top + scrollTop - clientTop,\n left = box.left + scrollLeft - clientLeft;\n\n return { top: Math.round(top), left: Math.round(left) };\n };\n\n var matchesSelector = function(el, selector, ctx) {\n ctx = ctx || el.parentNode;\n var possibles = ctx.querySelectorAll(selector);\n for (var i = 0; i < possibles.length; i++) {\n if (possibles[i] === el)\n return true;\n }\n return false;\n };\n\n var findDelegateElement = function(parentElement, childElement, selector) {\n if (matchesSelector(childElement, selector, parentElement)) {\n return childElement;\n } else {\n var currentParent = childElement.parentNode;\n while (currentParent != null && currentParent !== parentElement) {\n if (matchesSelector(currentParent, selector, parentElement)) {\n return currentParent;\n } else {\n currentParent = currentParent.parentNode;\n }\n }\n }\n };\n\n var iev = (function() {\n var rv = -1;\n if (navigator.appName === 'Microsoft Internet Explorer') {\n var ua = navigator.userAgent,\n re = new RegExp(\"MSIE ([0-9]{1,}[\\.0-9]{0,})\");\n if (re.exec(ua) != null)\n rv = parseFloat(RegExp.$1);\n }\n return rv;\n })(),\n DEFAULT_GRID_X = 10,\n DEFAULT_GRID_Y = 10,\n isIELT9 = iev > -1 && iev < 9,\n isIE9 = iev === 9,\n _pl = function(e) {\n if (isIELT9) {\n return [ e.clientX + document.documentElement.scrollLeft, e.clientY + document.documentElement.scrollTop ];\n }\n else {\n var ts = _touches(e), t = _getTouch(ts, 0);\n // for IE9 pageX might be null if the event was synthesized. We try for pageX/pageY first,\n // falling back to clientX/clientY if necessary. In every other browser we want to use pageX/pageY.\n return isIE9 ? [t.pageX || t.clientX, t.pageY || t.clientY] : [t.pageX, t.pageY];\n }\n },\n _getTouch = function(touches, idx) { return touches.item ? touches.item(idx) : touches[idx]; },\n _touches = function(e) {\n return e.touches && e.touches.length > 0 ? e.touches :\n e.changedTouches && e.changedTouches.length > 0 ? e.changedTouches :\n e.targetTouches && e.targetTouches.length > 0 ? e.targetTouches :\n [ e ];\n },\n _classes = {\n draggable:\"katavorio-draggable\", // draggable elements\n droppable:\"katavorio-droppable\", // droppable elements\n drag : \"katavorio-drag\", // elements currently being dragged\n selected:\"katavorio-drag-selected\", // elements in current drag selection\n active : \"katavorio-drag-active\", // droppables that are targets of a currently dragged element\n hover : \"katavorio-drag-hover\", // droppables over which a matching drag element is hovering\n noSelect : \"katavorio-drag-no-select\", // added to the body to provide a hook to suppress text selection\n ghostProxy:\"katavorio-ghost-proxy\", // added to a ghost proxy element in use when a drag has exited the bounds of its parent.\n clonedDrag:\"katavorio-clone-drag\" // added to a node that is a clone of an element created at the start of a drag\n },\n _defaultScope = \"katavorio-drag-scope\",\n _events = [ \"stop\", \"start\", \"drag\", \"drop\", \"over\", \"out\", \"beforeStart\" ],\n _devNull = function() {},\n _true = function() { return true; },\n _foreach = function(l, fn, from) {\n for (var i = 0; i < l.length; i++) {\n if (l[i] != from)\n fn(l[i]);\n }\n },\n _setDroppablesActive = function(dd, val, andHover, drag) {\n _foreach(dd, function(e) {\n e.setActive(val);\n if (val) e.updatePosition();\n if (andHover) e.setHover(drag, val);\n });\n },\n _each = function(obj, fn) {\n if (obj == null) return;\n obj = !_isString(obj) && (obj.tagName == null && obj.length != null) ? obj : [ obj ];\n for (var i = 0; i < obj.length; i++)\n fn.apply(obj[i], [ obj[i] ]);\n },\n _consume = function(e) {\n if (e.stopPropagation) {\n e.stopPropagation();\n e.preventDefault();\n }\n else {\n e.returnValue = false;\n }\n },\n _defaultInputFilterSelector = \"input,textarea,select,button,option\",\n //\n // filters out events on all input elements, like textarea, checkbox, input, select.\n _inputFilter = function(e, el, _katavorio) {\n var t = e.srcElement || e.target;\n return !matchesSelector(t, _katavorio.getInputFilterSelector(), el);\n };\n\n var Super = function(el, params, css, scope) {\n this.params = params || {};\n this.el = el;\n this.params.addClass(this.el, this._class);\n this.uuid = _uuid();\n var enabled = true;\n this.setEnabled = function(e) { enabled = e; };\n this.isEnabled = function() { return enabled; };\n this.toggleEnabled = function() { enabled = !enabled; };\n this.setScope = function(scopes) {\n this.scopes = scopes ? scopes.split(/\\s+/) : [ scope ];\n };\n this.addScope = function(scopes) {\n var m = {};\n _each(this.scopes, function(s) { m[s] = true;});\n _each(scopes ? scopes.split(/\\s+/) : [], function(s) { m[s] = true;});\n this.scopes = [];\n for (var i in m) this.scopes.push(i);\n };\n this.removeScope = function(scopes) {\n var m = {};\n _each(this.scopes, function(s) { m[s] = true;});\n _each(scopes ? scopes.split(/\\s+/) : [], function(s) { delete m[s];});\n this.scopes = [];\n for (var i in m) this.scopes.push(i);\n };\n this.toggleScope = function(scopes) {\n var m = {};\n _each(this.scopes, function(s) { m[s] = true;});\n _each(scopes ? scopes.split(/\\s+/) : [], function(s) {\n if (m[s]) delete m[s];\n else m[s] = true;\n });\n this.scopes = [];\n for (var i in m) this.scopes.push(i);\n };\n this.setScope(params.scope);\n this.k = params.katavorio;\n return params.katavorio;\n };\n\n var TRUE = function() { return true; };\n var FALSE = function() { return false; };\n\n var Drag = function(el, params, css, scope) {\n this._class = css.draggable;\n var k = Super.apply(this, arguments);\n this.rightButtonCanDrag = this.params.rightButtonCanDrag;\n var downAt = [0,0], posAtDown = null, pagePosAtDown = null, pageDelta = [0,0], moving = false, initialScroll = [0,0],\n consumeStartEvent = this.params.consumeStartEvent !== false,\n dragEl = this.el,\n clone = this.params.clone,\n scroll = this.params.scroll,\n _multipleDrop = params.multipleDrop !== false,\n isConstrained = false,\n useGhostProxy = params.ghostProxy === true ? TRUE : params.ghostProxy && typeof params.ghostProxy === \"function\" ? params.ghostProxy : FALSE,\n ghostProxy = function(el) { return el.cloneNode(true); },\n selector = params.selector,\n elementToDrag = null;\n\n var snapThreshold = params.snapThreshold,\n _snap = function(pos, gridX, gridY, thresholdX, thresholdY) {\n var _dx = Math.floor(pos[0] / gridX),\n _dxl = gridX * _dx,\n _dxt = _dxl + gridX,\n _x = Math.abs(pos[0] - _dxl) <= thresholdX ? _dxl : Math.abs(_dxt - pos[0]) <= thresholdX ? _dxt : pos[0];\n\n var _dy = Math.floor(pos[1] / gridY),\n _dyl = gridY * _dy,\n _dyt = _dyl + gridY,\n _y = Math.abs(pos[1] - _dyl) <= thresholdY ? _dyl : Math.abs(_dyt - pos[1]) <= thresholdY ? _dyt : pos[1];\n\n return [ _x, _y];\n };\n\n this.posses = [];\n this.posseRoles = {};\n\n this.toGrid = function(pos) {\n if (this.params.grid == null) {\n return pos;\n }\n else {\n var tx = this.params.grid ? this.params.grid[0] / 2 : snapThreshold ? snapThreshold : DEFAULT_GRID_X / 2,\n ty = this.params.grid ? this.params.grid[1] / 2 : snapThreshold ? snapThreshold : DEFAULT_GRID_Y / 2;\n\n return _snap(pos, this.params.grid[0], this.params.grid[1], tx, ty);\n }\n };\n\n this.snap = function(x, y) {\n if (dragEl == null) return;\n x = x || (this.params.grid ? this.params.grid[0] : DEFAULT_GRID_X);\n y = y || (this.params.grid ? this.params.grid[1] : DEFAULT_GRID_Y);\n var p = this.params.getPosition(dragEl),\n tx = this.params.grid ? this.params.grid[0] / 2 : snapThreshold,\n ty = this.params.grid ? this.params.grid[1] / 2 : snapThreshold;\n\n this.params.setPosition(dragEl, _snap(p, x, y, tx, ty));\n };\n\n this.setUseGhostProxy = function(val) {\n useGhostProxy = val ? TRUE : FALSE;\n };\n\n var constrain;\n var negativeFilter = function(pos) {\n return (params.allowNegative === false) ? [ Math.max (0, pos[0]), Math.max(0, pos[1]) ] : pos;\n };\n\n var _setConstrain = function(value) {\n constrain = typeof value === \"function\" ? value : value ? function(pos, dragEl, _constrainRect, _size) {\n return negativeFilter([\n Math.max(0, Math.min(_constrainRect.w - _size[0], pos[0])),\n Math.max(0, Math.min(_constrainRect.h - _size[1], pos[1]))\n ]);\n }.bind(this) : function(pos) { return negativeFilter(pos); };\n }.bind(this);\n\n _setConstrain(typeof this.params.constrain === \"function\" ? this.params.constrain : (this.params.constrain || this.params.containment));\n\n\n /**\n * Sets whether or not the Drag is constrained. A value of 'true' means constrain to parent bounds; a function\n * will be executed and returns true if the position is allowed.\n * @param value\n */\n this.setConstrain = function(value) {\n _setConstrain(value);\n };\n\n var revertFunction;\n /**\n * Sets a function to call on drag stop, which, if it returns true, indicates that the given element should\n * revert to its position before the previous drag.\n * @param fn\n */\n this.setRevert = function(fn) {\n revertFunction = fn;\n };\n\n var _assignId = function(obj) {\n if (typeof obj === \"function\") {\n obj._katavorioId = _uuid();\n return obj._katavorioId;\n } else {\n return obj;\n }\n },\n // a map of { spec -> [ fn, exclusion ] } entries.\n _filters = {},\n _testFilter = function(e) {\n for (var key in _filters) {\n var f = _filters[key];\n var rv = f[0](e);\n if (f[1]) rv = !rv;\n if (!rv) return false;\n }\n return true;\n },\n _setFilter = this.setFilter = function(f, _exclude) {\n if (f) {\n var key = _assignId(f);\n _filters[key] = [\n function(e) {\n var t = e.srcElement || e.target, m;\n if (_isString(f)) {\n m = matchesSelector(t, f, el);\n }\n else if (typeof f === \"function\") {\n m = f(e, el);\n }\n return m;\n },\n _exclude !== false\n ];\n\n }\n },\n _addFilter = this.addFilter = _setFilter,\n _removeFilter = this.removeFilter = function(f) {\n var key = typeof f === \"function\" ? f._katavorioId : f;\n delete _filters[key];\n };\n\n this.clearAllFilters = function() {\n _filters = {};\n };\n\n this.canDrag = this.params.canDrag || _true;\n\n var constrainRect,\n matchingDroppables = [],\n intersectingDroppables = [];\n\n this.downListener = function(e) {\n var isNotRightClick = this.rightButtonCanDrag || (e.which !== 3 && e.button !== 2);\n if (isNotRightClick && this.isEnabled() && this.canDrag()) {\n\n var _f = _testFilter(e) && _inputFilter(e, this.el, this.k);\n if (_f) {\n\n if (selector) {\n elementToDrag = findDelegateElement(this.el, e.target || e.srcElement, selector);\n if(elementToDrag == null) {\n return;\n }\n }\n else {\n elementToDrag = this.el;\n }\n\n if (clone) {\n dragEl = elementToDrag.cloneNode(true);\n this.params.addClass(dragEl, _classes.clonedDrag);\n\n dragEl.setAttribute(\"id\", null);\n dragEl.style.position = \"absolute\";\n\n if (this.params.parent != null) {\n var p = this.params.getPosition(this.el);\n dragEl.style.left = p[0] + \"px\";\n dragEl.style.top = p[1] + \"px\";\n this.params.parent.appendChild(dragEl);\n } else {\n // the clone node is added to the body; getOffsetRect gives us a value\n // relative to the body.\n var b = getOffsetRect(elementToDrag);\n dragEl.style.left = b.left + \"px\";\n dragEl.style.top = b.top + \"px\";\n\n document.body.appendChild(dragEl);\n }\n\n } else {\n dragEl = elementToDrag;\n }\n\n consumeStartEvent && _consume(e);\n downAt = _pl(e);\n if (dragEl && dragEl.parentNode)\n {\n initialScroll = [dragEl.parentNode.scrollLeft, dragEl.parentNode.scrollTop];\n }\n //\n this.params.bind(document, \"mousemove\", this.moveListener);\n this.params.bind(document, \"mouseup\", this.upListener);\n k.markSelection(this);\n k.markPosses(this);\n this.params.addClass(document.body, css.noSelect);\n _dispatch(\"beforeStart\", {el:this.el, pos:posAtDown, e:e, drag:this});\n }\n else if (this.params.consumeFilteredEvents) {\n _consume(e);\n }\n }\n }.bind(this);\n\n this.moveListener = function(e) {\n if (downAt) {\n if (!moving) {\n var _continue = _dispatch(\"start\", {el:this.el, pos:posAtDown, e:e, drag:this});\n if (_continue !== false) {\n if (!downAt) {\n return;\n }\n this.mark(true);\n moving = true;\n } else {\n this.abort();\n }\n }\n\n // it is possible that the start event caused the drag to be aborted. So we check\n // again that we are currently dragging.\n if (downAt) {\n intersectingDroppables.length = 0;\n var pos = _pl(e), dx = pos[0] - downAt[0], dy = pos[1] - downAt[1],\n z = this.params.ignoreZoom ? 1 : k.getZoom();\n if (dragEl && dragEl.parentNode)\n {\n dx += dragEl.parentNode.scrollLeft - initialScroll[0];\n dy += dragEl.parentNode.scrollTop - initialScroll[1];\n }\n dx /= z;\n dy /= z;\n this.moveBy(dx, dy, e);\n k.updateSelection(dx, dy, this);\n k.updatePosses(dx, dy, this);\n }\n }\n }.bind(this);\n\n this.upListener = function(e) {\n if (downAt) {\n downAt = null;\n this.params.unbind(document, \"mousemove\", this.moveListener);\n this.params.unbind(document, \"mouseup\", this.upListener);\n this.params.removeClass(document.body, css.noSelect);\n this.unmark(e);\n k.unmarkSelection(this, e);\n k.unmarkPosses(this, e);\n this.stop(e);\n\n //k.notifySelectionDragStop(this, e); removed in 1.1.0 under the \"leave it for one release in case it breaks\" rule.\n // it isnt necessary to fire this as the normal stop event now includes a `selection` member that has every dragged element.\n // firing this event causes consumers who use the `selection` array to process a lot more drag stop events than is necessary\n\n k.notifyPosseDragStop(this, e);\n moving = false;\n if (clone) {\n dragEl && dragEl.parentNode && dragEl.parentNode.removeChild(dragEl);\n dragEl = null;\n }\n\n intersectingDroppables.length = 0;\n\n if (revertFunction && revertFunction(this.el, this.params.getPosition(this.el)) === true) {\n this.params.setPosition(this.el, posAtDown);\n _dispatch(\"revert\", this.el);\n }\n }\n }.bind(this);\n\n this.getFilters = function() { return _filters; };\n\n this.abort = function() {\n if (downAt != null) {\n this.upListener();\n }\n };\n\n /**\n * Returns the element that was last dragged. This may be some original element from the DOM, or if `clone` is\n * set, then its actually a copy of some original DOM element. In some client calls to this method, it is the\n * actual element that was dragged that is desired. In others, it is the original DOM element that the user\n * wishes to get - in which case, pass true for `retrieveOriginalElement`.\n *\n * @returns {*}\n */\n this.getDragElement = function(retrieveOriginalElement) {\n return retrieveOriginalElement ? elementToDrag || this.el : dragEl || this.el;\n };\n\n var listeners = {\"start\":[], \"drag\":[], \"stop\":[], \"over\":[], \"out\":[], \"beforeStart\":[], \"revert\":[] };\n if (params.events.start) listeners.start.push(params.events.start);\n if (params.events.beforeStart) listeners.beforeStart.push(params.events.beforeStart);\n if (params.events.stop) listeners.stop.push(params.events.stop);\n if (params.events.drag) listeners.drag.push(params.events.drag);\n if (params.events.revert) listeners.revert.push(params.events.revert);\n\n this.on = function(evt, fn) {\n if (listeners[evt]) listeners[evt].push(fn);\n };\n\n this.off = function(evt, fn) {\n if (listeners[evt]) {\n var l = [];\n for (var i = 0; i < listeners[evt].length; i++) {\n if (listeners[evt][i] !== fn) l.push(listeners[evt][i]);\n }\n listeners[evt] = l;\n }\n };\n\n var _dispatch = function(evt, value) {\n var result = null;\n if (listeners[evt]) {\n for (var i = 0; i < listeners[evt].length; i++) {\n try {\n var v = listeners[evt][i](value);\n if (v != null) {\n result = v;\n }\n }\n catch (e) { }\n }\n }\n return result;\n };\n\n this.notifyStart = function(e) {\n _dispatch(\"start\", {el:this.el, pos:this.params.getPosition(dragEl), e:e, drag:this});\n };\n\n this.stop = function(e, force) {\n if (force || moving) {\n var positions = [],\n sel = k.getSelection(),\n dPos = this.params.getPosition(dragEl);\n\n if (sel.length > 1) {\n for (var i = 0; i < sel.length; i++) {\n var p = this.params.getPosition(sel[i].el);\n positions.push([ sel[i].el, { left: p[0], top: p[1] }, sel[i] ]);\n }\n }\n else {\n positions.push([ dragEl, {left:dPos[0], top:dPos[1]}, this ]);\n }\n\n _dispatch(\"stop\", {\n el: dragEl,\n pos: ghostProxyOffsets || dPos,\n finalPos:dPos,\n e: e,\n drag: this,\n selection:positions\n });\n }\n };\n\n this.mark = function(andNotify) {\n posAtDown = this.params.getPosition(dragEl);\n pagePosAtDown = this.params.getPosition(dragEl, true);\n pageDelta = [pagePosAtDown[0] - posAtDown[0], pagePosAtDown[1] - posAtDown[1]];\n this.size = this.params.getSize(dragEl);\n matchingDroppables = k.getMatchingDroppables(this);\n _setDroppablesActive(matchingDroppables, true, false, this);\n this.params.addClass(dragEl, this.params.dragClass || css.drag);\n\n var cs;\n if (this.params.getConstrainingRectangle) {\n cs = this.params.getConstrainingRectangle(dragEl)\n } else {\n cs = this.params.getSize(dragEl.parentNode);\n }\n constrainRect = {w: cs[0], h: cs[1]};\n\n if (andNotify) {\n k.notifySelectionDragStart(this);\n }\n };\n var ghostProxyOffsets;\n this.unmark = function(e, doNotCheckDroppables) {\n _setDroppablesActive(matchingDroppables, false, true, this);\n\n if (isConstrained && useGhostProxy(elementToDrag)) {\n ghostProxyOffsets = [dragEl.offsetLeft, dragEl.offsetTop];\n elementToDrag.parentNode.removeChild(dragEl);\n dragEl = elementToDrag;\n }\n else {\n ghostProxyOffsets = null;\n }\n\n this.params.removeClass(dragEl, this.params.dragClass || css.drag);\n matchingDroppables.length = 0;\n isConstrained = false;\n if (!doNotCheckDroppables) {\n if (intersectingDroppables.length > 0 && ghostProxyOffsets) {\n params.setPosition(elementToDrag, ghostProxyOffsets);\n }\n intersectingDroppables.sort(_rankSort);\n for (var i = 0; i < intersectingDroppables.length; i++) {\n var retVal = intersectingDroppables[i].drop(this, e);\n if (retVal === true) break;\n }\n }\n };\n this.moveBy = function(dx, dy, e) {\n intersectingDroppables.length = 0;\n var desiredLoc = this.toGrid([posAtDown[0] + dx, posAtDown[1] + dy]),\n cPos = constrain(desiredLoc, dragEl, constrainRect, this.size);\n\n if (useGhostProxy(this.el)) {\n if (desiredLoc[0] !== cPos[0] || desiredLoc[1] !== cPos[1]) {\n if (!isConstrained) {\n var gp = ghostProxy(elementToDrag);\n params.addClass(gp, _classes.ghostProxy);\n elementToDrag.parentNode.appendChild(gp);\n dragEl = gp;\n isConstrained = true;\n }\n cPos = desiredLoc;\n }\n else {\n if (isConstrained) {\n elementToDrag.parentNode.removeChild(dragEl);\n dragEl = elementToDrag;\n isConstrained = false;\n }\n }\n }\n\n var rect = { x:cPos[0], y:cPos[1], w:this.size[0], h:this.size[1]},\n pageRect = { x:rect.x + pageDelta[0], y:rect.y + pageDelta[1], w:rect.w, h:rect.h},\n focusDropElement = null;\n\n this.params.setPosition(dragEl, cPos);\n for (var i = 0; i < matchingDroppables.length; i++) {\n var r2 = { x:matchingDroppables[i].pagePosition[0], y:matchingDroppables[i].pagePosition[1], w:matchingDroppables[i].size[0], h:matchingDroppables[i].size[1]};\n if (this.params.intersects(pageRect, r2) && (_multipleDrop || focusDropElement == null || focusDropElement === matchingDroppables[i].el) && matchingDroppables[i].canDrop(this)) {\n if (!focusDropElement) focusDropElement = matchingDroppables[i].el;\n intersectingDroppables.push(matchingDroppables[i]);\n matchingDroppables[i].setHover(this, true, e);\n }\n else if (matchingDroppables[i].isHover()) {\n matchingDroppables[i].setHover(this, false, e);\n }\n }\n\n _dispatch(\"drag\", {el:this.el, pos:cPos, e:e, drag:this});\n\n /* test to see if the parent needs to be scrolled (future)\n if (scroll) {\n var pnsl = dragEl.parentNode.scrollLeft, pnst = dragEl.parentNode.scrollTop;\n console.log(\"scroll!\", pnsl, pnst);\n }*/\n };\n this.destroy = function() {\n this.params.unbind(this.el, \"mousedown\", this.downListener);\n this.params.unbind(document, \"mousemove\", this.moveListener);\n this.params.unbind(document, \"mouseup\", this.upListener);\n this.downListener = null;\n this.upListener = null;\n this.moveListener = null;\n };\n\n // init:register mousedown, and perhaps set a filter\n this.params.bind(this.el, \"mousedown\", this.downListener);\n\n // if handle provded, use that. otherwise, try to set a filter.\n // note that a `handle` selector always results in filterExclude being set to false, ie.\n // the selector defines the handle element(s).\n if (this.params.handle)\n _setFilter(this.params.handle, false);\n else\n _setFilter(this.params.filter, this.params.filterExclude);\n };\n\n var Drop = function(el, params, css, scope) {\n this._class = css.droppable;\n this.params = params || {};\n this.rank = params.rank || 0;\n this._activeClass = this.params.activeClass || css.active;\n this._hoverClass = this.params.hoverClass || css.hover;\n Super.apply(this, arguments);\n var hover = false;\n this.allowLoopback = this.params.allowLoopback !== false;\n\n this.setActive = function(val) {\n this.params[val ? \"addClass\" : \"removeClass\"](this.el, this._activeClass);\n };\n\n this.updatePosition = function() {\n this.position = this.params.getPosition(this.el);\n this.pagePosition = this.params.getPosition(this.el, true);\n this.size = this.params.getSize(this.el);\n };\n\n this.canDrop = this.params.canDrop || function(drag) {\n return true;\n };\n\n this.isHover = function() { return hover; };\n\n this.setHover = function(drag, val, e) {\n // if turning off hover but this was not the drag that caused the hover, ignore.\n if (val || this.el._katavorioDragHover == null || this.el._katavorioDragHover === drag.el._katavorio) {\n this.params[val ? \"addClass\" : \"removeClass\"](this.el, this._hoverClass);\n this.el._katavorioDragHover = val ? drag.el._katavorio : null;\n if (hover !== val) {\n this.params.events[val ? \"over\" : \"out\"]({el: this.el, e: e, drag: drag, drop: this});\n }\n hover = val;\n }\n };\n\n /**\n * A drop event. `drag` is the corresponding Drag object, which may be a Drag for some specific element, or it\n * may be a Drag on some element acting as a delegate for elements contained within it.\n * @param drag\n * @param event\n * @returns {*}\n */\n this.drop = function(drag, event) {\n return this.params.events[\"drop\"]({ drag:drag, e:event, drop:this });\n };\n\n this.destroy = function() {\n this._class = null;\n this._activeClass = null;\n this._hoverClass = null;\n hover = null;\n };\n };\n\n var _uuid = function() {\n return ('xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\n var r = Math.random()*16|0, v = c === 'x' ? r : (r&0x3|0x8);\n return v.toString(16);\n }));\n };\n\n var _rankSort = function(a,b) {\n return a.rank < b.rank ? 1 : a.rank > b.rank ? -1 : 0;\n };\n\n var _gel = function(el) {\n if (el == null) return null;\n el = (typeof el === \"string\" || el.constructor === String) ? document.getElementById(el) : el;\n if (el == null) return null;\n el._katavorio = el._katavorio || _uuid();\n return el;\n };\n\n root.Katavorio = function(katavorioParams) {\n\n var _selection = [],\n _selectionMap = {};\n\n this._dragsByScope = {};\n this._dropsByScope = {};\n var _zoom = 1,\n _reg = function(obj, map) {\n _each(obj, function(_obj) {\n for(var i = 0; i < _obj.scopes.length; i++) {\n map[_obj.scopes[i]] = map[_obj.scopes[i]] || [];\n map[_obj.scopes[i]].push(_obj);\n }\n });\n },\n _unreg = function(obj, map) {\n var c = 0;\n _each(obj, function(_obj) {\n for(var i = 0; i < _obj.scopes.length; i++) {\n if (map[_obj.scopes[i]]) {\n var idx = katavorioParams.indexOf(map[_obj.scopes[i]], _obj);\n if (idx !== -1) {\n map[_obj.scopes[i]].splice(idx, 1);\n c++;\n }\n }\n }\n });\n\n return c > 0 ;\n },\n _getMatchingDroppables = this.getMatchingDroppables = function(drag) {\n var dd = [], _m = {};\n for (var i = 0; i < drag.scopes.length; i++) {\n var _dd = this._dropsByScope[drag.scopes[i]];\n if (_dd) {\n for (var j = 0; j < _dd.length; j++) {\n if (_dd[j].canDrop(drag) && !_m[_dd[j].uuid] && (_dd[j].allowLoopback || _dd[j].el !== drag.el)) {\n _m[_dd[j].uuid] = true;\n dd.push(_dd[j]);\n }\n }\n }\n }\n dd.sort(_rankSort);\n return dd;\n },\n _prepareParams = function(p) {\n p = p || {};\n var _p = {\n events:{}\n }, i;\n for (i in katavorioParams) _p[i] = katavorioParams[i];\n for (i in p) _p[i] = p[i];\n // events\n\n for (i = 0; i < _events.length; i++) {\n _p.events[_events[i]] = p[_events[i]] || _devNull;\n }\n _p.katavorio = this;\n return _p;\n }.bind(this),\n _mistletoe = function(existingDrag, params) {\n for (var i = 0; i < _events.length; i++) {\n if (params[_events[i]]) {\n existingDrag.on(_events[i], params[_events[i]]);\n }\n }\n }.bind(this),\n _css = {},\n overrideCss = katavorioParams.css || {},\n _scope = katavorioParams.scope || _defaultScope;\n\n // prepare map of css classes based on defaults frst, then optional overrides\n for (var i in _classes) _css[i] = _classes[i];\n for (var i in overrideCss) _css[i] = overrideCss[i];\n\n var inputFilterSelector = katavorioParams.inputFilterSelector || _defaultInputFilterSelector;\n /**\n * Gets the selector identifying which input elements to filter from drag events.\n * @method getInputFilterSelector\n * @return {String} Current input filter selector.\n */\n this.getInputFilterSelector = function() { return inputFilterSelector; };\n\n /**\n * Sets the selector identifying which input elements to filter from drag events.\n * @method setInputFilterSelector\n * @param {String} selector Input filter selector to set.\n * @return {Katavorio} Current instance; method may be chained.\n */\n this.setInputFilterSelector = function(selector) {\n inputFilterSelector = selector;\n return this;\n };\n\n /**\n * Either makes the given element draggable, or identifies it as an element inside which some identified list\n * of elements may be draggable.\n * @param el\n * @param params\n * @returns {Array}\n */\n this.draggable = function(el, params) {\n var o = [];\n _each(el, function (_el) {\n _el = _gel(_el);\n if (_el != null) {\n if (_el._katavorioDrag == null) {\n var p = _prepareParams(params);\n _el._katavorioDrag = new Drag(_el, p, _css, _scope);\n _reg(_el._katavorioDrag, this._dragsByScope);\n o.push(_el._katavorioDrag);\n katavorioParams.addClass(_el, _css.draggable);\n }\n else {\n _mistletoe(_el._katavorioDrag, params);\n }\n }\n }.bind(this));\n return o;\n };\n\n this.droppable = function(el, params) {\n var o = [];\n _each(el, function(_el) {\n _el = _gel(_el);\n if (_el != null) {\n var drop = new Drop(_el, _prepareParams(params), _css, _scope);\n _el._katavorioDrop = _el._katavorioDrop || [];\n _el._katavorioDrop.push(drop);\n _reg(drop, this._dropsByScope);\n o.push(drop);\n katavorioParams.addClass(_el, _css.droppable);\n }\n }.bind(this));\n return o;\n };\n\n /**\n * @name Katavorio#select\n * @function\n * @desc Adds an element to the current selection (for multiple node drag)\n * @param {Element|String} DOM element - or id of the element - to add.\n */\n this.select = function(el) {\n _each(el, function() {\n var _el = _gel(this);\n if (_el && _el._katavorioDrag) {\n if (!_selectionMap[_el._katavorio]) {\n _selection.push(_el._katavorioDrag);\n _selectionMap[_el._katavorio] = [ _el, _selection.length - 1 ];\n katavorioParams.addClass(_el, _css.selected);\n }\n }\n });\n return this;\n };\n\n /**\n * @name Katavorio#deselect\n * @function\n * @desc Removes an element from the current selection (for multiple node drag)\n * @param {Element|String} DOM element - or id of the element - to remove.\n */\n this.deselect = function(el) {\n _each(el, function() {\n var _el = _gel(this);\n if (_el && _el._katavorio) {\n var e = _selectionMap[_el._katavorio];\n if (e) {\n var _s = [];\n for (var i = 0; i < _selection.length; i++)\n if (_selection[i].el !== _el) _s.push(_selection[i]);\n _selection = _s;\n delete _selectionMap[_el._katavorio];\n katavorioParams.removeClass(_el, _css.selected);\n }\n }\n });\n return this;\n };\n\n this.deselectAll = function() {\n for (var i in _selectionMap) {\n var d = _selectionMap[i];\n katavorioParams.removeClass(d[0], _css.selected);\n }\n\n _selection.length = 0;\n _selectionMap = {};\n };\n\n this.markSelection = function(drag) {\n _foreach(_selection, function(e) { e.mark(); }, drag);\n };\n\n this.markPosses = function(drag) {\n if (drag.posses) {\n _each(drag.posses, function(p) {\n if (drag.posseRoles[p] && _posses[p]) {\n _foreach(_posses[p].members, function (d) {\n d.mark();\n }, drag);\n }\n })\n }\n };\n\n this.unmarkSelection = function(drag, event) {\n _foreach(_selection, function(e) { e.unmark(event); }, drag);\n };\n\n this.unmarkPosses = function(drag, event) {\n if (drag.posses) {\n _each(drag.posses, function(p) {\n if (drag.posseRoles[p] && _posses[p]) {\n _foreach(_posses[p].members, function (d) {\n d.unmark(event, true);\n }, drag);\n }\n });\n }\n };\n\n this.getSelection = function() { return _selection.slice(0); };\n\n this.updateSelection = function(dx, dy, drag) {\n _foreach(_selection, function(e) { e.moveBy(dx, dy); }, drag);\n };\n\n var _posseAction = function(fn, drag) {\n if (drag.posses) {\n _each(drag.posses, function(p) {\n if (drag.posseRoles[p] && _posses[p]) {\n _foreach(_posses[p].members, function (e) {\n fn(e);\n }, drag);\n }\n });\n }\n };\n\n this.updatePosses = function(dx, dy, drag) {\n _posseAction(function(e) { e.moveBy(dx, dy); }, drag);\n };\n\n this.notifyPosseDragStop = function(drag, evt) {\n _posseAction(function(e) { e.stop(evt, true); }, drag);\n };\n\n this.notifySelectionDragStop = function(drag, evt) {\n _foreach(_selection, function(e) { e.stop(evt, true); }, drag);\n };\n\n this.notifySelectionDragStart = function(drag, evt) {\n _foreach(_selection, function(e) { e.notifyStart(evt);}, drag);\n };\n\n this.setZoom = function(z) { _zoom = z; };\n this.getZoom = function() { return _zoom; };\n\n // does the work of changing scopes\n var _scopeManip = function(kObj, scopes, map, fn) {\n _each(kObj, function(_kObj) {\n _unreg(_kObj, map); // deregister existing scopes\n _kObj[fn](scopes); // set scopes\n _reg(_kObj, map); // register new ones\n });\n };\n\n _each([ \"set\", \"add\", \"remove\", \"toggle\"], function(v) {\n this[v + \"Scope\"] = function(el, scopes) {\n _scopeManip(el._katavorioDrag, scopes, this._dragsByScope, v + \"Scope\");\n _scopeManip(el._katavorioDrop, scopes, this._dropsByScope, v + \"Scope\");\n }.bind(this);\n this[v + \"DragScope\"] = function(el, scopes) {\n _scopeManip(el.constructor === Drag ? el : el._katavorioDrag, scopes, this._dragsByScope, v + \"Scope\");\n }.bind(this);\n this[v + \"DropScope\"] = function(el, scopes) {\n _scopeManip(el.constructor === Drop ? el : el._katavorioDrop, scopes, this._dropsByScope, v + \"Scope\");\n }.bind(this);\n }.bind(this));\n\n this.snapToGrid = function(x, y) {\n for (var s in this._dragsByScope) {\n _foreach(this._dragsByScope[s], function(d) { d.snap(x, y); });\n }\n };\n\n this.getDragsForScope = function(s) { return this._dragsByScope[s]; };\n this.getDropsForScope = function(s) { return this._dropsByScope[s]; };\n\n var _destroy = function(el, type, map) {\n el = _gel(el);\n if (el[type]) {\n\n // remove from selection, if present.\n var selIdx = _selection.indexOf(el[type]);\n if (selIdx >= 0) {\n _selection.splice(selIdx, 1);\n }\n\n if (_unreg(el[type], map)) {\n _each(el[type], function(kObj) { kObj.destroy() });\n }\n\n delete el[type];\n }\n };\n\n var _removeListener = function(el, type, evt, fn) {\n el = _gel(el);\n if (el[type]) {\n el[type].off(evt, fn);\n }\n };\n\n this.elementRemoved = function(el) {\n this.destroyDraggable(el);\n this.destroyDroppable(el);\n };\n\n /**\n * Either completely remove drag functionality from the given element, or remove a specific event handler. If you\n * call this method with a single argument - the element - all drag functionality is removed from it. Otherwise, if\n * you provide an event name and listener function, this function is de-registered (if found).\n * @param el Element to update\n * @param {string} [evt] Optional event name to unsubscribe\n * @param {Function} [fn] Optional function to unsubscribe\n */\n this.destroyDraggable = function(el, evt, fn) {\n if (arguments.length === 1) {\n _destroy(el, \"_katavorioDrag\", this._dragsByScope);\n } else {\n _removeListener(el, \"_katavorioDrag\", evt, fn);\n }\n };\n\n /**\n * Either completely remove drop functionality from the given element, or remove a specific event handler. If you\n * call this method with a single argument - the element - all drop functionality is removed from it. Otherwise, if\n * you provide an event name and listener function, this function is de-registered (if found).\n * @param el Element to update\n * @param {string} [evt] Optional event name to unsubscribe\n * @param {Function} [fn] Optional function to unsubscribe\n */\n this.destroyDroppable = function(el, evt, fn) {\n if (arguments.length === 1) {\n _destroy(el, \"_katavorioDrop\", this._dropsByScope);\n } else {\n _removeListener(el, \"_katavorioDrop\", evt, fn);\n }\n };\n\n this.reset = function() {\n this._dragsByScope = {};\n this._dropsByScope = {};\n _selection = [];\n _selectionMap = {};\n _posses = {};\n };\n\n // ----- groups\n var _posses = {};\n\n var _processOneSpec = function(el, _spec, dontAddExisting) {\n var posseId = _isString(_spec) ? _spec : _spec.id;\n var active = _isString(_spec) ? true : _spec.active !== false;\n var posse = _posses[posseId] || (function() {\n var g = {name:posseId, members:[]};\n _posses[posseId] = g;\n return g;\n })();\n _each(el, function(_el) {\n if (_el._katavorioDrag) {\n\n if (dontAddExisting && _el._katavorioDrag.posseRoles[posse.name] != null) return;\n\n _suggest(posse.members, _el._katavorioDrag);\n _suggest(_el._katavorioDrag.posses, posse.name);\n _el._katavorioDrag.posseRoles[posse.name] = active;\n }\n });\n return posse;\n };\n\n /**\n * Add the given element to the posse with the given id, creating the group if it at first does not exist.\n * @method addToPosse\n * @param {Element} el Element to add.\n * @param {String...|Object...} spec Variable args parameters. Each argument can be a either a String, indicating\n * the ID of a Posse to which the element should be added as an active participant, or an Object containing\n * `{ id:\"posseId\", active:false/true}`. In the latter case, if `active` is not provided it is assumed to be\n * true.\n * @returns {Posse|Posse[]} The Posse(s) to which the element(s) was/were added.\n */\n this.addToPosse = function(el, spec) {\n\n var posses = [];\n\n for (var i = 1; i < arguments.length; i++) {\n posses.push(_processOneSpec(el, arguments[i]));\n }\n\n return posses.length === 1 ? posses[0] : posses;\n };\n\n /**\n * Sets the posse(s) for the element with the given id, creating those that do not yet exist, and removing from\n * the element any current Posses that are not specified by this method call. This method will not change the\n * active/passive state if it is given a posse in which the element is already a member.\n * @method setPosse\n * @param {Element} el Element to set posse(s) on.\n * @param {String...|Object...} spec Variable args parameters. Each argument can be a either a String, indicating\n * the ID of a Posse to which the element should be added as an active participant, or an Object containing\n * `{ id:\"posseId\", active:false/true}`. In the latter case, if `active` is not provided it is assumed to be\n * true.\n * @returns {Posse|Posse[]} The Posse(s) to which the element(s) now belongs.\n */\n this.setPosse = function(el, spec) {\n\n var posses = [];\n\n for (var i = 1; i < arguments.length; i++) {\n posses.push(_processOneSpec(el, arguments[i], true).name);\n }\n\n _each(el, function(_el) {\n if (_el._katavorioDrag) {\n var diff = _difference(_el._katavorioDrag.posses, posses);\n var p = [];\n Array.prototype.push.apply(p, _el._katavorioDrag.posses);\n for (var i = 0; i < diff.length; i++) {\n this.removeFromPosse(_el, diff[i]);\n }\n }\n }.bind(this));\n\n return posses.length === 1 ? posses[0] : posses;\n };\n\n /**\n * Remove the given element from the given posse(s).\n * @method removeFromPosse\n * @param {Element} el Element to remove.\n * @param {String...} posseId Varargs parameter: one value for each posse to remove the element from.\n */\n this.removeFromPosse = function(el, posseId) {\n if (arguments.length < 2) throw new TypeError(\"No posse id provided for remove operation\");\n for(var i = 1; i < arguments.length; i++) {\n posseId = arguments[i];\n _each(el, function (_el) {\n if (_el._katavorioDrag && _el._katavorioDrag.posses) {\n var d = _el._katavorioDrag;\n _each(posseId, function (p) {\n _vanquish(_posses[p].members, d);\n _vanquish(d.posses, p);\n delete d.posseRoles[p];\n });\n }\n });\n }\n };\n\n /**\n * Remove the given element from all Posses to which it belongs.\n * @method removeFromAllPosses\n * @param {Element|Element[]} el Element to remove from Posses.\n */\n this.removeFromAllPosses = function(el) {\n _each(el, function(_el) {\n if (_el._katavorioDrag && _el._katavorioDrag.posses) {\n var d = _el._katavorioDrag;\n _each(d.posses, function(p) {\n _vanquish(_posses[p].members, d);\n });\n d.posses.length = 0;\n d.posseRoles = {};\n }\n });\n };\n\n /**\n * Changes the participation state for the element in the Posse with the given ID.\n * @param {Element|Element[]} el Element(s) to change state for.\n * @param {String} posseId ID of the Posse to change element state for.\n * @param {Boolean} state True to make active, false to make passive.\n */\n this.setPosseState = function(el, posseId, state) {\n var posse = _posses[posseId];\n if (posse) {\n _each(el, function(_el) {\n if (_el._katavorioDrag && _el._katavorioDrag.posses) {\n _el._katavorioDrag.posseRoles[posse.name] = state;\n }\n });\n }\n };\n\n };\n\n root.Katavorio.version = \"1.0.0\";\n\n if (typeof exports !== \"undefined\") {\n exports.Katavorio = root.Katavorio;\n }\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n\n(function() {\n\n var root = this;\n root.jsPlumbUtil = root.jsPlumbUtil || {};\n var jsPlumbUtil = root.jsPlumbUtil;\n\n if (typeof exports !=='undefined') { exports.jsPlumbUtil = jsPlumbUtil;}\n\n\n function isArray(a) {\n return Object.prototype.toString.call(a) === \"[object Array]\";\n }\n jsPlumbUtil.isArray = isArray;\n function isNumber(n) {\n return Object.prototype.toString.call(n) === \"[object Number]\";\n }\n jsPlumbUtil.isNumber = isNumber;\n function isString(s) {\n return typeof s === \"string\";\n }\n jsPlumbUtil.isString = isString;\n function isBoolean(s) {\n return typeof s === \"boolean\";\n }\n jsPlumbUtil.isBoolean = isBoolean;\n function isNull(s) {\n return s == null;\n }\n jsPlumbUtil.isNull = isNull;\n function isObject(o) {\n return o == null ? false : Object.prototype.toString.call(o) === \"[object Object]\";\n }\n jsPlumbUtil.isObject = isObject;\n function isDate(o) {\n return Object.prototype.toString.call(o) === \"[object Date]\";\n }\n jsPlumbUtil.isDate = isDate;\n function isFunction(o) {\n return Object.prototype.toString.call(o) === \"[object Function]\";\n }\n jsPlumbUtil.isFunction = isFunction;\n function isNamedFunction(o) {\n return isFunction(o) && o.name != null && o.name.length > 0;\n }\n jsPlumbUtil.isNamedFunction = isNamedFunction;\n function isEmpty(o) {\n for (var i in o) {\n if (o.hasOwnProperty(i)) {\n return false;\n }\n }\n return true;\n }\n jsPlumbUtil.isEmpty = isEmpty;\n function clone(a) {\n if (isString(a)) {\n return \"\" + a;\n }\n else if (isBoolean(a)) {\n return !!a;\n }\n else if (isDate(a)) {\n return new Date(a.getTime());\n }\n else if (isFunction(a)) {\n return a;\n }\n else if (isArray(a)) {\n var b = [];\n for (var i = 0; i < a.length; i++) {\n b.push(clone(a[i]));\n }\n return b;\n }\n else if (isObject(a)) {\n var c = {};\n for (var j in a) {\n c[j] = clone(a[j]);\n }\n return c;\n }\n else {\n return a;\n }\n }\n jsPlumbUtil.clone = clone;\n function merge(a, b, collations, overwrites) {\n // first change the collations array - if present - into a lookup table, because its faster.\n var cMap = {}, ar, i, oMap = {};\n collations = collations || [];\n overwrites = overwrites || [];\n for (i = 0; i < collations.length; i++) {\n cMap[collations[i]] = true;\n }\n for (i = 0; i < overwrites.length; i++) {\n oMap[overwrites[i]] = true;\n }\n var c = clone(a);\n for (i in b) {\n if (c[i] == null || oMap[i]) {\n c[i] = b[i];\n }\n else if (isString(b[i]) || isBoolean(b[i])) {\n if (!cMap[i]) {\n c[i] = b[i]; // if we dont want to collate, just copy it in.\n }\n else {\n ar = [];\n // if c's object is also an array we can keep its values.\n ar.push.apply(ar, isArray(c[i]) ? c[i] : [c[i]]);\n ar.push.apply(ar, isBoolean(b[i]) ? b[i] : [b[i]]);\n c[i] = ar;\n }\n }\n else {\n if (isArray(b[i])) {\n ar = [];\n // if c's object is also an array we can keep its values.\n if (isArray(c[i])) {\n ar.push.apply(ar, c[i]);\n }\n ar.push.apply(ar, b[i]);\n c[i] = ar;\n }\n else if (isObject(b[i])) {\n // overwrite c's value with an object if it is not already one.\n if (!isObject(c[i])) {\n c[i] = {};\n }\n for (var j in b[i]) {\n c[i][j] = b[i][j];\n }\n }\n }\n }\n return c;\n }\n jsPlumbUtil.merge = merge;\n function replace(inObj, path, value) {\n if (inObj == null) {\n return;\n }\n var q = inObj, t = q;\n path.replace(/([^\\.])+/g, function (term, lc, pos, str) {\n var array = term.match(/([^\\[0-9]+){1}(\\[)([0-9+])/), last = pos + term.length >= str.length, _getArray = function () {\n return t[array[1]] || (function () {\n t[array[1]] = [];\n return t[array[1]];\n })();\n };\n if (last) {\n // set term = value on current t, creating term as array if necessary.\n if (array) {\n _getArray()[array[3]] = value;\n }\n else {\n t[term] = value;\n }\n }\n else {\n // set to current t[term], creating t[term] if necessary.\n if (array) {\n var a_1 = _getArray();\n t = a_1[array[3]] || (function () {\n a_1[array[3]] = {};\n return a_1[array[3]];\n })();\n }\n else {\n t = t[term] || (function () {\n t[term] = {};\n return t[term];\n })();\n }\n }\n return \"\";\n });\n return inObj;\n }\n jsPlumbUtil.replace = replace;\n //\n // chain a list of functions, supplied by [ object, method name, args ], and return on the first\n // one that returns the failValue. if none return the failValue, return the successValue.\n //\n function functionChain(successValue, failValue, fns) {\n for (var i = 0; i < fns.length; i++) {\n var o = fns[i][0][fns[i][1]].apply(fns[i][0], fns[i][2]);\n if (o === failValue) {\n return o;\n }\n }\n return successValue;\n }\n jsPlumbUtil.functionChain = functionChain;\n /**\n *\n * Take the given model and expand out any parameters. 'functionPrefix' is optional, and if present, helps jsplumb figure out what to do if a value is a Function.\n * if you do not provide it (and doNotExpandFunctions is null, or false), jsplumb will run the given values through any functions it finds, and use the function's\n * output as the value in the result. if you do provide the prefix, only functions that are named and have this prefix\n * will be executed; other functions will be passed as values to the output.\n *\n * @param model\n * @param values\n * @param functionPrefix\n * @param doNotExpandFunctions\n * @returns {any}\n */\n function populate(model, values, functionPrefix, doNotExpandFunctions) {\n // for a string, see if it has parameter matches, and if so, try to make the substitutions.\n var getValue = function (fromString) {\n var matches = fromString.match(/(\\${.*?})/g);\n if (matches != null) {\n for (var i = 0; i < matches.length; i++) {\n var val = values[matches[i].substring(2, matches[i].length - 1)] || \"\";\n if (val != null) {\n fromString = fromString.replace(matches[i], val);\n }\n }\n }\n return fromString;\n };\n // process one entry.\n var _one = function (d) {\n if (d != null) {\n if (isString(d)) {\n return getValue(d);\n }\n else if (isFunction(d) && !doNotExpandFunctions && (functionPrefix == null || (d.name || \"\").indexOf(functionPrefix) === 0)) {\n return d(values);\n }\n else if (isArray(d)) {\n var r = [];\n for (var i = 0; i < d.length; i++) {\n r.push(_one(d[i]));\n }\n return r;\n }\n else if (isObject(d)) {\n var s = {};\n for (var j in d) {\n s[j] = _one(d[j]);\n }\n return s;\n }\n else {\n return d;\n }\n }\n };\n return _one(model);\n }\n jsPlumbUtil.populate = populate;\n function findWithFunction(a, f) {\n if (a) {\n for (var i = 0; i < a.length; i++) {\n if (f(a[i])) {\n return i;\n }\n }\n }\n return -1;\n }\n jsPlumbUtil.findWithFunction = findWithFunction;\n function removeWithFunction(a, f) {\n var idx = findWithFunction(a, f);\n if (idx > -1) {\n a.splice(idx, 1);\n }\n return idx !== -1;\n }\n jsPlumbUtil.removeWithFunction = removeWithFunction;\n function remove(l, v) {\n var idx = l.indexOf(v);\n if (idx > -1) {\n l.splice(idx, 1);\n }\n return idx !== -1;\n }\n jsPlumbUtil.remove = remove;\n function addWithFunction(list, item, hashFunction) {\n if (findWithFunction(list, hashFunction) === -1) {\n list.push(item);\n }\n }\n jsPlumbUtil.addWithFunction = addWithFunction;\n function addToList(map, key, value, insertAtStart) {\n var l = map[key];\n if (l == null) {\n l = [];\n map[key] = l;\n }\n l[insertAtStart ? \"unshift\" : \"push\"](value);\n return l;\n }\n jsPlumbUtil.addToList = addToList;\n function suggest(list, item, insertAtHead) {\n if (list.indexOf(item) === -1) {\n if (insertAtHead) {\n list.unshift(item);\n }\n else {\n list.push(item);\n }\n return true;\n }\n return false;\n }\n jsPlumbUtil.suggest = suggest;\n //\n // extends the given obj (which can be an array) with the given constructor function, prototype functions, and\n // class members, any of which may be null.\n //\n function extend(child, parent, _protoFn) {\n var i;\n parent = isArray(parent) ? parent : [parent];\n var _copyProtoChain = function (focus) {\n var proto = focus.__proto__;\n while (proto != null) {\n if (proto.prototype != null) {\n for (var j in proto.prototype) {\n if (proto.prototype.hasOwnProperty(j) && !child.prototype.hasOwnProperty(j)) {\n child.prototype[j] = proto.prototype[j];\n }\n }\n proto = proto.prototype.__proto__;\n }\n else {\n proto = null;\n }\n }\n };\n for (i = 0; i < parent.length; i++) {\n for (var j in parent[i].prototype) {\n if (parent[i].prototype.hasOwnProperty(j) && !child.prototype.hasOwnProperty(j)) {\n child.prototype[j] = parent[i].prototype[j];\n }\n }\n _copyProtoChain(parent[i]);\n }\n var _makeFn = function (name, protoFn) {\n return function () {\n for (i = 0; i < parent.length; i++) {\n if (parent[i].prototype[name]) {\n parent[i].prototype[name].apply(this, arguments);\n }\n }\n return protoFn.apply(this, arguments);\n };\n };\n var _oneSet = function (fns) {\n for (var k in fns) {\n child.prototype[k] = _makeFn(k, fns[k]);\n }\n };\n if (arguments.length > 2) {\n for (i = 2; i < arguments.length; i++) {\n _oneSet(arguments[i]);\n }\n }\n return child;\n }\n jsPlumbUtil.extend = extend;\n function uuid() {\n return ('xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);\n return v.toString(16);\n }));\n }\n jsPlumbUtil.uuid = uuid;\n function fastTrim(s) {\n if (s == null) {\n return null;\n }\n var str = s.replace(/^\\s\\s*/, ''), ws = /\\s/, i = str.length;\n while (ws.test(str.charAt(--i))) {\n }\n return str.slice(0, i + 1);\n }\n jsPlumbUtil.fastTrim = fastTrim;\n function each(obj, fn) {\n obj = obj.length == null || typeof obj === \"string\" ? [obj] : obj;\n for (var i = 0; i < obj.length; i++) {\n fn(obj[i]);\n }\n }\n jsPlumbUtil.each = each;\n function map(obj, fn) {\n var o = [];\n for (var i = 0; i < obj.length; i++) {\n o.push(fn(obj[i]));\n }\n return o;\n }\n jsPlumbUtil.map = map;\n function mergeWithParents(type, map, parentAttribute) {\n parentAttribute = parentAttribute || \"parent\";\n var _def = function (id) {\n return id ? map[id] : null;\n };\n var _parent = function (def) {\n return def ? _def(def[parentAttribute]) : null;\n };\n var _one = function (parent, def) {\n if (parent == null) {\n return def;\n }\n else {\n var d_1 = merge(parent, def);\n return _one(_parent(parent), d_1);\n }\n };\n var _getDef = function (t) {\n if (t == null) {\n return {};\n }\n if (typeof t === \"string\") {\n return _def(t);\n }\n else if (t.length) {\n var done = false, i = 0, _dd = void 0;\n while (!done && i < t.length) {\n _dd = _getDef(t[i]);\n if (_dd) {\n done = true;\n }\n else {\n i++;\n }\n }\n return _dd;\n }\n };\n var d = _getDef(type);\n if (d) {\n return _one(_parent(d), d);\n }\n else {\n return {};\n }\n }\n jsPlumbUtil.mergeWithParents = mergeWithParents;\n jsPlumbUtil.logEnabled = true;\n function log() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n if (jsPlumbUtil.logEnabled && typeof console !== \"undefined\") {\n try {\n var msg = arguments[arguments.length - 1];\n console.log(msg);\n }\n catch (e) {\n }\n }\n }\n jsPlumbUtil.log = log;\n /**\n * Wraps one function with another, creating a placeholder for the\n * wrapped function if it was null. this is used to wrap the various\n * drag/drop event functions - to allow jsPlumb to be notified of\n * important lifecycle events without imposing itself on the user's\n * drag/drop functionality.\n * @method jsPlumbUtil.wrap\n * @param {Function} wrappedFunction original function to wrap; may be null.\n * @param {Function} newFunction function to wrap the original with.\n * @param {Object} [returnOnThisValue] Optional. Indicates that the wrappedFunction should\n * not be executed if the newFunction returns a value matching 'returnOnThisValue'.\n * note that this is a simple comparison and only works for primitives right now.\n */\n function wrap(wrappedFunction, newFunction, returnOnThisValue) {\n return function () {\n var r = null;\n try {\n if (newFunction != null) {\n r = newFunction.apply(this, arguments);\n }\n }\n catch (e) {\n log(\"jsPlumb function failed : \" + e);\n }\n if ((wrappedFunction != null) && (returnOnThisValue == null || (r !== returnOnThisValue))) {\n try {\n r = wrappedFunction.apply(this, arguments);\n }\n catch (e) {\n log(\"wrapped function failed : \" + e);\n }\n }\n return r;\n };\n }\n jsPlumbUtil.wrap = wrap;\n var EventGenerator = /** @class */ (function () {\n function EventGenerator() {\n var _this = this;\n this._listeners = {};\n this.eventsSuspended = false;\n this.tick = false;\n // this is a list of events that should re-throw any errors that occur during their dispatch.\n this.eventsToDieOn = { \"ready\": true };\n this.queue = [];\n this.bind = function (event, listener, insertAtStart) {\n var _one = function (evt) {\n addToList(_this._listeners, evt, listener, insertAtStart);\n listener.__jsPlumb = listener.__jsPlumb || {};\n listener.__jsPlumb[uuid()] = evt;\n };\n if (typeof event === \"string\") {\n _one(event);\n }\n else if (event.length != null) {\n for (var i = 0; i < event.length; i++) {\n _one(event[i]);\n }\n }\n return _this;\n };\n this.fire = function (event, value, originalEvent) {\n if (!this.tick) {\n this.tick = true;\n if (!this.eventsSuspended && this._listeners[event]) {\n var l = this._listeners[event].length, i = 0, _gone = false, ret = null;\n if (!this.shouldFireEvent || this.shouldFireEvent(event, value, originalEvent)) {\n while (!_gone && i < l && ret !== false) {\n // doing it this way rather than catching and then possibly re-throwing means that an error propagated by this\n // method will have the whole call stack available in the debugger.\n if (this.eventsToDieOn[event]) {\n this._listeners[event][i].apply(this, [value, originalEvent]);\n }\n else {\n try {\n ret = this._listeners[event][i].apply(this, [value, originalEvent]);\n }\n catch (e) {\n log(\"jsPlumb: fire failed for event \" + event + \" : \" + e);\n }\n }\n i++;\n if (this._listeners == null || this._listeners[event] == null) {\n _gone = true;\n }\n }\n }\n }\n this.tick = false;\n this._drain();\n }\n else {\n this.queue.unshift(arguments);\n }\n return this;\n };\n this._drain = function () {\n var n = _this.queue.pop();\n if (n) {\n _this.fire.apply(_this, n);\n }\n };\n this.unbind = function (eventOrListener, listener) {\n if (arguments.length === 0) {\n this._listeners = {};\n }\n else if (arguments.length === 1) {\n if (typeof eventOrListener === \"string\") {\n delete this._listeners[eventOrListener];\n }\n else if (eventOrListener.__jsPlumb) {\n var evt = void 0;\n for (var i in eventOrListener.__jsPlumb) {\n evt = eventOrListener.__jsPlumb[i];\n remove(this._listeners[evt] || [], eventOrListener);\n }\n }\n }\n else if (arguments.length === 2) {\n remove(this._listeners[eventOrListener] || [], listener);\n }\n return this;\n };\n this.getListener = function (forEvent) {\n return _this._listeners[forEvent];\n };\n this.setSuspendEvents = function (val) {\n _this.eventsSuspended = val;\n };\n this.isSuspendEvents = function () {\n return _this.eventsSuspended;\n };\n this.silently = function (fn) {\n _this.setSuspendEvents(true);\n try {\n fn();\n }\n catch (e) {\n log(\"Cannot execute silent function \" + e);\n }\n _this.setSuspendEvents(false);\n };\n this.cleanupListeners = function () {\n for (var i in _this._listeners) {\n _this._listeners[i] = null;\n }\n };\n }\n return EventGenerator;\n }());\n jsPlumbUtil.EventGenerator = EventGenerator;\n\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains utility functions that run in browsers only.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n ;(function() {\n\n \"use strict\";\n\n var root = this;\n\n root.jsPlumbUtil.matchesSelector = function(el, selector, ctx) {\n ctx = ctx || el.parentNode;\n var possibles = ctx.querySelectorAll(selector);\n for (var i = 0; i < possibles.length; i++) {\n if (possibles[i] === el) {\n return true;\n }\n }\n return false;\n };\n\n root.jsPlumbUtil.consume = function(e, doNotPreventDefault) {\n if (e.stopPropagation) {\n e.stopPropagation();\n }\n else {\n e.returnValue = false;\n }\n\n if (!doNotPreventDefault && e.preventDefault){\n e.preventDefault();\n }\n };\n\n /*\n * Function: sizeElement\n * Helper to size and position an element. You would typically use\n * this when writing your own Connector or Endpoint implementation.\n *\n * Parameters:\n * x - [int] x position for the element origin\n * y - [int] y position for the element origin\n * w - [int] width of the element\n * h - [int] height of the element\n *\n */\n root.jsPlumbUtil.sizeElement = function(el, x, y, w, h) {\n if (el) {\n el.style.height = h + \"px\";\n el.height = h;\n el.style.width = w + \"px\";\n el.width = w;\n el.style.left = x + \"px\";\n el.style.top = y + \"px\";\n }\n };\n\n }).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * This file contains the core code.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;(function () {\n\n \"use strict\";\n\n var root = this;\n\n var _ju = root.jsPlumbUtil,\n\n /**\n * creates a timestamp, using milliseconds since 1970, but as a string.\n */\n _timestamp = function () {\n return \"\" + (new Date()).getTime();\n },\n\n // helper method to update the hover style whenever it, or paintStyle, changes.\n // we use paintStyle as the foundation and merge hoverPaintStyle over the\n // top.\n _updateHoverStyle = function (component) {\n if (component._jsPlumb.paintStyle && component._jsPlumb.hoverPaintStyle) {\n var mergedHoverStyle = {};\n jsPlumb.extend(mergedHoverStyle, component._jsPlumb.paintStyle);\n jsPlumb.extend(mergedHoverStyle, component._jsPlumb.hoverPaintStyle);\n delete component._jsPlumb.hoverPaintStyle;\n // we want the fill of paintStyle to override a gradient, if possible.\n if (mergedHoverStyle.gradient && component._jsPlumb.paintStyle.fill) {\n delete mergedHoverStyle.gradient;\n }\n component._jsPlumb.hoverPaintStyle = mergedHoverStyle;\n }\n },\n events = [\"tap\", \"dbltap\", \"click\", \"dblclick\", \"mouseover\", \"mouseout\", \"mousemove\", \"mousedown\", \"mouseup\", \"contextmenu\" ],\n eventFilters = { \"mouseout\": \"mouseleave\", \"mouseexit\": \"mouseleave\" },\n _updateAttachedElements = function (component, state, timestamp, sourceElement) {\n var affectedElements = component.getAttachedElements();\n if (affectedElements) {\n for (var i = 0, j = affectedElements.length; i < j; i++) {\n if (!sourceElement || sourceElement !== affectedElements[i]) {\n affectedElements[i].setHover(state, true, timestamp);\t\t\t// tell the attached elements not to inform their own attached elements.\n }\n }\n }\n },\n _splitType = function (t) {\n return t == null ? null : t.split(\" \");\n },\n _mapType = function(map, obj, typeId) {\n for (var i in obj) {\n map[i] = typeId;\n }\n },\n _each = function(fn, obj) {\n obj = _ju.isArray(obj) || (obj.length != null && !_ju.isString(obj)) ? obj : [ obj ];\n for (var i = 0; i < obj.length; i++) {\n try {\n fn.apply(obj[i], [ obj[i] ]);\n }\n catch (e) {\n _ju.log(\".each iteration failed : \" + e);\n }\n }\n },\n _applyTypes = function (component, params, doNotRepaint) {\n if (component.getDefaultType) {\n var td = component.getTypeDescriptor(), map = {};\n var defType = component.getDefaultType();\n var o = _ju.merge({}, defType);\n _mapType(map, defType, \"__default\");\n for (var i = 0, j = component._jsPlumb.types.length; i < j; i++) {\n var tid = component._jsPlumb.types[i];\n if (tid !== \"__default\") {\n var _t = component._jsPlumb.instance.getType(tid, td);\n if (_t != null) {\n o = _ju.merge(o, _t, [ \"cssClass\" ], [ \"connector\" ]);\n _mapType(map, _t, tid);\n }\n }\n }\n\n if (params) {\n o = _ju.populate(o, params, \"_\");\n }\n\n component.applyType(o, doNotRepaint, map);\n if (!doNotRepaint) {\n component.repaint();\n }\n }\n },\n\n// ------------------------------ BEGIN jsPlumbUIComponent --------------------------------------------\n\n jsPlumbUIComponent = root.jsPlumbUIComponent = function (params) {\n\n _ju.EventGenerator.apply(this, arguments);\n\n var self = this,\n a = arguments,\n idPrefix = self.idPrefix,\n id = idPrefix + (new Date()).getTime();\n\n this._jsPlumb = {\n instance: params._jsPlumb,\n parameters: params.parameters || {},\n paintStyle: null,\n hoverPaintStyle: null,\n paintStyleInUse: null,\n hover: false,\n beforeDetach: params.beforeDetach,\n beforeDrop: params.beforeDrop,\n overlayPlacements: [],\n hoverClass: params.hoverClass || params._jsPlumb.Defaults.HoverClass,\n types: [],\n typeCache:{}\n };\n\n this.cacheTypeItem = function(key, item, typeId) {\n this._jsPlumb.typeCache[typeId] = this._jsPlumb.typeCache[typeId] || {};\n this._jsPlumb.typeCache[typeId][key] = item;\n };\n this.getCachedTypeItem = function(key, typeId) {\n return this._jsPlumb.typeCache[typeId] ? this._jsPlumb.typeCache[typeId][key] : null;\n };\n\n this.getId = function () {\n return id;\n };\n\n// ----------------------------- default type --------------------------------------------\n\n\n var o = params.overlays || [], oo = {};\n if (this.defaultOverlayKeys) {\n for (var i = 0; i < this.defaultOverlayKeys.length; i++) {\n Array.prototype.push.apply(o, this._jsPlumb.instance.Defaults[this.defaultOverlayKeys[i]] || []);\n }\n\n for (i = 0; i < o.length; i++) {\n // if a string, convert to object representation so that we can store the typeid on it.\n // also assign an id.\n var fo = jsPlumb.convertToFullOverlaySpec(o[i]);\n oo[fo[1].id] = fo;\n }\n }\n\n var _defaultType = {\n overlays:oo,\n parameters: params.parameters || {},\n scope: params.scope || this._jsPlumb.instance.getDefaultScope()\n };\n this.getDefaultType = function() {\n return _defaultType;\n };\n this.appendToDefaultType = function(obj) {\n for (var i in obj) {\n _defaultType[i] = obj[i];\n }\n };\n\n// ----------------------------- end default type --------------------------------------------\n\n // all components can generate events\n\n if (params.events) {\n for (var evtName in params.events) {\n self.bind(evtName, params.events[evtName]);\n }\n }\n\n // all components get this clone function.\n // TODO issue 116 showed a problem with this - it seems 'a' that is in\n // the clone function's scope is shared by all invocations of it, the classic\n // JS closure problem. for now, jsPlumb does a version of this inline where\n // it used to call clone. but it would be nice to find some time to look\n // further at this.\n this.clone = function () {\n var o = Object.create(this.constructor.prototype);\n this.constructor.apply(o, a);\n return o;\n }.bind(this);\n\n // user can supply a beforeDetach callback, which will be executed before a detach\n // is performed; returning false prevents the detach.\n this.isDetachAllowed = function (connection) {\n var r = true;\n if (this._jsPlumb.beforeDetach) {\n try {\n r = this._jsPlumb.beforeDetach(connection);\n }\n catch (e) {\n _ju.log(\"jsPlumb: beforeDetach callback failed\", e);\n }\n }\n return r;\n };\n\n // user can supply a beforeDrop callback, which will be executed before a dropped\n // connection is confirmed. user can return false to reject connection.\n this.isDropAllowed = function (sourceId, targetId, scope, connection, dropEndpoint, source, target) {\n var r = this._jsPlumb.instance.checkCondition(\"beforeDrop\", {\n sourceId: sourceId,\n targetId: targetId,\n scope: scope,\n connection: connection,\n dropEndpoint: dropEndpoint,\n source: source, target: target\n });\n if (this._jsPlumb.beforeDrop) {\n try {\n r = this._jsPlumb.beforeDrop({\n sourceId: sourceId,\n targetId: targetId,\n scope: scope,\n connection: connection,\n dropEndpoint: dropEndpoint,\n source: source, target: target\n });\n }\n catch (e) {\n _ju.log(\"jsPlumb: beforeDrop callback failed\", e);\n }\n }\n return r;\n };\n\n var domListeners = [];\n\n // sets the component associated with listener events. for instance, an overlay delegates\n // its events back to a connector. but if the connector is swapped on the underlying connection,\n // then this component must be changed. This is called by setConnector in the Connection class.\n this.setListenerComponent = function (c) {\n for (var i = 0; i < domListeners.length; i++) {\n domListeners[i][3] = c;\n }\n };\n\n\n };\n\n var _removeTypeCssHelper = function (component, typeIndex) {\n var typeId = component._jsPlumb.types[typeIndex],\n type = component._jsPlumb.instance.getType(typeId, component.getTypeDescriptor());\n\n if (type != null && type.cssClass && component.canvas) {\n component._jsPlumb.instance.removeClass(component.canvas, type.cssClass);\n }\n };\n\n _ju.extend(root.jsPlumbUIComponent, _ju.EventGenerator, {\n\n getParameter: function (name) {\n return this._jsPlumb.parameters[name];\n },\n\n setParameter: function (name, value) {\n this._jsPlumb.parameters[name] = value;\n },\n\n getParameters: function () {\n return this._jsPlumb.parameters;\n },\n\n setParameters: function (p) {\n this._jsPlumb.parameters = p;\n },\n\n getClass:function() {\n return jsPlumb.getClass(this.canvas);\n },\n\n hasClass:function(clazz) {\n return jsPlumb.hasClass(this.canvas, clazz);\n },\n\n addClass: function (clazz) {\n jsPlumb.addClass(this.canvas, clazz);\n },\n\n removeClass: function (clazz) {\n jsPlumb.removeClass(this.canvas, clazz);\n },\n\n updateClasses: function (classesToAdd, classesToRemove) {\n jsPlumb.updateClasses(this.canvas, classesToAdd, classesToRemove);\n },\n\n setType: function (typeId, params, doNotRepaint) {\n this.clearTypes();\n this._jsPlumb.types = _splitType(typeId) || [];\n _applyTypes(this, params, doNotRepaint);\n },\n\n getType: function () {\n return this._jsPlumb.types;\n },\n\n reapplyTypes: function (params, doNotRepaint) {\n _applyTypes(this, params, doNotRepaint);\n },\n\n hasType: function (typeId) {\n return this._jsPlumb.types.indexOf(typeId) !== -1;\n },\n\n addType: function (typeId, params, doNotRepaint) {\n var t = _splitType(typeId), _cont = false;\n if (t != null) {\n for (var i = 0, j = t.length; i < j; i++) {\n if (!this.hasType(t[i])) {\n this._jsPlumb.types.push(t[i]);\n _cont = true;\n }\n }\n if (_cont) {\n _applyTypes(this, params, doNotRepaint);\n }\n }\n },\n\n removeType: function (typeId, params, doNotRepaint) {\n var t = _splitType(typeId), _cont = false, _one = function (tt) {\n var idx = this._jsPlumb.types.indexOf(tt);\n if (idx !== -1) {\n // remove css class if necessary\n _removeTypeCssHelper(this, idx);\n this._jsPlumb.types.splice(idx, 1);\n return true;\n }\n return false;\n }.bind(this);\n\n if (t != null) {\n for (var i = 0, j = t.length; i < j; i++) {\n _cont = _one(t[i]) || _cont;\n }\n if (_cont) {\n _applyTypes(this, params, doNotRepaint);\n }\n }\n },\n clearTypes: function (params, doNotRepaint) {\n var i = this._jsPlumb.types.length;\n for (var j = 0; j < i; j++) {\n _removeTypeCssHelper(this, 0);\n this._jsPlumb.types.splice(0, 1);\n }\n _applyTypes(this, params, doNotRepaint);\n },\n\n toggleType: function (typeId, params, doNotRepaint) {\n var t = _splitType(typeId);\n if (t != null) {\n for (var i = 0, j = t.length; i < j; i++) {\n var idx = this._jsPlumb.types.indexOf(t[i]);\n if (idx !== -1) {\n _removeTypeCssHelper(this, idx);\n this._jsPlumb.types.splice(idx, 1);\n }\n else {\n this._jsPlumb.types.push(t[i]);\n }\n }\n\n _applyTypes(this, params, doNotRepaint);\n }\n },\n applyType: function (t, doNotRepaint) {\n this.setPaintStyle(t.paintStyle, doNotRepaint);\n this.setHoverPaintStyle(t.hoverPaintStyle, doNotRepaint);\n if (t.parameters) {\n for (var i in t.parameters) {\n this.setParameter(i, t.parameters[i]);\n }\n }\n this._jsPlumb.paintStyleInUse = this.getPaintStyle();\n },\n setPaintStyle: function (style, doNotRepaint) {\n // this._jsPlumb.paintStyle = jsPlumb.extend({}, style);\n // TODO figure out if we want components to clone paintStyle so as not to share it.\n this._jsPlumb.paintStyle = style;\n this._jsPlumb.paintStyleInUse = this._jsPlumb.paintStyle;\n _updateHoverStyle(this);\n if (!doNotRepaint) {\n this.repaint();\n }\n },\n getPaintStyle: function () {\n return this._jsPlumb.paintStyle;\n },\n setHoverPaintStyle: function (style, doNotRepaint) {\n //this._jsPlumb.hoverPaintStyle = jsPlumb.extend({}, style);\n // TODO figure out if we want components to clone paintStyle so as not to share it.\n this._jsPlumb.hoverPaintStyle = style;\n _updateHoverStyle(this);\n if (!doNotRepaint) {\n this.repaint();\n }\n },\n getHoverPaintStyle: function () {\n return this._jsPlumb.hoverPaintStyle;\n },\n destroy: function (force) {\n if (force || this.typeId == null) {\n this.cleanupListeners(); // this is on EventGenerator\n this.clone = null;\n this._jsPlumb = null;\n }\n },\n\n isHover: function () {\n return this._jsPlumb.hover;\n },\n\n setHover: function (hover, ignoreAttachedElements, timestamp) {\n // while dragging, we ignore these events. this keeps the UI from flashing and\n // swishing and whatevering.\n if (this._jsPlumb && !this._jsPlumb.instance.currentlyDragging && !this._jsPlumb.instance.isHoverSuspended()) {\n\n this._jsPlumb.hover = hover;\n var method = hover ? \"addClass\" : \"removeClass\";\n\n if (this.canvas != null) {\n if (this._jsPlumb.instance.hoverClass != null) {\n this._jsPlumb.instance[method](this.canvas, this._jsPlumb.instance.hoverClass);\n }\n if (this._jsPlumb.hoverClass != null) {\n this._jsPlumb.instance[method](this.canvas, this._jsPlumb.hoverClass);\n }\n }\n if (this._jsPlumb.hoverPaintStyle != null) {\n this._jsPlumb.paintStyleInUse = hover ? this._jsPlumb.hoverPaintStyle : this._jsPlumb.paintStyle;\n if (!this._jsPlumb.instance.isSuspendDrawing()) {\n timestamp = timestamp || _timestamp();\n this.repaint({timestamp: timestamp, recalc: false});\n }\n }\n // get the list of other affected elements, if supported by this component.\n // for a connection, its the endpoints. for an endpoint, its the connections! surprise.\n if (this.getAttachedElements && !ignoreAttachedElements) {\n _updateAttachedElements(this, hover, _timestamp(), this);\n }\n }\n }\n });\n\n// ------------------------------ END jsPlumbUIComponent --------------------------------------------\n\n var _jsPlumbInstanceIndex = 0,\n getInstanceIndex = function () {\n var i = _jsPlumbInstanceIndex + 1;\n _jsPlumbInstanceIndex++;\n return i;\n };\n\n var jsPlumbInstance = root.jsPlumbInstance = function (_defaults) {\n\n this.version = \"2.9.0\";\n\n this.Defaults = {\n Anchor: \"Bottom\",\n Anchors: [ null, null ],\n ConnectionsDetachable: true,\n ConnectionOverlays: [ ],\n Connector: \"Bezier\",\n Container: null,\n DoNotThrowErrors: false,\n DragOptions: { },\n DropOptions: { },\n Endpoint: \"Dot\",\n EndpointOverlays: [ ],\n Endpoints: [ null, null ],\n EndpointStyle: { fill: \"#456\" },\n EndpointStyles: [ null, null ],\n EndpointHoverStyle: null,\n EndpointHoverStyles: [ null, null ],\n HoverPaintStyle: null,\n LabelStyle: { color: \"black\" },\n LogEnabled: false,\n Overlays: [ ],\n MaxConnections: 1,\n PaintStyle: { \"stroke-width\": 4, stroke: \"#456\" },\n ReattachConnections: false,\n RenderMode: \"svg\",\n Scope: \"jsPlumb_DefaultScope\"\n };\n\n if (_defaults) {\n jsPlumb.extend(this.Defaults, _defaults);\n }\n\n this.logEnabled = this.Defaults.LogEnabled;\n this._connectionTypes = {};\n this._endpointTypes = {};\n\n _ju.EventGenerator.apply(this);\n\n var _currentInstance = this,\n _instanceIndex = getInstanceIndex(),\n _bb = _currentInstance.bind,\n _initialDefaults = {},\n _zoom = 1,\n _info = function (el) {\n if (el == null) {\n return null;\n }\n else if (el.nodeType === 3 || el.nodeType === 8) {\n return { el:el, text:true };\n }\n else {\n var _el = _currentInstance.getElement(el);\n return { el: _el, id: (_ju.isString(el) && _el == null) ? el : _getId(_el) };\n }\n };\n\n this.getInstanceIndex = function () {\n return _instanceIndex;\n };\n\n // CONVERTED\n this.setZoom = function (z, repaintEverything) {\n _zoom = z;\n _currentInstance.fire(\"zoom\", _zoom);\n if (repaintEverything) {\n _currentInstance.repaintEverything();\n }\n return true;\n };\n // CONVERTED\n this.getZoom = function () {\n return _zoom;\n };\n\n for (var i in this.Defaults) {\n _initialDefaults[i] = this.Defaults[i];\n }\n\n var _container, _containerDelegations = [];\n this.unbindContainer = function() {\n if (_container != null && _containerDelegations.length > 0) {\n for (var i = 0; i < _containerDelegations.length; i++) {\n _currentInstance.off(_container, _containerDelegations[i][0], _containerDelegations[i][1]);\n }\n }\n };\n this.setContainer = function (c) {\n\n this.unbindContainer();\n\n // get container as dom element.\n c = this.getElement(c);\n // move existing connections and endpoints, if any.\n this.select().each(function (conn) {\n conn.moveParent(c);\n });\n this.selectEndpoints().each(function (ep) {\n ep.moveParent(c);\n });\n\n // set container.\n var previousContainer = _container;\n _container = c;\n _containerDelegations.length = 0;\n var eventAliases = {\n \"endpointclick\":\"endpointClick\",\n \"endpointdblclick\":\"endpointDblClick\"\n };\n\n var _oneDelegateHandler = function (id, e, componentType) {\n var t = e.srcElement || e.target,\n jp = (t && t.parentNode ? t.parentNode._jsPlumb : null) || (t ? t._jsPlumb : null) || (t && t.parentNode && t.parentNode.parentNode ? t.parentNode.parentNode._jsPlumb : null);\n if (jp) {\n jp.fire(id, jp, e);\n var alias = componentType ? eventAliases[componentType + id] || id : id;\n // jsplumb also fires every event coming from components/overlays. That's what the test for `jp.component` is for.\n _currentInstance.fire(alias, jp.component || jp, e);\n }\n };\n\n var _addOneDelegate = function(eventId, selector, fn) {\n _containerDelegations.push([eventId, fn]);\n _currentInstance.on(_container, eventId, selector, fn);\n };\n\n // delegate one event on the container to jsplumb elements. it might be possible to\n // abstract this out: each of endpoint, connection and overlay could register themselves with\n // jsplumb as \"component types\" or whatever, and provide a suitable selector. this would be\n // done by the renderer (although admittedly from 2.0 onwards we're not supporting vml anymore)\n var _oneDelegate = function (id) {\n // connections.\n _addOneDelegate(id, \".jtk-connector\", function (e) {\n _oneDelegateHandler(id, e);\n });\n // endpoints. note they can have an enclosing div, or not.\n _addOneDelegate(id, \".jtk-endpoint\", function (e) {\n _oneDelegateHandler(id, e, \"endpoint\");\n });\n // overlays\n _addOneDelegate(id, \".jtk-overlay\", function (e) {\n _oneDelegateHandler(id, e);\n });\n };\n\n for (var i = 0; i < events.length; i++) {\n _oneDelegate(events[i]);\n }\n\n // managed elements\n for (var elId in managedElements) {\n var el = managedElements[elId].el;\n if (el.parentNode === previousContainer) {\n previousContainer.removeChild(el);\n _container.appendChild(el);\n }\n }\n\n };\n this.getContainer = function () {\n return _container;\n };\n\n this.bind = function (event, fn) {\n if (\"ready\" === event && initialized) {\n fn();\n }\n else {\n _bb.apply(_currentInstance, [event, fn]);\n }\n };\n\n _currentInstance.importDefaults = function (d) {\n for (var i in d) {\n _currentInstance.Defaults[i] = d[i];\n }\n if (d.Container) {\n _currentInstance.setContainer(d.Container);\n }\n\n return _currentInstance;\n };\n\n _currentInstance.restoreDefaults = function () {\n _currentInstance.Defaults = jsPlumb.extend({}, _initialDefaults);\n return _currentInstance;\n };\n\n var log = null,\n initialized = false,\n // TODO remove from window scope\n connections = [],\n // map of element id -> endpoint lists. an element can have an arbitrary\n // number of endpoints on it, and not all of them have to be connected\n // to anything.\n endpointsByElement = {},\n endpointsByUUID = {},\n managedElements = {},\n offsets = {},\n offsetTimestamps = {},\n draggableStates = {},\n connectionBeingDragged = false,\n sizes = [],\n _suspendDrawing = false,\n _suspendedAt = null,\n DEFAULT_SCOPE = this.Defaults.Scope,\n _curIdStamp = 1,\n _idstamp = function () {\n return \"\" + _curIdStamp++;\n },\n\n //\n // appends an element to some other element, which is calculated as follows:\n //\n // 1. if Container exists, use that element.\n // 2. if the 'parent' parameter exists, use that.\n // 3. otherwise just use the root element.\n //\n //\n _appendElement = function (el, parent) {\n if (_container) {\n _container.appendChild(el);\n }\n else if (!parent) {\n this.appendToRoot(el);\n }\n else {\n this.getElement(parent).appendChild(el);\n }\n }.bind(this),\n\n //\n // Draws an endpoint and its connections. this is the main entry point into drawing connections as well\n // as endpoints, since jsPlumb is endpoint-centric under the hood.\n //\n // @param element element to draw (of type library specific element object)\n // @param ui UI object from current library's event system. optional.\n // @param timestamp timestamp for this paint cycle. used to speed things up a little by cutting down the amount of offset calculations we do.\n // @param clearEdits defaults to false; indicates that mouse edits for connectors should be cleared\n ///\n _draw = function (element, ui, timestamp, clearEdits) {\n\n if (!_suspendDrawing) {\n var id = _getId(element),\n repaintEls,\n dm = _currentInstance.getDragManager();\n\n if (dm) {\n repaintEls = dm.getElementsForDraggable(id);\n }\n\n if (timestamp == null) {\n timestamp = _timestamp();\n }\n\n // update the offset of everything _before_ we try to draw anything.\n var o = _updateOffset({ elId: id, offset: ui, recalc: false, timestamp: timestamp });\n\n if (repaintEls && o && o.o) {\n for (var i in repaintEls) {\n _updateOffset({\n elId: repaintEls[i].id,\n offset: {\n left: o.o.left + repaintEls[i].offset.left,\n top: o.o.top + repaintEls[i].offset.top\n },\n recalc: false,\n timestamp: timestamp\n });\n }\n }\n\n _currentInstance.anchorManager.redraw(id, ui, timestamp, null, clearEdits);\n\n if (repaintEls) {\n for (var j in repaintEls) {\n _currentInstance.anchorManager.redraw(repaintEls[j].id, ui, timestamp, repaintEls[j].offset, clearEdits, true);\n }\n }\n }\n },\n\n //\n // gets an Endpoint by uuid.\n //\n _getEndpoint = function (uuid) {\n return endpointsByUUID[uuid];\n },\n\n /**\n * inits a draggable if it's not already initialised.\n * TODO: somehow abstract this to the adapter, because the concept of \"draggable\" has no\n * place on the server.\n */\n\n\n _scopeMatch = function (e1, e2) {\n var s1 = e1.scope.split(/\\s/), s2 = e2.scope.split(/\\s/);\n for (var i = 0; i < s1.length; i++) {\n for (var j = 0; j < s2.length; j++) {\n if (s2[j] === s1[i]) {\n return true;\n }\n }\n }\n\n return false;\n },\n\n _mergeOverrides = function (def, values) {\n var m = jsPlumb.extend({}, def);\n for (var i in values) {\n if (values[i]) {\n m[i] = values[i];\n }\n }\n return m;\n },\n\n /*\n * prepares a final params object that can be passed to _newConnection, taking into account defaults, events, etc.\n */\n _prepareConnectionParams = function (params, referenceParams) {\n var _p = jsPlumb.extend({ }, params);\n if (referenceParams) {\n jsPlumb.extend(_p, referenceParams);\n }\n\n // hotwire endpoints passed as source or target to sourceEndpoint/targetEndpoint, respectively.\n if (_p.source) {\n if (_p.source.endpoint) {\n _p.sourceEndpoint = _p.source;\n }\n else {\n _p.source = _currentInstance.getElement(_p.source);\n }\n }\n if (_p.target) {\n if (_p.target.endpoint) {\n _p.targetEndpoint = _p.target;\n }\n else {\n _p.target = _currentInstance.getElement(_p.target);\n }\n }\n\n // test for endpoint uuids to connect\n if (params.uuids) {\n _p.sourceEndpoint = _getEndpoint(params.uuids[0]);\n _p.targetEndpoint = _getEndpoint(params.uuids[1]);\n }\n\n // now ensure that if we do have Endpoints already, they're not full.\n // source:\n if (_p.sourceEndpoint && _p.sourceEndpoint.isFull()) {\n _ju.log(_currentInstance, \"could not add connection; source endpoint is full\");\n return;\n }\n\n // target:\n if (_p.targetEndpoint && _p.targetEndpoint.isFull()) {\n _ju.log(_currentInstance, \"could not add connection; target endpoint is full\");\n return;\n }\n\n // if source endpoint mandates connection type and nothing specified in our params, use it.\n if (!_p.type && _p.sourceEndpoint) {\n _p.type = _p.sourceEndpoint.connectionType;\n }\n\n // copy in any connectorOverlays that were specified on the source endpoint.\n // it doesnt copy target endpoint overlays. i'm not sure if we want it to or not.\n if (_p.sourceEndpoint && _p.sourceEndpoint.connectorOverlays) {\n _p.overlays = _p.overlays || [];\n for (var i = 0, j = _p.sourceEndpoint.connectorOverlays.length; i < j; i++) {\n _p.overlays.push(_p.sourceEndpoint.connectorOverlays[i]);\n }\n }\n\n // scope\n if (_p.sourceEndpoint && _p.sourceEndpoint.scope) {\n _p.scope = _p.sourceEndpoint.scope;\n }\n\n // pointer events\n if (!_p[\"pointer-events\"] && _p.sourceEndpoint && _p.sourceEndpoint.connectorPointerEvents) {\n _p[\"pointer-events\"] = _p.sourceEndpoint.connectorPointerEvents;\n }\n\n\n var _addEndpoint = function (el, def, idx) {\n return _currentInstance.addEndpoint(el, _mergeOverrides(def, {\n anchor: _p.anchors ? _p.anchors[idx] : _p.anchor,\n endpoint: _p.endpoints ? _p.endpoints[idx] : _p.endpoint,\n paintStyle: _p.endpointStyles ? _p.endpointStyles[idx] : _p.endpointStyle,\n hoverPaintStyle: _p.endpointHoverStyles ? _p.endpointHoverStyles[idx] : _p.endpointHoverStyle\n }));\n };\n\n // check for makeSource/makeTarget specs.\n\n var _oneElementDef = function (type, idx, defs, matchType) {\n if (_p[type] && !_p[type].endpoint && !_p[type + \"Endpoint\"] && !_p.newConnection) {\n var tid = _getId(_p[type]), tep = defs[tid];\n\n tep = tep ? tep[matchType] : null;\n\n if (tep) {\n // if not enabled, return.\n if (!tep.enabled) {\n return false;\n }\n var newEndpoint = tep.endpoint != null && tep.endpoint._jsPlumb ? tep.endpoint : _addEndpoint(_p[type], tep.def, idx);\n if (newEndpoint.isFull()) {\n return false;\n }\n _p[type + \"Endpoint\"] = newEndpoint;\n if (!_p.scope && tep.def.scope) {\n _p.scope = tep.def.scope;\n } // provide scope if not already provided and endpoint def has one.\n if (tep.uniqueEndpoint) {\n if (!tep.endpoint) {\n tep.endpoint = newEndpoint;\n newEndpoint.setDeleteOnEmpty(false);\n }\n else {\n newEndpoint.finalEndpoint = tep.endpoint;\n }\n } else {\n newEndpoint.setDeleteOnEmpty(true);\n }\n\n //\n // copy in connector overlays if present on the source definition.\n //\n if (idx === 0 && tep.def.connectorOverlays) {\n _p.overlays = _p.overlays || [];\n Array.prototype.push.apply(_p.overlays, tep.def.connectorOverlays);\n }\n }\n }\n };\n\n if (_oneElementDef(\"source\", 0, this.sourceEndpointDefinitions, _p.type || \"default\") === false) {\n return;\n }\n if (_oneElementDef(\"target\", 1, this.targetEndpointDefinitions, _p.type || \"default\") === false) {\n return;\n }\n\n // last, ensure scopes match\n if (_p.sourceEndpoint && _p.targetEndpoint) {\n if (!_scopeMatch(_p.sourceEndpoint, _p.targetEndpoint)) {\n _p = null;\n }\n }\n\n return _p;\n }.bind(_currentInstance),\n\n _newConnection = function (params) {\n var connectionFunc = _currentInstance.Defaults.ConnectionType || _currentInstance.getDefaultConnectionType();\n\n params._jsPlumb = _currentInstance;\n params.newConnection = _newConnection;\n params.newEndpoint = _newEndpoint;\n params.endpointsByUUID = endpointsByUUID;\n params.endpointsByElement = endpointsByElement;\n params.finaliseConnection = _finaliseConnection;\n params.id = \"con_\" + _idstamp();\n var con = new connectionFunc(params);\n\n // if the connection is draggable, then maybe we need to tell the target endpoint to init the\n // dragging code. it won't run again if it already configured to be draggable.\n if (con.isDetachable()) {\n con.endpoints[0].initDraggable(\"_jsPlumbSource\");\n con.endpoints[1].initDraggable(\"_jsPlumbTarget\");\n }\n\n return con;\n },\n\n //\n // adds the connection to the backing model, fires an event if necessary and then redraws\n //\n _finaliseConnection = _currentInstance.finaliseConnection = function (jpc, params, originalEvent, doInformAnchorManager) {\n params = params || {};\n // add to list of connections (by scope).\n if (!jpc.suspendedEndpoint) {\n connections.push(jpc);\n }\n\n jpc.pending = null;\n\n // turn off isTemporarySource on the source endpoint (only viable on first draw)\n jpc.endpoints[0].isTemporarySource = false;\n\n // always inform the anchor manager\n // except that if jpc has a suspended endpoint it's not true to say the\n // connection is new; it has just (possibly) moved. the question is whether\n // to make that call here or in the anchor manager. i think perhaps here.\n if (doInformAnchorManager !== false) {\n _currentInstance.anchorManager.newConnection(jpc);\n }\n\n // force a paint\n _draw(jpc.source);\n\n // fire an event\n if (!params.doNotFireConnectionEvent && params.fireEvent !== false) {\n\n var eventArgs = {\n connection: jpc,\n source: jpc.source, target: jpc.target,\n sourceId: jpc.sourceId, targetId: jpc.targetId,\n sourceEndpoint: jpc.endpoints[0], targetEndpoint: jpc.endpoints[1]\n };\n\n _currentInstance.fire(\"connection\", eventArgs, originalEvent);\n }\n },\n\n /*\n factory method to prepare a new endpoint. this should always be used instead of creating Endpoints\n manually, since this method attaches event listeners and an id.\n */\n _newEndpoint = function (params, id) {\n var endpointFunc = _currentInstance.Defaults.EndpointType || jsPlumb.Endpoint;\n var _p = jsPlumb.extend({}, params);\n _p._jsPlumb = _currentInstance;\n _p.newConnection = _newConnection;\n _p.newEndpoint = _newEndpoint;\n _p.endpointsByUUID = endpointsByUUID;\n _p.endpointsByElement = endpointsByElement;\n _p.fireDetachEvent = fireDetachEvent;\n _p.elementId = id || _getId(_p.source);\n var ep = new endpointFunc(_p);\n ep.id = \"ep_\" + _idstamp();\n _manage(_p.elementId, _p.source);\n\n if (!jsPlumb.headless) {\n _currentInstance.getDragManager().endpointAdded(_p.source, id);\n }\n\n return ep;\n },\n\n /*\n * performs the given function operation on all the connections found\n * for the given element id; this means we find all the endpoints for\n * the given element, and then for each endpoint find the connectors\n * connected to it. then we pass each connection in to the given\n * function.\n */\n _operation = function (elId, func, endpointFunc) {\n var endpoints = endpointsByElement[elId];\n if (endpoints && endpoints.length) {\n for (var i = 0, ii = endpoints.length; i < ii; i++) {\n for (var j = 0, jj = endpoints[i].connections.length; j < jj; j++) {\n var retVal = func(endpoints[i].connections[j]);\n // if the function passed in returns true, we exit.\n // most functions return false.\n if (retVal) {\n return;\n }\n }\n if (endpointFunc) {\n endpointFunc(endpoints[i]);\n }\n }\n }\n },\n\n _setDraggable = function (element, draggable) {\n return jsPlumb.each(element, function (el) {\n if (_currentInstance.isDragSupported(el)) {\n draggableStates[_currentInstance.getAttribute(el, \"id\")] = draggable;\n _currentInstance.setElementDraggable(el, draggable);\n }\n });\n },\n /*\n * private method to do the business of hiding/showing.\n *\n * @param el\n * either Id of the element in question or a library specific\n * object for the element.\n * @param state\n * String specifying a value for the css 'display' property\n * ('block' or 'none').\n */\n _setVisible = function (el, state, alsoChangeEndpoints) {\n state = state === \"block\";\n var endpointFunc = null;\n if (alsoChangeEndpoints) {\n endpointFunc = function (ep) {\n ep.setVisible(state, true, true);\n };\n }\n var info = _info(el);\n _operation(info.id, function (jpc) {\n if (state && alsoChangeEndpoints) {\n // this test is necessary because this functionality is new, and i wanted to maintain backwards compatibility.\n // this block will only set a connection to be visible if the other endpoint in the connection is also visible.\n var oidx = jpc.sourceId === info.id ? 1 : 0;\n if (jpc.endpoints[oidx].isVisible()) {\n jpc.setVisible(true);\n }\n }\n else { // the default behaviour for show, and what always happens for hide, is to just set the visibility without getting clever.\n jpc.setVisible(state);\n }\n }, endpointFunc);\n },\n /**\n * private method to do the business of toggling hiding/showing.\n */\n _toggleVisible = function (elId, changeEndpoints) {\n var endpointFunc = null;\n if (changeEndpoints) {\n endpointFunc = function (ep) {\n var state = ep.isVisible();\n ep.setVisible(!state);\n };\n }\n _operation(elId, function (jpc) {\n var state = jpc.isVisible();\n jpc.setVisible(!state);\n }, endpointFunc);\n },\n\n // TODO comparison performance\n _getCachedData = function (elId) {\n var o = offsets[elId];\n if (!o) {\n return _updateOffset({elId: elId});\n }\n else {\n return {o: o, s: sizes[elId]};\n }\n },\n\n /**\n * gets an id for the given element, creating and setting one if\n * necessary. the id is of the form\n *\n * jsPlumb__\n *\n * where \"index in instance\" is a monotonically increasing integer that starts at 0,\n * for each instance. this method is used not only to assign ids to elements that do not\n * have them but also to connections and endpoints.\n */\n _getId = function (element, uuid, doNotCreateIfNotFound) {\n if (_ju.isString(element)) {\n return element;\n }\n if (element == null) {\n return null;\n }\n var id = _currentInstance.getAttribute(element, \"id\");\n if (!id || id === \"undefined\") {\n // check if fixed uuid parameter is given\n if (arguments.length === 2 && arguments[1] !== undefined) {\n id = uuid;\n }\n else if (arguments.length === 1 || (arguments.length === 3 && !arguments[2])) {\n id = \"jsPlumb_\" + _instanceIndex + \"_\" + _idstamp();\n }\n\n if (!doNotCreateIfNotFound) {\n _currentInstance.setAttribute(element, \"id\", id);\n }\n }\n return id;\n };\n\n this.setConnectionBeingDragged = function (v) {\n connectionBeingDragged = v;\n };\n this.isConnectionBeingDragged = function () {\n return connectionBeingDragged;\n };\n\n /**\n * Returns a map of all the elements this jsPlumbInstance is currently managing.\n * @returns {Object} Map of [id-> {el, endpoint[], connection, position}] information.\n */\n this.getManagedElements = function() {\n return managedElements;\n };\n\n this.connectorClass = \"jtk-connector\";\n this.connectorOutlineClass = \"jtk-connector-outline\";\n this.connectedClass = \"jtk-connected\";\n this.hoverClass = \"jtk-hover\";\n this.endpointClass = \"jtk-endpoint\";\n this.endpointConnectedClass = \"jtk-endpoint-connected\";\n this.endpointFullClass = \"jtk-endpoint-full\";\n this.endpointDropAllowedClass = \"jtk-endpoint-drop-allowed\";\n this.endpointDropForbiddenClass = \"jtk-endpoint-drop-forbidden\";\n this.overlayClass = \"jtk-overlay\";\n this.draggingClass = \"jtk-dragging\";// CONVERTED\n this.elementDraggingClass = \"jtk-element-dragging\";// CONVERTED\n this.sourceElementDraggingClass = \"jtk-source-element-dragging\"; // CONVERTED\n this.targetElementDraggingClass = \"jtk-target-element-dragging\";// CONVERTED\n this.endpointAnchorClassPrefix = \"jtk-endpoint-anchor\";\n this.hoverSourceClass = \"jtk-source-hover\";\n this.hoverTargetClass = \"jtk-target-hover\";\n this.dragSelectClass = \"jtk-drag-select\";\n\n this.Anchors = {};\n this.Connectors = { \"svg\": {} };\n this.Endpoints = { \"svg\": {} };\n this.Overlays = { \"svg\": {} } ;\n this.ConnectorRenderers = {};\n this.SVG = \"svg\";\n\n// --------------------------- jsPlumbInstance public API ---------------------------------------------------------\n\n\n this.addEndpoint = function (el, params, referenceParams) {\n referenceParams = referenceParams || {};\n var p = jsPlumb.extend({}, referenceParams);\n jsPlumb.extend(p, params);\n p.endpoint = p.endpoint || _currentInstance.Defaults.Endpoint;\n p.paintStyle = p.paintStyle || _currentInstance.Defaults.EndpointStyle;\n\n var results = [],\n inputs = (_ju.isArray(el) || (el.length != null && !_ju.isString(el))) ? el : [ el ];\n\n for (var i = 0, j = inputs.length; i < j; i++) {\n p.source = _currentInstance.getElement(inputs[i]);\n _ensureContainer(p.source);\n\n var id = _getId(p.source), e = _newEndpoint(p, id);\n\n // ensure element is managed.\n var myOffset = _manage(id, p.source).info.o;\n _ju.addToList(endpointsByElement, id, e);\n\n if (!_suspendDrawing) {\n e.paint({\n anchorLoc: e.anchor.compute({ xy: [ myOffset.left, myOffset.top ], wh: sizes[id], element: e, timestamp: _suspendedAt }),\n timestamp: _suspendedAt\n });\n }\n\n results.push(e);\n }\n\n return results.length === 1 ? results[0] : results;\n };\n\n this.addEndpoints = function (el, endpoints, referenceParams) {\n var results = [];\n for (var i = 0, j = endpoints.length; i < j; i++) {\n var e = _currentInstance.addEndpoint(el, endpoints[i], referenceParams);\n if (_ju.isArray(e)) {\n Array.prototype.push.apply(results, e);\n }\n else {\n results.push(e);\n }\n }\n return results;\n };\n\n this.animate = function (el, properties, options) {\n if (!this.animationSupported) {\n return false;\n }\n\n options = options || {};\n var del = _currentInstance.getElement(el),\n id = _getId(del),\n stepFunction = jsPlumb.animEvents.step,\n completeFunction = jsPlumb.animEvents.complete;\n\n options[stepFunction] = _ju.wrap(options[stepFunction], function () {\n _currentInstance.revalidate(id);\n });\n\n // onComplete repaints, just to make sure everything looks good at the end of the animation.\n options[completeFunction] = _ju.wrap(options[completeFunction], function () {\n _currentInstance.revalidate(id);\n });\n\n _currentInstance.doAnimate(del, properties, options);\n };\n\n /**\n * checks for a listener for the given condition, executing it if found, passing in the given value.\n * condition listeners would have been attached using \"bind\" (which is, you could argue, now overloaded, since\n * firing click events etc is a bit different to what this does). i thought about adding a \"bindCondition\"\n * or something, but decided against it, for the sake of simplicity. jsPlumb will never fire one of these\n * condition events anyway.\n */\n this.checkCondition = function (conditionName, args) {\n var l = _currentInstance.getListener(conditionName),\n r = true;\n\n if (l && l.length > 0) {\n var values = Array.prototype.slice.call(arguments, 1);\n try {\n for (var i = 0, j = l.length; i < j; i++) {\n r = r && l[i].apply(l[i], values);\n }\n }\n catch (e) {\n _ju.log(_currentInstance, \"cannot check condition [\" + conditionName + \"]\" + e);\n }\n }\n return r;\n };\n\n this.connect = function (params, referenceParams) {\n // prepare a final set of parameters to create connection with\n var _p = _prepareConnectionParams(params, referenceParams), jpc;\n // TODO probably a nicer return value if the connection was not made. _prepareConnectionParams\n // will return null (and log something) if either endpoint was full. what would be nicer is to\n // create a dedicated 'error' object.\n if (_p) {\n if (_p.source == null && _p.sourceEndpoint == null) {\n _ju.log(\"Cannot establish connection - source does not exist\");\n return;\n }\n if (_p.target == null && _p.targetEndpoint == null) {\n _ju.log(\"Cannot establish connection - target does not exist\");\n return;\n }\n _ensureContainer(_p.source);\n // create the connection. it is not yet registered\n jpc = _newConnection(_p);\n // now add it the model, fire an event, and redraw\n _finaliseConnection(jpc, _p);\n }\n return jpc;\n };\n\n var stTypes = [\n { el: \"source\", elId: \"sourceId\", epDefs: \"sourceEndpointDefinitions\" },\n { el: \"target\", elId: \"targetId\", epDefs: \"targetEndpointDefinitions\" }\n ];\n\n var _set = function (c, el, idx, doNotRepaint) {\n var ep, _st = stTypes[idx], cId = c[_st.elId], cEl = c[_st.el], sid, sep,\n oldEndpoint = c.endpoints[idx];\n\n var evtParams = {\n index: idx,\n originalSourceId: idx === 0 ? cId : c.sourceId,\n newSourceId: c.sourceId,\n originalTargetId: idx === 1 ? cId : c.targetId,\n newTargetId: c.targetId,\n connection: c\n };\n\n if (el.constructor === jsPlumb.Endpoint) {\n ep = el;\n ep.addConnection(c);\n el = ep.element;\n }\n else {\n sid = _getId(el);\n sep = this[_st.epDefs][sid];\n\n if (sid === c[_st.elId]) {\n ep = null; // dont change source/target if the element is already the one given.\n }\n else if (sep) {\n for (var t in sep) {\n if (!sep[t].enabled) {\n return;\n }\n ep = sep[t].endpoint != null && sep[t].endpoint._jsPlumb ? sep[t].endpoint : this.addEndpoint(el, sep[t].def);\n if (sep[t].uniqueEndpoint) {\n sep[t].endpoint = ep;\n }\n ep.addConnection(c);\n }\n }\n else {\n ep = c.makeEndpoint(idx === 0, el, sid);\n }\n }\n\n if (ep != null) {\n oldEndpoint.detachFromConnection(c);\n c.endpoints[idx] = ep;\n c[_st.el] = ep.element;\n c[_st.elId] = ep.elementId;\n evtParams[idx === 0 ? \"newSourceId\" : \"newTargetId\"] = ep.elementId;\n\n fireMoveEvent(evtParams);\n\n if (!doNotRepaint) {\n c.repaint();\n }\n }\n\n evtParams.element = el;\n return evtParams;\n\n }.bind(this);\n\n this.setSource = function (connection, el, doNotRepaint) {\n var p = _set(connection, el, 0, doNotRepaint);\n this.anchorManager.sourceChanged(p.originalSourceId, p.newSourceId, connection, p.el);\n };\n this.setTarget = function (connection, el, doNotRepaint) {\n var p = _set(connection, el, 1, doNotRepaint);\n this.anchorManager.updateOtherEndpoint(p.originalSourceId, p.originalTargetId, p.newTargetId, connection);\n };\n\n this.deleteEndpoint = function (object, dontUpdateHover, deleteAttachedObjects) {\n var endpoint = (typeof object === \"string\") ? endpointsByUUID[object] : object;\n if (endpoint) {\n _currentInstance.deleteObject({ endpoint: endpoint, dontUpdateHover: dontUpdateHover, deleteAttachedObjects:deleteAttachedObjects });\n }\n return _currentInstance;\n };\n\n this.deleteEveryEndpoint = function () {\n var _is = _currentInstance.setSuspendDrawing(true);\n for (var id in endpointsByElement) {\n var endpoints = endpointsByElement[id];\n if (endpoints && endpoints.length) {\n for (var i = 0, j = endpoints.length; i < j; i++) {\n _currentInstance.deleteEndpoint(endpoints[i], true);\n }\n }\n }\n endpointsByElement = {};\n managedElements = {};\n endpointsByUUID = {};\n offsets = {};\n offsetTimestamps = {};\n _currentInstance.anchorManager.reset();\n var dm = _currentInstance.getDragManager();\n if (dm) {\n dm.reset();\n }\n if (!_is) {\n _currentInstance.setSuspendDrawing(false);\n }\n return _currentInstance;\n };\n\n var fireDetachEvent = function (jpc, doFireEvent, originalEvent) {\n // may have been given a connection, or in special cases, an object\n var connType = _currentInstance.Defaults.ConnectionType || _currentInstance.getDefaultConnectionType(),\n argIsConnection = jpc.constructor === connType,\n params = argIsConnection ? {\n connection: jpc,\n source: jpc.source, target: jpc.target,\n sourceId: jpc.sourceId, targetId: jpc.targetId,\n sourceEndpoint: jpc.endpoints[0], targetEndpoint: jpc.endpoints[1]\n } : jpc;\n\n if (doFireEvent) {\n _currentInstance.fire(\"connectionDetached\", params, originalEvent);\n }\n\n // always fire this. used by internal jsplumb stuff.\n _currentInstance.fire(\"internal.connectionDetached\", params, originalEvent);\n\n _currentInstance.anchorManager.connectionDetached(params);\n };\n\n var fireMoveEvent = _currentInstance.fireMoveEvent = function (params, evt) {\n _currentInstance.fire(\"connectionMoved\", params, evt);\n };\n\n this.unregisterEndpoint = function (endpoint) {\n if (endpoint._jsPlumb.uuid) {\n endpointsByUUID[endpoint._jsPlumb.uuid] = null;\n }\n _currentInstance.anchorManager.deleteEndpoint(endpoint);\n // TODO at least replace this with a removeWithFunction call.\n for (var e in endpointsByElement) {\n var endpoints = endpointsByElement[e];\n if (endpoints) {\n var newEndpoints = [];\n for (var i = 0, j = endpoints.length; i < j; i++) {\n if (endpoints[i] !== endpoint) {\n newEndpoints.push(endpoints[i]);\n }\n }\n\n endpointsByElement[e] = newEndpoints;\n }\n if (endpointsByElement[e].length < 1) {\n delete endpointsByElement[e];\n }\n }\n };\n\n var IS_DETACH_ALLOWED = \"isDetachAllowed\";\n var BEFORE_DETACH = \"beforeDetach\";\n var CHECK_CONDITION = \"checkCondition\";\n\n /**\n * Deletes a Connection.\n * @method deleteConnection\n * @param connection Connection to delete\n * @param {Object} [params] Optional delete parameters\n * @param {Boolean} [params.doNotFireEvent=false] If true, a connection detached event will not be fired. Otherwise one will.\n * @param {Boolean} [params.force=false] If true, the connection will be deleted even if a beforeDetach interceptor tries to stop the deletion.\n * @returns {Boolean} True if the connection was deleted, false otherwise.\n */\n this.deleteConnection = function(connection, params) {\n\n if (connection != null) {\n params = params || {};\n\n if (params.force || _ju.functionChain(true, false, [\n [ connection.endpoints[0], IS_DETACH_ALLOWED, [ connection ] ],\n [ connection.endpoints[1], IS_DETACH_ALLOWED, [ connection ] ],\n [ connection, IS_DETACH_ALLOWED, [ connection ] ],\n [ _currentInstance, CHECK_CONDITION, [ BEFORE_DETACH, connection ] ]\n ])) {\n\n connection.setHover(false);\n fireDetachEvent(connection, !connection.pending && params.fireEvent !== false, params.originalEvent);\n\n connection.endpoints[0].detachFromConnection(connection);\n connection.endpoints[1].detachFromConnection(connection);\n _ju.removeWithFunction(connections, function (_c) {\n return connection.id === _c.id;\n });\n\n connection.cleanup();\n connection.destroy();\n return true;\n }\n }\n return false;\n };\n\n /**\n * Remove all Connections from all elements, but leaves Endpoints in place ((unless a connection is set to auto delete its Endpoints).\n * @method deleteEveryConnection\n * @param {Object} [params] optional params object for the call\n * @param {Boolean} [params.fireEvent=true] Whether or not to fire detach events\n * @param {Boolean} [params.forceDetach=false] If true, this call will ignore any `beforeDetach` interceptors.\n * @returns {Number} The number of connections that were deleted.\n */\n this.deleteEveryConnection = function (params) {\n params = params || {};\n var count = connections.length, deletedCount = 0;\n _currentInstance.batch(function () {\n for (var i = 0; i < count; i++) {\n deletedCount += _currentInstance.deleteConnection(connections[0], params) ? 1 : 0;\n }\n });\n return deletedCount;\n };\n\n /**\n * Removes all an element's Connections.\n * @method deleteConnectionsForElement\n * @param {Object} el Either the id of the element, or a selector for the element.\n * @param {Object} [params] Optional parameters.\n * @param {Boolean} [params.fireEvent=true] Whether or not to fire the detach event.\n * @param {Boolean} [params.forceDetach=false] If true, this call will ignore any `beforeDetach` interceptors.\n * @return {jsPlumbInstance} The current jsPlumb instance.\n */\n this.deleteConnectionsForElement = function (el, params) {\n params = params || {};\n el = _currentInstance.getElement(el);\n var id = _getId(el), endpoints = endpointsByElement[id];\n if (endpoints && endpoints.length) {\n for (var i = 0, j = endpoints.length; i < j; i++) {\n endpoints[i].deleteEveryConnection(params);\n }\n }\n return _currentInstance;\n };\n\n /// not public. but of course its exposed. how to change this.\n this.deleteObject = function (params) {\n var result = {\n endpoints: {},\n connections: {},\n endpointCount: 0,\n connectionCount: 0\n },\n deleteAttachedObjects = params.deleteAttachedObjects !== false;\n\n var unravelConnection = function (connection) {\n if (connection != null && result.connections[connection.id] == null) {\n if (!params.dontUpdateHover && connection._jsPlumb != null) {\n connection.setHover(false);\n }\n result.connections[connection.id] = connection;\n result.connectionCount++;\n }\n };\n var unravelEndpoint = function (endpoint) {\n if (endpoint != null && result.endpoints[endpoint.id] == null) {\n if (!params.dontUpdateHover && endpoint._jsPlumb != null) {\n endpoint.setHover(false);\n }\n result.endpoints[endpoint.id] = endpoint;\n result.endpointCount++;\n\n if (deleteAttachedObjects) {\n for (var i = 0; i < endpoint.connections.length; i++) {\n var c = endpoint.connections[i];\n unravelConnection(c);\n }\n }\n }\n };\n\n if (params.connection) {\n unravelConnection(params.connection);\n }\n else {\n unravelEndpoint(params.endpoint);\n }\n\n // loop through connections\n for (var i in result.connections) {\n var c = result.connections[i];\n if (c._jsPlumb) {\n _ju.removeWithFunction(connections, function (_c) {\n return c.id === _c.id;\n });\n\n fireDetachEvent(c, params.fireEvent === false ? false : !c.pending, params.originalEvent);\n var doNotCleanup = params.deleteAttachedObjects == null ? null : !params.deleteAttachedObjects;\n\n c.endpoints[0].detachFromConnection(c, null, doNotCleanup);\n c.endpoints[1].detachFromConnection(c, null, doNotCleanup);\n\n c.cleanup(true);\n c.destroy(true);\n }\n }\n\n // loop through endpoints\n for (var j in result.endpoints) {\n var e = result.endpoints[j];\n if (e._jsPlumb) {\n _currentInstance.unregisterEndpoint(e);\n // FIRE some endpoint deleted event?\n e.cleanup(true);\n e.destroy(true);\n }\n }\n\n return result;\n };\n\n\n // helpers for select/selectEndpoints\n var _setOperation = function (list, func, args, selector) {\n for (var i = 0, j = list.length; i < j; i++) {\n list[i][func].apply(list[i], args);\n }\n return selector(list);\n },\n _getOperation = function (list, func, args) {\n var out = [];\n for (var i = 0, j = list.length; i < j; i++) {\n out.push([ list[i][func].apply(list[i], args), list[i] ]);\n }\n return out;\n },\n setter = function (list, func, selector) {\n return function () {\n return _setOperation(list, func, arguments, selector);\n };\n },\n getter = function (list, func) {\n return function () {\n return _getOperation(list, func, arguments);\n };\n },\n prepareList = function (input, doNotGetIds) {\n var r = [];\n if (input) {\n if (typeof input === 'string') {\n if (input === \"*\") {\n return input;\n }\n r.push(input);\n }\n else {\n if (doNotGetIds) {\n r = input;\n }\n else {\n if (input.length) {\n for (var i = 0, j = input.length; i < j; i++) {\n r.push(_info(input[i]).id);\n }\n }\n else {\n r.push(_info(input).id);\n }\n }\n }\n }\n return r;\n },\n filterList = function (list, value, missingIsFalse) {\n if (list === \"*\") {\n return true;\n }\n return list.length > 0 ? list.indexOf(value) !== -1 : !missingIsFalse;\n };\n\n // get some connections, specifying source/target/scope\n this.getConnections = function (options, flat) {\n if (!options) {\n options = {};\n } else if (options.constructor === String) {\n options = { \"scope\": options };\n }\n var scope = options.scope || _currentInstance.getDefaultScope(),\n scopes = prepareList(scope, true),\n sources = prepareList(options.source),\n targets = prepareList(options.target),\n results = (!flat && scopes.length > 1) ? {} : [],\n _addOne = function (scope, obj) {\n if (!flat && scopes.length > 1) {\n var ss = results[scope];\n if (ss == null) {\n ss = results[scope] = [];\n }\n ss.push(obj);\n } else {\n results.push(obj);\n }\n };\n\n for (var j = 0, jj = connections.length; j < jj; j++) {\n var c = connections[j],\n sourceId = c.proxies && c.proxies[0] ? c.proxies[0].originalEp.elementId : c.sourceId,\n targetId = c.proxies && c.proxies[1] ? c.proxies[1].originalEp.elementId : c.targetId;\n\n if (filterList(scopes, c.scope) && filterList(sources, sourceId) && filterList(targets, targetId)) {\n _addOne(c.scope, c);\n }\n }\n\n return results;\n };\n\n var _curryEach = function (list, executor) {\n return function (f) {\n for (var i = 0, ii = list.length; i < ii; i++) {\n f(list[i]);\n }\n return executor(list);\n };\n },\n _curryGet = function (list) {\n return function (idx) {\n return list[idx];\n };\n };\n\n var _makeCommonSelectHandler = function (list, executor) {\n var out = {\n length: list.length,\n each: _curryEach(list, executor),\n get: _curryGet(list)\n },\n setters = [\"setHover\", \"removeAllOverlays\", \"setLabel\", \"addClass\", \"addOverlay\", \"removeOverlay\",\n \"removeOverlays\", \"showOverlay\", \"hideOverlay\", \"showOverlays\", \"hideOverlays\", \"setPaintStyle\",\n \"setHoverPaintStyle\", \"setSuspendEvents\", \"setParameter\", \"setParameters\", \"setVisible\",\n \"repaint\", \"addType\", \"toggleType\", \"removeType\", \"removeClass\", \"setType\", \"bind\", \"unbind\" ],\n\n getters = [\"getLabel\", \"getOverlay\", \"isHover\", \"getParameter\", \"getParameters\", \"getPaintStyle\",\n \"getHoverPaintStyle\", \"isVisible\", \"hasType\", \"getType\", \"isSuspendEvents\" ],\n i, ii;\n\n for (i = 0, ii = setters.length; i < ii; i++) {\n out[setters[i]] = setter(list, setters[i], executor);\n }\n\n for (i = 0, ii = getters.length; i < ii; i++) {\n out[getters[i]] = getter(list, getters[i]);\n }\n\n return out;\n };\n\n var _makeConnectionSelectHandler = function (list) {\n var common = _makeCommonSelectHandler(list, _makeConnectionSelectHandler);\n return jsPlumb.extend(common, {\n // setters\n setDetachable: setter(list, \"setDetachable\", _makeConnectionSelectHandler),\n setReattach: setter(list, \"setReattach\", _makeConnectionSelectHandler),\n setConnector: setter(list, \"setConnector\", _makeConnectionSelectHandler),\n delete: function () {\n for (var i = 0, ii = list.length; i < ii; i++) {\n _currentInstance.deleteConnection(list[i]);\n }\n },\n // getters\n isDetachable: getter(list, \"isDetachable\"),\n isReattach: getter(list, \"isReattach\")\n });\n };\n\n var _makeEndpointSelectHandler = function (list) {\n var common = _makeCommonSelectHandler(list, _makeEndpointSelectHandler);\n return jsPlumb.extend(common, {\n setEnabled: setter(list, \"setEnabled\", _makeEndpointSelectHandler),\n setAnchor: setter(list, \"setAnchor\", _makeEndpointSelectHandler),\n isEnabled: getter(list, \"isEnabled\"),\n deleteEveryConnection: function () {\n for (var i = 0, ii = list.length; i < ii; i++) {\n list[i].deleteEveryConnection();\n }\n },\n \"delete\": function () {\n for (var i = 0, ii = list.length; i < ii; i++) {\n _currentInstance.deleteEndpoint(list[i]);\n }\n }\n });\n };\n\n this.select = function (params) {\n params = params || {};\n params.scope = params.scope || \"*\";\n return _makeConnectionSelectHandler(params.connections || _currentInstance.getConnections(params, true));\n };\n\n this.selectEndpoints = function (params) {\n params = params || {};\n params.scope = params.scope || \"*\";\n var noElementFilters = !params.element && !params.source && !params.target,\n elements = noElementFilters ? \"*\" : prepareList(params.element),\n sources = noElementFilters ? \"*\" : prepareList(params.source),\n targets = noElementFilters ? \"*\" : prepareList(params.target),\n scopes = prepareList(params.scope, true);\n\n var ep = [];\n\n for (var el in endpointsByElement) {\n var either = filterList(elements, el, true),\n source = filterList(sources, el, true),\n sourceMatchExact = sources !== \"*\",\n target = filterList(targets, el, true),\n targetMatchExact = targets !== \"*\";\n\n // if they requested 'either' then just match scope. otherwise if they requested 'source' (not as a wildcard) then we have to match only endpoints that have isSource set to to true, and the same thing with isTarget.\n if (either || source || target) {\n inner:\n for (var i = 0, ii = endpointsByElement[el].length; i < ii; i++) {\n var _ep = endpointsByElement[el][i];\n if (filterList(scopes, _ep.scope, true)) {\n\n var noMatchSource = (sourceMatchExact && sources.length > 0 && !_ep.isSource),\n noMatchTarget = (targetMatchExact && targets.length > 0 && !_ep.isTarget);\n\n if (noMatchSource || noMatchTarget) {\n continue inner;\n }\n\n ep.push(_ep);\n }\n }\n }\n }\n\n return _makeEndpointSelectHandler(ep);\n };\n\n // get all connections managed by the instance of jsplumb.\n this.getAllConnections = function () {\n return connections;\n };\n this.getDefaultScope = function () {\n return DEFAULT_SCOPE;\n };\n // get an endpoint by uuid.\n this.getEndpoint = _getEndpoint;\n /**\n * Gets the list of Endpoints for a given element.\n * @method getEndpoints\n * @param {String|Element|Selector} el The element to get endpoints for.\n * @return {Endpoint[]} An array of Endpoints for the specified element.\n */\n this.getEndpoints = function (el) {\n return endpointsByElement[_info(el).id] || [];\n };\n // gets the default endpoint type. used when subclassing. see wiki.\n this.getDefaultEndpointType = function () {\n return jsPlumb.Endpoint;\n };\n // gets the default connection type. used when subclassing. see wiki.\n this.getDefaultConnectionType = function () {\n return jsPlumb.Connection;\n };\n /*\n * Gets an element's id, creating one if necessary. really only exposed\n * for the lib-specific functionality to access; would be better to pass\n * the current instance into the lib-specific code (even though this is\n * a static call. i just don't want to expose it to the public API).\n */\n this.getId = _getId;\n this.draw = _draw;\n this.info = _info;\n\n this.appendElement = _appendElement;\n\n var _hoverSuspended = false;\n this.isHoverSuspended = function () {\n return _hoverSuspended;\n };\n this.setHoverSuspended = function (s) {\n _hoverSuspended = s;\n };\n\n // set an element's connections to be hidden\n this.hide = function (el, changeEndpoints) {\n _setVisible(el, \"none\", changeEndpoints);\n return _currentInstance;\n };\n\n // exposed for other objects to use to get a unique id.\n this.idstamp = _idstamp;\n\n // ensure that, if the current container exists, it is a DOM element and not a selector.\n // if it does not exist and `candidate` is supplied, the offset parent of that element will be set as the Container.\n // this is used to do a better default behaviour for the case that the user has not set a container:\n // addEndpoint, makeSource, makeTarget and connect all call this method with the offsetParent of the\n // element in question (for connect it is the source element). So if no container is set, it is inferred\n // to be the offsetParent of the first element the user tries to connect.\n var _ensureContainer = function (candidate) {\n if (!_container && candidate) {\n var can = _currentInstance.getElement(candidate);\n if (can.offsetParent) {\n _currentInstance.setContainer(can.offsetParent);\n }\n }\n };\n\n var _getContainerFromDefaults = function () {\n if (_currentInstance.Defaults.Container) {\n _currentInstance.setContainer(_currentInstance.Defaults.Container);\n }\n };\n\n // check if a given element is managed or not. if not, add to our map. if drawing is not suspended then\n // we'll also stash its dimensions; otherwise we'll do this in a lazy way through updateOffset.\n var _manage = _currentInstance.manage = function (id, element, _transient) {\n if (!managedElements[id]) {\n managedElements[id] = {\n el: element,\n endpoints: [],\n connections: []\n };\n\n managedElements[id].info = _updateOffset({ elId: id, timestamp: _suspendedAt });\n _currentInstance.addClass(element, \"jtk-managed\");\n if (!_transient) {\n _currentInstance.fire(\"manageElement\", { id:id, info:managedElements[id].info, el:element });\n }\n }\n\n return managedElements[id];\n };\n\n var _unmanage = _currentInstance.unmanage = function(id) {\n if (managedElements[id]) {\n _currentInstance.removeClass(managedElements[id].el, \"jtk-managed\");\n delete managedElements[id];\n _currentInstance.fire(\"unmanageElement\", id);\n }\n };\n\n /**\n * updates the offset and size for a given element, and stores the\n * values. if 'offset' is not null we use that (it would have been\n * passed in from a drag call) because it's faster; but if it is null,\n * or if 'recalc' is true in order to force a recalculation, we get the current values.\n * @method updateOffset\n */\n var _updateOffset = function (params) {\n\n var timestamp = params.timestamp, recalc = params.recalc, offset = params.offset, elId = params.elId, s;\n if (_suspendDrawing && !timestamp) {\n timestamp = _suspendedAt;\n }\n if (!recalc) {\n if (timestamp && timestamp === offsetTimestamps[elId]) {\n return {o: params.offset || offsets[elId], s: sizes[elId]};\n }\n }\n if (recalc || (!offset && offsets[elId] == null)) { // if forced repaint or no offset available, we recalculate.\n\n // get the current size and offset, and store them\n s = managedElements[elId] ? managedElements[elId].el : null;\n if (s != null) {\n sizes[elId] = _currentInstance.getSize(s);\n offsets[elId] = _currentInstance.getOffset(s);\n offsetTimestamps[elId] = timestamp;\n }\n } else {\n offsets[elId] = offset || offsets[elId];\n if (sizes[elId] == null) {\n s = managedElements[elId].el;\n if (s != null) {\n sizes[elId] = _currentInstance.getSize(s);\n }\n }\n offsetTimestamps[elId] = timestamp;\n }\n\n if (offsets[elId] && !offsets[elId].right) {\n offsets[elId].right = offsets[elId].left + sizes[elId][0];\n offsets[elId].bottom = offsets[elId].top + sizes[elId][1];\n offsets[elId].width = sizes[elId][0];\n offsets[elId].height = sizes[elId][1];\n offsets[elId].centerx = offsets[elId].left + (offsets[elId].width / 2);\n offsets[elId].centery = offsets[elId].top + (offsets[elId].height / 2);\n }\n\n return {o: offsets[elId], s: sizes[elId]};\n };\n\n this.updateOffset = _updateOffset;\n\n /**\n * callback from the current library to tell us to prepare ourselves (attach\n * mouse listeners etc; can't do that until the library has provided a bind method)\n */\n this.init = function () {\n if (!initialized) {\n _getContainerFromDefaults();\n _currentInstance.anchorManager = new root.jsPlumb.AnchorManager({jsPlumbInstance: _currentInstance});\n initialized = true;\n _currentInstance.fire(\"ready\", _currentInstance);\n }\n }.bind(this);\n\n this.log = log;\n this.jsPlumbUIComponent = jsPlumbUIComponent;\n\n /*\n * Creates an anchor with the given params.\n *\n *\n * Returns: The newly created Anchor.\n * Throws: an error if a named anchor was not found.\n */\n this.makeAnchor = function () {\n var pp, _a = function (t, p) {\n if (root.jsPlumb.Anchors[t]) {\n return new root.jsPlumb.Anchors[t](p);\n }\n if (!_currentInstance.Defaults.DoNotThrowErrors) {\n throw { msg: \"jsPlumb: unknown anchor type '\" + t + \"'\" };\n }\n };\n if (arguments.length === 0) {\n return null;\n }\n var specimen = arguments[0], elementId = arguments[1], jsPlumbInstance = arguments[2], newAnchor = null;\n // if it appears to be an anchor already...\n if (specimen.compute && specimen.getOrientation) {\n return specimen;\n } //TODO hazy here about whether it should be added or is already added somehow.\n // is it the name of an anchor type?\n else if (typeof specimen === \"string\") {\n newAnchor = _a(arguments[0], {elementId: elementId, jsPlumbInstance: _currentInstance});\n }\n // is it an array? it will be one of:\n // an array of [spec, params] - this defines a single anchor, which may be dynamic, but has parameters.\n // an array of arrays - this defines some dynamic anchors\n // an array of numbers - this defines a single anchor.\n else if (_ju.isArray(specimen)) {\n if (_ju.isArray(specimen[0]) || _ju.isString(specimen[0])) {\n // if [spec, params] format\n if (specimen.length === 2 && _ju.isObject(specimen[1])) {\n // if first arg is a string, its a named anchor with params\n if (_ju.isString(specimen[0])) {\n pp = root.jsPlumb.extend({elementId: elementId, jsPlumbInstance: _currentInstance}, specimen[1]);\n newAnchor = _a(specimen[0], pp);\n }\n // otherwise first arg is array, second is params. we treat as a dynamic anchor, which is fine\n // even if the first arg has only one entry. you could argue all anchors should be implicitly dynamic in fact.\n else {\n pp = root.jsPlumb.extend({elementId: elementId, jsPlumbInstance: _currentInstance, anchors: specimen[0]}, specimen[1]);\n newAnchor = new root.jsPlumb.DynamicAnchor(pp);\n }\n }\n else {\n newAnchor = new jsPlumb.DynamicAnchor({anchors: specimen, selector: null, elementId: elementId, jsPlumbInstance: _currentInstance});\n }\n\n }\n else {\n var anchorParams = {\n x: specimen[0], y: specimen[1],\n orientation: (specimen.length >= 4) ? [ specimen[2], specimen[3] ] : [0, 0],\n offsets: (specimen.length >= 6) ? [ specimen[4], specimen[5] ] : [ 0, 0 ],\n elementId: elementId,\n jsPlumbInstance: _currentInstance,\n cssClass: specimen.length === 7 ? specimen[6] : null\n };\n newAnchor = new root.jsPlumb.Anchor(anchorParams);\n newAnchor.clone = function () {\n return new root.jsPlumb.Anchor(anchorParams);\n };\n }\n }\n\n if (!newAnchor.id) {\n newAnchor.id = \"anchor_\" + _idstamp();\n }\n return newAnchor;\n };\n\n /**\n * makes a list of anchors from the given list of types or coords, eg\n * [\"TopCenter\", \"RightMiddle\", \"BottomCenter\", [0, 1, -1, -1] ]\n */\n this.makeAnchors = function (types, elementId, jsPlumbInstance) {\n var r = [];\n for (var i = 0, ii = types.length; i < ii; i++) {\n if (typeof types[i] === \"string\") {\n r.push(root.jsPlumb.Anchors[types[i]]({elementId: elementId, jsPlumbInstance: jsPlumbInstance}));\n }\n else if (_ju.isArray(types[i])) {\n r.push(_currentInstance.makeAnchor(types[i], elementId, jsPlumbInstance));\n }\n }\n return r;\n };\n\n /**\n * Makes a dynamic anchor from the given list of anchors (which may be in shorthand notation as strings or dimension arrays, or Anchor\n * objects themselves) and the given, optional, anchorSelector function (jsPlumb uses a default if this is not provided; most people will\n * not need to provide this - i think).\n */\n this.makeDynamicAnchor = function (anchors, anchorSelector) {\n return new root.jsPlumb.DynamicAnchor({anchors: anchors, selector: anchorSelector, elementId: null, jsPlumbInstance: _currentInstance});\n };\n\n// --------------------- makeSource/makeTarget ----------------------------------------------\n\n this.targetEndpointDefinitions = {};\n this.sourceEndpointDefinitions = {};\n\n var selectorFilter = function (evt, _el, selector, _instance, negate) {\n var t = evt.target || evt.srcElement, ok = false,\n sel = _instance.getSelector(_el, selector);\n for (var j = 0; j < sel.length; j++) {\n if (sel[j] === t) {\n ok = true;\n break;\n }\n }\n return negate ? !ok : ok;\n };\n\n var _makeElementDropHandler = function (elInfo, p, dropOptions, isSource, isTarget) {\n var proxyComponent = new jsPlumbUIComponent(p);\n var _drop = p._jsPlumb.EndpointDropHandler({\n jsPlumb: _currentInstance,\n enabled: function () {\n return elInfo.def.enabled;\n },\n isFull: function () {\n var targetCount = _currentInstance.select({target: elInfo.id}).length;\n return elInfo.def.maxConnections > 0 && targetCount >= elInfo.def.maxConnections;\n },\n element: elInfo.el,\n elementId: elInfo.id,\n isSource: isSource,\n isTarget: isTarget,\n addClass: function (clazz) {\n _currentInstance.addClass(elInfo.el, clazz);\n },\n removeClass: function (clazz) {\n _currentInstance.removeClass(elInfo.el, clazz);\n },\n onDrop: function (jpc) {\n var source = jpc.endpoints[0];\n source.anchor.unlock();\n },\n isDropAllowed: function () {\n return proxyComponent.isDropAllowed.apply(proxyComponent, arguments);\n },\n isRedrop:function(jpc) {\n return (jpc.suspendedElement != null && jpc.suspendedEndpoint != null && jpc.suspendedEndpoint.element === elInfo.el);\n },\n getEndpoint: function (jpc) {\n\n // make a new Endpoint for the target, or get it from the cache if uniqueEndpoint\n // is set. if its a redrop the new endpoint will be immediately cleaned up.\n\n var newEndpoint = elInfo.def.endpoint;\n\n // if no cached endpoint, or there was one but it has been cleaned up\n // (ie. detached), create a new one\n if (newEndpoint == null || newEndpoint._jsPlumb == null) {\n var eps = _currentInstance.deriveEndpointAndAnchorSpec(jpc.getType().join(\" \"), true);\n var pp = eps.endpoints ? root.jsPlumb.extend(p, {\n endpoint:elInfo.def.def.endpoint || eps.endpoints[1]\n }) :p;\n if (eps.anchors) {\n pp = root.jsPlumb.extend(pp, {\n anchor:elInfo.def.def.anchor || eps.anchors[1]\n });\n }\n newEndpoint = _currentInstance.addEndpoint(elInfo.el, pp);\n newEndpoint._mtNew = true;\n }\n\n if (p.uniqueEndpoint) {\n elInfo.def.endpoint = newEndpoint;\n }\n\n newEndpoint.setDeleteOnEmpty(true);\n\n // if connection is detachable, init the new endpoint to be draggable, to support that happening.\n if (jpc.isDetachable()) {\n newEndpoint.initDraggable();\n }\n\n // if the anchor has a 'positionFinder' set, then delegate to that function to find\n // out where to locate the anchor.\n if (newEndpoint.anchor.positionFinder != null) {\n var dropPosition = _currentInstance.getUIPosition(arguments, _currentInstance.getZoom()),\n elPosition = _currentInstance.getOffset(elInfo.el),\n elSize = _currentInstance.getSize(elInfo.el),\n ap = dropPosition == null ? [0,0] : newEndpoint.anchor.positionFinder(dropPosition, elPosition, elSize, newEndpoint.anchor.constructorParams);\n\n newEndpoint.anchor.x = ap[0];\n newEndpoint.anchor.y = ap[1];\n // now figure an orientation for it..kind of hard to know what to do actually. probably the best thing i can do is to\n // support specifying an orientation in the anchor's spec. if one is not supplied then i will make the orientation\n // be what will cause the most natural link to the source: it will be pointing at the source, but it needs to be\n // specified in one axis only, and so how to make that choice? i think i will use whichever axis is the one in which\n // the target is furthest away from the source.\n }\n\n return newEndpoint;\n },\n maybeCleanup: function (ep) {\n if (ep._mtNew && ep.connections.length === 0) {\n _currentInstance.deleteObject({endpoint: ep});\n }\n else {\n delete ep._mtNew;\n }\n }\n });\n\n // wrap drop events as needed and initialise droppable\n var dropEvent = root.jsPlumb.dragEvents.drop;\n dropOptions.scope = dropOptions.scope || (p.scope || _currentInstance.Defaults.Scope);\n dropOptions[dropEvent] = _ju.wrap(dropOptions[dropEvent], _drop, true);\n dropOptions.rank = p.rank || 0;\n\n // if target, return true from the over event. this will cause katavorio to stop setting drops to hover\n // if multipleDrop is set to false.\n if (isTarget) {\n dropOptions[root.jsPlumb.dragEvents.over] = function () { return true; };\n }\n\n // vanilla jsplumb only\n if (p.allowLoopback === false) {\n dropOptions.canDrop = function (_drag) {\n var de = _drag.getDragElement()._jsPlumbRelatedElement;\n return de !== elInfo.el;\n };\n }\n _currentInstance.initDroppable(elInfo.el, dropOptions, \"internal\");\n\n return _drop;\n\n };\n\n // see API docs\n this.makeTarget = function (el, params, referenceParams) {\n\n // put jsplumb ref into params without altering the params passed in\n var p = root.jsPlumb.extend({_jsPlumb: this}, referenceParams);\n root.jsPlumb.extend(p, params);\n\n var maxConnections = p.maxConnections || -1,\n\n _doOne = function (el) {\n\n // get the element's id and store the endpoint definition for it. jsPlumb.connect calls will look for one of these,\n // and use the endpoint definition if found.\n // decode the info for this element (id and element)\n var elInfo = _info(el),\n elid = elInfo.id,\n dropOptions = root.jsPlumb.extend({}, p.dropOptions || {}),\n type = p.connectionType || \"default\";\n\n this.targetEndpointDefinitions[elid] = this.targetEndpointDefinitions[elid] || {};\n\n _ensureContainer(elid);\n\n // if this is a group and the user has not mandated a rank, set to -1 so that Nodes takes\n // precedence.\n if (elInfo.el._isJsPlumbGroup && dropOptions.rank == null) {\n dropOptions.rank = -1;\n }\n\n // store the definition\n var _def = {\n def: root.jsPlumb.extend({}, p),\n uniqueEndpoint: p.uniqueEndpoint,\n maxConnections: maxConnections,\n enabled: true\n };\n\n if (p.createEndpoint) {\n _def.uniqueEndpoint = true;\n _def.endpoint = _currentInstance.addEndpoint(el, _def.def);\n _def.endpoint.setDeleteOnEmpty(false);\n }\n\n elInfo.def = _def;\n this.targetEndpointDefinitions[elid][type] = _def;\n _makeElementDropHandler(elInfo, p, dropOptions, p.isSource === true, true);\n // stash the definition on the drop\n elInfo.el._katavorioDrop[elInfo.el._katavorioDrop.length - 1].targetDef = _def;\n\n }.bind(this);\n\n // make an array if only given one element\n var inputs = el.length && el.constructor !== String ? el : [ el ];\n\n // register each one in the list.\n for (var i = 0, ii = inputs.length; i < ii; i++) {\n _doOne(inputs[i]);\n }\n\n return this;\n };\n\n // see api docs\n this.unmakeTarget = function (el, doNotClearArrays) {\n var info = _info(el);\n _currentInstance.destroyDroppable(info.el, \"internal\");\n if (!doNotClearArrays) {\n delete this.targetEndpointDefinitions[info.id];\n }\n\n return this;\n };\n\n // see api docs\n this.makeSource = function (el, params, referenceParams) {\n var p = root.jsPlumb.extend({_jsPlumb: this}, referenceParams);\n root.jsPlumb.extend(p, params);\n var type = p.connectionType || \"default\";\n var aae = _currentInstance.deriveEndpointAndAnchorSpec(type);\n p.endpoint = p.endpoint || aae.endpoints[0];\n p.anchor = p.anchor || aae.anchors[0];\n var maxConnections = p.maxConnections || -1,\n onMaxConnections = p.onMaxConnections,\n _doOne = function (elInfo) {\n // get the element's id and store the endpoint definition for it. jsPlumb.connect calls will look for one of these,\n // and use the endpoint definition if found.\n var elid = elInfo.id,\n _del = this.getElement(elInfo.el);\n\n this.sourceEndpointDefinitions[elid] = this.sourceEndpointDefinitions[elid] || {};\n _ensureContainer(elid);\n\n var _def = {\n def:root.jsPlumb.extend({}, p),\n uniqueEndpoint: p.uniqueEndpoint,\n maxConnections: maxConnections,\n enabled: true\n };\n\n if (p.createEndpoint) {\n _def.uniqueEndpoint = true;\n _def.endpoint = _currentInstance.addEndpoint(el, _def.def);\n _def.endpoint.setDeleteOnEmpty(false);\n }\n\n this.sourceEndpointDefinitions[elid][type] = _def;\n elInfo.def = _def;\n\n var stopEvent = root.jsPlumb.dragEvents.stop,\n dragEvent = root.jsPlumb.dragEvents.drag,\n dragOptions = root.jsPlumb.extend({ }, p.dragOptions || {}),\n existingDrag = dragOptions.drag,\n existingStop = dragOptions.stop,\n ep = null,\n endpointAddedButNoDragYet = false;\n\n // set scope if its not set in dragOptions but was passed in in params\n dragOptions.scope = dragOptions.scope || p.scope;\n\n dragOptions[dragEvent] = _ju.wrap(dragOptions[dragEvent], function () {\n if (existingDrag) {\n existingDrag.apply(this, arguments);\n }\n endpointAddedButNoDragYet = false;\n });\n\n dragOptions[stopEvent] = _ju.wrap(dragOptions[stopEvent], function () {\n\n if (existingStop) {\n existingStop.apply(this, arguments);\n }\n this.currentlyDragging = false;\n if (ep._jsPlumb != null) { // if not cleaned up...\n\n // reset the anchor to the anchor that was initially provided. the one we were using to drag\n // the connection was just a placeholder that was located at the place the user pressed the\n // mouse button to initiate the drag.\n var anchorDef = p.anchor || this.Defaults.Anchor,\n oldAnchor = ep.anchor,\n oldConnection = ep.connections[0];\n\n var newAnchor = this.makeAnchor(anchorDef, elid, this),\n _el = ep.element;\n\n // if the anchor has a 'positionFinder' set, then delegate to that function to find\n // out where to locate the anchor. issue 117.\n if (newAnchor.positionFinder != null) {\n var elPosition = _currentInstance.getOffset(_el),\n elSize = this.getSize(_el),\n dropPosition = { left: elPosition.left + (oldAnchor.x * elSize[0]), top: elPosition.top + (oldAnchor.y * elSize[1]) },\n ap = newAnchor.positionFinder(dropPosition, elPosition, elSize, newAnchor.constructorParams);\n\n newAnchor.x = ap[0];\n newAnchor.y = ap[1];\n }\n\n ep.setAnchor(newAnchor, true);\n ep.repaint();\n this.repaint(ep.elementId);\n if (oldConnection != null) {\n this.repaint(oldConnection.targetId);\n }\n }\n }.bind(this));\n\n // when the user presses the mouse, add an Endpoint, if we are enabled.\n var mouseDownListener = function (e) {\n // on right mouse button, abort.\n if (e.which === 3 || e.button === 2) {\n return;\n }\n\n // TODO store def on element.\n var def = this.sourceEndpointDefinitions[elid][type];\n\n // if disabled, return.\n if (!def.enabled) {\n return;\n }\n\n elid = this.getId(this.getElement(elInfo.el)); // elid might have changed since this method was called to configure the element.\n\n // if a filter was given, run it, and return if it says no.\n if (p.filter) {\n var r = _ju.isString(p.filter) ? selectorFilter(e, elInfo.el, p.filter, this, p.filterExclude) : p.filter(e, elInfo.el);\n if (r === false) {\n return;\n }\n }\n\n // if maxConnections reached\n var sourceCount = this.select({source: elid}).length;\n if (def.maxConnections >= 0 && (sourceCount >= def.maxConnections)) {\n if (onMaxConnections) {\n onMaxConnections({\n element: elInfo.el,\n maxConnections: maxConnections\n }, e);\n }\n return false;\n }\n\n // find the position on the element at which the mouse was pressed; this is where the endpoint\n // will be located.\n var elxy = root.jsPlumb.getPositionOnElement(e, _del, _zoom);\n\n // we need to override the anchor in here, and force 'isSource', but we don't want to mess with\n // the params passed in, because after a connection is established we're going to reset the endpoint\n // to have the anchor we were given.\n var tempEndpointParams = {};\n root.jsPlumb.extend(tempEndpointParams, p);\n tempEndpointParams.isTemporarySource = true;\n tempEndpointParams.anchor = [ elxy[0], elxy[1] , 0, 0];\n tempEndpointParams.dragOptions = dragOptions;\n\n if (def.def.scope) {\n tempEndpointParams.scope = def.def.scope;\n }\n\n ep = this.addEndpoint(elid, tempEndpointParams);\n endpointAddedButNoDragYet = true;\n ep.setDeleteOnEmpty(true);\n\n // if unique endpoint and it's already been created, push it onto the endpoint we create. at the end\n // of a successful connection we'll switch to that endpoint.\n // TODO this is the same code as the programmatic endpoints create on line 1050 ish\n if (def.uniqueEndpoint) {\n if (!def.endpoint) {\n def.endpoint = ep;\n ep.setDeleteOnEmpty(false);\n }\n else {\n ep.finalEndpoint = def.endpoint;\n }\n }\n\n var _delTempEndpoint = function () {\n // this mouseup event is fired only if no dragging occurred, by jquery and yui, but for mootools\n // it is fired even if dragging has occurred, in which case we would blow away a perfectly\n // legitimate endpoint, were it not for this check. the flag is set after adding an\n // endpoint and cleared in a drag listener we set in the dragOptions above.\n _currentInstance.off(ep.canvas, \"mouseup\", _delTempEndpoint);\n _currentInstance.off(elInfo.el, \"mouseup\", _delTempEndpoint);\n if (endpointAddedButNoDragYet) {\n endpointAddedButNoDragYet = false;\n _currentInstance.deleteEndpoint(ep);\n }\n };\n\n _currentInstance.on(ep.canvas, \"mouseup\", _delTempEndpoint);\n _currentInstance.on(elInfo.el, \"mouseup\", _delTempEndpoint);\n\n // optionally check for attributes to extract from the source element\n var payload = {};\n if (def.def.extract) {\n for (var att in def.def.extract) {\n var v = (e.srcElement || e.target).getAttribute(att);\n if (v) {\n payload[def.def.extract[att]] = v;\n }\n }\n }\n\n // and then trigger its mousedown event, which will kick off a drag, which will start dragging\n // a new connection from this endpoint.\n _currentInstance.trigger(ep.canvas, \"mousedown\", e, payload);\n\n _ju.consume(e);\n\n }.bind(this);\n\n this.on(elInfo.el, \"mousedown\", mouseDownListener);\n _def.trigger = mouseDownListener;\n\n // if a filter was provided, set it as a dragFilter on the element,\n // to prevent the element drag function from kicking in when we want to\n // drag a new connection\n if (p.filter && (_ju.isString(p.filter) || _ju.isFunction(p.filter))) {\n _currentInstance.setDragFilter(elInfo.el, p.filter);\n }\n\n var dropOptions = root.jsPlumb.extend({}, p.dropOptions || {});\n\n _makeElementDropHandler(elInfo, p, dropOptions, true, p.isTarget === true);\n\n }.bind(this);\n\n var inputs = el.length && el.constructor !== String ? el : [ el ];\n for (var i = 0, ii = inputs.length; i < ii; i++) {\n _doOne(_info(inputs[i]));\n }\n\n return this;\n };\n\n // see api docs\n this.unmakeSource = function (el, connectionType, doNotClearArrays) {\n var info = _info(el);\n _currentInstance.destroyDroppable(info.el, \"internal\");\n var eldefs = this.sourceEndpointDefinitions[info.id];\n if (eldefs) {\n for (var def in eldefs) {\n if (connectionType == null || connectionType === def) {\n var mouseDownListener = eldefs[def].trigger;\n if (mouseDownListener) {\n _currentInstance.off(info.el, \"mousedown\", mouseDownListener);\n }\n if (!doNotClearArrays) {\n delete this.sourceEndpointDefinitions[info.id][def];\n }\n }\n }\n }\n\n return this;\n };\n\n // see api docs\n this.unmakeEverySource = function () {\n for (var i in this.sourceEndpointDefinitions) {\n _currentInstance.unmakeSource(i, null, true);\n }\n\n this.sourceEndpointDefinitions = {};\n return this;\n };\n\n var _getScope = function (el, types, connectionType) {\n types = _ju.isArray(types) ? types : [ types ];\n var id = _getId(el);\n connectionType = connectionType || \"default\";\n for (var i = 0; i < types.length; i++) {\n var eldefs = this[types[i]][id];\n if (eldefs && eldefs[connectionType]) {\n return eldefs[connectionType].def.scope || this.Defaults.Scope;\n }\n }\n }.bind(this);\n\n var _setScope = function (el, scope, types, connectionType) {\n types = _ju.isArray(types) ? types : [ types ];\n var id = _getId(el);\n connectionType = connectionType || \"default\";\n for (var i = 0; i < types.length; i++) {\n var eldefs = this[types[i]][id];\n if (eldefs && eldefs[connectionType]) {\n eldefs[connectionType].def.scope = scope;\n }\n }\n\n }.bind(this);\n\n this.getScope = function (el, scope) {\n return _getScope(el, [ \"sourceEndpointDefinitions\", \"targetEndpointDefinitions\" ]);\n };\n this.getSourceScope = function (el) {\n return _getScope(el, \"sourceEndpointDefinitions\");\n };\n this.getTargetScope = function (el) {\n return _getScope(el, \"targetEndpointDefinitions\");\n };\n this.setScope = function (el, scope, connectionType) {\n this.setSourceScope(el, scope, connectionType);\n this.setTargetScope(el, scope, connectionType);\n };\n this.setSourceScope = function (el, scope, connectionType) {\n _setScope(el, scope, \"sourceEndpointDefinitions\", connectionType);\n // we get the source scope during the mousedown event, but we also want to set this.\n this.setDragScope(el, scope);\n };\n this.setTargetScope = function (el, scope, connectionType) {\n _setScope(el, scope, \"targetEndpointDefinitions\", connectionType);\n this.setDropScope(el, scope);\n };\n\n // see api docs\n this.unmakeEveryTarget = function () {\n for (var i in this.targetEndpointDefinitions) {\n _currentInstance.unmakeTarget(i, true);\n }\n\n this.targetEndpointDefinitions = {};\n return this;\n };\n\n // does the work of setting a source enabled or disabled.\n var _setEnabled = function (type, el, state, toggle, connectionType) {\n var a = type === \"source\" ? this.sourceEndpointDefinitions : this.targetEndpointDefinitions,\n originalState, info, newState;\n\n connectionType = connectionType || \"default\";\n\n // a selector or an array\n if (el.length && !_ju.isString(el)) {\n originalState = [];\n for (var i = 0, ii = el.length; i < ii; i++) {\n info = _info(el[i]);\n if (a[info.id] && a[info.id][connectionType]) {\n originalState[i] = a[info.id][connectionType].enabled;\n newState = toggle ? !originalState[i] : state;\n a[info.id][connectionType].enabled = newState;\n _currentInstance[newState ? \"removeClass\" : \"addClass\"](info.el, \"jtk-\" + type + \"-disabled\");\n }\n }\n }\n // otherwise a DOM element or a String ID.\n else {\n info = _info(el);\n var id = info.id;\n if (a[id] && a[id][connectionType]) {\n originalState = a[id][connectionType].enabled;\n newState = toggle ? !originalState : state;\n a[id][connectionType].enabled = newState;\n _currentInstance[newState ? \"removeClass\" : \"addClass\"](info.el, \"jtk-\" + type + \"-disabled\");\n }\n }\n return originalState;\n }.bind(this);\n\n var _first = function (el, fn) {\n if (_ju.isString(el) || !el.length) {\n return fn.apply(this, [ el ]);\n }\n else if (el.length) {\n return fn.apply(this, [ el[0] ]);\n }\n\n }.bind(this);\n\n this.toggleSourceEnabled = function (el, connectionType) {\n _setEnabled(\"source\", el, null, true, connectionType);\n return this.isSourceEnabled(el, connectionType);\n };\n\n this.setSourceEnabled = function (el, state, connectionType) {\n return _setEnabled(\"source\", el, state, null, connectionType);\n };\n this.isSource = function (el, connectionType) {\n connectionType = connectionType || \"default\";\n return _first(el, function (_el) {\n var eldefs = this.sourceEndpointDefinitions[_info(_el).id];\n return eldefs != null && eldefs[connectionType] != null;\n }.bind(this));\n };\n this.isSourceEnabled = function (el, connectionType) {\n connectionType = connectionType || \"default\";\n return _first(el, function (_el) {\n var sep = this.sourceEndpointDefinitions[_info(_el).id];\n return sep && sep[connectionType] && sep[connectionType].enabled === true;\n }.bind(this));\n };\n\n this.toggleTargetEnabled = function (el, connectionType) {\n _setEnabled(\"target\", el, null, true, connectionType);\n return this.isTargetEnabled(el, connectionType);\n };\n\n this.isTarget = function (el, connectionType) {\n connectionType = connectionType || \"default\";\n return _first(el, function (_el) {\n var eldefs = this.targetEndpointDefinitions[_info(_el).id];\n return eldefs != null && eldefs[connectionType] != null;\n }.bind(this));\n };\n this.isTargetEnabled = function (el, connectionType) {\n connectionType = connectionType || \"default\";\n return _first(el, function (_el) {\n var tep = this.targetEndpointDefinitions[_info(_el).id];\n return tep && tep[connectionType] && tep[connectionType].enabled === true;\n }.bind(this));\n };\n this.setTargetEnabled = function (el, state, connectionType) {\n return _setEnabled(\"target\", el, state, null, connectionType);\n };\n\n// --------------------- end makeSource/makeTarget ----------------------------------------------\n\n this.ready = function (fn) {\n _currentInstance.bind(\"ready\", fn);\n };\n\n var _elEach = function(el, fn) {\n // support both lists...\n if (typeof el === 'object' && el.length) {\n for (var i = 0, ii = el.length; i < ii; i++) {\n fn(el[i]);\n }\n }\n else {// ...and single strings or elements.\n fn(el);\n }\n\n return _currentInstance;\n };\n\n // repaint some element's endpoints and connections\n this.repaint = function (el, ui, timestamp) {\n return _elEach(el, function(_el) {\n _draw(_el, ui, timestamp);\n });\n };\n\n this.revalidate = function (el, timestamp, isIdAlready) {\n return _elEach(el, function(_el) {\n var elId = isIdAlready ? _el : _currentInstance.getId(_el);\n _currentInstance.updateOffset({ elId: elId, recalc: true, timestamp:timestamp });\n var dm = _currentInstance.getDragManager();\n if (dm) {\n dm.updateOffsets(elId);\n }\n _currentInstance.repaint(_el);\n });\n };\n\n // repaint every endpoint and connection.\n this.repaintEverything = function () {\n // TODO this timestamp causes continuous anchors to not repaint properly.\n // fix this. do not just take out the timestamp. it runs a lot faster with\n // the timestamp included.\n var timestamp = _timestamp(), elId;\n\n for (elId in endpointsByElement) {\n _currentInstance.updateOffset({ elId: elId, recalc: true, timestamp: timestamp });\n }\n\n for (elId in endpointsByElement) {\n _draw(elId, null, timestamp);\n }\n\n return this;\n };\n\n this.removeAllEndpoints = function (el, recurse, affectedElements) {\n affectedElements = affectedElements || [];\n var _one = function (_el) {\n var info = _info(_el),\n ebe = endpointsByElement[info.id],\n i, ii;\n\n if (ebe) {\n affectedElements.push(info);\n for (i = 0, ii = ebe.length; i < ii; i++) {\n _currentInstance.deleteEndpoint(ebe[i], false);\n }\n }\n delete endpointsByElement[info.id];\n\n if (recurse) {\n if (info.el && info.el.nodeType !== 3 && info.el.nodeType !== 8) {\n for (i = 0, ii = info.el.childNodes.length; i < ii; i++) {\n _one(info.el.childNodes[i]);\n }\n }\n }\n\n };\n _one(el);\n return this;\n };\n\n var _doRemove = function(info, affectedElements) {\n _currentInstance.removeAllEndpoints(info.id, true, affectedElements);\n var dm = _currentInstance.getDragManager();\n var _one = function(_info) {\n\n if (dm) {\n dm.elementRemoved(_info.id);\n }\n _currentInstance.anchorManager.clearFor(_info.id);\n _currentInstance.anchorManager.removeFloatingConnection(_info.id);\n\n if (_currentInstance.isSource(_info.el)) {\n _currentInstance.unmakeSource(_info.el);\n }\n if (_currentInstance.isTarget(_info.el)) {\n _currentInstance.unmakeTarget(_info.el);\n }\n _currentInstance.destroyDraggable(_info.el);\n _currentInstance.destroyDroppable(_info.el);\n\n\n delete _currentInstance.floatingConnections[_info.id];\n delete managedElements[_info.id];\n delete offsets[_info.id];\n if (_info.el) {\n _currentInstance.removeElement(_info.el);\n _info.el._jsPlumb = null;\n }\n };\n\n // remove all affected child elements\n for (var ae = 1; ae < affectedElements.length; ae++) {\n _one(affectedElements[ae]);\n }\n // and always remove the requested one from the dom.\n _one(info);\n };\n\n /**\n * Remove the given element, including cleaning up all endpoints registered for it.\n * This is exposed in the public API but also used internally by jsPlumb when removing the\n * element associated with a connection drag.\n */\n this.remove = function (el, doNotRepaint) {\n var info = _info(el), affectedElements = [];\n if (info.text) {\n info.el.parentNode.removeChild(info.el);\n }\n else if (info.id) {\n _currentInstance.batch(function () {\n _doRemove(info, affectedElements);\n }, doNotRepaint === true);\n }\n return _currentInstance;\n };\n\n this.empty = function (el, doNotRepaint) {\n var affectedElements = [];\n var _one = function(el, dontRemoveFocus) {\n var info = _info(el);\n if (info.text) {\n info.el.parentNode.removeChild(info.el);\n }\n else if (info.el) {\n while(info.el.childNodes.length > 0) {\n _one(info.el.childNodes[0]);\n }\n if (!dontRemoveFocus) {\n _doRemove(info, affectedElements);\n }\n }\n };\n\n _currentInstance.batch(function() {\n _one(el, true);\n }, doNotRepaint === false);\n\n return _currentInstance;\n };\n\n this.reset = function (doNotUnbindInstanceEventListeners) {\n _currentInstance.silently(function() {\n _hoverSuspended = false;\n _currentInstance.removeAllGroups();\n _currentInstance.removeGroupManager();\n _currentInstance.deleteEveryEndpoint();\n if (!doNotUnbindInstanceEventListeners) {\n _currentInstance.unbind();\n }\n this.targetEndpointDefinitions = {};\n this.sourceEndpointDefinitions = {};\n connections.length = 0;\n if (this.doReset) {\n this.doReset();\n }\n }.bind(this));\n };\n\n var _clearObject = function (obj) {\n if (obj.canvas && obj.canvas.parentNode) {\n obj.canvas.parentNode.removeChild(obj.canvas);\n }\n obj.cleanup();\n obj.destroy();\n };\n\n this.clear = function () {\n _currentInstance.select().each(_clearObject);\n _currentInstance.selectEndpoints().each(_clearObject);\n\n endpointsByElement = {};\n endpointsByUUID = {};\n };\n\n this.setDefaultScope = function (scope) {\n DEFAULT_SCOPE = scope;\n return _currentInstance;\n };\n\n this.deriveEndpointAndAnchorSpec = function(type, dontPrependDefault) {\n var bits = ((dontPrependDefault ? \"\" : \"default \") + type).split(/[\\s]/), eps = null, ep = null, a = null, as = null;\n for (var i = 0; i < bits.length; i++) {\n var _t = _currentInstance.getType(bits[i], \"connection\");\n if (_t) {\n if (_t.endpoints) {\n eps = _t.endpoints;\n }\n if (_t.endpoint) {\n ep = _t.endpoint;\n }\n if (_t.anchors) {\n as = _t.anchors;\n }\n if (_t.anchor) {\n a = _t.anchor;\n }\n }\n }\n return { endpoints: eps ? eps : [ ep, ep ], anchors: as ? as : [a, a ]};\n };\n\n // sets the id of some element, changing whatever we need to to keep track.\n this.setId = function (el, newId, doNotSetAttribute) {\n //\n var id;\n\n if (_ju.isString(el)) {\n id = el;\n }\n else {\n el = this.getElement(el);\n id = this.getId(el);\n }\n\n var sConns = this.getConnections({source: id, scope: '*'}, true),\n tConns = this.getConnections({target: id, scope: '*'}, true);\n\n newId = \"\" + newId;\n\n if (!doNotSetAttribute) {\n el = this.getElement(id);\n this.setAttribute(el, \"id\", newId);\n }\n else {\n el = this.getElement(newId);\n }\n\n endpointsByElement[newId] = endpointsByElement[id] || [];\n for (var i = 0, ii = endpointsByElement[newId].length; i < ii; i++) {\n endpointsByElement[newId][i].setElementId(newId);\n endpointsByElement[newId][i].setReferenceElement(el);\n }\n delete endpointsByElement[id];\n\n this.sourceEndpointDefinitions[newId] = this.sourceEndpointDefinitions[id];\n delete this.sourceEndpointDefinitions[id];\n this.targetEndpointDefinitions[newId] = this.targetEndpointDefinitions[id];\n delete this.targetEndpointDefinitions[id];\n\n this.anchorManager.changeId(id, newId);\n var dm = this.getDragManager();\n if (dm) {\n dm.changeId(id, newId);\n }\n managedElements[newId] = managedElements[id];\n delete managedElements[id];\n\n var _conns = function (list, epIdx, type) {\n for (var i = 0, ii = list.length; i < ii; i++) {\n list[i].endpoints[epIdx].setElementId(newId);\n list[i].endpoints[epIdx].setReferenceElement(el);\n list[i][type + \"Id\"] = newId;\n list[i][type] = el;\n }\n };\n _conns(sConns, 0, \"source\");\n _conns(tConns, 1, \"target\");\n\n this.repaint(newId);\n };\n\n this.setDebugLog = function (debugLog) {\n log = debugLog;\n };\n\n this.setSuspendDrawing = function (val, repaintAfterwards) {\n var curVal = _suspendDrawing;\n _suspendDrawing = val;\n if (val) {\n _suspendedAt = new Date().getTime();\n } else {\n _suspendedAt = null;\n }\n if (repaintAfterwards) {\n this.repaintEverything();\n }\n return curVal;\n };\n\n // returns whether or not drawing is currently suspended.\n this.isSuspendDrawing = function () {\n return _suspendDrawing;\n };\n\n // return timestamp for when drawing was suspended.\n this.getSuspendedAt = function () {\n return _suspendedAt;\n };\n\n this.batch = function (fn, doNotRepaintAfterwards) {\n var _wasSuspended = this.isSuspendDrawing();\n if (!_wasSuspended) {\n this.setSuspendDrawing(true);\n }\n try {\n fn();\n }\n catch (e) {\n _ju.log(\"Function run while suspended failed\", e);\n }\n if (!_wasSuspended) {\n this.setSuspendDrawing(false, !doNotRepaintAfterwards);\n }\n };\n\n this.doWhileSuspended = this.batch;\n\n this.getCachedData = _getCachedData;\n this.timestamp = _timestamp;\n this.show = function (el, changeEndpoints) {\n _setVisible(el, \"block\", changeEndpoints);\n return _currentInstance;\n };\n\n // TODO: update this method to return the current state.\n this.toggleVisible = _toggleVisible;\n this.addListener = this.bind;\n\n var floatingConnections = [];\n this.registerFloatingConnection = function(info, conn, ep) {\n floatingConnections[info.id] = conn;\n // only register for the target endpoint; we will not be dragging the source at any time\n // before this connection is either discarded or made into a permanent connection.\n _ju.addToList(endpointsByElement, info.id, ep);\n };\n this.getFloatingConnectionFor = function(id) {\n return floatingConnections[id];\n };\n };\n\n _ju.extend(root.jsPlumbInstance, _ju.EventGenerator, {\n setAttribute: function (el, a, v) {\n this.setAttribute(el, a, v);\n },\n getAttribute: function (el, a) {\n return this.getAttribute(root.jsPlumb.getElement(el), a);\n },\n convertToFullOverlaySpec: function(spec) {\n if (_ju.isString(spec)) {\n spec = [ spec, { } ];\n }\n spec[1].id = spec[1].id || _ju.uuid();\n return spec;\n },\n registerConnectionType: function (id, type) {\n this._connectionTypes[id] = root.jsPlumb.extend({}, type);\n if (type.overlays) {\n var to = {};\n for (var i = 0; i < type.overlays.length; i++) {\n // if a string, convert to object representation so that we can store the typeid on it.\n // also assign an id.\n var fo = this.convertToFullOverlaySpec(type.overlays[i]);\n to[fo[1].id] = fo;\n }\n this._connectionTypes[id].overlays = to;\n }\n },\n registerConnectionTypes: function (types) {\n for (var i in types) {\n this.registerConnectionType(i, types[i]);\n }\n },\n registerEndpointType: function (id, type) {\n this._endpointTypes[id] = root.jsPlumb.extend({}, type);\n if (type.overlays) {\n var to = {};\n for (var i = 0; i < type.overlays.length; i++) {\n // if a string, convert to object representation so that we can store the typeid on it.\n // also assign an id.\n var fo = this.convertToFullOverlaySpec(type.overlays[i]);\n to[fo[1].id] = fo;\n }\n this._endpointTypes[id].overlays = to;\n }\n },\n registerEndpointTypes: function (types) {\n for (var i in types) {\n this.registerEndpointType(i, types[i]);\n }\n },\n getType: function (id, typeDescriptor) {\n return typeDescriptor === \"connection\" ? this._connectionTypes[id] : this._endpointTypes[id];\n },\n setIdChanged: function (oldId, newId) {\n this.setId(oldId, newId, true);\n },\n // set parent: change the parent for some node and update all the registrations we need to.\n setParent: function (el, newParent) {\n var _dom = this.getElement(el),\n _id = this.getId(_dom),\n _pdom = this.getElement(newParent),\n _pid = this.getId(_pdom),\n dm = this.getDragManager();\n\n _dom.parentNode.removeChild(_dom);\n _pdom.appendChild(_dom);\n if (dm) {\n dm.setParent(_dom, _id, _pdom, _pid);\n }\n },\n extend: function (o1, o2, names) {\n var i;\n if (names) {\n for (i = 0; i < names.length; i++) {\n o1[names[i]] = o2[names[i]];\n }\n }\n else {\n for (i in o2) {\n o1[i] = o2[i];\n }\n }\n\n return o1;\n },\n floatingConnections: {},\n getFloatingAnchorIndex: function (jpc) {\n return jpc.endpoints[0].isFloating() ? 0 : jpc.endpoints[1].isFloating() ? 1 : -1;\n }\n });\n\n// --------------------- static instance + module registration -------------------------------------------\n\n// create static instance and assign to window if window exists.\n var jsPlumb = new jsPlumbInstance();\n // register on 'root' (lets us run on server or browser)\n root.jsPlumb = jsPlumb;\n // add 'getInstance' method to static instance\n jsPlumb.getInstance = function (_defaults, overrideFns) {\n var j = new jsPlumbInstance(_defaults);\n if (overrideFns) {\n for (var ovf in overrideFns) {\n j[ovf] = overrideFns[ovf];\n }\n }\n j.init();\n return j;\n };\n jsPlumb.each = function (spec, fn) {\n if (spec == null) {\n return;\n }\n if (typeof spec === \"string\") {\n fn(jsPlumb.getElement(spec));\n }\n else if (spec.length != null) {\n for (var i = 0; i < spec.length; i++) {\n fn(jsPlumb.getElement(spec[i]));\n }\n }\n else {\n fn(spec);\n } // assume it's an element.\n };\n\n // CommonJS\n if (typeof exports !== 'undefined') {\n exports.jsPlumb = jsPlumb;\n }\n\n// --------------------- end static instance + AMD registration -------------------------------------------\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;(function() {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n\n // ------------------------------ BEGIN OverlayCapablejsPlumbUIComponent --------------------------------------------\n\n var _internalLabelOverlayId = \"__label\",\n // this is a shortcut helper method to let people add a label as\n // overlay.\n _makeLabelOverlay = function (component, params) {\n\n var _params = {\n cssClass: params.cssClass,\n labelStyle: component.labelStyle,\n id: _internalLabelOverlayId,\n component: component,\n _jsPlumb: component._jsPlumb.instance // TODO not necessary, since the instance can be accessed through the component.\n },\n mergedParams = _jp.extend(_params, params);\n\n return new _jp.Overlays[component._jsPlumb.instance.getRenderMode()].Label(mergedParams);\n },\n _processOverlay = function (component, o) {\n var _newOverlay = null;\n if (_ju.isArray(o)) {\t// this is for the shorthand [\"Arrow\", { width:50 }] syntax\n // there's also a three arg version:\n // [\"Arrow\", { width:50 }, {location:0.7}]\n // which merges the 3rd arg into the 2nd.\n var type = o[0],\n // make a copy of the object so as not to mess up anyone else's reference...\n p = _jp.extend({component: component, _jsPlumb: component._jsPlumb.instance}, o[1]);\n if (o.length === 3) {\n _jp.extend(p, o[2]);\n }\n _newOverlay = new _jp.Overlays[component._jsPlumb.instance.getRenderMode()][type](p);\n } else if (o.constructor === String) {\n _newOverlay = new _jp.Overlays[component._jsPlumb.instance.getRenderMode()][o]({component: component, _jsPlumb: component._jsPlumb.instance});\n } else {\n _newOverlay = o;\n }\n\n _newOverlay.id = _newOverlay.id || _ju.uuid();\n component.cacheTypeItem(\"overlay\", _newOverlay, _newOverlay.id);\n component._jsPlumb.overlays[_newOverlay.id] = _newOverlay;\n\n return _newOverlay;\n };\n\n _jp.OverlayCapableJsPlumbUIComponent = function (params) {\n\n root.jsPlumbUIComponent.apply(this, arguments);\n this._jsPlumb.overlays = {};\n this._jsPlumb.overlayPositions = {};\n\n if (params.label) {\n this.getDefaultType().overlays[_internalLabelOverlayId] = [\"Label\", {\n label: params.label,\n location: params.labelLocation || this.defaultLabelLocation || 0.5,\n labelStyle: params.labelStyle || this._jsPlumb.instance.Defaults.LabelStyle,\n id:_internalLabelOverlayId\n }];\n }\n\n this.setListenerComponent = function (c) {\n if (this._jsPlumb) {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i].setListenerComponent(c);\n }\n }\n };\n };\n\n _jp.OverlayCapableJsPlumbUIComponent.applyType = function (component, t) {\n if (t.overlays) {\n // loop through the ones in the type. if already present on the component,\n // dont remove or re-add.\n var keep = {}, i;\n\n for (i in t.overlays) {\n\n var existing = component._jsPlumb.overlays[t.overlays[i][1].id];\n if (existing) {\n // maybe update from data, if there were parameterised values for instance.\n existing.updateFrom(t.overlays[i][1]);\n keep[t.overlays[i][1].id] = true;\n }\n else {\n var c = component.getCachedTypeItem(\"overlay\", t.overlays[i][1].id);\n if (c != null) {\n c.reattach(component._jsPlumb.instance, component);\n c.setVisible(true);\n // maybe update from data, if there were parameterised values for instance.\n c.updateFrom(t.overlays[i][1]);\n component._jsPlumb.overlays[c.id] = c;\n }\n else {\n c = component.addOverlay(t.overlays[i], true);\n }\n keep[c.id] = true;\n }\n }\n\n // now loop through the full overlays and remove those that we dont want to keep\n for (i in component._jsPlumb.overlays) {\n if (keep[component._jsPlumb.overlays[i].id] == null) {\n component.removeOverlay(component._jsPlumb.overlays[i].id, true); // remove overlay but dont clean it up.\n // that would remove event listeners etc; overlays are never discarded by the types stuff, they are\n // just detached/reattached.\n }\n }\n }\n };\n\n _ju.extend(_jp.OverlayCapableJsPlumbUIComponent, root.jsPlumbUIComponent, {\n\n setHover: function (hover, ignoreAttachedElements) {\n if (this._jsPlumb && !this._jsPlumb.instance.isConnectionBeingDragged()) {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i][hover ? \"addClass\" : \"removeClass\"](this._jsPlumb.instance.hoverClass);\n }\n }\n },\n addOverlay: function (overlay, doNotRepaint) {\n var o = _processOverlay(this, overlay);\n if (!doNotRepaint) {\n this.repaint();\n }\n return o;\n },\n getOverlay: function (id) {\n return this._jsPlumb.overlays[id];\n },\n getOverlays: function () {\n return this._jsPlumb.overlays;\n },\n hideOverlay: function (id) {\n var o = this.getOverlay(id);\n if (o) {\n o.hide();\n }\n },\n hideOverlays: function () {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i].hide();\n }\n },\n showOverlay: function (id) {\n var o = this.getOverlay(id);\n if (o) {\n o.show();\n }\n },\n showOverlays: function () {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i].show();\n }\n },\n removeAllOverlays: function (doNotRepaint) {\n for (var i in this._jsPlumb.overlays) {\n if (this._jsPlumb.overlays[i].cleanup) {\n this._jsPlumb.overlays[i].cleanup();\n }\n }\n\n this._jsPlumb.overlays = {};\n this._jsPlumb.overlayPositions = null;\n this._jsPlumb.overlayPlacements= {};\n if (!doNotRepaint) {\n this.repaint();\n }\n },\n removeOverlay: function (overlayId, dontCleanup) {\n var o = this._jsPlumb.overlays[overlayId];\n if (o) {\n o.setVisible(false);\n if (!dontCleanup && o.cleanup) {\n o.cleanup();\n }\n delete this._jsPlumb.overlays[overlayId];\n if (this._jsPlumb.overlayPositions) {\n delete this._jsPlumb.overlayPositions[overlayId];\n }\n\n if (this._jsPlumb.overlayPlacements) {\n delete this._jsPlumb.overlayPlacements[overlayId];\n }\n }\n },\n removeOverlays: function () {\n for (var i = 0, j = arguments.length; i < j; i++) {\n this.removeOverlay(arguments[i]);\n }\n },\n moveParent: function (newParent) {\n if (this.bgCanvas) {\n this.bgCanvas.parentNode.removeChild(this.bgCanvas);\n newParent.appendChild(this.bgCanvas);\n }\n\n if (this.canvas && this.canvas.parentNode) {\n this.canvas.parentNode.removeChild(this.canvas);\n newParent.appendChild(this.canvas);\n\n for (var i in this._jsPlumb.overlays) {\n if (this._jsPlumb.overlays[i].isAppendedAtTopLevel) {\n var el = this._jsPlumb.overlays[i].getElement();\n el.parentNode.removeChild(el);\n newParent.appendChild(el);\n }\n }\n }\n },\n getLabel: function () {\n var lo = this.getOverlay(_internalLabelOverlayId);\n return lo != null ? lo.getLabel() : null;\n },\n getLabelOverlay: function () {\n return this.getOverlay(_internalLabelOverlayId);\n },\n setLabel: function (l) {\n var lo = this.getOverlay(_internalLabelOverlayId);\n if (!lo) {\n var params = l.constructor === String || l.constructor === Function ? { label: l } : l;\n lo = _makeLabelOverlay(this, params);\n this._jsPlumb.overlays[_internalLabelOverlayId] = lo;\n }\n else {\n if (l.constructor === String || l.constructor === Function) {\n lo.setLabel(l);\n }\n else {\n if (l.label) {\n lo.setLabel(l.label);\n }\n if (l.location) {\n lo.setLocation(l.location);\n }\n }\n }\n\n if (!this._jsPlumb.instance.isSuspendDrawing()) {\n this.repaint();\n }\n },\n cleanup: function (force) {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i].cleanup(force);\n this._jsPlumb.overlays[i].destroy(force);\n }\n if (force) {\n this._jsPlumb.overlays = {};\n this._jsPlumb.overlayPositions = null;\n }\n },\n setVisible: function (v) {\n this[v ? \"showOverlays\" : \"hideOverlays\"]();\n },\n setAbsoluteOverlayPosition: function (overlay, xy) {\n this._jsPlumb.overlayPositions[overlay.id] = xy;\n },\n getAbsoluteOverlayPosition: function (overlay) {\n return this._jsPlumb.overlayPositions ? this._jsPlumb.overlayPositions[overlay.id] : null;\n },\n _clazzManip:function(action, clazz, dontUpdateOverlays) {\n if (!dontUpdateOverlays) {\n for (var i in this._jsPlumb.overlays) {\n this._jsPlumb.overlays[i][action + \"Class\"](clazz);\n }\n }\n },\n addClass:function(clazz, dontUpdateOverlays) {\n this._clazzManip(\"add\", clazz, dontUpdateOverlays);\n },\n removeClass:function(clazz, dontUpdateOverlays) {\n this._clazzManip(\"remove\", clazz, dontUpdateOverlays);\n }\n });\n\n// ------------------------------ END OverlayCapablejsPlumbUIComponent --------------------------------------------\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * This file contains the code for Endpoints.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n * \n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n * \n * Dual licensed under the MIT and GPL2 licenses.\n */\n;(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n\n // create the drag handler for a connection\n var _makeConnectionDragHandler = function (endpoint, placeholder, _jsPlumb) {\n var stopped = false;\n return {\n drag: function () {\n if (stopped) {\n stopped = false;\n return true;\n }\n\n if (placeholder.element) {\n var _ui = _jsPlumb.getUIPosition(arguments, _jsPlumb.getZoom());\n if (_ui != null) {\n _jsPlumb.setPosition(placeholder.element, _ui);\n }\n _jsPlumb.repaint(placeholder.element, _ui);\n // always repaint the source endpoint, because only continuous/dynamic anchors cause the endpoint\n // to be repainted, so static anchors need to be told (or the endpoint gets dragged around)\n endpoint.paint({anchorPoint:endpoint.anchor.getCurrentLocation({element:endpoint})});\n }\n },\n stopDrag: function () {\n stopped = true;\n }\n };\n };\n\n // creates a placeholder div for dragging purposes, adds it, and pre-computes its offset.\n var _makeDraggablePlaceholder = function (placeholder, _jsPlumb, ipco, ips) {\n var n = _jsPlumb.createElement(\"div\", { position : \"absolute\" });\n _jsPlumb.appendElement(n);\n var id = _jsPlumb.getId(n);\n _jsPlumb.setPosition(n, ipco);\n n.style.width = ips[0] + \"px\";\n n.style.height = ips[1] + \"px\";\n _jsPlumb.manage(id, n, true); // TRANSIENT MANAGE\n // create and assign an id, and initialize the offset.\n placeholder.id = id;\n placeholder.element = n;\n };\n\n // create a floating endpoint (for drag connections)\n var _makeFloatingEndpoint = function (paintStyle, referenceAnchor, endpoint, referenceCanvas, sourceElement, _jsPlumb, _newEndpoint, scope) {\n var floatingAnchor = new _jp.FloatingAnchor({ reference: referenceAnchor, referenceCanvas: referenceCanvas, jsPlumbInstance: _jsPlumb });\n //setting the scope here should not be the way to fix that mootools issue. it should be fixed by not\n // adding the floating endpoint as a droppable. that makes more sense anyway!\n // TRANSIENT MANAGE\n return _newEndpoint({\n paintStyle: paintStyle,\n endpoint: endpoint,\n anchor: floatingAnchor,\n source: sourceElement,\n scope: scope\n });\n };\n\n var typeParameters = [ \"connectorStyle\", \"connectorHoverStyle\", \"connectorOverlays\",\n \"connector\", \"connectionType\", \"connectorClass\", \"connectorHoverClass\" ];\n\n // a helper function that tries to find a connection to the given element, and returns it if so. if elementWithPrecedence is null,\n // or no connection to it is found, we return the first connection in our list.\n var findConnectionToUseForDynamicAnchor = function (ep, elementWithPrecedence) {\n var idx = 0;\n if (elementWithPrecedence != null) {\n for (var i = 0; i < ep.connections.length; i++) {\n if (ep.connections[i].sourceId === elementWithPrecedence || ep.connections[i].targetId === elementWithPrecedence) {\n idx = i;\n break;\n }\n }\n }\n\n return ep.connections[idx];\n };\n\n _jp.Endpoint = function (params) {\n var _jsPlumb = params._jsPlumb,\n _newConnection = params.newConnection,\n _newEndpoint = params.newEndpoint;\n\n this.idPrefix = \"_jsplumb_e_\";\n this.defaultLabelLocation = [ 0.5, 0.5 ];\n this.defaultOverlayKeys = [\"Overlays\", \"EndpointOverlays\"];\n _jp.OverlayCapableJsPlumbUIComponent.apply(this, arguments);\n\n// TYPE\n\n this.appendToDefaultType({\n connectionType:params.connectionType,\n maxConnections: params.maxConnections == null ? this._jsPlumb.instance.Defaults.MaxConnections : params.maxConnections, // maximum number of connections this endpoint can be the source of.,\n paintStyle: params.endpointStyle || params.paintStyle || params.style || this._jsPlumb.instance.Defaults.EndpointStyle || _jp.Defaults.EndpointStyle,\n hoverPaintStyle: params.endpointHoverStyle || params.hoverPaintStyle || this._jsPlumb.instance.Defaults.EndpointHoverStyle || _jp.Defaults.EndpointHoverStyle,\n connectorStyle: params.connectorStyle,\n connectorHoverStyle: params.connectorHoverStyle,\n connectorClass: params.connectorClass,\n connectorHoverClass: params.connectorHoverClass,\n connectorOverlays: params.connectorOverlays,\n connector: params.connector,\n connectorTooltip: params.connectorTooltip\n });\n\n// END TYPE\n\n this._jsPlumb.enabled = !(params.enabled === false);\n this._jsPlumb.visible = true;\n this.element = _jp.getElement(params.source);\n this._jsPlumb.uuid = params.uuid;\n this._jsPlumb.floatingEndpoint = null;\n var inPlaceCopy = null;\n if (this._jsPlumb.uuid) {\n params.endpointsByUUID[this._jsPlumb.uuid] = this;\n }\n this.elementId = params.elementId;\n this.dragProxy = params.dragProxy;\n\n this._jsPlumb.connectionCost = params.connectionCost;\n this._jsPlumb.connectionsDirected = params.connectionsDirected;\n this._jsPlumb.currentAnchorClass = \"\";\n this._jsPlumb.events = {};\n\n var deleteOnEmpty = params.deleteOnEmpty === true;\n this.setDeleteOnEmpty = function(d) {\n deleteOnEmpty = d;\n };\n\n var _updateAnchorClass = function () {\n // stash old, get new\n var oldAnchorClass = _jsPlumb.endpointAnchorClassPrefix + \"-\" + this._jsPlumb.currentAnchorClass;\n this._jsPlumb.currentAnchorClass = this.anchor.getCssClass();\n var anchorClass = _jsPlumb.endpointAnchorClassPrefix + (this._jsPlumb.currentAnchorClass ? \"-\" + this._jsPlumb.currentAnchorClass : \"\");\n\n this.removeClass(oldAnchorClass);\n this.addClass(anchorClass);\n // add and remove at the same time to reduce the number of reflows.\n _jp.updateClasses(this.element, anchorClass, oldAnchorClass);\n }.bind(this);\n\n this.prepareAnchor = function(anchorParams) {\n var a = this._jsPlumb.instance.makeAnchor(anchorParams, this.elementId, _jsPlumb);\n a.bind(\"anchorChanged\", function (currentAnchor) {\n this.fire(\"anchorChanged\", {endpoint: this, anchor: currentAnchor});\n _updateAnchorClass();\n }.bind(this));\n return a;\n };\n\n this.setPreparedAnchor = function(anchor, doNotRepaint) {\n this._jsPlumb.instance.continuousAnchorFactory.clear(this.elementId);\n this.anchor = anchor;\n _updateAnchorClass();\n\n if (!doNotRepaint) {\n this._jsPlumb.instance.repaint(this.elementId);\n }\n\n return this;\n };\n\n this.setAnchor = function (anchorParams, doNotRepaint) {\n var a = this.prepareAnchor(anchorParams);\n this.setPreparedAnchor(a, doNotRepaint);\n return this;\n };\n\n var internalHover = function (state) {\n if (this.connections.length > 0) {\n for (var i = 0; i < this.connections.length; i++) {\n this.connections[i].setHover(state, false);\n }\n }\n else {\n this.setHover(state);\n }\n }.bind(this);\n\n this.bind(\"mouseover\", function () {\n internalHover(true);\n });\n this.bind(\"mouseout\", function () {\n internalHover(false);\n });\n\n // ANCHOR MANAGER\n if (!params._transient) { // in place copies, for example, are transient. they will never need to be retrieved during a paint cycle, because they dont move, and then they are deleted.\n this._jsPlumb.instance.anchorManager.add(this, this.elementId);\n }\n\n this.prepareEndpoint = function(ep, typeId) {\n var _e = function (t, p) {\n var rm = _jsPlumb.getRenderMode();\n if (_jp.Endpoints[rm][t]) {\n return new _jp.Endpoints[rm][t](p);\n }\n if (!_jsPlumb.Defaults.DoNotThrowErrors) {\n throw { msg: \"jsPlumb: unknown endpoint type '\" + t + \"'\" };\n }\n };\n\n var endpointArgs = {\n _jsPlumb: this._jsPlumb.instance,\n cssClass: params.cssClass,\n container: params.container,\n tooltip: params.tooltip,\n connectorTooltip: params.connectorTooltip,\n endpoint: this\n };\n\n var endpoint;\n\n if (_ju.isString(ep)) {\n endpoint = _e(ep, endpointArgs);\n }\n else if (_ju.isArray(ep)) {\n endpointArgs = _ju.merge(ep[1], endpointArgs);\n endpoint = _e(ep[0], endpointArgs);\n }\n else {\n endpoint = ep.clone();\n }\n\n // assign a clone function using a copy of endpointArgs. this is used when a drag starts: the endpoint that was dragged is cloned,\n // and the clone is left in its place while the original one goes off on a magical journey.\n // the copy is to get around a closure problem, in which endpointArgs ends up getting shared by\n // the whole world.\n //var argsForClone = jsPlumb.extend({}, endpointArgs);\n endpoint.clone = function () {\n // TODO this, and the code above, can be refactored to be more dry.\n if (_ju.isString(ep)) {\n return _e(ep, endpointArgs);\n }\n else if (_ju.isArray(ep)) {\n endpointArgs = _ju.merge(ep[1], endpointArgs);\n return _e(ep[0], endpointArgs);\n }\n }.bind(this);\n\n endpoint.typeId = typeId;\n return endpoint;\n };\n\n this.setEndpoint = function(ep, doNotRepaint) {\n var _ep = this.prepareEndpoint(ep);\n this.setPreparedEndpoint(_ep, true);\n };\n\n this.setPreparedEndpoint = function (ep, doNotRepaint) {\n if (this.endpoint != null) {\n this.endpoint.cleanup();\n this.endpoint.destroy();\n }\n this.endpoint = ep;\n this.type = this.endpoint.type;\n this.canvas = this.endpoint.canvas;\n };\n\n _jp.extend(this, params, typeParameters);\n\n this.isSource = params.isSource || false;\n this.isTemporarySource = params.isTemporarySource || false;\n this.isTarget = params.isTarget || false;\n\n this.connections = params.connections || [];\n this.connectorPointerEvents = params[\"connector-pointer-events\"];\n\n this.scope = params.scope || _jsPlumb.getDefaultScope();\n this.timestamp = null;\n this.reattachConnections = params.reattach || _jsPlumb.Defaults.ReattachConnections;\n this.connectionsDetachable = _jsPlumb.Defaults.ConnectionsDetachable;\n if (params.connectionsDetachable === false || params.detachable === false) {\n this.connectionsDetachable = false;\n }\n this.dragAllowedWhenFull = params.dragAllowedWhenFull !== false;\n\n if (params.onMaxConnections) {\n this.bind(\"maxConnections\", params.onMaxConnections);\n }\n\n //\n // add a connection. not part of public API.\n //\n this.addConnection = function (connection) {\n this.connections.push(connection);\n this[(this.connections.length > 0 ? \"add\" : \"remove\") + \"Class\"](_jsPlumb.endpointConnectedClass);\n this[(this.isFull() ? \"add\" : \"remove\") + \"Class\"](_jsPlumb.endpointFullClass);\n };\n\n this.detachFromConnection = function (connection, idx, doNotCleanup) {\n idx = idx == null ? this.connections.indexOf(connection) : idx;\n if (idx >= 0) {\n this.connections.splice(idx, 1);\n this[(this.connections.length > 0 ? \"add\" : \"remove\") + \"Class\"](_jsPlumb.endpointConnectedClass);\n this[(this.isFull() ? \"add\" : \"remove\") + \"Class\"](_jsPlumb.endpointFullClass);\n }\n\n if (!doNotCleanup && deleteOnEmpty && this.connections.length === 0) {\n _jsPlumb.deleteObject({\n endpoint: this,\n fireEvent: false,\n deleteAttachedObjects: doNotCleanup !== true\n });\n }\n };\n\n this.deleteEveryConnection = function(params) {\n var c = this.connections.length;\n for (var i = 0; i < c; i++) {\n _jsPlumb.deleteConnection(this.connections[0], params);\n }\n };\n\n this.detachFrom = function (targetEndpoint, fireEvent, originalEvent) {\n var c = [];\n for (var i = 0; i < this.connections.length; i++) {\n if (this.connections[i].endpoints[1] === targetEndpoint || this.connections[i].endpoints[0] === targetEndpoint) {\n c.push(this.connections[i]);\n }\n }\n for (var j = 0, count = c.length; j < count; j++) {\n _jsPlumb.deleteConnection(c[0]);\n }\n return this;\n };\n\n this.getElement = function () {\n return this.element;\n };\n\n this.setElement = function (el) {\n var parentId = this._jsPlumb.instance.getId(el),\n curId = this.elementId;\n // remove the endpoint from the list for the current endpoint's element\n _ju.removeWithFunction(params.endpointsByElement[this.elementId], function (e) {\n return e.id === this.id;\n }.bind(this));\n this.element = _jp.getElement(el);\n this.elementId = _jsPlumb.getId(this.element);\n _jsPlumb.anchorManager.rehomeEndpoint(this, curId, this.element);\n _jsPlumb.dragManager.endpointAdded(this.element);\n _ju.addToList(params.endpointsByElement, parentId, this);\n return this;\n };\n\n /**\n * private but must be exposed.\n */\n this.makeInPlaceCopy = function () {\n var loc = this.anchor.getCurrentLocation({element: this}),\n o = this.anchor.getOrientation(this),\n acc = this.anchor.getCssClass(),\n inPlaceAnchor = {\n bind: function () {\n },\n compute: function () {\n return [ loc[0], loc[1] ];\n },\n getCurrentLocation: function () {\n return [ loc[0], loc[1] ];\n },\n getOrientation: function () {\n return o;\n },\n getCssClass: function () {\n return acc;\n }\n };\n\n return _newEndpoint({\n dropOptions: params.dropOptions,\n anchor: inPlaceAnchor,\n source: this.element,\n paintStyle: this.getPaintStyle(),\n endpoint: params.hideOnDrag ? \"Blank\" : this.endpoint,\n _transient: true,\n scope: this.scope,\n reference:this\n });\n };\n\n /**\n * returns a connection from the pool; used when dragging starts. just gets the head of the array if it can.\n */\n this.connectorSelector = function () {\n return this.connections[0];\n };\n\n this.setStyle = this.setPaintStyle;\n\n this.paint = function (params) {\n params = params || {};\n var timestamp = params.timestamp, recalc = !(params.recalc === false);\n if (!timestamp || this.timestamp !== timestamp) {\n\n var info = _jsPlumb.updateOffset({ elId: this.elementId, timestamp: timestamp });\n\n var xy = params.offset ? params.offset.o : info.o;\n if (xy != null) {\n var ap = params.anchorPoint, connectorPaintStyle = params.connectorPaintStyle;\n if (ap == null) {\n var wh = params.dimensions || info.s,\n anchorParams = { xy: [ xy.left, xy.top ], wh: wh, element: this, timestamp: timestamp };\n if (recalc && this.anchor.isDynamic && this.connections.length > 0) {\n var c = findConnectionToUseForDynamicAnchor(this, params.elementWithPrecedence),\n oIdx = c.endpoints[0] === this ? 1 : 0,\n oId = oIdx === 0 ? c.sourceId : c.targetId,\n oInfo = _jsPlumb.getCachedData(oId),\n oOffset = oInfo.o, oWH = oInfo.s;\n\n anchorParams.index = oIdx === 0 ? 1 : 0;\n anchorParams.connection = c;\n anchorParams.txy = [ oOffset.left, oOffset.top ];\n anchorParams.twh = oWH;\n anchorParams.tElement = c.endpoints[oIdx];\n } else if (this.connections.length > 0) {\n anchorParams.connection = this.connections[0];\n }\n ap = this.anchor.compute(anchorParams);\n }\n\n this.endpoint.compute(ap, this.anchor.getOrientation(this), this._jsPlumb.paintStyleInUse, connectorPaintStyle || this.paintStyleInUse);\n this.endpoint.paint(this._jsPlumb.paintStyleInUse, this.anchor);\n this.timestamp = timestamp;\n\n // paint overlays\n for (var i in this._jsPlumb.overlays) {\n if (this._jsPlumb.overlays.hasOwnProperty(i)) {\n var o = this._jsPlumb.overlays[i];\n if (o.isVisible()) {\n this._jsPlumb.overlayPlacements[i] = o.draw(this.endpoint, this._jsPlumb.paintStyleInUse);\n o.paint(this._jsPlumb.overlayPlacements[i]);\n }\n }\n }\n }\n }\n };\n\n this.getTypeDescriptor = function () {\n return \"endpoint\";\n };\n this.isVisible = function () {\n return this._jsPlumb.visible;\n };\n\n this.repaint = this.paint;\n\n var draggingInitialised = false;\n this.initDraggable = function () {\n\n // is this a connection source? we make it draggable and have the\n // drag listener maintain a connection with a floating endpoint.\n if (!draggingInitialised && _jp.isDragSupported(this.element)) {\n var placeholderInfo = { id: null, element: null },\n jpc = null,\n existingJpc = false,\n existingJpcParams = null,\n _dragHandler = _makeConnectionDragHandler(this, placeholderInfo, _jsPlumb),\n dragOptions = params.dragOptions || {},\n defaultOpts = {},\n startEvent = _jp.dragEvents.start,\n stopEvent = _jp.dragEvents.stop,\n dragEvent = _jp.dragEvents.drag,\n beforeStartEvent = _jp.dragEvents.beforeStart,\n payload;\n\n // respond to beforeStart from katavorio; this will have, optionally, a payload of attribute values\n // that were placed there by the makeSource mousedown listener.\n var beforeStart = function(beforeStartParams) {\n payload = beforeStartParams.e.payload || {};\n };\n\n var start = function (startParams) {\n\n// ------------- first, get a connection to drag. this may be null, in which case we are dragging a new one.\n\n jpc = this.connectorSelector();\n\n// -------------------------------- now a bunch of tests about whether or not to proceed -------------------------\n\n var _continue = true;\n // if not enabled, return\n if (!this.isEnabled()) {\n _continue = false;\n }\n // if no connection and we're not a source - or temporarily a source, as is the case with makeSource - return.\n if (jpc == null && !this.isSource && !this.isTemporarySource) {\n _continue = false;\n }\n // otherwise if we're full and not allowed to drag, also return false.\n if (this.isSource && this.isFull() && !(jpc != null && this.dragAllowedWhenFull)) {\n _continue = false;\n }\n // if the connection was setup as not detachable or one of its endpoints\n // was setup as connectionsDetachable = false, or Defaults.ConnectionsDetachable\n // is set to false...\n if (jpc != null && !jpc.isDetachable(this)) {\n // .. and the endpoint is full\n if (this.isFull()) {\n _continue = false;\n } else {\n // otherwise, if not full, set the connection to null, and we will now proceed\n // to drag a new connection.\n jpc = null;\n }\n }\n\n var beforeDrag = _jsPlumb.checkCondition(jpc == null ? \"beforeDrag\" : \"beforeStartDetach\", {\n endpoint:this,\n source:this.element,\n sourceId:this.elementId,\n connection:jpc\n });\n if (beforeDrag === false) {\n _continue = false;\n }\n // else we might have been given some data. we'll pass it in to a new connection as 'data'.\n // here we also merge in the optional payload we were given on mousedown.\n else if (typeof beforeDrag === \"object\") {\n _jp.extend(beforeDrag, payload || {});\n }\n else {\n // or if no beforeDrag data, maybe use the payload on its own.\n beforeDrag = payload || {};\n }\n\n if (_continue === false) {\n // this is for mootools and yui. returning false from this causes jquery to stop drag.\n // the events are wrapped in both mootools and yui anyway, but i don't think returning\n // false from the start callback would stop a drag.\n if (_jsPlumb.stopDrag) {\n _jsPlumb.stopDrag(this.canvas);\n }\n _dragHandler.stopDrag();\n return false;\n }\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n // ok to proceed.\n\n // clear hover for all connections for this endpoint before continuing.\n for (var i = 0; i < this.connections.length; i++) {\n this.connections[i].setHover(false);\n }\n\n this.addClass(\"endpointDrag\");\n _jsPlumb.setConnectionBeingDragged(true);\n\n // if we're not full but there was a connection, make it null. we'll create a new one.\n if (jpc && !this.isFull() && this.isSource) {\n jpc = null;\n }\n\n _jsPlumb.updateOffset({ elId: this.elementId });\n\n// ---------------- make the element we will drag around, and position it -----------------------------\n\n var ipco = this._jsPlumb.instance.getOffset(this.canvas),\n canvasElement = this.canvas,\n ips = this._jsPlumb.instance.getSize(this.canvas);\n\n _makeDraggablePlaceholder(placeholderInfo, _jsPlumb, ipco, ips);\n\n // store the id of the dragging div and the source element. the drop function will pick these up. \n _jsPlumb.setAttributes(this.canvas, {\n \"dragId\": placeholderInfo.id,\n \"elId\": this.elementId\n });\n\n// ------------------- create an endpoint that will be our floating endpoint ------------------------------------\n\n var endpointToFloat = this.dragProxy || this.endpoint;\n if (this.dragProxy == null && this.connectionType != null) {\n var aae = this._jsPlumb.instance.deriveEndpointAndAnchorSpec(this.connectionType);\n if (aae.endpoints[1]) {\n endpointToFloat = aae.endpoints[1];\n }\n }\n var centerAnchor = this._jsPlumb.instance.makeAnchor(\"Center\");\n centerAnchor.isFloating = true;\n this._jsPlumb.floatingEndpoint = _makeFloatingEndpoint(this.getPaintStyle(), centerAnchor, endpointToFloat, this.canvas, placeholderInfo.element, _jsPlumb, _newEndpoint, this.scope);\n var _savedAnchor = this._jsPlumb.floatingEndpoint.anchor;\n\n\n if (jpc == null) {\n\n this.setHover(false, false);\n // create a connection. one end is this endpoint, the other is a floating endpoint. \n jpc = _newConnection({\n sourceEndpoint: this,\n targetEndpoint: this._jsPlumb.floatingEndpoint,\n source: this.element, // for makeSource with parent option. ensure source element is represented correctly.\n target: placeholderInfo.element,\n anchors: [ this.anchor, this._jsPlumb.floatingEndpoint.anchor ],\n paintStyle: params.connectorStyle, // this can be null. Connection will use the default.\n hoverPaintStyle: params.connectorHoverStyle,\n connector: params.connector, // this can also be null. Connection will use the default.\n overlays: params.connectorOverlays,\n type: this.connectionType,\n cssClass: this.connectorClass,\n hoverClass: this.connectorHoverClass,\n scope:params.scope,\n data:beforeDrag\n });\n jpc.pending = true;\n jpc.addClass(_jsPlumb.draggingClass);\n this._jsPlumb.floatingEndpoint.addClass(_jsPlumb.draggingClass);\n this._jsPlumb.floatingEndpoint.anchor = _savedAnchor;\n // fire an event that informs that a connection is being dragged\n _jsPlumb.fire(\"connectionDrag\", jpc);\n\n // register the new connection on the drag manager. This connection, at this point, is 'pending',\n // and has as its target a temporary element (the 'placeholder'). If the connection subsequently\n // becomes established, the anchor manager is informed that the target of the connection has\n // changed.\n\n _jsPlumb.anchorManager.newConnection(jpc);\n\n } else {\n existingJpc = true;\n jpc.setHover(false);\n // new anchor idx\n var anchorIdx = jpc.endpoints[0].id === this.id ? 0 : 1;\n this.detachFromConnection(jpc, null, true); // detach from the connection while dragging is occurring. but dont cleanup automatically.\n\n // store the original scope (issue 57)\n var dragScope = _jsPlumb.getDragScope(canvasElement);\n _jsPlumb.setAttribute(this.canvas, \"originalScope\", dragScope);\n\n // fire an event that informs that a connection is being dragged. we do this before\n // replacing the original target with the floating element info.\n _jsPlumb.fire(\"connectionDrag\", jpc);\n\n // now we replace ourselves with the temporary div we created above:\n if (anchorIdx === 0) {\n existingJpcParams = [ jpc.source, jpc.sourceId, canvasElement, dragScope ];\n _jsPlumb.anchorManager.sourceChanged(jpc.endpoints[anchorIdx].elementId, placeholderInfo.id, jpc, placeholderInfo.element);\n\n } else {\n existingJpcParams = [ jpc.target, jpc.targetId, canvasElement, dragScope ];\n jpc.target = placeholderInfo.element;\n jpc.targetId = placeholderInfo.id;\n\n _jsPlumb.anchorManager.updateOtherEndpoint(jpc.sourceId, jpc.endpoints[anchorIdx].elementId, jpc.targetId, jpc);\n }\n\n // store the original endpoint and assign the new floating endpoint for the drag.\n jpc.suspendedEndpoint = jpc.endpoints[anchorIdx];\n\n // PROVIDE THE SUSPENDED ELEMENT, BE IT A SOURCE OR TARGET (ISSUE 39)\n jpc.suspendedElement = jpc.endpoints[anchorIdx].getElement();\n jpc.suspendedElementId = jpc.endpoints[anchorIdx].elementId;\n jpc.suspendedElementType = anchorIdx === 0 ? \"source\" : \"target\";\n\n jpc.suspendedEndpoint.setHover(false);\n this._jsPlumb.floatingEndpoint.referenceEndpoint = jpc.suspendedEndpoint;\n jpc.endpoints[anchorIdx] = this._jsPlumb.floatingEndpoint;\n\n jpc.addClass(_jsPlumb.draggingClass);\n this._jsPlumb.floatingEndpoint.addClass(_jsPlumb.draggingClass);\n }\n\n _jsPlumb.registerFloatingConnection(placeholderInfo, jpc, this._jsPlumb.floatingEndpoint);\n\n // // register it and register connection on it.\n // _jsPlumb.floatingConnections[placeholderInfo.id] = jpc;\n //\n // // only register for the target endpoint; we will not be dragging the source at any time\n // // before this connection is either discarded or made into a permanent connection.\n // _ju.addToList(params.endpointsByElement, placeholderInfo.id, this._jsPlumb.floatingEndpoint);\n\n\n // tell jsplumb about it\n _jsPlumb.currentlyDragging = true;\n }.bind(this);\n\n var stop = function () {\n _jsPlumb.setConnectionBeingDragged(false);\n\n if (jpc && jpc.endpoints != null) {\n // get the actual drop event (decode from library args to stop function)\n var originalEvent = _jsPlumb.getDropEvent(arguments);\n // unlock the other endpoint (if it is dynamic, it would have been locked at drag start)\n var idx = _jsPlumb.getFloatingAnchorIndex(jpc);\n jpc.endpoints[idx === 0 ? 1 : 0].anchor.unlock();\n // TODO: Dont want to know about css classes inside jsplumb, ideally.\n jpc.removeClass(_jsPlumb.draggingClass);\n\n // if we have the floating endpoint then the connection has not been dropped\n // on another endpoint. If it is a new connection we throw it away. If it is an\n // existing connection we check to see if we should reattach it, throwing it away\n // if not.\n if (this._jsPlumb && (jpc.deleteConnectionNow || jpc.endpoints[idx] === this._jsPlumb.floatingEndpoint)) {\n // 6a. if the connection was an existing one...\n if (existingJpc && jpc.suspendedEndpoint) {\n // fix for issue35, thanks Sylvain Gizard: when firing the detach event make sure the\n // floating endpoint has been replaced.\n if (idx === 0) {\n jpc.floatingElement = jpc.source;\n jpc.floatingId = jpc.sourceId;\n jpc.floatingEndpoint = jpc.endpoints[0];\n jpc.floatingIndex = 0;\n jpc.source = existingJpcParams[0];\n jpc.sourceId = existingJpcParams[1];\n } else {\n // keep a copy of the floating element; the anchor manager will want to clean up.\n jpc.floatingElement = jpc.target;\n jpc.floatingId = jpc.targetId;\n jpc.floatingEndpoint = jpc.endpoints[1];\n jpc.floatingIndex = 1;\n jpc.target = existingJpcParams[0];\n jpc.targetId = existingJpcParams[1];\n }\n\n var fe = this._jsPlumb.floatingEndpoint; // store for later removal.\n // restore the original scope (issue 57)\n _jsPlumb.setDragScope(existingJpcParams[2], existingJpcParams[3]);\n jpc.endpoints[idx] = jpc.suspendedEndpoint;\n // if the connection should be reattached, or the other endpoint refuses detach, then\n // reset the connection to its original state\n if (jpc.isReattach() || jpc._forceReattach || jpc._forceDetach || !_jsPlumb.deleteConnection(jpc, {originalEvent: originalEvent})) {\n\n jpc.setHover(false);\n jpc._forceDetach = null;\n jpc._forceReattach = null;\n this._jsPlumb.floatingEndpoint.detachFromConnection(jpc);\n jpc.suspendedEndpoint.addConnection(jpc);\n\n // TODO this code is duplicated in lots of places...and there is nothing external\n // in the code; it all refers to the connection itself. we could add a\n // `checkSanity(connection)` method to anchorManager that did this.\n if (idx === 1) {\n _jsPlumb.anchorManager.updateOtherEndpoint(jpc.sourceId, jpc.floatingId, jpc.targetId, jpc);\n }\n else {\n _jsPlumb.anchorManager.sourceChanged(jpc.floatingId, jpc.sourceId, jpc, jpc.source);\n }\n\n _jsPlumb.repaint(existingJpcParams[1]);\n }\n else {\n _jsPlumb.deleteObject({endpoint: fe});\n }\n }\n }\n\n // makeTargets sets this flag, to tell us we have been replaced and should delete this object.\n if (this.deleteAfterDragStop) {\n _jsPlumb.deleteObject({endpoint: this});\n }\n else {\n if (this._jsPlumb) {\n this.paint({recalc: false});\n }\n }\n\n // although the connection is no longer valid, there are use cases where this is useful.\n _jsPlumb.fire(\"connectionDragStop\", jpc, originalEvent);\n // fire this event to give people more fine-grained control (connectionDragStop fires a lot)\n if (jpc.pending) {\n _jsPlumb.fire(\"connectionAborted\", jpc, originalEvent);\n }\n // tell jsplumb that dragging is finished.\n _jsPlumb.currentlyDragging = false;\n jpc.suspendedElement = null;\n jpc.suspendedEndpoint = null;\n jpc = null;\n }\n\n // if no endpoints, jpc already cleaned up. but still we want to ensure we're reset properly.\n // remove the element associated with the floating endpoint\n // (and its associated floating endpoint and visual artefacts)\n if (placeholderInfo && placeholderInfo.element) {\n _jsPlumb.remove(placeholderInfo.element, false, false);\n }\n // remove the inplace copy\n if (inPlaceCopy) {\n _jsPlumb.deleteObject({endpoint: inPlaceCopy});\n }\n\n if (this._jsPlumb) {\n // make our canvas visible (TODO: hand off to library; we should not know about DOM)\n this.canvas.style.visibility = \"visible\";\n // unlock our anchor\n this.anchor.unlock();\n // clear floating anchor.\n this._jsPlumb.floatingEndpoint = null;\n }\n\n }.bind(this);\n\n dragOptions = _jp.extend(defaultOpts, dragOptions);\n dragOptions.scope = this.scope || dragOptions.scope;\n dragOptions[beforeStartEvent] = _ju.wrap(dragOptions[beforeStartEvent], beforeStart, false);\n dragOptions[startEvent] = _ju.wrap(dragOptions[startEvent], start, false);\n // extracted drag handler function so can be used by makeSource\n dragOptions[dragEvent] = _ju.wrap(dragOptions[dragEvent], _dragHandler.drag);\n dragOptions[stopEvent] = _ju.wrap(dragOptions[stopEvent], stop);\n dragOptions.multipleDrop = false;\n\n dragOptions.canDrag = function () {\n return this.isSource || this.isTemporarySource || (this.connections.length > 0 && this.connectionsDetachable !== false);\n }.bind(this);\n\n _jsPlumb.initDraggable(this.canvas, dragOptions, \"internal\");\n\n this.canvas._jsPlumbRelatedElement = this.element;\n\n draggingInitialised = true;\n }\n };\n\n var ep = params.endpoint || this._jsPlumb.instance.Defaults.Endpoint || _jp.Defaults.Endpoint;\n this.setEndpoint(ep, true);\n var anchorParamsToUse = params.anchor ? params.anchor : params.anchors ? params.anchors : (_jsPlumb.Defaults.Anchor || \"Top\");\n this.setAnchor(anchorParamsToUse, true);\n\n // finally, set type if it was provided\n var type = [ \"default\", (params.type || \"\")].join(\" \");\n this.addType(type, params.data, true);\n this.canvas = this.endpoint.canvas;\n this.canvas._jsPlumb = this;\n\n this.initDraggable();\n\n // pulled this out into a function so we can reuse it for the inPlaceCopy canvas; you can now drop detached connections\n // back onto the endpoint you detached it from.\n var _initDropTarget = function (canvas, isTransient, endpoint, referenceEndpoint) {\n\n if (_jp.isDropSupported(this.element)) {\n var dropOptions = params.dropOptions || _jsPlumb.Defaults.DropOptions || _jp.Defaults.DropOptions;\n dropOptions = _jp.extend({}, dropOptions);\n dropOptions.scope = dropOptions.scope || this.scope;\n var dropEvent = _jp.dragEvents.drop,\n overEvent = _jp.dragEvents.over,\n outEvent = _jp.dragEvents.out,\n _ep = this,\n drop = _jsPlumb.EndpointDropHandler({\n getEndpoint: function () {\n return _ep;\n },\n jsPlumb: _jsPlumb,\n enabled: function () {\n return endpoint != null ? endpoint.isEnabled() : true;\n },\n isFull: function () {\n return endpoint.isFull();\n },\n element: this.element,\n elementId: this.elementId,\n isSource: this.isSource,\n isTarget: this.isTarget,\n addClass: function (clazz) {\n _ep.addClass(clazz);\n },\n removeClass: function (clazz) {\n _ep.removeClass(clazz);\n },\n isDropAllowed: function () {\n return _ep.isDropAllowed.apply(_ep, arguments);\n },\n reference:referenceEndpoint,\n isRedrop:function(jpc, dhParams) {\n return jpc.suspendedEndpoint && dhParams.reference && (jpc.suspendedEndpoint.id === dhParams.reference.id);\n }\n });\n\n dropOptions[dropEvent] = _ju.wrap(dropOptions[dropEvent], drop, true);\n dropOptions[overEvent] = _ju.wrap(dropOptions[overEvent], function () {\n var draggable = _jp.getDragObject(arguments),\n id = _jsPlumb.getAttribute(_jp.getElement(draggable), \"dragId\"),\n _jpc = _jsPlumb.getFloatingConnectionFor(id);//_jsPlumb.floatingConnections[id];\n\n if (_jpc != null) {\n var idx = _jsPlumb.getFloatingAnchorIndex(_jpc);\n // here we should fire the 'over' event if we are a target and this is a new connection,\n // or we are the same as the floating endpoint.\n var _cont = (this.isTarget && idx !== 0) || (_jpc.suspendedEndpoint && this.referenceEndpoint && this.referenceEndpoint.id === _jpc.suspendedEndpoint.id);\n if (_cont) {\n var bb = _jsPlumb.checkCondition(\"checkDropAllowed\", {\n sourceEndpoint: _jpc.endpoints[idx],\n targetEndpoint: this,\n connection: _jpc\n });\n this[(bb ? \"add\" : \"remove\") + \"Class\"](_jsPlumb.endpointDropAllowedClass);\n this[(bb ? \"remove\" : \"add\") + \"Class\"](_jsPlumb.endpointDropForbiddenClass);\n _jpc.endpoints[idx].anchor.over(this.anchor, this);\n }\n }\n }.bind(this));\n\n dropOptions[outEvent] = _ju.wrap(dropOptions[outEvent], function () {\n var draggable = _jp.getDragObject(arguments),\n id = draggable == null ? null : _jsPlumb.getAttribute(_jp.getElement(draggable), \"dragId\"),\n _jpc = id ? _jsPlumb.getFloatingConnectionFor(id) : null;\n\n if (_jpc != null) {\n var idx = _jsPlumb.getFloatingAnchorIndex(_jpc);\n var _cont = (this.isTarget && idx !== 0) || (_jpc.suspendedEndpoint && this.referenceEndpoint && this.referenceEndpoint.id === _jpc.suspendedEndpoint.id);\n if (_cont) {\n this.removeClass(_jsPlumb.endpointDropAllowedClass);\n this.removeClass(_jsPlumb.endpointDropForbiddenClass);\n _jpc.endpoints[idx].anchor.out();\n }\n }\n }.bind(this));\n\n _jsPlumb.initDroppable(canvas, dropOptions, \"internal\", isTransient);\n }\n }.bind(this);\n\n // Initialise the endpoint's canvas as a drop target. The drop handler will take care of the logic of whether\n // something can actually be dropped.\n if (!this.anchor.isFloating) {\n _initDropTarget(this.canvas, !(params._transient || this.anchor.isFloating), this, params.reference);\n }\n\n return this;\n };\n\n _ju.extend(_jp.Endpoint, _jp.OverlayCapableJsPlumbUIComponent, {\n\n setVisible: function (v, doNotChangeConnections, doNotNotifyOtherEndpoint) {\n this._jsPlumb.visible = v;\n if (this.canvas) {\n this.canvas.style.display = v ? \"block\" : \"none\";\n }\n this[v ? \"showOverlays\" : \"hideOverlays\"]();\n if (!doNotChangeConnections) {\n for (var i = 0; i < this.connections.length; i++) {\n this.connections[i].setVisible(v);\n if (!doNotNotifyOtherEndpoint) {\n var oIdx = this === this.connections[i].endpoints[0] ? 1 : 0;\n // only change the other endpoint if this is its only connection.\n if (this.connections[i].endpoints[oIdx].connections.length === 1) {\n this.connections[i].endpoints[oIdx].setVisible(v, true, true);\n }\n }\n }\n }\n },\n getAttachedElements: function () {\n return this.connections;\n },\n applyType: function (t, doNotRepaint) {\n this.setPaintStyle(t.endpointStyle || t.paintStyle, doNotRepaint);\n this.setHoverPaintStyle(t.endpointHoverStyle || t.hoverPaintStyle, doNotRepaint);\n if (t.maxConnections != null) {\n this._jsPlumb.maxConnections = t.maxConnections;\n }\n if (t.scope) {\n this.scope = t.scope;\n }\n _jp.extend(this, t, typeParameters);\n if (t.cssClass != null && this.canvas) {\n this._jsPlumb.instance.addClass(this.canvas, t.cssClass);\n }\n _jp.OverlayCapableJsPlumbUIComponent.applyType(this, t);\n },\n isEnabled: function () {\n return this._jsPlumb.enabled;\n },\n setEnabled: function (e) {\n this._jsPlumb.enabled = e;\n },\n cleanup: function () {\n var anchorClass = this._jsPlumb.instance.endpointAnchorClassPrefix + (this._jsPlumb.currentAnchorClass ? \"-\" + this._jsPlumb.currentAnchorClass : \"\");\n _jp.removeClass(this.element, anchorClass);\n this.anchor = null;\n this.endpoint.cleanup(true);\n this.endpoint.destroy();\n this.endpoint = null;\n // drag/drop\n this._jsPlumb.instance.destroyDraggable(this.canvas, \"internal\");\n this._jsPlumb.instance.destroyDroppable(this.canvas, \"internal\");\n },\n setHover: function (h) {\n if (this.endpoint && this._jsPlumb && !this._jsPlumb.instance.isConnectionBeingDragged()) {\n this.endpoint.setHover(h);\n }\n },\n isFull: function () {\n return this._jsPlumb.maxConnections === 0 ? true : !(this.isFloating() || this._jsPlumb.maxConnections < 0 || this.connections.length < this._jsPlumb.maxConnections);\n },\n /**\n * private but needs to be exposed.\n */\n isFloating: function () {\n return this.anchor != null && this.anchor.isFloating;\n },\n isConnectedTo: function (endpoint) {\n var found = false;\n if (endpoint) {\n for (var i = 0; i < this.connections.length; i++) {\n if (this.connections[i].endpoints[1] === endpoint || this.connections[i].endpoints[0] === endpoint) {\n found = true;\n break;\n }\n }\n }\n return found;\n },\n getConnectionCost: function () {\n return this._jsPlumb.connectionCost;\n },\n setConnectionCost: function (c) {\n this._jsPlumb.connectionCost = c;\n },\n areConnectionsDirected: function () {\n return this._jsPlumb.connectionsDirected;\n },\n setConnectionsDirected: function (b) {\n this._jsPlumb.connectionsDirected = b;\n },\n setElementId: function (_elId) {\n this.elementId = _elId;\n this.anchor.elementId = _elId;\n },\n setReferenceElement: function (_el) {\n this.element = _jp.getElement(_el);\n },\n setDragAllowedWhenFull: function (allowed) {\n this.dragAllowedWhenFull = allowed;\n },\n equals: function (endpoint) {\n return this.anchor.equals(endpoint.anchor);\n },\n getUuid: function () {\n return this._jsPlumb.uuid;\n },\n computeAnchor: function (params) {\n return this.anchor.compute(params);\n }\n });\n\n root.jsPlumbInstance.prototype.EndpointDropHandler = function (dhParams) {\n return function (e) {\n\n var _jsPlumb = dhParams.jsPlumb;\n\n // remove the classes that are added dynamically. drop is neither forbidden nor allowed now that\n // the drop is finishing.\n dhParams.removeClass(_jsPlumb.endpointDropAllowedClass);\n dhParams.removeClass(_jsPlumb.endpointDropForbiddenClass);\n\n var originalEvent = _jsPlumb.getDropEvent(arguments),\n draggable = _jsPlumb.getDragObject(arguments),\n id = _jsPlumb.getAttribute(draggable, \"dragId\"),\n elId = _jsPlumb.getAttribute(draggable, \"elId\"),\n scope = _jsPlumb.getAttribute(draggable, \"originalScope\"),\n jpc = _jsPlumb.getFloatingConnectionFor(id);\n\n // if no active connection, bail.\n if (jpc == null) {\n return;\n }\n\n // calculate if this is an existing connection.\n var existingConnection = jpc.suspendedEndpoint != null;\n\n // if suspended endpoint exists but has been cleaned up, bail. This means it's an existing connection\n // that has been detached and will shortly be discarded.\n if (existingConnection && jpc.suspendedEndpoint._jsPlumb == null) {\n return;\n }\n\n // get the drop endpoint. for a normal connection this is just the one that would replace the currently\n // floating endpoint. for a makeTarget this is a new endpoint that is created on drop. But we leave that to\n // the handler to figure out.\n var _ep = dhParams.getEndpoint(jpc);\n\n // If we're not given an endpoint to use, bail.\n if (_ep == null) {\n return;\n }\n\n // if this is a drop back where the connection came from, mark it force reattach and\n // return; the stop handler will reattach. without firing an event.\n if (dhParams.isRedrop(jpc, dhParams)) {\n jpc._forceReattach = true;\n jpc.setHover(false);\n if (dhParams.maybeCleanup) {\n dhParams.maybeCleanup(_ep);\n }\n return;\n }\n\n // ensure we dont bother trying to drop sources on non-source eps, and same for target.\n var idx = _jsPlumb.getFloatingAnchorIndex(jpc);\n if ((idx === 0 && !dhParams.isSource)|| (idx === 1 && !dhParams.isTarget)){\n if (dhParams.maybeCleanup) {\n dhParams.maybeCleanup(_ep);\n }\n return;\n }\n\n if (dhParams.onDrop) {\n dhParams.onDrop(jpc);\n }\n\n // restore the original scope if necessary (issue 57)\n if (scope) {\n _jsPlumb.setDragScope(draggable, scope);\n }\n\n // if the target of the drop is full, fire an event (we abort below)\n // makeTarget: keep.\n var isFull = dhParams.isFull(e);\n if (isFull) {\n _ep.fire(\"maxConnections\", {\n endpoint: this,\n connection: jpc,\n maxConnections: _ep._jsPlumb.maxConnections\n }, originalEvent);\n }\n //\n // if endpoint enabled, not full, and matches the index of the floating endpoint...\n if (!isFull && dhParams.enabled()) {\n var _doContinue = true;\n\n // before testing for beforeDrop, reset the connection's source/target to be the actual DOM elements\n // involved (that is, stash any temporary stuff used for dragging. but we need to keep it around in\n // order that the anchor manager can clean things up properly).\n if (idx === 0) {\n jpc.floatingElement = jpc.source;\n jpc.floatingId = jpc.sourceId;\n jpc.floatingEndpoint = jpc.endpoints[0];\n jpc.floatingIndex = 0;\n jpc.source = dhParams.element;\n jpc.sourceId = dhParams.elementId;\n } else {\n jpc.floatingElement = jpc.target;\n jpc.floatingId = jpc.targetId;\n jpc.floatingEndpoint = jpc.endpoints[1];\n jpc.floatingIndex = 1;\n jpc.target = dhParams.element;\n jpc.targetId = dhParams.elementId;\n }\n\n // if this is an existing connection and detach is not allowed we won't continue. The connection's\n // endpoints have been reinstated; everything is back to how it was.\n if (existingConnection && jpc.suspendedEndpoint.id !== _ep.id) {\n if (!jpc.isDetachAllowed(jpc) || !jpc.endpoints[idx].isDetachAllowed(jpc) || !jpc.suspendedEndpoint.isDetachAllowed(jpc) || !_jsPlumb.checkCondition(\"beforeDetach\", jpc)) {\n _doContinue = false;\n }\n }\n\n// ------------ wrap the execution path in a function so we can support asynchronous beforeDrop\n\n var continueFunction = function (optionalData) {\n // remove this jpc from the current endpoint, which is a floating endpoint that we will\n // subsequently discard.\n jpc.endpoints[idx].detachFromConnection(jpc);\n\n // if there's a suspended endpoint, detach it from the connection.\n if (jpc.suspendedEndpoint) {\n jpc.suspendedEndpoint.detachFromConnection(jpc);\n }\n\n jpc.endpoints[idx] = _ep;\n _ep.addConnection(jpc);\n\n // copy our parameters in to the connection:\n var params = _ep.getParameters();\n for (var aParam in params) {\n jpc.setParameter(aParam, params[aParam]);\n }\n\n if (!existingConnection) {\n // if not an existing connection and\n if (params.draggable) {\n _jsPlumb.initDraggable(this.element, dhParams.dragOptions, \"internal\", _jsPlumb);\n }\n }\n else {\n var suspendedElementId = jpc.suspendedEndpoint.elementId;\n _jsPlumb.fireMoveEvent({\n index: idx,\n originalSourceId: idx === 0 ? suspendedElementId : jpc.sourceId,\n newSourceId: idx === 0 ? _ep.elementId : jpc.sourceId,\n originalTargetId: idx === 1 ? suspendedElementId : jpc.targetId,\n newTargetId: idx === 1 ? _ep.elementId : jpc.targetId,\n originalSourceEndpoint: idx === 0 ? jpc.suspendedEndpoint : jpc.endpoints[0],\n newSourceEndpoint: idx === 0 ? _ep : jpc.endpoints[0],\n originalTargetEndpoint: idx === 1 ? jpc.suspendedEndpoint : jpc.endpoints[1],\n newTargetEndpoint: idx === 1 ? _ep : jpc.endpoints[1],\n connection: jpc\n }, originalEvent);\n }\n\n if (idx === 1) {\n _jsPlumb.anchorManager.updateOtherEndpoint(jpc.sourceId, jpc.floatingId, jpc.targetId, jpc);\n }\n else {\n _jsPlumb.anchorManager.sourceChanged(jpc.floatingId, jpc.sourceId, jpc, jpc.source);\n }\n\n // when makeSource has uniqueEndpoint:true, we want to create connections with new endpoints\n // that are subsequently deleted. So makeSource sets `finalEndpoint`, which is the Endpoint to\n // which the connection should be attached. The `detachFromConnection` call below results in the\n // temporary endpoint being cleaned up.\n if (jpc.endpoints[0].finalEndpoint) {\n var _toDelete = jpc.endpoints[0];\n _toDelete.detachFromConnection(jpc);\n jpc.endpoints[0] = jpc.endpoints[0].finalEndpoint;\n jpc.endpoints[0].addConnection(jpc);\n }\n\n // if optionalData was given, merge it onto the connection's data.\n if (_ju.isObject(optionalData)) {\n jpc.mergeData(optionalData);\n }\n // finalise will inform the anchor manager and also add to\n // connectionsByScope if necessary.\n _jsPlumb.finaliseConnection(jpc, null, originalEvent, false);\n jpc.setHover(false);\n\n // SP continuous anchor flush\n _jsPlumb.revalidate(jpc.endpoints[0].element);\n\n }.bind(this);\n\n var dontContinueFunction = function () {\n // otherwise just put it back on the endpoint it was on before the drag.\n if (jpc.suspendedEndpoint) {\n jpc.endpoints[idx] = jpc.suspendedEndpoint;\n jpc.setHover(false);\n jpc._forceDetach = true;\n if (idx === 0) {\n jpc.source = jpc.suspendedEndpoint.element;\n jpc.sourceId = jpc.suspendedEndpoint.elementId;\n } else {\n jpc.target = jpc.suspendedEndpoint.element;\n jpc.targetId = jpc.suspendedEndpoint.elementId;\n }\n jpc.suspendedEndpoint.addConnection(jpc);\n\n // TODO checkSanity\n if (idx === 1) {\n _jsPlumb.anchorManager.updateOtherEndpoint(jpc.sourceId, jpc.floatingId, jpc.targetId, jpc);\n }\n else {\n _jsPlumb.anchorManager.sourceChanged(jpc.floatingId, jpc.sourceId, jpc, jpc.source);\n }\n\n _jsPlumb.repaint(jpc.sourceId);\n jpc._forceDetach = false;\n }\n };\n\n// --------------------------------------\n // now check beforeDrop. this will be available only on Endpoints that are setup to\n // have a beforeDrop condition (although, secretly, under the hood all Endpoints and\n // the Connection have them, because they are on jsPlumbUIComponent. shhh!), because\n // it only makes sense to have it on a target endpoint.\n _doContinue = _doContinue && dhParams.isDropAllowed(jpc.sourceId, jpc.targetId, jpc.scope, jpc, _ep);// && jpc.pending;\n\n if (_doContinue) {\n continueFunction(_doContinue);\n return true;\n }\n else {\n dontContinueFunction();\n }\n }\n\n if (dhParams.maybeCleanup) {\n dhParams.maybeCleanup(_ep);\n }\n\n _jsPlumb.currentlyDragging = false;\n };\n };\n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * This file contains the code for Connections.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this,\n _jp = root.jsPlumb,\n _ju = root.jsPlumbUtil;\n\n var makeConnector = function (_jsPlumb, renderMode, connectorName, connectorArgs, forComponent) {\n // first make sure we have a cache for the specified renderer\n _jp.Connectors[renderMode] = _jp.Connectors[renderMode] || {};\n\n // now see if the one we want exists; if not we will try to make it\n if (_jp.Connectors[renderMode][connectorName] == null) {\n\n if (_jp.Connectors[connectorName] == null) {\n if (!_jsPlumb.Defaults.DoNotThrowErrors) {\n throw new TypeError(\"jsPlumb: unknown connector type '\" + connectorName + \"'\");\n } else {\n return null;\n }\n }\n\n _jp.Connectors[renderMode][connectorName] = function() {\n _jp.Connectors[connectorName].apply(this, arguments);\n _jp.ConnectorRenderers[renderMode].apply(this, arguments);\n };\n\n _ju.extend(_jp.Connectors[renderMode][connectorName], [ _jp.Connectors[connectorName], _jp.ConnectorRenderers[renderMode]]);\n\n }\n\n return new _jp.Connectors[renderMode][connectorName](connectorArgs, forComponent);\n },\n _makeAnchor = function (anchorParams, elementId, _jsPlumb) {\n return (anchorParams) ? _jsPlumb.makeAnchor(anchorParams, elementId, _jsPlumb) : null;\n },\n _updateConnectedClass = function (conn, element, _jsPlumb, remove) {\n if (element != null) {\n element._jsPlumbConnections = element._jsPlumbConnections || {};\n if (remove) {\n delete element._jsPlumbConnections[conn.id];\n }\n else {\n element._jsPlumbConnections[conn.id] = true;\n }\n\n if (_ju.isEmpty(element._jsPlumbConnections)) {\n _jsPlumb.removeClass(element, _jsPlumb.connectedClass);\n }\n else {\n _jsPlumb.addClass(element, _jsPlumb.connectedClass);\n }\n }\n };\n\n _jp.Connection = function (params) {\n var _newEndpoint = params.newEndpoint;\n\n this.id = params.id;\n this.connector = null;\n this.idPrefix = \"_jsplumb_c_\";\n this.defaultLabelLocation = 0.5;\n this.defaultOverlayKeys = [\"Overlays\", \"ConnectionOverlays\"];\n // if a new connection is the result of moving some existing connection, params.previousConnection\n // will have that Connection in it. listeners for the jsPlumbConnection event can look for that\n // member and take action if they need to.\n this.previousConnection = params.previousConnection;\n this.source = _jp.getElement(params.source);\n this.target = _jp.getElement(params.target);\n\n\n _jp.OverlayCapableJsPlumbUIComponent.apply(this, arguments);\n\n // sourceEndpoint and targetEndpoint override source/target, if they are present. but \n // source is not overridden if the Endpoint has declared it is not the final target of a connection;\n // instead we use the source that the Endpoint declares will be the final source element.\n if (params.sourceEndpoint) {\n this.source = params.sourceEndpoint.getElement();\n this.sourceId = params.sourceEndpoint.elementId;\n } else {\n this.sourceId = this._jsPlumb.instance.getId(this.source);\n }\n\n if (params.targetEndpoint) {\n this.target = params.targetEndpoint.getElement();\n this.targetId = params.targetEndpoint.elementId;\n } else {\n this.targetId = this._jsPlumb.instance.getId(this.target);\n }\n\n\n this.scope = params.scope; // scope may have been passed in to the connect call. if it wasn't, we will pull it from the source endpoint, after having initialised the endpoints. \n this.endpoints = [];\n this.endpointStyles = [];\n\n var _jsPlumb = this._jsPlumb.instance;\n\n _jsPlumb.manage(this.sourceId, this.source);\n _jsPlumb.manage(this.targetId, this.target);\n\n this._jsPlumb.visible = true;\n\n this._jsPlumb.params = {\n cssClass: params.cssClass,\n container: params.container,\n \"pointer-events\": params[\"pointer-events\"],\n editorParams: params.editorParams,\n overlays: params.overlays\n };\n this._jsPlumb.lastPaintedAt = null;\n\n // listen to mouseover and mouseout events passed from the container delegate.\n this.bind(\"mouseover\", function () {\n this.setHover(true);\n }.bind(this));\n this.bind(\"mouseout\", function () {\n this.setHover(false);\n }.bind(this));\n\n\n// INITIALISATION CODE\n\n this.makeEndpoint = function (isSource, el, elId, ep) {\n elId = elId || this._jsPlumb.instance.getId(el);\n return this.prepareEndpoint(_jsPlumb, _newEndpoint, this, ep, isSource ? 0 : 1, params, el, elId);\n };\n\n // if type given, get the endpoint definitions mapping to that type from the jsplumb instance, and use those.\n // we apply types at the end of this constructor but endpoints are only honoured in a type definition at\n // create time.\n if (params.type) {\n params.endpoints = params.endpoints || this._jsPlumb.instance.deriveEndpointAndAnchorSpec(params.type).endpoints;\n }\n\n var eS = this.makeEndpoint(true, this.source, this.sourceId, params.sourceEndpoint),\n eT = this.makeEndpoint(false, this.target, this.targetId, params.targetEndpoint);\n\n if (eS) {\n _ju.addToList(params.endpointsByElement, this.sourceId, eS);\n }\n if (eT) {\n _ju.addToList(params.endpointsByElement, this.targetId, eT);\n }\n // if scope not set, set it to be the scope for the source endpoint.\n if (!this.scope) {\n this.scope = this.endpoints[0].scope;\n }\n\n // if explicitly told to (or not to) delete endpoints when empty, override endpoint's preferences\n if (params.deleteEndpointsOnEmpty != null) {\n this.endpoints[0].setDeleteOnEmpty(params.deleteEndpointsOnEmpty);\n this.endpoints[1].setDeleteOnEmpty(params.deleteEndpointsOnEmpty);\n }\n\n// -------------------------- DEFAULT TYPE ---------------------------------------------\n\n // DETACHABLE\n var _detachable = _jsPlumb.Defaults.ConnectionsDetachable;\n if (params.detachable === false) {\n _detachable = false;\n }\n if (this.endpoints[0].connectionsDetachable === false) {\n _detachable = false;\n }\n if (this.endpoints[1].connectionsDetachable === false) {\n _detachable = false;\n }\n // REATTACH\n var _reattach = params.reattach || this.endpoints[0].reattachConnections || this.endpoints[1].reattachConnections || _jsPlumb.Defaults.ReattachConnections;\n\n this.appendToDefaultType({\n detachable: _detachable,\n reattach: _reattach,\n paintStyle:this.endpoints[0].connectorStyle || this.endpoints[1].connectorStyle || params.paintStyle || _jsPlumb.Defaults.PaintStyle || _jp.Defaults.PaintStyle,\n hoverPaintStyle:this.endpoints[0].connectorHoverStyle || this.endpoints[1].connectorHoverStyle || params.hoverPaintStyle || _jsPlumb.Defaults.HoverPaintStyle || _jp.Defaults.HoverPaintStyle\n });\n\n var _suspendedAt = _jsPlumb.getSuspendedAt();\n if (!_jsPlumb.isSuspendDrawing()) {\n // paint the endpoints\n var myInfo = _jsPlumb.getCachedData(this.sourceId),\n myOffset = myInfo.o, myWH = myInfo.s,\n otherInfo = _jsPlumb.getCachedData(this.targetId),\n otherOffset = otherInfo.o,\n otherWH = otherInfo.s,\n initialTimestamp = _suspendedAt || _jsPlumb.timestamp(),\n anchorLoc = this.endpoints[0].anchor.compute({\n xy: [ myOffset.left, myOffset.top ], wh: myWH, element: this.endpoints[0],\n elementId: this.endpoints[0].elementId,\n txy: [ otherOffset.left, otherOffset.top ], twh: otherWH, tElement: this.endpoints[1],\n timestamp: initialTimestamp\n });\n\n this.endpoints[0].paint({ anchorLoc: anchorLoc, timestamp: initialTimestamp });\n\n anchorLoc = this.endpoints[1].anchor.compute({\n xy: [ otherOffset.left, otherOffset.top ], wh: otherWH, element: this.endpoints[1],\n elementId: this.endpoints[1].elementId,\n txy: [ myOffset.left, myOffset.top ], twh: myWH, tElement: this.endpoints[0],\n timestamp: initialTimestamp\n });\n this.endpoints[1].paint({ anchorLoc: anchorLoc, timestamp: initialTimestamp });\n }\n\n this.getTypeDescriptor = function () {\n return \"connection\";\n };\n this.getAttachedElements = function () {\n return this.endpoints;\n };\n\n this.isDetachable = function (ep) {\n return this._jsPlumb.detachable === false ? false : ep != null ? ep.connectionsDetachable === true : this._jsPlumb.detachable === true;\n };\n this.setDetachable = function (detachable) {\n this._jsPlumb.detachable = detachable === true;\n };\n this.isReattach = function () {\n return this._jsPlumb.reattach === true || this.endpoints[0].reattachConnections === true || this.endpoints[1].reattachConnections === true;\n };\n this.setReattach = function (reattach) {\n this._jsPlumb.reattach = reattach === true;\n };\n\n// END INITIALISATION CODE\n\n\n// COST + DIRECTIONALITY\n // if cost not supplied, try to inherit from source endpoint\n this._jsPlumb.cost = params.cost || this.endpoints[0].getConnectionCost();\n this._jsPlumb.directed = params.directed;\n // inherit directed flag if set no source endpoint\n if (params.directed == null) {\n this._jsPlumb.directed = this.endpoints[0].areConnectionsDirected();\n }\n// END COST + DIRECTIONALITY\n\n// PARAMETERS\n // merge all the parameters objects into the connection. parameters set\n // on the connection take precedence; then source endpoint params, then\n // finally target endpoint params.\n var _p = _jp.extend({}, this.endpoints[1].getParameters());\n _jp.extend(_p, this.endpoints[0].getParameters());\n _jp.extend(_p, this.getParameters());\n this.setParameters(_p);\n// END PARAMETERS\n\n// PAINTING\n\n this.setConnector(this.endpoints[0].connector || this.endpoints[1].connector || params.connector || _jsPlumb.Defaults.Connector || _jp.Defaults.Connector, true);\n var data = params.data == null || !_ju.isObject(params.data) ? {} : params.data;\n this.getData = function() { return data; };\n this.setData = function(d) { data = d || {}; };\n this.mergeData = function(d) { data = _jp.extend(data, d); };\n\n // the very last thing we do is apply types, if there are any.\n var _types = [ \"default\", this.endpoints[0].connectionType, this.endpoints[1].connectionType, params.type ].join(\" \");\n if (/[^\\s]/.test(_types)) {\n this.addType(_types, params.data, true);\n }\n\n this.updateConnectedClass();\n\n// END PAINTING \n };\n\n _ju.extend(_jp.Connection, _jp.OverlayCapableJsPlumbUIComponent, {\n applyType: function (t, doNotRepaint, typeMap) {\n\n var _connector = null;\n if (t.connector != null) {\n _connector = this.getCachedTypeItem(\"connector\", typeMap.connector);\n if (_connector == null) {\n _connector = this.prepareConnector(t.connector, typeMap.connector);\n this.cacheTypeItem(\"connector\", _connector, typeMap.connector);\n }\n this.setPreparedConnector(_connector);\n }\n\n // none of these things result in the creation of objects so can be ignored.\n if (t.detachable != null) {\n this.setDetachable(t.detachable);\n }\n if (t.reattach != null) {\n this.setReattach(t.reattach);\n }\n if (t.scope) {\n this.scope = t.scope;\n }\n\n if (t.cssClass != null && this.canvas) {\n this._jsPlumb.instance.addClass(this.canvas, t.cssClass);\n }\n\n var _anchors = null;\n // this also results in the creation of objects.\n if (t.anchor) {\n // note that even if the param was anchor, we store `anchors`.\n _anchors = this.getCachedTypeItem(\"anchors\", typeMap.anchor);\n if (_anchors == null) {\n _anchors = [ this._jsPlumb.instance.makeAnchor(t.anchor), this._jsPlumb.instance.makeAnchor(t.anchor) ];\n this.cacheTypeItem(\"anchors\", _anchors, typeMap.anchor);\n }\n }\n else if (t.anchors) {\n _anchors = this.getCachedTypeItem(\"anchors\", typeMap.anchors);\n if (_anchors == null) {\n _anchors = [\n this._jsPlumb.instance.makeAnchor(t.anchors[0]),\n this._jsPlumb.instance.makeAnchor(t.anchors[1])\n ];\n this.cacheTypeItem(\"anchors\", _anchors, typeMap.anchors);\n }\n }\n if (_anchors != null) {\n this.endpoints[0].anchor = _anchors[0];\n this.endpoints[1].anchor = _anchors[1];\n if (this.endpoints[1].anchor.isDynamic) {\n this._jsPlumb.instance.repaint(this.endpoints[1].elementId);\n }\n }\n\n _jp.OverlayCapableJsPlumbUIComponent.applyType(this, t);\n },\n addClass: function (c, informEndpoints) {\n if (informEndpoints) {\n this.endpoints[0].addClass(c);\n this.endpoints[1].addClass(c);\n if (this.suspendedEndpoint) {\n this.suspendedEndpoint.addClass(c);\n }\n }\n if (this.connector) {\n this.connector.addClass(c);\n }\n },\n removeClass: function (c, informEndpoints) {\n if (informEndpoints) {\n this.endpoints[0].removeClass(c);\n this.endpoints[1].removeClass(c);\n if (this.suspendedEndpoint) {\n this.suspendedEndpoint.removeClass(c);\n }\n }\n if (this.connector) {\n this.connector.removeClass(c);\n }\n },\n isVisible: function () {\n return this._jsPlumb.visible;\n },\n setVisible: function (v) {\n this._jsPlumb.visible = v;\n if (this.connector) {\n this.connector.setVisible(v);\n }\n this.repaint();\n },\n cleanup: function () {\n this.updateConnectedClass(true);\n this.endpoints = null;\n this.source = null;\n this.target = null;\n if (this.connector != null) {\n this.connector.cleanup(true);\n this.connector.destroy(true);\n }\n this.connector = null;\n },\n updateConnectedClass:function(remove) {\n if (this._jsPlumb) {\n _updateConnectedClass(this, this.source, this._jsPlumb.instance, remove);\n _updateConnectedClass(this, this.target, this._jsPlumb.instance, remove);\n }\n },\n setHover: function (state) {\n if (this.connector && this._jsPlumb && !this._jsPlumb.instance.isConnectionBeingDragged()) {\n this.connector.setHover(state);\n root.jsPlumb[state ? \"addClass\" : \"removeClass\"](this.source, this._jsPlumb.instance.hoverSourceClass);\n root.jsPlumb[state ? \"addClass\" : \"removeClass\"](this.target, this._jsPlumb.instance.hoverTargetClass);\n }\n },\n getUuids:function() {\n return [ this.endpoints[0].getUuid(), this.endpoints[1].getUuid() ];\n },\n getCost: function () {\n return this._jsPlumb ? this._jsPlumb.cost : -Infinity;\n },\n setCost: function (c) {\n this._jsPlumb.cost = c;\n },\n isDirected: function () {\n return this._jsPlumb.directed;\n },\n getConnector: function () {\n return this.connector;\n },\n prepareConnector:function(connectorSpec, typeId) {\n var connectorArgs = {\n _jsPlumb: this._jsPlumb.instance,\n cssClass: this._jsPlumb.params.cssClass,\n container: this._jsPlumb.params.container,\n \"pointer-events\": this._jsPlumb.params[\"pointer-events\"]\n },\n renderMode = this._jsPlumb.instance.getRenderMode(),\n connector;\n\n if (_ju.isString(connectorSpec)) {\n connector = makeConnector(this._jsPlumb.instance, renderMode, connectorSpec, connectorArgs, this);\n } // lets you use a string as shorthand.\n else if (_ju.isArray(connectorSpec)) {\n if (connectorSpec.length === 1) {\n connector = makeConnector(this._jsPlumb.instance, renderMode, connectorSpec[0], connectorArgs, this);\n }\n else {\n connector = makeConnector(this._jsPlumb.instance, renderMode, connectorSpec[0], _ju.merge(connectorSpec[1], connectorArgs), this);\n }\n }\n if (typeId != null) {\n connector.typeId = typeId;\n }\n return connector;\n },\n setPreparedConnector: function(connector, doNotRepaint, doNotChangeListenerComponent, typeId) {\n\n if (this.connector !== connector) {\n\n var previous, previousClasses = \"\";\n // the connector will not be cleaned up if it was set as part of a type, because `typeId` will be set on it\n // and we havent passed in `true` for \"force\" here.\n if (this.connector != null) {\n previous = this.connector;\n previousClasses = previous.getClass();\n this.connector.cleanup();\n this.connector.destroy();\n }\n\n this.connector = connector;\n if (typeId) {\n this.cacheTypeItem(\"connector\", connector, typeId);\n }\n\n this.canvas = this.connector.canvas;\n this.bgCanvas = this.connector.bgCanvas;\n\n // put classes from prior connector onto the canvas\n this.addClass(previousClasses);\n\n // new: instead of binding listeners per connector, we now just have one delegate on the container.\n // so for that handler we set the connection as the '_jsPlumb' member of the canvas element, and\n // bgCanvas, if it exists, which it does right now in the VML renderer, so it won't from v 2.0.0 onwards.\n if (this.canvas) {\n this.canvas._jsPlumb = this;\n }\n if (this.bgCanvas) {\n this.bgCanvas._jsPlumb = this;\n }\n\n if (previous != null) {\n var o = this.getOverlays();\n for (var i = 0; i < o.length; i++) {\n if (o[i].transfer) {\n o[i].transfer(this.connector);\n }\n }\n }\n\n if (!doNotChangeListenerComponent) {\n this.setListenerComponent(this.connector);\n }\n if (!doNotRepaint) {\n this.repaint();\n }\n }\n },\n setConnector: function (connectorSpec, doNotRepaint, doNotChangeListenerComponent, typeId) {\n var connector = this.prepareConnector(connectorSpec, typeId);\n this.setPreparedConnector(connector, doNotRepaint, doNotChangeListenerComponent, typeId);\n },\n paint: function (params) {\n\n if (!this._jsPlumb.instance.isSuspendDrawing() && this._jsPlumb.visible) {\n params = params || {};\n var timestamp = params.timestamp,\n // if the moving object is not the source we must transpose the two references.\n swap = false,\n tId = swap ? this.sourceId : this.targetId, sId = swap ? this.targetId : this.sourceId,\n tIdx = swap ? 0 : 1, sIdx = swap ? 1 : 0;\n\n if (timestamp == null || timestamp !== this._jsPlumb.lastPaintedAt) {\n var sourceInfo = this._jsPlumb.instance.updateOffset({elId:sId}).o,\n targetInfo = this._jsPlumb.instance.updateOffset({elId:tId}).o,\n sE = this.endpoints[sIdx], tE = this.endpoints[tIdx];\n\n var sAnchorP = sE.anchor.getCurrentLocation({xy: [sourceInfo.left, sourceInfo.top], wh: [sourceInfo.width, sourceInfo.height], element: sE, timestamp: timestamp}),\n tAnchorP = tE.anchor.getCurrentLocation({xy: [targetInfo.left, targetInfo.top], wh: [targetInfo.width, targetInfo.height], element: tE, timestamp: timestamp});\n\n this.connector.resetBounds();\n\n this.connector.compute({\n sourcePos: sAnchorP,\n targetPos: tAnchorP,\n sourceOrientation:sE.anchor.getOrientation(sE),\n targetOrientation:tE.anchor.getOrientation(tE),\n sourceEndpoint: this.endpoints[sIdx],\n targetEndpoint: this.endpoints[tIdx],\n \"stroke-width\": this._jsPlumb.paintStyleInUse.strokeWidth,\n sourceInfo: sourceInfo,\n targetInfo: targetInfo\n });\n\n var overlayExtents = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };\n\n // compute overlays. we do this first so we can get their placements, and adjust the\n // container if needs be (if an overlay would be clipped)\n for (var i in this._jsPlumb.overlays) {\n if (this._jsPlumb.overlays.hasOwnProperty(i)) {\n var o = this._jsPlumb.overlays[i];\n if (o.isVisible()) {\n this._jsPlumb.overlayPlacements[i] = o.draw(this.connector, this._jsPlumb.paintStyleInUse, this.getAbsoluteOverlayPosition(o));\n overlayExtents.minX = Math.min(overlayExtents.minX, this._jsPlumb.overlayPlacements[i].minX);\n overlayExtents.maxX = Math.max(overlayExtents.maxX, this._jsPlumb.overlayPlacements[i].maxX);\n overlayExtents.minY = Math.min(overlayExtents.minY, this._jsPlumb.overlayPlacements[i].minY);\n overlayExtents.maxY = Math.max(overlayExtents.maxY, this._jsPlumb.overlayPlacements[i].maxY);\n }\n }\n }\n\n var lineWidth = parseFloat(this._jsPlumb.paintStyleInUse.strokeWidth || 1) / 2,\n outlineWidth = parseFloat(this._jsPlumb.paintStyleInUse.strokeWidth || 0),\n extents = {\n xmin: Math.min(this.connector.bounds.minX - (lineWidth + outlineWidth), overlayExtents.minX),\n ymin: Math.min(this.connector.bounds.minY - (lineWidth + outlineWidth), overlayExtents.minY),\n xmax: Math.max(this.connector.bounds.maxX + (lineWidth + outlineWidth), overlayExtents.maxX),\n ymax: Math.max(this.connector.bounds.maxY + (lineWidth + outlineWidth), overlayExtents.maxY)\n };\n // paint the connector.\n this.connector.paint(this._jsPlumb.paintStyleInUse, null, extents);\n // and then the overlays\n for (var j in this._jsPlumb.overlays) {\n if (this._jsPlumb.overlays.hasOwnProperty(j)) {\n var p = this._jsPlumb.overlays[j];\n if (p.isVisible()) {\n p.paint(this._jsPlumb.overlayPlacements[j], extents);\n }\n }\n }\n }\n this._jsPlumb.lastPaintedAt = timestamp;\n }\n },\n repaint: function (params) {\n var p = jsPlumb.extend(params || {}, {});\n p.elId = this.sourceId;\n this.paint(p);\n },\n prepareEndpoint: function (_jsPlumb, _newEndpoint, conn, existing, index, params, element, elementId) {\n var e;\n if (existing) {\n conn.endpoints[index] = existing;\n existing.addConnection(conn);\n } else {\n if (!params.endpoints) {\n params.endpoints = [ null, null ];\n }\n var ep = params.endpoints[index] || params.endpoint || _jsPlumb.Defaults.Endpoints[index] || _jp.Defaults.Endpoints[index] || _jsPlumb.Defaults.Endpoint || _jp.Defaults.Endpoint;\n if (!params.endpointStyles) {\n params.endpointStyles = [ null, null ];\n }\n if (!params.endpointHoverStyles) {\n params.endpointHoverStyles = [ null, null ];\n }\n var es = params.endpointStyles[index] || params.endpointStyle || _jsPlumb.Defaults.EndpointStyles[index] || _jp.Defaults.EndpointStyles[index] || _jsPlumb.Defaults.EndpointStyle || _jp.Defaults.EndpointStyle;\n // Endpoints derive their fill from the connector's stroke, if no fill was specified.\n if (es.fill == null && params.paintStyle != null) {\n es.fill = params.paintStyle.stroke;\n }\n\n if (es.outlineStroke == null && params.paintStyle != null) {\n es.outlineStroke = params.paintStyle.outlineStroke;\n }\n if (es.outlineWidth == null && params.paintStyle != null) {\n es.outlineWidth = params.paintStyle.outlineWidth;\n }\n\n var ehs = params.endpointHoverStyles[index] || params.endpointHoverStyle || _jsPlumb.Defaults.EndpointHoverStyles[index] || _jp.Defaults.EndpointHoverStyles[index] || _jsPlumb.Defaults.EndpointHoverStyle || _jp.Defaults.EndpointHoverStyle;\n // endpoint hover fill style is derived from connector's hover stroke style\n if (params.hoverPaintStyle != null) {\n if (ehs == null) {\n ehs = {};\n }\n if (ehs.fill == null) {\n ehs.fill = params.hoverPaintStyle.stroke;\n }\n }\n var a = params.anchors ? params.anchors[index] :\n params.anchor ? params.anchor :\n _makeAnchor(_jsPlumb.Defaults.Anchors[index], elementId, _jsPlumb) ||\n _makeAnchor(_jp.Defaults.Anchors[index], elementId, _jsPlumb) ||\n _makeAnchor(_jsPlumb.Defaults.Anchor, elementId, _jsPlumb) ||\n _makeAnchor(_jp.Defaults.Anchor, elementId, _jsPlumb),\n u = params.uuids ? params.uuids[index] : null;\n\n e = _newEndpoint({\n paintStyle: es, hoverPaintStyle: ehs, endpoint: ep, connections: [ conn ],\n uuid: u, anchor: a, source: element, scope: params.scope,\n reattach: params.reattach || _jsPlumb.Defaults.ReattachConnections,\n detachable: params.detachable || _jsPlumb.Defaults.ConnectionsDetachable\n });\n if (existing == null) {\n e.setDeleteOnEmpty(true);\n }\n conn.endpoints[index] = e;\n\n if (params.drawEndpoints === false) {\n e.setVisible(false, true, true);\n }\n\n }\n return e;\n }\n\n }); // END Connection class \n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * This file contains the code for creating and manipulating anchors.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n\n var root = this,\n _ju = root.jsPlumbUtil,\n _jp = root.jsPlumb;\n\n //\n // manages anchors for all elements.\n //\n _jp.AnchorManager = function (params) {\n var _amEndpoints = {},\n continuousAnchorLocations = {},\n continuousAnchorOrientations = {},\n connectionsByElementId = {},\n self = this,\n anchorLists = {},\n jsPlumbInstance = params.jsPlumbInstance,\n floatingConnections = {},\n // used by placeAnchors function\n placeAnchorsOnLine = function (desc, elementDimensions, elementPosition, connections, horizontal, otherMultiplier, reverse) {\n var a = [], step = elementDimensions[horizontal ? 0 : 1] / (connections.length + 1);\n\n for (var i = 0; i < connections.length; i++) {\n var val = (i + 1) * step, other = otherMultiplier * elementDimensions[horizontal ? 1 : 0];\n if (reverse) {\n val = elementDimensions[horizontal ? 0 : 1] - val;\n }\n\n var dx = (horizontal ? val : other), x = elementPosition[0] + dx, xp = dx / elementDimensions[0],\n dy = (horizontal ? other : val), y = elementPosition[1] + dy, yp = dy / elementDimensions[1];\n\n a.push([ x, y, xp, yp, connections[i][1], connections[i][2] ]);\n }\n\n return a;\n },\n // used by edgeSortFunctions\n currySort = function (reverseAngles) {\n return function (a, b) {\n var r = true;\n if (reverseAngles) {\n r = a[0][0] < b[0][0];\n }\n else {\n r = a[0][0] > b[0][0];\n }\n return r === false ? -1 : 1;\n };\n },\n // used by edgeSortFunctions\n leftSort = function (a, b) {\n // first get adjusted values\n var p1 = a[0][0] < 0 ? -Math.PI - a[0][0] : Math.PI - a[0][0],\n p2 = b[0][0] < 0 ? -Math.PI - b[0][0] : Math.PI - b[0][0];\n if (p1 > p2) {\n return 1;\n }\n else {\n return -1;\n }\n },\n // used by placeAnchors\n edgeSortFunctions = {\n \"top\": function (a, b) {\n return a[0] > b[0] ? 1 : -1;\n },\n \"right\": currySort(true),\n \"bottom\": currySort(true),\n \"left\": leftSort\n },\n // used by placeAnchors\n _sortHelper = function (_array, _fn) {\n return _array.sort(_fn);\n },\n // used by AnchorManager.redraw\n placeAnchors = function (elementId, _anchorLists) {\n var cd = jsPlumbInstance.getCachedData(elementId), sS = cd.s, sO = cd.o,\n placeSomeAnchors = function (desc, elementDimensions, elementPosition, unsortedConnections, isHorizontal, otherMultiplier, orientation) {\n if (unsortedConnections.length > 0) {\n var sc = _sortHelper(unsortedConnections, edgeSortFunctions[desc]), // puts them in order based on the target element's pos on screen\n reverse = desc === \"right\" || desc === \"top\",\n anchors = placeAnchorsOnLine(desc, elementDimensions,\n elementPosition, sc,\n isHorizontal, otherMultiplier, reverse);\n\n // takes a computed anchor position and adjusts it for parent offset and scroll, then stores it.\n var _setAnchorLocation = function (endpoint, anchorPos) {\n continuousAnchorLocations[endpoint.id] = [ anchorPos[0], anchorPos[1], anchorPos[2], anchorPos[3] ];\n continuousAnchorOrientations[endpoint.id] = orientation;\n };\n\n for (var i = 0; i < anchors.length; i++) {\n var c = anchors[i][4], weAreSource = c.endpoints[0].elementId === elementId, weAreTarget = c.endpoints[1].elementId === elementId;\n if (weAreSource) {\n _setAnchorLocation(c.endpoints[0], anchors[i]);\n }\n if (weAreTarget) {\n _setAnchorLocation(c.endpoints[1], anchors[i]);\n }\n }\n }\n };\n\n placeSomeAnchors(\"bottom\", sS, [sO.left, sO.top], _anchorLists.bottom, true, 1, [0, 1]);\n placeSomeAnchors(\"top\", sS, [sO.left, sO.top], _anchorLists.top, true, 0, [0, -1]);\n placeSomeAnchors(\"left\", sS, [sO.left, sO.top], _anchorLists.left, false, 0, [-1, 0]);\n placeSomeAnchors(\"right\", sS, [sO.left, sO.top], _anchorLists.right, false, 1, [1, 0]);\n };\n\n this.reset = function () {\n _amEndpoints = {};\n connectionsByElementId = {};\n anchorLists = {};\n };\n this.addFloatingConnection = function (key, conn) {\n floatingConnections[key] = conn;\n };\n this.removeFloatingConnection = function (key) {\n delete floatingConnections[key];\n };\n this.newConnection = function (conn) {\n var sourceId = conn.sourceId, targetId = conn.targetId,\n ep = conn.endpoints,\n doRegisterTarget = true,\n registerConnection = function (otherIndex, otherEndpoint, otherAnchor, elId, c) {\n if ((sourceId === targetId) && otherAnchor.isContinuous) {\n // remove the target endpoint's canvas. we dont need it.\n conn._jsPlumb.instance.removeElement(ep[1].canvas);\n doRegisterTarget = false;\n }\n _ju.addToList(connectionsByElementId, elId, [c, otherEndpoint, otherAnchor.constructor === _jp.DynamicAnchor]);\n };\n\n registerConnection(0, ep[0], ep[0].anchor, targetId, conn);\n if (doRegisterTarget) {\n registerConnection(1, ep[1], ep[1].anchor, sourceId, conn);\n }\n };\n var removeEndpointFromAnchorLists = function (endpoint) {\n (function (list, eId) {\n if (list) { // transient anchors dont get entries in this list.\n var f = function (e) {\n return e[4] === eId;\n };\n _ju.removeWithFunction(list.top, f);\n _ju.removeWithFunction(list.left, f);\n _ju.removeWithFunction(list.bottom, f);\n _ju.removeWithFunction(list.right, f);\n }\n })(anchorLists[endpoint.elementId], endpoint.id);\n };\n this.connectionDetached = function (connInfo, doNotRedraw) {\n var connection = connInfo.connection || connInfo,\n sourceId = connInfo.sourceId,\n targetId = connInfo.targetId,\n ep = connection.endpoints,\n removeConnection = function (otherIndex, otherEndpoint, otherAnchor, elId, c) {\n _ju.removeWithFunction(connectionsByElementId[elId], function (_c) {\n return _c[0].id === c.id;\n });\n };\n\n removeConnection(1, ep[1], ep[1].anchor, sourceId, connection);\n removeConnection(0, ep[0], ep[0].anchor, targetId, connection);\n if (connection.floatingId) {\n removeConnection(connection.floatingIndex, connection.floatingEndpoint, connection.floatingEndpoint.anchor, connection.floatingId, connection);\n removeEndpointFromAnchorLists(connection.floatingEndpoint);\n }\n\n // remove from anchorLists\n removeEndpointFromAnchorLists(connection.endpoints[0]);\n removeEndpointFromAnchorLists(connection.endpoints[1]);\n\n if (!doNotRedraw) {\n self.redraw(connection.sourceId);\n if (connection.targetId !== connection.sourceId) {\n self.redraw(connection.targetId);\n }\n }\n };\n this.add = function (endpoint, elementId) {\n _ju.addToList(_amEndpoints, elementId, endpoint);\n };\n this.changeId = function (oldId, newId) {\n connectionsByElementId[newId] = connectionsByElementId[oldId];\n _amEndpoints[newId] = _amEndpoints[oldId];\n delete connectionsByElementId[oldId];\n delete _amEndpoints[oldId];\n };\n this.getConnectionsFor = function (elementId) {\n return connectionsByElementId[elementId] || [];\n };\n this.getEndpointsFor = function (elementId) {\n return _amEndpoints[elementId] || [];\n };\n this.deleteEndpoint = function (endpoint) {\n _ju.removeWithFunction(_amEndpoints[endpoint.elementId], function (e) {\n return e.id === endpoint.id;\n });\n removeEndpointFromAnchorLists(endpoint);\n };\n this.clearFor = function (elementId) {\n delete _amEndpoints[elementId];\n _amEndpoints[elementId] = [];\n };\n // updates the given anchor list by either updating an existing anchor's info, or adding it. this function\n // also removes the anchor from its previous list, if the edge it is on has changed.\n // all connections found along the way (those that are connected to one of the faces this function\n // operates on) are added to the connsToPaint list, as are their endpoints. in this way we know to repaint\n // them wthout having to calculate anything else about them.\n var _updateAnchorList = function (lists, theta, order, conn, aBoolean, otherElId, idx, reverse, edgeId, elId, connsToPaint, endpointsToPaint) {\n // first try to find the exact match, but keep track of the first index of a matching element id along the way.s\n var exactIdx = -1,\n firstMatchingElIdx = -1,\n endpoint = conn.endpoints[idx],\n endpointId = endpoint.id,\n oIdx = [1, 0][idx],\n values = [\n [ theta, order ],\n conn,\n aBoolean,\n otherElId,\n endpointId\n ],\n listToAddTo = lists[edgeId],\n listToRemoveFrom = endpoint._continuousAnchorEdge ? lists[endpoint._continuousAnchorEdge] : null,\n i,\n candidate;\n\n if (listToRemoveFrom) {\n var rIdx = _ju.findWithFunction(listToRemoveFrom, function (e) {\n return e[4] === endpointId;\n });\n if (rIdx !== -1) {\n listToRemoveFrom.splice(rIdx, 1);\n // get all connections from this list\n for (i = 0; i < listToRemoveFrom.length; i++) {\n candidate = listToRemoveFrom[i][1];\n _ju.addWithFunction(connsToPaint, candidate, function (c) {\n return c.id === candidate.id;\n });\n _ju.addWithFunction(endpointsToPaint, listToRemoveFrom[i][1].endpoints[idx], function (e) {\n return e.id === candidate.endpoints[idx].id;\n });\n _ju.addWithFunction(endpointsToPaint, listToRemoveFrom[i][1].endpoints[oIdx], function (e) {\n return e.id === candidate.endpoints[oIdx].id;\n });\n }\n }\n }\n\n for (i = 0; i < listToAddTo.length; i++) {\n candidate = listToAddTo[i][1];\n if (params.idx === 1 && listToAddTo[i][3] === otherElId && firstMatchingElIdx === -1) {\n firstMatchingElIdx = i;\n }\n _ju.addWithFunction(connsToPaint, candidate, function (c) {\n return c.id === candidate.id;\n });\n _ju.addWithFunction(endpointsToPaint, listToAddTo[i][1].endpoints[idx], function (e) {\n return e.id === candidate.endpoints[idx].id;\n });\n _ju.addWithFunction(endpointsToPaint, listToAddTo[i][1].endpoints[oIdx], function (e) {\n return e.id === candidate.endpoints[oIdx].id;\n });\n }\n if (exactIdx !== -1) {\n listToAddTo[exactIdx] = values;\n }\n else {\n var insertIdx = reverse ? firstMatchingElIdx !== -1 ? firstMatchingElIdx : 0 : listToAddTo.length; // of course we will get this from having looked through the array shortly.\n listToAddTo.splice(insertIdx, 0, values);\n }\n\n // store this for next time.\n endpoint._continuousAnchorEdge = edgeId;\n };\n\n //\n // find the entry in an endpoint's list for this connection and update its target endpoint\n // with the current target in the connection.\n // This method and sourceChanged need to be folder into one.\n //\n this.updateOtherEndpoint = function (sourceElId, oldTargetId, newTargetId, connection) {\n var sIndex = _ju.findWithFunction(connectionsByElementId[sourceElId], function (i) {\n return i[0].id === connection.id;\n }),\n tIndex = _ju.findWithFunction(connectionsByElementId[oldTargetId], function (i) {\n return i[0].id === connection.id;\n });\n\n // update or add data for source\n if (sIndex !== -1) {\n connectionsByElementId[sourceElId][sIndex][0] = connection;\n connectionsByElementId[sourceElId][sIndex][1] = connection.endpoints[1];\n connectionsByElementId[sourceElId][sIndex][2] = connection.endpoints[1].anchor.constructor === _jp.DynamicAnchor;\n }\n\n // remove entry for previous target (if there)\n if (tIndex > -1) {\n connectionsByElementId[oldTargetId].splice(tIndex, 1);\n // add entry for new target\n _ju.addToList(connectionsByElementId, newTargetId, [connection, connection.endpoints[0], connection.endpoints[0].anchor.constructor === _jp.DynamicAnchor]);\n }\n\n connection.updateConnectedClass();\n };\n\n //\n // notification that the connection given has changed source from the originalId to the newId.\n // This involves:\n // 1. removing the connection from the list of connections stored for the originalId\n // 2. updating the source information for the target of the connection\n // 3. re-registering the connection in connectionsByElementId with the newId\n //\n this.sourceChanged = function (originalId, newId, connection, newElement) {\n if (originalId !== newId) {\n\n connection.sourceId = newId;\n connection.source = newElement;\n\n // remove the entry that points from the old source to the target\n _ju.removeWithFunction(connectionsByElementId[originalId], function (info) {\n return info[0].id === connection.id;\n });\n // find entry for target and update it\n var tIdx = _ju.findWithFunction(connectionsByElementId[connection.targetId], function (i) {\n return i[0].id === connection.id;\n });\n if (tIdx > -1) {\n connectionsByElementId[connection.targetId][tIdx][0] = connection;\n connectionsByElementId[connection.targetId][tIdx][1] = connection.endpoints[0];\n connectionsByElementId[connection.targetId][tIdx][2] = connection.endpoints[0].anchor.constructor === _jp.DynamicAnchor;\n }\n // add entry for new source\n _ju.addToList(connectionsByElementId, newId, [connection, connection.endpoints[1], connection.endpoints[1].anchor.constructor === _jp.DynamicAnchor]);\n\n // TODO SP not final on this yet. when a user drags an existing connection and it turns into a self\n // loop, then this code hides the target endpoint (by removing it from the DOM) But I think this should\n // occur only if the anchor is Continuous\n if (connection.endpoints[1].anchor.isContinuous) {\n if (connection.source === connection.target) {\n connection._jsPlumb.instance.removeElement(connection.endpoints[1].canvas);\n }\n else {\n if (connection.endpoints[1].canvas.parentNode == null) {\n connection._jsPlumb.instance.appendElement(connection.endpoints[1].canvas);\n }\n }\n }\n\n connection.updateConnectedClass();\n }\n };\n\n //\n // moves the given endpoint from `currentId` to `element`.\n // This involves:\n //\n // 1. changing the key in _amEndpoints under which the endpoint is stored\n // 2. changing the source or target values in all of the endpoint's connections\n // 3. changing the array in connectionsByElementId in which the endpoint's connections\n // are stored (done by either sourceChanged or updateOtherEndpoint)\n //\n this.rehomeEndpoint = function (ep, currentId, element) {\n var eps = _amEndpoints[currentId] || [],\n elementId = jsPlumbInstance.getId(element);\n\n if (elementId !== currentId) {\n var idx = eps.indexOf(ep);\n if (idx > -1) {\n var _ep = eps.splice(idx, 1)[0];\n self.add(_ep, elementId);\n }\n }\n\n for (var i = 0; i < ep.connections.length; i++) {\n if (ep.connections[i].sourceId === currentId) {\n self.sourceChanged(currentId, ep.elementId, ep.connections[i], ep.element);\n }\n else if (ep.connections[i].targetId === currentId) {\n ep.connections[i].targetId = ep.elementId;\n ep.connections[i].target = ep.element;\n self.updateOtherEndpoint(ep.connections[i].sourceId, currentId, ep.elementId, ep.connections[i]);\n }\n }\n };\n\n this.redraw = function (elementId, ui, timestamp, offsetToUI, clearEdits, doNotRecalcEndpoint) {\n\n if (!jsPlumbInstance.isSuspendDrawing()) {\n // get all the endpoints for this element\n var ep = _amEndpoints[elementId] || [],\n endpointConnections = connectionsByElementId[elementId] || [],\n connectionsToPaint = [],\n endpointsToPaint = [],\n anchorsToUpdate = [];\n\n timestamp = timestamp || jsPlumbInstance.timestamp();\n // offsetToUI are values that would have been calculated in the dragManager when registering\n // an endpoint for an element that had a parent (somewhere in the hierarchy) that had been\n // registered as draggable.\n offsetToUI = offsetToUI || {left: 0, top: 0};\n if (ui) {\n ui = {\n left: ui.left + offsetToUI.left,\n top: ui.top + offsetToUI.top\n };\n }\n\n // valid for one paint cycle.\n var myOffset = jsPlumbInstance.updateOffset({ elId: elementId, offset: ui, recalc: false, timestamp: timestamp }),\n orientationCache = {};\n\n // actually, first we should compute the orientation of this element to all other elements to which\n // this element is connected with a continuous anchor (whether both ends of the connection have\n // a continuous anchor or just one)\n\n for (var i = 0; i < endpointConnections.length; i++) {\n var conn = endpointConnections[i][0],\n sourceId = conn.sourceId,\n targetId = conn.targetId,\n sourceContinuous = conn.endpoints[0].anchor.isContinuous,\n targetContinuous = conn.endpoints[1].anchor.isContinuous;\n\n if (sourceContinuous || targetContinuous) {\n var oKey = sourceId + \"_\" + targetId,\n o = orientationCache[oKey],\n oIdx = conn.sourceId === elementId ? 1 : 0;\n\n if (sourceContinuous && !anchorLists[sourceId]) {\n anchorLists[sourceId] = { top: [], right: [], bottom: [], left: [] };\n }\n if (targetContinuous && !anchorLists[targetId]) {\n anchorLists[targetId] = { top: [], right: [], bottom: [], left: [] };\n }\n\n if (elementId !== targetId) {\n jsPlumbInstance.updateOffset({ elId: targetId, timestamp: timestamp });\n }\n if (elementId !== sourceId) {\n jsPlumbInstance.updateOffset({ elId: sourceId, timestamp: timestamp });\n }\n\n var td = jsPlumbInstance.getCachedData(targetId),\n sd = jsPlumbInstance.getCachedData(sourceId);\n\n if (targetId === sourceId && (sourceContinuous || targetContinuous)) {\n // here we may want to improve this by somehow determining the face we'd like\n // to put the connector on. ideally, when drawing, the face should be calculated\n // by determining which face is closest to the point at which the mouse button\n // was released. for now, we're putting it on the top face.\n _updateAnchorList( anchorLists[sourceId], -Math.PI / 2, 0, conn, false, targetId, 0, false, \"top\", sourceId, connectionsToPaint, endpointsToPaint);\n _updateAnchorList( anchorLists[targetId], -Math.PI / 2, 0, conn, false, sourceId, 1, false, \"top\", targetId, connectionsToPaint, endpointsToPaint);\n }\n else {\n if (!o) {\n o = this.calculateOrientation(sourceId, targetId, sd.o, td.o, conn.endpoints[0].anchor, conn.endpoints[1].anchor, conn);\n orientationCache[oKey] = o;\n // this would be a performance enhancement, but the computed angles need to be clamped to\n //the (-PI/2 -> PI/2) range in order for the sorting to work properly.\n /* orientationCache[oKey2] = {\n orientation:o.orientation,\n a:[o.a[1], o.a[0]],\n theta:o.theta + Math.PI,\n theta2:o.theta2 + Math.PI\n };*/\n }\n if (sourceContinuous) {\n _updateAnchorList(anchorLists[sourceId], o.theta, 0, conn, false, targetId, 0, false, o.a[0], sourceId, connectionsToPaint, endpointsToPaint);\n }\n if (targetContinuous) {\n _updateAnchorList(anchorLists[targetId], o.theta2, -1, conn, true, sourceId, 1, true, o.a[1], targetId, connectionsToPaint, endpointsToPaint);\n }\n }\n\n if (sourceContinuous) {\n _ju.addWithFunction(anchorsToUpdate, sourceId, function (a) {\n return a === sourceId;\n });\n }\n if (targetContinuous) {\n _ju.addWithFunction(anchorsToUpdate, targetId, function (a) {\n return a === targetId;\n });\n }\n _ju.addWithFunction(connectionsToPaint, conn, function (c) {\n return c.id === conn.id;\n });\n if ((sourceContinuous && oIdx === 0) || (targetContinuous && oIdx === 1)) {\n _ju.addWithFunction(endpointsToPaint, conn.endpoints[oIdx], function (e) {\n return e.id === conn.endpoints[oIdx].id;\n });\n }\n }\n }\n\n // place Endpoints whose anchors are continuous but have no Connections\n for (i = 0; i < ep.length; i++) {\n if (ep[i].connections.length === 0 && ep[i].anchor.isContinuous) {\n if (!anchorLists[elementId]) {\n anchorLists[elementId] = { top: [], right: [], bottom: [], left: [] };\n }\n _updateAnchorList(anchorLists[elementId], -Math.PI / 2, 0, {endpoints: [ep[i], ep[i]], paint: function () {\n }}, false, elementId, 0, false, ep[i].anchor.getDefaultFace(), elementId, connectionsToPaint, endpointsToPaint);\n _ju.addWithFunction(anchorsToUpdate, elementId, function (a) {\n return a === elementId;\n });\n }\n }\n\n // now place all the continuous anchors we need to;\n for (i = 0; i < anchorsToUpdate.length; i++) {\n placeAnchors(anchorsToUpdate[i], anchorLists[anchorsToUpdate[i]]);\n }\n\n // now that continuous anchors have been placed, paint all the endpoints for this element\n for (i = 0; i < ep.length; i++) {\n ep[i].paint({ timestamp: timestamp, offset: myOffset, dimensions: myOffset.s, recalc: doNotRecalcEndpoint !== true });\n }\n\n // ... and any other endpoints we came across as a result of the continuous anchors.\n for (i = 0; i < endpointsToPaint.length; i++) {\n var cd = jsPlumbInstance.getCachedData(endpointsToPaint[i].elementId);\n //endpointsToPaint[i].paint({ timestamp: timestamp, offset: cd, dimensions: cd.s });\n endpointsToPaint[i].paint({ timestamp: null, offset: cd, dimensions: cd.s });\n }\n\n // paint all the standard and \"dynamic connections\", which are connections whose other anchor is\n // static and therefore does need to be recomputed; we make sure that happens only one time.\n\n // TODO we could have compiled a list of these in the first pass through connections; might save some time.\n for (i = 0; i < endpointConnections.length; i++) {\n var otherEndpoint = endpointConnections[i][1];\n if (otherEndpoint.anchor.constructor === _jp.DynamicAnchor) {\n otherEndpoint.paint({ elementWithPrecedence: elementId, timestamp: timestamp });\n _ju.addWithFunction(connectionsToPaint, endpointConnections[i][0], function (c) {\n return c.id === endpointConnections[i][0].id;\n });\n // all the connections for the other endpoint now need to be repainted\n for (var k = 0; k < otherEndpoint.connections.length; k++) {\n if (otherEndpoint.connections[k] !== endpointConnections[i][0]) {\n _ju.addWithFunction(connectionsToPaint, otherEndpoint.connections[k], function (c) {\n return c.id === otherEndpoint.connections[k].id;\n });\n }\n }\n } else {\n _ju.addWithFunction(connectionsToPaint, endpointConnections[i][0], function (c) {\n return c.id === endpointConnections[i][0].id;\n });\n }\n }\n\n // paint current floating connection for this element, if there is one.\n var fc = floatingConnections[elementId];\n if (fc) {\n fc.paint({timestamp: timestamp, recalc: false, elId: elementId});\n }\n\n // paint all the connections\n for (i = 0; i < connectionsToPaint.length; i++) {\n connectionsToPaint[i].paint({elId: elementId, timestamp: null, recalc: false, clearEdits: clearEdits});\n }\n }\n };\n\n var ContinuousAnchor = function (anchorParams) {\n _ju.EventGenerator.apply(this);\n this.type = \"Continuous\";\n this.isDynamic = true;\n this.isContinuous = true;\n var faces = anchorParams.faces || [\"top\", \"right\", \"bottom\", \"left\"],\n clockwise = !(anchorParams.clockwise === false),\n availableFaces = { },\n opposites = { \"top\": \"bottom\", \"right\": \"left\", \"left\": \"right\", \"bottom\": \"top\" },\n clockwiseOptions = { \"top\": \"right\", \"right\": \"bottom\", \"left\": \"top\", \"bottom\": \"left\" },\n antiClockwiseOptions = { \"top\": \"left\", \"right\": \"top\", \"left\": \"bottom\", \"bottom\": \"right\" },\n secondBest = clockwise ? clockwiseOptions : antiClockwiseOptions,\n lastChoice = clockwise ? antiClockwiseOptions : clockwiseOptions,\n cssClass = anchorParams.cssClass || \"\",\n _currentFace = null, _lockedFace = null, X_AXIS_FACES = [\"left\", \"right\"], Y_AXIS_FACES = [\"top\", \"bottom\"],\n _lockedAxis = null;\n\n for (var i = 0; i < faces.length; i++) {\n availableFaces[faces[i]] = true;\n }\n\n this.getDefaultFace = function () {\n return faces.length === 0 ? \"top\" : faces[0];\n };\n\n this.isRelocatable = function() { return true; };\n this.isSnapOnRelocate = function() { return true; };\n\n // if the given edge is supported, returns it. otherwise looks for a substitute that _is_\n // supported. if none supported we also return the request edge.\n this.verifyEdge = function (edge) {\n if (availableFaces[edge]) {\n return edge;\n }\n else if (availableFaces[opposites[edge]]) {\n return opposites[edge];\n }\n else if (availableFaces[secondBest[edge]]) {\n return secondBest[edge];\n }\n else if (availableFaces[lastChoice[edge]]) {\n return lastChoice[edge];\n }\n return edge; // we have to give them something.\n };\n\n this.isEdgeSupported = function (edge) {\n return _lockedAxis == null ?\n\n (_lockedFace == null ? availableFaces[edge] === true : _lockedFace === edge)\n\n : _lockedAxis.indexOf(edge) !== -1;\n };\n\n this.setCurrentFace = function(face, overrideLock) {\n _currentFace = face;\n // if currently locked, and the user wants to override, do that.\n if (overrideLock && _lockedFace != null) {\n _lockedFace = _currentFace;\n }\n };\n\n this.getCurrentFace = function() { return _currentFace; };\n this.getSupportedFaces = function() {\n var af = [];\n for (var k in availableFaces) {\n if (availableFaces[k]) {\n af.push(k);\n }\n }\n return af;\n };\n\n this.lock = function() {\n _lockedFace = _currentFace;\n };\n this.unlock = function() {\n _lockedFace = null;\n };\n this.isLocked = function() {\n return _lockedFace != null;\n };\n\n this.lockCurrentAxis = function() {\n if (_currentFace != null) {\n _lockedAxis = (_currentFace === \"left\" || _currentFace === \"right\") ? X_AXIS_FACES : Y_AXIS_FACES;\n }\n };\n\n this.unlockCurrentAxis = function() {\n _lockedAxis = null;\n };\n\n this.compute = function (params) {\n return continuousAnchorLocations[params.element.id] || [0, 0];\n };\n this.getCurrentLocation = function (params) {\n return continuousAnchorLocations[params.element.id] || [0, 0];\n };\n this.getOrientation = function (endpoint) {\n return continuousAnchorOrientations[endpoint.id] || [0, 0];\n };\n this.getCssClass = function () {\n return cssClass;\n };\n };\n\n // continuous anchors\n jsPlumbInstance.continuousAnchorFactory = {\n get: function (params) {\n return new ContinuousAnchor(params);\n },\n clear: function (elementId) {\n delete continuousAnchorLocations[elementId];\n }\n };\n };\n\n _jp.AnchorManager.prototype.calculateOrientation = function (sourceId, targetId, sd, td, sourceAnchor, targetAnchor) {\n\n var Orientation = { HORIZONTAL: \"horizontal\", VERTICAL: \"vertical\", DIAGONAL: \"diagonal\", IDENTITY: \"identity\" },\n axes = [\"left\", \"top\", \"right\", \"bottom\"];\n\n if (sourceId === targetId) {\n return {\n orientation: Orientation.IDENTITY,\n a: [\"top\", \"top\"]\n };\n }\n\n var theta = Math.atan2((td.centery - sd.centery), (td.centerx - sd.centerx)),\n theta2 = Math.atan2((sd.centery - td.centery), (sd.centerx - td.centerx));\n\n// --------------------------------------------------------------------------------------\n\n // improved face calculation. get midpoints of each face for source and target, then put in an array with all combinations of\n // source/target faces. sort this array by distance between midpoints. the entry at index 0 is our preferred option. we can\n // go through the array one by one until we find an entry in which each requested face is supported.\n var candidates = [], midpoints = { };\n (function (types, dim) {\n for (var i = 0; i < types.length; i++) {\n midpoints[types[i]] = {\n \"left\": [ dim[i].left, dim[i].centery ],\n \"right\": [ dim[i].right, dim[i].centery ],\n \"top\": [ dim[i].centerx, dim[i].top ],\n \"bottom\": [ dim[i].centerx , dim[i].bottom]\n };\n }\n })([ \"source\", \"target\" ], [ sd, td ]);\n\n for (var sf = 0; sf < axes.length; sf++) {\n for (var tf = 0; tf < axes.length; tf++) {\n candidates.push({\n source: axes[sf],\n target: axes[tf],\n dist: Biltong.lineLength(midpoints.source[axes[sf]], midpoints.target[axes[tf]])\n });\n }\n }\n\n candidates.sort(function (a, b) {\n return a.dist < b.dist ? -1 : a.dist > b.dist ? 1 : 0;\n });\n\n // now go through this list and try to get an entry that satisfies both (there will be one, unless one of the anchors\n // declares no available faces)\n var sourceEdge = candidates[0].source, targetEdge = candidates[0].target;\n for (var i = 0; i < candidates.length; i++) {\n\n if (!sourceAnchor.isContinuous || sourceAnchor.isEdgeSupported(candidates[i].source)) {\n sourceEdge = candidates[i].source;\n }\n else {\n sourceEdge = null;\n }\n\n if (!targetAnchor.isContinuous || targetAnchor.isEdgeSupported(candidates[i].target)) {\n targetEdge = candidates[i].target;\n }\n else {\n targetEdge = null;\n }\n\n if (sourceEdge != null && targetEdge != null) {\n break;\n }\n }\n\n if (sourceAnchor.isContinuous) {\n sourceAnchor.setCurrentFace(sourceEdge);\n }\n\n if (targetAnchor.isContinuous) {\n targetAnchor.setCurrentFace(targetEdge);\n }\n\n// --------------------------------------------------------------------------------------\n\n return {\n a: [ sourceEdge, targetEdge ],\n theta: theta,\n theta2: theta2\n };\n };\n\n /**\n * Anchors model a position on some element at which an Endpoint may be located. They began as a first class citizen of jsPlumb, ie. a user\n * was required to create these themselves, but over time this has been replaced by the concept of referring to them either by name (eg. \"TopMiddle\"),\n * or by an array describing their coordinates (eg. [ 0, 0.5, 0, -1 ], which is the same as \"TopMiddle\"). jsPlumb now handles all of the\n * creation of Anchors without user intervention.\n */\n _jp.Anchor = function (params) {\n this.x = params.x || 0;\n this.y = params.y || 0;\n this.elementId = params.elementId;\n this.cssClass = params.cssClass || \"\";\n this.userDefinedLocation = null;\n this.orientation = params.orientation || [ 0, 0 ];\n this.lastReturnValue = null;\n this.offsets = params.offsets || [ 0, 0 ];\n this.timestamp = null;\n\n var relocatable = params.relocatable !== false;\n this.isRelocatable = function() { return relocatable; };\n this.setRelocatable = function(_relocatable) { relocatable = _relocatable; };\n var snapOnRelocate = params.snapOnRelocate !== false;\n this.isSnapOnRelocate = function() { return snapOnRelocate; };\n\n var locked = false;\n this.lock = function() { locked = true; };\n this.unlock = function() { locked = false; };\n this.isLocked = function() { return locked; };\n\n _ju.EventGenerator.apply(this);\n\n this.compute = function (params) {\n\n var xy = params.xy, wh = params.wh, timestamp = params.timestamp;\n\n if (params.clearUserDefinedLocation) {\n this.userDefinedLocation = null;\n }\n\n if (timestamp && timestamp === this.timestamp) {\n return this.lastReturnValue;\n }\n\n if (this.userDefinedLocation != null) {\n this.lastReturnValue = this.userDefinedLocation;\n }\n else {\n this.lastReturnValue = [ xy[0] + (this.x * wh[0]) + this.offsets[0], xy[1] + (this.y * wh[1]) + this.offsets[1], this.x, this.y ];\n }\n\n this.timestamp = timestamp;\n return this.lastReturnValue;\n };\n\n this.getCurrentLocation = function (params) {\n params = params || {};\n return (this.lastReturnValue == null || (params.timestamp != null && this.timestamp !== params.timestamp)) ? this.compute(params) : this.lastReturnValue;\n };\n\n this.setPosition = function(x, y, ox, oy, overrideLock) {\n if (!locked || overrideLock) {\n this.x = x;\n this.y = y;\n this.orientation = [ ox, oy ];\n this.lastReturnValue = null;\n }\n };\n };\n _ju.extend(_jp.Anchor, _ju.EventGenerator, {\n equals: function (anchor) {\n if (!anchor) {\n return false;\n }\n var ao = anchor.getOrientation(),\n o = this.getOrientation();\n return this.x === anchor.x && this.y === anchor.y && this.offsets[0] === anchor.offsets[0] && this.offsets[1] === anchor.offsets[1] && o[0] === ao[0] && o[1] === ao[1];\n },\n getUserDefinedLocation: function () {\n return this.userDefinedLocation;\n },\n setUserDefinedLocation: function (l) {\n this.userDefinedLocation = l;\n },\n clearUserDefinedLocation: function () {\n this.userDefinedLocation = null;\n },\n getOrientation: function () {\n return this.orientation;\n },\n getCssClass: function () {\n return this.cssClass;\n }\n });\n\n /**\n * An Anchor that floats. its orientation is computed dynamically from\n * its position relative to the anchor it is floating relative to. It is used when creating\n * a connection through drag and drop.\n *\n * TODO FloatingAnchor could totally be refactored to extend Anchor just slightly.\n */\n _jp.FloatingAnchor = function (params) {\n\n _jp.Anchor.apply(this, arguments);\n\n // this is the anchor that this floating anchor is referenced to for\n // purposes of calculating the orientation.\n var ref = params.reference,\n // the canvas this refers to.\n refCanvas = params.referenceCanvas,\n size = _jp.getSize(refCanvas),\n // these are used to store the current relative position of our\n // anchor wrt the reference anchor. they only indicate\n // direction, so have a value of 1 or -1 (or, very rarely, 0). these\n // values are written by the compute method, and read\n // by the getOrientation method.\n xDir = 0, yDir = 0,\n // temporary member used to store an orientation when the floating\n // anchor is hovering over another anchor.\n orientation = null,\n _lastResult = null;\n\n // clear from parent. we want floating anchor orientation to always be computed.\n this.orientation = null;\n\n // set these to 0 each; they are used by certain types of connectors in the loopback case,\n // when the connector is trying to clear the element it is on. but for floating anchor it's not\n // very important.\n this.x = 0;\n this.y = 0;\n\n this.isFloating = true;\n\n this.compute = function (params) {\n var xy = params.xy,\n result = [ xy[0] + (size[0] / 2), xy[1] + (size[1] / 2) ]; // return origin of the element. we may wish to improve this so that any object can be the drag proxy.\n _lastResult = result;\n return result;\n };\n\n this.getOrientation = function (_endpoint) {\n if (orientation) {\n return orientation;\n }\n else {\n var o = ref.getOrientation(_endpoint);\n // here we take into account the orientation of the other\n // anchor: if it declares zero for some direction, we declare zero too. this might not be the most awesome. perhaps we can come\n // up with a better way. it's just so that the line we draw looks like it makes sense. maybe this wont make sense.\n return [ Math.abs(o[0]) * xDir * -1,\n Math.abs(o[1]) * yDir * -1 ];\n }\n };\n\n /**\n * notification the endpoint associated with this anchor is hovering\n * over another anchor; we want to assume that anchor's orientation\n * for the duration of the hover.\n */\n this.over = function (anchor, endpoint) {\n orientation = anchor.getOrientation(endpoint);\n };\n\n /**\n * notification the endpoint associated with this anchor is no\n * longer hovering over another anchor; we should resume calculating\n * orientation as we normally do.\n */\n this.out = function () {\n orientation = null;\n };\n\n this.getCurrentLocation = function (params) {\n return _lastResult == null ? this.compute(params) : _lastResult;\n };\n };\n _ju.extend(_jp.FloatingAnchor, _jp.Anchor);\n\n var _convertAnchor = function (anchor, jsPlumbInstance, elementId) {\n return anchor.constructor === _jp.Anchor ? anchor : jsPlumbInstance.makeAnchor(anchor, elementId, jsPlumbInstance);\n };\n\n /* \n * A DynamicAnchor is an Anchor that contains a list of other Anchors, which it cycles\n * through at compute time to find the one that is located closest to\n * the center of the target element, and returns that Anchor's compute\n * method result. this causes endpoints to follow each other with\n * respect to the orientation of their target elements, which is a useful\n * feature for some applications.\n * \n */\n _jp.DynamicAnchor = function (params) {\n _jp.Anchor.apply(this, arguments);\n\n this.isDynamic = true;\n this.anchors = [];\n this.elementId = params.elementId;\n this.jsPlumbInstance = params.jsPlumbInstance;\n\n for (var i = 0; i < params.anchors.length; i++) {\n this.anchors[i] = _convertAnchor(params.anchors[i], this.jsPlumbInstance, this.elementId);\n }\n\n this.getAnchors = function () {\n return this.anchors;\n };\n\n var _curAnchor = this.anchors.length > 0 ? this.anchors[0] : null,\n _lastAnchor = _curAnchor,\n self = this,\n\n // helper method to calculate the distance between the centers of the two elements.\n _distance = function (anchor, cx, cy, xy, wh) {\n var ax = xy[0] + (anchor.x * wh[0]), ay = xy[1] + (anchor.y * wh[1]),\n acx = xy[0] + (wh[0] / 2), acy = xy[1] + (wh[1] / 2);\n return (Math.sqrt(Math.pow(cx - ax, 2) + Math.pow(cy - ay, 2)) +\n Math.sqrt(Math.pow(acx - ax, 2) + Math.pow(acy - ay, 2)));\n },\n // default method uses distance between element centers. you can provide your own method in the dynamic anchor\n // constructor (and also to jsPlumb.makeDynamicAnchor). the arguments to it are four arrays:\n // xy - xy loc of the anchor's element\n // wh - anchor's element's dimensions\n // txy - xy loc of the element of the other anchor in the connection\n // twh - dimensions of the element of the other anchor in the connection.\n // anchors - the list of selectable anchors\n _anchorSelector = params.selector || function (xy, wh, txy, twh, anchors) {\n var cx = txy[0] + (twh[0] / 2), cy = txy[1] + (twh[1] / 2);\n var minIdx = -1, minDist = Infinity;\n for (var i = 0; i < anchors.length; i++) {\n var d = _distance(anchors[i], cx, cy, xy, wh);\n if (d < minDist) {\n minIdx = i + 0;\n minDist = d;\n }\n }\n return anchors[minIdx];\n };\n\n this.compute = function (params) {\n var xy = params.xy, wh = params.wh, txy = params.txy, twh = params.twh;\n\n this.timestamp = params.timestamp;\n\n var udl = self.getUserDefinedLocation();\n if (udl != null) {\n return udl;\n }\n\n // if anchor is locked or an opposite element was not given, we\n // maintain our state. anchor will be locked\n // if it is the source of a drag and drop.\n if (this.isLocked() || txy == null || twh == null) {\n return _curAnchor.compute(params);\n }\n else {\n params.timestamp = null; // otherwise clear this, i think. we want the anchor to compute.\n }\n\n _curAnchor = _anchorSelector(xy, wh, txy, twh, this.anchors);\n this.x = _curAnchor.x;\n this.y = _curAnchor.y;\n\n if (_curAnchor !== _lastAnchor) {\n this.fire(\"anchorChanged\", _curAnchor);\n }\n\n _lastAnchor = _curAnchor;\n\n return _curAnchor.compute(params);\n };\n\n this.getCurrentLocation = function (params) {\n return this.getUserDefinedLocation() || (_curAnchor != null ? _curAnchor.getCurrentLocation(params) : null);\n };\n\n this.getOrientation = function (_endpoint) {\n return _curAnchor != null ? _curAnchor.getOrientation(_endpoint) : [ 0, 0 ];\n };\n this.over = function (anchor, endpoint) {\n if (_curAnchor != null) {\n _curAnchor.over(anchor, endpoint);\n }\n };\n this.out = function () {\n if (_curAnchor != null) {\n _curAnchor.out();\n }\n };\n\n this.setAnchor = function(a) {\n _curAnchor = a;\n };\n\n this.getCssClass = function () {\n return (_curAnchor && _curAnchor.getCssClass()) || \"\";\n };\n\n /**\n * Attempt to match an anchor with the given coordinates and then set it.\n * @param coords\n * @returns true if matching anchor found, false otherwise.\n */\n this.setAnchorCoordinates = function(coords) {\n var idx = jsPlumbUtil.findWithFunction(this.anchors, function(a) {\n return a.x === coords[0] && a.y === coords[1];\n });\n if (idx !== -1) {\n this.setAnchor(this.anchors[idx]);\n return true;\n } else {\n return false;\n }\n };\n };\n _ju.extend(_jp.DynamicAnchor, _jp.Anchor);\n\n// -------- basic anchors ------------------ \n var _curryAnchor = function (x, y, ox, oy, type, fnInit) {\n _jp.Anchors[type] = function (params) {\n var a = params.jsPlumbInstance.makeAnchor([ x, y, ox, oy, 0, 0 ], params.elementId, params.jsPlumbInstance);\n a.type = type;\n if (fnInit) {\n fnInit(a, params);\n }\n return a;\n };\n };\n\n _curryAnchor(0.5, 0, 0, -1, \"TopCenter\");\n _curryAnchor(0.5, 1, 0, 1, \"BottomCenter\");\n _curryAnchor(0, 0.5, -1, 0, \"LeftMiddle\");\n _curryAnchor(1, 0.5, 1, 0, \"RightMiddle\");\n\n _curryAnchor(0.5, 0, 0, -1, \"Top\");\n _curryAnchor(0.5, 1, 0, 1, \"Bottom\");\n _curryAnchor(0, 0.5, -1, 0, \"Left\");\n _curryAnchor(1, 0.5, 1, 0, \"Right\");\n _curryAnchor(0.5, 0.5, 0, 0, \"Center\");\n _curryAnchor(1, 0, 0, -1, \"TopRight\");\n _curryAnchor(1, 1, 0, 1, \"BottomRight\");\n _curryAnchor(0, 0, 0, -1, \"TopLeft\");\n _curryAnchor(0, 1, 0, 1, \"BottomLeft\");\n\n// ------- dynamic anchors ------------------- \n\n // default dynamic anchors chooses from Top, Right, Bottom, Left\n _jp.Defaults.DynamicAnchors = function (params) {\n return params.jsPlumbInstance.makeAnchors([\"TopCenter\", \"RightMiddle\", \"BottomCenter\", \"LeftMiddle\"], params.elementId, params.jsPlumbInstance);\n };\n\n // default dynamic anchors bound to name 'AutoDefault'\n _jp.Anchors.AutoDefault = function (params) {\n var a = params.jsPlumbInstance.makeDynamicAnchor(_jp.Defaults.DynamicAnchors(params));\n a.type = \"AutoDefault\";\n return a;\n };\n\n// ------- continuous anchors ------------------- \n\n var _curryContinuousAnchor = function (type, faces) {\n _jp.Anchors[type] = function (params) {\n var a = params.jsPlumbInstance.makeAnchor([\"Continuous\", { faces: faces }], params.elementId, params.jsPlumbInstance);\n a.type = type;\n return a;\n };\n };\n\n _jp.Anchors.Continuous = function (params) {\n return params.jsPlumbInstance.continuousAnchorFactory.get(params);\n };\n\n _curryContinuousAnchor(\"ContinuousLeft\", [\"left\"]);\n _curryContinuousAnchor(\"ContinuousTop\", [\"top\"]);\n _curryContinuousAnchor(\"ContinuousBottom\", [\"bottom\"]);\n _curryContinuousAnchor(\"ContinuousRight\", [\"right\"]);\n\n// ------- position assign anchors ------------------- \n\n // this anchor type lets you assign the position at connection time.\n _curryAnchor(0, 0, 0, 0, \"Assign\", function (anchor, params) {\n // find what to use as the \"position finder\". the user may have supplied a String which represents\n // the id of a position finder in jsPlumb.AnchorPositionFinders, or the user may have supplied the\n // position finder as a function. we find out what to use and then set it on the anchor.\n var pf = params.position || \"Fixed\";\n anchor.positionFinder = pf.constructor === String ? params.jsPlumbInstance.AnchorPositionFinders[pf] : pf;\n // always set the constructor params; the position finder might need them later (the Grid one does,\n // for example)\n anchor.constructorParams = params;\n });\n\n // these are the default anchor positions finders, which are used by the makeTarget function. supplying\n // a position finder argument to that function allows you to specify where the resulting anchor will\n // be located\n root.jsPlumbInstance.prototype.AnchorPositionFinders = {\n \"Fixed\": function (dp, ep, es) {\n return [ (dp.left - ep.left) / es[0], (dp.top - ep.top) / es[1] ];\n },\n \"Grid\": function (dp, ep, es, params) {\n var dx = dp.left - ep.left, dy = dp.top - ep.top,\n gx = es[0] / (params.grid[0]), gy = es[1] / (params.grid[1]),\n mx = Math.floor(dx / gx), my = Math.floor(dy / gy);\n return [ ((mx * gx) + (gx / 2)) / es[0], ((my * gy) + (gy / 2)) / es[1] ];\n }\n };\n\n// ------- perimeter anchors ------------------- \n\n _jp.Anchors.Perimeter = function (params) {\n params = params || {};\n var anchorCount = params.anchorCount || 60,\n shape = params.shape;\n\n if (!shape) {\n throw new Error(\"no shape supplied to Perimeter Anchor type\");\n }\n\n var _circle = function () {\n var r = 0.5, step = Math.PI * 2 / anchorCount, current = 0, a = [];\n for (var i = 0; i < anchorCount; i++) {\n var x = r + (r * Math.sin(current)),\n y = r + (r * Math.cos(current));\n a.push([ x, y, 0, 0 ]);\n current += step;\n }\n return a;\n },\n _path = function (segments) {\n var anchorsPerFace = anchorCount / segments.length, a = [],\n _computeFace = function (x1, y1, x2, y2, fractionalLength) {\n anchorsPerFace = anchorCount * fractionalLength;\n var dx = (x2 - x1) / anchorsPerFace, dy = (y2 - y1) / anchorsPerFace;\n for (var i = 0; i < anchorsPerFace; i++) {\n a.push([\n x1 + (dx * i),\n y1 + (dy * i),\n 0,\n 0\n ]);\n }\n };\n\n for (var i = 0; i < segments.length; i++) {\n _computeFace.apply(null, segments[i]);\n }\n\n return a;\n },\n _shape = function (faces) {\n var s = [];\n for (var i = 0; i < faces.length; i++) {\n s.push([faces[i][0], faces[i][1], faces[i][2], faces[i][3], 1 / faces.length]);\n }\n return _path(s);\n },\n _rectangle = function () {\n return _shape([\n [ 0, 0, 1, 0 ],\n [ 1, 0, 1, 1 ],\n [ 1, 1, 0, 1 ],\n [ 0, 1, 0, 0 ]\n ]);\n };\n\n var _shapes = {\n \"Circle\": _circle,\n \"Ellipse\": _circle,\n \"Diamond\": function () {\n return _shape([\n [ 0.5, 0, 1, 0.5 ],\n [ 1, 0.5, 0.5, 1 ],\n [ 0.5, 1, 0, 0.5 ],\n [ 0, 0.5, 0.5, 0 ]\n ]);\n },\n \"Rectangle\": _rectangle,\n \"Square\": _rectangle,\n \"Triangle\": function () {\n return _shape([\n [ 0.5, 0, 1, 1 ],\n [ 1, 1, 0, 1 ],\n [ 0, 1, 0.5, 0]\n ]);\n },\n \"Path\": function (params) {\n var points = params.points, p = [], tl = 0;\n for (var i = 0; i < points.length - 1; i++) {\n var l = Math.sqrt(Math.pow(points[i][2] - points[i][0]) + Math.pow(points[i][3] - points[i][1]));\n tl += l;\n p.push([points[i][0], points[i][1], points[i + 1][0], points[i + 1][1], l]);\n }\n for (var j = 0; j < p.length; j++) {\n p[j][4] = p[j][4] / tl;\n }\n return _path(p);\n }\n },\n _rotate = function (points, amountInDegrees) {\n var o = [], theta = amountInDegrees / 180 * Math.PI;\n for (var i = 0; i < points.length; i++) {\n var _x = points[i][0] - 0.5,\n _y = points[i][1] - 0.5;\n\n o.push([\n 0.5 + ((_x * Math.cos(theta)) - (_y * Math.sin(theta))),\n 0.5 + ((_x * Math.sin(theta)) + (_y * Math.cos(theta))),\n points[i][2],\n points[i][3]\n ]);\n }\n return o;\n };\n\n if (!_shapes[shape]) {\n throw new Error(\"Shape [\" + shape + \"] is unknown by Perimeter Anchor type\");\n }\n\n var da = _shapes[shape](params);\n if (params.rotation) {\n da = _rotate(da, params.rotation);\n }\n var a = params.jsPlumbInstance.makeDynamicAnchor(da);\n a.type = \"Perimeter\";\n return a;\n };\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains the default Connectors, Endpoint and Overlay definitions.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n * \n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n * \n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil, _jg = root.Biltong;\n\n _jp.Segments = {\n\n /*\n * Class: AbstractSegment\n * A Connector is made up of 1..N Segments, each of which has a Type, such as 'Straight', 'Arc',\n * 'Bezier'. This is new from 1.4.2, and gives us a lot more flexibility when drawing connections: things such\n * as rounded corners for flowchart connectors, for example, or a straight line stub for Bezier connections, are\n * much easier to do now.\n *\n * A Segment is responsible for providing coordinates for painting it, and also must be able to report its length.\n * \n */\n AbstractSegment: function (params) {\n this.params = params;\n\n /**\n * Function: findClosestPointOnPath\n * Finds the closest point on this segment to the given [x, y],\n * returning both the x and y of the point plus its distance from\n * the supplied point, and its location along the length of the\n * path inscribed by the segment. This implementation returns\n * Infinity for distance and null values for everything else;\n * subclasses are expected to override.\n */\n this.findClosestPointOnPath = function (x, y) {\n return {\n d: Infinity,\n x: null,\n y: null,\n l: null\n };\n };\n\n this.getBounds = function () {\n return {\n minX: Math.min(params.x1, params.x2),\n minY: Math.min(params.y1, params.y2),\n maxX: Math.max(params.x1, params.x2),\n maxY: Math.max(params.y1, params.y2)\n };\n };\n\n /**\n * Computes the list of points on the segment that intersect the given line.\n * @method lineIntersection\n * @param {number} x1\n * @param {number} y1\n * @param {number} x2\n * @param {number} y2\n * @returns {Array<[number, number]>}\n */\n this.lineIntersection = function(x1, y1, x2, y2) {\n return [];\n };\n\n /**\n * Computes the list of points on the segment that intersect the box with the given origin and size.\n * @method boxIntersection\n * @param {number} x1\n * @param {number} y1\n * @param {number} w\n * @param {number} h\n * @returns {Array<[number, number]>}\n */\n this.boxIntersection = function(x, y, w, h) {\n var a = [];\n a.push.apply(a, this.lineIntersection(x, y, x + w, y));\n a.push.apply(a, this.lineIntersection(x + w, y, x + w, y + h));\n a.push.apply(a, this.lineIntersection(x + w, y + h, x, y + h));\n a.push.apply(a, this.lineIntersection(x, y + h, x, y));\n return a;\n };\n\n /**\n * Computes the list of points on the segment that intersect the given bounding box, which is an object of the form { x:.., y:.., w:.., h:.. }.\n * @method lineIntersection\n * @param {BoundingRectangle} box\n * @returns {Array<[number, number]>}\n */\n this.boundingBoxIntersection = function(box) {\n return this.boxIntersection(box.x, box.y, box.w, box.y);\n };\n },\n Straight: function (params) {\n var _super = _jp.Segments.AbstractSegment.apply(this, arguments),\n length, m, m2, x1, x2, y1, y2,\n _recalc = function () {\n length = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));\n m = _jg.gradient({x: x1, y: y1}, {x: x2, y: y2});\n m2 = -1 / m;\n };\n\n this.type = \"Straight\";\n\n this.getLength = function () {\n return length;\n };\n this.getGradient = function () {\n return m;\n };\n\n this.getCoordinates = function () {\n return { x1: x1, y1: y1, x2: x2, y2: y2 };\n };\n this.setCoordinates = function (coords) {\n x1 = coords.x1;\n y1 = coords.y1;\n x2 = coords.x2;\n y2 = coords.y2;\n _recalc();\n };\n this.setCoordinates({x1: params.x1, y1: params.y1, x2: params.x2, y2: params.y2});\n\n this.getBounds = function () {\n return {\n minX: Math.min(x1, x2),\n minY: Math.min(y1, y2),\n maxX: Math.max(x1, x2),\n maxY: Math.max(y1, y2)\n };\n };\n\n /**\n * returns the point on the segment's path that is 'location' along the length of the path, where 'location' is a decimal from\n * 0 to 1 inclusive. for the straight line segment this is simple maths.\n */\n this.pointOnPath = function (location, absolute) {\n if (location === 0 && !absolute) {\n return { x: x1, y: y1 };\n }\n else if (location === 1 && !absolute) {\n return { x: x2, y: y2 };\n }\n else {\n var l = absolute ? location > 0 ? location : length + location : location * length;\n return _jg.pointOnLine({x: x1, y: y1}, {x: x2, y: y2}, l);\n }\n };\n\n /**\n * returns the gradient of the segment at the given point - which for us is constant.\n */\n this.gradientAtPoint = function (_) {\n return m;\n };\n\n /**\n * returns the point on the segment's path that is 'distance' along the length of the path from 'location', where\n * 'location' is a decimal from 0 to 1 inclusive, and 'distance' is a number of pixels.\n * this hands off to jsPlumbUtil to do the maths, supplying two points and the distance.\n */\n this.pointAlongPathFrom = function (location, distance, absolute) {\n var p = this.pointOnPath(location, absolute),\n farAwayPoint = distance <= 0 ? {x: x1, y: y1} : {x: x2, y: y2 };\n\n /*\n location == 1 ? {\n x:x1 + ((x2 - x1) * 10),\n y:y1 + ((y1 - y2) * 10)\n } :\n */\n\n if (distance <= 0 && Math.abs(distance) > 1) {\n distance *= -1;\n }\n\n return _jg.pointOnLine(p, farAwayPoint, distance);\n };\n\n // is c between a and b?\n var within = function (a, b, c) {\n return c >= Math.min(a, b) && c <= Math.max(a, b);\n };\n // find which of a and b is closest to c\n var closest = function (a, b, c) {\n return Math.abs(c - a) < Math.abs(c - b) ? a : b;\n };\n\n /**\n Function: findClosestPointOnPath\n Finds the closest point on this segment to [x,y]. See\n notes on this method in AbstractSegment.\n */\n this.findClosestPointOnPath = function (x, y) {\n var out = {\n d: Infinity,\n x: null,\n y: null,\n l: null,\n x1: x1,\n x2: x2,\n y1: y1,\n y2: y2\n };\n\n if (m === 0) {\n out.y = y1;\n out.x = within(x1, x2, x) ? x : closest(x1, x2, x);\n }\n else if (m === Infinity || m === -Infinity) {\n out.x = x1;\n out.y = within(y1, y2, y) ? y : closest(y1, y2, y);\n }\n else {\n // closest point lies on normal from given point to this line. \n var b = y1 - (m * x1),\n b2 = y - (m2 * x),\n // y1 = m.x1 + b and y1 = m2.x1 + b2\n // so m.x1 + b = m2.x1 + b2\n // x1(m - m2) = b2 - b\n // x1 = (b2 - b) / (m - m2)\n _x1 = (b2 - b) / (m - m2),\n _y1 = (m * _x1) + b;\n\n out.x = within(x1, x2, _x1) ? _x1 : closest(x1, x2, _x1);//_x1;\n out.y = within(y1, y2, _y1) ? _y1 : closest(y1, y2, _y1);//_y1;\n }\n\n var fractionInSegment = _jg.lineLength([ out.x, out.y ], [ x1, y1 ]);\n out.d = _jg.lineLength([x, y], [out.x, out.y]);\n out.l = fractionInSegment / length;\n return out;\n };\n\n var _pointLiesBetween = function(q, p1, p2) {\n return (p2 > p1) ? (p1 <= q && q <= p2) : (p1 >= q && q >= p2);\n }, _plb = _pointLiesBetween;\n\n /**\n * Calculates all intersections of the given line with this segment.\n * @param _x1\n * @param _y1\n * @param _x2\n * @param _y2\n * @returns {Array}\n */\n this.lineIntersection = function(_x1, _y1, _x2, _y2) {\n var m2 = Math.abs(_jg.gradient({x: _x1, y: _y1}, {x: _x2, y: _y2})),\n m1 = Math.abs(m),\n b = m1 === Infinity ? x1 : y1 - (m1 * x1),\n out = [],\n b2 = m2 === Infinity ? _x1 : _y1 - (m2 * _x1);\n\n // if lines parallel, no intersection\n if (m2 !== m1) {\n // perpendicular, segment horizontal\n if(m2 === Infinity && m1 === 0) {\n if (_plb(_x1, x1, x2) && _plb(y1, _y1, _y2)) {\n out = [ _x1, y1 ]; // we return X on the incident line and Y from the segment\n }\n } else if(m2 === 0 && m1 === Infinity) {\n // perpendicular, segment vertical\n if(_plb(_y1, y1, y2) && _plb(x1, _x1, _x2)) {\n out = [x1, _y1]; // we return X on the segment and Y from the incident line\n }\n } else {\n var X, Y;\n if (m2 === Infinity) {\n // test line is a vertical line. where does it cross the segment?\n X = _x1;\n if (_plb(X, x1, x2)) {\n Y = (m1 * _x1) + b;\n if (_plb(Y, _y1, _y2)) {\n out = [ X, Y ];\n }\n }\n } else if (m2 === 0) {\n Y = _y1;\n // test line is a horizontal line. where does it cross the segment?\n if (_plb(Y, y1, y2)) {\n X = (_y1 - b) / m1;\n if (_plb(X, _x1, _x2)) {\n out = [ X, Y ];\n }\n }\n } else {\n // mX + b = m2X + b2\n // mX - m2X = b2 - b\n // X(m - m2) = b2 - b\n // X = (b2 - b) / (m - m2)\n // Y = mX + b\n X = (b2 - b) / (m1 - m2);\n Y = (m1 * X) + b;\n if(_plb(X, x1, x2) && _plb(Y, y1, y2)) {\n out = [ X, Y];\n }\n }\n }\n }\n\n return out;\n };\n\n /**\n * Calculates all intersections of the given box with this segment. By default this method simply calls `lineIntersection` with each of the four\n * faces of the box; subclasses can override this if they think there's a faster way to compute the entire box at once.\n * @param x X position of top left corner of box\n * @param y Y position of top left corner of box\n * @param w width of box\n * @param h height of box\n * @returns {Array}\n */\n this.boxIntersection = function(x, y, w, h) {\n var a = [];\n a.push.apply(a, this.lineIntersection(x, y, x + w, y));\n a.push.apply(a, this.lineIntersection(x + w, y, x + w, y + h));\n a.push.apply(a, this.lineIntersection(x + w, y + h, x, y + h));\n a.push.apply(a, this.lineIntersection(x, y + h, x, y));\n return a;\n };\n\n /**\n * Calculates all intersections of the given bounding box with this segment. By default this method simply calls `lineIntersection` with each of the four\n * faces of the box; subclasses can override this if they think there's a faster way to compute the entire box at once.\n * @param box Bounding box, in { x:.., y:..., w:..., h:... } format.\n * @returns {Array}\n */\n this.boundingBoxIntersection = function(box) {\n return this.boxIntersection(box.x, box.y, box.w, box.h);\n };\n },\n\n /*\n Arc Segment. You need to supply:\n\n r - radius\n cx - center x for the arc\n cy - center y for the arc\n ac - whether the arc is anticlockwise or not. default is clockwise.\n\n and then either:\n\n startAngle - startAngle for the arc.\n endAngle - endAngle for the arc.\n\n or:\n\n x1 - x for start point\n y1 - y for start point\n x2 - x for end point\n y2 - y for end point\n\n */\n Arc: function (params) {\n var _super = _jp.Segments.AbstractSegment.apply(this, arguments),\n _calcAngle = function (_x, _y) {\n return _jg.theta([params.cx, params.cy], [_x, _y]);\n },\n _calcAngleForLocation = function (segment, location) {\n if (segment.anticlockwise) {\n var sa = segment.startAngle < segment.endAngle ? segment.startAngle + TWO_PI : segment.startAngle,\n s = Math.abs(sa - segment.endAngle);\n return sa - (s * location);\n }\n else {\n var ea = segment.endAngle < segment.startAngle ? segment.endAngle + TWO_PI : segment.endAngle,\n ss = Math.abs(ea - segment.startAngle);\n\n return segment.startAngle + (ss * location);\n }\n },\n TWO_PI = 2 * Math.PI;\n\n this.radius = params.r;\n this.anticlockwise = params.ac;\n this.type = \"Arc\";\n\n if (params.startAngle && params.endAngle) {\n this.startAngle = params.startAngle;\n this.endAngle = params.endAngle;\n this.x1 = params.cx + (this.radius * Math.cos(params.startAngle));\n this.y1 = params.cy + (this.radius * Math.sin(params.startAngle));\n this.x2 = params.cx + (this.radius * Math.cos(params.endAngle));\n this.y2 = params.cy + (this.radius * Math.sin(params.endAngle));\n }\n else {\n this.startAngle = _calcAngle(params.x1, params.y1);\n this.endAngle = _calcAngle(params.x2, params.y2);\n this.x1 = params.x1;\n this.y1 = params.y1;\n this.x2 = params.x2;\n this.y2 = params.y2;\n }\n\n if (this.endAngle < 0) {\n this.endAngle += TWO_PI;\n }\n if (this.startAngle < 0) {\n this.startAngle += TWO_PI;\n }\n\n // segment is used by vml \n //this.segment = _jg.quadrant([this.x1, this.y1], [this.x2, this.y2]);\n\n // we now have startAngle and endAngle as positive numbers, meaning the\n // absolute difference (|d|) between them is the sweep (s) of this arc, unless the\n // arc is 'anticlockwise' in which case 's' is given by 2PI - |d|.\n\n var ea = this.endAngle < this.startAngle ? this.endAngle + TWO_PI : this.endAngle;\n this.sweep = Math.abs(ea - this.startAngle);\n if (this.anticlockwise) {\n this.sweep = TWO_PI - this.sweep;\n }\n var circumference = 2 * Math.PI * this.radius,\n frac = this.sweep / TWO_PI,\n length = circumference * frac;\n\n this.getLength = function () {\n return length;\n };\n\n this.getBounds = function () {\n return {\n minX: params.cx - params.r,\n maxX: params.cx + params.r,\n minY: params.cy - params.r,\n maxY: params.cy + params.r\n };\n };\n\n var VERY_SMALL_VALUE = 0.0000000001,\n gentleRound = function (n) {\n var f = Math.floor(n), r = Math.ceil(n);\n if (n - f < VERY_SMALL_VALUE) {\n return f;\n }\n else if (r - n < VERY_SMALL_VALUE) {\n return r;\n }\n return n;\n };\n\n /**\n * returns the point on the segment's path that is 'location' along the length of the path, where 'location' is a decimal from\n * 0 to 1 inclusive.\n */\n this.pointOnPath = function (location, absolute) {\n\n if (location === 0) {\n return { x: this.x1, y: this.y1, theta: this.startAngle };\n }\n else if (location === 1) {\n return { x: this.x2, y: this.y2, theta: this.endAngle };\n }\n\n if (absolute) {\n location = location / length;\n }\n\n var angle = _calcAngleForLocation(this, location),\n _x = params.cx + (params.r * Math.cos(angle)),\n _y = params.cy + (params.r * Math.sin(angle));\n\n return { x: gentleRound(_x), y: gentleRound(_y), theta: angle };\n };\n\n /**\n * returns the gradient of the segment at the given point.\n */\n this.gradientAtPoint = function (location, absolute) {\n var p = this.pointOnPath(location, absolute);\n var m = _jg.normal([ params.cx, params.cy ], [p.x, p.y ]);\n if (!this.anticlockwise && (m === Infinity || m === -Infinity)) {\n m *= -1;\n }\n return m;\n };\n\n this.pointAlongPathFrom = function (location, distance, absolute) {\n var p = this.pointOnPath(location, absolute),\n arcSpan = distance / circumference * 2 * Math.PI,\n dir = this.anticlockwise ? -1 : 1,\n startAngle = p.theta + (dir * arcSpan),\n startX = params.cx + (this.radius * Math.cos(startAngle)),\n startY = params.cy + (this.radius * Math.sin(startAngle));\n\n return {x: startX, y: startY};\n };\n\n // TODO: lineIntersection\n },\n\n Bezier: function (params) {\n this.curve = [\n { x: params.x1, y: params.y1},\n { x: params.cp1x, y: params.cp1y },\n { x: params.cp2x, y: params.cp2y },\n { x: params.x2, y: params.y2 }\n ];\n\n var _super = _jp.Segments.AbstractSegment.apply(this, arguments);\n // although this is not a strictly rigorous determination of bounds\n // of a bezier curve, it works for the types of curves that this segment\n // type produces.\n this.bounds = {\n minX: Math.min(params.x1, params.x2, params.cp1x, params.cp2x),\n minY: Math.min(params.y1, params.y2, params.cp1y, params.cp2y),\n maxX: Math.max(params.x1, params.x2, params.cp1x, params.cp2x),\n maxY: Math.max(params.y1, params.y2, params.cp1y, params.cp2y)\n };\n\n this.type = \"Bezier\";\n\n var _translateLocation = function (_curve, location, absolute) {\n if (absolute) {\n location = root.jsBezier.locationAlongCurveFrom(_curve, location > 0 ? 0 : 1, location);\n }\n\n return location;\n };\n\n /**\n * returns the point on the segment's path that is 'location' along the length of the path, where 'location' is a decimal from\n * 0 to 1 inclusive.\n */\n this.pointOnPath = function (location, absolute) {\n location = _translateLocation(this.curve, location, absolute);\n return root.jsBezier.pointOnCurve(this.curve, location);\n };\n\n /**\n * returns the gradient of the segment at the given point.\n */\n this.gradientAtPoint = function (location, absolute) {\n location = _translateLocation(this.curve, location, absolute);\n return root.jsBezier.gradientAtPoint(this.curve, location);\n };\n\n this.pointAlongPathFrom = function (location, distance, absolute) {\n location = _translateLocation(this.curve, location, absolute);\n return root.jsBezier.pointAlongCurveFrom(this.curve, location, distance);\n };\n\n this.getLength = function () {\n return root.jsBezier.getLength(this.curve);\n };\n\n this.getBounds = function () {\n return this.bounds;\n };\n\n this.findClosestPointOnPath = function (x, y) {\n var p = root.jsBezier.nearestPointOnCurve({x:x,y:y}, this.curve);\n return {\n d:Math.sqrt(Math.pow(p.point.x - x, 2) + Math.pow(p.point.y - y, 2)),\n x:p.point.x,\n y:p.point.y,\n l:p.location,\n s:this\n };\n };\n\n this.lineIntersection = function(x1, y1, x2, y2) {\n return root.jsBezier.lineIntersection(x1, y1, x2, y2, this.curve);\n };\n }\n };\n\n _jp.SegmentRenderer = {\n getPath: function (segment, isFirstSegment) {\n return ({\n \"Straight\": function (isFirstSegment) {\n var d = segment.getCoordinates();\n return (isFirstSegment ? \"M \" + d.x1 + \" \" + d.y1 + \" \" : \"\") + \"L \" + d.x2 + \" \" + d.y2;\n },\n \"Bezier\": function (isFirstSegment) {\n var d = segment.params;\n return (isFirstSegment ? \"M \" + d.x2 + \" \" + d.y2 + \" \" : \"\") +\n \"C \" + d.cp2x + \" \" + d.cp2y + \" \" + d.cp1x + \" \" + d.cp1y + \" \" + d.x1 + \" \" + d.y1;\n },\n \"Arc\": function (isFirstSegment) {\n var d = segment.params,\n laf = segment.sweep > Math.PI ? 1 : 0,\n sf = segment.anticlockwise ? 0 : 1;\n\n return (isFirstSegment ? \"M\" + segment.x1 + \" \" + segment.y1 + \" \" : \"\") + \"A \" + segment.radius + \" \" + d.r + \" 0 \" + laf + \",\" + sf + \" \" + segment.x2 + \" \" + segment.y2;\n }\n })[segment.type](isFirstSegment);\n }\n };\n\n /*\n Class: UIComponent\n Superclass for Connector and AbstractEndpoint.\n */\n var AbstractComponent = function () {\n this.resetBounds = function () {\n this.bounds = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };\n };\n this.resetBounds();\n };\n\n /*\n * Class: Connector\n * Superclass for all Connectors; here is where Segments are managed. This is exposed on jsPlumb just so it\n * can be accessed from other files. You should not try to instantiate one of these directly.\n *\n * When this class is asked for a pointOnPath, or gradient etc, it must first figure out which segment to dispatch\n * that request to. This is done by keeping track of the total connector length as segments are added, and also\n * their cumulative ratios to the total length. Then when the right segment is found it is a simple case of dispatching\n * the request to it (and adjusting 'location' so that it is relative to the beginning of that segment.)\n */\n _jp.Connectors.AbstractConnector = function (params) {\n\n AbstractComponent.apply(this, arguments);\n\n var segments = [],\n totalLength = 0,\n segmentProportions = [],\n segmentProportionalLengths = [],\n stub = params.stub || 0,\n sourceStub = _ju.isArray(stub) ? stub[0] : stub,\n targetStub = _ju.isArray(stub) ? stub[1] : stub,\n gap = params.gap || 0,\n sourceGap = _ju.isArray(gap) ? gap[0] : gap,\n targetGap = _ju.isArray(gap) ? gap[1] : gap,\n userProvidedSegments = null,\n paintInfo = null;\n\n this.getPathData = function() {\n var p = \"\";\n for (var i = 0; i < segments.length; i++) {\n p += _jp.SegmentRenderer.getPath(segments[i], i === 0);\n p += \" \";\n }\n return p;\n };\n\n /**\n * Function: findSegmentForPoint\n * Returns the segment that is closest to the given [x,y],\n * null if nothing found. This function returns a JS\n * object with:\n *\n * d - distance from segment\n * l - proportional location in segment\n * x - x point on the segment\n * y - y point on the segment\n * s - the segment itself.\n */\n this.findSegmentForPoint = function (x, y) {\n var out = { d: Infinity, s: null, x: null, y: null, l: null };\n for (var i = 0; i < segments.length; i++) {\n var _s = segments[i].findClosestPointOnPath(x, y);\n if (_s.d < out.d) {\n out.d = _s.d;\n out.l = _s.l;\n out.x = _s.x;\n out.y = _s.y;\n out.s = segments[i];\n out.x1 = _s.x1;\n out.x2 = _s.x2;\n out.y1 = _s.y1;\n out.y2 = _s.y2;\n out.index = i;\n }\n }\n\n return out;\n };\n\n this.lineIntersection = function(x1, y1, x2, y2) {\n var out = [];\n for (var i = 0; i < segments.length; i++) {\n out.push.apply(out, segments[i].lineIntersection(x1, y1, x2, y2));\n }\n return out;\n };\n\n this.boxIntersection = function(x, y, w, h) {\n var out = [];\n for (var i = 0; i < segments.length; i++) {\n out.push.apply(out, segments[i].boxIntersection(x, y, w, h));\n }\n return out;\n };\n\n this.boundingBoxIntersection = function(box) {\n var out = [];\n for (var i = 0; i < segments.length; i++) {\n out.push.apply(out, segments[i].boundingBoxIntersection(box));\n }\n return out;\n };\n\n var _updateSegmentProportions = function () {\n var curLoc = 0;\n for (var i = 0; i < segments.length; i++) {\n var sl = segments[i].getLength();\n segmentProportionalLengths[i] = sl / totalLength;\n segmentProportions[i] = [curLoc, (curLoc += (sl / totalLength)) ];\n }\n },\n\n /**\n * returns [segment, proportion of travel in segment, segment index] for the segment\n * that contains the point which is 'location' distance along the entire path, where\n * 'location' is a decimal between 0 and 1 inclusive. in this connector type, paths\n * are made up of a list of segments, each of which contributes some fraction to\n * the total length.\n * From 1.3.10 this also supports the 'absolute' property, which lets us specify a location\n * as the absolute distance in pixels, rather than a proportion of the total path.\n */\n _findSegmentForLocation = function (location, absolute) {\n if (absolute) {\n location = location > 0 ? location / totalLength : (totalLength + location) / totalLength;\n }\n var idx = segmentProportions.length - 1, inSegmentProportion = 1;\n for (var i = 0; i < segmentProportions.length; i++) {\n if (segmentProportions[i][1] >= location) {\n idx = i;\n // todo is this correct for all connector path types?\n inSegmentProportion = location === 1 ? 1 : location === 0 ? 0 : (location - segmentProportions[i][0]) / segmentProportionalLengths[i];\n break;\n }\n }\n return { segment: segments[idx], proportion: inSegmentProportion, index: idx };\n },\n _addSegment = function (conn, type, params) {\n if (params.x1 === params.x2 && params.y1 === params.y2) {\n return;\n }\n var s = new _jp.Segments[type](params);\n segments.push(s);\n totalLength += s.getLength();\n conn.updateBounds(s);\n },\n _clearSegments = function () {\n totalLength = segments.length = segmentProportions.length = segmentProportionalLengths.length = 0;\n };\n\n this.setSegments = function (_segs) {\n userProvidedSegments = [];\n totalLength = 0;\n for (var i = 0; i < _segs.length; i++) {\n userProvidedSegments.push(_segs[i]);\n totalLength += _segs[i].getLength();\n }\n };\n\n this.getLength = function() {\n return totalLength;\n };\n\n var _prepareCompute = function (params) {\n this.strokeWidth = params.strokeWidth;\n var segment = _jg.quadrant(params.sourcePos, params.targetPos),\n swapX = params.targetPos[0] < params.sourcePos[0],\n swapY = params.targetPos[1] < params.sourcePos[1],\n lw = params.strokeWidth || 1,\n so = params.sourceEndpoint.anchor.getOrientation(params.sourceEndpoint),\n to = params.targetEndpoint.anchor.getOrientation(params.targetEndpoint),\n x = swapX ? params.targetPos[0] : params.sourcePos[0],\n y = swapY ? params.targetPos[1] : params.sourcePos[1],\n w = Math.abs(params.targetPos[0] - params.sourcePos[0]),\n h = Math.abs(params.targetPos[1] - params.sourcePos[1]);\n\n // if either anchor does not have an orientation set, we derive one from their relative\n // positions. we fix the axis to be the one in which the two elements are further apart, and\n // point each anchor at the other element. this is also used when dragging a new connection.\n if (so[0] === 0 && so[1] === 0 || to[0] === 0 && to[1] === 0) {\n var index = w > h ? 0 : 1, oIndex = [1, 0][index];\n so = [];\n to = [];\n so[index] = params.sourcePos[index] > params.targetPos[index] ? -1 : 1;\n to[index] = params.sourcePos[index] > params.targetPos[index] ? 1 : -1;\n so[oIndex] = 0;\n to[oIndex] = 0;\n }\n\n var sx = swapX ? w + (sourceGap * so[0]) : sourceGap * so[0],\n sy = swapY ? h + (sourceGap * so[1]) : sourceGap * so[1],\n tx = swapX ? targetGap * to[0] : w + (targetGap * to[0]),\n ty = swapY ? targetGap * to[1] : h + (targetGap * to[1]),\n oProduct = ((so[0] * to[0]) + (so[1] * to[1]));\n\n var result = {\n sx: sx, sy: sy, tx: tx, ty: ty, lw: lw,\n xSpan: Math.abs(tx - sx),\n ySpan: Math.abs(ty - sy),\n mx: (sx + tx) / 2,\n my: (sy + ty) / 2,\n so: so, to: to, x: x, y: y, w: w, h: h,\n segment: segment,\n startStubX: sx + (so[0] * sourceStub),\n startStubY: sy + (so[1] * sourceStub),\n endStubX: tx + (to[0] * targetStub),\n endStubY: ty + (to[1] * targetStub),\n isXGreaterThanStubTimes2: Math.abs(sx - tx) > (sourceStub + targetStub),\n isYGreaterThanStubTimes2: Math.abs(sy - ty) > (sourceStub + targetStub),\n opposite: oProduct === -1,\n perpendicular: oProduct === 0,\n orthogonal: oProduct === 1,\n sourceAxis: so[0] === 0 ? \"y\" : \"x\",\n points: [x, y, w, h, sx, sy, tx, ty ],\n stubs:[sourceStub, targetStub]\n };\n result.anchorOrientation = result.opposite ? \"opposite\" : result.orthogonal ? \"orthogonal\" : \"perpendicular\";\n return result;\n };\n\n this.getSegments = function () {\n return segments;\n };\n\n this.updateBounds = function (segment) {\n var segBounds = segment.getBounds();\n this.bounds.minX = Math.min(this.bounds.minX, segBounds.minX);\n this.bounds.maxX = Math.max(this.bounds.maxX, segBounds.maxX);\n this.bounds.minY = Math.min(this.bounds.minY, segBounds.minY);\n this.bounds.maxY = Math.max(this.bounds.maxY, segBounds.maxY);\n };\n\n var dumpSegmentsToConsole = function () {\n console.log(\"SEGMENTS:\");\n for (var i = 0; i < segments.length; i++) {\n console.log(segments[i].type, segments[i].getLength(), segmentProportions[i]);\n }\n };\n\n this.pointOnPath = function (location, absolute) {\n var seg = _findSegmentForLocation(location, absolute);\n return seg.segment && seg.segment.pointOnPath(seg.proportion, false) || [0, 0];\n };\n\n this.gradientAtPoint = function (location, absolute) {\n var seg = _findSegmentForLocation(location, absolute);\n return seg.segment && seg.segment.gradientAtPoint(seg.proportion, false) || 0;\n };\n\n this.pointAlongPathFrom = function (location, distance, absolute) {\n var seg = _findSegmentForLocation(location, absolute);\n // TODO what happens if this crosses to the next segment?\n return seg.segment && seg.segment.pointAlongPathFrom(seg.proportion, distance, false) || [0, 0];\n };\n\n this.compute = function (params) {\n paintInfo = _prepareCompute.call(this, params);\n\n _clearSegments();\n this._compute(paintInfo, params);\n this.x = paintInfo.points[0];\n this.y = paintInfo.points[1];\n this.w = paintInfo.points[2];\n this.h = paintInfo.points[3];\n this.segment = paintInfo.segment;\n _updateSegmentProportions();\n };\n\n return {\n addSegment: _addSegment,\n prepareCompute: _prepareCompute,\n sourceStub: sourceStub,\n targetStub: targetStub,\n maxStub: Math.max(sourceStub, targetStub),\n sourceGap: sourceGap,\n targetGap: targetGap,\n maxGap: Math.max(sourceGap, targetGap)\n };\n };\n _ju.extend(_jp.Connectors.AbstractConnector, AbstractComponent);\n\n\n // ********************************* END OF CONNECTOR TYPES *******************************************************************\n\n // ********************************* ENDPOINT TYPES *******************************************************************\n\n _jp.Endpoints.AbstractEndpoint = function (params) {\n AbstractComponent.apply(this, arguments);\n var compute = this.compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n var out = this._compute.apply(this, arguments);\n this.x = out[0];\n this.y = out[1];\n this.w = out[2];\n this.h = out[3];\n this.bounds.minX = this.x;\n this.bounds.minY = this.y;\n this.bounds.maxX = this.x + this.w;\n this.bounds.maxY = this.y + this.h;\n return out;\n };\n return {\n compute: compute,\n cssClass: params.cssClass\n };\n };\n _ju.extend(_jp.Endpoints.AbstractEndpoint, AbstractComponent);\n\n /**\n * Class: Endpoints.Dot\n * A round endpoint, with default radius 10 pixels.\n */\n\n /**\n * Function: Constructor\n *\n * Parameters:\n *\n * radius - radius of the endpoint. defaults to 10 pixels.\n */\n _jp.Endpoints.Dot = function (params) {\n this.type = \"Dot\";\n var _super = _jp.Endpoints.AbstractEndpoint.apply(this, arguments);\n params = params || {};\n this.radius = params.radius || 10;\n this.defaultOffset = 0.5 * this.radius;\n this.defaultInnerRadius = this.radius / 3;\n\n this._compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n this.radius = endpointStyle.radius || this.radius;\n var x = anchorPoint[0] - this.radius,\n y = anchorPoint[1] - this.radius,\n w = this.radius * 2,\n h = this.radius * 2;\n\n if (endpointStyle.stroke) {\n var lw = endpointStyle.strokeWidth || 1;\n x -= lw;\n y -= lw;\n w += (lw * 2);\n h += (lw * 2);\n }\n return [ x, y, w, h, this.radius ];\n };\n };\n _ju.extend(_jp.Endpoints.Dot, _jp.Endpoints.AbstractEndpoint);\n\n _jp.Endpoints.Rectangle = function (params) {\n this.type = \"Rectangle\";\n var _super = _jp.Endpoints.AbstractEndpoint.apply(this, arguments);\n params = params || {};\n this.width = params.width || 20;\n this.height = params.height || 20;\n\n this._compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n var width = endpointStyle.width || this.width,\n height = endpointStyle.height || this.height,\n x = anchorPoint[0] - (width / 2),\n y = anchorPoint[1] - (height / 2);\n\n return [ x, y, width, height];\n };\n };\n _ju.extend(_jp.Endpoints.Rectangle, _jp.Endpoints.AbstractEndpoint);\n\n var DOMElementEndpoint = function (params) {\n _jp.jsPlumbUIComponent.apply(this, arguments);\n this._jsPlumb.displayElements = [];\n };\n _ju.extend(DOMElementEndpoint, _jp.jsPlumbUIComponent, {\n getDisplayElements: function () {\n return this._jsPlumb.displayElements;\n },\n appendDisplayElement: function (el) {\n this._jsPlumb.displayElements.push(el);\n }\n });\n\n /**\n * Class: Endpoints.Image\n * Draws an image as the Endpoint.\n */\n /**\n * Function: Constructor\n *\n * Parameters:\n *\n * src - location of the image to use.\n\n TODO: multiple references to self. not sure quite how to get rid of them entirely. perhaps self = null in the cleanup\n function will suffice\n\n TODO this class still might leak memory.\n\n */\n _jp.Endpoints.Image = function (params) {\n\n this.type = \"Image\";\n DOMElementEndpoint.apply(this, arguments);\n _jp.Endpoints.AbstractEndpoint.apply(this, arguments);\n\n var _onload = params.onload,\n src = params.src || params.url,\n clazz = params.cssClass ? \" \" + params.cssClass : \"\";\n\n this._jsPlumb.img = new Image();\n this._jsPlumb.ready = false;\n this._jsPlumb.initialized = false;\n this._jsPlumb.deleted = false;\n this._jsPlumb.widthToUse = params.width;\n this._jsPlumb.heightToUse = params.height;\n this._jsPlumb.endpoint = params.endpoint;\n\n this._jsPlumb.img.onload = function () {\n if (this._jsPlumb != null) {\n this._jsPlumb.ready = true;\n this._jsPlumb.widthToUse = this._jsPlumb.widthToUse || this._jsPlumb.img.width;\n this._jsPlumb.heightToUse = this._jsPlumb.heightToUse || this._jsPlumb.img.height;\n if (_onload) {\n _onload(this);\n }\n }\n }.bind(this);\n\n /*\n Function: setImage\n Sets the Image to use in this Endpoint.\n\n Parameters:\n img - may be a URL or an Image object\n onload - optional; a callback to execute once the image has loaded.\n */\n this._jsPlumb.endpoint.setImage = function (_img, onload) {\n var s = _img.constructor === String ? _img : _img.src;\n _onload = onload;\n this._jsPlumb.img.src = s;\n\n if (this.canvas != null) {\n this.canvas.setAttribute(\"src\", this._jsPlumb.img.src);\n }\n }.bind(this);\n\n this._jsPlumb.endpoint.setImage(src, _onload);\n this._compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n this.anchorPoint = anchorPoint;\n if (this._jsPlumb.ready) {\n return [anchorPoint[0] - this._jsPlumb.widthToUse / 2, anchorPoint[1] - this._jsPlumb.heightToUse / 2,\n this._jsPlumb.widthToUse, this._jsPlumb.heightToUse];\n }\n else {\n return [0, 0, 0, 0];\n }\n };\n\n this.canvas = _jp.createElement(\"img\", {\n position:\"absolute\",\n margin:0,\n padding:0,\n outline:0\n }, this._jsPlumb.instance.endpointClass + clazz);\n\n if (this._jsPlumb.widthToUse) {\n this.canvas.setAttribute(\"width\", this._jsPlumb.widthToUse);\n }\n if (this._jsPlumb.heightToUse) {\n this.canvas.setAttribute(\"height\", this._jsPlumb.heightToUse);\n }\n this._jsPlumb.instance.appendElement(this.canvas);\n\n this.actuallyPaint = function (d, style, anchor) {\n if (!this._jsPlumb.deleted) {\n if (!this._jsPlumb.initialized) {\n this.canvas.setAttribute(\"src\", this._jsPlumb.img.src);\n this.appendDisplayElement(this.canvas);\n this._jsPlumb.initialized = true;\n }\n var x = this.anchorPoint[0] - (this._jsPlumb.widthToUse / 2),\n y = this.anchorPoint[1] - (this._jsPlumb.heightToUse / 2);\n _ju.sizeElement(this.canvas, x, y, this._jsPlumb.widthToUse, this._jsPlumb.heightToUse);\n }\n };\n\n this.paint = function (style, anchor) {\n if (this._jsPlumb != null) { // may have been deleted\n if (this._jsPlumb.ready) {\n this.actuallyPaint(style, anchor);\n }\n else {\n root.setTimeout(function () {\n this.paint(style, anchor);\n }.bind(this), 200);\n }\n }\n };\n };\n _ju.extend(_jp.Endpoints.Image, [ DOMElementEndpoint, _jp.Endpoints.AbstractEndpoint ], {\n cleanup: function (force) {\n if (force) {\n this._jsPlumb.deleted = true;\n if (this.canvas) {\n this.canvas.parentNode.removeChild(this.canvas);\n }\n this.canvas = null;\n }\n }\n });\n\n /*\n * Class: Endpoints.Blank\n * An Endpoint that paints nothing (visible) on the screen. Supports cssClass and hoverClass parameters like all Endpoints.\n */\n _jp.Endpoints.Blank = function (params) {\n var _super = _jp.Endpoints.AbstractEndpoint.apply(this, arguments);\n this.type = \"Blank\";\n DOMElementEndpoint.apply(this, arguments);\n this._compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n return [anchorPoint[0], anchorPoint[1], 10, 0];\n };\n\n var clazz = params.cssClass ? \" \" + params.cssClass : \"\";\n\n this.canvas = _jp.createElement(\"div\", {\n display: \"block\",\n width: \"1px\",\n height: \"1px\",\n background: \"transparent\",\n position: \"absolute\"\n }, this._jsPlumb.instance.endpointClass + clazz);\n\n this._jsPlumb.instance.appendElement(this.canvas);\n\n this.paint = function (style, anchor) {\n _ju.sizeElement(this.canvas, this.x, this.y, this.w, this.h);\n };\n };\n _ju.extend(_jp.Endpoints.Blank, [_jp.Endpoints.AbstractEndpoint, DOMElementEndpoint], {\n cleanup: function () {\n if (this.canvas && this.canvas.parentNode) {\n this.canvas.parentNode.removeChild(this.canvas);\n }\n }\n });\n\n /*\n * Class: Endpoints.Triangle\n * A triangular Endpoint.\n */\n /*\n * Function: Constructor\n *\n * Parameters:\n *\n * width width of the triangle's base. defaults to 55 pixels.\n * height height of the triangle from base to apex. defaults to 55 pixels.\n */\n _jp.Endpoints.Triangle = function (params) {\n this.type = \"Triangle\";\n _jp.Endpoints.AbstractEndpoint.apply(this, arguments);\n var self = this;\n params = params || { };\n params.width = params.width || 55;\n params.height = params.height || 55;\n this.width = params.width;\n this.height = params.height;\n this._compute = function (anchorPoint, orientation, endpointStyle, connectorPaintStyle) {\n var width = endpointStyle.width || self.width,\n height = endpointStyle.height || self.height,\n x = anchorPoint[0] - (width / 2),\n y = anchorPoint[1] - (height / 2);\n return [ x, y, width, height ];\n };\n };\n// ********************************* END OF ENDPOINT TYPES *******************************************************************\n\n\n// ********************************* OVERLAY DEFINITIONS *********************************************************************** \n\n var AbstractOverlay = _jp.Overlays.AbstractOverlay = function (params) {\n this.visible = true;\n this.isAppendedAtTopLevel = true;\n this.component = params.component;\n this.loc = params.location == null ? 0.5 : params.location;\n this.endpointLoc = params.endpointLocation == null ? [ 0.5, 0.5] : params.endpointLocation;\n this.visible = params.visible !== false;\n };\n AbstractOverlay.prototype = {\n cleanup: function (force) {\n if (force) {\n this.component = null;\n this.canvas = null;\n this.endpointLoc = null;\n }\n },\n reattach:function(instance, component) { },\n setVisible: function (val) {\n this.visible = val;\n this.component.repaint();\n },\n isVisible: function () {\n return this.visible;\n },\n hide: function () {\n this.setVisible(false);\n },\n show: function () {\n this.setVisible(true);\n },\n incrementLocation: function (amount) {\n this.loc += amount;\n this.component.repaint();\n },\n setLocation: function (l) {\n this.loc = l;\n this.component.repaint();\n },\n getLocation: function () {\n return this.loc;\n },\n updateFrom:function() { }\n };\n\n\n /*\n * Class: Overlays.Arrow\n *\n * An arrow overlay, defined by four points: the head, the two sides of the tail, and a 'foldback' point at some distance along the length\n * of the arrow that lines from each tail point converge into. The foldback point is defined using a decimal that indicates some fraction\n * of the length of the arrow and has a default value of 0.623. A foldback point value of 1 would mean that the arrow had a straight line\n * across the tail.\n */\n /*\n * @constructor\n *\n * @param {Object} params Constructor params.\n * @param {Number} [params.length] Distance in pixels from head to tail baseline. default 20.\n * @param {Number} [params.width] Width in pixels of the tail baseline. default 20.\n * @param {String} [params.fill] Style to use when filling the arrow. defaults to \"black\".\n * @param {String} [params.stroke] Style to use when stroking the arrow. defaults to null, which means the arrow is not stroked.\n * @param {Number} [params.stroke-width] Line width to use when stroking the arrow. defaults to 1, but only used if stroke is not null.\n * @param {Number} [params.foldback] Distance (as a decimal from 0 to 1 inclusive) along the length of the arrow marking the point the tail points should fold back to. defaults to 0.623.\n * @param {Number} [params.location] Distance (as a decimal from 0 to 1 inclusive) marking where the arrow should sit on the connector. defaults to 0.5.\n * @param {NUmber} [params.direction] Indicates the direction the arrow points in. valid values are -1 and 1; 1 is default.\n */\n _jp.Overlays.Arrow = function (params) {\n this.type = \"Arrow\";\n AbstractOverlay.apply(this, arguments);\n this.isAppendedAtTopLevel = false;\n params = params || {};\n var self = this;\n\n this.length = params.length || 20;\n this.width = params.width || 20;\n this.id = params.id;\n var direction = (params.direction || 1) < 0 ? -1 : 1,\n paintStyle = params.paintStyle || { \"stroke-width\": 1 },\n // how far along the arrow the lines folding back in come to. default is 62.3%.\n foldback = params.foldback || 0.623;\n\n this.computeMaxSize = function () {\n return self.width * 1.5;\n };\n\n this.elementCreated = function(p, component) {\n this.path = p;\n if (params.events) {\n for (var i in params.events) {\n _jp.on(p, i, params.events[i]);\n }\n }\n };\n\n this.draw = function (component, currentConnectionPaintStyle) {\n\n var hxy, mid, txy, tail, cxy;\n if (component.pointAlongPathFrom) {\n\n if (_ju.isString(this.loc) || this.loc > 1 || this.loc < 0) {\n var l = parseInt(this.loc, 10),\n fromLoc = this.loc < 0 ? 1 : 0;\n hxy = component.pointAlongPathFrom(fromLoc, l, false);\n mid = component.pointAlongPathFrom(fromLoc, l - (direction * this.length / 2), false);\n txy = _jg.pointOnLine(hxy, mid, this.length);\n }\n else if (this.loc === 1) {\n hxy = component.pointOnPath(this.loc);\n mid = component.pointAlongPathFrom(this.loc, -(this.length));\n txy = _jg.pointOnLine(hxy, mid, this.length);\n\n if (direction === -1) {\n var _ = txy;\n txy = hxy;\n hxy = _;\n }\n }\n else if (this.loc === 0) {\n txy = component.pointOnPath(this.loc);\n mid = component.pointAlongPathFrom(this.loc, this.length);\n hxy = _jg.pointOnLine(txy, mid, this.length);\n if (direction === -1) {\n var __ = txy;\n txy = hxy;\n hxy = __;\n }\n }\n else {\n hxy = component.pointAlongPathFrom(this.loc, direction * this.length / 2);\n mid = component.pointOnPath(this.loc);\n txy = _jg.pointOnLine(hxy, mid, this.length);\n }\n\n tail = _jg.perpendicularLineTo(hxy, txy, this.width);\n cxy = _jg.pointOnLine(hxy, txy, foldback * this.length);\n\n var d = { hxy: hxy, tail: tail, cxy: cxy },\n stroke = paintStyle.stroke || currentConnectionPaintStyle.stroke,\n fill = paintStyle.fill || currentConnectionPaintStyle.stroke,\n lineWidth = paintStyle.strokeWidth || currentConnectionPaintStyle.strokeWidth;\n\n return {\n component: component,\n d: d,\n \"stroke-width\": lineWidth,\n stroke: stroke,\n fill: fill,\n minX: Math.min(hxy.x, tail[0].x, tail[1].x),\n maxX: Math.max(hxy.x, tail[0].x, tail[1].x),\n minY: Math.min(hxy.y, tail[0].y, tail[1].y),\n maxY: Math.max(hxy.y, tail[0].y, tail[1].y)\n };\n }\n else {\n return {component: component, minX: 0, maxX: 0, minY: 0, maxY: 0};\n }\n };\n };\n _ju.extend(_jp.Overlays.Arrow, AbstractOverlay, {\n updateFrom:function(d) {\n this.length = d.length || this.length;\n this.width = d.width|| this.width;\n this.direction = d.direction != null ? d.direction : this.direction;\n this.foldback = d.foldback|| this.foldback;\n },\n cleanup:function() {\n if (this.path && this.canvas) {\n this.canvas.removeChild(this.path);\n }\n }\n });\n\n /*\n * Class: Overlays.PlainArrow\n *\n * A basic arrow. This is in fact just one instance of the more generic case in which the tail folds back on itself to some\n * point along the length of the arrow: in this case, that foldback point is the full length of the arrow. so it just does\n * a 'call' to Arrow with foldback set appropriately.\n */\n /*\n * Function: Constructor\n * See for allowed parameters for this overlay.\n */\n _jp.Overlays.PlainArrow = function (params) {\n params = params || {};\n var p = _jp.extend(params, {foldback: 1});\n _jp.Overlays.Arrow.call(this, p);\n this.type = \"PlainArrow\";\n };\n _ju.extend(_jp.Overlays.PlainArrow, _jp.Overlays.Arrow);\n\n /*\n * Class: Overlays.Diamond\n * \n * A diamond. Like PlainArrow, this is a concrete case of the more generic case of the tail points converging on some point...it just\n * happens that in this case, that point is greater than the length of the the arrow.\n *\n * this could probably do with some help with positioning...due to the way it reuses the Arrow paint code, what Arrow thinks is the\n * center is actually 1/4 of the way along for this guy. but we don't have any knowledge of pixels at this point, so we're kind of\n * stuck when it comes to helping out the Arrow class. possibly we could pass in a 'transpose' parameter or something. the value\n * would be -l/4 in this case - move along one quarter of the total length.\n */\n /*\n * Function: Constructor\n * See for allowed parameters for this overlay.\n */\n _jp.Overlays.Diamond = function (params) {\n params = params || {};\n var l = params.length || 40,\n p = _jp.extend(params, {length: l / 2, foldback: 2});\n _jp.Overlays.Arrow.call(this, p);\n this.type = \"Diamond\";\n };\n _ju.extend(_jp.Overlays.Diamond, _jp.Overlays.Arrow);\n\n var _getDimensions = function (component, forceRefresh) {\n if (component._jsPlumb.cachedDimensions == null || forceRefresh) {\n component._jsPlumb.cachedDimensions = component.getDimensions();\n }\n return component._jsPlumb.cachedDimensions;\n };\n\n // abstract superclass for overlays that add an element to the DOM.\n var AbstractDOMOverlay = function (params) {\n _jp.jsPlumbUIComponent.apply(this, arguments);\n AbstractOverlay.apply(this, arguments);\n\n // hand off fired events to associated component.\n var _f = this.fire;\n this.fire = function () {\n _f.apply(this, arguments);\n if (this.component) {\n this.component.fire.apply(this.component, arguments);\n }\n };\n\n this.detached=false;\n this.id = params.id;\n this._jsPlumb.div = null;\n this._jsPlumb.initialised = false;\n this._jsPlumb.component = params.component;\n this._jsPlumb.cachedDimensions = null;\n this._jsPlumb.create = params.create;\n this._jsPlumb.initiallyInvisible = params.visible === false;\n\n this.getElement = function () {\n if (this._jsPlumb.div == null) {\n var div = this._jsPlumb.div = _jp.getElement(this._jsPlumb.create(this._jsPlumb.component));\n div.style.position = \"absolute\";\n jsPlumb.addClass(div, this._jsPlumb.instance.overlayClass + \" \" +\n (this.cssClass ? this.cssClass :\n params.cssClass ? params.cssClass : \"\"));\n this._jsPlumb.instance.appendElement(div);\n this._jsPlumb.instance.getId(div);\n this.canvas = div;\n\n // in IE the top left corner is what it placed at the desired location. This will not\n // be fixed. IE8 is not going to be supported for much longer.\n var ts = \"translate(-50%, -50%)\";\n div.style.webkitTransform = ts;\n div.style.mozTransform = ts;\n div.style.msTransform = ts;\n div.style.oTransform = ts;\n div.style.transform = ts;\n\n // write the related component into the created element\n div._jsPlumb = this;\n\n if (params.visible === false) {\n div.style.display = \"none\";\n }\n }\n return this._jsPlumb.div;\n };\n\n this.draw = function (component, currentConnectionPaintStyle, absolutePosition) {\n var td = _getDimensions(this);\n if (td != null && td.length === 2) {\n var cxy = { x: 0, y: 0 };\n\n // absolutePosition would have been set by a call to connection.setAbsoluteOverlayPosition.\n if (absolutePosition) {\n cxy = { x: absolutePosition[0], y: absolutePosition[1] };\n }\n else if (component.pointOnPath) {\n var loc = this.loc, absolute = false;\n if (_ju.isString(this.loc) || this.loc < 0 || this.loc > 1) {\n loc = parseInt(this.loc, 10);\n absolute = true;\n }\n cxy = component.pointOnPath(loc, absolute); // a connection\n }\n else {\n var locToUse = this.loc.constructor === Array ? this.loc : this.endpointLoc;\n cxy = { x: locToUse[0] * component.w,\n y: locToUse[1] * component.h };\n }\n\n var minx = cxy.x - (td[0] / 2),\n miny = cxy.y - (td[1] / 2);\n\n return {\n component: component,\n d: { minx: minx, miny: miny, td: td, cxy: cxy },\n minX: minx,\n maxX: minx + td[0],\n minY: miny,\n maxY: miny + td[1]\n };\n }\n else {\n return {minX: 0, maxX: 0, minY: 0, maxY: 0};\n }\n };\n };\n _ju.extend(AbstractDOMOverlay, [_jp.jsPlumbUIComponent, AbstractOverlay], {\n getDimensions: function () {\n return [1,1];\n },\n setVisible: function (state) {\n if (this._jsPlumb.div) {\n this._jsPlumb.div.style.display = state ? \"block\" : \"none\";\n // if initially invisible, dimensions are 0,0 and never get updated\n if (state && this._jsPlumb.initiallyInvisible) {\n _getDimensions(this, true);\n this.component.repaint();\n this._jsPlumb.initiallyInvisible = false;\n }\n }\n },\n /*\n * Function: clearCachedDimensions\n * Clears the cached dimensions for the label. As a performance enhancement, label dimensions are\n * cached from 1.3.12 onwards. The cache is cleared when you change the label text, of course, but\n * there are other reasons why the text dimensions might change - if you make a change through CSS, for\n * example, you might change the font size. in that case you should explicitly call this method.\n */\n clearCachedDimensions: function () {\n this._jsPlumb.cachedDimensions = null;\n },\n cleanup: function (force) {\n if (force) {\n if (this._jsPlumb.div != null) {\n this._jsPlumb.div._jsPlumb = null;\n this._jsPlumb.instance.removeElement(this._jsPlumb.div);\n }\n }\n else {\n // if not a forced cleanup, just detach child from parent for now.\n if (this._jsPlumb && this._jsPlumb.div && this._jsPlumb.div.parentNode) {\n this._jsPlumb.div.parentNode.removeChild(this._jsPlumb.div);\n }\n this.detached = true;\n }\n\n },\n reattach:function(instance, component) {\n if (this._jsPlumb.div != null) {\n instance.getContainer().appendChild(this._jsPlumb.div);\n }\n this.detached = false;\n },\n computeMaxSize: function () {\n var td = _getDimensions(this);\n return Math.max(td[0], td[1]);\n },\n paint: function (p, containerExtents) {\n if (!this._jsPlumb.initialised) {\n this.getElement();\n p.component.appendDisplayElement(this._jsPlumb.div);\n this._jsPlumb.initialised = true;\n if (this.detached) {\n this._jsPlumb.div.parentNode.removeChild(this._jsPlumb.div);\n }\n }\n this._jsPlumb.div.style.left = (p.component.x + p.d.minx) + \"px\";\n this._jsPlumb.div.style.top = (p.component.y + p.d.miny) + \"px\";\n }\n });\n\n /*\n * Class: Overlays.Custom\n * A Custom overlay. You supply a 'create' function which returns some DOM element, and jsPlumb positions it.\n * The 'create' function is passed a Connection or Endpoint.\n */\n /*\n * Function: Constructor\n * \n * Parameters:\n * create - function for jsPlumb to call that returns a DOM element.\n * location - distance (as a decimal from 0 to 1 inclusive) marking where the label should sit on the connector. defaults to 0.5.\n * id - optional id to use for later retrieval of this overlay.\n *\n */\n _jp.Overlays.Custom = function (params) {\n this.type = \"Custom\";\n AbstractDOMOverlay.apply(this, arguments);\n };\n _ju.extend(_jp.Overlays.Custom, AbstractDOMOverlay);\n\n _jp.Overlays.GuideLines = function () {\n var self = this;\n self.length = 50;\n self.strokeWidth = 5;\n this.type = \"GuideLines\";\n AbstractOverlay.apply(this, arguments);\n _jp.jsPlumbUIComponent.apply(this, arguments);\n this.draw = function (connector, currentConnectionPaintStyle) {\n\n var head = connector.pointAlongPathFrom(self.loc, self.length / 2),\n mid = connector.pointOnPath(self.loc),\n tail = _jg.pointOnLine(head, mid, self.length),\n tailLine = _jg.perpendicularLineTo(head, tail, 40),\n headLine = _jg.perpendicularLineTo(tail, head, 20);\n\n return {\n connector: connector,\n head: head,\n tail: tail,\n headLine: headLine,\n tailLine: tailLine,\n minX: Math.min(head.x, tail.x, headLine[0].x, headLine[1].x),\n minY: Math.min(head.y, tail.y, headLine[0].y, headLine[1].y),\n maxX: Math.max(head.x, tail.x, headLine[0].x, headLine[1].x),\n maxY: Math.max(head.y, tail.y, headLine[0].y, headLine[1].y)\n };\n };\n\n // this.cleanup = function() { }; // nothing to clean up for GuideLines\n };\n\n /*\n * Class: Overlays.Label\n\n */\n /*\n * Function: Constructor\n * \n * Parameters:\n * cssClass - optional css class string to append to css class. This string is appended \"as-is\", so you can of course have multiple classes\n * defined. This parameter is preferred to using labelStyle, borderWidth and borderStyle.\n * label - the label to paint. May be a string or a function that returns a string. Nothing will be painted if your label is null or your\n * label function returns null. empty strings _will_ be painted.\n * location - distance (as a decimal from 0 to 1 inclusive) marking where the label should sit on the connector. defaults to 0.5.\n * id - optional id to use for later retrieval of this overlay.\n * \n *\n */\n _jp.Overlays.Label = function (params) {\n this.labelStyle = params.labelStyle;\n\n var labelWidth = null, labelHeight = null, labelText = null, labelPadding = null;\n this.cssClass = this.labelStyle != null ? this.labelStyle.cssClass : null;\n var p = _jp.extend({\n create: function () {\n return _jp.createElement(\"div\");\n }}, params);\n _jp.Overlays.Custom.call(this, p);\n this.type = \"Label\";\n this.label = params.label || \"\";\n this.labelText = null;\n if (this.labelStyle) {\n var el = this.getElement();\n this.labelStyle.font = this.labelStyle.font || \"12px sans-serif\";\n el.style.font = this.labelStyle.font;\n el.style.color = this.labelStyle.color || \"black\";\n if (this.labelStyle.fill) {\n el.style.background = this.labelStyle.fill;\n }\n if (this.labelStyle.borderWidth > 0) {\n var dStyle = this.labelStyle.borderStyle ? this.labelStyle.borderStyle : \"black\";\n el.style.border = this.labelStyle.borderWidth + \"px solid \" + dStyle;\n }\n if (this.labelStyle.padding) {\n el.style.padding = this.labelStyle.padding;\n }\n }\n\n };\n _ju.extend(_jp.Overlays.Label, _jp.Overlays.Custom, {\n cleanup: function (force) {\n if (force) {\n this.div = null;\n this.label = null;\n this.labelText = null;\n this.cssClass = null;\n this.labelStyle = null;\n }\n },\n getLabel: function () {\n return this.label;\n },\n /*\n * Function: setLabel\n * sets the label's, um, label. you would think i'd call this function\n * 'setText', but you can pass either a Function or a String to this, so\n * it makes more sense as 'setLabel'. This uses innerHTML on the label div, so keep\n * that in mind if you need escaped HTML.\n */\n setLabel: function (l) {\n this.label = l;\n this.labelText = null;\n this.clearCachedDimensions();\n this.update();\n this.component.repaint();\n },\n getDimensions: function () {\n this.update();\n return AbstractDOMOverlay.prototype.getDimensions.apply(this, arguments);\n },\n update: function () {\n if (typeof this.label === \"function\") {\n var lt = this.label(this);\n this.getElement().innerHTML = lt.replace(/\\r\\n/g, \" \");\n }\n else {\n if (this.labelText == null) {\n this.labelText = this.label;\n this.getElement().innerHTML = this.labelText.replace(/\\r\\n/g, \" \");\n }\n }\n },\n updateFrom:function(d) {\n if(d.label != null){\n this.setLabel(d.label);\n }\n }\n });\n\n // ********************************* END OF OVERLAY DEFINITIONS ***********************************************************************\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;(function() {\n \"use strict\";\n\n var root = this,\n _ju = root.jsPlumbUtil,\n _jpi = root.jsPlumbInstance;\n\n var GROUP_COLLAPSED_CLASS = \"jtk-group-collapsed\";\n var GROUP_EXPANDED_CLASS = \"jtk-group-expanded\";\n var GROUP_CONTAINER_SELECTOR = \"[jtk-group-content]\";\n var ELEMENT_DRAGGABLE_EVENT = \"elementDraggable\";\n var STOP = \"stop\";\n var REVERT = \"revert\";\n var GROUP_MANAGER = \"_groupManager\";\n var GROUP = \"_jsPlumbGroup\";\n var GROUP_DRAG_SCOPE = \"_jsPlumbGroupDrag\";\n var EVT_CHILD_ADDED = \"group:addMember\";\n var EVT_CHILD_REMOVED = \"group:removeMember\";\n var EVT_GROUP_ADDED = \"group:add\";\n var EVT_GROUP_REMOVED = \"group:remove\";\n var EVT_EXPAND = \"group:expand\";\n var EVT_COLLAPSE = \"group:collapse\";\n var EVT_GROUP_DRAG_STOP = \"groupDragStop\";\n var EVT_CONNECTION_MOVED = \"connectionMoved\";\n var EVT_INTERNAL_CONNECTION_DETACHED = \"internal.connectionDetached\";\n\n var CMD_REMOVE_ALL = \"removeAll\";\n var CMD_ORPHAN_ALL = \"orphanAll\";\n var CMD_SHOW = \"show\";\n var CMD_HIDE = \"hide\";\n\n var GroupManager = function(_jsPlumb) {\n var _managedGroups = {}, _connectionSourceMap = {}, _connectionTargetMap = {}, self = this;\n\n _jsPlumb.bind(\"connection\", function(p) {\n if (p.source[GROUP] != null && p.target[GROUP] != null && p.source[GROUP] === p.target[GROUP]) {\n _connectionSourceMap[p.connection.id] = p.source[GROUP];\n _connectionTargetMap[p.connection.id] = p.source[GROUP];\n }\n else {\n if (p.source[GROUP] != null) {\n _ju.suggest(p.source[GROUP].connections.source, p.connection);\n _connectionSourceMap[p.connection.id] = p.source[GROUP];\n }\n if (p.target[GROUP] != null) {\n _ju.suggest(p.target[GROUP].connections.target, p.connection);\n _connectionTargetMap[p.connection.id] = p.target[GROUP];\n }\n }\n });\n\n function _cleanupDetachedConnection(conn) {\n delete conn.proxies;\n var group = _connectionSourceMap[conn.id], f;\n if (group != null) {\n f = function(c) { return c.id === conn.id; };\n _ju.removeWithFunction(group.connections.source, f);\n _ju.removeWithFunction(group.connections.target, f);\n delete _connectionSourceMap[conn.id];\n }\n\n group = _connectionTargetMap[conn.id];\n if (group != null) {\n f = function(c) { return c.id === conn.id; };\n _ju.removeWithFunction(group.connections.source, f);\n _ju.removeWithFunction(group.connections.target, f);\n delete _connectionTargetMap[conn.id];\n }\n }\n\n _jsPlumb.bind(EVT_INTERNAL_CONNECTION_DETACHED, function(p) {\n _cleanupDetachedConnection(p.connection);\n });\n\n _jsPlumb.bind(EVT_CONNECTION_MOVED, function(p) {\n var connMap = p.index === 0 ? _connectionSourceMap : _connectionTargetMap;\n var group = connMap[p.connection.id];\n if (group) {\n var list = group.connections[p.index === 0 ? \"source\" : \"target\"];\n var idx = list.indexOf(p.connection);\n if (idx !== -1) {\n list.splice(idx, 1);\n }\n }\n });\n\n this.addGroup = function(group) {\n _jsPlumb.addClass(group.getEl(), GROUP_EXPANDED_CLASS);\n _managedGroups[group.id] = group;\n group.manager = this;\n _updateConnectionsForGroup(group);\n _jsPlumb.fire(EVT_GROUP_ADDED, { group:group });\n };\n\n this.addToGroup = function(group, el, doNotFireEvent) {\n group = this.getGroup(group);\n if (group) {\n var groupEl = group.getEl();\n\n if (el._isJsPlumbGroup) {\n return;\n }\n var currentGroup = el._jsPlumbGroup;\n // if already a member of this group, do nothing\n if (currentGroup !== group) {\n var elpos = _jsPlumb.getOffset(el, true);\n var cpos = group.collapsed ? _jsPlumb.getOffset(groupEl, true) : _jsPlumb.getOffset(group.getDragArea(), true);\n\n // otherwise, transfer to this group.\n if (currentGroup != null) {\n currentGroup.remove(el, false, doNotFireEvent, false, group);\n self.updateConnectionsForGroup(currentGroup);\n }\n group.add(el, doNotFireEvent/*, currentGroup*/);\n\n var handleDroppedConnections = function (list, index) {\n var oidx = index === 0 ? 1 : 0;\n list.each(function (c) {\n c.setVisible(false);\n if (c.endpoints[oidx].element._jsPlumbGroup === group) {\n c.endpoints[oidx].setVisible(false);\n self.expandConnection(c, oidx, group);\n }\n else {\n c.endpoints[index].setVisible(false);\n self.collapseConnection(c, index, group);\n }\n });\n };\n\n if (group.collapsed) {\n handleDroppedConnections(_jsPlumb.select({source: el}), 0);\n handleDroppedConnections(_jsPlumb.select({target: el}), 1);\n }\n\n var elId = _jsPlumb.getId(el);\n _jsPlumb.dragManager.setParent(el, elId, groupEl, _jsPlumb.getId(groupEl), elpos);\n\n var newPosition = { left: elpos.left - cpos.left, top: elpos.top - cpos.top };\n\n _jsPlumb.setPosition(el, newPosition);\n\n _jsPlumb.dragManager.revalidateParent(el, elId, elpos);\n\n self.updateConnectionsForGroup(group);\n\n _jsPlumb.revalidate(elId);\n\n if (!doNotFireEvent) {\n var p = {group: group, el: el};\n if (currentGroup) {\n p.sourceGroup = currentGroup;\n }\n _jsPlumb.fire(EVT_CHILD_ADDED, p);\n }\n }\n }\n };\n\n this.removeFromGroup = function(group, el, doNotFireEvent) {\n group = this.getGroup(group);\n if (group) {\n group.remove(el, null, doNotFireEvent);\n }\n };\n\n this.getGroup = function(groupId) {\n var group = groupId;\n if (_ju.isString(groupId)) {\n group = _managedGroups[groupId];\n if (group == null) {\n throw new TypeError(\"No such group [\" + groupId + \"]\");\n }\n }\n return group;\n };\n\n this.getGroups = function() {\n var o = [];\n for (var g in _managedGroups) {\n o.push(_managedGroups[g]);\n }\n return o;\n };\n\n this.removeGroup = function(group, deleteMembers, manipulateDOM, doNotFireEvent) {\n group = this.getGroup(group);\n this.expandGroup(group, true); // this reinstates any original connections and removes all proxies, but does not fire an event.\n var newPositions = group[deleteMembers ? CMD_REMOVE_ALL : CMD_ORPHAN_ALL](manipulateDOM, doNotFireEvent);\n _jsPlumb.remove(group.getEl());\n delete _managedGroups[group.id];\n delete _jsPlumb._groups[group.id];\n _jsPlumb.fire(EVT_GROUP_REMOVED, { group:group });\n return newPositions; // this will be null in the case or remove, but be a map of {id->[x,y]} in the case of orphan\n };\n\n this.removeAllGroups = function(deleteMembers, manipulateDOM, doNotFireEvent) {\n for (var g in _managedGroups) {\n this.removeGroup(_managedGroups[g], deleteMembers, manipulateDOM, doNotFireEvent);\n }\n };\n\n function _setVisible(group, state) {\n var m = group.getMembers();\n for (var i = 0; i < m.length; i++) {\n _jsPlumb[state ? CMD_SHOW : CMD_HIDE](m[i], true);\n }\n }\n\n var _collapseConnection = this.collapseConnection = function(c, index, group) {\n\n var proxyEp, groupEl = group.getEl(), groupElId = _jsPlumb.getId(groupEl),\n originalElementId = c.endpoints[index].elementId;\n\n var otherEl = c.endpoints[index === 0 ? 1 : 0].element;\n if (otherEl[GROUP] && (!otherEl[GROUP].shouldProxy() && otherEl[GROUP].collapsed)) {\n return;\n }\n\n c.proxies = c.proxies || [];\n if(c.proxies[index]) {\n proxyEp = c.proxies[index].ep;\n }else {\n proxyEp = _jsPlumb.addEndpoint(groupEl, {\n endpoint:group.getEndpoint(c, index),\n anchor:group.getAnchor(c, index),\n parameters:{\n isProxyEndpoint:true\n }\n });\n }\n proxyEp.setDeleteOnEmpty(true);\n\n // for this index, stash proxy info: the new EP, the original EP.\n c.proxies[index] = { ep:proxyEp, originalEp: c.endpoints[index] };\n\n // and advise the anchor manager\n if (index === 0) {\n // TODO why are there two differently named methods? Why is there not one method that says \"some end of this\n // connection changed (you give the index), and here's the new element and element id.\"\n _jsPlumb.anchorManager.sourceChanged(originalElementId, groupElId, c, groupEl);\n }\n else {\n _jsPlumb.anchorManager.updateOtherEndpoint(c.endpoints[0].elementId, originalElementId, groupElId, c);\n c.target = groupEl;\n c.targetId = groupElId;\n }\n\n\n // detach the original EP from the connection.\n c.proxies[index].originalEp.detachFromConnection(c, null, true);\n\n // set the proxy as the new ep\n proxyEp.connections = [ c ];\n c.endpoints[index] = proxyEp;\n\n c.setVisible(true);\n };\n\n this.collapseGroup = function(group) {\n group = this.getGroup(group);\n if (group == null || group.collapsed) {\n return;\n }\n var groupEl = group.getEl();\n\n // todo remove old proxy endpoints first, just in case?\n //group.proxies.length = 0;\n\n // hide all connections\n _setVisible(group, false);\n\n if (group.shouldProxy()) {\n // collapses all connections in a group.\n var _collapseSet = function (conns, index) {\n for (var i = 0; i < conns.length; i++) {\n var c = conns[i];\n _collapseConnection(c, index, group);\n }\n };\n\n // setup proxies for sources and targets\n _collapseSet(group.connections.source, 0);\n _collapseSet(group.connections.target, 1);\n }\n\n group.collapsed = true;\n _jsPlumb.removeClass(groupEl, GROUP_EXPANDED_CLASS);\n _jsPlumb.addClass(groupEl, GROUP_COLLAPSED_CLASS);\n _jsPlumb.revalidate(groupEl);\n _jsPlumb.fire(EVT_COLLAPSE, { group:group });\n };\n\n var _expandConnection = this.expandConnection = function(c, index, group) {\n\n // if no proxies or none for this end of the connection, abort.\n if (c.proxies == null || c.proxies[index] == null) {\n return;\n }\n\n var groupElId = _jsPlumb.getId(group.getEl()),\n originalElement = c.proxies[index].originalEp.element,\n originalElementId = c.proxies[index].originalEp.elementId;\n\n c.endpoints[index] = c.proxies[index].originalEp;\n // and advise the anchor manager\n if (index === 0) {\n // TODO why are there two differently named methods? Why is there not one method that says \"some end of this\n // connection changed (you give the index), and here's the new element and element id.\"\n _jsPlumb.anchorManager.sourceChanged(groupElId, originalElementId, c, originalElement);\n }\n else {\n _jsPlumb.anchorManager.updateOtherEndpoint(c.endpoints[0].elementId, groupElId, originalElementId, c);\n c.target = originalElement;\n c.targetId = originalElementId;\n }\n\n // detach the proxy EP from the connection (which will cause it to be removed as we no longer need it)\n c.proxies[index].ep.detachFromConnection(c, null);\n\n c.proxies[index].originalEp.addConnection(c);\n\n // cleanup\n delete c.proxies[index];\n };\n\n this.expandGroup = function(group, doNotFireEvent) {\n\n group = this.getGroup(group);\n\n if (group == null || !group.collapsed) {\n return;\n }\n var groupEl = group.getEl();\n\n _setVisible(group, true);\n\n if (group.shouldProxy()) {\n // collapses all connections in a group.\n var _expandSet = function (conns, index) {\n for (var i = 0; i < conns.length; i++) {\n var c = conns[i];\n _expandConnection(c, index, group);\n }\n };\n\n // setup proxies for sources and targets\n _expandSet(group.connections.source, 0);\n _expandSet(group.connections.target, 1);\n }\n\n group.collapsed = false;\n _jsPlumb.addClass(groupEl, GROUP_EXPANDED_CLASS);\n _jsPlumb.removeClass(groupEl, GROUP_COLLAPSED_CLASS);\n _jsPlumb.revalidate(groupEl);\n this.repaintGroup(group);\n if (!doNotFireEvent) {\n _jsPlumb.fire(EVT_EXPAND, { group: group});\n }\n };\n\n this.repaintGroup = function(group) {\n group = this.getGroup(group);\n var m = group.getMembers();\n for (var i = 0; i < m.length; i++) {\n _jsPlumb.revalidate(m[i]);\n }\n };\n\n // TODO refactor this with the code that responds to `connection` events.\n function _updateConnectionsForGroup(group) {\n var members = group.getMembers();\n var c1 = _jsPlumb.getConnections({source:members, scope:\"*\"}, true);\n var c2 = _jsPlumb.getConnections({target:members, scope:\"*\"}, true);\n var processed = {};\n group.connections.source.length = 0;\n group.connections.target.length = 0;\n var oneSet = function(c) {\n for (var i = 0; i < c.length; i++) {\n if (processed[c[i].id]) {\n continue;\n }\n processed[c[i].id] = true;\n if (c[i].source._jsPlumbGroup === group) {\n if (c[i].target._jsPlumbGroup !== group) {\n group.connections.source.push(c[i]);\n }\n _connectionSourceMap[c[i].id] = group;\n }\n else if (c[i].target._jsPlumbGroup === group) {\n group.connections.target.push(c[i]);\n _connectionTargetMap[c[i].id] = group;\n }\n }\n };\n oneSet(c1); oneSet(c2);\n }\n\n this.updateConnectionsForGroup = _updateConnectionsForGroup;\n this.refreshAllGroups = function() {\n for (var g in _managedGroups) {\n _updateConnectionsForGroup(_managedGroups[g]);\n _jsPlumb.dragManager.updateOffsets(_jsPlumb.getId(_managedGroups[g].getEl()));\n }\n };\n };\n\n /**\n *\n * @param {jsPlumbInstance} _jsPlumb Associated jsPlumb instance.\n * @param {Object} params\n * @param {Element} params.el The DOM element representing the Group.\n * @param {String} [params.id] Optional ID for the Group. A UUID will be assigned as the Group's ID if you do not provide one.\n * @param {Boolean} [params.constrain=false] If true, child elements will not be able to be dragged outside of the Group container.\n * @param {Boolean} [params.revert=true] By default, child elements revert to the container if dragged outside. You can change this by setting `revert:false`. This behaviour is also overridden if you set `orphan` or `prune`.\n * @param {Boolean} [params.orphan=false] If true, child elements dropped outside of the Group container will be removed from the Group (but not from the DOM).\n * @param {Boolean} [params.prune=false] If true, child elements dropped outside of the Group container will be removed from the Group and also from the DOM.\n * @param {Boolean} [params.dropOverride=false] If true, a child element that has been dropped onto some other Group will not be subject to the controls imposed by `prune`, `revert` or `orphan`.\n * @constructor\n */\n var Group = function(_jsPlumb, params) {\n var self = this;\n var el = params.el;\n this.getEl = function() { return el; };\n this.id = params.id || _ju.uuid();\n el._isJsPlumbGroup = true;\n\n var getDragArea = this.getDragArea = function() {\n var da = _jsPlumb.getSelector(el, GROUP_CONTAINER_SELECTOR);\n return da && da.length > 0 ? da[0] : el;\n };\n\n var ghost = params.ghost === true;\n var constrain = ghost || (params.constrain === true);\n var revert = params.revert !== false;\n var orphan = params.orphan === true;\n var prune = params.prune === true;\n var dropOverride = params.dropOverride === true;\n var proxied = params.proxied !== false;\n var elements = [];\n this.connections = { source:[], target:[], internal:[] };\n\n // this function, and getEndpoint below, are stubs for a future setup in which we can choose endpoint\n // and anchor based upon the connection and the index (source/target) of the endpoint to be proxied.\n this.getAnchor = function(conn, endpointIndex) {\n return params.anchor || \"Continuous\";\n };\n\n this.getEndpoint = function(conn, endpointIndex) {\n return params.endpoint || [ \"Dot\", { radius:10 }];\n };\n\n this.collapsed = false;\n if (params.draggable !== false) {\n var opts = {\n stop:function(params) {\n _jsPlumb.fire(EVT_GROUP_DRAG_STOP, jsPlumb.extend(params, {group:self}));\n },\n scope:GROUP_DRAG_SCOPE\n };\n if (params.dragOptions) {\n root.jsPlumb.extend(opts, params.dragOptions);\n }\n _jsPlumb.draggable(params.el, opts);\n }\n if (params.droppable !== false) {\n _jsPlumb.droppable(params.el, {\n drop:function(p) {\n var el = p.drag.el;\n if (el._isJsPlumbGroup) {\n return;\n }\n var currentGroup = el._jsPlumbGroup;\n if (currentGroup !== self) {\n if (currentGroup != null) {\n if (currentGroup.overrideDrop(el, self)) {\n return;\n }\n }\n _jsPlumb.getGroupManager().addToGroup(self, el, false);\n }\n\n }\n });\n }\n var _each = function(_el, fn) {\n var els = _el.nodeType == null ? _el : [ _el ];\n for (var i = 0; i < els.length; i++) {\n fn(els[i]);\n }\n };\n\n this.overrideDrop = function(_el, targetGroup) {\n return dropOverride && (revert || prune || orphan);\n };\n\n this.add = function(_el, doNotFireEvent/*, sourceGroup*/) {\n var dragArea = getDragArea();\n _each(_el, function(__el) {\n\n if (__el._jsPlumbGroup != null) {\n if (__el._jsPlumbGroup === self) {\n return;\n } else {\n __el._jsPlumbGroup.remove(__el, true, doNotFireEvent, false);\n }\n }\n\n __el._jsPlumbGroup = self;\n elements.push(__el);\n // test if draggable and add handlers if so.\n if (_jsPlumb.isAlreadyDraggable(__el)) {\n _bindDragHandlers(__el);\n }\n\n if (__el.parentNode !== dragArea) {\n dragArea.appendChild(__el);\n }\n\n // if (!doNotFireEvent) {\n // var p = {group: self, el: __el};\n // if (sourceGroup) {\n // p.sourceGroup = sourceGroup;\n // }\n // //_jsPlumb.fire(EVT_CHILD_ADDED, p);\n // }\n });\n\n _jsPlumb.getGroupManager().updateConnectionsForGroup(self);\n };\n\n this.remove = function(el, manipulateDOM, doNotFireEvent, doNotUpdateConnections, targetGroup) {\n\n _each(el, function(__el) {\n delete __el._jsPlumbGroup;\n _ju.removeWithFunction(elements, function(e) {\n return e === __el;\n });\n\n if (manipulateDOM) {\n try { self.getDragArea().removeChild(__el); }\n catch (e) {\n jsPlumbUtil.log(\"Could not remove element from Group \" + e);\n }\n }\n _unbindDragHandlers(__el);\n if (!doNotFireEvent) {\n var p = {group: self, el: __el};\n if (targetGroup) {\n p.targetGroup = targetGroup;\n }\n _jsPlumb.fire(EVT_CHILD_REMOVED, p);\n }\n });\n if (!doNotUpdateConnections) {\n _jsPlumb.getGroupManager().updateConnectionsForGroup(self);\n }\n };\n this.removeAll = function(manipulateDOM, doNotFireEvent) {\n for (var i = 0, l = elements.length; i < l; i++) {\n var el = elements[0];\n self.remove(el, manipulateDOM, doNotFireEvent, true);\n _jsPlumb.remove(el, true);\n }\n elements.length = 0;\n _jsPlumb.getGroupManager().updateConnectionsForGroup(self);\n };\n this.orphanAll = function() {\n var orphanedPositions = {};\n for (var i = 0; i < elements.length; i++) {\n var newPosition = _orphan(elements[i]);\n orphanedPositions[newPosition[0]] = newPosition[1];\n }\n elements.length = 0;\n\n return orphanedPositions;\n };\n this.getMembers = function() { return elements; };\n\n el[GROUP] = this;\n\n _jsPlumb.bind(ELEMENT_DRAGGABLE_EVENT, function(dragParams) {\n // if its for the current group,\n if (dragParams.el._jsPlumbGroup === this) {\n _bindDragHandlers(dragParams.el);\n }\n }.bind(this));\n\n function _findParent(_el) {\n return _el.offsetParent;\n }\n\n function _isInsideParent(_el, pos) {\n var p = _findParent(_el),\n s = _jsPlumb.getSize(p),\n ss = _jsPlumb.getSize(_el),\n leftEdge = pos[0],\n rightEdge = leftEdge + ss[0],\n topEdge = pos[1],\n bottomEdge = topEdge + ss[1];\n\n return rightEdge > 0 && leftEdge < s[0] && bottomEdge > 0 && topEdge < s[1];\n }\n\n //\n // orphaning an element means taking it out of the group and adding it to the main jsplumb container.\n // we return the new calculated position from this method and the element's id.\n //\n function _orphan(_el) {\n var id = _jsPlumb.getId(_el);\n var pos = _jsPlumb.getOffset(_el);\n _el.parentNode.removeChild(_el);\n _jsPlumb.getContainer().appendChild(_el);\n _jsPlumb.setPosition(_el, pos);\n delete _el._jsPlumbGroup;\n _unbindDragHandlers(_el);\n _jsPlumb.dragManager.clearParent(_el, id);\n return [id, pos];\n }\n\n //\n // remove an element from the group, then either prune it from the jsplumb instance, or just orphan it.\n //\n function _pruneOrOrphan(p) {\n var orphanedPosition = null;\n if (!_isInsideParent(p.el, p.pos)) {\n var group = p.el._jsPlumbGroup;\n if (prune) {\n _jsPlumb.remove(p.el);\n } else {\n orphanedPosition = _orphan(p.el);\n }\n\n group.remove(p.el);\n }\n\n return orphanedPosition;\n }\n\n //\n // redraws the element\n //\n function _revalidate(_el) {\n var id = _jsPlumb.getId(_el);\n _jsPlumb.revalidate(_el);\n _jsPlumb.dragManager.revalidateParent(_el, id);\n }\n\n //\n // unbind the group specific drag/revert handlers.\n //\n function _unbindDragHandlers(_el) {\n if (!_el._katavorioDrag) {\n return;\n }\n if (prune || orphan) {\n _el._katavorioDrag.off(STOP, _pruneOrOrphan);\n }\n if (!prune && !orphan && revert) {\n _el._katavorioDrag.off(REVERT, _revalidate);\n _el._katavorioDrag.setRevert(null);\n }\n }\n\n function _bindDragHandlers(_el) {\n if (!_el._katavorioDrag) {\n return;\n }\n if (prune || orphan) {\n _el._katavorioDrag.on(STOP, _pruneOrOrphan);\n }\n\n if (constrain) {\n _el._katavorioDrag.setConstrain(true);\n }\n\n if (ghost) {\n _el._katavorioDrag.setUseGhostProxy(true);\n }\n\n if (!prune && !orphan && revert) {\n _el._katavorioDrag.on(REVERT, _revalidate);\n _el._katavorioDrag.setRevert(function(__el, pos) {\n return !_isInsideParent(__el, pos);\n });\n }\n }\n\n this.shouldProxy = function() {\n return proxied;\n };\n\n _jsPlumb.getGroupManager().addGroup(this);\n };\n\n /**\n * Adds a group to the jsPlumb instance.\n * @method addGroup\n * @param {Object} params\n * @return {Group} The newly created Group.\n */\n _jpi.prototype.addGroup = function(params) {\n var j = this;\n j._groups = j._groups || {};\n if (j._groups[params.id] != null) {\n throw new TypeError(\"cannot create Group [\" + params.id + \"]; a Group with that ID exists\");\n }\n if (params.el[GROUP] != null) {\n throw new TypeError(\"cannot create Group [\" + params.id + \"]; the given element is already a Group\");\n }\n var group = new Group(j, params);\n j._groups[group.id] = group;\n if (params.collapsed) {\n this.collapseGroup(group);\n }\n return group;\n };\n\n /**\n * Add an element to a group.\n * @method addToGroup\n * @param {String} group Group, or ID of the group, to add the element to.\n * @param {Element} el Element to add to the group.\n */\n _jpi.prototype.addToGroup = function(group, el, doNotFireEvent) {\n\n var _one = function(_el) {\n var id = this.getId(_el);\n this.manage(id, _el);\n this.getGroupManager().addToGroup(group, _el, doNotFireEvent);\n }.bind(this);\n\n if (Array.isArray(el)) {\n for (var i = 0; i < el.length; i++) {\n _one(el[i]);\n }\n } else {\n _one(el);\n }\n };\n\n /**\n * Remove an element from a group.\n * @method removeFromGroup\n * @param {String} group Group, or ID of the group, to remove the element from.\n * @param {Element} el Element to add to the group.\n */\n _jpi.prototype.removeFromGroup = function(group, el, doNotFireEvent) {\n this.getGroupManager().removeFromGroup(group, el, doNotFireEvent);\n };\n\n /**\n * Remove a group, and optionally remove its members from the jsPlumb instance.\n * @method removeGroup\n * @param {String|Group} group Group to delete, or ID of Group to delete.\n * @param {Boolean} [deleteMembers=false] If true, group members will be removed along with the group. Otherwise they will\n * just be 'orphaned' (returned to the main container).\n * @returns {Map[String, Position}} When deleteMembers is false, this method returns a map of {id->position}\n */\n _jpi.prototype.removeGroup = function(group, deleteMembers, manipulateDOM, doNotFireEvent) {\n return this.getGroupManager().removeGroup(group, deleteMembers, manipulateDOM, doNotFireEvent);\n };\n\n /**\n * Remove all groups, and optionally remove their members from the jsPlumb instance.\n * @method removeAllGroup\n * @param {Boolean} [deleteMembers=false] If true, group members will be removed along with the groups. Otherwise they will\n * just be 'orphaned' (returned to the main container).\n */\n _jpi.prototype.removeAllGroups = function(deleteMembers, manipulateDOM, doNotFireEvent) {\n this.getGroupManager().removeAllGroups(deleteMembers, manipulateDOM, doNotFireEvent);\n };\n\n /**\n * Get a Group\n * @method getGroup\n * @param {String} groupId ID of the group to get\n * @return {Group} Group with the given ID, null if not found.\n */\n _jpi.prototype.getGroup = function(groupId) {\n return this.getGroupManager().getGroup(groupId);\n };\n\n /**\n * Gets all the Groups managed by the jsPlumb instance.\n * @returns {Group[]} List of Groups. Empty if none.\n */\n _jpi.prototype.getGroups = function() {\n return this.getGroupManager().getGroups();\n };\n\n /**\n * Expands a group element. jsPlumb doesn't do \"everything\" for you here, because what it means to expand a Group\n * will vary from application to application. jsPlumb does these things:\n *\n * - Hides any connections that are internal to the group (connections between members, and connections from member of\n * the group to the group itself)\n * - Proxies all connections for which the source or target is a member of the group.\n * - Hides the proxied connections.\n * - Adds the jtk-group-expanded class to the group's element\n * - Removes the jtk-group-collapsed class from the group's element.\n *\n * @method expandGroup\n * @param {String|Group} group Group to expand, or ID of Group to expand.\n */\n _jpi.prototype.expandGroup = function(group) {\n this.getGroupManager().expandGroup(group);\n };\n\n /**\n * Collapses a group element. jsPlumb doesn't do \"everything\" for you here, because what it means to collapse a Group\n * will vary from application to application. jsPlumb does these things:\n *\n * - Shows any connections that are internal to the group (connections between members, and connections from member of\n * the group to the group itself)\n * - Removes proxies for all connections for which the source or target is a member of the group.\n * - Shows the previously proxied connections.\n * - Adds the jtk-group-collapsed class to the group's element\n * - Removes the jtk-group-expanded class from the group's element.\n *\n * @method expandGroup\n * @param {String|Group} group Group to expand, or ID of Group to expand.\n */\n _jpi.prototype.collapseGroup = function(groupId) {\n this.getGroupManager().collapseGroup(groupId);\n };\n\n\n _jpi.prototype.repaintGroup = function(group) {\n this.getGroupManager().repaintGroup(group);\n };\n\n /**\n * Collapses or expands a group element depending on its current state. See notes in the collapseGroup and expandGroup method.\n *\n * @method toggleGroup\n * @param {String|Group} group Group to expand/collapse, or ID of Group to expand/collapse.\n */\n _jpi.prototype.toggleGroup = function(group) {\n group = this.getGroupManager().getGroup(group);\n if (group != null) {\n this.getGroupManager()[group.collapsed ? \"expandGroup\" : \"collapseGroup\"](group);\n }\n };\n\n //\n // lazy init a group manager for the given jsplumb instance.\n //\n _jpi.prototype.getGroupManager = function() {\n var mgr = this[GROUP_MANAGER];\n if (mgr == null) {\n mgr = this[GROUP_MANAGER] = new GroupManager(this);\n }\n return mgr;\n };\n\n _jpi.prototype.removeGroupManager = function() {\n delete this[GROUP_MANAGER];\n };\n\n /**\n * Gets the Group that the given element belongs to, null if none.\n * @method getGroupFor\n * @param {String|Element} el Element, or element ID.\n * @returns {Group} A Group, if found, or null.\n */\n _jpi.prototype.getGroupFor = function(el) {\n el = this.getElement(el);\n if (el) {\n return el[GROUP];\n }\n };\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n\n/*\n * This file contains the 'flowchart' connectors, consisting of vertical and horizontal line segments.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n var STRAIGHT = \"Straight\";\n var ARC = \"Arc\";\n\n var Flowchart = function (params) {\n this.type = \"Flowchart\";\n params = params || {};\n params.stub = params.stub == null ? 30 : params.stub;\n var segments,\n _super = _jp.Connectors.AbstractConnector.apply(this, arguments),\n midpoint = params.midpoint == null ? 0.5 : params.midpoint,\n alwaysRespectStubs = params.alwaysRespectStubs === true,\n lastx = null, lasty = null, lastOrientation,\n cornerRadius = params.cornerRadius != null ? params.cornerRadius : 0,\n\n // TODO now common between this and AbstractBezierEditor; refactor into superclass?\n loopbackRadius = params.loopbackRadius || 25,\n isLoopbackCurrently = false,\n\n sgn = function (n) {\n return n < 0 ? -1 : n === 0 ? 0 : 1;\n },\n segmentDirections = function(segment) {\n return [\n sgn( segment[2] - segment[0] ),\n sgn( segment[3] - segment[1] )\n ];\n },\n /**\n * helper method to add a segment.\n */\n addSegment = function (segments, x, y, paintInfo) {\n if (lastx === x && lasty === y) {\n return;\n }\n var lx = lastx == null ? paintInfo.sx : lastx,\n ly = lasty == null ? paintInfo.sy : lasty,\n o = lx === x ? \"v\" : \"h\";\n\n lastx = x;\n lasty = y;\n segments.push([ lx, ly, x, y, o ]);\n },\n segLength = function (s) {\n return Math.sqrt(Math.pow(s[0] - s[2], 2) + Math.pow(s[1] - s[3], 2));\n },\n _cloneArray = function (a) {\n var _a = [];\n _a.push.apply(_a, a);\n return _a;\n },\n writeSegments = function (conn, segments, paintInfo) {\n var current = null, next, currentDirection, nextDirection;\n for (var i = 0; i < segments.length - 1; i++) {\n\n current = current || _cloneArray(segments[i]);\n next = _cloneArray(segments[i + 1]);\n\n currentDirection = segmentDirections(current);\n nextDirection = segmentDirections(next);\n\n if (cornerRadius > 0 && current[4] !== next[4]) {\n\n var minSegLength = Math.min(segLength(current), segLength(next));\n var radiusToUse = Math.min(cornerRadius, minSegLength / 2);\n\n current[2] -= currentDirection[0] * radiusToUse;\n current[3] -= currentDirection[1] * radiusToUse;\n next[0] += nextDirection[0] * radiusToUse;\n next[1] += nextDirection[1] * radiusToUse;\n\n var ac = (currentDirection[1] === nextDirection[0] && nextDirection[0] === 1) ||\n ((currentDirection[1] === nextDirection[0] && nextDirection[0] === 0) && currentDirection[0] !== nextDirection[1]) ||\n (currentDirection[1] === nextDirection[0] && nextDirection[0] === -1),\n sgny = next[1] > current[3] ? 1 : -1,\n sgnx = next[0] > current[2] ? 1 : -1,\n sgnEqual = sgny === sgnx,\n cx = (sgnEqual && ac || (!sgnEqual && !ac)) ? next[0] : current[2],\n cy = (sgnEqual && ac || (!sgnEqual && !ac)) ? current[3] : next[1];\n\n _super.addSegment(conn, STRAIGHT, {\n x1: current[0], y1: current[1], x2: current[2], y2: current[3]\n });\n\n _super.addSegment(conn, ARC, {\n r: radiusToUse,\n x1: current[2],\n y1: current[3],\n x2: next[0],\n y2: next[1],\n cx: cx,\n cy: cy,\n ac: ac\n });\n }\n else {\n // dx + dy are used to adjust for line width.\n var dx = (current[2] === current[0]) ? 0 : (current[2] > current[0]) ? (paintInfo.lw / 2) : -(paintInfo.lw / 2),\n dy = (current[3] === current[1]) ? 0 : (current[3] > current[1]) ? (paintInfo.lw / 2) : -(paintInfo.lw / 2);\n\n _super.addSegment(conn, STRAIGHT, {\n x1: current[0] - dx, y1: current[1] - dy, x2: current[2] + dx, y2: current[3] + dy\n });\n }\n current = next;\n }\n if (next != null) {\n // last segment\n _super.addSegment(conn, STRAIGHT, {\n x1: next[0], y1: next[1], x2: next[2], y2: next[3]\n });\n }\n };\n\n this._compute = function (paintInfo, params) {\n\n segments = [];\n lastx = null;\n lasty = null;\n lastOrientation = null;\n\n var commonStubCalculator = function () {\n return [paintInfo.startStubX, paintInfo.startStubY, paintInfo.endStubX, paintInfo.endStubY];\n },\n stubCalculators = {\n perpendicular: commonStubCalculator,\n orthogonal: commonStubCalculator,\n opposite: function (axis) {\n var pi = paintInfo,\n idx = axis === \"x\" ? 0 : 1,\n areInProximity = {\n \"x\": function () {\n return ( (pi.so[idx] === 1 && (\n ( (pi.startStubX > pi.endStubX) && (pi.tx > pi.startStubX) ) ||\n ( (pi.sx > pi.endStubX) && (pi.tx > pi.sx))))) ||\n\n ( (pi.so[idx] === -1 && (\n ( (pi.startStubX < pi.endStubX) && (pi.tx < pi.startStubX) ) ||\n ( (pi.sx < pi.endStubX) && (pi.tx < pi.sx)))));\n },\n \"y\": function () {\n return ( (pi.so[idx] === 1 && (\n ( (pi.startStubY > pi.endStubY) && (pi.ty > pi.startStubY) ) ||\n ( (pi.sy > pi.endStubY) && (pi.ty > pi.sy))))) ||\n\n ( (pi.so[idx] === -1 && (\n ( (pi.startStubY < pi.endStubY) && (pi.ty < pi.startStubY) ) ||\n ( (pi.sy < pi.endStubY) && (pi.ty < pi.sy)))));\n }\n };\n\n if (!alwaysRespectStubs && areInProximity[axis]()) {\n return {\n \"x\": [(paintInfo.sx + paintInfo.tx) / 2, paintInfo.startStubY, (paintInfo.sx + paintInfo.tx) / 2, paintInfo.endStubY],\n \"y\": [paintInfo.startStubX, (paintInfo.sy + paintInfo.ty) / 2, paintInfo.endStubX, (paintInfo.sy + paintInfo.ty) / 2]\n }[axis];\n }\n else {\n return [paintInfo.startStubX, paintInfo.startStubY, paintInfo.endStubX, paintInfo.endStubY];\n }\n }\n };\n\n // calculate Stubs.\n var stubs = stubCalculators[paintInfo.anchorOrientation](paintInfo.sourceAxis),\n idx = paintInfo.sourceAxis === \"x\" ? 0 : 1,\n oidx = paintInfo.sourceAxis === \"x\" ? 1 : 0,\n ss = stubs[idx],\n oss = stubs[oidx],\n es = stubs[idx + 2],\n oes = stubs[oidx + 2];\n\n // add the start stub segment. use stubs for loopback as it will look better, with the loop spaced\n // away from the element.\n addSegment(segments, stubs[0], stubs[1], paintInfo);\n\n // if its a loopback and we should treat it differently.\n // if (false && params.sourcePos[0] === params.targetPos[0] && params.sourcePos[1] === params.targetPos[1]) {\n //\n // // we use loopbackRadius here, as statemachine connectors do.\n // // so we go radius to the left from stubs[0], then upwards by 2*radius, to the right by 2*radius,\n // // down by 2*radius, left by radius.\n // addSegment(segments, stubs[0] - loopbackRadius, stubs[1], paintInfo);\n // addSegment(segments, stubs[0] - loopbackRadius, stubs[1] - (2 * loopbackRadius), paintInfo);\n // addSegment(segments, stubs[0] + loopbackRadius, stubs[1] - (2 * loopbackRadius), paintInfo);\n // addSegment(segments, stubs[0] + loopbackRadius, stubs[1], paintInfo);\n // addSegment(segments, stubs[0], stubs[1], paintInfo);\n //\n // }\n // else {\n\n\n var midx = paintInfo.startStubX + ((paintInfo.endStubX - paintInfo.startStubX) * midpoint),\n midy = paintInfo.startStubY + ((paintInfo.endStubY - paintInfo.startStubY) * midpoint);\n\n var orientations = {x: [0, 1], y: [1, 0]},\n lineCalculators = {\n perpendicular: function (axis) {\n var pi = paintInfo,\n sis = {\n x: [\n [[1, 2, 3, 4], null, [2, 1, 4, 3]],\n null,\n [[4, 3, 2, 1], null, [3, 4, 1, 2]]\n ],\n y: [\n [[3, 2, 1, 4], null, [2, 3, 4, 1]],\n null,\n [[4, 1, 2, 3], null, [1, 4, 3, 2]]\n ]\n },\n stubs = {\n x: [[pi.startStubX, pi.endStubX], null, [pi.endStubX, pi.startStubX]],\n y: [[pi.startStubY, pi.endStubY], null, [pi.endStubY, pi.startStubY]]\n },\n midLines = {\n x: [[midx, pi.startStubY], [midx, pi.endStubY]],\n y: [[pi.startStubX, midy], [pi.endStubX, midy]]\n },\n linesToEnd = {\n x: [[pi.endStubX, pi.startStubY]],\n y: [[pi.startStubX, pi.endStubY]]\n },\n startToEnd = {\n x: [[pi.startStubX, pi.endStubY], [pi.endStubX, pi.endStubY]],\n y: [[pi.endStubX, pi.startStubY], [pi.endStubX, pi.endStubY]]\n },\n startToMidToEnd = {\n x: [[pi.startStubX, midy], [pi.endStubX, midy], [pi.endStubX, pi.endStubY]],\n y: [[midx, pi.startStubY], [midx, pi.endStubY], [pi.endStubX, pi.endStubY]]\n },\n otherStubs = {\n x: [pi.startStubY, pi.endStubY],\n y: [pi.startStubX, pi.endStubX]\n },\n soIdx = orientations[axis][0], toIdx = orientations[axis][1],\n _so = pi.so[soIdx] + 1,\n _to = pi.to[toIdx] + 1,\n otherFlipped = (pi.to[toIdx] === -1 && (otherStubs[axis][1] < otherStubs[axis][0])) || (pi.to[toIdx] === 1 && (otherStubs[axis][1] > otherStubs[axis][0])),\n stub1 = stubs[axis][_so][0],\n stub2 = stubs[axis][_so][1],\n segmentIndexes = sis[axis][_so][_to];\n\n if (pi.segment === segmentIndexes[3] || (pi.segment === segmentIndexes[2] && otherFlipped)) {\n return midLines[axis];\n }\n else if (pi.segment === segmentIndexes[2] && stub2 < stub1) {\n return linesToEnd[axis];\n }\n else if ((pi.segment === segmentIndexes[2] && stub2 >= stub1) || (pi.segment === segmentIndexes[1] && !otherFlipped)) {\n return startToMidToEnd[axis];\n }\n else if (pi.segment === segmentIndexes[0] || (pi.segment === segmentIndexes[1] && otherFlipped)) {\n return startToEnd[axis];\n }\n },\n orthogonal: function (axis, startStub, otherStartStub, endStub, otherEndStub) {\n var pi = paintInfo,\n extent = {\n \"x\": pi.so[0] === -1 ? Math.min(startStub, endStub) : Math.max(startStub, endStub),\n \"y\": pi.so[1] === -1 ? Math.min(startStub, endStub) : Math.max(startStub, endStub)\n }[axis];\n\n return {\n \"x\": [\n [extent, otherStartStub],\n [extent, otherEndStub],\n [endStub, otherEndStub]\n ],\n \"y\": [\n [otherStartStub, extent],\n [otherEndStub, extent],\n [otherEndStub, endStub]\n ]\n }[axis];\n },\n opposite: function (axis, ss, oss, es) {\n var pi = paintInfo,\n otherAxis = {\"x\": \"y\", \"y\": \"x\"}[axis],\n dim = {\"x\": \"height\", \"y\": \"width\"}[axis],\n comparator = pi[\"is\" + axis.toUpperCase() + \"GreaterThanStubTimes2\"];\n\n if (params.sourceEndpoint.elementId === params.targetEndpoint.elementId) {\n var _val = oss + ((1 - params.sourceEndpoint.anchor[otherAxis]) * params.sourceInfo[dim]) + _super.maxStub;\n return {\n \"x\": [\n [ss, _val],\n [es, _val]\n ],\n \"y\": [\n [_val, ss],\n [_val, es]\n ]\n }[axis];\n\n }\n else if (!comparator || (pi.so[idx] === 1 && ss > es) || (pi.so[idx] === -1 && ss < es)) {\n return {\n \"x\": [\n [ss, midy],\n [es, midy]\n ],\n \"y\": [\n [midx, ss],\n [midx, es]\n ]\n }[axis];\n }\n else if ((pi.so[idx] === 1 && ss < es) || (pi.so[idx] === -1 && ss > es)) {\n return {\n \"x\": [\n [midx, pi.sy],\n [midx, pi.ty]\n ],\n \"y\": [\n [pi.sx, midy],\n [pi.tx, midy]\n ]\n }[axis];\n }\n }\n };\n\n // compute the rest of the line\n var p = lineCalculators[paintInfo.anchorOrientation](paintInfo.sourceAxis, ss, oss, es, oes);\n if (p) {\n for (var i = 0; i < p.length; i++) {\n addSegment(segments, p[i][0], p[i][1], paintInfo);\n }\n }\n\n // line to end stub\n addSegment(segments, stubs[2], stubs[3], paintInfo);\n\n //}\n\n // end stub to end (common)\n addSegment(segments, paintInfo.tx, paintInfo.ty, paintInfo);\n\n\n\n // write out the segments.\n writeSegments(this, segments, paintInfo);\n\n };\n };\n\n _jp.Connectors.Flowchart = Flowchart;\n _ju.extend(_jp.Connectors.Flowchart, _jp.Connectors.AbstractConnector);\n\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains the code for the Bezier connector type.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n\n _jp.Connectors.AbstractBezierConnector = function(params) {\n params = params || {};\n var showLoopback = params.showLoopback !== false,\n curviness = params.curviness || 10,\n margin = params.margin || 5,\n proximityLimit = params.proximityLimit || 80,\n clockwise = params.orientation && params.orientation === \"clockwise\",\n loopbackRadius = params.loopbackRadius || 25,\n isLoopbackCurrently = false,\n _super;\n\n this._compute = function (paintInfo, p) {\n\n var sp = p.sourcePos,\n tp = p.targetPos,\n _w = Math.abs(sp[0] - tp[0]),\n _h = Math.abs(sp[1] - tp[1]);\n\n if (!showLoopback || (p.sourceEndpoint.elementId !== p.targetEndpoint.elementId)) {\n isLoopbackCurrently = false;\n this._computeBezier(paintInfo, p, sp, tp, _w, _h);\n } else {\n isLoopbackCurrently = true;\n // a loopback connector. draw an arc from one anchor to the other.\n var x1 = p.sourcePos[0], y1 = p.sourcePos[1] - margin,\n cx = x1, cy = y1 - loopbackRadius,\n // canvas sizing stuff, to ensure the whole painted area is visible.\n _x = cx - loopbackRadius,\n _y = cy - loopbackRadius;\n\n _w = 2 * loopbackRadius;\n _h = 2 * loopbackRadius;\n\n paintInfo.points[0] = _x;\n paintInfo.points[1] = _y;\n paintInfo.points[2] = _w;\n paintInfo.points[3] = _h;\n\n // ADD AN ARC SEGMENT.\n _super.addSegment(this, \"Arc\", {\n loopback: true,\n x1: (x1 - _x) + 4,\n y1: y1 - _y,\n startAngle: 0,\n endAngle: 2 * Math.PI,\n r: loopbackRadius,\n ac: !clockwise,\n x2: (x1 - _x) - 4,\n y2: y1 - _y,\n cx: cx - _x,\n cy: cy - _y\n });\n }\n };\n\n _super = _jp.Connectors.AbstractConnector.apply(this, arguments);\n return _super;\n };\n _ju.extend(_jp.Connectors.AbstractBezierConnector, _jp.Connectors.AbstractConnector);\n\n var Bezier = function (params) {\n params = params || {};\n this.type = \"Bezier\";\n\n var _super = _jp.Connectors.AbstractBezierConnector.apply(this, arguments),\n majorAnchor = params.curviness || 150,\n minorAnchor = 10;\n\n this.getCurviness = function () {\n return majorAnchor;\n };\n\n this._findControlPoint = function (point, sourceAnchorPosition, targetAnchorPosition, sourceEndpoint, targetEndpoint, soo, too) {\n // determine if the two anchors are perpendicular to each other in their orientation. we swap the control\n // points around if so (code could be tightened up)\n var perpendicular = soo[0] !== too[0] || soo[1] === too[1],\n p = [];\n\n if (!perpendicular) {\n if (soo[0] === 0) {\n p.push(sourceAnchorPosition[0] < targetAnchorPosition[0] ? point[0] + minorAnchor : point[0] - minorAnchor);\n }\n else {\n p.push(point[0] - (majorAnchor * soo[0]));\n }\n\n if (soo[1] === 0) {\n p.push(sourceAnchorPosition[1] < targetAnchorPosition[1] ? point[1] + minorAnchor : point[1] - minorAnchor);\n }\n else {\n p.push(point[1] + (majorAnchor * too[1]));\n }\n }\n else {\n if (too[0] === 0) {\n p.push(targetAnchorPosition[0] < sourceAnchorPosition[0] ? point[0] + minorAnchor : point[0] - minorAnchor);\n }\n else {\n p.push(point[0] + (majorAnchor * too[0]));\n }\n\n if (too[1] === 0) {\n p.push(targetAnchorPosition[1] < sourceAnchorPosition[1] ? point[1] + minorAnchor : point[1] - minorAnchor);\n }\n else {\n p.push(point[1] + (majorAnchor * soo[1]));\n }\n }\n\n return p;\n };\n\n this._computeBezier = function (paintInfo, p, sp, tp, _w, _h) {\n\n var _CP, _CP2,\n _sx = sp[0] < tp[0] ? _w : 0,\n _sy = sp[1] < tp[1] ? _h : 0,\n _tx = sp[0] < tp[0] ? 0 : _w,\n _ty = sp[1] < tp[1] ? 0 : _h;\n\n _CP = this._findControlPoint([_sx, _sy], sp, tp, p.sourceEndpoint, p.targetEndpoint, paintInfo.so, paintInfo.to);\n _CP2 = this._findControlPoint([_tx, _ty], tp, sp, p.targetEndpoint, p.sourceEndpoint, paintInfo.to, paintInfo.so);\n\n\n _super.addSegment(this, \"Bezier\", {\n x1: _sx, y1: _sy, x2: _tx, y2: _ty,\n cp1x: _CP[0], cp1y: _CP[1], cp2x: _CP2[0], cp2y: _CP2[1]\n });\n };\n\n\n };\n\n _jp.Connectors.Bezier = Bezier;\n _ju.extend(Bezier, _jp.Connectors.AbstractBezierConnector);\n\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains the state machine connectors, which extend AbstractBezierConnector.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n * \n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n\n var _segment = function (x1, y1, x2, y2) {\n if (x1 <= x2 && y2 <= y1) {\n return 1;\n }\n else if (x1 <= x2 && y1 <= y2) {\n return 2;\n }\n else if (x2 <= x1 && y2 >= y1) {\n return 3;\n }\n return 4;\n },\n\n // the control point we will use depends on the faces to which each end of the connection is assigned, specifically whether or not the\n // two faces are parallel or perpendicular. if they are parallel then the control point lies on the midpoint of the axis in which they\n // are parellel and varies only in the other axis; this variation is proportional to the distance that the anchor points lie from the\n // center of that face. if the two faces are perpendicular then the control point is at some distance from both the midpoints; the amount and\n // direction are dependent on the orientation of the two elements. 'seg', passed in to this method, tells you which segment the target element\n // lies in with respect to the source: 1 is top right, 2 is bottom right, 3 is bottom left, 4 is top left.\n //\n // sourcePos and targetPos are arrays of info about where on the source and target each anchor is located. their contents are:\n //\n // 0 - absolute x\n // 1 - absolute y\n // 2 - proportional x in element (0 is left edge, 1 is right edge)\n // 3 - proportional y in element (0 is top edge, 1 is bottom edge)\n //\n _findControlPoint = function (midx, midy, segment, sourceEdge, targetEdge, dx, dy, distance, proximityLimit) {\n // TODO (maybe)\n // - if anchor pos is 0.5, make the control point take into account the relative position of the elements.\n if (distance <= proximityLimit) {\n return [midx, midy];\n }\n\n if (segment === 1) {\n if (sourceEdge[3] <= 0 && targetEdge[3] >= 1) {\n return [ midx + (sourceEdge[2] < 0.5 ? -1 * dx : dx), midy ];\n }\n else if (sourceEdge[2] >= 1 && targetEdge[2] <= 0) {\n return [ midx, midy + (sourceEdge[3] < 0.5 ? -1 * dy : dy) ];\n }\n else {\n return [ midx + (-1 * dx) , midy + (-1 * dy) ];\n }\n }\n else if (segment === 2) {\n if (sourceEdge[3] >= 1 && targetEdge[3] <= 0) {\n return [ midx + (sourceEdge[2] < 0.5 ? -1 * dx : dx), midy ];\n }\n else if (sourceEdge[2] >= 1 && targetEdge[2] <= 0) {\n return [ midx, midy + (sourceEdge[3] < 0.5 ? -1 * dy : dy) ];\n }\n else {\n return [ midx + dx, midy + (-1 * dy) ];\n }\n }\n else if (segment === 3) {\n if (sourceEdge[3] >= 1 && targetEdge[3] <= 0) {\n return [ midx + (sourceEdge[2] < 0.5 ? -1 * dx : dx), midy ];\n }\n else if (sourceEdge[2] <= 0 && targetEdge[2] >= 1) {\n return [ midx, midy + (sourceEdge[3] < 0.5 ? -1 * dy : dy) ];\n }\n else {\n return [ midx + (-1 * dx) , midy + (-1 * dy) ];\n }\n }\n else if (segment === 4) {\n if (sourceEdge[3] <= 0 && targetEdge[3] >= 1) {\n return [ midx + (sourceEdge[2] < 0.5 ? -1 * dx : dx), midy ];\n }\n else if (sourceEdge[2] <= 0 && targetEdge[2] >= 1) {\n return [ midx, midy + (sourceEdge[3] < 0.5 ? -1 * dy : dy) ];\n }\n else {\n return [ midx + dx , midy + (-1 * dy) ];\n }\n }\n\n };\n\n var StateMachine = function (params) {\n params = params || {};\n this.type = \"StateMachine\";\n\n var _super = _jp.Connectors.AbstractBezierConnector.apply(this, arguments),\n curviness = params.curviness || 10,\n margin = params.margin || 5,\n proximityLimit = params.proximityLimit || 80,\n clockwise = params.orientation && params.orientation === \"clockwise\",\n _controlPoint;\n\n this._computeBezier = function(paintInfo, params, sp, tp, w, h) {\n var _sx = params.sourcePos[0] < params.targetPos[0] ? 0 : w,\n _sy = params.sourcePos[1] < params.targetPos[1] ? 0 : h,\n _tx = params.sourcePos[0] < params.targetPos[0] ? w : 0,\n _ty = params.sourcePos[1] < params.targetPos[1] ? h : 0;\n\n // now adjust for the margin\n if (params.sourcePos[2] === 0) {\n _sx -= margin;\n }\n if (params.sourcePos[2] === 1) {\n _sx += margin;\n }\n if (params.sourcePos[3] === 0) {\n _sy -= margin;\n }\n if (params.sourcePos[3] === 1) {\n _sy += margin;\n }\n if (params.targetPos[2] === 0) {\n _tx -= margin;\n }\n if (params.targetPos[2] === 1) {\n _tx += margin;\n }\n if (params.targetPos[3] === 0) {\n _ty -= margin;\n }\n if (params.targetPos[3] === 1) {\n _ty += margin;\n }\n\n //\n // these connectors are quadratic bezier curves, having a single control point. if both anchors\n // are located at 0.5 on their respective faces, the control point is set to the midpoint and you\n // get a straight line. this is also the case if the two anchors are within 'proximityLimit', since\n // it seems to make good aesthetic sense to do that. outside of that, the control point is positioned\n // at 'curviness' pixels away along the normal to the straight line connecting the two anchors.\n //\n // there may be two improvements to this. firstly, we might actually support the notion of avoiding nodes\n // in the UI, or at least making a good effort at doing so. if a connection would pass underneath some node,\n // for example, we might increase the distance the control point is away from the midpoint in a bid to\n // steer it around that node. this will work within limits, but i think those limits would also be the likely\n // limits for, once again, aesthetic good sense in the layout of a chart using these connectors.\n //\n // the second possible change is actually two possible changes: firstly, it is possible we should gradually\n // decrease the 'curviness' as the distance between the anchors decreases; start tailing it off to 0 at some\n // point (which should be configurable). secondly, we might slightly increase the 'curviness' for connectors\n // with respect to how far their anchor is from the center of its respective face. this could either look cool,\n // or stupid, and may indeed work only in a way that is so subtle as to have been a waste of time.\n //\n\n var _midx = (_sx + _tx) / 2,\n _midy = (_sy + _ty) / 2,\n segment = _segment(_sx, _sy, _tx, _ty),\n distance = Math.sqrt(Math.pow(_tx - _sx, 2) + Math.pow(_ty - _sy, 2)),\n cp1x, cp2x, cp1y, cp2y;\n\n\n // calculate the control point. this code will be where we'll put in a rudimentary element avoidance scheme; it\n // will work by extending the control point to force the curve to be, um, curvier.\n _controlPoint = _findControlPoint(_midx,\n _midy,\n segment,\n params.sourcePos,\n params.targetPos,\n curviness, curviness,\n distance,\n proximityLimit);\n\n cp1x = _controlPoint[0];\n cp2x = _controlPoint[0];\n cp1y = _controlPoint[1];\n cp2y = _controlPoint[1];\n\n _super.addSegment(this, \"Bezier\", {\n x1: _tx, y1: _ty, x2: _sx, y2: _sy,\n cp1x: cp1x, cp1y: cp1y,\n cp2x: cp2x, cp2y: cp2y\n });\n };\n };\n\n _jp.Connectors.StateMachine = StateMachine;\n _ju.extend(StateMachine, _jp.Connectors.AbstractBezierConnector);\n\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains the 'flowchart' connectors, consisting of vertical and horizontal line segments.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n var STRAIGHT = \"Straight\";\n\n var Straight = function (params) {\n this.type = STRAIGHT;\n var _super = _jp.Connectors.AbstractConnector.apply(this, arguments);\n\n this._compute = function (paintInfo, _) {\n _super.addSegment(this, STRAIGHT, {x1: paintInfo.sx, y1: paintInfo.sy, x2: paintInfo.startStubX, y2: paintInfo.startStubY});\n _super.addSegment(this, STRAIGHT, {x1: paintInfo.startStubX, y1: paintInfo.startStubY, x2: paintInfo.endStubX, y2: paintInfo.endStubY});\n _super.addSegment(this, STRAIGHT, {x1: paintInfo.endStubX, y1: paintInfo.endStubY, x2: paintInfo.tx, y2: paintInfo.ty});\n };\n };\n\n _jp.Connectors.Straight = Straight;\n _ju.extend(Straight, _jp.Connectors.AbstractConnector);\n\n}).call(typeof window !== 'undefined' ? window : this);\n/*\n * This file contains the SVG renderers.\n *\n * Copyright (c) 2010 - 2018 jsPlumb (hello@jsplumbtoolkit.com)\n * \n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n * \n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n// ************************** SVG utility methods ********************************************\t\n\n \"use strict\";\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil;\n\n var svgAttributeMap = {\n \"stroke-linejoin\": \"stroke-linejoin\",\n \"stroke-dashoffset\": \"stroke-dashoffset\",\n \"stroke-linecap\": \"stroke-linecap\"\n },\n STROKE_DASHARRAY = \"stroke-dasharray\",\n DASHSTYLE = \"dashstyle\",\n LINEAR_GRADIENT = \"linearGradient\",\n RADIAL_GRADIENT = \"radialGradient\",\n DEFS = \"defs\",\n FILL = \"fill\",\n STOP = \"stop\",\n STROKE = \"stroke\",\n STROKE_WIDTH = \"stroke-width\",\n STYLE = \"style\",\n NONE = \"none\",\n JSPLUMB_GRADIENT = \"jsplumb_gradient_\",\n LINE_WIDTH = \"strokeWidth\",\n ns = {\n svg: \"http://www.w3.org/2000/svg\"\n },\n _attr = function (node, attributes) {\n for (var i in attributes) {\n node.setAttribute(i, \"\" + attributes[i]);\n }\n },\n _node = function (name, attributes) {\n attributes = attributes || {};\n attributes.version = \"1.1\";\n attributes.xmlns = ns.svg;\n return _jp.createElementNS(ns.svg, name, null, null, attributes);\n },\n _pos = function (d) {\n return \"position:absolute;left:\" + d[0] + \"px;top:\" + d[1] + \"px\";\n },\n _clearGradient = function (parent) {\n var els = parent.querySelectorAll(\" defs,linearGradient,radialGradient\");\n for (var i = 0; i < els.length; i++) {\n els[i].parentNode.removeChild(els[i]);\n }\n },\n _updateGradient = function (parent, node, style, dimensions, uiComponent) {\n var id = JSPLUMB_GRADIENT + uiComponent._jsPlumb.instance.idstamp();\n // first clear out any existing gradient\n _clearGradient(parent);\n // this checks for an 'offset' property in the gradient, and in the absence of it, assumes\n // we want a linear gradient. if it's there, we create a radial gradient.\n // it is possible that a more explicit means of defining the gradient type would be\n // better. relying on 'offset' means that we can never have a radial gradient that uses\n // some default offset, for instance.\n // issue 244 suggested the 'gradientUnits' attribute; without this, straight/flowchart connectors with gradients would\n // not show gradients when the line was perfectly horizontal or vertical.\n var g;\n if (!style.gradient.offset) {\n g = _node(LINEAR_GRADIENT, {id: id, gradientUnits: \"userSpaceOnUse\"});\n }\n else {\n g = _node(RADIAL_GRADIENT, { id: id });\n }\n\n var defs = _node(DEFS);\n parent.appendChild(defs);\n defs.appendChild(g);\n\n // the svg radial gradient seems to treat stops in the reverse\n // order to how canvas does it. so we want to keep all the maths the same, but\n // iterate the actual style declarations in reverse order, if the x indexes are not in order.\n for (var i = 0; i < style.gradient.stops.length; i++) {\n var styleToUse = uiComponent.segment === 1 || uiComponent.segment === 2 ? i : style.gradient.stops.length - 1 - i,\n stopColor = style.gradient.stops[styleToUse][1],\n s = _node(STOP, {\"offset\": Math.floor(style.gradient.stops[i][0] * 100) + \"%\", \"stop-color\": stopColor});\n\n g.appendChild(s);\n }\n var applyGradientTo = style.stroke ? STROKE : FILL;\n node.setAttribute(applyGradientTo, \"url(#\" + id + \")\");\n },\n _applyStyles = function (parent, node, style, dimensions, uiComponent) {\n\n node.setAttribute(FILL, style.fill ? style.fill : NONE);\n node.setAttribute(STROKE, style.stroke ? style.stroke : NONE);\n\n if (style.gradient) {\n _updateGradient(parent, node, style, dimensions, uiComponent);\n }\n else {\n // make sure we clear any existing gradient\n _clearGradient(parent);\n node.setAttribute(STYLE, \"\");\n }\n\n if (style.strokeWidth) {\n node.setAttribute(STROKE_WIDTH, style.strokeWidth);\n }\n\n // in SVG there is a stroke-dasharray attribute we can set, and its syntax looks like\n // the syntax in VML but is actually kind of nasty: values are given in the pixel\n // coordinate space, whereas in VML they are multiples of the width of the stroked\n // line, which makes a lot more sense. for that reason, jsPlumb is supporting both\n // the native svg 'stroke-dasharray' attribute, and also the 'dashstyle' concept from\n // VML, which will be the preferred method. the code below this converts a dashstyle\n // attribute given in terms of stroke width into a pixel representation, by using the\n // stroke's lineWidth.\n if (style[DASHSTYLE] && style[LINE_WIDTH] && !style[STROKE_DASHARRAY]) {\n var sep = style[DASHSTYLE].indexOf(\",\") === -1 ? \" \" : \",\",\n parts = style[DASHSTYLE].split(sep),\n styleToUse = \"\";\n parts.forEach(function (p) {\n styleToUse += (Math.floor(p * style.strokeWidth) + sep);\n });\n node.setAttribute(STROKE_DASHARRAY, styleToUse);\n }\n else if (style[STROKE_DASHARRAY]) {\n node.setAttribute(STROKE_DASHARRAY, style[STROKE_DASHARRAY]);\n }\n\n // extra attributes such as join type, dash offset.\n for (var i in svgAttributeMap) {\n if (style[i]) {\n node.setAttribute(svgAttributeMap[i], style[i]);\n }\n }\n },\n _appendAtIndex = function (svg, path, idx) {\n if (svg.childNodes.length > idx) {\n svg.insertBefore(path, svg.childNodes[idx]);\n }\n else {\n svg.appendChild(path);\n }\n };\n\n /**\n utility methods for other objects to use.\n */\n _ju.svg = {\n node: _node,\n attr: _attr,\n pos: _pos\n };\n\n // ************************** / SVG utility methods ********************************************\n\n /*\n * Base class for SVG components.\n */\n var SvgComponent = function (params) {\n var pointerEventsSpec = params.pointerEventsSpec || \"all\", renderer = {};\n\n _jp.jsPlumbUIComponent.apply(this, params.originalArgs);\n this.canvas = null;\n this.path = null;\n this.svg = null;\n this.bgCanvas = null;\n\n var clazz = params.cssClass + \" \" + (params.originalArgs[0].cssClass || \"\"),\n svgParams = {\n \"style\": \"\",\n \"width\": 0,\n \"height\": 0,\n \"pointer-events\": pointerEventsSpec,\n \"position\": \"absolute\"\n };\n\n this.svg = _node(\"svg\", svgParams);\n\n if (params.useDivWrapper) {\n this.canvas = _jp.createElement(\"div\", { position : \"absolute\" });\n _ju.sizeElement(this.canvas, 0, 0, 1, 1);\n this.canvas.className = clazz;\n }\n else {\n _attr(this.svg, { \"class\": clazz });\n this.canvas = this.svg;\n }\n\n params._jsPlumb.appendElement(this.canvas, params.originalArgs[0].parent);\n if (params.useDivWrapper) {\n this.canvas.appendChild(this.svg);\n }\n\n var displayElements = [ this.canvas ];\n this.getDisplayElements = function () {\n return displayElements;\n };\n\n this.appendDisplayElement = function (el) {\n displayElements.push(el);\n };\n\n this.paint = function (style, anchor, extents) {\n if (style != null) {\n\n var xy = [ this.x, this.y ], wh = [ this.w, this.h ], p;\n if (extents != null) {\n if (extents.xmin < 0) {\n xy[0] += extents.xmin;\n }\n if (extents.ymin < 0) {\n xy[1] += extents.ymin;\n }\n wh[0] = extents.xmax + ((extents.xmin < 0) ? -extents.xmin : 0);\n wh[1] = extents.ymax + ((extents.ymin < 0) ? -extents.ymin : 0);\n }\n\n if (params.useDivWrapper) {\n _ju.sizeElement(this.canvas, xy[0], xy[1], wh[0], wh[1]);\n xy[0] = 0;\n xy[1] = 0;\n p = _pos([ 0, 0 ]);\n }\n else {\n p = _pos([ xy[0], xy[1] ]);\n }\n\n renderer.paint.apply(this, arguments);\n\n _attr(this.svg, {\n \"style\": p,\n \"width\": wh[0] || 0,\n \"height\": wh[1] || 0\n });\n }\n };\n\n return {\n renderer: renderer\n };\n };\n\n _ju.extend(SvgComponent, _jp.jsPlumbUIComponent, {\n cleanup: function (force) {\n if (force || this.typeId == null) {\n if (this.canvas) {\n this.canvas._jsPlumb = null;\n }\n if (this.svg) {\n this.svg._jsPlumb = null;\n }\n if (this.bgCanvas) {\n this.bgCanvas._jsPlumb = null;\n }\n\n if (this.canvas && this.canvas.parentNode) {\n this.canvas.parentNode.removeChild(this.canvas);\n }\n if (this.bgCanvas && this.bgCanvas.parentNode) {\n this.canvas.parentNode.removeChild(this.canvas);\n }\n\n this.svg = null;\n this.canvas = null;\n this.path = null;\n this.group = null;\n }\n else {\n // if not a forced cleanup, just detach from DOM for now.\n if (this.canvas && this.canvas.parentNode) {\n this.canvas.parentNode.removeChild(this.canvas);\n }\n if (this.bgCanvas && this.bgCanvas.parentNode) {\n this.bgCanvas.parentNode.removeChild(this.bgCanvas);\n }\n }\n },\n reattach:function(instance) {\n var c = instance.getContainer();\n if (this.canvas && this.canvas.parentNode == null) {\n c.appendChild(this.canvas);\n }\n if (this.bgCanvas && this.bgCanvas.parentNode == null) {\n c.appendChild(this.bgCanvas);\n }\n },\n setVisible: function (v) {\n if (this.canvas) {\n this.canvas.style.display = v ? \"block\" : \"none\";\n }\n }\n });\n\n /*\n * Base class for SVG connectors.\n */\n _jp.ConnectorRenderers.svg = function (params) {\n var self = this,\n _super = SvgComponent.apply(this, [\n {\n cssClass: params._jsPlumb.connectorClass,\n originalArgs: arguments,\n pointerEventsSpec: \"none\",\n _jsPlumb: params._jsPlumb\n }\n ]);\n\n _super.renderer.paint = function (style, anchor, extents) {\n\n var segments = self.getSegments(), p = \"\", offset = [0, 0];\n if (extents.xmin < 0) {\n offset[0] = -extents.xmin;\n }\n if (extents.ymin < 0) {\n offset[1] = -extents.ymin;\n }\n\n if (segments.length > 0) {\n\n p = self.getPathData();\n\n var a = {\n d: p,\n transform: \"translate(\" + offset[0] + \",\" + offset[1] + \")\",\n \"pointer-events\": params[\"pointer-events\"] || \"visibleStroke\"\n },\n outlineStyle = null,\n d = [self.x, self.y, self.w, self.h];\n\n // outline style. actually means drawing an svg object underneath the main one.\n if (style.outlineStroke) {\n var outlineWidth = style.outlineWidth || 1,\n outlineStrokeWidth = style.strokeWidth + (2 * outlineWidth);\n outlineStyle = _jp.extend({}, style);\n delete outlineStyle.gradient;\n outlineStyle.stroke = style.outlineStroke;\n outlineStyle.strokeWidth = outlineStrokeWidth;\n\n if (self.bgPath == null) {\n self.bgPath = _node(\"path\", a);\n _jp.addClass(self.bgPath, _jp.connectorOutlineClass);\n _appendAtIndex(self.svg, self.bgPath, 0);\n }\n else {\n _attr(self.bgPath, a);\n }\n\n _applyStyles(self.svg, self.bgPath, outlineStyle, d, self);\n }\n\n if (self.path == null) {\n self.path = _node(\"path\", a);\n _appendAtIndex(self.svg, self.path, style.outlineStroke ? 1 : 0);\n }\n else {\n _attr(self.path, a);\n }\n\n _applyStyles(self.svg, self.path, style, d, self);\n }\n };\n };\n _ju.extend(_jp.ConnectorRenderers.svg, SvgComponent);\n\n// ******************************* svg segment renderer *****************************************************\t\n\n\n// ******************************* /svg segments *****************************************************\n\n /*\n * Base class for SVG endpoints.\n */\n var SvgEndpoint = _jp.SvgEndpoint = function (params) {\n var _super = SvgComponent.apply(this, [\n {\n cssClass: params._jsPlumb.endpointClass,\n originalArgs: arguments,\n pointerEventsSpec: \"all\",\n useDivWrapper: true,\n _jsPlumb: params._jsPlumb\n }\n ]);\n\n _super.renderer.paint = function (style) {\n var s = _jp.extend({}, style);\n if (s.outlineStroke) {\n s.stroke = s.outlineStroke;\n }\n\n if (this.node == null) {\n this.node = this.makeNode(s);\n this.svg.appendChild(this.node);\n }\n else if (this.updateNode != null) {\n this.updateNode(this.node);\n }\n _applyStyles(this.svg, this.node, s, [ this.x, this.y, this.w, this.h ], this);\n _pos(this.node, [ this.x, this.y ]);\n }.bind(this);\n\n };\n _ju.extend(SvgEndpoint, SvgComponent);\n\n /*\n * SVG Dot Endpoint\n */\n _jp.Endpoints.svg.Dot = function () {\n _jp.Endpoints.Dot.apply(this, arguments);\n SvgEndpoint.apply(this, arguments);\n this.makeNode = function (style) {\n return _node(\"circle\", {\n \"cx\": this.w / 2,\n \"cy\": this.h / 2,\n \"r\": this.radius\n });\n };\n this.updateNode = function (node) {\n _attr(node, {\n \"cx\": this.w / 2,\n \"cy\": this.h / 2,\n \"r\": this.radius\n });\n };\n };\n _ju.extend(_jp.Endpoints.svg.Dot, [_jp.Endpoints.Dot, SvgEndpoint]);\n\n /*\n * SVG Rectangle Endpoint\n */\n _jp.Endpoints.svg.Rectangle = function () {\n _jp.Endpoints.Rectangle.apply(this, arguments);\n SvgEndpoint.apply(this, arguments);\n this.makeNode = function (style) {\n return _node(\"rect\", {\n \"width\": this.w,\n \"height\": this.h\n });\n };\n this.updateNode = function (node) {\n _attr(node, {\n \"width\": this.w,\n \"height\": this.h\n });\n };\n };\n _ju.extend(_jp.Endpoints.svg.Rectangle, [_jp.Endpoints.Rectangle, SvgEndpoint]);\n\n /*\n * SVG Image Endpoint is the default image endpoint.\n */\n _jp.Endpoints.svg.Image = _jp.Endpoints.Image;\n /*\n * Blank endpoint in svg renderer is the default Blank endpoint.\n */\n _jp.Endpoints.svg.Blank = _jp.Endpoints.Blank;\n /*\n * Label overlay in svg renderer is the default Label overlay.\n */\n _jp.Overlays.svg.Label = _jp.Overlays.Label;\n /*\n * Custom overlay in svg renderer is the default Custom overlay.\n */\n _jp.Overlays.svg.Custom = _jp.Overlays.Custom;\n\n var AbstractSvgArrowOverlay = function (superclass, originalArgs) {\n superclass.apply(this, originalArgs);\n _jp.jsPlumbUIComponent.apply(this, originalArgs);\n this.isAppendedAtTopLevel = false;\n var self = this;\n this.path = null;\n this.paint = function (params, containerExtents) {\n // only draws on connections, not endpoints.\n if (params.component.svg && containerExtents) {\n if (this.path == null) {\n this.path = _node(\"path\", {\n \"pointer-events\": \"all\"\n });\n params.component.svg.appendChild(this.path);\n if (this.elementCreated) {\n this.elementCreated(this.path, params.component);\n }\n\n this.canvas = params.component.svg; // for the sake of completeness; this behaves the same as other overlays\n }\n var clazz = originalArgs && (originalArgs.length === 1) ? (originalArgs[0].cssClass || \"\") : \"\",\n offset = [0, 0];\n\n if (containerExtents.xmin < 0) {\n offset[0] = -containerExtents.xmin;\n }\n if (containerExtents.ymin < 0) {\n offset[1] = -containerExtents.ymin;\n }\n\n _attr(this.path, {\n \"d\": makePath(params.d),\n \"class\": clazz,\n stroke: params.stroke ? params.stroke : null,\n fill: params.fill ? params.fill : null,\n transform: \"translate(\" + offset[0] + \",\" + offset[1] + \")\"\n });\n }\n };\n var makePath = function (d) {\n return (isNaN(d.cxy.x) || isNaN(d.cxy.y)) ? \"\" : \"M\" + d.hxy.x + \",\" + d.hxy.y +\n \" L\" + d.tail[0].x + \",\" + d.tail[0].y +\n \" L\" + d.cxy.x + \",\" + d.cxy.y +\n \" L\" + d.tail[1].x + \",\" + d.tail[1].y +\n \" L\" + d.hxy.x + \",\" + d.hxy.y;\n };\n this.transfer = function(target) {\n if (target.canvas && this.path && this.path.parentNode) {\n this.path.parentNode.removeChild(this.path);\n target.canvas.appendChild(this.path);\n }\n };\n };\n _ju.extend(AbstractSvgArrowOverlay, [_jp.jsPlumbUIComponent, _jp.Overlays.AbstractOverlay], {\n cleanup: function (force) {\n if (this.path != null) {\n if (force) {\n this._jsPlumb.instance.removeElement(this.path);\n }\n else {\n if (this.path.parentNode) {\n this.path.parentNode.removeChild(this.path);\n }\n }\n }\n },\n reattach:function(instance, component) {\n if (this.path && component.canvas) {\n component.canvas.appendChild(this.path);\n }\n },\n setVisible: function (v) {\n if (this.path != null) {\n (this.path.style.display = (v ? \"block\" : \"none\"));\n }\n }\n });\n\n _jp.Overlays.svg.Arrow = function () {\n AbstractSvgArrowOverlay.apply(this, [_jp.Overlays.Arrow, arguments]);\n };\n _ju.extend(_jp.Overlays.svg.Arrow, [ _jp.Overlays.Arrow, AbstractSvgArrowOverlay ]);\n\n _jp.Overlays.svg.PlainArrow = function () {\n AbstractSvgArrowOverlay.apply(this, [_jp.Overlays.PlainArrow, arguments]);\n };\n _ju.extend(_jp.Overlays.svg.PlainArrow, [ _jp.Overlays.PlainArrow, AbstractSvgArrowOverlay ]);\n\n _jp.Overlays.svg.Diamond = function () {\n AbstractSvgArrowOverlay.apply(this, [_jp.Overlays.Diamond, arguments]);\n };\n _ju.extend(_jp.Overlays.svg.Diamond, [ _jp.Overlays.Diamond, AbstractSvgArrowOverlay ]);\n\n // a test\n _jp.Overlays.svg.GuideLines = function () {\n var path = null, self = this, p1_1, p1_2;\n _jp.Overlays.GuideLines.apply(this, arguments);\n this.paint = function (params, containerExtents) {\n if (path == null) {\n path = _node(\"path\");\n params.connector.svg.appendChild(path);\n self.attachListeners(path, params.connector);\n self.attachListeners(path, self);\n\n p1_1 = _node(\"path\");\n params.connector.svg.appendChild(p1_1);\n self.attachListeners(p1_1, params.connector);\n self.attachListeners(p1_1, self);\n\n p1_2 = _node(\"path\");\n params.connector.svg.appendChild(p1_2);\n self.attachListeners(p1_2, params.connector);\n self.attachListeners(p1_2, self);\n }\n\n var offset = [0, 0];\n if (containerExtents.xmin < 0) {\n offset[0] = -containerExtents.xmin;\n }\n if (containerExtents.ymin < 0) {\n offset[1] = -containerExtents.ymin;\n }\n\n _attr(path, {\n \"d\": makePath(params.head, params.tail),\n stroke: \"red\",\n fill: null,\n transform: \"translate(\" + offset[0] + \",\" + offset[1] + \")\"\n });\n\n _attr(p1_1, {\n \"d\": makePath(params.tailLine[0], params.tailLine[1]),\n stroke: \"blue\",\n fill: null,\n transform: \"translate(\" + offset[0] + \",\" + offset[1] + \")\"\n });\n\n _attr(p1_2, {\n \"d\": makePath(params.headLine[0], params.headLine[1]),\n stroke: \"green\",\n fill: null,\n transform: \"translate(\" + offset[0] + \",\" + offset[1] + \")\"\n });\n };\n\n var makePath = function (d1, d2) {\n return \"M \" + d1.x + \",\" + d1.y +\n \" L\" + d2.x + \",\" + d2.y;\n };\n };\n _ju.extend(_jp.Overlays.svg.GuideLines, _jp.Overlays.GuideLines);\n}).call(typeof window !== 'undefined' ? window : this);\n\n/*\n * This file contains code used when jsPlumb is being rendered in a DOM.\n *\n * Copyright (c) 2010 - 2019 jsPlumb (hello@jsplumbtoolkit.com)\n *\n * https://jsplumbtoolkit.com\n * https://github.com/jsplumb/jsplumb\n *\n * Dual licensed under the MIT and GPL2 licenses.\n */\n;\n(function () {\n\n \"use strict\";\n\n var root = this, _jp = root.jsPlumb, _ju = root.jsPlumbUtil,\n _jk = root.Katavorio, _jg = root.Biltong;\n\n var _getEventManager = function(instance) {\n var e = instance._mottle;\n if (!e) {\n e = instance._mottle = new root.Mottle();\n }\n return e;\n };\n\n var _getDragManager = function (instance, category) {\n\n category = category || \"main\";\n var key = \"_katavorio_\" + category;\n var k = instance[key],\n e = instance.getEventManager();\n\n if (!k) {\n k = new _jk({\n bind: e.on,\n unbind: e.off,\n getSize: _jp.getSize,\n getConstrainingRectangle:function(el) {\n return [ el.parentNode.scrollWidth, el.parentNode.scrollHeight ];\n },\n getPosition: function (el, relativeToRoot) {\n // if this is a nested draggable then compute the offset against its own offsetParent, otherwise\n // compute against the Container's origin. see also the getUIPosition method below.\n var o = instance.getOffset(el, relativeToRoot, el._katavorioDrag ? el.offsetParent : null);\n return [o.left, o.top];\n },\n setPosition: function (el, xy) {\n el.style.left = xy[0] + \"px\";\n el.style.top = xy[1] + \"px\";\n },\n addClass: _jp.addClass,\n removeClass: _jp.removeClass,\n intersects: _jg.intersects,\n indexOf: function(l, i) { return l.indexOf(i); },\n scope:instance.getDefaultScope(),\n css: {\n noSelect: instance.dragSelectClass,\n droppable: \"jtk-droppable\",\n draggable: \"jtk-draggable\",\n drag: \"jtk-drag\",\n selected: \"jtk-drag-selected\",\n active: \"jtk-drag-active\",\n hover: \"jtk-drag-hover\",\n ghostProxy:\"jtk-ghost-proxy\"\n }\n });\n k.setZoom(instance.getZoom());\n instance[key] = k;\n instance.bind(\"zoom\", k.setZoom);\n }\n return k;\n };\n\n var _dragStart=function(params) {\n var options = params.el._jsPlumbDragOptions;\n var cont = true;\n if (options.canDrag) {\n cont = options.canDrag();\n }\n if (cont) {\n this.setHoverSuspended(true);\n this.select({source: params.el}).addClass(this.elementDraggingClass + \" \" + this.sourceElementDraggingClass, true);\n this.select({target: params.el}).addClass(this.elementDraggingClass + \" \" + this.targetElementDraggingClass, true);\n this.setConnectionBeingDragged(true);\n }\n return cont;\n };\n var _dragMove=function(params) {\n var ui = this.getUIPosition(arguments, this.getZoom());\n if (ui != null) {\n var o = params.el._jsPlumbDragOptions;\n this.draw(params.el, ui, null, true);\n if (o._dragging) {\n this.addClass(params.el, \"jtk-dragged\");\n }\n o._dragging = true;\n }\n };\n var _dragStop=function(params) {\n var elements = params.selection, uip;\n\n var _one = function (_e) {\n if (_e[1] != null) {\n // run the reported offset through the code that takes parent containers\n // into account, to adjust if necessary (issue 554)\n uip = this.getUIPosition([{\n el:_e[2].el,\n pos:[_e[1].left, _e[1].top]\n }]);\n this.draw(_e[2].el, uip);\n }\n\n delete _e[0]._jsPlumbDragOptions._dragging;\n\n this.removeClass(_e[0], \"jtk-dragged\");\n this.select({source: _e[2].el}).removeClass(this.elementDraggingClass + \" \" + this.sourceElementDraggingClass, true);\n this.select({target: _e[2].el}).removeClass(this.elementDraggingClass + \" \" + this.targetElementDraggingClass, true);\n this.getDragManager().dragEnded(_e[2].el);\n }.bind(this);\n\n for (var i = 0; i < elements.length; i++) {\n _one(elements[i]);\n }\n\n this.setHoverSuspended(false);\n this.setConnectionBeingDragged(false);\n };\n\n var _animProps = function (o, p) {\n var _one = function (pName) {\n if (p[pName] != null) {\n if (_ju.isString(p[pName])) {\n var m = p[pName].match(/-=/) ? -1 : 1,\n v = p[pName].substring(2);\n return o[pName] + (m * v);\n }\n else {\n return p[pName];\n }\n }\n else {\n return o[pName];\n }\n };\n return [ _one(\"left\"), _one(\"top\") ];\n };\n\n var _genLoc = function (prefix, e) {\n if (e == null) {\n return [ 0, 0 ];\n }\n var ts = _touches(e), t = _getTouch(ts, 0);\n return [t[prefix + \"X\"], t[prefix + \"Y\"]];\n },\n _pageLocation = _genLoc.bind(this, \"page\"),\n _screenLocation = _genLoc.bind(this, \"screen\"),\n _clientLocation = _genLoc.bind(this, \"client\"),\n _getTouch = function (touches, idx) {\n return touches.item ? touches.item(idx) : touches[idx];\n },\n _touches = function (e) {\n return e.touches && e.touches.length > 0 ? e.touches :\n e.changedTouches && e.changedTouches.length > 0 ? e.changedTouches :\n e.targetTouches && e.targetTouches.length > 0 ? e.targetTouches :\n [ e ];\n };\n\n /**\n Manages dragging for some instance of jsPlumb.\n\n TODO instead of this being accessed directly, it should subscribe to events on the jsPlumb instance: every method\n in here is called directly by jsPlumb. But what should happen is that we have unpublished events that this listens\n to. The only trick is getting one of these instantiated with every jsPlumb instance: it needs to have a hook somehow.\n Basically the general idea is to pull ALL the drag code out (prototype method registrations plus this) into a\n dedicated drag script), that does not necessarily need to be included.\n\n\n */\n var DragManager = function (_currentInstance) {\n var _draggables = {}, _dlist = [], _delements = {}, _elementsWithEndpoints = {},\n // elementids mapped to the draggable to which they belong.\n _draggablesForElements = {};\n\n /**\n register some element as draggable. right now the drag init stuff is done elsewhere, and it is\n possible that will continue to be the case.\n */\n this.register = function (el) {\n var id = _currentInstance.getId(el),\n parentOffset;\n\n if (!_draggables[id]) {\n _draggables[id] = el;\n _dlist.push(el);\n _delements[id] = {};\n }\n\n // look for child elements that have endpoints and register them against this draggable.\n var _oneLevel = function (p) {\n if (p) {\n for (var i = 0; i < p.childNodes.length; i++) {\n if (p.childNodes[i].nodeType !== 3 && p.childNodes[i].nodeType !== 8) {\n var cEl = jsPlumb.getElement(p.childNodes[i]),\n cid = _currentInstance.getId(p.childNodes[i], null, true);\n if (cid && _elementsWithEndpoints[cid] && _elementsWithEndpoints[cid] > 0) {\n if (!parentOffset) {\n parentOffset = _currentInstance.getOffset(el);\n }\n var cOff = _currentInstance.getOffset(cEl);\n _delements[id][cid] = {\n id: cid,\n offset: {\n left: cOff.left - parentOffset.left,\n top: cOff.top - parentOffset.top\n }\n };\n _draggablesForElements[cid] = id;\n }\n _oneLevel(p.childNodes[i]);\n }\n }\n }\n };\n\n _oneLevel(el);\n };\n\n // refresh the offsets for child elements of this element.\n this.updateOffsets = function (elId, childOffsetOverrides) {\n if (elId != null) {\n childOffsetOverrides = childOffsetOverrides || {};\n var domEl = jsPlumb.getElement(elId),\n id = _currentInstance.getId(domEl),\n children = _delements[id],\n parentOffset;\n\n if (children) {\n for (var i in children) {\n if (children.hasOwnProperty(i)) {\n var cel = jsPlumb.getElement(i),\n cOff = childOffsetOverrides[i] || _currentInstance.getOffset(cel);\n\n // do not update if we have a value already and we'd just be writing 0,0\n if (cel.offsetParent == null && _delements[id][i] != null) {\n continue;\n }\n\n if (!parentOffset) {\n parentOffset = _currentInstance.getOffset(domEl);\n }\n\n _delements[id][i] = {\n id: i,\n offset: {\n left: cOff.left - parentOffset.left,\n top: cOff.top - parentOffset.top\n }\n };\n _draggablesForElements[i] = id;\n }\n }\n }\n }\n };\n\n /**\n notification that an endpoint was added to the given el. we go up from that el's parent\n node, looking for a parent that has been registered as a draggable. if we find one, we add this\n el to that parent's list of elements to update on drag (if it is not there already)\n */\n this.endpointAdded = function (el, id) {\n\n id = id || _currentInstance.getId(el);\n\n var b = document.body,\n p = el.parentNode;\n\n _elementsWithEndpoints[id] = _elementsWithEndpoints[id] ? _elementsWithEndpoints[id] + 1 : 1;\n\n while (p != null && p !== b) {\n var pid = _currentInstance.getId(p, null, true);\n if (pid && _draggables[pid]) {\n var pLoc = _currentInstance.getOffset(p);\n\n if (_delements[pid][id] == null) {\n var cLoc = _currentInstance.getOffset(el);\n _delements[pid][id] = {\n id: id,\n offset: {\n left: cLoc.left - pLoc.left,\n top: cLoc.top - pLoc.top\n }\n };\n _draggablesForElements[id] = pid;\n }\n break;\n }\n p = p.parentNode;\n }\n };\n\n this.endpointDeleted = function (endpoint) {\n if (_elementsWithEndpoints[endpoint.elementId]) {\n _elementsWithEndpoints[endpoint.elementId]--;\n if (_elementsWithEndpoints[endpoint.elementId] <= 0) {\n for (var i in _delements) {\n if (_delements.hasOwnProperty(i) && _delements[i]) {\n delete _delements[i][endpoint.elementId];\n delete _draggablesForElements[endpoint.elementId];\n }\n }\n }\n }\n };\n\n this.changeId = function (oldId, newId) {\n _delements[newId] = _delements[oldId];\n _delements[oldId] = {};\n _draggablesForElements[newId] = _draggablesForElements[oldId];\n _draggablesForElements[oldId] = null;\n };\n\n this.getElementsForDraggable = function (id) {\n return _delements[id];\n };\n\n this.elementRemoved = function (elementId) {\n var elId = _draggablesForElements[elementId];\n if (elId) {\n delete _delements[elId][elementId];\n delete _draggablesForElements[elementId];\n }\n };\n\n this.reset = function () {\n _draggables = {};\n _dlist = [];\n _delements = {};\n _elementsWithEndpoints = {};\n };\n\n //\n // notification drag ended. We check automatically if need to update some\n // ancestor's offsets.\n //\n this.dragEnded = function (el) {\n if (el.offsetParent != null) {\n var id = _currentInstance.getId(el),\n ancestor = _draggablesForElements[id];\n\n if (ancestor) {\n this.updateOffsets(ancestor);\n }\n }\n };\n\n this.setParent = function (el, elId, p, pId, currentChildLocation) {\n var current = _draggablesForElements[elId];\n if (!_delements[pId]) {\n _delements[pId] = {};\n }\n var pLoc = _currentInstance.getOffset(p),\n cLoc = currentChildLocation || _currentInstance.getOffset(el);\n\n if (current && _delements[current]) {\n delete _delements[current][elId];\n }\n\n _delements[pId][elId] = {\n id:elId,\n offset : {\n left: cLoc.left - pLoc.left,\n top: cLoc.top - pLoc.top\n }\n };\n _draggablesForElements[elId] = pId;\n };\n\n this.clearParent = function(el, elId) {\n var current = _draggablesForElements[elId];\n if (current) {\n delete _delements[current][elId];\n delete _draggablesForElements[elId];\n }\n };\n\n this.revalidateParent = function(el, elId, childOffset) {\n var current = _draggablesForElements[elId];\n if (current) {\n var co = {};\n co[elId] = childOffset;\n this.updateOffsets(current, co);\n _currentInstance.revalidate(current);\n }\n };\n\n this.getDragAncestor = function (el) {\n var de = jsPlumb.getElement(el),\n id = _currentInstance.getId(de),\n aid = _draggablesForElements[id];\n\n if (aid) {\n return jsPlumb.getElement(aid);\n }\n else {\n return null;\n }\n };\n\n };\n\n var _setClassName = function (el, cn, classList) {\n cn = _ju.fastTrim(cn);\n if (typeof el.className.baseVal !== \"undefined\") {\n el.className.baseVal = cn;\n }\n else {\n el.className = cn;\n }\n\n // recent (i currently have 61.0.3163.100) version of chrome do not update classList when you set the base val\n // of an svg element's className. in the long run we'd like to move to just using classList anyway\n try {\n var cl = el.classList;\n if (cl != null) {\n while (cl.length > 0) {\n cl.remove(cl.item(0));\n }\n for (var i = 0; i < classList.length; i++) {\n if (classList[i]) {\n cl.add(classList[i]);\n }\n }\n }\n }\n catch(e) {\n // not fatal\n _ju.log(\"JSPLUMB: cannot set class list\", e);\n }\n },\n _getClassName = function (el) {\n return (typeof el.className.baseVal === \"undefined\") ? el.className : el.className.baseVal;\n },\n _classManip = function (el, classesToAdd, classesToRemove) {\n classesToAdd = classesToAdd == null ? [] : _ju.isArray(classesToAdd) ? classesToAdd : classesToAdd.split(/\\s+/);\n classesToRemove = classesToRemove == null ? [] : _ju.isArray(classesToRemove) ? classesToRemove : classesToRemove.split(/\\s+/);\n\n var className = _getClassName(el),\n curClasses = className.split(/\\s+/);\n\n var _oneSet = function (add, classes) {\n for (var i = 0; i < classes.length; i++) {\n if (add) {\n if (curClasses.indexOf(classes[i]) === -1) {\n curClasses.push(classes[i]);\n }\n }\n else {\n var idx = curClasses.indexOf(classes[i]);\n if (idx !== -1) {\n curClasses.splice(idx, 1);\n }\n }\n }\n };\n\n _oneSet(true, classesToAdd);\n _oneSet(false, classesToRemove);\n\n _setClassName(el, curClasses.join(\" \"), curClasses);\n };\n\n root.jsPlumb.extend(root.jsPlumbInstance.prototype, {\n\n headless: false,\n\n pageLocation: _pageLocation,\n screenLocation: _screenLocation,\n clientLocation: _clientLocation,\n\n getDragManager:function() {\n if (this.dragManager == null) {\n this.dragManager = new DragManager(this);\n }\n\n return this.dragManager;\n },\n\n recalculateOffsets:function(elId) {\n this.getDragManager().updateOffsets(elId);\n },\n\n createElement:function(tag, style, clazz, atts) {\n return this.createElementNS(null, tag, style, clazz, atts);\n },\n\n createElementNS:function(ns, tag, style, clazz, atts) {\n var e = ns == null ? document.createElement(tag) : document.createElementNS(ns, tag);\n var i;\n style = style || {};\n for (i in style) {\n e.style[i] = style[i];\n }\n\n if (clazz) {\n e.className = clazz;\n }\n\n atts = atts || {};\n for (i in atts) {\n e.setAttribute(i, \"\" + atts[i]);\n }\n\n return e;\n },\n\n getAttribute: function (el, attName) {\n return el.getAttribute != null ? el.getAttribute(attName) : null;\n },\n\n setAttribute: function (el, a, v) {\n if (el.setAttribute != null) {\n el.setAttribute(a, v);\n }\n },\n\n setAttributes: function (el, atts) {\n for (var i in atts) {\n if (atts.hasOwnProperty(i)) {\n el.setAttribute(i, atts[i]);\n }\n }\n },\n appendToRoot: function (node) {\n document.body.appendChild(node);\n },\n getRenderModes: function () {\n return [ \"svg\" ];\n },\n getClass:_getClassName,\n addClass: function (el, clazz) {\n jsPlumb.each(el, function (e) {\n _classManip(e, clazz);\n });\n },\n hasClass: function (el, clazz) {\n el = jsPlumb.getElement(el);\n if (el.classList) {\n return el.classList.contains(clazz);\n }\n else {\n return _getClassName(el).indexOf(clazz) !== -1;\n }\n },\n removeClass: function (el, clazz) {\n jsPlumb.each(el, function (e) {\n _classManip(e, null, clazz);\n });\n },\n toggleClass:function(el, clazz) {\n if (jsPlumb.hasClass(el, clazz)) {\n jsPlumb.removeClass(el, clazz);\n } else {\n jsPlumb.addClass(el, clazz);\n }\n },\n updateClasses: function (el, toAdd, toRemove) {\n jsPlumb.each(el, function (e) {\n _classManip(e, toAdd, toRemove);\n });\n },\n setClass: function (el, clazz) {\n if (clazz != null) {\n jsPlumb.each(el, function (e) {\n _setClassName(e, clazz, clazz.split(/\\s+/));\n });\n }\n },\n setPosition: function (el, p) {\n el.style.left = p.left + \"px\";\n el.style.top = p.top + \"px\";\n },\n getPosition: function (el) {\n var _one = function (prop) {\n var v = el.style[prop];\n return v ? v.substring(0, v.length - 2) : 0;\n };\n return {\n left: _one(\"left\"),\n top: _one(\"top\")\n };\n },\n getStyle:function(el, prop) {\n if (typeof window.getComputedStyle !== 'undefined') {\n return getComputedStyle(el, null).getPropertyValue(prop);\n } else {\n return el.currentStyle[prop];\n }\n },\n getSelector: function (ctx, spec) {\n var sel = null;\n if (arguments.length === 1) {\n sel = ctx.nodeType != null ? ctx : document.querySelectorAll(ctx);\n }\n else {\n sel = ctx.querySelectorAll(spec);\n }\n\n return sel;\n },\n getOffset:function(el, relativeToRoot, container) {\n el = jsPlumb.getElement(el);\n container = container || this.getContainer();\n var out = {\n left: el.offsetLeft,\n top: el.offsetTop\n },\n op = (relativeToRoot || (container != null && (el !== container && el.offsetParent !== container))) ? el.offsetParent : null,\n _maybeAdjustScroll = function(offsetParent) {\n if (offsetParent != null && offsetParent !== document.body && (offsetParent.scrollTop > 0 || offsetParent.scrollLeft > 0)) {\n out.left -= offsetParent.scrollLeft;\n out.top -= offsetParent.scrollTop;\n }\n }.bind(this);\n\n while (op != null) {\n out.left += op.offsetLeft;\n out.top += op.offsetTop;\n _maybeAdjustScroll(op);\n op = relativeToRoot ? op.offsetParent :\n op.offsetParent === container ? null : op.offsetParent;\n }\n\n // if container is scrolled and the element (or its offset parent) is not absolute or fixed, adjust accordingly.\n if (container != null && !relativeToRoot && (container.scrollTop > 0 || container.scrollLeft > 0)) {\n var pp = el.offsetParent != null ? this.getStyle(el.offsetParent, \"position\") : \"static\",\n p = this.getStyle(el, \"position\");\n if (p !== \"absolute\" && p !== \"fixed\" && pp !== \"absolute\" && pp !== \"fixed\") {\n out.left -= container.scrollLeft;\n out.top -= container.scrollTop;\n }\n }\n return out;\n },\n //\n // return x+y proportion of the given element's size corresponding to the location of the given event.\n //\n getPositionOnElement: function (evt, el, zoom) {\n var box = typeof el.getBoundingClientRect !== \"undefined\" ? el.getBoundingClientRect() : { left: 0, top: 0, width: 0, height: 0 },\n body = document.body,\n docElem = document.documentElement,\n scrollTop = window.pageYOffset || docElem.scrollTop || body.scrollTop,\n scrollLeft = window.pageXOffset || docElem.scrollLeft || body.scrollLeft,\n clientTop = docElem.clientTop || body.clientTop || 0,\n clientLeft = docElem.clientLeft || body.clientLeft || 0,\n pst = 0,\n psl = 0,\n top = box.top + scrollTop - clientTop + (pst * zoom),\n left = box.left + scrollLeft - clientLeft + (psl * zoom),\n cl = jsPlumb.pageLocation(evt),\n w = box.width || (el.offsetWidth * zoom),\n h = box.height || (el.offsetHeight * zoom),\n x = (cl[0] - left) / w,\n y = (cl[1] - top) / h;\n\n return [ x, y ];\n },\n\n /**\n * Gets the absolute position of some element as read from the left/top properties in its style.\n * @method getAbsolutePosition\n * @param {Element} el The element to retrieve the absolute coordinates from. **Note** this is a DOM element, not a selector from the underlying library.\n * @return {Number[]} [left, top] pixel values.\n */\n getAbsolutePosition: function (el) {\n var _one = function (s) {\n var ss = el.style[s];\n if (ss) {\n return parseFloat(ss.substring(0, ss.length - 2));\n }\n };\n return [ _one(\"left\"), _one(\"top\") ];\n },\n\n /**\n * Sets the absolute position of some element by setting the left/top properties in its style.\n * @method setAbsolutePosition\n * @param {Element} el The element to set the absolute coordinates on. **Note** this is a DOM element, not a selector from the underlying library.\n * @param {Number[]} xy x and y coordinates\n * @param {Number[]} [animateFrom] Optional previous xy to animate from.\n * @param {Object} [animateOptions] Options for the animation.\n */\n setAbsolutePosition: function (el, xy, animateFrom, animateOptions) {\n if (animateFrom) {\n this.animate(el, {\n left: \"+=\" + (xy[0] - animateFrom[0]),\n top: \"+=\" + (xy[1] - animateFrom[1])\n }, animateOptions);\n }\n else {\n el.style.left = xy[0] + \"px\";\n el.style.top = xy[1] + \"px\";\n }\n },\n /**\n * gets the size for the element, in an array : [ width, height ].\n */\n getSize: function (el) {\n return [ el.offsetWidth, el.offsetHeight ];\n },\n getWidth: function (el) {\n return el.offsetWidth;\n },\n getHeight: function (el) {\n return el.offsetHeight;\n },\n getRenderMode : function() { return \"svg\"; },\n draggable : function (el, options) {\n var info;\n el = _ju.isArray(el) || (el.length != null && !_ju.isString(el)) ? el: [ el ];\n Array.prototype.slice.call(el).forEach(function(_el) {\n info = this.info(_el);\n if (info.el) {\n this._initDraggableIfNecessary(info.el, true, options, info.id, true);\n }\n }.bind(this));\n return this;\n },\n initDraggable: function (el, options, category) {\n _getDragManager(this, category).draggable(el, options);\n el._jsPlumbDragOptions = options;\n },\n destroyDraggable: function (el, category) {\n _getDragManager(this, category).destroyDraggable(el);\n delete el._jsPlumbDragOptions;\n },\n unbindDraggable: function (el, evt, fn, category) {\n _getDragManager(this, category).destroyDraggable(el, evt, fn);\n },\n setDraggable : function (element, draggable) {\n return jsPlumb.each(element, function (el) {\n if (this.isDragSupported(el)) {\n this._draggableStates[this.getAttribute(el, \"id\")] = draggable;\n this.setElementDraggable(el, draggable);\n }\n }.bind(this));\n },\n _draggableStates : {},\n /*\n * toggles the draggable state of the given element(s).\n * el is either an id, or an element object, or a list of ids/element objects.\n */\n toggleDraggable : function (el) {\n var state;\n jsPlumb.each(el, function (el) {\n var elId = this.getAttribute(el, \"id\");\n state = this._draggableStates[elId] == null ? false : this._draggableStates[elId];\n state = !state;\n this._draggableStates[elId] = state;\n this.setDraggable(el, state);\n return state;\n }.bind(this));\n return state;\n },\n _initDraggableIfNecessary : function (element, isDraggable, dragOptions, id, fireEvent) {\n // TODO FIRST: move to DragManager. including as much of the decision to init dragging as possible.\n if (!jsPlumb.headless) {\n var _draggable = isDraggable == null ? false : isDraggable;\n if (_draggable) {\n if (jsPlumb.isDragSupported(element, this)) {\n var options = dragOptions || this.Defaults.DragOptions;\n options = jsPlumb.extend({}, options); // make a copy.\n if (!jsPlumb.isAlreadyDraggable(element, this)) {\n var dragEvent = jsPlumb.dragEvents.drag,\n stopEvent = jsPlumb.dragEvents.stop,\n startEvent = jsPlumb.dragEvents.start;\n\n this.manage(id, element);\n\n options[startEvent] = _ju.wrap(options[startEvent], _dragStart.bind(this));\n\n options[dragEvent] = _ju.wrap(options[dragEvent], _dragMove.bind(this));\n\n options[stopEvent] = _ju.wrap(options[stopEvent], _dragStop.bind(this));\n\n var elId = this.getId(element); // need ID\n\n this._draggableStates[elId] = true;\n var draggable = this._draggableStates[elId];\n\n options.disabled = draggable == null ? false : !draggable;\n this.initDraggable(element, options);\n this.getDragManager().register(element);\n if (fireEvent) {\n this.fire(\"elementDraggable\", {el:element, options:options});\n }\n }\n else {\n // already draggable. attach any start, drag or stop listeners to the current Drag.\n if (dragOptions.force) {\n this.initDraggable(element, options);\n }\n }\n }\n }\n }\n },\n animationSupported:true,\n getElement: function (el) {\n if (el == null) {\n return null;\n }\n // here we pluck the first entry if el was a list of entries.\n // this is not my favourite thing to do, but previous versions of\n // jsplumb supported jquery selectors, and it is possible a selector\n // will be passed in here.\n el = typeof el === \"string\" ? el : el.length != null && el.enctype == null ? el[0] : el;\n return typeof el === \"string\" ? document.getElementById(el) : el;\n },\n removeElement: function (element) {\n _getDragManager(this).elementRemoved(element);\n this.getEventManager().remove(element);\n },\n //\n // this adapter supports a rudimentary animation function. no easing is supported. only\n // left/top properties are supported. property delta args are expected to be in the form\n //\n // +=x.xxxx\n //\n // or\n //\n // -=x.xxxx\n //\n doAnimate: function (el, properties, options) {\n options = options || {};\n var o = this.getOffset(el),\n ap = _animProps(o, properties),\n ldist = ap[0] - o.left,\n tdist = ap[1] - o.top,\n d = options.duration || 250,\n step = 15, steps = d / step,\n linc = (step / d) * ldist,\n tinc = (step / d) * tdist,\n idx = 0,\n _int = setInterval(function () {\n _jp.setPosition(el, {\n left: o.left + (linc * (idx + 1)),\n top: o.top + (tinc * (idx + 1))\n });\n if (options.step != null) {\n options.step(idx, Math.ceil(steps));\n }\n idx++;\n if (idx >= steps) {\n window.clearInterval(_int);\n if (options.complete != null) {\n options.complete();\n }\n }\n }, step);\n },\n // DRAG/DROP\n\n\n destroyDroppable: function (el, category) {\n _getDragManager(this, category).destroyDroppable(el);\n },\n unbindDroppable: function (el, evt, fn, category) {\n _getDragManager(this, category).destroyDroppable(el, evt, fn);\n },\n\n droppable :function(el, options) {\n el = _ju.isArray(el) || (el.length != null && !_ju.isString(el)) ? el: [ el ];\n var info;\n options = options || {};\n options.allowLoopback = false;\n Array.prototype.slice.call(el).forEach(function(_el) {\n info = this.info(_el);\n if (info.el) {\n this.initDroppable(info.el, options);\n }\n }.bind(this));\n return this;\n },\n\n initDroppable: function (el, options, category) {\n _getDragManager(this, category).droppable(el, options);\n },\n isAlreadyDraggable: function (el) {\n return el._katavorioDrag != null;\n },\n isDragSupported: function (el, options) {\n return true;\n },\n isDropSupported: function (el, options) {\n return true;\n },\n isElementDraggable: function (el) {\n el = _jp.getElement(el);\n return el._katavorioDrag && el._katavorioDrag.isEnabled();\n },\n getDragObject: function (eventArgs) {\n return eventArgs[0].drag.getDragElement();\n },\n getDragScope: function (el) {\n return el._katavorioDrag && el._katavorioDrag.scopes.join(\" \") || \"\";\n },\n getDropEvent: function (args) {\n return args[0].e;\n },\n getUIPosition: function (eventArgs, zoom) {\n // here the position reported to us by Katavorio is relative to the element's offsetParent. For top\n // level nodes that is fine, but if we have a nested draggable then its offsetParent is actually\n // not going to be the jsplumb container; it's going to be some child of that element. In that case\n // we want to adjust the UI position to account for the offsetParent's position relative to the Container\n // origin.\n var el = eventArgs[0].el;\n if (el.offsetParent == null) {\n return null;\n }\n var finalPos = eventArgs[0].finalPos || eventArgs[0].pos;\n var p = { left:finalPos[0], top:finalPos[1] };\n if (el._katavorioDrag && el.offsetParent !== this.getContainer()) {\n var oc = this.getOffset(el.offsetParent);\n p.left += oc.left;\n p.top += oc.top;\n }\n return p;\n },\n setDragFilter: function (el, filter, _exclude) {\n if (el._katavorioDrag) {\n el._katavorioDrag.setFilter(filter, _exclude);\n }\n },\n setElementDraggable: function (el, draggable) {\n el = _jp.getElement(el);\n if (el._katavorioDrag) {\n el._katavorioDrag.setEnabled(draggable);\n }\n },\n setDragScope: function (el, scope) {\n if (el._katavorioDrag) {\n el._katavorioDrag.k.setDragScope(el, scope);\n }\n },\n setDropScope:function(el, scope) {\n if (el._katavorioDrop && el._katavorioDrop.length > 0) {\n el._katavorioDrop[0].k.setDropScope(el, scope);\n }\n },\n addToPosse:function(el, spec) {\n var specs = Array.prototype.slice.call(arguments, 1);\n var dm = _getDragManager(this);\n _jp.each(el, function(_el) {\n _el = [ _jp.getElement(_el) ];\n _el.push.apply(_el, specs );\n dm.addToPosse.apply(dm, _el);\n });\n },\n setPosse:function(el, spec) {\n var specs = Array.prototype.slice.call(arguments, 1);\n var dm = _getDragManager(this);\n _jp.each(el, function(_el) {\n _el = [ _jp.getElement(_el) ];\n _el.push.apply(_el, specs );\n dm.setPosse.apply(dm, _el);\n });\n },\n removeFromPosse:function(el, posseId) {\n var specs = Array.prototype.slice.call(arguments, 1);\n var dm = _getDragManager(this);\n _jp.each(el, function(_el) {\n _el = [ _jp.getElement(_el) ];\n _el.push.apply(_el, specs );\n dm.removeFromPosse.apply(dm, _el);\n });\n },\n removeFromAllPosses:function(el) {\n var dm = _getDragManager(this);\n _jp.each(el, function(_el) { dm.removeFromAllPosses(_jp.getElement(_el)); });\n },\n setPosseState:function(el, posseId, state) {\n var dm = _getDragManager(this);\n _jp.each(el, function(_el) { dm.setPosseState(_jp.getElement(_el), posseId, state); });\n },\n dragEvents: {\n 'start': 'start', 'stop': 'stop', 'drag': 'drag', 'step': 'step',\n 'over': 'over', 'out': 'out', 'drop': 'drop', 'complete': 'complete',\n 'beforeStart':'beforeStart'\n },\n animEvents: {\n 'step': \"step\", 'complete': 'complete'\n },\n stopDrag: function (el) {\n if (el._katavorioDrag) {\n el._katavorioDrag.abort();\n }\n },\n addToDragSelection: function (spec) {\n _getDragManager(this).select(spec);\n },\n removeFromDragSelection: function (spec) {\n _getDragManager(this).deselect(spec);\n },\n clearDragSelection: function () {\n _getDragManager(this).deselectAll();\n },\n trigger: function (el, event, originalEvent, payload) {\n this.getEventManager().trigger(el, event, originalEvent, payload);\n },\n doReset:function() {\n // look for katavorio instances and reset each one if found.\n for (var key in this) {\n if (key.indexOf(\"_katavorio_\") === 0) {\n this[key].reset();\n }\n }\n },\n getEventManager:function() {\n return _getEventManager(this);\n },\n on : function(el, event, callback) {\n // TODO: here we would like to map the tap event if we know its\n // an internal bind to a click. we have to know its internal because only\n // then can we be sure that the UP event wont be consumed (tap is a synthesized\n // event from a mousedown followed by a mouseup).\n //event = { \"click\":\"tap\", \"dblclick\":\"dbltap\"}[event] || event;\n this.getEventManager().on.apply(this, arguments);\n return this;\n },\n off : function(el, event, callback) {\n this.getEventManager().off.apply(this, arguments);\n return this;\n }\n\n });\n\n var ready = function (f) {\n var _do = function () {\n if (/complete|loaded|interactive/.test(document.readyState) && typeof(document.body) !== \"undefined\" && document.body != null) {\n f();\n }\n else {\n setTimeout(_do, 9);\n }\n };\n\n _do();\n };\n ready(_jp.init);\n\n}).call(typeof window !== 'undefined' ? window : this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/jsplumb/dist/js/jsplumb.js\n// module id = 721\n// module chunks = 3 4 5","\nimport i18n from '@/module/i18n'\n\n/**\n * cycle\n */\nconst cycleList = [\n {\n value: 'month',\n label: `${i18n.$t('月')}`\n },\n {\n value: 'week',\n label: `${i18n.$t('周')}`\n },\n {\n value: 'day',\n label: `${i18n.$t('日')}`\n },\n {\n value: 'hour',\n label: `${i18n.$t('时')}`\n }\n]\n\n/**\n * cycle value\n */\nconst dateValueList = {\n 'hour': [\n {\n value: 'last1Hour',\n label: `${i18n.$t('前1小时')}`\n },\n {\n value: 'last2Hours',\n label: `${i18n.$t('前2小时')}`\n },\n {\n value: 'last3Hours',\n label: `${i18n.$t('前3小时')}`\n }\n ],\n 'day': [\n {\n value: 'last1Days',\n label: `${i18n.$t('昨天')}`\n },\n {\n value: 'last2Days',\n label: `${i18n.$t('前两天')}`\n },\n {\n value: 'last3Days',\n label: `${i18n.$t('前三天')}`\n },\n {\n value: 'last7Days',\n label: `${i18n.$t('前七天')}`\n }\n ],\n 'week': [\n {\n value: 'lastWeek',\n label: `${i18n.$t('上周')}`\n },\n {\n value: 'lastMonday',\n label: `${i18n.$t('上周一')}`\n },\n {\n value: 'lastTuesday',\n label: `${i18n.$t('上周二')}`\n },\n {\n value: 'lastWednesday',\n label: `${i18n.$t('上周三')}`\n },\n {\n value: 'lastThursday',\n label: `${i18n.$t('上周四')}`\n },\n {\n value: 'lastFriday',\n label: `${i18n.$t('上周五')}`\n },\n {\n value: 'lastSaturday',\n label: `${i18n.$t('上周六')}`\n },\n {\n value: 'lastSunday',\n label: `${i18n.$t('上周日')}`\n }\n ],\n 'month': [\n {\n value: 'lastMonth',\n label: `${i18n.$t('上月')}`\n },\n {\n value: 'lastMonthBegin',\n label: `${i18n.$t('上月初')}`\n },\n {\n value: 'lastMonthEnd',\n label: `${i18n.$t('上月末')}`\n }\n ]\n}\n\n/**\n * direct\n */\nconst directList = [\n {\n id: 1,\n code: 'IN',\n disabled: false\n },\n {\n id: 2,\n code: 'OUT',\n disabled: false\n }\n]\n\n/**\n * type\n */\nconst typeList = [\n {\n id: 1,\n code: 'VARCHAR',\n disabled: false\n },\n {\n id: 2,\n code: 'INTEGER',\n disabled: false\n },\n {\n id: 3,\n code: 'LONG',\n disabled: false\n },\n {\n id: 4,\n code: 'FLOAT',\n disabled: false\n },\n {\n id: 5,\n code: 'DOUBLE',\n disabled: false\n },\n {\n id: 6,\n code: 'DATE',\n disabled: false\n },\n {\n id: 7,\n code: 'TIME',\n disabled: false\n },\n {\n id: 8,\n code: 'TIMESTAMP',\n disabled: false\n },\n {\n id: 9,\n code: 'BOOLEAN',\n disabled: false\n }\n]\n\n/**\n * sqlType\n */\nconst sqlTypeList = [\n {\n id: 0,\n code: `${i18n.$t('查询')}`\n },\n {\n id: 1,\n code: `${i18n.$t('非查询')}`\n }\n]\n\nexport {\n cycleList,\n dateValueList,\n typeList,\n directList,\n sqlTypeList\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/js/conf/home/pages/dag/_source/formModel/tasks/_source/commcon.js","\n \n \n \n \n \n \n \n \n