{"version":3,"sources":["webpack:///./node_modules/@progress/kendo-ui/js/dataviz/diagram/math.js"],"names":["module","exports","modules","installedModules","__webpack_require__","moduleId","id","loaded","call","m","c","p","0","3","Error","890","911","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","f","define","apply","undefined","$","kendo","window","diagram","dataviz","Class","deepExtend","Utils","Point","Point2D","isFunction","contains","map","HITTESTAREA","EPSILON","fn","plus","this","x","y","minus","offset","value","times","s","normalize","length","Math","sqrt","toString","lengthSquared","middleOf","q","toPolar","useDegrees","factor","PI","a","atan2","abs","halfpi","len","Polar","isOnLine","from","to","temp","o1","u1","r1","Rect","inflate","r2","union","height","width","parse","str","tempStr","slice","xy","split","parseInt","isNaN","PathDefiner","extend","init","left","right","point","dx","dy","r","x1","min","y1","x2","max","y2","center","top","bottom","topLeft","topRight","bottomLeft","bottomRight","clone","isEmpty","equals","rect","rotatedBounds","angle","points","rotatedPoints","tl","tr","br","bl","rotate","delimiter","scale","scaleX","scaleY","staicPoint","adornerCenter","thisCenter","delta","scaled","position","zoom","overlaps","rectBottomRight","Size","isNearZero","num","intersectLine","start1","end1","start2","end2","isSegment","tangensdiff","num1","num2","prototype","Empty","toRect","empty","fromPoints","Intersect","lines","segments","rectWithLine","start","end","rects","rect1","rect2","intersect","reverseAngle","RectAlign","container","align","content","alignment","alignValues","toLowerCase","i","_singleAlign","_align","_left","_center","_right","stretch","_stretch","_top","middle","_middle","_bottom","alignCalc","Matrix","b","d","e","applyRect","fromSVGMatrix","vm","fromMatrixVector","v","fromList","translation","unit","rotation","cos","sin","scaling","parts","nums","trim","parseFloat","substr","indexOf","MatrixVector","fromMatrix","normalVariable","mean","deviation","random","log","randomId","isUndefined","result","chars","charAt","round","Geometry","_distanceToLineSquared","d2","pt1","pt2","vx","vy","dot","distanceToLine","distanceToPolyline","minimum","Number","MAX_VALUE","p1","p2","HashTable","_buckets","add","key","obj","_createGetBucket","isDefined","get","_bucketExists","set","containsKey","remove","hashId","_hash","forEach","func","hashes","_hashes","hash","bucket","ht","hasOwnProperty","push","isNumber","isString","_hashString","isObject","_objectHashId","ch","charCodeAt","_hashId","Dictionary","Observable","dictionary","that","_hashTable","Array","isArray","k","entry","trigger","thisRef","forEachValue","forEachKey","keys","Queue","_tail","_head","enqueue","next","dequeue","item","current","Set","resource","context","kv","toArray","Node","shape","links","outgoing","incoming","weight","associatedShape","bounds","data","type","shortForm","isVirtual","isIsolated","isLinkedTo","node","any","link","getComplement","getChildren","children","getParents","parents","copy","balance","owner","adjacentTo","removeLink","source","target","hasLinkTo","degree","incidentWith","getLinksWith","all","getNeighbors","neighbors","Link","connection","sourceFound","targetFound","associatedConnection","getCommonNode","isBridging","v1","v2","getNodes","changeSource","changeTarget","changesNodes","w","reverse","oldSource","oldTarget","directTo","createReverseEdge","reversed","Graph","idOrDiagram","nodes","_nodeMap","_root","_hasCachedRelationships","cacheRelationships","forceRebuild","assignLevels","startNode","visited","n","level","child","root","found","first","getConnectedComponents","componentIndex","setItemIndices","componentId","initArray","_collectConnectedNodes","components","graph","addNodeAndOutgoings","sort","setIds","nodeIndex","nextId","index","calcBounds","getSpanningTree","tree","remaining","_addNode","levelCount","pop","ni","cn","newLink","addLink","treeLevels","takeRandomNode","excludedNodes","incidenceLessThan","pool","grep","randomInteger","isHealthy","hasNode","sourceOrLink","addExistingLink","foundSource","getNode","addNode","foundTarget","removeAllLinks","hasLink","t","linkOrId","nodeOrId","_removeNode","removeNode","areConnected","n1","n2","layoutRect","newNode","newLinks","saveMapping","save","nodeMap","linkMap","nOriginal","nCopy","linkOriginal","linkCopy","linearize","addIds","depthFirstTraversal","action","foundNode","_dftIterator","breadthFirstTraversal","queue","_stronglyConnectedComponents","excludeSingleItems","indices","lowLinks","connected","stack","component","findCycles","isAcyclic","isSubGraph","other","otherArray","thisArray","makeAcyclic","oneLink","oneNode","rev","N","intensityCatalog","flowIntensity","catalogEqualIntensity","intensity","sourceStack","targetStack","targets","li","targetLink","unshift","sources","si","sourceLink","maxdiff","ri","ril","u","concat","vertexOrder","kk","reversedEdges","Predefined","EightGraph","Mindmap","ThreeGraph","BinaryTree","levels","createBalancedTree","Linear","Tree","siblingsCount","Forest","trees","createBalancedForest","Workflow","Grid","g","previous","j","graphString","previousLink","part","lin","_addShape","kendoDiagram","shapeDefaults","radius","fill","undoable","addShape","_addConnection","options","connect","createDiagramFromGraph","doLayout","randomSize","element","clientWidth","clientHeight","opt","color","gli","sourceShape","targetShape","l","SpringLayout","layoutGraph","limitToView","shi","news","counter","lastAdded","parent","treeCount","createRandomConnectedGraph","nodeCount","maxIncidence","isTree","poolNode","randomAdditions","randomDiagram","shapeCount","ui","jQuery","912"],"mappings":"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","file":"js/chunk-vendors~24a9015d.92abe88d.js","sourcesContent":["module.exports =\n/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ (function(module, exports, __webpack_require__) {\n\n\tmodule.exports = __webpack_require__(911);\n\n\n/***/ }),\n\n/***/ 3:\n/***/ (function(module, exports) {\n\n\tmodule.exports = function() { throw new Error(\"define cannot be used indirect\"); };\r\n\n\n/***/ }),\n\n/***/ 890:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"../../kendo.dataviz.core\");\n\n/***/ }),\n\n/***/ 911:\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(f, define){\n\t    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [ __webpack_require__(912), __webpack_require__(890) ], __WEBPACK_AMD_DEFINE_FACTORY__ = (f), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t})(function(){\n\n\t(function ($, undefined) {\n\t    // Imports ================================================================\n\t    var kendo = window.kendo,\n\t        diagram = kendo.dataviz.diagram,\n\t        Class = kendo.Class,\n\t        deepExtend = kendo.deepExtend,\n\t        dataviz = kendo.dataviz,\n\t        Utils = diagram.Utils,\n\t        Point = dataviz.Point2D,\n\t        isFunction = kendo.isFunction,\n\t        contains = Utils.contains,\n\t        map = $.map;\n\n\t    // Constants ==============================================================\n\t    var HITTESTAREA = 3,\n\t        EPSILON = 1e-06;\n\n\t    deepExtend(Point.fn, {\n\t        plus: function (p) {\n\t            return new Point(this.x + p.x, this.y + p.y);\n\t        },\n\t        minus: function (p) {\n\t            return new Point(this.x - p.x, this.y - p.y);\n\t        },\n\t        offset: function (value) {\n\t            return new Point(this.x - value, this.y - value);\n\t        },\n\t        times: function (s) {\n\t            return new Point(this.x * s, this.y * s);\n\t        },\n\t        normalize: function () {\n\t            if (this.length() === 0) {\n\t                return new Point();\n\t            }\n\t            return this.times(1 / this.length());\n\t        },\n\t        length: function () {\n\t            return Math.sqrt(this.x * this.x + this.y * this.y);\n\t        },\n\t        toString: function () {\n\t            return \"(\" + this.x + \",\" + this.y + \")\";\n\t        },\n\t        lengthSquared: function () {\n\t            return (this.x * this.x + this.y * this.y);\n\t        },\n\t        middleOf: function MiddleOf(p, q) {\n\t            return new Point(q.x - p.x, q.y - p.y).times(0.5).plus(p);\n\t        },\n\t        toPolar: function (useDegrees) {\n\t            var factor = 1;\n\t            if (useDegrees) {\n\t                factor = 180 / Math.PI;\n\t            }\n\t            var a = Math.atan2(Math.abs(this.y), Math.abs(this.x));\n\t            var halfpi = Math.PI / 2;\n\t            var len = this.length();\n\t            if (this.x === 0) {\n\t                // note that the angle goes down and not the usual mathematical convention\n\n\t                if (this.y === 0) {\n\t                    return new Polar(0, 0);\n\t                }\n\t                if (this.y > 0) {\n\t                    return new Polar(len, factor * halfpi);\n\t                }\n\t                if (this.y < 0) {\n\t                    return new Polar(len, factor * 3 * halfpi);\n\t                }\n\t            }\n\t            else if (this.x > 0) {\n\t                if (this.y === 0) {\n\t                    return new Polar(len, 0);\n\t                }\n\t                if (this.y > 0) {\n\t                    return new Polar(len, factor * a);\n\t                }\n\t                if (this.y < 0) {\n\t                    return new Polar(len, factor * (4 * halfpi - a));\n\t                }\n\t            }\n\t            else {\n\t                if (this.y === 0) {\n\t                    return new Polar(len, 2 * halfpi);\n\t                }\n\t                if (this.y > 0) {\n\t                    return new Polar(len, factor * (2 * halfpi - a));\n\t                }\n\t                if (this.y < 0) {\n\t                    return new Polar(len, factor * (2 * halfpi + a));\n\t                }\n\t            }\n\t        },\n\t        isOnLine: function (from, to) {\n\t            if (from.x > to.x) { // from must be the leftmost point\n\t                var temp = to;\n\t                to = from;\n\t                from = temp;\n\t            }\n\t            var r1 = new Rect(from.x, from.y).inflate(HITTESTAREA, HITTESTAREA),\n\t                r2 = new Rect(to.x, to.y).inflate(HITTESTAREA, HITTESTAREA), o1, u1;\n\t            if (r1.union(r2).contains(this)) {\n\t                if (from.x === to.x || from.y === to.y) {\n\t                    return true;\n\t                }\n\t                else if (from.y < to.y) {\n\t                    o1 = r1.x + (((r2.x - r1.x) * (this.y - (r1.y + r1.height))) / ((r2.y + r2.height) - (r1.y + r1.height)));\n\t                    u1 = (r1.x + r1.width) + ((((r2.x + r2.width) - (r1.x + r1.width)) * (this.y - r1.y)) / (r2.y - r1.y));\n\t                }\n\t                else {\n\t                    o1 = r1.x + (((r2.x - r1.x) * (this.y - r1.y)) / (r2.y - r1.y));\n\t                    u1 = (r1.x + r1.width) + ((((r2.x + r2.width) - (r1.x + r1.width)) * (this.y - (r1.y + r1.height))) / ((r2.y + r2.height) - (r1.y + r1.height)));\n\t                }\n\t                return (this.x > o1 && this.x < u1);\n\t            }\n\t            return false;\n\t        }\n\t    });\n\n\t    deepExtend(Point, {\n\t        parse: function (str) {\n\t            var tempStr = str.slice(1, str.length - 1),\n\t                xy = tempStr.split(\",\"),\n\t                x = parseInt(xy[0], 10),\n\t                y = parseInt(xy[1], 10);\n\t            if (!isNaN(x) && !isNaN(y)) {\n\t                return new Point(x, y);\n\t            }\n\t        }\n\t    });\n\n\t    /**\n\t     * Structure combining a Point with two additional points representing the handles or tangents attached to the first point.\n\t     * If the additional points are null or equal to the first point the path will be sharp.\n\t     * Left and right correspond to the direction of the underlying path.\n\t     */\n\t    var PathDefiner = Class.extend(\n\t        {\n\t            init: function (p, left, right) {\n\t                this.point = p;\n\t                this.left = left;\n\t                this.right = right;\n\t            }\n\t        }\n\t    );\n\n\t    /**\n\t     * Defines a rectangular region.\n\t     */\n\t    var Rect = Class.extend({\n\t        init: function (x, y, width, height) {\n\t            this.x = x || 0;\n\t            this.y = y || 0;\n\t            this.width = width || 0;\n\t            this.height = height || 0;\n\t        },\n\t        contains: function (point) {\n\t            return ((point.x >= this.x) && (point.x <= (this.x + this.width)) && (point.y >= this.y) && (point.y <= (this.y + this.height)));\n\t        },\n\t        inflate: function (dx, dy) {\n\t            if (dy === undefined) {\n\t                dy = dx;\n\t            }\n\n\t            this.x -= dx;\n\t            this.y -= dy;\n\t            this.width += 2 * dx + 1;\n\t            this.height += 2 * dy + 1;\n\t            return this;\n\t        },\n\t        offset: function (dx, dy) {\n\t            var x = dx, y = dy;\n\t            if (dx instanceof Point) {\n\t                x = dx.x;\n\t                y = dx.y;\n\t            }\n\t            this.x += x;\n\t            this.y += y;\n\t            return this;\n\t        },\n\t        union: function (r) {\n\t            var x1 = Math.min(this.x, r.x);\n\t            var y1 = Math.min(this.y, r.y);\n\t            var x2 = Math.max((this.x + this.width), (r.x + r.width));\n\t            var y2 = Math.max((this.y + this.height), (r.y + r.height));\n\t            return new Rect(x1, y1, x2 - x1, y2 - y1);\n\t        },\n\t        center: function () {\n\t            return new Point(this.x + this.width / 2, this.y + this.height / 2);\n\t        },\n\t        top: function () {\n\t            return new Point(this.x + this.width / 2, this.y);\n\t        },\n\t        right: function () {\n\t            return new Point(this.x + this.width, this.y + this.height / 2);\n\t        },\n\t        bottom: function () {\n\t            return new Point(this.x + this.width / 2, this.y + this.height);\n\t        },\n\t        left: function () {\n\t            return new Point(this.x, this.y + this.height / 2);\n\t        },\n\t        topLeft: function () {\n\t            return new Point(this.x, this.y);\n\t        },\n\t        topRight: function () {\n\t            return new Point(this.x + this.width, this.y);\n\t        },\n\t        bottomLeft: function () {\n\t            return new Point(this.x, this.y + this.height);\n\t        },\n\t        bottomRight: function () {\n\t            return new Point(this.x + this.width, this.y + this.height);\n\t        },\n\t        clone: function () {\n\t            return new Rect(this.x, this.y, this.width, this.height);\n\t        },\n\t        isEmpty: function () {\n\t            return !this.width && !this.height;\n\t        },\n\t        equals: function (rect) {\n\t            return this.x === rect.x && this.y === rect.y && this.width === rect.width && this.height === rect.height;\n\t        },\n\t        rotatedBounds: function (angle) {\n\t            var rect = this.clone(),\n\t                points = this.rotatedPoints(angle),\n\t                tl = points[0],\n\t                tr = points[1],\n\t                br = points[2],\n\t                bl = points[3];\n\n\t            rect.x = Math.min(br.x, tl.x, tr.x, bl.x);\n\t            rect.y = Math.min(br.y, tl.y, tr.y, bl.y);\n\t            rect.width = Math.max(br.x, tl.x, tr.x, bl.x) - rect.x;\n\t            rect.height = Math.max(br.y, tl.y, tr.y, bl.y) - rect.y;\n\n\t            return rect;\n\t        },\n\t        rotatedPoints: function (angle) {\n\t            var rect = this,\n\t                c = rect.center(),\n\t                br = rect.bottomRight().rotate(c, 360 - angle),\n\t                tl = rect.topLeft().rotate(c, 360 - angle),\n\t                tr = rect.topRight().rotate(c, 360 - angle),\n\t                bl = rect.bottomLeft().rotate(c, 360 - angle);\n\n\t            return [tl, tr, br, bl];\n\t        },\n\t        toString: function (delimiter) {\n\t            delimiter = delimiter || \" \";\n\n\t            return this.x + delimiter + this.y + delimiter + this.width + delimiter + this.height;\n\t        },\n\t        scale: function (scaleX, scaleY, staicPoint, adornerCenter, angle) {\n\t            var tl = this.topLeft();\n\t            var thisCenter = this.center();\n\t            tl.rotate(thisCenter, 360 - angle).rotate(adornerCenter, angle);\n\n\t            var delta = staicPoint.minus(tl);\n\t            var scaled = new Point(delta.x * scaleX, delta.y * scaleY);\n\t            var position = delta.minus(scaled);\n\t            tl = tl.plus(position);\n\t            tl.rotate(adornerCenter, 360 - angle).rotate(thisCenter, angle);\n\n\t            this.x = tl.x;\n\t            this.y = tl.y;\n\n\t            this.width *= scaleX;\n\t            this.height *= scaleY;\n\t        },\n\n\t        zoom: function(zoom) {\n\t            this.x *= zoom;\n\t            this.y *= zoom;\n\t            this.width *= zoom;\n\t            this.height *= zoom;\n\t            return this;\n\t        },\n\n\t        overlaps: function(rect) {\n\t            var bottomRight = this.bottomRight();\n\t            var rectBottomRight = rect.bottomRight();\n\t            var overlaps = !(bottomRight.x < rect.x || bottomRight.y < rect.y ||\n\t                rectBottomRight.x < this.x || rectBottomRight.y < this.y);\n\t            return overlaps;\n\t        }\n\t    });\n\n\t    var Size = Class.extend({\n\t        init: function (width, height) {\n\t            this.width = width;\n\t            this.height = height;\n\t        }\n\t    });\n\n\t    Size.prototype.Empty = new Size(0, 0);\n\n\t    Rect.toRect = function (rect) {\n\t        if (!(rect instanceof Rect)) {\n\t            rect = new Rect(rect.x, rect.y, rect.width, rect.height);\n\t        }\n\n\t        return rect;\n\t    };\n\n\t    Rect.empty = function () {\n\t        return new Rect(0, 0, 0, 0);\n\t    };\n\n\t    Rect.fromPoints = function (p, q) {\n\t        if (isNaN(p.x) || isNaN(p.y) || isNaN(q.x) || isNaN(q.y)) {\n\t            throw \"Some values are NaN.\";\n\t        }\n\t        return new Rect(Math.min(p.x, q.x), Math.min(p.y, q.y), Math.abs(p.x - q.x), Math.abs(p.y - q.y));\n\t    };\n\n\t    function isNearZero(num) {\n\t        return Math.abs(num) < EPSILON;\n\t    }\n\n\t    function intersectLine(start1, end1, start2, end2, isSegment) {\n\t        var tangensdiff = ((end1.x - start1.x) * (end2.y - start2.y)) - ((end1.y - start1.y) * (end2.x - start2.x));\n\t        if (isNearZero(tangensdiff)) {\n\t            //parallel lines\n\t            return;\n\t        }\n\n\t        var num1 = ((start1.y - start2.y) * (end2.x - start2.x)) - ((start1.x - start2.x) * (end2.y - start2.y));\n\t        var num2 = ((start1.y - start2.y) * (end1.x - start1.x)) - ((start1.x - start2.x) * (end1.y - start1.y));\n\t        var r = num1 / tangensdiff;\n\t        var s = num2 / tangensdiff;\n\n\t        if (isSegment && (r < 0 || r > 1 || s < 0 || s > 1)) {\n\t            //r < 0 => line 1 is below line 2\n\t            //r > 1 => line 1 is above line 2\n\t            //s < 0 => line 2 is below line 1\n\t            //s > 1 => line 2 is above line 1\n\t            return;\n\t        }\n\n\t        return new Point(start1.x + (r * (end1.x - start1.x)), start1.y + (r * (end1.y - start1.y)));\n\t    }\n\n\t    var Intersect = {\n\t        lines: function (start1, end1, start2, end2) {\n\t            return intersectLine(start1, end1, start2, end2);\n\t        },\n\t        segments: function (start1, end1, start2, end2) {\n\t            return intersectLine(start1, end1, start2, end2, true);\n\t        },\n\t        rectWithLine: function (rect, start, end) {\n\t            return  Intersect.segments(start, end, rect.topLeft(), rect.topRight()) ||\n\t                Intersect.segments(start, end, rect.topRight(), rect.bottomRight()) ||\n\t                Intersect.segments(start, end, rect.bottomLeft(), rect.bottomRight()) ||\n\t                Intersect.segments(start, end, rect.topLeft(), rect.bottomLeft());\n\t        },\n\t        rects: function (rect1, rect2, angle) {\n\t            var tl = rect2.topLeft(),\n\t                tr = rect2.topRight(),\n\t                bl = rect2.bottomLeft(),\n\t                br = rect2.bottomRight();\n\t            var center = rect2.center();\n\t            if (angle) {\n\t                tl = tl.rotate(center, angle);\n\t                tr = tr.rotate(center, angle);\n\t                bl = bl.rotate(center, angle);\n\t                br = br.rotate(center, angle);\n\t            }\n\n\t            var intersect = rect1.contains(tl) ||\n\t                rect1.contains(tr) ||\n\t                rect1.contains(bl) ||\n\t                rect1.contains(br) ||\n\t                Intersect.rectWithLine(rect1, tl, tr) ||\n\t                Intersect.rectWithLine(rect1, tl, bl) ||\n\t                Intersect.rectWithLine(rect1, tr, br) ||\n\t                Intersect.rectWithLine(rect1, bl, br);\n\n\t            if (!intersect) {//last possible case is rect1 to be completely within rect2\n\t                tl = rect1.topLeft();\n\t                tr = rect1.topRight();\n\t                bl = rect1.bottomLeft();\n\t                br = rect1.bottomRight();\n\n\t                if (angle) {\n\t                    var reverseAngle = 360 - angle;\n\t                    tl = tl.rotate(center, reverseAngle);\n\t                    tr = tr.rotate(center, reverseAngle);\n\t                    bl = bl.rotate(center, reverseAngle);\n\t                    br = br.rotate(center, reverseAngle);\n\t                }\n\n\t                intersect = rect2.contains(tl) ||\n\t                    rect2.contains(tr) ||\n\t                    rect2.contains(bl) ||\n\t                    rect2.contains(br);\n\t            }\n\n\t            return intersect;\n\t        }\n\t    };\n\n\t    /**\n\t     * Aligns two rectangles, where one is the container and the other is content.\n\t     */\n\t    var RectAlign = Class.extend({\n\t        init: function (container) {\n\t            this.container = Rect.toRect(container);\n\t        },\n\n\t        align: function (content, alignment) {\n\t            var alignValues = alignment.toLowerCase().split(\" \");\n\n\t            for (var i = 0; i < alignValues.length; i++) {\n\t                content = this._singleAlign(content, alignValues[i]);\n\t            }\n\n\t            return content;\n\t        },\n\t        _singleAlign: function (content, alignment) {\n\t            if (isFunction(this[alignment])) {\n\t                return this[alignment](content);\n\t            }\n\t            else {\n\t                return content;\n\t            }\n\t        },\n\n\t        left: function (content) {\n\t            return this._align(content, this._left);\n\t        },\n\t        center: function (content) {\n\t            return this._align(content, this._center);\n\t        },\n\t        right: function (content) {\n\t            return this._align(content, this._right);\n\t        },\n\t        stretch: function (content) {\n\t            return this._align(content, this._stretch);\n\t        },\n\t        top: function (content) {\n\t            return this._align(content, this._top);\n\t        },\n\t        middle: function (content) {\n\t            return this._align(content, this._middle);\n\t        },\n\t        bottom: function (content) {\n\t            return this._align(content, this._bottom);\n\t        },\n\n\t        _left: function (container, content) {\n\t            content.x = container.x;\n\t        },\n\t        _center: function (container, content) {\n\t            content.x = ((container.width - content.width) / 2) || 0;\n\t        },\n\t        _right: function (container, content) {\n\t            content.x = container.width - content.width;\n\t        },\n\t        _top: function (container, content) {\n\t            content.y = container.y;\n\t        },\n\t        _middle: function (container, content) {\n\t            content.y = ((container.height - content.height) / 2) || 0;\n\t        },\n\t        _bottom: function (container, content) {\n\t            content.y = container.height - content.height;\n\t        },\n\t        _stretch: function (container, content) {\n\t            content.x = 0;\n\t            content.y = 0;\n\t            content.height = container.height;\n\t            content.width = container.width;\n\t        },\n\t        _align: function (content, alignCalc) {\n\t            content = Rect.toRect(content);\n\t            alignCalc(this.container, content);\n\n\t            return content;\n\t        }\n\t    });\n\n\t    var Polar = Class.extend({\n\t        init: function (r, a) {\n\t            this.r = r;\n\t            this.angle = a;\n\t        }\n\t    });\n\n\t    /**\n\t     * SVG transformation matrix.\n\t     */\n\t    var Matrix = Class.extend({\n\t        init: function (a, b, c, d, e, f) {\n\t            this.a = a || 0;\n\t            this.b = b || 0;\n\t            this.c = c || 0;\n\t            this.d = d || 0;\n\t            this.e = e || 0;\n\t            this.f = f || 0;\n\t        },\n\t        plus: function (m) {\n\t            this.a += m.a;\n\t            this.b += m.b;\n\t            this.c += m.c;\n\t            this.d += m.d;\n\t            this.e += m.e;\n\t            this.f += m.f;\n\t        },\n\t        minus: function (m) {\n\t            this.a -= m.a;\n\t            this.b -= m.b;\n\t            this.c -= m.c;\n\t            this.d -= m.d;\n\t            this.e -= m.e;\n\t            this.f -= m.f;\n\t        },\n\t        times: function (m) {\n\t            return new Matrix(\n\t                this.a * m.a + this.c * m.b,\n\t                this.b * m.a + this.d * m.b,\n\t                this.a * m.c + this.c * m.d,\n\t                this.b * m.c + this.d * m.d,\n\t                this.a * m.e + this.c * m.f + this.e,\n\t                this.b * m.e + this.d * m.f + this.f\n\t            );\n\t        },\n\t        apply: function (p) {\n\t            return new Point(this.a * p.x + this.c * p.y + this.e, this.b * p.x + this.d * p.y + this.f);\n\t        },\n\t        applyRect: function (r) {\n\t            return Rect.fromPoints(this.apply(r.topLeft()), this.apply(r.bottomRight()));\n\t        },\n\t        toString: function () {\n\t            return \"matrix(\" + this.a + \" \" + this.b + \" \" + this.c + \" \" + this.d + \" \" + this.e + \" \" + this.f + \")\";\n\t        }\n\t    });\n\n\t    deepExtend(Matrix, {\n\t        fromSVGMatrix: function (vm) {\n\t            var m = new Matrix();\n\t            m.a = vm.a;\n\t            m.b = vm.b;\n\t            m.c = vm.c;\n\t            m.d = vm.d;\n\t            m.e = vm.e;\n\t            m.f = vm.f;\n\t            return m;\n\t        },\n\t        fromMatrixVector: function (v) {\n\t            var m = new Matrix();\n\t            m.a = v.a;\n\t            m.b = v.b;\n\t            m.c = v.c;\n\t            m.d = v.d;\n\t            m.e = v.e;\n\t            m.f = v.f;\n\t            return m;\n\t        },\n\t        fromList: function (v) {\n\t            if (v.length !== 6) {\n\t                throw \"The given list should consist of six elements.\";\n\t            }\n\t            var m = new Matrix();\n\t            m.a = v[0];\n\t            m.b = v[1];\n\t            m.c = v[2];\n\t            m.d = v[3];\n\t            m.e = v[4];\n\t            m.f = v[5];\n\t            return m;\n\t        },\n\t        translation: function (x, y) {\n\t            var m = new Matrix();\n\t            m.a = 1;\n\t            m.b = 0;\n\t            m.c = 0;\n\t            m.d = 1;\n\t            m.e = x;\n\t            m.f = y;\n\t            return m;\n\t        },\n\t        unit: function () {\n\t            return new Matrix(1, 0, 0, 1, 0, 0);\n\t        },\n\t        rotation: function (angle, x, y) {\n\t            var m = new Matrix();\n\t            m.a = Math.cos(angle * Math.PI / 180);\n\t            m.b = Math.sin(angle * Math.PI / 180);\n\t            m.c = -m.b;\n\t            m.d = m.a;\n\t            m.e = (x - x * m.a + y * m.b) || 0;\n\t            m.f = (y - y * m.a - x * m.b) || 0;\n\t            return m;\n\t        },\n\t        scaling: function (scaleX, scaleY) {\n\t            var m = new Matrix();\n\t            m.a = scaleX;\n\t            m.b = 0;\n\t            m.c = 0;\n\t            m.d = scaleY;\n\t            m.e = 0;\n\t            m.f = 0;\n\t            return m;\n\t        },\n\t        parse: function (v) {\n\t            var parts, nums;\n\t            if (v) {\n\t                v = v.trim();\n\t                // of the form \"matrix(...)\"\n\t                if (v.slice(0, 6).toLowerCase() === \"matrix\") {\n\t                    nums = v.slice(7, v.length - 1).trim();\n\t                    parts = nums.split(\",\");\n\t                    if (parts.length === 6) {\n\t                        return Matrix.fromList(map(parts, function (p) {\n\t                            return parseFloat(p);\n\t                        }));\n\t                    }\n\t                    parts = nums.split(\" \");\n\t                    if (parts.length === 6) {\n\t                        return Matrix.fromList(map(parts, function (p) {\n\t                            return parseFloat(p);\n\t                        }));\n\t                    }\n\t                }\n\t                // of the form \"(...)\"\n\t                if (v.slice(0, 1) === \"(\" && v.slice(v.length - 1) === \")\") {\n\t                    v = v.substr(1, v.length - 1);\n\t                }\n\t                if (v.indexOf(\",\") > 0) {\n\t                    parts = v.split(\",\");\n\t                    if (parts.length === 6) {\n\t                        return Matrix.fromList(map(parts, function (p) {\n\t                            return parseFloat(p);\n\t                        }));\n\t                    }\n\t                }\n\t                if (v.indexOf(\" \") > 0) {\n\t                    parts = v.split(\" \");\n\t                    if (parts.length === 6) {\n\t                        return Matrix.fromList(map(parts, function (p) {\n\t                            return parseFloat(p);\n\t                        }));\n\t                    }\n\t                }\n\t            }\n\t            return parts;\n\t        }\n\t    });\n\n\t    /**\n\t     * SVG transformation represented as a vector.\n\t     */\n\t    var MatrixVector = Class.extend({\n\t        init: function (a, b, c, d, e, f) {\n\t            this.a = a || 0;\n\t            this.b = b || 0;\n\t            this.c = c || 0;\n\t            this.d = d || 0;\n\t            this.e = e || 0;\n\t            this.f = f || 0;\n\t        },\n\t        fromMatrix: function FromMatrix(m) {\n\t            var v = new MatrixVector();\n\t            v.a = m.a;\n\t            v.b = m.b;\n\t            v.c = m.c;\n\t            v.d = m.d;\n\t            v.e = m.e;\n\t            v.f = m.f;\n\t            return v;\n\t        }\n\t    });\n\n\t    /**\n\t     * Returns a value with Gaussian (normal) distribution.\n\t     * @param mean The mean value of the distribution.\n\t     * @param deviation The deviation (spreading at half-height) of the distribution.\n\t     * @returns {number}\n\t     */\n\t    function normalVariable(mean, deviation) {\n\t        var x, y, r;\n\t        do {\n\t            x = Math.random() * 2 - 1;\n\t            y = Math.random() * 2 - 1;\n\t            r = x * x + y * y;\n\t        }\n\t        while (!r || r > 1);\n\t        return mean + deviation * x * Math.sqrt(-2 * Math.log(r) / r);\n\t    }\n\n\t    /**\n\t     * Returns a random identifier which can be used as an ID of objects, eventually augmented with a prefix.\n\t     * @returns {string}\n\t     */\n\t    function randomId(length) {\n\t        if (Utils.isUndefined(length)) {\n\t            length = 10;\n\t        }\n\t        // old version return Math.floor((1 + Math.random()) * 0x1000000).toString(16).substring(1);\n\t        var result = '';\n\t        var chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n\t        for (var i = length; i > 0; --i) {\n\t            result += chars.charAt(Math.round(Math.random() * (chars.length - 1)));\n\t        }\n\t        return result;\n\t    }\n\n\t    var Geometry = {\n\n\t        /**\n\t         * Returns the squared distance to the line defined by the two given Points.\n\t         * @param p An arbitrary Point.\n\t         * @param a An endpoint of the line or segment.\n\t         * @param b The complementary endpoint of the line or segment.\n\t         */\n\t        _distanceToLineSquared: function (p, a, b) {\n\t            function d2(pt1, pt2) {\n\t                return (pt1.x - pt2.x) * (pt1.x - pt2.x) + (pt1.y - pt2.y) * (pt1.y - pt2.y);\n\t            }\n\n\t            if (a === b) { // returns the distance of p to a\n\t                return d2(p, a);\n\t            }\n\n\t            var vx = b.x - a.x,\n\t                vy = b.y - a.y,\n\t                dot = (p.x - a.x) * vx + (p.y - a.y) * vy;\n\t            if (dot < 0) {\n\t                return d2(a, p); // sits on side of a\n\t            }\n\n\t            dot = (b.x - p.x) * vx + (b.y - p.y) * vy;\n\t            if (dot < 0) {\n\t                return d2(b, p); // sits on side of b\n\t            }\n\t            // regular case, use crossproduct to get the sine out\n\t            dot = (b.x - p.x) * vy - (b.y - p.y) * vx;\n\t            return dot * dot / (vx * vx + vy * vy);\n\t        },\n\n\t        /**\n\t         * Returns the distance to the line defined by the two given Points.\n\t         * @param p An arbitrary Point.\n\t         * @param a An endpoint of the line or segment.\n\t         * @param b The complementary endpoint of the line or segment.\n\t         */\n\t        distanceToLine: function (p, a, b) {\n\t            return Math.sqrt(this._distanceToLineSquared(p, a, b));\n\t        },\n\n\t        /**\n\t         * Returns the distance of the given points to the polyline defined by the points.\n\t         * @param p An arbitrary point.\n\t         * @param points The points defining the polyline.\n\t         * @returns {Number}\n\t         */\n\t        distanceToPolyline: function (p, points) {\n\t            var minimum = Number.MAX_VALUE;\n\t            if (Utils.isUndefined(points) || points.length === 0) {\n\t                return Number.MAX_VALUE;\n\t            }\n\t            for (var s = 0; s < points.length - 1; s++) {\n\t                var p1 = points[s];\n\t                var p2 = points[s + 1];\n\n\t                var d = this._distanceToLineSquared(p, p1, p2);\n\t                if (d < minimum) {\n\t                    minimum = d;\n\t                }\n\t            }\n\t            return Math.sqrt(minimum);\n\t        }\n\t    };\n\n\t    /*---------------The HashTable structure--------------------------------*/\n\n\t    /**\n\t     * Represents a collection of key-value pairs that are organized based on the hash code of the key.\n\t     * _buckets[hashId] = {key: key, value:...}\n\t     * Important: do not use the standard Array access method, use the get/set methods instead.\n\t     * See http://en.wikipedia.org/wiki/Hash_table\n\t     */\n\t    var HashTable = kendo.Class.extend({\n\t        init: function () {\n\t            this._buckets = [];\n\t            this.length = 0;\n\t        },\n\n\t        /**\n\t         * Adds the literal object with the given key (of the form {key: key,....}).\n\t         */\n\t        add: function (key, value) {\n\n\t            var obj = this._createGetBucket(key);\n\t            if (Utils.isDefined(value)) {\n\t                obj.value = value;\n\t            }\n\t            return obj;\n\t        },\n\n\t        /**\n\t         * Gets the literal object with the given key.\n\t         */\n\t        get: function (key) {\n\t            if (this._bucketExists(key)) {\n\t                return this._createGetBucket(key);\n\t            }\n\t            return null;\n\t        },\n\n\t        /**\n\t         * Set the key-value pair.\n\t         * @param key The key of the entry.\n\t         * @param value The value to set. If the key already exists the value will be overwritten.\n\t         */\n\t        set: function (key, value) {\n\t            this.add(key, value);\n\t        },\n\n\t        /**\n\t         * Determines whether the HashTable contains a specific key.\n\t         */\n\t        containsKey: function (key) {\n\t            return this._bucketExists(key);\n\t        },\n\n\t        /**\n\t         * Removes the element with the specified key from the hashtable.\n\t         * Returns the removed bucket.\n\t         */\n\t        remove: function (key) {\n\t            if (this._bucketExists(key)) {\n\t                var hashId = this._hash(key);\n\t                delete this._buckets[hashId];\n\t                this.length--;\n\t                return key;\n\t            }\n\t        },\n\n\t        /**\n\t         * Foreach with an iterator working on the key-value pairs.\n\t         * @param func\n\t         */\n\t        forEach: function (func) {\n\t            var hashes = this._hashes();\n\t            for (var i = 0, len = hashes.length; i < len; i++) {\n\t                var hash = hashes[i];\n\t                var bucket = this._buckets[hash];\n\t                if (Utils.isUndefined(bucket)) {\n\t                    continue;\n\t                }\n\t                func(bucket);\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns a (shallow) clone of the current HashTable.\n\t         * @returns {HashTable}\n\t         */\n\t        clone: function () {\n\t            var ht = new HashTable();\n\t            var hashes = this._hashes();\n\t            for (var i = 0, len = hashes.length; i < len; i++) {\n\t                var hash = hashes[i];\n\t                var bucket = this._buckets[hash];\n\t                if (Utils.isUndefined(bucket)) {\n\t                    continue;\n\t                }\n\t                ht.add(bucket.key, bucket.value);\n\t            }\n\t            return ht;\n\t        },\n\n\t        /**\n\t         * Returns the hashes of the buckets.\n\t         * @returns {Array}\n\t         * @private\n\t         */\n\t        _hashes: function () {\n\t            var hashes = [];\n\t            for (var hash in this._buckets) {\n\t                if (this._buckets.hasOwnProperty(hash)) {\n\t                    hashes.push(hash);\n\t                }\n\t            }\n\t            return hashes;\n\t        },\n\n\t        _bucketExists: function (key) {\n\t            var hashId = this._hash(key);\n\t            return Utils.isDefined(this._buckets[hashId]);\n\t        },\n\n\t        /**\n\t         * Returns-adds the createGetBucket with the given key. If not present it will\n\t         * be created and returned.\n\t         * A createGetBucket is a literal object of the form {key: key, ...}.\n\t         */\n\t        _createGetBucket: function (key) {\n\t            var hashId = this._hash(key);\n\t            var bucket = this._buckets[hashId];\n\t            if (Utils.isUndefined(bucket)) {\n\t                bucket = { key: key };\n\t                this._buckets[hashId] = bucket;\n\t                this.length++;\n\t            }\n\t            return bucket;\n\t        },\n\n\t        /**\n\t         * Hashing of the given key.\n\t         */\n\t        _hash: function (key) {\n\t            if (Utils.isNumber(key)) {\n\t                return key;\n\t            }\n\t            if (Utils.isString(key)) {\n\t                return this._hashString(key);\n\t            }\n\t            if (Utils.isObject(key)) {\n\t                return this._objectHashId(key);\n\t            }\n\t            throw \"Unsupported key type.\";\n\t        },\n\n\t        /**\n\t         * Hashing of a string.\n\t         */\n\t        _hashString: function (s) {\n\t            // see for example http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery\n\t            var result = 0;\n\t            if (s.length === 0) {\n\t                return result;\n\t            }\n\t            for (var i = 0; i < s.length; i++) {\n\t                var ch = s.charCodeAt(i);\n\t                result = ((result * 32) - result) + ch;\n\t            }\n\t            return result;\n\t        },\n\n\t        /**\n\t         * Returns the unique identifier for an object. This is automatically assigned and add on the object.\n\t         */\n\t        _objectHashId: function (key) {\n\t            var id = key._hashId;\n\t            if (Utils.isUndefined(id)) {\n\t                id = randomId();\n\t                key._hashId = id;\n\t            }\n\t            return id;\n\t        }\n\t    });\n\n\t    /*---------------The Dictionary structure--------------------------------*/\n\n\t    /**\n\t     * Represents a collection of key-value pairs.\n\t     * Important: do not use the standard Array access method, use the get/Set methods instead.\n\t     */\n\t    var Dictionary = kendo.Observable.extend({\n\t        /**\n\t         * Initializes a new instance of the Dictionary class.\n\t         * @param dictionary Loads the content of the given dictionary into this new one.\n\t         */\n\t        init: function (dictionary) {\n\t            var that = this;\n\t            kendo.Observable.fn.init.call(that);\n\t            this._hashTable = new HashTable();\n\t            this.length = 0;\n\t            if (Utils.isDefined(dictionary)) {\n\t                if (Array.isArray(dictionary)) {\n\t                    for (var i = 0; i < dictionary.length; i++) {\n\t                        this.add(dictionary[i]);\n\t                    }\n\t                } else {\n\t                    dictionary.forEach(function (k, v) {\n\t                        this.add(k, v);\n\t                    }, this);\n\t                }\n\t            }\n\t        },\n\n\t        /**\n\t         * Adds a key-value to the dictionary.\n\t         * If the key already exists this will assign the given value to the existing entry.\n\t         */\n\t        add: function (key, value) {\n\t            var entry = this._hashTable.get(key);\n\t            if (!entry) {\n\t                entry = this._hashTable.add(key);\n\t                this.length++;\n\t                this.trigger('changed');\n\t            }\n\t            entry.value = value;\n\t        },\n\n\t        /**\n\t         * Set the key-value pair.\n\t         * @param key The key of the entry.\n\t         * @param value The value to set. If the key already exists the value will be overwritten.\n\t         */\n\t        set: function (key, value) {\n\t            this.add(key, value);\n\t        },\n\n\t        /**\n\t         * Gets the value associated with the given key in the dictionary.\n\t         */\n\t        get: function (key) {\n\t            var entry = this._hashTable.get(key);\n\t            if (entry) {\n\t                return entry.value;\n\t            }\n\t            throw new Error(\"Cannot find key \" + key);\n\t        },\n\n\t        /**\n\t         * Returns whether the dictionary contains the given key.\n\t         */\n\t        containsKey: function (key) {\n\t            return this._hashTable.containsKey(key);\n\t        },\n\n\t        /**\n\t         * Removes the element with the specified key from the dictionary.\n\t         */\n\t        remove: function (key) {\n\t            if (this.containsKey(key)) {\n\t                this.trigger(\"changed\");\n\t                this.length--;\n\t                return this._hashTable.remove(key);\n\t            }\n\t        },\n\n\t        /**\n\t         * The functional gets the key and value as parameters.\n\t         */\n\t        forEach: function (func, thisRef) {\n\t            this._hashTable.forEach(function (entry) {\n\t                func.call(thisRef, entry.key, entry.value);\n\t            });\n\t        },\n\n\t        /**\n\t         * Same as forEach except that only the value is passed to the functional.\n\t         */\n\t        forEachValue: function (func, thisRef) {\n\t            this._hashTable.forEach(function (entry) {\n\t                func.call(thisRef, entry.value);\n\t            });\n\t        },\n\n\t        /**\n\t         * Calls a defined callback function for each key in the dictionary.\n\t         */\n\t        forEachKey: function (func, thisRef) {\n\t            this._hashTable.forEach(function (entry) {\n\t                func.call(thisRef, entry.key);\n\t            });\n\t        },\n\n\t        /**\n\t         * Gets an array with all keys in the dictionary.\n\t         */\n\t        keys: function () {\n\t            var keys = [];\n\t            this.forEachKey(function (key) {\n\t                keys.push(key);\n\t            });\n\t            return keys;\n\t        }\n\t    });\n\n\t    /*---------------Queue structure--------------------------------*/\n\n\t    var Queue = kendo.Class.extend({\n\n\t        init: function () {\n\t            this._tail = null;\n\t            this._head = null;\n\t            this.length = 0;\n\t        },\n\n\t        /**\n\t         * Enqueues an object to the end of the queue.\n\t         */\n\t        enqueue: function (value) {\n\t            var entry = { value: value, next: null };\n\t            if (!this._head) {\n\t                this._head = entry;\n\t                this._tail = this._head;\n\t            }\n\t            else {\n\t                this._tail.next = entry;\n\t                this._tail = this._tail.next;\n\t            }\n\t            this.length++;\n\t        },\n\n\t        /**\n\t         * Removes and returns the object at top of the queue.\n\t         */\n\t        dequeue: function () {\n\t            if (this.length < 1) {\n\t                throw new Error(\"The queue is empty.\");\n\t            }\n\t            var value = this._head.value;\n\t            this._head = this._head.next;\n\t            this.length--;\n\t            return value;\n\t        },\n\n\t        contains: function (item) {\n\t            var current = this._head;\n\t            while (current) {\n\t                if (current.value === item) {\n\t                    return true;\n\t                }\n\t                current = current.next;\n\t            }\n\t            return false;\n\t        }\n\t    });\n\n\n\t    /**\n\t     * While other data structures can have multiple times the same item a Set owns only\n\t     * once a particular item.\n\t     * @type {*}\n\t     */\n\t    var Set = kendo.Observable.extend({\n\t        init: function (resource) {\n\t            var that = this;\n\t            kendo.Observable.fn.init.call(that);\n\t            this._hashTable = new HashTable();\n\t            this.length = 0;\n\t            if (Utils.isDefined(resource)) {\n\t                if (resource instanceof HashTable) {\n\t                    resource.forEach(function (d) {\n\t                        this.add(d);\n\t                    });\n\t                }\n\t                else if (resource instanceof Dictionary) {\n\t                    resource.forEach(function (k, v) {\n\t                        this.add({key: k, value: v});\n\t                    }, this);\n\t                }\n\t            }\n\t        },\n\n\t        contains: function (item) {\n\t            return this._hashTable.containsKey(item);\n\t        },\n\n\t        add: function (item) {\n\t            var entry = this._hashTable.get(item);\n\t            if (!entry) {\n\t                this._hashTable.add(item, item);\n\t                this.length++;\n\t                this.trigger('changed');\n\t            }\n\t        },\n\n\t        get: function (item) {\n\t            if (this.contains(item)) {\n\t                return this._hashTable.get(item).value;\n\t            }\n\t            else {\n\t                return null;\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns the hash of the item.\n\t         * @param item\n\t         * @returns {*}\n\t         */\n\t        hash: function (item) {\n\t            return this._hashTable._hash(item);\n\t        },\n\n\t        /**\n\t         * Removes the given item from the set. No exception is thrown if the item is not in the Set.\n\t         * @param item\n\t         */\n\t        remove: function (item) {\n\t            if (this.contains(item)) {\n\t                this._hashTable.remove(item);\n\t                this.length--;\n\t                this.trigger('changed');\n\t            }\n\t        },\n\t        /**\n\t         * Foreach with an iterator working on the key-value pairs.\n\t         * @param func\n\t         */\n\t        forEach: function (func, context) {\n\t            this._hashTable.forEach(function (kv) {\n\t                func(kv.value);\n\t            }, context);\n\t        },\n\t        toArray: function () {\n\t            var r = [];\n\t            this.forEach(function (d) {\n\t                r.push(d);\n\t            });\n\t            return r;\n\t        }\n\t    });\n\n\t    /*----------------Node-------------------------------*/\n\n\t    /**\n\t     * Defines the node (vertex) of a Graph.\n\t     */\n\t    var Node = kendo.Class.extend({\n\n\t        init: function (id, shape) {\n\n\t            /**\n\t             * Holds all the links incident with the current node.\n\t             * Do not use this property to manage the incoming links, use the appropriate add/remove methods instead.\n\t             */\n\t            this.links = [];\n\n\t            /**\n\t             * Holds the links from the current one to another Node .\n\t             * Do not use this property to manage the incoming links, use the appropriate add/remove methods instead.\n\t             */\n\t            this.outgoing = [];\n\n\t            /**\n\t             * Holds the links from another Node to the current one.\n\t             * Do not use this property to manage the incoming links, use the appropriate add/remove methods instead.\n\t             */\n\t            this.incoming = [];\n\n\t            /**\n\t             * Holds the weight of this Node.\n\t             */\n\t            this.weight = 1;\n\n\t            if (Utils.isDefined(id)) {\n\t                this.id = id;\n\t            }\n\t            else {\n\t                this.id = randomId();\n\t            }\n\t            if (Utils.isDefined(shape)) {\n\t                this.associatedShape = shape;\n\t                // transfer the shape's bounds to the runtime props\n\t                var b = shape.bounds();\n\t                this.width = b.width;\n\t                this.height = b.height;\n\t                this.x = b.x;\n\t                this.y = b.y;\n\t            }\n\t            else {\n\t                this.associatedShape = null;\n\t            }\n\t            /**\n\t             * The payload of the node.\n\t             * @type {null}\n\t             */\n\t            this.data = null;\n\t            this.type = \"Node\";\n\t            this.shortForm = \"Node '\" + this.id + \"'\";\n\t            /**\n\t             * Whether this is an injected node during the analysis or layout process.\n\t             * @type {boolean}\n\t             */\n\t            this.isVirtual = false;\n\t        },\n\n\t        /**\n\t         * Returns whether this node has no links attached.\n\t         */\n\t        isIsolated: function () {\n\t            return Utils.isEmpty(this.links);\n\t        },\n\n\t        /**\n\t         * Gets or sets the bounding rectangle of this node.\n\t         * This should be considered as runtime data, the property is not hotlinked to a SVG item.\n\t         */\n\t        bounds: function (r) {\n\t            if (!Utils.isDefined(r)) {\n\t                return new diagram.Rect(this.x, this.y, this.width, this.height);\n\t            }\n\n\t            this.x = r.x;\n\t            this.y = r.y;\n\t            this.width = r.width;\n\t            this.height = r.height;\n\t        },\n\n\t        /**\n\t         * Returns whether there is at least one link with the given (complementary) node. This can be either an\n\t         * incoming or outgoing link.\n\t         */\n\t        isLinkedTo: function (node) {\n\t            var that = this;\n\t            return Utils.any(that.links, function (link) {\n\t                return link.getComplement(that) === node;\n\t            });\n\t        },\n\n\t        /**\n\t         * Gets the children of this node, defined as the adjacent nodes with a link from this node to the adjacent one.\n\t         * @returns {Array}\n\t         */\n\t        getChildren: function () {\n\t            if (this.outgoing.length === 0) {\n\t                return [];\n\t            }\n\t            var children = [];\n\t            for (var i = 0, len = this.outgoing.length; i < len; i++) {\n\t                var link = this.outgoing[i];\n\t                children.push(link.getComplement(this));\n\t            }\n\t            return children;\n\t        },\n\n\t        /**\n\t         * Gets the parents of this node, defined as the adjacent nodes with a link from the adjacent node to this one.\n\t         * @returns {Array}\n\t         */\n\t        getParents: function () {\n\t            if (this.incoming.length === 0) {\n\t                return [];\n\t            }\n\t            var parents = [];\n\t            for (var i = 0, len = this.incoming.length; i < len; i++) {\n\t                var link = this.incoming[i];\n\t                parents.push(link.getComplement(this));\n\t            }\n\t            return parents;\n\t        },\n\n\t        /**\n\t         * Returns a clone of the Node. Note that the identifier is not cloned since it's a different Node instance.\n\t         * @returns {Node}\n\t         */\n\t        clone: function () {\n\t            var copy = new Node();\n\t            if (Utils.isDefined(this.weight)) {\n\t                copy.weight = this.weight;\n\t            }\n\t            if (Utils.isDefined(this.balance)) {\n\t                copy.balance = this.balance;\n\t            }\n\t            if (Utils.isDefined(this.owner)) {\n\t                copy.owner = this.owner;\n\t            }\n\t            copy.associatedShape = this.associatedShape;\n\t            copy.x = this.x;\n\t            copy.y = this.y;\n\t            copy.width = this.width;\n\t            copy.height = this.height;\n\t            return copy;\n\t        },\n\n\t        /**\n\t         * Returns whether there is a link from the current node to the given node.\n\t         */\n\t        adjacentTo: function (node) {\n\t            return this.isLinkedTo(node) !== null;\n\t        },\n\n\t        /**\n\t         * Removes the given link from the link collection this node owns.\n\t         * @param link\n\t         */\n\t        removeLink: function (link) {\n\t            if (link.source === this) {\n\t                Utils.remove(this.links, link);\n\t                Utils.remove(this.outgoing, link);\n\t                link.source = null;\n\t            }\n\n\t            if (link.target === this) {\n\t                Utils.remove(this.links, link);\n\t                Utils.remove(this.incoming, link);\n\t                link.target = null;\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns whether there is a (outgoing) link from the current node to the given one.\n\t         */\n\t        hasLinkTo: function (node) {\n\t            return Utils.any(this.outgoing, function (link) {\n\t                return link.target === node;\n\t            });\n\t        },\n\n\t        /**\n\t         * Returns the degree of this node, i.e. the sum of incoming and outgoing links.\n\t         */\n\t        degree: function () {\n\t            return this.links.length;\n\t        },\n\n\t        /**\n\t         * Returns whether this node is either the source or the target of the given link.\n\t         */\n\t        incidentWith: function (link) {\n\t            return contains(this.links, link);\n\t        },\n\n\t        /**\n\t         * Returns the links between this node and the given one.\n\t         */\n\t        getLinksWith: function (node) {\n\t            return Utils.all(this.links, function (link) {\n\t                return link.getComplement(this) === node;\n\t            }, this);\n\t        },\n\n\t        /**\n\t         * Returns the nodes (either parent or child) which are linked to the current one.\n\t         */\n\t        getNeighbors: function () {\n\t            var neighbors = [];\n\t            Utils.forEach(this.incoming, function (e) {\n\t                neighbors.push(e.getComplement(this));\n\t            }, this);\n\t            Utils.forEach(this.outgoing, function (e) {\n\t                neighbors.push(e.getComplement(this));\n\t            }, this);\n\t            return neighbors;\n\t        }\n\t    });\n\n\t    /**\n\t     * Defines a directed link (edge, connection) of a Graph.\n\t     */\n\t    var Link = kendo.Class.extend({\n\n\t        init: function (source, target, id, connection) {\n\t            if (Utils.isUndefined(source)) {\n\t                throw \"The source of the new link is not set.\";\n\t            }\n\t            if (Utils.isUndefined(target)) {\n\t                throw \"The target of the new link is not set.\";\n\t            }\n\t            var sourceFound, targetFound;\n\t            if (Utils.isString(source)) {\n\t                sourceFound = new Node(source);\n\t            }\n\t            else {\n\t                sourceFound = source;\n\t            }\n\t            if (Utils.isString(target)) {\n\t                targetFound = new Node(target);\n\t            }\n\t            else {\n\t                targetFound = target;\n\t            }\n\n\t            this.source = sourceFound;\n\t            this.target = targetFound;\n\t            this.source.links.push(this);\n\t            this.target.links.push(this);\n\t            this.source.outgoing.push(this);\n\t            this.target.incoming.push(this);\n\t            if (Utils.isDefined(id)) {\n\t                this.id = id;\n\t            }\n\t            else {\n\t                this.id = randomId();\n\t            }\n\t            if (Utils.isDefined(connection)) {\n\t                this.associatedConnection = connection;\n\t            }\n\t            else {\n\t                this.associatedConnection = null;\n\t            }\n\t            this.type = \"Link\";\n\t            this.shortForm = \"Link '\" + this.source.id + \"->\" + this.target.id + \"'\";\n\t        },\n\n\t        /**\n\t         * Returns the complementary node of the given one, if any.\n\t         */\n\t        getComplement: function (node) {\n\t            if (this.source !== node && this.target !== node) {\n\t                throw \"The given node is not incident with this link.\";\n\t            }\n\t            return this.source === node ? this.target : this.source;\n\t        },\n\n\t        /**\n\t         * Returns the overlap of the current link with the given one, if any.\n\t         */\n\t        getCommonNode: function (link) {\n\t            if (this.source === link.source || this.source === link.target) {\n\t                return this.source;\n\t            }\n\t            if (this.target === link.source || this.target === link.target) {\n\t                return this.target;\n\t            }\n\t            return null;\n\t        },\n\n\t        /**\n\t         * Returns whether the current link is bridging the given nodes.\n\t         */\n\t        isBridging: function (v1, v2) {\n\t            return this.source === v1 && this.target === v2 || this.source === v2 && this.target === v1;\n\t        },\n\n\t        /**\n\t         * Returns the source and target of this link as a tuple.\n\t         */\n\t        getNodes: function () {\n\t            return [this.source, this.target];\n\t        },\n\n\t        /**\n\t         * Returns whether the given node is either the source or the target of the current link.\n\t         */\n\t        incidentWith: function (node) {\n\t            return this.source === node || this.target === node;\n\t        },\n\n\t        /**\n\t         * Returns whether the given link is a continuation of the current one. This can be both\n\t         * via an incoming or outgoing link.\n\t         */\n\t        adjacentTo: function (link) {\n\t            return contains(this.source.links, link) || contains(this.target.links, link);\n\t        },\n\n\t        /**\n\t         * Changes the source-node of this link.\n\t         */\n\t        changeSource: function (node) {\n\t            Utils.remove(this.source.links, this);\n\t            Utils.remove(this.source.outgoing, this);\n\n\t            node.links.push(this);\n\t            node.outgoing.push(this);\n\n\t            this.source = node;\n\t        },\n\n\t        /**\n\t         * Changes the target-node of this link.\n\t         * @param node\n\t         */\n\t        changeTarget: function (node) {\n\t            Utils.remove(this.target.links, this);\n\t            Utils.remove(this.target.incoming, this);\n\n\t            node.links.push(this);\n\t            node.incoming.push(this);\n\n\t            this.target = node;\n\t        },\n\n\t        /**\n\t         * Changes both the source and the target nodes of this link.\n\t         */\n\t        changesNodes: function (v, w) {\n\t            if (this.source === v) {\n\t                this.changeSource(w);\n\t            }\n\t            else if (this.target === v) {\n\t                this.changeTarget(w);\n\t            }\n\t        },\n\n\t        /**\n\t         * Reverses the direction of this link.\n\t         */\n\t        reverse: function () {\n\t            var oldSource = this.source;\n\t            var oldTarget = this.target;\n\n\t            this.source = oldTarget;\n\t            Utils.remove(oldSource.outgoing, this);\n\t            this.source.outgoing.push(this);\n\n\t            this.target = oldSource;\n\t            Utils.remove(oldTarget.incoming, this);\n\t            this.target.incoming.push(this);\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Ensures that the given target defines the endpoint of this link.\n\t         */\n\t        directTo: function (target) {\n\t            if (this.source !== target && this.target !== target) {\n\t                throw \"The given node is not incident with this link.\";\n\t            }\n\t            if (this.target !== target) {\n\t                this.reverse();\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns a reversed clone of this link.\n\t         */\n\t        createReverseEdge: function () {\n\t            var r = this.clone();\n\t            r.reverse();\n\t            r.reversed = true;\n\t            return r;\n\t        },\n\n\t        /**\n\t         * Returns a clone of this link.\n\t         */\n\t        clone: function () {\n\t            var clone = new Link(this.source, this.target);\n\t            return clone;\n\t        }\n\t    });\n\n\t    /*--------------Graph structure---------------------------------*/\n\t    /**\n\t     * Defines a directed graph structure.\n\t     * Note that the incidence structure resides in the nodes through the incoming and outgoing links collection, rahter than\n\t     * inside the Graph.\n\t     */\n\t    var Graph = kendo.Class.extend({\n\t        init: function (idOrDiagram) {\n\t            /**\n\t             * The links or edge collection of this Graph.\n\t             * @type {Array}\n\t             */\n\t            this.links = [];\n\t            /**\n\t             * The node or vertex collection of this Graph.\n\t             * @type {Array}\n\t             */\n\t            this.nodes = [];\n\n\t            this._nodeMap = new Dictionary();\n\t            /**\n\t             * The optional reference to the Diagram on which this Graph is based.\n\t             * @type {null}\n\t             */\n\t            this.diagram = null;\n\n\t            /**\n\t             * The root of this Graph. If not set explicitly the first Node with zero incoming links will be taken.\n\t             * @type {null}\n\t             * @private\n\t             */\n\t            this._root = null;\n\t            if (Utils.isDefined(idOrDiagram)) {\n\t                if (Utils.isString(idOrDiagram)) {\n\t                    this.id = idOrDiagram;\n\t                }\n\t                else {\n\t                    this.diagram = idOrDiagram;\n\t                    this.id = idOrDiagram.id;\n\t                }\n\t            }\n\t            else {\n\t                this.id = randomId();\n\t            }\n\n\t            /**\n\t             * The bounds of this graph if the nodes have spatial extension defined.\n\t             * @type {Rect}\n\t             */\n\t            this.bounds = new Rect();\n\t            // keeps track whether the children & parents have been created\n\t            this._hasCachedRelationships = false;\n\t            this.type = \"Graph\";\n\t        },\n\t        /**\n\t         * Caches the relational information of parents and children in the 'parents' and 'children'\n\t         * properties.\n\t         * @param forceRebuild If set to true the relational info will be rebuild even if already present.\n\t         */\n\t        cacheRelationships: function (forceRebuild) {\n\t            if (Utils.isUndefined(forceRebuild)) {\n\t                forceRebuild = false;\n\t            }\n\t            if (this._hasCachedRelationships && !forceRebuild) {\n\t                return;\n\t            }\n\t            for (var i = 0, len = this.nodes.length; i < len; i++) {\n\t                var node = this.nodes[i];\n\t                node.children = this.getChildren(node);\n\t                node.parents = this.getParents(node);\n\t            }\n\t            this._hasCachedRelationships = true;\n\t        },\n\n\t        /**\n\t         * Assigns tree-levels to the nodes assuming this is a tree graph.\n\t         * If not connected or not a tree the process will succeed but\n\t         * will have little meaning.\n\t         * @param startNode The node from where the level numbering starts, usually the root of the tree.\n\t         * @param visited The collection of visited nodes.\n\t         * @param offset The offset or starting counter of the level info.\n\t         */\n\t        assignLevels: function (startNode, offset, visited) {\n\t            if (!startNode) {\n\t                throw \"Start node not specified.\";\n\t            }\n\t            if (Utils.isUndefined(offset)) {\n\t                offset = 0;\n\t            }\n\t            // if not done before, cache the parents and children\n\t            this.cacheRelationships();\n\t            if (Utils.isUndefined(visited)) {\n\t                visited = new Dictionary();\n\t                Utils.forEach(this.nodes, function (n) {\n\t                    visited.add(n, false);\n\t                });\n\t            }\n\t            visited.set(startNode, true);\n\t            startNode.level = offset;\n\t            var children = startNode.children;\n\t            for (var i = 0, len = children.length; i < len; i++) {\n\t                var child = children[i];\n\t                if (!child || visited.get(child)) {\n\t                    continue;\n\t                }\n\t                this.assignLevels(child, offset + 1, visited);\n\t            }\n\t        },\n\n\t        /**\n\t         * Gets or set the root of this graph.\n\t         * If not set explicitly the first Node with zero incoming links will be taken.\n\t         * @param value\n\t         * @returns {*}\n\t         */\n\t        root: function (value) {\n\t            if (Utils.isUndefined(value)) {\n\t                if (!this._root) {\n\t                    // TODO: better to use the longest path for the most probable root?\n\t                    var found = Utils.first(this.nodes, function (n) {\n\t                        return n.incoming.length === 0;\n\t                    });\n\t                    if (found) {\n\t                        return found;\n\t                    }\n\t                    return Utils.first(this.nodes);\n\t                }\n\t                else {\n\t                    return this._root;\n\t                }\n\t            }\n\t            else {\n\t                this._root = value;\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns the connected components of this graph.\n\t         * Note that the returned graphs are made up of the nodes and links of this graph, i.e. a pointer to the items of this graph.\n\t         * If you alter the items of the components you'll alter the original graph and vice versa.\n\t         * @returns {Array}\n\t         */\n\t        getConnectedComponents: function () {\n\t            this.componentIndex = 0;\n\t            this.setItemIndices();\n\t            var componentId = Utils.initArray(this.nodes.length, -1);\n\n\t            for (var v = 0; v < this.nodes.length; v++) {\n\t                if (componentId[v] === -1) {\n\t                    this._collectConnectedNodes(componentId, v);\n\t                    this.componentIndex++;\n\t                }\n\t            }\n\n\t            var components = [], i;\n\t            for (i = 0; i < this.componentIndex; ++i) {\n\t                components[i] = new Graph();\n\t            }\n\t            for (i = 0; i < componentId.length; ++i) {\n\t                var graph = components[componentId[i]];\n\t                graph.addNodeAndOutgoings(this.nodes[i]);\n\t            }\n\t            // sorting the components in decreasing order of node count\n\t            components.sort(function (a, b) {\n\t                return b.nodes.length - a.nodes.length;\n\t            });\n\t            return components;\n\t        },\n\n\t        _collectConnectedNodes: function (setIds, nodeIndex) {\n\t            setIds[nodeIndex] = this.componentIndex; // part of the current component\n\t            var node = this.nodes[nodeIndex];\n\t            Utils.forEach(node.links,\n\t                function (link) {\n\t                    var next = link.getComplement(node);\n\t                    var nextId = next.index;\n\t                    if (setIds[nextId] === -1) {\n\t                        this._collectConnectedNodes(setIds, nextId);\n\t                    }\n\t                }, this);\n\t        },\n\n\t        /**\n\t         * Calculates the bounds of this Graph if the Nodes have spatial dimensions defined.\n\t         * @returns {Rect}\n\t         */\n\t        calcBounds: function () {\n\t            if (this.isEmpty()) {\n\t                this.bounds = new Rect();\n\t                return this.bounds;\n\t            }\n\t            var b = null;\n\t            for (var i = 0, len = this.nodes.length; i < len; i++) {\n\t                var node = this.nodes[i];\n\t                if (!b) {\n\t                    b = node.bounds();\n\t                }\n\t                else {\n\t                    b = b.union(node.bounds());\n\t                }\n\t            }\n\t            this.bounds = b;\n\t            return this.bounds;\n\t        },\n\n\t        /**\n\t         * Creates a spanning tree for the current graph.\n\t         * Important: this will not return a spanning forest if the graph is disconnected.\n\t         * Prim's algorithm  finds a minimum-cost spanning tree of an edge-weighted, connected, undirected graph;\n\t         * see http://en.wikipedia.org/wiki/Prim%27s_algorithm .\n\t         * @param root The root of the spanning tree.\n\t         * @returns {Graph}\n\t         */\n\t        getSpanningTree: function (root) {\n\t            var tree = new Graph();\n\t            var map = new Dictionary(), source, target;\n\t            tree.root = root.clone();\n\t            tree.root.level = 0;\n\t            tree.root.id = root.id;\n\t            map.add(root, tree.root);\n\t            root.level = 0;\n\n\t            var visited = [];\n\t            var remaining = [];\n\t            tree._addNode(tree.root);\n\t            visited.push(root);\n\t            remaining.push(root);\n\n\t            var levelCount = 1;\n\t            while (remaining.length > 0) {\n\t                var next = remaining.pop();\n\t                for (var ni = 0; ni < next.links.length; ni++) {\n\t                    var link = next.links[ni];\n\t                    var cn = link.getComplement(next);\n\t                    if (contains(visited, cn)) {\n\t                        continue;\n\t                    }\n\n\t                    cn.level = next.level + 1;\n\t                    if (levelCount < cn.level + 1) {\n\t                        levelCount = cn.level + 1;\n\t                    }\n\t                    if (!contains(remaining, cn)) {\n\t                        remaining.push(cn);\n\t                    }\n\t                    if (!contains(visited, cn)) {\n\t                        visited.push(cn);\n\t                    }\n\t                    if (map.containsKey(next)) {\n\t                        source = map.get(next);\n\t                    }\n\t                    else {\n\t                        source = next.clone();\n\t                        source.level = next.level;\n\t                        source.id = next.id;\n\t                        map.add(next, source);\n\t                    }\n\t                    if (map.containsKey(cn)) {\n\t                        target = map.get(cn);\n\t                    }\n\t                    else {\n\t                        target = cn.clone();\n\t                        target.level = cn.level;\n\t                        target.id = cn.id;\n\t                        map.add(cn, target);\n\t                    }\n\t                    var newLink = new Link(source, target);\n\t                    tree.addLink(newLink);\n\t                }\n\n\t            }\n\n\t            var treeLevels = [];\n\t            for (var i = 0; i < levelCount; i++) {\n\t                treeLevels.push([]);\n\t            }\n\n\t            Utils.forEach(tree.nodes, function (node) {\n\t                treeLevels[node.level].push(node);\n\t            });\n\n\t            tree.treeLevels = treeLevels;\n\t            tree.cacheRelationships();\n\t            return tree;\n\t        },\n\n\t        /**\n\t         * Returns a random node in this graph.\n\t         * @param excludedNodes The collection of nodes which should not be considered.\n\t         * @param incidenceLessThan The maximum degree or incidence the random node should have.\n\t         * @returns {*}\n\t         */\n\t        takeRandomNode: function (excludedNodes, incidenceLessThan) {\n\t            if (Utils.isUndefined(excludedNodes)) {\n\t                excludedNodes = [];\n\t            }\n\t            if (Utils.isUndefined(incidenceLessThan)) {\n\t                incidenceLessThan = 4;\n\t            }\n\t            if (this.nodes.length === 0) {\n\t                return null;\n\t            }\n\t            if (this.nodes.length === 1) {\n\t                return contains(excludedNodes, this.nodes[0]) ? null : this.nodes[0];\n\t            }\n\t            var pool = $.grep(this.nodes, function (node) {\n\t                return !contains(excludedNodes, node) && node.degree() <= incidenceLessThan;\n\t            });\n\t            if (Utils.isEmpty(pool)) {\n\t                return null;\n\t            }\n\t            return pool[Utils.randomInteger(0, pool.length)];\n\t        },\n\n\t        /**\n\t         * Returns whether this is an empty graph.\n\t         */\n\t        isEmpty: function () {\n\t            return Utils.isEmpty(this.nodes);\n\t        },\n\n\t        /**\n\t         * Checks whether the endpoints of the links are all in the nodes collection.\n\t         */\n\t        isHealthy: function () {\n\t            return Utils.all(this.links, function (link) {\n\t                return contains(this.nodes, link.source) && contains(this.nodes, link.target);\n\t            }, this);\n\t        },\n\n\t        /**\n\t         * Gets the parents of this node, defined as the adjacent nodes with a link from the adjacent node to this one.\n\t         * @returns {Array}\n\t         */\n\t        getParents: function (n) {\n\t            if (!this.hasNode(n)) {\n\t                throw \"The given node is not part of this graph.\";\n\t            }\n\t            return n.getParents();\n\t        },\n\n\t        /**\n\t         * Gets the children of this node, defined as the adjacent nodes with a link from this node to the adjacent one.\n\t         * @returns {Array}\n\t         */\n\t        getChildren: function (n) {\n\t            if (!this.hasNode(n)) {\n\t                throw \"The given node is not part of this graph.\";\n\t            }\n\t            return n.getChildren();\n\t        },\n\n\t        /**\n\t         * Adds a new link to the graph between the given nodes.\n\t         */\n\t        addLink: function (sourceOrLink, target, owner) {\n\n\t            if (Utils.isUndefined(sourceOrLink)) {\n\t                throw \"The source of the link is not defined.\";\n\t            }\n\t            if (Utils.isUndefined(target)) {\n\t                // can only be undefined if the first one is a Link\n\t                if (Utils.isDefined(sourceOrLink.type) && sourceOrLink.type === \"Link\") {\n\t                    this.addExistingLink(sourceOrLink);\n\t                    return;\n\t                }\n\t                else {\n\t                    throw \"The target of the link is not defined.\";\n\t                }\n\t            }\n\n\t            var foundSource = this.getNode(sourceOrLink);\n\t            if (Utils.isUndefined(foundSource)) {\n\t                foundSource = this.addNode(sourceOrLink);\n\t            }\n\t            var foundTarget = this.getNode(target);\n\t            if (Utils.isUndefined(foundTarget)) {\n\t                foundTarget = this.addNode(target);\n\t            }\n\n\t            var newLink = new Link(foundSource, foundTarget);\n\n\t            if (Utils.isDefined(owner)) {\n\t                newLink.owner = owner;\n\t            }\n\n\t            /*newLink.source.outgoing.push(newLink);\n\t             newLink.source.links.push(newLink);\n\t             newLink.target.incoming.push(newLink);\n\t             newLink.target.links.push(newLink);*/\n\n\t            this.links.push(newLink);\n\n\t            return newLink;\n\t        },\n\n\t        /**\n\t         * Removes all the links in this graph.\n\t         */\n\t        removeAllLinks: function () {\n\t            while (this.links.length > 0) {\n\t                var link = this.links[0];\n\t                this.removeLink(link);\n\t            }\n\t        },\n\n\t        /**\n\t         * Adds the given link to the current graph.\n\t         */\n\t        addExistingLink: function (link) {\n\n\t            if (this.hasLink(link)) {\n\t                return;\n\t            }\n\t            this.links.push(link);\n\t            if (this.hasNode(link.source.id)) {\n\t                // priority to the existing node with the id even if other props are different\n\t                var s = this.getNode(link.source.id);\n\t                link.changeSource(s);\n\t            }\n\t            else {\n\t                this.addNode(link.source);\n\t            }\n\n\t            if (this.hasNode(link.target.id)) {\n\t                var t = this.getNode(link.target.id);\n\t                link.changeTarget(t);\n\t            }\n\t            else {\n\t                this.addNode(link.target);\n\t            }\n\n\t            /*  if (!link.source.outgoing.contains(link)) {\n\t             link.source.outgoing.push(link);\n\t             }\n\t             if (!link.source.links.contains(link)) {\n\t             link.source.links.push(link);\n\t             }\n\t             if (!link.target.incoming.contains(link)) {\n\t             link.target.incoming.push(link);\n\t             }\n\t             if (!link.target.links.contains(link)) {\n\t             link.target.links.push(link);\n\t             }*/\n\t        },\n\n\t        /**\n\t         * Returns whether the given identifier or Link is part of this graph.\n\t         * @param linkOrId An identifier or a Link object.\n\t         * @returns {*}\n\t         */\n\t        hasLink: function (linkOrId) {\n\t            if (Utils.isString(linkOrId)) {\n\t                return Utils.any(this.links, function (link) {\n\t                    return link.id === linkOrId;\n\t                });\n\t            }\n\t            if (linkOrId.type === \"Link\") {\n\t                return contains(this.links, linkOrId);\n\t            }\n\t            throw \"The given object is neither an identifier nor a Link.\";\n\t        },\n\t        /**\n\t         * Gets the node with the specified Id or null if not part of this graph.\n\t         */\n\t        getNode: function (nodeOrId) {\n\t            var id = nodeOrId.id || nodeOrId;\n\t            if (this._nodeMap.containsKey(id)) {\n\t                return this._nodeMap.get(id);\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns whether the given node or node Id is part of this graph.\n\t         */\n\t        hasNode: function (nodeOrId) {\n\t            var id = nodeOrId.id || nodeOrId;\n\t            return this._nodeMap.containsKey(id);\n\t        },\n\n\t        _addNode: function(node) {\n\t            this.nodes.push(node);\n\t            this._nodeMap.add(node.id, node);\n\t        },\n\n\t        _removeNode: function(node) {\n\t            Utils.remove(this.nodes, node);\n\t            this._nodeMap.remove(node.id);\n\t        },\n\n\t        /**\n\t         * Removes the given node from this graph.\n\t         * The node can be specified as an object or as an identifier (string).\n\t         */\n\t        removeNode: function (nodeOrId) {\n\t            var n = nodeOrId;\n\t            if (Utils.isString(nodeOrId)) {\n\t                n = this.getNode(nodeOrId);\n\t            }\n\n\t            if (Utils.isDefined(n)) {\n\t                var links = n.links;\n\t                n.links = [];\n\t                for (var i = 0, len = links.length; i < len; i++) {\n\t                    var link = links[i];\n\t                    this.removeLink(link);\n\t                }\n\t                this._removeNode(n);\n\t            }\n\t            else {\n\t                throw \"The identifier should be a Node or the Id (string) of a node.\";\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns whether the given nodes are connected with a least one link independently of the direction.\n\t         */\n\t        areConnected: function (n1, n2) {\n\t            return Utils.any(this.links, function (link) {\n\t                return link.source == n1 && link.target == n2 || link.source == n2 && link.target == n1;\n\t            });\n\t        },\n\n\t        /**\n\t         * Removes the given link from this graph.\n\t         */\n\t        removeLink: function (link) {\n\t            /*    if (!this.links.contains(link)) {\n\t             throw \"The given link is not part of the Graph.\";\n\t             }\n\t             */\n\t            Utils.remove(this.links, link);\n\n\t            Utils.remove(link.source.outgoing, link);\n\t            Utils.remove(link.source.links, link);\n\t            Utils.remove(link.target.incoming, link);\n\t            Utils.remove(link.target.links, link);\n\t        },\n\n\t        /**\n\t         * Adds a new node to this graph, if not already present.\n\t         * The node can be an existing Node or the identifier of a new node.\n\t         * No error is thrown if the node is already there and the existing one is returned.\n\t         */\n\t        addNode: function (nodeOrId, layoutRect, owner) {\n\n\t            var newNode = null;\n\n\t            if (!Utils.isDefined(nodeOrId)) {\n\t                throw \"No Node or identifier for a new Node is given.\";\n\t            }\n\n\t            if (Utils.isString(nodeOrId)) {\n\t                if (this.hasNode(nodeOrId)) {\n\t                    return this.getNode(nodeOrId);\n\t                }\n\t                newNode = new Node(nodeOrId);\n\t            }\n\t            else {\n\t                if (this.hasNode(nodeOrId)) {\n\t                    return this.getNode(nodeOrId);\n\t                }\n\t                // todo: ensure that the param is a Node?\n\t                newNode = nodeOrId;\n\t            }\n\n\t            if (Utils.isDefined(layoutRect)) {\n\t                newNode.bounds(layoutRect);\n\t            }\n\n\t            if (Utils.isDefined(owner)) {\n\t                newNode.owner = owner;\n\t            }\n\t            this._addNode(newNode);\n\t            return newNode;\n\t        },\n\n\t        /**\n\t         * Adds the given Node and its outgoing links.\n\t         */\n\t        addNodeAndOutgoings: function (node) {\n\t            if (!this.hasNode(node)) {\n\t                this._addNode(node);\n\t            }\n\n\t            var newLinks = node.outgoing;\n\t            node.outgoing = [];\n\t            Utils.forEach(newLinks, function (link) {\n\t                this.addExistingLink(link);\n\t            }, this);\n\t        },\n\n\t        /**\n\t         * Sets the 'index' property on the links and nodes of this graph.\n\t         */\n\t        setItemIndices: function () {\n\t            var i;\n\t            for (i = 0; i < this.nodes.length; ++i) {\n\t                this.nodes[i].index = i;\n\t            }\n\n\t            for (i = 0; i < this.links.length; ++i) {\n\t                this.links[i].index = i;\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns a clone of this graph.\n\t         */\n\t        clone: function (saveMapping) {\n\t            var copy = new Graph();\n\t            var save = Utils.isDefined(saveMapping) && saveMapping === true;\n\t            if (save) {\n\t                copy.nodeMap = new Dictionary();\n\t                copy.linkMap = new Dictionary();\n\t            }\n\t            // we need a map even if the saveMapping is not set\n\t            var map = new Dictionary();\n\t            Utils.forEach(this.nodes, function (nOriginal) {\n\t                var nCopy = nOriginal.clone();\n\t                map.set(nOriginal, nCopy);\n\t                copy._addNode(nCopy);\n\n\t                if (save) {\n\t                    copy.nodeMap.set(nCopy, nOriginal);\n\t                }\n\t            });\n\n\t            Utils.forEach(this.links, function (linkOriginal) {\n\t                if (map.containsKey(linkOriginal.source) && map.containsKey(linkOriginal.target)) {\n\t                    var linkCopy = copy.addLink(map.get(linkOriginal.source), map.get(linkOriginal.target));\n\t                    if (save) {\n\t                        copy.linkMap.set(linkCopy, linkOriginal);\n\t                    }\n\t                }\n\t            });\n\n\t            return copy;\n\t        },\n\n\t        /**\n\t         * The parsing allows a quick way to create graphs.\n\t         *  - [\"n1->n2\", \"n2->n3\"]: creates the three nodes and adds the links\n\t         *  - [\"n1->n2\", {id: \"QSDF\"}, \"n2->n3\"]: same as previous but also performs a deep extend of the link between n1 and n2 with the given object.\n\t         */\n\t        linearize: function (addIds) {\n\t            return Graph.Utils.linearize(this, addIds);\n\t        },\n\n\t        /**\n\t         * Performs a depth-first traversal starting at the given node.\n\t         * @param startNode a node or id of a node in this graph\n\t         * @param action\n\t         */\n\t        depthFirstTraversal: function (startNode, action) {\n\t            if (Utils.isUndefined(startNode)) {\n\t                throw \"You need to supply a starting node.\";\n\t            }\n\t            if (Utils.isUndefined(action)) {\n\t                throw \"You need to supply an action.\";\n\t            }\n\t            if (!this.hasNode(startNode)) {\n\t                throw \"The given start-node is not part of this graph\";\n\t            }\n\t            var foundNode = this.getNode(startNode);// case the given one is an Id\n\t            var visited = [];\n\t            this._dftIterator(foundNode, action, visited);\n\t        },\n\n\t        _dftIterator: function (node, action, visited) {\n\n\t            action(node);\n\t            visited.push(node);\n\t            var children = node.getChildren();\n\t            for (var i = 0, len = children.length; i < len; i++) {\n\t                var child = children[i];\n\t                if (contains(visited, child)) {\n\t                    continue;\n\t                }\n\t                this._dftIterator(child, action, visited);\n\t            }\n\t        },\n\n\t        /**\n\t         * Performs a breadth-first traversal starting at the given node.\n\t         * @param startNode a node or id of a node in this graph\n\t         * @param action\n\t         */\n\t        breadthFirstTraversal: function (startNode, action) {\n\n\t            if (Utils.isUndefined(startNode)) {\n\t                throw \"You need to supply a starting node.\";\n\t            }\n\t            if (Utils.isUndefined(action)) {\n\t                throw \"You need to supply an action.\";\n\t            }\n\n\t            if (!this.hasNode(startNode)) {\n\t                throw \"The given start-node is not part of this graph\";\n\t            }\n\t            var foundNode = this.getNode(startNode);// case the given one is an Id\n\t            var queue = new Queue();\n\t            var visited = [];\n\t            queue.enqueue(foundNode);\n\n\t            while (queue.length > 0) {\n\t                var node = queue.dequeue();\n\t                action(node);\n\t                visited.push(node);\n\t                var children = node.getChildren();\n\t                for (var i = 0, len = children.length; i < len; i++) {\n\t                    var child = children[i];\n\t                    if (contains(visited, child) || contains(queue, child)) {\n\t                        continue;\n\t                    }\n\t                    queue.enqueue(child);\n\t                }\n\t            }\n\t        },\n\n\t        /**\n\t         * This is the classic Tarjan algorithm for strongly connected components.\n\t         * See e.g. http://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm\n\t         * @param excludeSingleItems Whether isolated nodes should be excluded from the analysis.\n\t         * @param node The start node from which the analysis starts.\n\t         * @param indices  Numbers the nodes consecutively in the order in which they are discovered.\n\t         * @param lowLinks The smallest index of any node known to be reachable from the node, including the node itself\n\t         * @param connected The current component.\n\t         * @param stack The bookkeeping stack of things to visit.\n\t         * @param index The counter of visited nodes used to assign the indices.\n\t         * @private\n\t         */\n\t        _stronglyConnectedComponents: function (excludeSingleItems, node, indices, lowLinks, connected, stack, index) {\n\t            indices.add(node, index);\n\t            lowLinks.add(node, index);\n\t            index++;\n\n\t            stack.push(node);\n\n\t            var children = node.getChildren(), next;\n\t            for (var i = 0, len = children.length; i < len; i++) {\n\t                next = children[i];\n\t                if (!indices.containsKey(next)) {\n\t                    this._stronglyConnectedComponents(excludeSingleItems, next, indices, lowLinks, connected, stack, index);\n\t                    lowLinks.add(node, Math.min(lowLinks.get(node), lowLinks.get(next)));\n\t                }\n\t                else if (contains(stack, next)) {\n\t                    lowLinks.add(node, Math.min(lowLinks.get(node), indices.get(next)));\n\t                }\n\t            }\n\t            // If v is a root node, pop the stack and generate a strong component\n\t            if (lowLinks.get(node) === indices.get(node)) {\n\t                var component = [];\n\t                do {\n\t                    next = stack.pop();\n\t                    component.push(next);\n\t                }\n\t                while (next !== node);\n\t                if (!excludeSingleItems || (component.length > 1)) {\n\t                    connected.push(component);\n\t                }\n\t            }\n\t        },\n\n\t        /**\n\t         * Returns the cycles found in this graph.\n\t         * The returned arrays consist of the nodes which are strongly coupled.\n\t         * @param excludeSingleItems Whether isolated nodes should be excluded.\n\t         * @returns {Array} The array of cycles found.\n\t         */\n\t        findCycles: function (excludeSingleItems) {\n\t            if (Utils.isUndefined(excludeSingleItems)) {\n\t                excludeSingleItems = true;\n\t            }\n\t            var indices = new Dictionary();\n\t            var lowLinks = new Dictionary();\n\t            var connected = [];\n\t            var stack = [];\n\t            for (var i = 0, len = this.nodes.length; i < len; i++) {\n\t                var node = this.nodes[i];\n\t                if (indices.containsKey(node)) {\n\t                    continue;\n\t                }\n\t                this._stronglyConnectedComponents(excludeSingleItems, node, indices, lowLinks, connected, stack, 0);\n\t            }\n\t            return connected;\n\t        },\n\n\t        /**\n\t         * Returns whether this graph is acyclic.\n\t         * @returns {*}\n\t         */\n\t        isAcyclic: function () {\n\t            return Utils.isEmpty(this.findCycles());\n\t        },\n\n\t        /**\n\t         * Returns whether the given graph is a subgraph of this one.\n\t         * @param other Another graph instance.\n\t         */\n\t        isSubGraph: function (other) {\n\t            var otherArray = other.linearize();\n\t            var thisArray = this.linearize();\n\t            return Utils.all(otherArray, function (s) {\n\t                return contains(thisArray, s);\n\t            });\n\t        },\n\n\t        /**\n\t         *  Makes an acyclic graph from the current (connected) one.\n\t         * * @returns {Array} The reversed links.\n\t         */\n\t        makeAcyclic: function () {\n\t            // if empty or almost empty\n\t            if (this.isEmpty() || this.nodes.length <= 1 || this.links.length <= 1) {\n\t                return [];\n\t            }\n\t            // singular case of just two nodes\n\t            if (this.nodes.length == 2) {\n\t                var result = [];\n\t                if (this.links.length > 1) {\n\t                    var oneLink = this.links[0];\n\t                    var oneNode = oneLink.source;\n\t                    for (var i = 0, len = this.links.length; i < len; i++) {\n\t                        var link = this.links[i];\n\t                        if (link.source == oneNode) {\n\t                            continue;\n\t                        }\n\t                        var rev = link.reverse();\n\t                        result.push(rev);\n\t                    }\n\t                }\n\t                return result;\n\t            }\n\n\t            var copy = this.clone(true); // copy.nodeMap tells you the mapping\n\t            var N = this.nodes.length;\n\n\t            var intensityCatalog = new Dictionary();\n\n\t            /**\n\t             * If there are both incoming and outgoing links this will return the flow intensity (out-in).\n\t             * Otherwise the node acts as a flow source with N specifying the (equal) intensity.\n\t             * @param node\n\t             * @returns {number}\n\t             */\n\t            var flowIntensity = function (node) {\n\t                if (node.outgoing.length === 0) {\n\t                    return (2 - N);\n\t                }\n\t                else if (node.incoming.length === 0) {\n\t                    return (N - 2);\n\t                }\n\t                else {\n\t                    return node.outgoing.length - node.incoming.length;\n\t                }\n\t            };\n\n\t            /**\n\t             * Collects the nodes with the same intensity.\n\t             * @param node\n\t             * @param intensityCatalog\n\t             */\n\t            var catalogEqualIntensity = function (node, intensityCatalog) {\n\t                var intensity = flowIntensity(node, N);\n\t                if (!intensityCatalog.containsKey(intensity)) {\n\t                    intensityCatalog.set(intensity, []);\n\t                }\n\t                intensityCatalog.get(intensity).push(node);\n\t            };\n\n\t            Utils.forEach(copy.nodes, function (v) {\n\t                catalogEqualIntensity(v, intensityCatalog);\n\t            });\n\n\t            var sourceStack = [];\n\t            var targetStack = [];\n\n\t            while (copy.nodes.length > 0) {\n\t                var source, target, intensity;\n\t                if (intensityCatalog.containsKey(2 - N)) {\n\t                    var targets = intensityCatalog.get(2 - N); // nodes without outgoings\n\t                    while (targets.length > 0) {\n\t                        target = targets.pop();\n\t                        for (var li = 0; li < target.links.length; li++) {\n\t                            var targetLink = target.links[li];\n\t                            source = targetLink.getComplement(target);\n\t                            intensity = flowIntensity(source, N);\n\t                            Utils.remove(intensityCatalog.get(intensity), source);\n\t                            source.removeLink(targetLink);\n\t                            catalogEqualIntensity(source, intensityCatalog);\n\t                        }\n\t                        copy._removeNode(target);\n\t                        targetStack.unshift(target);\n\t                    }\n\t                }\n\n\t                // move sources to sourceStack\n\t                if (intensityCatalog.containsKey(N - 2)) {\n\t                    var sources = intensityCatalog.get(N - 2); // nodes without incomings\n\t                    while (sources.length > 0) {\n\t                        source = sources.pop();\n\t                        for (var si = 0; si < source.links.length; si++) {\n\t                            var sourceLink = source.links[si];\n\t                            target = sourceLink.getComplement(source);\n\t                            intensity = flowIntensity(target, N);\n\t                            Utils.remove(intensityCatalog.get(intensity), target);\n\t                            target.removeLink(sourceLink);\n\t                            catalogEqualIntensity(target, intensityCatalog);\n\t                        }\n\t                        sourceStack.push(source);\n\t                        copy._removeNode(source);\n\t                    }\n\t                }\n\n\t                if (copy.nodes.length > 0) {\n\t                    for (var k = N - 3; k > 2 - N; k--) {\n\t                        if (intensityCatalog.containsKey(k) &&\n\t                            intensityCatalog.get(k).length > 0) {\n\t                            var maxdiff = intensityCatalog.get(k);\n\t                            var v = maxdiff.pop();\n\t                            for (var ri = 0; ri < v.links.length; ri++) {\n\t                                var ril = v.links[ri];\n\t                                var u = ril.getComplement(v);\n\t                                intensity = flowIntensity(u, N);\n\t                                Utils.remove(intensityCatalog.get(intensity), u);\n\t                                u.removeLink(ril);\n\t                                catalogEqualIntensity(u, intensityCatalog);\n\t                            }\n\t                            sourceStack.push(v);\n\t                            copy._removeNode(v);\n\t                            break;\n\t                        }\n\t                    }\n\t                }\n\t            }\n\n\t            sourceStack = sourceStack.concat(targetStack);\n\n\t            var vertexOrder = new Dictionary();\n\t            for (var kk = 0; kk < this.nodes.length; kk++) {\n\t                vertexOrder.set(copy.nodeMap.get(sourceStack[kk]), kk);\n\t            }\n\n\t            var reversedEdges = [];\n\t            Utils.forEach(this.links, function (link) {\n\t                if (vertexOrder.get(link.source) > vertexOrder.get(link.target)) {\n\t                    link.reverse();\n\t                    reversedEdges.push(link);\n\t                }\n\t            });\n\t            return reversedEdges;\n\t        }\n\t    });\n\n\t    /**\n\t     * A collection of predefined graphs for demo and testing purposes.\n\t     */\n\t    Graph.Predefined = {\n\t        /**\n\t         * Eight-shapes graph all connected in a cycle.\n\t         * @returns {*}\n\t         * @constructor\n\t         */\n\t        EightGraph: function () {\n\t            return Graph.Utils.parse([ \"1->2\", \"2->3\", \"3->4\", \"4->1\", \"3->5\", \"5->6\", \"6->7\", \"7->3\"]);\n\t        },\n\n\t        /**\n\t         * Creates a typical mindmap diagram.\n\t         * @returns {*}\n\t         * @constructor\n\t         */\n\t        Mindmap: function () {\n\t            return Graph.Utils.parse([\"0->1\", \"0->2\", \"0->3\", \"0->4\", \"0->5\", \"1->6\", \"1->7\", \"7->8\", \"2->9\", \"9->10\", \"9->11\", \"3->12\",\n\t                \"12->13\", \"13->14\", \"4->15\", \"4->16\", \"15->17\", \"15->18\", \"18->19\", \"18->20\", \"14->21\", \"14->22\", \"5->23\", \"23->24\", \"23->25\", \"6->26\"]);\n\t        },\n\n\t        /**\n\t         * Three nodes connected in a cycle.\n\t         * @returns {*}\n\t         * @constructor\n\t         */\n\t        ThreeGraph: function () {\n\t            return Graph.Utils.parse([ \"1->2\", \"2->3\", \"3->1\"]);\n\t        },\n\n\t        /**\n\t         * A tree with each node having two children.\n\t         * @param levels How many levels the binary tree should have.\n\t         * @returns {diagram.Graph}\n\t         * @constructor\n\t         */\n\t        BinaryTree: function (levels) {\n\t            if (Utils.isUndefined(levels)) {\n\t                levels = 5;\n\t            }\n\t            return Graph.Utils.createBalancedTree(levels, 2);\n\t        },\n\n\t        /**\n\t         * A linear graph (discrete line segment).\n\t         * @param length How many segments (the node count is hence (length+1)).\n\t         * @returns {diagram.Graph}\n\t         * @constructor\n\t         */\n\t        Linear: function (length) {\n\t            if (Utils.isUndefined(length)) {\n\t                length = 10;\n\t            }\n\t            return Graph.Utils.createBalancedTree(length, 1);\n\t        },\n\n\t        /**\n\t         * A standard tree-graph with the specified levels and children (siblings) count.\n\t         * Note that for a balanced tree of level N and sibling count s, counting the root as level zero:\n\t         *  - NodeCount = (1-s^(N+1))/(1-s)]\n\t         *  - LinkCount = s.(1-s^N)/(1-s)\n\t         * @param levels How many levels the tree should have.\n\t         * @param siblingsCount How many siblings each level should have.\n\t         * @returns {diagram.Graph}\n\t         * @constructor\n\t         */\n\t        Tree: function (levels, siblingsCount) {\n\t            return Graph.Utils.createBalancedTree(levels, siblingsCount);\n\t        },\n\n\t        /**\n\t         * Creates a forest.\n\t         * Note that for a balanced forest of level N, sibling count s and tree count t, counting the root as level zero:\n\t         *  - NodeCount = t.(1-s^(N+1))/(1-s)]\n\t         *  - LinkCount = t.s.(1-s^N)/(1-s)\n\t         * @param levels How many levels the tree should have.\n\t         * @param siblingsCount How many siblings each level should have.\n\t         * @param trees The amount of trees the forest should have.\n\t         * @returns {diagram.Graph}\n\t         * @constructor\n\t         */\n\t        Forest: function (levels, siblingsCount, trees) {\n\t            return Graph.Utils.createBalancedForest(levels, siblingsCount, trees);\n\t        },\n\n\t        /**\n\t         * A workflow-like graph with cycles.\n\t         * @returns {*}\n\t         * @constructor\n\t         */\n\t        Workflow: function () {\n\t            return Graph.Utils.parse(\n\t                [\"0->1\", \"1->2\", \"2->3\", \"1->4\", \"4->3\", \"3->5\", \"5->6\", \"6->3\", \"6->7\", \"5->4\"]\n\t            );\n\t        },\n\n\t        /**\n\t         * A grid graph with the direction of the links avoiding cycles.\n\t         * Node count: (n+1).(m+1)\n\t         * Link count: n.(m+1) + m.(n+1)\n\t         * @param n Horizontal count of grid cells. If zero this will result in a linear graph.\n\t         * @param m Vertical count of grid cells. If zero this will result in a linear graph.\n\t         * @constructor\n\t         */\n\t        Grid: function (n, m) {\n\t            var g = new diagram.Graph();\n\t            if (n <= 0 && m <= 0) {\n\t                return g;\n\t            }\n\n\t            for (var i = 0; i < n + 1; i++) {\n\t                var previous = null;\n\t                for (var j = 0; j < m + 1; j++) {\n\t                    // using x-y coordinates to name the nodes\n\t                    var node = new Node(i.toString() + \".\" + j.toString());\n\t                    g.addNode(node);\n\t                    if (previous) {\n\t                        g.addLink(previous, node);\n\t                    }\n\t                    if (i > 0) {\n\t                        var left = g.getNode((i - 1).toString() + \".\" + j.toString());\n\t                        g.addLink(left, node);\n\t                    }\n\t                    previous = node;\n\t                }\n\t            }\n\t            return g;\n\t        }\n\n\t    };\n\n\t    /**\n\t     * Graph generation and other utilities.\n\t     */\n\t    Graph.Utils = {\n\t        /**\n\t         * The parsing allows a quick way to create graphs.\n\t         *  - [\"n1->n2\", \"n2->n3\"]: creates the three nodes and adds the links\n\t         *  - [\"n1->n2\", {id: \"id177\"}, \"n2->n3\"]: same as previous but also performs a deep extend of the link between n1 and n2 with the given object.\n\t         */\n\t        parse: function (graphString) {\n\n\t            var previousLink, graph = new diagram.Graph(), parts = graphString.slice();\n\t            for (var i = 0, len = parts.length; i < len; i++) {\n\t                var part = parts[i];\n\t                if (Utils.isString(part)) // link spec\n\t                {\n\t                    if (part.indexOf(\"->\") < 0) {\n\t                        throw \"The link should be specified as 'a->b'.\";\n\t                    }\n\t                    var p = part.split(\"->\");\n\t                    if (p.length != 2) {\n\t                        throw \"The link should be specified as 'a->b'.\";\n\t                    }\n\t                    previousLink = new Link(p[0], p[1]);\n\t                    graph.addLink(previousLink);\n\t                }\n\t                if (Utils.isObject(part)) {\n\t                    if (!previousLink) {\n\t                        throw \"Specification found before Link definition.\";\n\t                    }\n\t                    kendo.deepExtend(previousLink, part);\n\t                }\n\t            }\n\t            return graph;\n\t        },\n\n\t        /**\n\t         * Returns a linearized representation of the given Graph.\n\t         * See also the Graph.Utils.parse method for the inverse operation.\n\t         */\n\t        linearize: function (graph, addIds) {\n\t            if (Utils.isUndefined(graph)) {\n\t                throw \"Expected an instance of a Graph object in slot one.\";\n\t            }\n\t            if (Utils.isUndefined(addIds)) {\n\t                addIds = false;\n\t            }\n\t            var lin = [];\n\t            for (var i = 0, len = graph.links.length; i < len; i++) {\n\t                var link = graph.links[i];\n\t                lin.push(link.source.id + \"->\" + link.target.id);\n\t                if (addIds) {\n\t                    lin.push({id: link.id});\n\t                }\n\t            }\n\t            return lin;\n\t        },\n\n\t        /**\n\t         * The method used by the diagram creation to instantiate a shape.\n\t         * @param kendoDiagram The Kendo diagram where the diagram will be created.\n\t         * @param p The position at which to place the shape.\n\t         * @param shapeDefaults Optional Shape options.\n\t         * @param id Optional identifier of the shape.\n\t         * @returns {*}\n\t         * @private\n\t         */\n\t        _addShape: function (kendoDiagram, p, id, shapeDefaults) {\n\t            if (Utils.isUndefined(p)) {\n\t                p = new diagram.Point(0, 0);\n\t            }\n\n\t            if (Utils.isUndefined(id)) {\n\t                id = randomId();\n\t            }\n\n\t            shapeDefaults = kendo.deepExtend({\n\t                width: 20,\n\t                height: 20,\n\t                id: id,\n\t                radius: 10,\n\t                fill: \"#778899\",\n\t                data: \"circle\",\n\t                undoable: false,\n\t                x: p.x,\n\t                y: p.y\n\t            }, shapeDefaults);\n\n\t            return kendoDiagram.addShape(shapeDefaults);\n\t        },\n\t        /**\n\t         * The method used by the diagram creation to instantiate a connection.\n\t         * @param diagram he Kendo diagram where the diagram will be created.\n\t         * @param from The source shape.\n\t         * @param to The target shape.\n\t         * @param options Optional Connection options.\n\t         * @returns {*}\n\t         * @private\n\t         */\n\t        _addConnection: function (diagram, from, to, options) {\n\t            return diagram.connect(from, to, options);\n\t        },\n\n\t        /**\n\t         * Creates a diagram from the given Graph.\n\t         * @param diagram The Kendo diagram where the diagram will be created.\n\t         * @param graph The graph structure defining the diagram.\n\t         */\n\t        createDiagramFromGraph: function (diagram, graph, doLayout, randomSize) {\n\n\t            if (Utils.isUndefined(diagram)) {\n\t                throw \"The diagram surface is undefined.\";\n\t            }\n\t            if (Utils.isUndefined(graph)) {\n\t                throw \"No graph specification defined.\";\n\t            }\n\t            if (Utils.isUndefined(doLayout)) {\n\t                doLayout = true;\n\t            }\n\t            if (Utils.isUndefined(randomSize)) {\n\t                randomSize = false;\n\t            }\n\n\t            var width = diagram.element.clientWidth || 200;\n\t            var height = diagram.element.clientHeight || 200;\n\t            var map = [], node, shape;\n\t            for (var i = 0, len = graph.nodes.length; i < len; i++) {\n\t                node = graph.nodes[i];\n\t                var p = node.position;\n\t                if (Utils.isUndefined(p)) {\n\t                    if (Utils.isDefined(node.x) && Utils.isDefined(node.y)) {\n\t                        p = new Point(node.x, node.y);\n\t                    }\n\t                    else {\n\t                        p = new Point(Utils.randomInteger(10, width - 20), Utils.randomInteger(10, height - 20));\n\t                    }\n\t                }\n\t                var opt = {};\n\n\t                if (node.id === \"0\") {\n\t                    /* kendo.deepExtend(opt,\n\t                     {\n\t                     fill: \"Orange\",\n\t                     data: 'circle',\n\t                     width: 100,\n\t                     height: 100,\n\t                     center: new Point(50, 50)\n\t                     });*/\n\t                }\n\t                else if (randomSize) {\n\t                    kendo.deepExtend(opt, {\n\t                        width: Math.random() * 150 + 20,\n\t                        height: Math.random() * 80 + 50,\n\t                        data: 'rectangle',\n\t                        fill: {\n\t                            color: \"#778899\"\n\t                        }\n\t                    });\n\t                }\n\n\t                shape = this._addShape(diagram, p, node.id, opt);\n\t                //shape.content(node.id);\n\n\t                var bounds = shape.bounds();\n\t                if (Utils.isDefined(bounds)) {\n\t                    node.x = bounds.x;\n\t                    node.y = bounds.y;\n\t                    node.width = bounds.width;\n\t                    node.height = bounds.height;\n\t                }\n\t                map[node.id] = shape;\n\t            }\n\t            for (var gli = 0; gli < graph.links.length; gli++) {\n\t                var link = graph.links[gli];\n\t                var sourceShape = map[link.source.id];\n\t                if (Utils.isUndefined(sourceShape)) {\n\t                    continue;\n\t                }\n\t                var targetShape = map[link.target.id];\n\t                if (Utils.isUndefined(targetShape)) {\n\t                    continue;\n\t                }\n\t                this._addConnection(diagram, sourceShape, targetShape, {id: link.id});\n\n\t            }\n\t            if (doLayout) {\n\t                var l = new diagram.SpringLayout(diagram);\n\t                l.layoutGraph(graph, {limitToView: false});\n\t                for (var shi = 0; shi < graph.nodes.length; shi++) {\n\t                    node = graph.nodes[shi];\n\t                    shape = map[node.id];\n\t                    shape.bounds(new Rect(node.x, node.y, node.width, node.height));\n\t                }\n\t            }\n\t        },\n\n\t        /**\n\t         * Creates a balanced tree with the specified number of levels and siblings count.\n\t         * Note that for a balanced tree of level N and sibling count s, counting the root as level zero:\n\t         *  - NodeCount = (1-s^(N+1))/(1-s)]\n\t         *  - LinkCount = s.(1-s^N)/(1-s)\n\t         * @param levels How many levels the tree should have.\n\t         * @param siblingsCount How many siblings each level should have.\n\t         * @returns {diagram.Graph}\n\t         */\n\t        createBalancedTree: function (levels, siblingsCount) {\n\t            if (Utils.isUndefined(levels)) {\n\t                levels = 3;\n\t            }\n\t            if (Utils.isUndefined(siblingsCount)) {\n\t                siblingsCount = 3;\n\t            }\n\n\t            var g = new diagram.Graph(), counter = -1, lastAdded = [], news;\n\t            if (levels <= 0 || siblingsCount <= 0) {\n\t                return g;\n\t            }\n\t            var root = new Node((++counter).toString());\n\t            g.addNode(root);\n\t            g.root = root;\n\t            lastAdded.push(root);\n\t            for (var i = 0; i < levels; i++) {\n\t                news = [];\n\t                for (var j = 0; j < lastAdded.length; j++) {\n\t                    var parent = lastAdded[j];\n\t                    for (var k = 0; k < siblingsCount; k++) {\n\t                        var item = new Node((++counter).toString());\n\t                        g.addLink(parent, item);\n\t                        news.push(item);\n\t                    }\n\t                }\n\t                lastAdded = news;\n\t            }\n\t            return g;\n\t        },\n\n\t        /**\n\t         * Creates a balanced tree with the specified number of levels and siblings count.\n\t         * Note that for a balanced forest of level N, sibling count s and tree count t, counting the root as level zero:\n\t         *  - NodeCount = t.(1-s^(N+1))/(1-s)]\n\t         *  - LinkCount = t.s.(1-s^N)/(1-s)\n\t         * @param levels How many levels the tree should have.\n\t         * @param siblingsCount How many siblings each level should have.\n\t         * @returns {diagram.Graph}\n\t         * @param treeCount The number of trees the forest should have.\n\t         */\n\t        createBalancedForest: function (levels, siblingsCount, treeCount) {\n\t            if (Utils.isUndefined(levels)) {\n\t                levels = 3;\n\t            }\n\t            if (Utils.isUndefined(siblingsCount)) {\n\t                siblingsCount = 3;\n\t            }\n\t            if (Utils.isUndefined(treeCount)) {\n\t                treeCount = 5;\n\t            }\n\t            var g = new diagram.Graph(), counter = -1, lastAdded = [], news;\n\t            if (levels <= 0 || siblingsCount <= 0 || treeCount <= 0) {\n\t                return g;\n\t            }\n\n\t            for (var t = 0; t < treeCount; t++) {\n\t                var root = new Node((++counter).toString());\n\t                g.addNode(root);\n\t                lastAdded = [root];\n\t                for (var i = 0; i < levels; i++) {\n\t                    news = [];\n\t                    for (var j = 0; j < lastAdded.length; j++) {\n\t                        var parent = lastAdded[j];\n\t                        for (var k = 0; k < siblingsCount; k++) {\n\t                            var item = new Node((++counter).toString());\n\t                            g.addLink(parent, item);\n\t                            news.push(item);\n\t                        }\n\t                    }\n\t                    lastAdded = news;\n\t                }\n\t            }\n\t            return g;\n\t        },\n\n\t        /**\n\t         * Creates a random graph (uniform distribution) with the specified amount of nodes.\n\t         * @param nodeCount The amount of nodes the random graph should have.\n\t         * @param maxIncidence The maximum allowed degree of the nodes.\n\t         * @param isTree Whether the return graph should be a tree (default: false).\n\t         * @returns {diagram.Graph}\n\t         */\n\t        createRandomConnectedGraph: function (nodeCount, maxIncidence, isTree) {\n\n\t            /* Swa's Mathematica export of random Bernoulli graphs\n\t             gr[n_,p_]:=Module[{g=RandomGraph[BernoulliGraphDistribution[n,p],VertexLabels->\"Name\",DirectedEdges->True]},\n\t             While[Not[ConnectedGraphQ[g]],g=RandomGraph[BernoulliGraphDistribution[n,p],VertexLabels->\"Name\",DirectedEdges->True]];g];\n\t             project[a_]:=(\"\\\"\"<>ToString[Part[#,1]]<>\"->\"<>ToString[Part[#,2]]<>\"\\\"\")&     @ a;\n\t             export[g_]:=project/@ EdgeList[g]\n\t             g = gr[12,.1]\n\t             export [g]\n\t             */\n\n\t            if (Utils.isUndefined(nodeCount)) {\n\t                nodeCount = 40;\n\t            }\n\t            if (Utils.isUndefined(maxIncidence)) {\n\t                maxIncidence = 4;\n\t            }\n\t            if (Utils.isUndefined(isTree)) {\n\t                isTree = false;\n\t            }\n\n\t            var g = new diagram.Graph(), counter = -1;\n\t            if (nodeCount <= 0) {\n\t                return g;\n\t            }\n\n\t            var root = new Node((++counter).toString());\n\t            g.addNode(root);\n\t            if (nodeCount === 1) {\n\t                return g;\n\t            }\n\t            if (nodeCount > 1) {\n\t                // random tree\n\t                for (var i = 1; i < nodeCount; i++) {\n\t                    var poolNode = g.takeRandomNode([], maxIncidence);\n\t                    if (!poolNode) {\n\t                        //failed to find one so the graph will have less nodes than specified\n\t                        break;\n\t                    }\n\t                    var newNode = g.addNode(i.toString());\n\t                    g.addLink(poolNode, newNode);\n\t                }\n\t                if (!isTree && nodeCount > 1) {\n\t                    var randomAdditions = Utils.randomInteger(1, nodeCount);\n\t                    for (var ri = 0; ri < randomAdditions; ri++) {\n\t                        var n1 = g.takeRandomNode([], maxIncidence);\n\t                        var n2 = g.takeRandomNode([], maxIncidence);\n\t                        if (n1 && n2 && !g.areConnected(n1, n2)) {\n\t                            g.addLink(n1, n2);\n\t                        }\n\t                    }\n\t                }\n\t                return g;\n\t            }\n\t        },\n\n\t        /**\n\t         * Generates a random diagram.\n\t         * @param diagram The host diagram.\n\t         * @param shapeCount The number of shapes the random diagram should contain.\n\t         * @param maxIncidence The maximum degree the shapes can have.\n\t         * @param isTree Whether the generated diagram should be a tree\n\t         * @param layoutType The optional layout type to apply after the diagram is generated.\n\t         */\n\t        randomDiagram: function (diagram, shapeCount, maxIncidence, isTree, randomSize) {\n\t            var g = kendo.dataviz.diagram.Graph.Utils.createRandomConnectedGraph(shapeCount, maxIncidence, isTree);\n\t            Graph.Utils.createDiagramFromGraph(diagram, g, false, randomSize);\n\t        }\n\t    };\n\n\t    kendo.deepExtend(diagram, {\n\t        init: function (element) {\n\t            kendo.init(element, diagram.ui);\n\t        },\n\n\t        Point: Point,\n\t        Intersect: Intersect,\n\t        Geometry: Geometry,\n\t        Rect: Rect,\n\t        Size: Size,\n\t        RectAlign: RectAlign,\n\t        Matrix: Matrix,\n\t        MatrixVector: MatrixVector,\n\t        normalVariable: normalVariable,\n\t        randomId: randomId,\n\t        Dictionary: Dictionary,\n\t        HashTable: HashTable,\n\t        Queue: Queue,\n\t        Set: Set,\n\t        Node: Node,\n\t        Link: Link,\n\t        Graph: Graph,\n\t        PathDefiner: PathDefiner\n\t    });\n\t})(window.kendo.jQuery);\n\n\t}, __webpack_require__(3));\n\n\n/***/ }),\n\n/***/ 912:\n/***/ (function(module, exports) {\n\n\tmodule.exports = require(\"./utils\");\n\n/***/ })\n\n/******/ });"],"sourceRoot":""}