2622 	    if (element.waypoints) {
2675 	    if (element.waypoints && !stopRecursion) {
2676 	      bbox = getBBox(element.waypoints, true);
2729 	    if (e.waypoints) {
2829 	  var line = createLine(connection.waypoints, this.CONNECTION_STYLE);
2854 	  var waypoints = connection.waypoints;
2858 	  for (idx = 0; (point = waypoints[idx]); idx++) {
4276 	function filterRedundantWaypoints(waypoints) {  argument
4279 	  waypoints = waypoints.slice();
4286 	  while (waypoints[idx]) {
4287 	    point = waypoints[idx];
4288 	    previousPoint = waypoints[idx - 1];
4289 	    nextPoint = waypoints[idx + 1];
4296 	      waypoints.splice(idx, 1);
4302 	  return waypoints;
5547 	  if (element.waypoints) {
7183 	GraphicsFactory.prototype.getConnectionPath = function(waypoints) {  argument
7186 	  return eventBus.fire('render.getConnectionPath', waypoints);
17009 	  function drawLine(parentGfx, waypoints, attrs) {  argument
17016 	    var line = createLine(waypoints, attrs);
17180 	    var waypoints = connection.waypoints;
17182 	    var pathData = 'm  ' + waypoints[0].x + ',' + waypoints[0].y;
17183 	    for (var i = 1; i < waypoints.length; i++) {
17184 	      pathData += 'L' + waypoints[i].x + ',' + waypoints[i].y + ' ';
18078 	      return drawLine(parentGfx, element.waypoints, attrs);
19613 	function getFlowLabelPosition(waypoints) {  argument
19616 	  var mid = waypoints.length / 2 - 1;
19618 	  var first = waypoints[Math.floor(mid)];
19619 	  var second = waypoints[Math.ceil(mid + 0.01)];
19622 	  var position = getWaypointsMid(waypoints);
19646 	function getWaypointsMid(waypoints) {  argument
19648 	  var mid = waypoints.length / 2 - 1;
19650 	  var first = waypoints[Math.floor(mid)];
19651 	  var second = waypoints[Math.ceil(mid + 0.01)];
19662 	  if (element.waypoints) {
19663 	    return getFlowLabelPosition(element.waypoints);
19732 	  var waypoints = bo.di.waypoint;
19734 	  if (!waypoints || waypoints.length < 2) {
19738 	  return waypoints.map(function(p) {
19859 	      waypoints: getWaypoints(semantic, source, target)
20419 	    var waypoints = element.waypoints,
20423 	    if (waypoints) {
20424 	      return this.createWaypointsHit(gfx, waypoints);
20444 	  this.createWaypointsHit = function(gfx, waypoints) {  argument
20446 	    var hit = createLine(waypoints);
20498 	    if (element.waypoints) {
20499 	      updateLine(hit, element.waypoints);
21338 	  if (element.waypoints) {
21367 	    if (element.waypoints) {
21380 	    if (element.waypoints) {
25904 	    return !(element.waypoints || element.host || element.labelTarget);
28044 	function getBendpointIntersection(waypoints, reference) {  argument
28048 	  for (i = 0; (w = waypoints[i]); i++) {
28052 	        point: waypoints[i],
28062 	function getPathIntersection(waypoints, reference) {  argument
28064 …ar intersections = intersect(circlePath(reference, INTERSECTION_THRESHOLD$1), linePath(waypoints));
28086 	        point: waypoints[idx],
28118 	function getApproxIntersection(waypoints, reference) {  argument
28119 …return getBendpointIntersection(waypoints, reference) || getPathIntersection(waypoints, reference);
28148 	function getConnectionIntersection(canvas, waypoints, event) {  argument
28150 	      intersection = getApproxIntersection(waypoints, localPosition);
28401 	  function isIntersectionMiddle(intersection, waypoints, treshold) {  argument
28410 	    p0 = waypoints[idx - 1];
28411 	    p1 = waypoints[idx];
28424 	    var waypoints = connection.waypoints,
28433 	      start: waypoints[intersection.index - 1],
28434 	      end: waypoints[intersection.index]
28456 	    var waypoints = connection.waypoints,
28457 	        intersection = getConnectionIntersection(canvas, waypoints, event),
28466 	    if (isIntersectionMiddle(intersection, waypoints, threshold)) {
28512 	    connection.waypoints.forEach(function(p, idx) {
28526 	    var waypoints = connection.waypoints;
28532 	    for (var i = 1; i < waypoints.length; i++) {
28534 	      segmentStart = waypoints[i - 1];
28535 	      segmentEnd = waypoints[i];
28597 	  function updateSegmentDraggerPosition(parentGfx, intersection, waypoints) {  argument
28600 	        segmentStart = waypoints[intersection.index - 1],
28601 	        segmentEnd = waypoints[intersection.index],
28647 	    if (!element.waypoints) {
28663 	        waypoints = element.waypoints,
28667 	    if (waypoints) {
28670 	      intersection = getConnectionIntersection(canvas, waypoints, event.originalEvent);
28679 	        updateSegmentDraggerPosition(bendpointsGfx, intersection, waypoints);
28694 	    if (!element.waypoints) {
28705 	    if (primary && primary.waypoints) {
28713 	    if (element.waypoints) {
28728 	    if (element.waypoints) {
28778 	        waypoints = connection.waypoints,
28784 	    if (!insert && bendpointIndex === waypoints.length - 1) {
28892 	        newWaypoints = connection.waypoints.slice(),
28969 	  var waypoints = connection.waypoints;
28971 	  connection.waypoints = newWaypoints;
28973 	  connection.waypoints = connectionDocking.getCroppedWaypoints(connection);
28975 	  newWaypoints = connection.waypoints;
28977 	  connection.waypoints = waypoints;
29025 	        waypoints = connection.waypoints,
29026 	        newWaypoints = waypoints.slice();
29028 	    context.waypoints = waypoints;
29036 	    connection.waypoints = newWaypoints;
29094 	        newWaypoints = connection.waypoints.slice(),
29148 	      drawPreviewHints.waypoints = newWaypoints;
29165 	        waypoints = context.waypoints;
29167 	    connection.waypoints = waypoints;
29269 	        waypoints = connection.waypoints,
29270 	        segmentStart = waypoints[segmentStartIndex],
29271 	        segmentEnd = waypoints[segmentEndIndex],
29272 	        intersection = getConnectionIntersection(canvas, waypoints, event),
29289 	    if (segmentEndIndex === waypoints.length - 1) {
29339 	    var oldWaypoints = connection.waypoints,
29343 	    connection.waypoints = newWaypoints;
29348 	    connection.waypoints = oldWaypoints;
29385 	  function filterRedundantWaypoints(waypoints, segmentStartIndex) {
29389 	    var filteredWaypoints = waypoints.filter(function(r, idx) {
29390 	      if (pointsOnLine(waypoints[idx - 1], waypoints[idx + 1], r)) {
29402 	      waypoints: filteredWaypoints,
29413 	    context.originalWaypoints = connection.waypoints.slice();
29494 	    context.newWaypoints = connection.waypoints = cropConnection(connection, newWaypoints);
29546 	    connection.waypoints = context.originalWaypoints;
29572 	    var filteredWaypoints = filtered.waypoints,
29774 	        waypoints = connection.waypoints,
29786 	      waypoints[segmentStartIndex - 1],
29789 	      waypoints[segmentEndIndex + 1]
29796 	    if (segmentEndIndex > waypoints.length - 3) {
29866 	        waypoints = context.connection.waypoints,
29873 	    var referenceWaypoints = [ waypoints[bendpointIndex - 1], waypoints[bendpointIndex + 1] ];
30243 	      waypoints = hints.waypoints,
30274 	  connection.waypoints = waypoints || [];
30278 	    connection.waypoints = this._layouter.layoutConnection(connection, {
30283 	      waypoints: hints.waypoints || connection.waypoints
30288 	  if (!connection.waypoints || !connection.waypoints.length) {
30289 	    connection.waypoints = [
30297 	    connection.waypoints = this._connectionDocking.getCroppedWaypoints(connection, source, target);
30319 	  var waypoints = this.cropWaypoints(start, end, source, target);
30321 	  var connection = this.createNoopConnection(waypoints[0], waypoints[1]);
30340 	      connectionPath = graphicsFactory.getConnectionPath({ waypoints: [ start, end ] });
31975 	        element.waypoints = map$1(element.waypoints, function(waypoint) {
32037 	  return !!element.waypoints;
32074 	      if (element.waypoints) {
32929 	      descriptor.waypoints = copyWaypoints$1(element);
33067 	      element.waypoints = map$1(element.waypoints, function(waypoint) {
33371 	  return !!element.waypoints;
33379 	  return map$1(element.waypoints, function(waypoint) {
33896 	  if (oldElement.waypoints) {
35896 	  if (element.waypoints) {
36558 	      if (element.waypoints || element.labelTarget) {
37920 	        waypoints = connection.waypoints;
37926 	    if (!hasMiddleSegments(waypoints)) {
37930 	    modeling.updateWaypoints(connection, self.snapMiddleSegments(waypoints));
37949 	LayoutConnectionBehavior.prototype.snapMiddleSegments = function(waypoints) {  argument
37953 	  waypoints = waypoints.slice();
37955 	  for (var i = 1; i < waypoints.length - 2; i++) {
37957 	    snapped = snapSegment(gridSnapping, waypoints[i], waypoints[i + 1]);
37959 	    waypoints[i] = snapped[0];
37960 	    waypoints[i + 1] = snapped[1];
37963 	  return waypoints;
37976 	function hasMiddleSegments(waypoints) {  argument
37977 	  return waypoints.length > 3;
39850 	      return c.waypoints[c.waypoints.length - 2 ];
39853 	      return c.waypoints[1];
40688 	  return !!element.waypoints;
41262 	    var waypoints = targetFlow.waypoints,
41281 	    var intersection = getApproxIntersection(waypoints, mid);
41284 	      waypointsBefore = waypoints.slice(0, intersection.index);
41285 	      waypointsAfter = waypoints.slice(intersection.index + (intersection.bendpoint ? 1 : 0));
41292 	      dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : mid;
41326 	          shape, target, { type: targetFlow.type, waypoints: waypointsAfter }
41360 	    if (newParent && newParent.waypoints) {
41375 	      return canInsert && getApproxIntersection(element.waypoints, newShapeMid);
41795 	    var waypoints = connection.waypoints;
41798 	      waypoints[0],
41799 	      waypoints[1],
41804 	      waypoints[waypoints.length - 1],
41805 	      waypoints[waypoints.length - 2],
41814 	    if (element.waypoints) {
42387 	function relativePositionMidWaypoint(waypoints, idx) {  argument
42389 	  var distanceSegment1 = getDistancePointPoint(waypoints[idx-1], waypoints[idx]),
42390 	      distanceSegment2 = getDistancePointPoint(waypoints[idx], waypoints[idx+1]);
42410 	function getLine(waypoints, idx) {  argument
42411 	  return [ waypoints[idx], waypoints[idx+1] ];
42695 	        newWaypoints = context.newWaypoints || connection.waypoints,
42908 	  var waypoints = safeGetWaypoints(connection),
42909 	      waypointsInsideNewBounds = getWaypointsInsideBounds(waypoints, shape),
42910 	      oldAnchor = waypoints[0];
42923 	  var waypoints = safeGetWaypoints(connection),
42924 	      waypointsInsideNewBounds = getWaypointsInsideBounds(waypoints, shape),
42925 	      oldAnchor = waypoints[waypoints.length - 1];
42938 	  var waypoints = safeGetWaypoints(connection),
42940 	      oldAnchor = waypoints[ 0 ];
42948 	  var waypoints = safeGetWaypoints(connection),
42950 	      oldAnchor = waypoints[ waypoints.length - 1 ];
42977 	  var waypoints = connection.waypoints;
42979 	  if (!waypoints.length) {
42983 	  return waypoints;
42986 	function getWaypointsInsideBounds(waypoints, bounds) {  argument
42987 	  var originalWaypoints = map$1(waypoints, getOriginal);
43186 	        waypoints: connection.waypoints.slice()
43208 	      waypoints: connection.waypoints.slice()
43580 	    return !s.hidden && !s.waypoints && (is$1(s, 'bpmn:FlowElement') || is$1(s, 'bpmn:Artifact'));
43693 	      var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);
44700 	  return element.waypoints;
47675 	  return !!element.waypoints;
47970 	  return element.waypoints;
48070 	BpmnFactory.prototype.createDiWaypoints = function(waypoints) {  argument
48073 	  return map$1(waypoints, function(pos) {
48083 	BpmnFactory.prototype.createDiEdge = function(semantic, waypoints, attrs) {  argument
48122 	      connection.waypoints = connectionDocking.getCroppedWaypoints(connection);
48684 …ction.businessObject.di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));
49176 	  if (!connection.waypoints) {
49177 	    connection.waypoints = this._layouter.layoutConnection(connection, hints);
49232 	      element.waypoints = map$1(element.waypoints, function(waypoint) {
49300 	  return !!element.waypoints;
49517 	    if (element.waypoints) {
49610 	  return element.waypoints;
49776 	  var oldWaypoints = connection.waypoints;
49782 	  connection.waypoints = this._layouter.layoutConnection(connection, context.hints);
49791 	  connection.waypoints = context.oldWaypoints;
49825 	  forEach(connection.waypoints, function(p) {
49856 	  forEach(connection.waypoints, function(p) {
50134 	    context.oldWaypoints = connection.waypoints;
50135 	    connection.waypoints = dockingOrPoints;
50183 	    layoutConnectionHints.waypoints = hints.newWaypoints;
50204 	    connection.waypoints = oldWaypoints;
50548 	        waypoints = copyWaypoints(connection),
50557 	      waypoints = map$1(waypoints, function(waypoint) {
50573 	      self._modeling.updateWaypoints(connection, waypoints, {
50606 	  return map$1(connection.waypoints, function(waypoint) {
50832 	  context.oldWaypoints = connection.waypoints;
50834 	  connection.waypoints = newWaypoints;
50844 	  connection.waypoints = oldWaypoints;
52312 	  return !!element.waypoints;
52757 	    waypoints: getBendpoints(a, segmentEnd, segmentDirections).concat(segmentEnd),
52771 	    waypoints: invertedSegment.waypoints.slice().reverse(),
52793 	    startSegment.waypoints[startSegment.waypoints.length - 1],
52794 	    endSegment.waypoints[0],
52799 	    waypoints: bendpoints,
52892 	      startSegment.waypoints,
52893 	      midSegment.waypoints,
52894 	      endSegment.waypoints
52983 	function repairConnection(source, target, start, end, waypoints, hints) {  argument
52986 	    waypoints = start;
52994 	  waypoints = waypoints || [];
53011 … repairedWaypoints = hints.connectionEnd && tryRepairConnectionEnd(target, source, end, waypoints);
53018 …redWaypoints = hints.connectionStart && tryRepairConnectionStart(source, target, start, waypoints);
53025 	  if (!hints.connectionStart && !hints.connectionEnd && waypoints && waypoints.length) {
53026 	    return waypoints;
53153 	  var waypoints = points.slice().reverse();
53155 	  waypoints = _tryRepairConnectionSide(moved, other, newDocking, waypoints);
53157 	  return waypoints ? waypoints.reverse() : null;
53385 	function withoutRedundantPoints(waypoints) {  argument
53386 	  return waypoints.reduce(function(points, p, idx) {
53389 	        next = waypoints[idx + 1];
53433 	      waypoints = hints.waypoints || connection.waypoints,
53441 	    connectionStart = getConnectionDocking(waypoints && waypoints[ 0 ], source);
53445 	    connectionEnd = getConnectionDocking(waypoints && waypoints[ waypoints.length - 1 ], target);
53454 	    if (waypoints && !isCompensationAssociation(source, target)) {
53455 	      return [].concat([ connectionStart ], waypoints.slice(1, -1), [ connectionEnd ]);
53500 	      waypoints,
53626 	  var waypoints = connection.waypoints;
53628 	  var orientation = waypoints && waypoints.length && getOrientation(waypoints[0], source);
53808 	  var croppedWaypoints = connection.waypoints.slice(sourceDocking.idx + 1, targetDocking.idx);
53823 	  var waypoints = connection.waypoints,
53828 	  dockingIdx = dockStart ? 0 : waypoints.length - 1;
53829 	  dockingPoint = waypoints[dockingIdx];
54077 	    if (element.waypoints || !element.parent) {
54361 	  return element.waypoints;
56219 	      if (snapTarget.waypoints.length < 3) {
56224 	      var waypoints = snapTarget.waypoints.slice(1, -1);
56226 	      forEach(waypoints, function(waypoint) {
56258 	  return !!element.waypoints;
56319 	    var docking = connection.waypoints[0];
56327 	    var docking = connection.waypoints[connection.waypoints.length - 1];
56370 	      var docking = connection.waypoints[0];
56382 	      var docking = connection.waypoints[ connection.waypoints.length - 1 ];
56625 	  return !!element.waypoints;