@ankhorage/zora 26.0.0 → 26.0.2

package/web-dist/components/graph-view/GraphView.js

@@ -94572,6 +94572,11 @@ var gcdMultipleZeroIfNonInt = function gcdMultipleZeroIfNonInt(arr) {
   }
   return out;
 };
+var isIntegerMultiple = function isIntegerMultiple(a, b) {
+  var ratio = a / b;
+  var nearest = Math.round(ratio);
+  return nearest >= 1 && Math.abs(ratio - nearest) < 0.000001;
+};
 var deg2rad = function deg2rad(deg) {
   return Math.PI * deg / 180;
 };
@@ -95499,6 +95504,39 @@ var getBarrelCurveConstants = function getBarrelCurveConstants(width, height) {
     ctrlPtOffsetPct: 0.05
   };
 };
+var getRotatedLabelBox$1 = function getRotatedLabelBox(bb, lx, ly, theta, ox, oy, th) {
+  var lx1 = bb.x1 - th - ox;
+  var lx2 = bb.x2 + th - ox;
+  var ly1 = bb.y1 - th - oy;
+  var ly2 = bb.y2 + th - oy;
+  if (theta) {
+    var cos = Math.cos(theta);
+    var sin = Math.sin(theta);
+    var rotate = function rotate(x, y) {
+      x = x - lx;
+      y = y - ly;
+      return {
+        x: x * cos - y * sin + lx + ox,
+        y: x * sin + y * cos + ly + oy
+      };
+    };
+    return [rotate(lx1, ly1), rotate(lx2, ly1), rotate(lx2, ly2), rotate(lx1, ly2)];
+  } else {
+    return [{
+      x: lx1 + ox,
+      y: ly1 + oy
+    }, {
+      x: lx2 + ox,
+      y: ly1 + oy
+    }, {
+      x: lx2 + ox,
+      y: ly2 + oy
+    }, {
+      x: lx1 + ox,
+      y: ly2 + oy
+    }];
+  }
+};
 function satPolygonIntersection(poly1, poly2) {
   function getAxes(polygon) {
     var axes = [];
@@ -95563,6 +95601,37 @@ function satPolygonIntersection(poly1, poly2) {
   }
   return true;
 }
+function doLinesIntersect(p1, p2, q1, q2) {
+  function ccw(a, b, c) {
+    return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
+  }
+  return ccw(p1, q1, q2) !== ccw(p2, q1, q2) && ccw(p1, p2, q1) !== ccw(p1, p2, q2);
+}
+function pointInPolygon(point, polygon) {
+  var inside = false;
+  for (var i = 0, j = polygon.length - 1;i < polygon.length; j = i++) {
+    var pi = polygon[i];
+    var pj = polygon[j];
+    var intersects = pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x;
+    if (intersects) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function segmentIntersectsPolygon(p1, p2, polygon) {
+  if (pointInPolygon(p1, polygon)) {
+    return true;
+  }
+  for (var i = 0;i < polygon.length; i++) {
+    var q1 = polygon[i];
+    var q2 = polygon[(i + 1) % polygon.length];
+    if (doLinesIntersect(p1, p2, q1, q2)) {
+      return true;
+    }
+  }
+  return false;
+}
 var pageRankDefaults = defaults$g({
   dampingFactor: 0.8,
   precision: 0.000001,
@@ -95603,7 +95672,7 @@ var elesfn$o = {
       matrix[_n] += w;
       columnSum[s] += w;
     }
-    var p = 1 / numNodes + additionalProb;
+    var p = dampingFactor / numNodes + additionalProb;
     for (var _j = 0;_j < numNodes; _j++) {
       if (columnSum[_j] === 0) {
         for (var _i2 = 0;_i2 < numNodes; _i2++) {
@@ -95613,7 +95682,7 @@ var elesfn$o = {
       } else {
         for (var _i3 = 0;_i3 < numNodes; _i3++) {
           var _n3 = _i3 * numNodes + _j;
-          matrix[_n3] = matrix[_n3] / columnSum[_j] + additionalProb;
+          matrix[_n3] = dampingFactor * matrix[_n3] / columnSum[_j] + additionalProb;
         }
       }
     }
@@ -96375,6 +96444,9 @@ var kMedoids = function kMedoids(options) {
   var nodes = this.nodes();
   var node = null;
   var opts = setOptions$2(options);
+  if (opts.k > nodes.length) {
+    error("kMedoids: k (".concat(opts.k, ") cannot exceed the number of nodes (").concat(nodes.length, ")."));
+  }
   var clusters = new Array(opts.k);
   var medoids;
   var assignment = {};
@@ -96588,12 +96660,14 @@ var mergeClosest = function mergeClosest(clusters, index, dists, mins, opts) {
     merged = {
       left: c1,
       right: c2,
-      key: c1.key
+      key: c1.key,
+      size: c1.size + c2.size
     };
   } else {
     merged = {
       value: c1.value.concat(c2.value),
-      key: c1.key
+      key: c1.key,
+      size: c1.size + c2.size
     };
   }
   clusters[c1.index] = merged;
@@ -96719,6 +96793,9 @@ var _buildClustersFromTree = function buildClustersFromTree(root, k, cy) {
 var hierarchicalClustering = function hierarchicalClustering(options) {
   var cy = this.cy();
   var nodes = this.nodes();
+  if (nodes.length === 0) {
+    return [];
+  }
   var opts = setOptions$1(options);
   var attrs = opts.attributes;
   var getDist = function getDist(n1, n2) {
@@ -96736,7 +96813,8 @@ var hierarchicalClustering = function hierarchicalClustering(options) {
     var cluster = {
       value: opts.mode === "dendrogram" ? nodes[n] : [nodes[n]],
       key: n,
-      index: n
+      index: n,
+      size: 1
     };
     clusters[n] = cluster;
     index[n] = cluster;
@@ -99802,7 +99880,8 @@ var valCmp = function valCmp(fieldVal, operator, value) {
     operator = operator.replace("@", "");
     caseInsensitive = true;
   }
-  if (isFieldStr || isValStr || caseInsensitive) {
+  var isSubstrCmp = operator === "*=" || operator === "^=" || operator === "$=";
+  if (isFieldStr || isValStr || caseInsensitive || isSubstrCmp) {
     fieldStr = !isFieldStr && !isFieldNum ? "" : "" + fieldVal;
     valStr = "" + value;
   }
@@ -100489,6 +100568,9 @@ var beforePositionSet = function beforePositionSet(eles, newPos, silent) {
         ele.children().shift(delta, silent);
       }
       ele.dirtyBoundingBoxCache();
+      if (ele.isNode()) {
+        ele.connectedEdges().dirtyBoundingBoxCache();
+      }
     }
   }
 };
@@ -100756,6 +100838,29 @@ elesfn$b.renderedBoundingBox = function(options) {
     h: y2 - y1
   };
 };
+var getLabelPolygon = function getLabelPolygon(ele) {
+  var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "main";
+  if (!ele || !ele.cy().styleEnabled()) {
+    return null;
+  }
+  var prefix = label === "main" ? undefined : label;
+  var _p = ele._private;
+  var cache = _p.labelPolygonCache;
+  var posKey = getLabelPolygonPosKey(ele);
+  var isDirty = cache == null || cache[label] == null || _p.styleDirty || _p.labelPolygonPosKey !== posKey;
+  if (!isDirty) {
+    return cache[label];
+  }
+  ele.recalculateRenderedStyle();
+  posKey = getLabelPolygonPosKey(ele);
+  if (_p.labelPolygonCache == null || _p.labelPolygonPosKey !== posKey) {
+    _p.labelPolygonCache = {};
+    _p.labelPolygonPosKey = posKey;
+  }
+  var polygon = getRotatedLabelBox(ele, prefix);
+  _p.labelPolygonCache[label] = polygon;
+  return polygon;
+};
 elesfn$b.dirtyCompoundBoundsCache = function() {
   var silent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
   var cy = this.cy();
@@ -100922,13 +101027,39 @@ var updateBoundsFromBox = function updateBoundsFromBox(b, b2) {
 var prefixedProperty = function prefixedProperty(obj, field, prefix) {
   return getPrefixedProperty(obj, field, prefix);
 };
+var getRotatedLabelBox = function getRotatedLabelBox(ele, prefix) {
+  if (ele.cy().headless()) {
+    return;
+  }
+  var _p = ele._private;
+  var prefixDash = prefix ? prefix + "-" : "";
+  var label = ele.pstyle(prefixDash + "label").strValue;
+  if (!label) {
+    return null;
+  }
+  ele.boundingBox({
+    includeLabels: true
+  });
+  var bbPrefix = prefix || "main";
+  var bb = _p.labelBounds[bbPrefix];
+  if (!bb) {
+    return null;
+  }
+  var lx = prefixedProperty(_p.rscratch, "labelX", prefix);
+  var ly = prefixedProperty(_p.rscratch, "labelY", prefix);
+  var theta = prefixedProperty(_p.rscratch, "labelAngle", prefix);
+  var ox = ele.pstyle(prefixDash + "text-margin-x").pfValue;
+  var oy = ele.pstyle(prefixDash + "text-margin-y").pfValue;
+  return getRotatedLabelBox$1(bb, lx, ly, theta, ox, oy, 0);
+};
 var updateBoundsFromArrow = function updateBoundsFromArrow(bounds, ele, prefix) {
   if (ele.cy().headless()) {
     return;
   }
   var _p = ele._private;
   var rstyle = _p.rstyle;
-  var halfArW = rstyle.arrowWidth / 2;
+  var arW = rstyle.arrowWidths != null && rstyle.arrowWidths[prefix] != null ? rstyle.arrowWidths[prefix] : rstyle.arrowWidth;
+  var halfArW = arW / 2;
   var arrowType = ele.pstyle(prefix + "-arrow-shape").value;
   var x;
   var y;
@@ -101420,6 +101551,17 @@ var cachedBoundingBoxImpl = function cachedBoundingBoxImpl(ele, opts) {
   }
   return bb;
 };
+var getLabelPolygonPosKey = function getLabelPolygonPosKey(ele) {
+  var angle = ele.pstyle("text-rotation").pfValue || 0;
+  if (ele.isEdge()) {
+    var p1 = ele.source().position();
+    var p2 = ele.target().position();
+    return hashIntsArray([Math.round(p1.x), Math.round(p1.y), Math.round(p2.x), Math.round(p2.y), Math.round(angle * 1000)]);
+  } else {
+    var pos = ele.position();
+    return hashIntsArray([Math.round(pos.x), Math.round(pos.y), Math.round(angle * 1000)]);
+  }
+};
 var defBbOpts = {
   includeNodes: true,
   includeEdges: true,
@@ -101497,6 +101639,8 @@ elesfn$b.dirtyBoundingBoxCache = function() {
     _p.arrowBounds.target = null;
     _p.arrowBounds["mid-source"] = null;
     _p.arrowBounds["mid-target"] = null;
+    _p.labelPolygonCache = {};
+    _p.labelPolygonPosKey = null;
   }
   this.emitAndNotify("bounds");
   return this;
@@ -102397,6 +102541,120 @@ var elesfn$8 = {
       value: min,
       ele: minEle
     };
+  },
+  withinBox: function withinBox(box) {
+    var cy = this.cy();
+    var r = cy.renderer();
+    if (cy.styleEnabled()) {
+      this.recalculateRenderedStyle();
+    }
+    var x2 = box.x2 != null ? box.x2 : box.x1 + box.w;
+    var y2 = box.y2 != null ? box.y2 : box.y1 + box.h;
+    var bb = makeBoundingBox({
+      x1: Math.min(box.x1, x2),
+      x2: Math.max(box.x1, x2),
+      y1: Math.min(box.y1, y2),
+      y2: Math.max(box.y1, y2)
+    });
+    var allInBox = r.getAllInBox(bb.x1, bb.y1, bb.x2, bb.y2);
+    var col = this;
+    return this.spawn(allInBox.filter(function(ele) {
+      return col.has(ele);
+    }));
+  },
+  hit: function hit(pos, options) {
+    var cy = this.cy();
+    var r = cy.renderer();
+    if (cy.styleEnabled()) {
+      this.recalculateRenderedStyle();
+    }
+    return this.spawn(r.hitTestAt(pos.x, pos.y, this, options));
+  },
+  polygonIntersection: function polygonIntersection(polygon) {
+    var eles = this;
+    var cy = eles.cy();
+    if (cy.styleEnabled()) {
+      this.recalculateRenderedStyle();
+    }
+    var matches = [];
+    for (var i = 0;i < eles.length; i++) {
+      var ele = eles[i];
+      ele.boundingBox();
+      if (ele.isEdge()) {
+        var rs = ele._private.rscratch;
+        var rstyle = ele._private.rstyle;
+        var pts = rstyle.bezierPts || rstyle.linePts || rstyle.haystackPts;
+        if (rstyle.bezierPts && rs.allpts && rs.allpts.length >= 6) {
+          var spans = (rs.allpts.length - 2) / 4;
+          var samplesPerSpan = rstyle.bezierPts.length / spans;
+          pts = [{
+            x: rs.allpts[0],
+            y: rs.allpts[1]
+          }];
+          for (var k = 0;k < spans; k++) {
+            for (var j = 0;j < samplesPerSpan; j++) {
+              pts.push(rstyle.bezierPts[k * samplesPerSpan + j]);
+            }
+            pts.push({
+              x: rs.allpts[k * 4 + 4],
+              y: rs.allpts[k * 4 + 5]
+            });
+          }
+        }
+        if ((!pts || pts.length < 2) && rs.startX != null && rs.startY != null && rs.endX != null && rs.endY != null) {
+          pts = [{
+            x: rs.startX,
+            y: rs.startY
+          }, {
+            x: rs.endX,
+            y: rs.endY
+          }];
+        }
+        if (pts && pts.length > 1) {
+          var bodyMatched = false;
+          for (var _k = 0;_k < pts.length - 1 && !bodyMatched; _k++) {
+            if (segmentIntersectsPolygon(pts[_k], pts[_k + 1], polygon)) {
+              matches.push(ele);
+              bodyMatched = true;
+            }
+          }
+          if (bodyMatched) {
+            continue;
+          }
+        }
+      } else {
+        var bb = ele._private.bodyBounds;
+        if (bb) {
+          var bodyPoly = [{
+            x: bb.x1,
+            y: bb.y1
+          }, {
+            x: bb.x2,
+            y: bb.y1
+          }, {
+            x: bb.x2,
+            y: bb.y2
+          }, {
+            x: bb.x1,
+            y: bb.y2
+          }];
+          if (satPolygonIntersection(bodyPoly, polygon)) {
+            matches.push(ele);
+            continue;
+          }
+        }
+      }
+      var labels = ele.isEdge() ? ["main", "source", "target"] : ["main"];
+      var labelMatched = false;
+      for (var _j = 0;_j < labels.length && !labelMatched; _j++) {
+        var labelPoly = getLabelPolygon(ele, labels[_j]);
+        if (labelPoly && labelPoly.length && satPolygonIntersection(labelPoly, polygon)) {
+          matches.push(ele);
+          labelMatched = true;
+        }
+      }
+    }
+    return this.spawn(matches);
   }
 };
 var fn$1 = elesfn$8;
@@ -103971,7 +104229,7 @@ elesfn$1.remove = function() {
   var removeFromPool = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   var self2 = this;
   var elesToRemove = [];
-  var elesToRemoveIds = {};
+  var elesToRemoveIds = new Set$1;
   var cy = self2._private.cy;
   function addConnectedEdges(node) {
     var edges = node._private.edges;
@@ -103986,11 +104244,11 @@ elesfn$1.remove = function() {
     }
   }
   function add(ele) {
-    var alreadyAdded = elesToRemoveIds[ele.id()];
+    var alreadyAdded = elesToRemoveIds.has(ele.id());
     if (removeFromPool && ele.removed() || alreadyAdded) {
       return;
     } else {
-      elesToRemoveIds[ele.id()] = true;
+      elesToRemoveIds.add(ele.id());
     }
     if (ele.isNode()) {
       elesToRemove.push(ele);
@@ -104013,7 +104271,7 @@ elesfn$1.remove = function() {
     pllEdge.clearTraversalCache();
   }
   var alteredParents = [];
-  alteredParents.ids = {};
+  alteredParents.ids = new Set$1;
   function removeChildRef(parent, ele) {
     ele = ele[0];
     parent = parent[0];
@@ -104021,8 +104279,8 @@ elesfn$1.remove = function() {
     var pid = parent.id();
     removeFromArray(children, ele);
     ele._private.parent = null;
-    if (!alteredParents.ids[pid]) {
-      alteredParents.ids[pid] = true;
+    if (!alteredParents.ids.has(pid)) {
+      alteredParents.ids.add(pid);
       alteredParents.push(parent);
     }
   }
@@ -104190,9 +104448,23 @@ var corefn$9 = {
     return collection.remove();
   }
 };
-/*! Bezier curve function generator. Copyright Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License */
+/*! Bezier curve function generator. Copyright 2014-2026 Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License
+ * https://github.com/gre/bezier-easing */
+var cbrt = Math.cbrt || function(x) {
+  return x < 0 ? -Math.pow(-x, 1 / 3) : Math.pow(x, 1 / 3);
+};
+function solveTForX(x, a, b, c) {
+  var j = 1 / Math.max(c, Math.sqrt(x)), k = x * j, l = k * j, s = c * j, q = b * l, m = s * s + q, h = -s * (s * s + 1.5 * q) - a * k * l, D = h * h - m * m * m, v;
+  if (m === 0 || D > 0.000000000001 * h * h) {
+    var U = -cbrt(h < 0 ? h - Math.sqrt(D) : h + Math.sqrt(D));
+    v = U + m / U || 0;
+  } else {
+    var r = Math.sqrt(m);
+    v = 2 * r * Math.cos(Math.acos(Math.max(-1, Math.min(1, -h / (m * r)))) / 3);
+  }
+  return Math.min(1, k / (v + s));
+}
 function generateCubicBezier(mX1, mY1, mX2, mY2) {
-  var NEWTON_ITERATIONS = 4, NEWTON_MIN_SLOPE = 0.001, SUBDIVISION_PRECISION = 0.0000001, SUBDIVISION_MAX_ITERATIONS = 10, kSplineTableSize = 11, kSampleStepSize = 1 / (kSplineTableSize - 1), float32ArraySupported = typeof Float32Array !== "undefined";
   if (arguments.length !== 4) {
     return false;
   }
@@ -104205,87 +104477,19 @@ function generateCubicBezier(mX1, mY1, mX2, mY2) {
   mX2 = Math.min(mX2, 1);
   mX1 = Math.max(mX1, 0);
   mX2 = Math.max(mX2, 0);
-  var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
-  function A(aA1, aA2) {
-    return 1 - 3 * aA2 + 3 * aA1;
-  }
-  function B(aA1, aA2) {
-    return 3 * aA2 - 6 * aA1;
-  }
-  function C(aA1) {
-    return 3 * aA1;
-  }
-  function calcBezier(aT, aA1, aA2) {
-    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
-  }
-  function getSlope(aT, aA1, aA2) {
-    return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
-  }
-  function newtonRaphsonIterate(aX, aGuessT) {
-    for (var _i = 0;_i < NEWTON_ITERATIONS; ++_i) {
-      var currentSlope = getSlope(aGuessT, mX1, mX2);
-      if (currentSlope === 0) {
-        return aGuessT;
-      }
-      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
-      aGuessT -= currentX / currentSlope;
-    }
-    return aGuessT;
-  }
-  function calcSampleValues() {
-    for (var _i2 = 0;_i2 < kSplineTableSize; ++_i2) {
-      mSampleValues[_i2] = calcBezier(_i2 * kSampleStepSize, mX1, mX2);
-    }
-  }
-  function binarySubdivide(aX, aA, aB) {
-    var currentX, currentT, i = 0;
-    do {
-      currentT = aA + (aB - aA) / 2;
-      currentX = calcBezier(currentT, mX1, mX2) - aX;
-      if (currentX > 0) {
-        aB = currentT;
-      } else {
-        aA = currentT;
-      }
-    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
-    return currentT;
-  }
-  function getTForX(aX) {
-    var intervalStart = 0, currentSample = 1, lastSample = kSplineTableSize - 1;
-    for (;currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
-      intervalStart += kSampleStepSize;
-    }
-    --currentSample;
-    var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]), guessForT = intervalStart + dist * kSampleStepSize, initialSlope = getSlope(guessForT, mX1, mX2);
-    if (initialSlope >= NEWTON_MIN_SLOPE) {
-      return newtonRaphsonIterate(aX, guessForT);
-    } else if (initialSlope === 0) {
-      return guessForT;
-    } else {
-      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);
-    }
-  }
-  var _precomputed = false;
-  function precompute() {
-    _precomputed = true;
-    if (mX1 !== mY1 || mX2 !== mY2) {
-      calcSampleValues();
-    }
-  }
+  var isLinear = mX1 === mY1 && mX2 === mY2, a = (3 * mX1 - 3 * mX2 + 1) / 2, b = mX2 - 2 * mX1, c = mX1, ay = 3 * mY1 - 3 * mY2 + 1, by = 3 * (mY2 - 2 * mY1), cy = 3 * mY1;
   var f = function f(aX) {
-    if (!_precomputed) {
-      precompute();
-    }
-    if (mX1 === mY1 && mX2 === mY2) {
+    if (isLinear) {
       return aX;
     }
-    if (aX === 0) {
+    if (aX <= 0) {
       return 0;
     }
-    if (aX === 1) {
+    if (aX >= 1) {
       return 1;
     }
-    return calcBezier(getTForX(aX), mY1, mY2);
+    var t = solveTForX(aX, a, b, c);
+    return ((ay * t + by) * t + cy) * t;
   };
   f.getControlPoints = function() {
     return [{
@@ -105434,12 +105638,12 @@ styfn$8.applyParsedProperty = function(ele, parsedProp) {
         var b2 = prop.valueMax[2];
         var a1 = prop.valueMin[3] == null ? 1 : prop.valueMin[3];
         var a2 = prop.valueMax[3] == null ? 1 : prop.valueMax[3];
-        var clr = [Math.round(r1 + (r2 - r1) * percent), Math.round(g1 + (g2 - g1) * percent), Math.round(b1 + (b2 - b1) * percent), Math.round(a1 + (a2 - a1) * percent)];
+        var clr = [Math.round(r1 + (r2 - r1) * percent), Math.round(g1 + (g2 - g1) * percent), Math.round(b1 + (b2 - b1) * percent), a1 + (a2 - a1) * percent];
         flatProp = {
           bypass: prop.bypass,
           name: prop.name,
           value: clr,
-          strValue: "rgb(" + clr[0] + ", " + clr[1] + ", " + clr[2] + ")"
+          strValue: "rgba(" + clr[0] + ", " + clr[1] + ", " + clr[2] + ", " + clr[3] + ")"
         };
       } else if (type.number) {
         var calcValue = prop.valueMin + (prop.valueMax - prop.valueMin) * percent;
@@ -105750,7 +105954,7 @@ styfn$7.overrideBypass = function(eles, name, value) {
         prop.pfValue = value;
       }
       if (isColor) {
-        prop.strValue = "rgb(" + value.join(",") + ")";
+        prop.strValue = value[3] == null ? "rgb(" + value[0] + "," + value[1] + "," + value[2] + ")" : "rgba(" + value[0] + "," + value[1] + "," + value[2] + "," + value[3] + ")";
       } else if (isMulti) {
         prop.strValue = value.join(" ");
       } else {
@@ -106084,6 +106288,16 @@ styfn$3.fromString = function(string) {
   style.appendFromString(string);
   return style;
 };
+var arrowPrefixes = ["source", "mid-source", "target", "mid-target"];
+var getArrowScale = function getArrowScale(edge, prefix) {
+  if (prefix != null) {
+    var prefixed = edge.pstyle(prefix + "-arrow-scale");
+    if (prefixed != null && prefixed.value !== "inherit") {
+      return prefixed.value;
+    }
+  }
+  return edge.pstyle("arrow-scale").value;
+};
 var styfn$2 = {};
 (function() {
   var number$1 = number;
@@ -106174,6 +106388,13 @@ var styfn$2 = {};
       min: 0,
       strictMin: true
     },
+    arrowScale: {
+      number: true,
+      unitless: true,
+      min: 0,
+      strictMin: true,
+      enums: ["inherit"]
+    },
     size: {
       number: true,
       min: 0
@@ -106712,6 +106933,18 @@ var styfn$2 = {};
   }, {
     name: "overlay-color",
     type: t.color
+  }, {
+    name: "overlay-fill",
+    type: t.fill
+  }, {
+    name: "overlay-gradient-stop-colors",
+    type: t.colors
+  }, {
+    name: "overlay-gradient-stop-positions",
+    type: t.percentages
+  }, {
+    name: "overlay-gradient-direction",
+    type: t.gradientDirection
   }, {
     name: "overlay-opacity",
     type: t.zeroOneNumber,
@@ -106731,6 +106964,18 @@ var styfn$2 = {};
   }, {
     name: "underlay-color",
     type: t.color
+  }, {
+    name: "underlay-fill",
+    type: t.fill
+  }, {
+    name: "underlay-gradient-stop-colors",
+    type: t.colors
+  }, {
+    name: "underlay-gradient-stop-positions",
+    type: t.percentages
+  }, {
+    name: "underlay-gradient-direction",
+    type: t.gradientDirection
   }, {
     name: "underlay-opacity",
     type: t.zeroOneNumber,
@@ -107168,7 +107413,7 @@ var styfn$2 = {};
     });
   }
   var edgeArrow = [];
-  var arrowPrefixes = styfn$2.arrowPrefixes = ["source", "mid-source", "target", "mid-target"];
+  styfn$2.arrowPrefixes = arrowPrefixes;
   [{
     name: "arrow-shape",
     type: t.arrowShape,
@@ -107182,6 +107427,10 @@ var styfn$2 = {};
   }, {
     name: "arrow-width",
     type: t.arrowWidth
+  }, {
+    name: "arrow-scale",
+    type: t.arrowScale,
+    triggersBounds: diff.any
   }].forEach(function(prop) {
     arrowPrefixes.forEach(function(prefix) {
       var name = prefix + "-" + prop.name;
@@ -107350,11 +107599,19 @@ styfn$2.getDefaultProperties = function() {
     "target-text-margin-y": 0,
     "overlay-opacity": 0,
     "overlay-color": "#000",
+    "overlay-fill": "solid",
+    "overlay-gradient-stop-colors": "#999",
+    "overlay-gradient-stop-positions": "0%",
+    "overlay-gradient-direction": "to-bottom",
     "overlay-padding": 10,
     "overlay-shape": "round-rectangle",
     "overlay-corner-radius": "auto",
     "underlay-opacity": 0,
     "underlay-color": "#000",
+    "underlay-fill": "solid",
+    "underlay-gradient-stop-colors": "#999",
+    "underlay-gradient-stop-positions": "0%",
+    "underlay-gradient-direction": "to-bottom",
     "underlay-padding": 10,
     "underlay-shape": "round-rectangle",
     "underlay-corner-radius": "auto",
@@ -107504,6 +107761,9 @@ styfn$2.getDefaultProperties = function() {
   }, {
     name: "arrow-width",
     value: 1
+  }, {
+    name: "arrow-scale",
+    value: "inherit"
   }].reduce(function(css, prop) {
     styfn$2.arrowPrefixes.forEach(function(prefix) {
       var name = prefix + "-" + prop.name;
@@ -107848,7 +108108,7 @@ styfn$1.parseImpl = function(name, value, propIsBypass, propIsFlat) {
       name,
       value: tuple,
       pfValue: tuple,
-      strValue: "rgb(" + tuple[0] + "," + tuple[1] + "," + tuple[2] + ")",
+      strValue: tuple[3] == null ? "rgb(" + tuple[0] + "," + tuple[1] + "," + tuple[2] + ")" : "rgba(" + tuple[0] + "," + tuple[1] + "," + tuple[2] + "," + tuple[3] + ")",
       bypass: propIsBypass
     };
   } else if (type.regex || type.regexes) {
@@ -109538,12 +109798,8 @@ function CoseLayout(options) {
   var notEdges = edges.filter(function(e) {
     var sourceId = e.source().data("id");
     var targetId = e.target().data("id");
-    var hasSource = nodes.some(function(n) {
-      return n.data("id") === sourceId;
-    });
-    var hasTarget = nodes.some(function(n) {
-      return n.data("id") === targetId;
-    });
+    var hasSource = nodes.hasElementWithId(sourceId);
+    var hasTarget = nodes.hasElementWithId(targetId);
     return !hasSource || !hasTarget;
   });
   this.options.eles = this.options.eles.not(notEdges);
@@ -110589,6 +110845,12 @@ NullRenderer.prototype = {
   isHeadless: function isHeadless() {
     return true;
   },
+  getAllInBox: function getAllInBox() {
+    return [];
+  },
+  hitTestAt: function hitTestAt() {
+    return [];
+  },
   png: throwImgErr,
   jpg: throwImgErr
 };
@@ -110634,8 +110896,8 @@ BRp$f.registerArrowShapes = function() {
     }
     return ret;
   };
-  var standardGap = function standardGap(edge) {
-    return edge.pstyle("width").pfValue * edge.pstyle("arrow-scale").pfValue * 2;
+  var standardGap = function standardGap(edge, prefix) {
+    return edge.pstyle("width").pfValue * getArrowScale(edge, prefix) * 2;
   };
   var defineArrowShape = function defineArrowShape(name, defn) {
     if (string(defn)) {
@@ -110654,7 +110916,7 @@ BRp$f.registerArrowShapes = function() {
         var points = transformPoints(this.points, size, angle, translation);
         renderer.arrowShapeImpl("polygon")(context, points);
       },
-      spacing: function spacing(edge) {
+      spacing: function spacing(edge, prefix) {
         return 0;
       },
       gap: standardGap
@@ -110681,8 +110943,8 @@ BRp$f.registerArrowShapes = function() {
       var ctrlPtTrans = transform(ctrlPt[0], ctrlPt[1], size, angle, translation);
       renderer.arrowShapeImpl(this.name)(context, ptsTrans, ctrlPtTrans);
     },
-    gap: function gap(edge) {
-      return standardGap(edge) * 0.8;
+    gap: function gap(edge, prefix) {
+      return standardGap(edge, prefix) * 0.8;
     }
   });
   defineArrowShape("triangle-tee", {
@@ -110713,8 +110975,8 @@ BRp$f.registerArrowShapes = function() {
       var triPts = transformPoints(this.pointsTr, size, angle, translation);
       renderer.arrowShapeImpl(this.name)(context, triPts, translation.x, translation.y, this.radius * size);
     },
-    spacing: function spacing(edge) {
-      return renderer.getArrowWidth(edge.pstyle("width").pfValue, edge.pstyle("arrow-scale").value) * this.radius;
+    spacing: function spacing(edge, prefix) {
+      return renderer.getArrowWidth(edge.pstyle("width").pfValue, getArrowScale(edge, prefix)) * this.radius;
     }
   });
   defineArrowShape("triangle-cross", {
@@ -110752,8 +111014,8 @@ BRp$f.registerArrowShapes = function() {
   });
   defineArrowShape("vee", {
     points: [-0.15, -0.3, 0, 0, 0.15, -0.3, 0, -0.15],
-    gap: function gap(edge) {
-      return standardGap(edge) * 0.525;
+    gap: function gap(edge, prefix) {
+      return standardGap(edge, prefix) * 0.525;
     }
   });
   defineArrowShape("circle", {
@@ -110766,16 +111028,16 @@ BRp$f.registerArrowShapes = function() {
     draw: function draw(context, size, angle, translation, edgeWidth) {
       renderer.arrowShapeImpl(this.name)(context, translation.x, translation.y, this.radius * size);
     },
-    spacing: function spacing(edge) {
-      return renderer.getArrowWidth(edge.pstyle("width").pfValue, edge.pstyle("arrow-scale").value) * this.radius;
+    spacing: function spacing(edge, prefix) {
+      return renderer.getArrowWidth(edge.pstyle("width").pfValue, getArrowScale(edge, prefix)) * this.radius;
     }
   });
   defineArrowShape("tee", {
     points: [-0.15, 0, -0.15, -0.1, 0.15, -0.1, 0.15, 0],
-    spacing: function spacing(edge) {
+    spacing: function spacing(edge, prefix) {
       return 1;
     },
-    gap: function gap(edge) {
+    gap: function gap(edge, prefix) {
       return 1;
     }
   });
@@ -110784,14 +111046,14 @@ BRp$f.registerArrowShapes = function() {
   });
   defineArrowShape("diamond", {
     points: [-0.15, -0.15, 0, -0.3, 0.15, -0.15, 0, 0],
-    gap: function gap(edge) {
-      return edge.pstyle("width").pfValue * edge.pstyle("arrow-scale").value;
+    gap: function gap(edge, prefix) {
+      return edge.pstyle("width").pfValue * getArrowScale(edge, prefix);
     }
   });
   defineArrowShape("chevron", {
     points: [0, 0, -0.15, -0.15, -0.1, -0.2, 0, -0.1, 0.1, -0.2, 0.15, -0.15],
-    gap: function gap(edge) {
-      return 0.95 * edge.pstyle("width").pfValue * edge.pstyle("arrow-scale").value;
+    gap: function gap(edge, prefix) {
+      return 0.95 * edge.pstyle("width").pfValue * getArrowScale(edge, prefix);
     }
   });
 };
@@ -110845,6 +111107,169 @@ BRp$e.findContainerClientCoords = function() {
 BRp$e.invalidateContainerClientCoordsCache = function() {
   this.containerBB = null;
 };
+BRp$e.getLabelHitPolygon = function(ele, prefix, th) {
+  var _p = ele._private;
+  var prefixDash = prefix ? prefix + "-" : "";
+  ele.boundingBox();
+  var bb = _p.labelBounds[prefix || "main"];
+  if (!bb) {
+    return null;
+  }
+  var lx = getPrefixedProperty(_p.rscratch, "labelX", prefix);
+  var ly = getPrefixedProperty(_p.rscratch, "labelY", prefix);
+  var theta = getPrefixedProperty(_p.rscratch, "labelAngle", prefix);
+  var ox = ele.pstyle(prefixDash + "text-margin-x").pfValue;
+  var oy = ele.pstyle(prefixDash + "text-margin-y").pfValue;
+  return getRotatedLabelBox$1(bb, lx, ly, theta, ox, oy, th);
+};
+BRp$e.checkLabelHitAt = function(ele, x, y, prefix, th) {
+  var prefixDash = prefix ? prefix + "-" : "";
+  var text = ele.pstyle(prefixDash + "label").value;
+  var eventsEnabled = ele.pstyle("text-events").strValue === "yes";
+  if (!eventsEnabled || !text) {
+    return false;
+  }
+  var polygon = this.getLabelHitPolygon(ele, prefix, th);
+  if (!polygon) {
+    return false;
+  }
+  var points = [];
+  for (var i = 0;i < polygon.length; i++) {
+    points.push(polygon[i].x, polygon[i].y);
+  }
+  return pointInsidePolygonPoints(x, y, points);
+};
+BRp$e.checkNodeHitAt = function(node, x, y, threshold) {
+  var r = this;
+  var width = node.outerWidth() + 2 * threshold;
+  var height = node.outerHeight() + 2 * threshold;
+  var pos = node.position();
+  if (pos.x - width / 2 <= x && x <= pos.x + width / 2 && pos.y - height / 2 <= y && y <= pos.y + height / 2) {
+    var cornerRadius = node.pstyle("corner-radius").value === "auto" ? "auto" : node.pstyle("corner-radius").pfValue;
+    var shape = r.nodeShapes[r.getNodeShape(node)];
+    return shape.checkPoint(x, y, 0, width, height, pos.x, pos.y, cornerRadius, node._private.rscratch);
+  }
+  return false;
+};
+BRp$e.checkEdgeHitAt = function(edge, x, y, threshold) {
+  var r = this;
+  var _p = edge._private;
+  var rs = _p.rscratch;
+  var styleWidth = edge.pstyle("width").pfValue;
+  var width = styleWidth / 2 + threshold;
+  var widthSq = width * width;
+  var width2 = width * 2;
+  var sqDist;
+  if (rs.edgeType === "segments" || rs.edgeType === "straight" || rs.edgeType === "haystack") {
+    var linePts = rs.allpts;
+    for (var i = 0;i + 3 < linePts.length; i += 2) {
+      if (inLineVicinity(x, y, linePts[i], linePts[i + 1], linePts[i + 2], linePts[i + 3], width2) && widthSq > (sqDist = sqdistToFiniteLine(x, y, linePts[i], linePts[i + 1], linePts[i + 2], linePts[i + 3]))) {
+        return {
+          sqDist
+        };
+      }
+    }
+  } else if (rs.edgeType === "bezier" || rs.edgeType === "multibezier" || rs.edgeType === "self" || rs.edgeType === "compound") {
+    var bezierPts = rs.allpts;
+    for (var k = 0;k + 5 < bezierPts.length; k += 4) {
+      if (inBezierVicinity(x, y, bezierPts[k], bezierPts[k + 1], bezierPts[k + 2], bezierPts[k + 3], bezierPts[k + 4], bezierPts[k + 5], width2) && widthSq > (sqDist = sqdistToQuadraticBezier(x, y, bezierPts[k], bezierPts[k + 1], bezierPts[k + 2], bezierPts[k + 3], bezierPts[k + 4], bezierPts[k + 5]))) {
+        return {
+          sqDist
+        };
+      }
+    }
+  }
+  var arrows = [{
+    name: "source",
+    x: rs.arrowStartX,
+    y: rs.arrowStartY,
+    angle: rs.srcArrowAngle
+  }, {
+    name: "target",
+    x: rs.arrowEndX,
+    y: rs.arrowEndY,
+    angle: rs.tgtArrowAngle
+  }, {
+    name: "mid-source",
+    x: rs.midX,
+    y: rs.midY,
+    angle: rs.midsrcArrowAngle
+  }, {
+    name: "mid-target",
+    x: rs.midX,
+    y: rs.midY,
+    angle: rs.midtgtArrowAngle
+  }];
+  for (var j = 0;j < arrows.length; j++) {
+    var ar = arrows[j];
+    var shape = r.arrowShapes[edge.pstyle(ar.name + "-arrow-shape").value];
+    var edgeWidth = styleWidth;
+    var arSize = r.getArrowWidth(styleWidth, getArrowScale(edge, ar.name));
+    if (shape.roughCollide(x, y, arSize, ar.angle, {
+      x: ar.x,
+      y: ar.y
+    }, edgeWidth, threshold) && shape.collide(x, y, arSize, ar.angle, {
+      x: ar.x,
+      y: ar.y
+    }, edgeWidth, threshold)) {
+      return {
+        sqDist: null
+      };
+    }
+  }
+  return null;
+};
+BRp$e.hitTestAt = function(x, y, eles, options) {
+  var r = this;
+  var zoom = r.cy.zoom();
+  var opts = options || {};
+  var isTouch = opts.isTouch;
+  var includeBody = opts.includeBody !== false;
+  var includeMainLabels = opts.includeMainLabels !== false;
+  var includeSourceLabels = opts.includeSourceLabels !== false;
+  var includeTargetLabels = opts.includeTargetLabels !== false;
+  var nodeThreshold = (isTouch ? 8 : 2) / zoom;
+  var labelThreshold = (isTouch ? 8 : 2) / zoom;
+  var edgeThreshold = (isTouch ? 24 : 8) / zoom;
+  var eleIds = new Set;
+  for (var i = 0;i < eles.length; i++) {
+    eleIds.add(eles[i]._private.data.id);
+  }
+  var zSorted = r.getCachedZSortedEles().interactive;
+  var matches = [];
+  for (var j = zSorted.length - 1;j >= 0; j--) {
+    var ele = zSorted[j];
+    if (!eleIds.has(ele._private.data.id)) {
+      continue;
+    }
+    var hit = false;
+    if (ele.isNode()) {
+      if (includeBody) {
+        hit = r.checkNodeHitAt(ele, x, y, nodeThreshold);
+      }
+      if (!hit && includeMainLabels) {
+        hit = r.checkLabelHitAt(ele, x, y, null, labelThreshold);
+      }
+    } else {
+      if (includeBody) {
+        hit = r.checkEdgeHitAt(ele, x, y, edgeThreshold) != null;
+      }
+      if (!hit && includeMainLabels) {
+        hit = r.checkLabelHitAt(ele, x, y, null, labelThreshold);
+      }
+      if (!hit && includeSourceLabels) {
+        hit = r.checkLabelHitAt(ele, x, y, "source", labelThreshold);
+      }
+      if (!hit && includeTargetLabels) {
+        hit = r.checkLabelHitAt(ele, x, y, "target", labelThreshold);
+      }
+    }
+    if (hit) {
+      matches.push(ele);
+    }
+  }
+  return matches;
+};
 BRp$e.findNearestElement = function(x, y, interactiveElementsOnly, isTouch) {
   return this.findNearestElements(x, y, interactiveElementsOnly, isTouch)[0];
 };
@@ -110893,26 +111318,15 @@ BRp$e.findNearestElements = function(x, y, interactiveElementsOnly, isTouch) {
     }
   }
   function checkNode(node) {
-    var width = node.outerWidth() + 2 * nodeThreshold;
-    var height = node.outerHeight() + 2 * nodeThreshold;
-    var hw = width / 2;
-    var hh = height / 2;
-    var pos = node.position();
-    var cornerRadius = node.pstyle("corner-radius").value === "auto" ? "auto" : node.pstyle("corner-radius").pfValue;
-    var rs = node._private.rscratch;
-    if (pos.x - hw <= x && x <= pos.x + hw && pos.y - hh <= y && y <= pos.y + hh) {
-      var shape = r.nodeShapes[self2.getNodeShape(node)];
-      if (shape.checkPoint(x, y, 0, width, height, pos.x, pos.y, cornerRadius, rs)) {
-        addEle(node, 0);
-        return true;
-      }
+    if (r.checkNodeHitAt(node, x, y, nodeThreshold)) {
+      addEle(node, 0);
+      return true;
     }
   }
   function checkEdge(edge) {
     var _p = edge._private;
     var rs = _p.rscratch;
     var styleWidth = edge.pstyle("width").pfValue;
-    var scale = edge.pstyle("arrow-scale").value;
     var width = styleWidth / 2 + edgeThreshold;
     var widthSq = width * width;
     var width2 = width * 2;
@@ -110938,7 +111352,6 @@ BRp$e.findNearestElements = function(x, y, interactiveElementsOnly, isTouch) {
     }
     var src = src || _p.source;
     var tgt = tgt || _p.target;
-    var arSize = self2.getArrowWidth(styleWidth, scale);
     var arrows = [{
       name: "source",
       x: rs.arrowStartX,
@@ -110964,6 +111377,7 @@ BRp$e.findNearestElements = function(x, y, interactiveElementsOnly, isTouch) {
       var ar = arrows[i];
       var shape = r.arrowShapes[edge.pstyle(ar.name + "-arrow-shape").value];
       var edgeWidth = edge.pstyle("width").pfValue;
+      var arSize = self2.getArrowWidth(styleWidth, getArrowScale(edge, ar.name));
       if (shape.roughCollide(x, y, arSize, ar.angle, {
         x: ar.x,
         y: ar.y
@@ -110980,68 +111394,10 @@ BRp$e.findNearestElements = function(x, y, interactiveElementsOnly, isTouch) {
       checkNode(tgt);
     }
   }
-  function preprop(obj, name, pre) {
-    return getPrefixedProperty(obj, name, pre);
-  }
   function checkLabel(ele, prefix) {
-    var _p = ele._private;
-    var th = labelThreshold;
-    var prefixDash;
-    if (prefix) {
-      prefixDash = prefix + "-";
-    } else {
-      prefixDash = "";
-    }
-    ele.boundingBox();
-    var bb = _p.labelBounds[prefix || "main"];
-    var text = ele.pstyle(prefixDash + "label").value;
-    var eventsEnabled = ele.pstyle("text-events").strValue === "yes";
-    if (!eventsEnabled || !text) {
-      return;
-    }
-    var lx = preprop(_p.rscratch, "labelX", prefix);
-    var ly = preprop(_p.rscratch, "labelY", prefix);
-    var theta = preprop(_p.rscratch, "labelAngle", prefix);
-    var ox = ele.pstyle(prefixDash + "text-margin-x").pfValue;
-    var oy = ele.pstyle(prefixDash + "text-margin-y").pfValue;
-    var lx1 = bb.x1 - th - ox;
-    var lx2 = bb.x2 + th - ox;
-    var ly1 = bb.y1 - th - oy;
-    var ly2 = bb.y2 + th - oy;
-    if (theta) {
-      var cos = Math.cos(theta);
-      var sin = Math.sin(theta);
-      var rotate = function rotate(x, y) {
-        x = x - lx;
-        y = y - ly;
-        return {
-          x: x * cos - y * sin + lx,
-          y: x * sin + y * cos + ly
-        };
-      };
-      var px1y1 = rotate(lx1, ly1);
-      var px1y2 = rotate(lx1, ly2);
-      var px2y1 = rotate(lx2, ly1);
-      var px2y2 = rotate(lx2, ly2);
-      var points = [
-        px1y1.x + ox,
-        px1y1.y + oy,
-        px2y1.x + ox,
-        px2y1.y + oy,
-        px2y2.x + ox,
-        px2y2.y + oy,
-        px1y2.x + ox,
-        px1y2.y + oy
-      ];
-      if (pointInsidePolygonPoints(x, y, points)) {
-        addEle(ele);
-        return true;
-      }
-    } else {
-      if (inBoundingBox(bb, x, y)) {
-        addEle(ele);
-        return true;
-      }
+    if (self2.checkLabelHitAt(ele, x, y, prefix, labelThreshold)) {
+      addEle(ele);
+      return true;
     }
   }
   for (var i = eles.length - 1;i >= 0; i--) {
@@ -111055,6 +111411,7 @@ BRp$e.findNearestElements = function(x, y, interactiveElementsOnly, isTouch) {
   return near;
 };
 BRp$e.getAllInBox = function(x1, y1, x2, y2) {
+  var r = this;
   var eles = this.getCachedZSortedEles().interactive;
   var zoom = this.cy.zoom();
   var labelThreshold = 2 / zoom;
@@ -111087,54 +111444,8 @@ BRp$e.getAllInBox = function(x1, y1, x2, y2) {
     y: boxBb.y2
   }];
   var boxEdges = [[selectionBox[0], selectionBox[1]], [selectionBox[1], selectionBox[2]], [selectionBox[2], selectionBox[3]], [selectionBox[3], selectionBox[0]]];
-  function preprop(obj, name, pre) {
-    return getPrefixedProperty(obj, name, pre);
-  }
   function getRotatedLabelBox(ele, prefix) {
-    var _p = ele._private;
-    var th = labelThreshold;
-    var prefixDash = "";
-    ele.boundingBox();
-    var bb = _p.labelBounds["main"];
-    if (!bb) {
-      return null;
-    }
-    var lx = preprop(_p.rscratch, "labelX", prefix);
-    var ly = preprop(_p.rscratch, "labelY", prefix);
-    var theta = preprop(_p.rscratch, "labelAngle", prefix);
-    var ox = ele.pstyle(prefixDash + "text-margin-x").pfValue;
-    var oy = ele.pstyle(prefixDash + "text-margin-y").pfValue;
-    var lx1 = bb.x1 - th - ox;
-    var lx2 = bb.x2 + th - ox;
-    var ly1 = bb.y1 - th - oy;
-    var ly2 = bb.y2 + th - oy;
-    if (theta) {
-      var cos = Math.cos(theta);
-      var sin = Math.sin(theta);
-      var rotate = function rotate(x, y) {
-        x = x - lx;
-        y = y - ly;
-        return {
-          x: x * cos - y * sin + lx,
-          y: x * sin + y * cos + ly
-        };
-      };
-      return [rotate(lx1, ly1), rotate(lx2, ly1), rotate(lx2, ly2), rotate(lx1, ly2)];
-    } else {
-      return [{
-        x: lx1,
-        y: ly1
-      }, {
-        x: lx2,
-        y: ly1
-      }, {
-        x: lx2,
-        y: ly2
-      }, {
-        x: lx1,
-        y: ly2
-      }];
-    }
+    return r.getLabelHitPolygon(ele, prefix, labelThreshold);
   }
   function doLinesIntersect(p1, p2, q1, q2) {
     function ccw(a, b, c) {
@@ -111777,6 +112088,15 @@ BRp$c.findTaxiPoints = function(edge, pairInfo) {
   };
   var dx = subDWH(pdx, dw);
   var dy = subDWH(pdy, dh);
+  var midBetween = function midBetween(c1, c2, size1, size2) {
+    if (!dIncludesNodeBody) {
+      return (c1 + c2) / 2;
+    }
+    var sgn = signum(c2 - c1);
+    var side1 = c1 + sgn * size1 / 2;
+    var side2 = c2 - sgn * size2 / 2;
+    return sgn * (side2 - side1) >= 0 ? (side1 + side2) / 2 : (c1 + c2) / 2;
+  };
   var isExplicitDir = false;
   if (rawTaxiDir === AUTO) {
     taxiDir = Math.abs(dx) > Math.abs(dy) ? HORIZONTAL : VERTICAL;
@@ -111816,11 +112136,11 @@ BRp$c.findTaxiPoints = function(edge, pairInfo) {
       var lShapeInsideSrc = Math.abs(pl) <= srcH / 2;
       var lShapeInsideTgt = Math.abs(pdx) <= tgtW / 2;
       if (lShapeInsideSrc) {
-        var x = (posPts.x1 + posPts.x2) / 2;
+        var x = midBetween(posPts.x1, posPts.x2, srcW, tgtW);
         var { y1, y2 } = posPts;
         rs.segpts = [x, y1, x, y2];
       } else if (lShapeInsideTgt) {
-        var y = (posPts.y1 + posPts.y2) / 2;
+        var y = midBetween(posPts.y1, posPts.y2, srcH, tgtH);
         var { x1, x2 } = posPts;
         rs.segpts = [x1, y, x2, y];
       } else {
@@ -111830,11 +112150,11 @@ BRp$c.findTaxiPoints = function(edge, pairInfo) {
       var _lShapeInsideSrc = Math.abs(pl) <= srcW / 2;
       var _lShapeInsideTgt = Math.abs(pdy) <= tgtH / 2;
       if (_lShapeInsideSrc) {
-        var _y = (posPts.y1 + posPts.y2) / 2;
+        var _y = midBetween(posPts.y1, posPts.y2, srcH, tgtH);
         var { x1: _x, x2: _x2 } = posPts;
         rs.segpts = [_x, _y, _x2, _y];
       } else if (_lShapeInsideTgt) {
-        var _x3 = (posPts.x1 + posPts.x2) / 2;
+        var _x3 = midBetween(posPts.x1, posPts.x2, srcW, tgtW);
         var { y1: _y2, y2: _y3 } = posPts;
         rs.segpts = [_x3, _y2, _x3, _y3];
       } else {
@@ -111868,8 +112188,9 @@ BRp$c.tryToCorrectInvalidPoints = function(edge, pairInfo) {
     var badEnd = !number$1(rs.endX) || !number$1(rs.endY);
     var badAEnd = !number$1(rs.arrowEndX) || !number$1(rs.arrowEndY);
     var minCpADistFactor = 3;
-    var arrowW = this.getArrowWidth(edge.pstyle("width").pfValue, edge.pstyle("arrow-scale").value) * this.arrowShapeWidth;
-    var minCpADist = minCpADistFactor * arrowW;
+    var edgeWidth = edge.pstyle("width").pfValue;
+    var minCpASrcDist = minCpADistFactor * this.getArrowWidth(edgeWidth, getArrowScale(edge, "source")) * this.arrowShapeWidth;
+    var minCpATgtDist = minCpADistFactor * this.getArrowWidth(edgeWidth, getArrowScale(edge, "target")) * this.arrowShapeWidth;
     var startACpDist = dist({
       x: rs.ctrlpts[0],
       y: rs.ctrlpts[1]
@@ -111877,15 +112198,7 @@ BRp$c.tryToCorrectInvalidPoints = function(edge, pairInfo) {
       x: rs.startX,
       y: rs.startY
     });
-    var closeStartACp = startACpDist < minCpADist;
-    var endACpDist = dist({
-      x: rs.ctrlpts[0],
-      y: rs.ctrlpts[1]
-    }, {
-      x: rs.endX,
-      y: rs.endY
-    });
-    var closeEndACp = endACpDist < minCpADist;
+    var closeStartACp = startACpDist < minCpASrcDist;
     var overlapping = false;
     if (badStart || badAStart || closeStartACp) {
       overlapping = true;
@@ -111905,13 +112218,21 @@ BRp$c.tryToCorrectInvalidPoints = function(edge, pairInfo) {
       };
       var srcCtrlPtIntn = srcShape.intersectLine(srcPos.x, srcPos.y, srcW, srcH, cpProj.x, cpProj.y, 0, srcCornerRadius, srcRs);
       if (closeStartACp) {
-        rs.ctrlpts[0] = rs.ctrlpts[0] + cpM.x * (minCpADist - startACpDist);
-        rs.ctrlpts[1] = rs.ctrlpts[1] + cpM.y * (minCpADist - startACpDist);
+        rs.ctrlpts[0] = rs.ctrlpts[0] + cpM.x * (minCpASrcDist - startACpDist);
+        rs.ctrlpts[1] = rs.ctrlpts[1] + cpM.y * (minCpASrcDist - startACpDist);
       } else {
-        rs.ctrlpts[0] = srcCtrlPtIntn[0] + cpM.x * minCpADist;
-        rs.ctrlpts[1] = srcCtrlPtIntn[1] + cpM.y * minCpADist;
+        rs.ctrlpts[0] = srcCtrlPtIntn[0] + cpM.x * minCpASrcDist;
+        rs.ctrlpts[1] = srcCtrlPtIntn[1] + cpM.y * minCpASrcDist;
       }
     }
+    var endACpDist = dist({
+      x: rs.ctrlpts[0],
+      y: rs.ctrlpts[1]
+    }, {
+      x: rs.endX,
+      y: rs.endY
+    });
+    var closeEndACp = endACpDist < minCpATgtDist;
     if (badEnd || badAEnd || closeEndACp) {
       overlapping = true;
       var _cpD = {
@@ -111930,11 +112251,11 @@ BRp$c.tryToCorrectInvalidPoints = function(edge, pairInfo) {
       };
       var tgtCtrlPtIntn = tgtShape.intersectLine(tgtPos.x, tgtPos.y, tgtW, tgtH, _cpProj.x, _cpProj.y, 0, tgtCornerRadius, tgtRs);
       if (closeEndACp) {
-        rs.ctrlpts[0] = rs.ctrlpts[0] + _cpM.x * (minCpADist - endACpDist);
-        rs.ctrlpts[1] = rs.ctrlpts[1] + _cpM.y * (minCpADist - endACpDist);
+        rs.ctrlpts[0] = rs.ctrlpts[0] + _cpM.x * (minCpATgtDist - endACpDist);
+        rs.ctrlpts[1] = rs.ctrlpts[1] + _cpM.y * (minCpATgtDist - endACpDist);
       } else {
-        rs.ctrlpts[0] = tgtCtrlPtIntn[0] + _cpM.x * minCpADist;
-        rs.ctrlpts[1] = tgtCtrlPtIntn[1] + _cpM.y * minCpADist;
+        rs.ctrlpts[0] = tgtCtrlPtIntn[0] + _cpM.x * minCpATgtDist;
+        rs.ctrlpts[1] = tgtCtrlPtIntn[1] + _cpM.y * minCpATgtDist;
       }
     }
     if (overlapping) {
@@ -112436,8 +112757,8 @@ BRp$b.findEndpoints = function(edge) {
       }
     }
   }
-  var arrowEnd = shortenIntersection(intersect, p1, r.arrowShapes[tgtArShape].spacing(edge) + tgtDist);
-  var edgeEnd = shortenIntersection(intersect, p1, r.arrowShapes[tgtArShape].gap(edge) + tgtDist);
+  var arrowEnd = shortenIntersection(intersect, p1, r.arrowShapes[tgtArShape].spacing(edge, "target") + tgtDist);
+  var edgeEnd = shortenIntersection(intersect, p1, r.arrowShapes[tgtArShape].gap(edge, "target") + tgtDist);
   rs.endX = edgeEnd[0];
   rs.endY = edgeEnd[1];
   rs.arrowEndX = arrowEnd[0];
@@ -112499,8 +112820,8 @@ BRp$b.findEndpoints = function(edge) {
       }
     }
   }
-  var arrowStart = shortenIntersection(intersect, p2, r.arrowShapes[srcArShape].spacing(edge) + srcDist);
-  var edgeStart = shortenIntersection(intersect, p2, r.arrowShapes[srcArShape].gap(edge) + srcDist);
+  var arrowStart = shortenIntersection(intersect, p2, r.arrowShapes[srcArShape].spacing(edge, "source") + srcDist);
+  var edgeStart = shortenIntersection(intersect, p2, r.arrowShapes[srcArShape].gap(edge, "source") + srcDist);
   rs.startX = edgeStart[0];
   rs.startY = edgeStart[1];
   rs.arrowStartX = arrowStart[0];
@@ -112590,7 +112911,18 @@ BRp$a.storeEdgeProjections = function(edge) {
       y: hpts[3]
     }];
   }
-  _p.rstyle.arrowWidth = this.getArrowWidth(edge.pstyle("width").pfValue, edge.pstyle("arrow-scale").value) * this.arrowShapeWidth;
+  var edgeWidth = edge.pstyle("width").pfValue;
+  var arrowWidths = _p.rstyle.arrowWidths = _p.rstyle.arrowWidths || {};
+  var maxScale = 0;
+  for (var _i = 0;_i < arrowPrefixes.length; _i++) {
+    var prefix = arrowPrefixes[_i];
+    var scale = getArrowScale(edge, prefix);
+    arrowWidths[prefix] = this.getArrowWidth(edgeWidth, scale) * this.arrowShapeWidth;
+    if (scale > maxScale) {
+      maxScale = scale;
+    }
+  }
+  _p.rstyle.arrowWidth = this.getArrowWidth(edgeWidth, maxScale) * this.arrowShapeWidth;
 };
 BRp$a.recalculateEdgeProjections = function(edges) {
   this.findEdgeControlPoints(edges);
@@ -114122,6 +114454,11 @@ BRp$3.load = function() {
   var wheelDeltaN = 4;
   var inaccurateScrollDevice;
   var inaccurateScrollFactor = 1e5;
+  var sampledScrollFactor;
+  var wheelFactorMaxReduction = 4;
+  var wheelNotchMaxReduction = 8;
+  var wheelSmallDeltaMax = 15;
+  var unconfirmedMagnitude = null;
   var allAreSameMagnitude = function allAreSameMagnitude(list) {
     var firstMag = Math.abs(list[0]);
     for (var i = 1;i < list.length; i++) {
@@ -114158,14 +114495,35 @@ BRp$3.load = function() {
           if (factor > 1) {
             inaccurateScrollDevice = true;
             inaccurateScrollFactor = factor;
+            sampledScrollFactor = factor;
           }
         }
       } else {
         wheelDeltas.push(Math.abs(delta));
         clamp = true;
       }
-    } else if (inaccurateScrollDevice) {
-      inaccurateScrollFactor = Math.min(Math.abs(delta), inaccurateScrollFactor);
+    }
+    var isWheelNotch = false;
+    if (inaccurateScrollDevice) {
+      var magnitude = Math.abs(delta);
+      isWheelNotch = isIntegerMultiple(magnitude, inaccurateScrollFactor);
+      if (isWheelNotch)
+        ;
+      else if (magnitude < Math.min(sampledScrollFactor / wheelNotchMaxReduction, wheelSmallDeltaMax)) {
+        unconfirmedMagnitude = null;
+      } else if (!integer(magnitude) && isIntegerMultiple(inaccurateScrollFactor, magnitude)) {
+        inaccurateScrollFactor = magnitude;
+        unconfirmedMagnitude = null;
+        isWheelNotch = true;
+      } else if (magnitude === unconfirmedMagnitude) {
+        var commonFactor = gcdMultipleZeroIfNonInt([inaccurateScrollFactor, magnitude]);
+        inaccurateScrollFactor = commonFactor * wheelFactorMaxReduction >= sampledScrollFactor ? commonFactor : magnitude;
+        unconfirmedMagnitude = null;
+        isWheelNotch = true;
+      } else {
+        unconfirmedMagnitude = magnitude;
+        clamp = integer(magnitude) || magnitude > inaccurateScrollFactor;
+      }
     }
     if (r.scrollingPage) {
       return;
@@ -114193,7 +114551,7 @@ BRp$3.load = function() {
         delta = signum(delta) * 5;
       }
       diff = delta / -250;
-      if (inaccurateScrollDevice) {
+      if (isWheelNotch) {
         diff /= inaccurateScrollFactor;
         diff *= 3;
       }
@@ -115490,6 +115848,7 @@ BRp$1.startRenderLoop = function() {
     if (cy.batching())
       ;
     else if (r.requestedFrame && !r.skipFrame) {
+      r.requestedFrame = false;
       beforeRenderCallbacks(r, true, requestTime);
       var startTime = performanceNow();
       r.render(r.renderOptions);
@@ -115508,7 +115867,6 @@ BRp$1.startRenderLoop = function() {
       r.redrawTotalTime += duration;
       r.lastRedrawTime = duration;
       r.averageRedrawTime = r.averageRedrawTime / 2 + duration / 2;
-      r.requestedFrame = false;
     } else {
       beforeRenderCallbacks(r, false, requestTime);
     }
@@ -117026,7 +117384,7 @@ CRp$9.drawEdge = function(context, edge, shiftToOriginWithBb) {
     context.lineWidth = edgeWidth + lineOutlineWidth;
     context.lineCap = lineCap;
     if (lineOutlineWidth > 0) {
-      r.colorStrokeStyle(context, lineOutlineColor[0], lineOutlineColor[1], lineOutlineColor[2], strokeOpacity);
+      r.colorStrokeStyle(context, lineOutlineColor, strokeOpacity);
     } else {
       context.lineCap = "butt";
       return;
@@ -117085,6 +117443,7 @@ var drawEdgeOverlayUnderlay = function drawEdgeOverlayUnderlay(overlayOrUnderlay
     throw new Error("Invalid state");
   }
   return function(context, edge) {
+    var _edge$pstyle;
     if (!edge.visible()) {
       return;
     }
@@ -117097,14 +117456,25 @@ var drawEdgeOverlayUnderlay = function drawEdgeOverlayUnderlay(overlayOrUnderlay
     var rs = edge._private.rscratch;
     var padding = edge.pstyle("".concat(overlayOrUnderlay, "-padding")).pfValue;
     var width = 2 * padding;
-    var color = edge.pstyle("".concat(overlayOrUnderlay, "-color")).value;
     context.lineWidth = width;
     if (rs.edgeType === "self" && !usePaths) {
       context.lineCap = "butt";
     } else {
       context.lineCap = "round";
     }
-    r.colorStrokeStyle(context, color[0], color[1], color[2], opacity);
+    var fillStyle = (_edge$pstyle = edge.pstyle("".concat(overlayOrUnderlay, "-fill"))) === null || _edge$pstyle === undefined ? undefined : _edge$pstyle.value;
+    if (fillStyle === "linear-gradient" || fillStyle === "radial-gradient") {
+      var gradient = r.createGradientStyleFor(context, overlayOrUnderlay, edge, fillStyle, opacity);
+      if (gradient) {
+        context.strokeStyle = gradient;
+      } else {
+        var color = edge.pstyle("".concat(overlayOrUnderlay, "-color")).value;
+        r.colorStrokeStyle(context, color, opacity);
+      }
+    } else {
+      var _color = edge.pstyle("".concat(overlayOrUnderlay, "-color")).value;
+      r.colorStrokeStyle(context, _color, opacity);
+    }
     r.drawEdgePath(edge, context, rs.allpts, "solid");
   };
 };
@@ -117247,17 +117617,17 @@ CRp$9.drawArrowhead = function(context, edge, prefix, x, y, angle, opacity) {
   var gco = context.globalCompositeOperation;
   if (opacity !== 1 || arrowFill === "hollow") {
     context.globalCompositeOperation = "destination-out";
-    self2.colorFillStyle(context, 255, 255, 255, 1);
-    self2.colorStrokeStyle(context, 255, 255, 255, 1);
-    self2.drawArrowShape(edge, context, arrowClearFill, edgeWidth, arrowShape, arrowWidth, x, y, angle);
+    self2.colorFillStyle(context, [255, 255, 255], 1);
+    self2.colorStrokeStyle(context, [255, 255, 255], 1);
+    self2.drawArrowShape(edge, context, arrowClearFill, edgeWidth, arrowShape, arrowWidth, x, y, angle, prefix);
     context.globalCompositeOperation = gco;
   }
   var color = edge.pstyle(prefix + "-arrow-color").value;
-  self2.colorFillStyle(context, color[0], color[1], color[2], opacity);
-  self2.colorStrokeStyle(context, color[0], color[1], color[2], opacity);
-  self2.drawArrowShape(edge, context, arrowFill, edgeWidth, arrowShape, arrowWidth, x, y, angle);
+  self2.colorFillStyle(context, color, opacity);
+  self2.colorStrokeStyle(context, color, opacity);
+  self2.drawArrowShape(edge, context, arrowFill, edgeWidth, arrowShape, arrowWidth, x, y, angle, prefix);
 };
-CRp$9.drawArrowShape = function(edge, context, fill, edgeWidth, shape, shapeWidth, x, y, angle) {
+CRp$9.drawArrowShape = function(edge, context, fill, edgeWidth, shape, shapeWidth, x, y, angle, prefix) {
   var r = this;
   var usePaths = this.usePaths() && shape !== "triangle-cross";
   var pathCacheHit = false;
@@ -117267,9 +117637,9 @@ CRp$9.drawArrowShape = function(edge, context, fill, edgeWidth, shape, shapeWidt
     x,
     y
   };
-  var scale = edge.pstyle("arrow-scale").value;
-  var size = this.getArrowWidth(edgeWidth, scale);
   var shapeImpl = r.arrowShapes[shape];
+  var scale = getArrowScale(edge, prefix);
+  var size = this.getArrowWidth(edgeWidth, scale);
   if (usePaths) {
     var cache = r.arrowPathCache = r.arrowPathCache || [];
     var key = hashString(shape);
@@ -117560,8 +117930,8 @@ CRp$7.setupTextStyle = function(context, ele) {
   var outlineColor = ele.pstyle("text-outline-color").value;
   context.font = labelStyle + " " + labelWeight + " " + labelSize + " " + labelFamily;
   context.lineJoin = "round";
-  this.colorFillStyle(context, color[0], color[1], color[2], opacity);
-  this.colorStrokeStyle(context, outlineColor[0], outlineColor[1], outlineColor[2], outlineOpacity);
+  this.colorFillStyle(context, color, opacity);
+  this.colorStrokeStyle(context, outlineColor, outlineOpacity);
 };
 function circle(ctx, x, y, width, height) {
   var diameter = Math.min(width, height);
@@ -117692,10 +118062,10 @@ CRp$7.drawText = function(context, ele, prefix) {
       var bgW = textW + 2 * backgroundPadding;
       var bgH = textH + 2 * backgroundPadding;
       if (doFill) {
-        context.fillStyle = "rgba(".concat(textBackgroundColor[0], ",").concat(textBackgroundColor[1], ",").concat(textBackgroundColor[2], ",").concat(backgroundOpacity * parentOpacity, ")");
+        this.colorFillStyle(context, textBackgroundColor, backgroundOpacity * parentOpacity);
       }
       if (doStroke) {
-        context.strokeStyle = "rgba(".concat(textBorderColor[0], ",").concat(textBorderColor[1], ",").concat(textBorderColor[2], ",").concat(borderOpacity * parentOpacity, ")");
+        this.colorStrokeStyle(context, textBorderColor, borderOpacity * parentOpacity);
         context.lineWidth = textBorderWidth;
         if (context.setLineDash) {
           switch (textBorderStyle) {
@@ -117875,11 +118245,11 @@ CRp$6.drawNode = function(context, node, shiftToOriginWithBb) {
   };
   var setupBorderColor = function setupBorderColor() {
     var bdrOpy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : borderOpacity;
-    r.colorStrokeStyle(context, borderColor[0], borderColor[1], borderColor[2], bdrOpy);
+    r.colorStrokeStyle(context, borderColor, bdrOpy);
   };
   var setupOutlineColor = function setupOutlineColor() {
     var otlnOpy = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : outlineOpacity;
-    r.colorStrokeStyle(context, outlineColor[0], outlineColor[1], outlineColor[2], otlnOpy);
+    r.colorStrokeStyle(context, outlineColor, otlnOpy);
   };
   var getPath = function getPath(width, height, shape, points) {
     var pathCache = r.nodePathCache = r.nodePathCache || [];
@@ -117931,6 +118301,9 @@ CRp$6.drawNode = function(context, node, shiftToOriginWithBb) {
     var prevBging = _p.backgrounding;
     var totalCompleted = 0;
     for (var _i = 0;_i < image.length; _i++) {
+      if (!urlDefined[_i]) {
+        continue;
+      }
       var bgContainment = node.cy().style().getIndexedStyle(node, "background-image-containment", "value", _i);
       if (inside && bgContainment === "over" || !inside && bgContainment === "inside") {
         totalCompleted++;
@@ -117983,7 +118356,7 @@ CRp$6.drawNode = function(context, node, shiftToOriginWithBb) {
     var opacity = (darkness > 0 ? darkness : -darkness) * darkenOpacity;
     var c = darkness > 0 ? 0 : 255;
     if (darkness !== 0) {
-      r.colorFillStyle(context, c, c, c, opacity);
+      r.colorFillStyle(context, [c, c, c], opacity);
       if (usePaths) {
         context.fill(path);
       } else {
@@ -118249,17 +118622,29 @@ var drawNodeOverlayUnderlay = function drawNodeOverlayUnderlay(overlayOrUnderlay
     }
     var padding = node.pstyle("".concat(overlayOrUnderlay, "-padding")).pfValue;
     var opacity = node.pstyle("".concat(overlayOrUnderlay, "-opacity")).value;
-    var color = node.pstyle("".concat(overlayOrUnderlay, "-color")).value;
     var shape = node.pstyle("".concat(overlayOrUnderlay, "-shape")).value;
     var radius = node.pstyle("".concat(overlayOrUnderlay, "-corner-radius")).value;
     if (opacity > 0) {
+      var _node$pstyle;
       pos = pos || node.position();
       if (nodeWidth == null || nodeHeight == null) {
         var _padding = node.padding();
         nodeWidth = node.width() + 2 * _padding;
         nodeHeight = node.height() + 2 * _padding;
       }
-      r.colorFillStyle(context, color[0], color[1], color[2], opacity);
+      var fillStyle = (_node$pstyle = node.pstyle("".concat(overlayOrUnderlay, "-fill"))) === null || _node$pstyle === undefined ? undefined : _node$pstyle.value;
+      if (fillStyle === "linear-gradient" || fillStyle === "radial-gradient") {
+        var gradient = r.createGradientStyleFor(context, overlayOrUnderlay, node, fillStyle, opacity);
+        if (gradient) {
+          context.fillStyle = gradient;
+        } else {
+          var color = node.pstyle("".concat(overlayOrUnderlay, "-color")).value;
+          r.colorFillStyle(context, color, opacity);
+        }
+      } else {
+        var _color = node.pstyle("".concat(overlayOrUnderlay, "-color")).value;
+        r.colorFillStyle(context, _color, opacity);
+      }
       r.nodeShapes[shape].draw(context, pos.x, pos.y, nodeWidth + padding * 2, nodeHeight + padding * 2, radius);
       context.fill();
     }
@@ -118333,7 +118718,7 @@ CRp$6.drawPie = function(context, node, nodeOpacity, pos) {
       context.arc(x, y, holeRadius, angleEnd, angleStart, true);
       context.closePath();
     }
-    this.colorFillStyle(context, color[0], color[1], color[2], opacity);
+    this.colorFillStyle(context, color, opacity);
     context.fill();
     lastPercent += percent;
   }
@@ -118387,7 +118772,7 @@ CRp$6.drawStripe = function(context, node, nodeOpacity, pos) {
     context.beginPath();
     context.rect(x, y + stripeH * lastPercent, stripeW, stripeH * percent);
     context.closePath();
-    this.colorFillStyle(context, color[0], color[1], color[2], opacity);
+    this.colorFillStyle(context, color, opacity);
     context.fill();
     lastPercent += percent;
   }
@@ -118395,6 +118780,12 @@ CRp$6.drawStripe = function(context, node, nodeOpacity, pos) {
 };
 var CRp$5 = {};
 var motionBlurDelay = 100;
+var colorAlpha = function colorAlpha(color) {
+  return color[3] == null ? 1 : color[3];
+};
+var effectiveAlpha = function effectiveAlpha(color, opacity) {
+  return colorAlpha(color) * opacity;
+};
 CRp$5.getPixelRatio = function() {
   var context = this.data.contexts[0];
   if (this.forcedPixelRatio != null) {
@@ -118434,7 +118825,7 @@ CRp$5.createGradientStyleFor = function(context, shapeStyleName, ele, fill, opac
       var d2 = dist(end, mid);
       gradientStyle = context.createRadialGradient(mid.x, mid.y, 0, mid.x, mid.y, Math.max(d1, d2));
     } else {
-      var pos = usePaths ? {
+      var pos = usePaths && shapeStyleName === "background" ? {
         x: 0,
         y: 0
       } : ele.position(), width = ele.paddedWidth(), height = ele.paddedHeight();
@@ -118445,11 +118836,11 @@ CRp$5.createGradientStyleFor = function(context, shapeStyleName, ele, fill, opac
       var _start = ele.sourceEndpoint(), _end = ele.targetEndpoint();
       gradientStyle = context.createLinearGradient(_start.x, _start.y, _end.x, _end.y);
     } else {
-      var _pos = usePaths ? {
+      var _pos = usePaths && shapeStyleName === "background" ? {
         x: 0,
         y: 0
       } : ele.position(), _width = ele.paddedWidth(), _height = ele.paddedHeight(), halfWidth = _width / 2, halfHeight = _height / 2;
-      var direction = ele.pstyle("background-gradient-direction").value;
+      var direction = ele.pstyle(shapeStyleName + "-gradient-direction").value;
       switch (direction) {
         case "to-bottom":
           gradientStyle = context.createLinearGradient(_pos.x, _pos.y - halfHeight, _pos.x, _pos.y + halfHeight);
@@ -118487,7 +118878,8 @@ CRp$5.createGradientStyleFor = function(context, shapeStyleName, ele, fill, opac
   var hasPositions = positions.length === colors.length;
   var length = colors.length;
   for (var i = 0;i < length; i++) {
-    gradientStyle.addColorStop(hasPositions ? positions[i] : i / (length - 1), "rgba(" + colors[i][0] + "," + colors[i][1] + "," + colors[i][2] + "," + opacity + ")");
+    var stopAlpha = effectiveAlpha(colors[i], opacity);
+    gradientStyle.addColorStop(hasPositions ? positions[i] : i / (length - 1), "rgba(" + colors[i][0] + "," + colors[i][1] + "," + colors[i][2] + "," + stopAlpha + ")");
   }
   return gradientStyle;
 };
@@ -118497,8 +118889,8 @@ CRp$5.gradientFillStyle = function(context, ele, fill, opacity) {
     return null;
   context.fillStyle = gradientStyle;
 };
-CRp$5.colorFillStyle = function(context, r, g, b, a) {
-  context.fillStyle = "rgba(" + r + "," + g + "," + b + "," + a + ")";
+CRp$5.colorFillStyle = function(context, color, opacity) {
+  context.fillStyle = "rgba(" + color[0] + "," + color[1] + "," + color[2] + "," + effectiveAlpha(color, opacity) + ")";
 };
 CRp$5.eleFillStyle = function(context, ele, opacity) {
   var backgroundFill = ele.pstyle("background-fill").value;
@@ -118506,7 +118898,7 @@ CRp$5.eleFillStyle = function(context, ele, opacity) {
     this.gradientFillStyle(context, ele, backgroundFill, opacity);
   } else {
     var backgroundColor = ele.pstyle("background-color").value;
-    this.colorFillStyle(context, backgroundColor[0], backgroundColor[1], backgroundColor[2], opacity);
+    this.colorFillStyle(context, backgroundColor, opacity);
   }
 };
 CRp$5.gradientStrokeStyle = function(context, ele, fill, opacity) {
@@ -118515,8 +118907,8 @@ CRp$5.gradientStrokeStyle = function(context, ele, fill, opacity) {
     return null;
   context.strokeStyle = gradientStyle;
 };
-CRp$5.colorStrokeStyle = function(context, r, g, b, a) {
-  context.strokeStyle = "rgba(" + r + "," + g + "," + b + "," + a + ")";
+CRp$5.colorStrokeStyle = function(context, color, opacity) {
+  context.strokeStyle = "rgba(" + color[0] + "," + color[1] + "," + color[2] + "," + effectiveAlpha(color, opacity) + ")";
 };
 CRp$5.eleStrokeStyle = function(context, ele, opacity) {
   var lineFill = ele.pstyle("line-fill").value;
@@ -118524,7 +118916,7 @@ CRp$5.eleStrokeStyle = function(context, ele, opacity) {
     this.gradientStrokeStyle(context, ele, lineFill, opacity);
   } else {
     var lineColor = ele.pstyle("line-color").value;
-    this.colorStrokeStyle(context, lineColor[0], lineColor[1], lineColor[2], opacity);
+    this.colorStrokeStyle(context, lineColor, opacity);
   }
 };
 CRp$5.matchCanvasSize = function(container) {
@@ -118672,7 +119064,7 @@ CRp$5.render = function(options) {
   function mbclear(context, x, y, w, h) {
     var gco = context.globalCompositeOperation;
     context.globalCompositeOperation = "destination-out";
-    r.colorFillStyle(context, 255, 255, 255, r.motionBlurTransparency);
+    r.colorFillStyle(context, [255, 255, 255], r.motionBlurTransparency);
     context.fillRect(x, y, w, h);
     context.globalCompositeOperation = gco;
   }
@@ -118750,7 +119142,7 @@ CRp$5.render = function(options) {
     }
     var outsideBgColor = style.core("outside-texture-bg-color").value;
     var outsideBgOpacity = style.core("outside-texture-bg-opacity").value;
-    r.colorFillStyle(context, outsideBgColor[0], outsideBgColor[1], outsideBgColor[2], outsideBgOpacity);
+    r.colorFillStyle(context, outsideBgColor, outsideBgOpacity);
     context.fillRect(0, 0, vp.width, vp.height);
     var zoom = cy.zoom();
     setContextTransform(context, false);
@@ -118995,7 +119387,7 @@ function toWebGLColor(color, opacity, outArray) {
   var r = color[0] / 255;
   var g = color[1] / 255;
   var b = color[2] / 255;
-  var a = opacity;
+  var a = (color[3] == null ? 1 : color[3]) * opacity;
   var arr = outArray || new Array(4);
   arr[0] = r * a;
   arr[1] = g * a;
@@ -120711,7 +121103,7 @@ var ElementDrawingWebGL = /* @__PURE__ */ function() {
       var lineOpacity = edge.pstyle("line-opacity").value;
       var opacity = baseOpacity * lineOpacity;
       var lineWidth = edge.pstyle("width").pfValue;
-      var scale$1 = edge.pstyle("arrow-scale").value;
+      var scale$1 = getArrowScale(edge, prefix);
       var size = this.r.getArrowWidth(lineWidth, scale$1);
       var instance = this.instanceCount;
       var transform = this.transformBuffer.getMatrixView(instance);
@@ -121382,8 +121774,10 @@ function renderWebgl(r, options, renderTarget) {
       drawAxes(r);
       drawAtlases(r);
     }
-    r.data.canvasNeedsRedraw[r.NODE] = false;
-    r.data.canvasNeedsRedraw[r.DRAG] = false;
+    if (renderTarget.screen) {
+      r.data.canvasNeedsRedraw[r.NODE] = false;
+      r.data.canvasNeedsRedraw[r.DRAG] = false;
+    }
   }
   if (r.webglDebug) {
     var end = performance.now();
@@ -122309,7 +122703,7 @@ sheetfn.appendToStyle = function(style) {
   }
   return style;
 };
-var version = "3.34.4";
+var version = "3.35.0";
 var cytoscape = function cytoscape(options) {
   if (options === undefined) {
     options = {};
@@ -122865,12 +123259,11 @@ function measureRenderedNodes(cy, nodeIds) {
     const node = cy.getElementById(id);
     if (!node.isNode())
       return [];
-    const bounds = node.renderedBoundingBox();
     return [
       {
         id,
         position: node.renderedPosition(),
-        size: { width: bounds.w, height: bounds.h }
+        size: { width: node.renderedOuterWidth(), height: node.renderedOuterHeight() }
       }
     ];
   });
@@ -123027,8 +123420,14 @@ function getGraphGeometryKey(cy) {
   return JSON.stringify(cy.nodes().map((node) => {
     if (node.isParent())
       return [node.id()];
-    const dimensions = node.layoutDimensions({ nodeDimensionsIncludeLabels: true });
-    return [node.id(), dimensions.w, dimensions.h];
+    const labelBounds = node.boundingBox({
+      includeEdges: false,
+      includeLabels: true,
+      includeNodes: false,
+      includeOverlays: false,
+      includeUnderlays: false
+    });
+    return [node.id(), node.outerWidth(), node.outerHeight(), labelBounds.w, labelBounds.h];
   }));
 }
 
@@ -123088,6 +123487,8 @@ var defaults2 = {
   ready: undefined,
   stop: undefined,
   nodeLayoutOptions: undefined,
+  useElkEdgeGeometry: false,
+  elkEdgeRadius: 0,
   elk: {
     algorithm: undefined
   },
@@ -123146,6 +123547,138 @@ var makeEdge = function(edge) {
   edge.scratch("elk", k);
   return k;
 };
+var getElkOrigins = function(graph) {
+  const origins = { [graph.id]: { x: 0, y: 0 } };
+  const walk = function(container, ox, oy) {
+    const children = container.children || [];
+    for (let i = 0;i < children.length; i++) {
+      const child = children[i];
+      const x = ox + (child.x || 0);
+      const y = oy + (child.y || 0);
+      origins[child.id] = { x, y };
+      walk(child, x, y);
+    }
+  };
+  walk(graph, 0, 0);
+  return origins;
+};
+var getElkEdgePoints = function(elkEdge, origins, rootId) {
+  const sec = elkEdge.sections && elkEdge.sections[0];
+  if (!sec || !sec.startPoint || !sec.endPoint) {
+    return [];
+  }
+  const container = elkEdge.container === undefined ? rootId : elkEdge.container;
+  const origin = origins[container] || { x: 0, y: 0 };
+  const raw = [sec.startPoint].concat(sec.bendPoints || [], [sec.endPoint]);
+  const points = [];
+  for (let i = 0;i < raw.length; i++) {
+    const p = { x: raw[i].x + origin.x, y: raw[i].y + origin.y };
+    const last = points[points.length - 1];
+    if (!last || last.x !== p.x || last.y !== p.y) {
+      points.push(p);
+    }
+  }
+  return points;
+};
+var fmtEndpoint = function(dx, dy) {
+  return `${dx.toFixed(1)}px ${dy.toFixed(1)}px`;
+};
+var projectOntoLine = function(a, b, p) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 0.001) {
+    return {
+      w: 0.5,
+      d: 0
+    };
+  }
+  const w = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  const cross = dx * (p.y - a.y) - dy * (p.x - a.x);
+  const d = cross / Math.sqrt(len2);
+  return {
+    w,
+    d
+  };
+};
+var clearElkEdgeStyle = function(edge) {
+  const saved = edge.scratch("_elkEdgeStyle");
+  if (!saved) {
+    return;
+  }
+  Object.keys(saved.applied).forEach((name) => {
+    if (edge.style(name) === saved.applied[name]) {
+      edge.removeStyle(name);
+      if (saved.previous[name] !== undefined) {
+        edge.style(name, saved.previous[name]);
+      }
+    }
+  });
+  edge.removeScratch("_elkEdgeStyle");
+};
+var setElkEdgeStyle = function(edge, style) {
+  const previous = {};
+  Object.keys(style).forEach((name) => {
+    const property = edge.pstyle(name);
+    if (property && property.bypass) {
+      previous[name] = property.strValue;
+    }
+  });
+  edge.style(style);
+  const applied = {};
+  Object.keys(style).forEach((name) => {
+    applied[name] = edge.style(name);
+  });
+  edge.scratch("_elkEdgeStyle", { previous, applied });
+};
+var applyElkEdgeGeometry = function(edge, points, sourceCenter, targetCenter, radius) {
+  if (points.length < 2) {
+    return;
+  }
+  const [startPoint] = points;
+  const endPoint = points[points.length - 1];
+  const bends = points.slice(1, points.length - 1);
+  const sourceEndpoint = fmtEndpoint(startPoint.x - sourceCenter.x, startPoint.y - sourceCenter.y);
+  const targetEndpoint = fmtEndpoint(endPoint.x - targetCenter.x, endPoint.y - targetCenter.y);
+  const segmentWeights = [];
+  const segmentDistances = [];
+  for (let i = 0;i < bends.length; i++) {
+    const proj = projectOntoLine(startPoint, endPoint, bends[i]);
+    const weight = proj.w.toFixed(4);
+    const distance = proj.d.toFixed(2);
+    if ((Number(weight) === 0 || Number(weight) === 1) && Number(distance) === 0) {
+      continue;
+    }
+    segmentWeights.push(weight);
+    segmentDistances.push(distance);
+  }
+  if (segmentWeights.length === 0) {
+    setElkEdgeStyle(edge, {
+      "curve-style": "straight",
+      "edge-distances": "endpoints",
+      "source-endpoint": sourceEndpoint,
+      "target-endpoint": targetEndpoint
+    });
+    return;
+  }
+  const style = {
+    "curve-style": radius > 0 ? "round-segments" : "segments",
+    "edge-distances": "endpoints",
+    "source-endpoint": sourceEndpoint,
+    "target-endpoint": targetEndpoint,
+    "segment-weights": segmentWeights.join(" "),
+    "segment-distances": segmentDistances.join(" ")
+  };
+  if (radius > 0) {
+    style["segment-radii"] = String(radius);
+    style["radius-type"] = "arc-radius";
+  }
+  setElkEdgeStyle(edge, style);
+};
+var supportsRoundSegments = function(cy) {
+  const names = cy.style().propertyNames;
+  return Array.isArray(names) && names.indexOf("segment-radii") >= 0;
+};
 var makeGraph = function(nodes, edges, options) {
   const elkNodes = [];
   const elkEdges = [];
@@ -123205,6 +123738,34 @@ class Layout {
     const graph = makeGraph(nodes, edges, options);
     graph["layoutOptions"] = options.elk;
     elk.layout(graph).then(() => {
+      const nodePosLookup = {};
+      nodes.filter((n) => !n.isParent()).forEach((n) => {
+        nodePosLookup[n.id()] = getPos(n, options);
+      });
+      const styleEnabled = options.cy.styleEnabled();
+      if (styleEnabled) {
+        edges.forEach(clearElkEdgeStyle);
+      }
+      if (options.useElkEdgeGeometry && styleEnabled) {
+        const elkEdgeLookup = {};
+        const origins = getElkOrigins(graph);
+        const radius = supportsRoundSegments(options.cy) ? options.elkEdgeRadius || 0 : 0;
+        for (let i = 0;i < graph.edges.length; i++) {
+          elkEdgeLookup[graph.edges[i].id] = graph.edges[i];
+        }
+        edges.forEach((edge) => {
+          const elkEdge = elkEdgeLookup[edge.id()];
+          const sourcePos = nodePosLookup[edge.source().id()];
+          const targetPos = nodePosLookup[edge.target().id()];
+          if (edge.isLoop() || !elkEdge || !sourcePos || !targetPos) {
+            return;
+          }
+          const rawPoints = getElkEdgePoints(elkEdge, origins, graph.id);
+          const transform = (node, point) => options.transform ? options.transform(node, { x: point.x, y: point.y }) : point;
+          const points = rawPoints.map((point, i) => transform(i === rawPoints.length - 1 ? edge.target() : edge.source(), point));
+          applyElkEdgeGeometry(edge, points, transform(edge.source(), sourcePos), transform(edge.target(), targetPos), radius);
+        });
+      }
       nodes.filter((n) => !n.isParent()).layoutPositions(layout, options, (n) => getPos(n, options));
     });
     return this;
@@ -123520,7 +124081,7 @@ function updateRuntime(state, input) {
   applyKnownNodeSizes(state);
   state.loopSizer.update();
   const geometry = getGraphGeometryKey(state.cy);
-  const relayout = geometry !== state.geometryRef.current || hasGraphLayoutChanged(previous, input);
+  const relayout = hasGraphLayoutChanged(previous, input) || geometry !== state.geometryRef.current;
   state.geometryRef.current = geometry;
   if (!relayout) {
     if (previous?.zoomMode !== input.zoomMode || previous?.fitPadding !== input.fitPadding || previous?.minZoom !== input.minZoom || previous?.maxZoom !== input.maxZoom || previous?.minReadableLabelSize !== input.minReadableLabelSize || previous?.maxFitLabelSize !== input.maxFitLabelSize) {