@hpcc-js/tree 2.25.0 → 2.31.0

package/dist/index.js

@@ -5,8 +5,8 @@
 }(this, (function (exports, api, common) { 'use strict';
 
     var PKG_NAME = "@hpcc-js/tree";
-    var PKG_VERSION = "2.25.0";
-    var BUILD_VERSION = "2.76.0";
+    var PKG_VERSION = "2.31.0";
+    var BUILD_VERSION = "2.88.0";
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -329,83 +329,92 @@
       copy: node_copy
     };
 
-    function Node$1(value) {
-      this._ = value;
-      this.next = null;
-    }
+    var slice = Array.prototype.slice;
 
     function shuffle(array) {
-      var i,
-          n = (array = array.slice()).length,
-          head = null,
-          node = head;
-
-      while (n) {
-        var next = new Node$1(array[n - 1]);
-        if (node) node = node.next = next;
-        else node = head = next;
-        array[i] = array[--n];
+      var m = array.length,
+          t,
+          i;
+
+      while (m) {
+        i = Math.random() * m-- | 0;
+        t = array[m];
+        array[m] = array[i];
+        array[i] = t;
       }
 
-      return {
-        head: head,
-        tail: node
-      };
+      return array;
     }
 
     function enclose(circles) {
-      return encloseN(shuffle(circles), []);
-    }
+      var i = 0, n = (circles = shuffle(slice.call(circles))).length, B = [], p, e;
+
+      while (i < n) {
+        p = circles[i];
+        if (e && enclosesWeak(e, p)) ++i;
+        else e = encloseBasis(B = extendBasis(B, p)), i = 0;
+      }
 
-    function encloses(a, b) {
-      var dx = b.x - a.x,
-          dy = b.y - a.y,
-          dr = a.r - b.r;
-      return dr * dr + 1e-6 > dx * dx + dy * dy;
+      return e;
     }
 
-    // Returns the smallest circle that contains circles L and intersects circles B.
-    function encloseN(L, B) {
-      var circle,
-          l0 = null,
-          l1 = L.head,
-          l2,
-          p1;
+    function extendBasis(B, p) {
+      var i, j;
 
-      switch (B.length) {
-        case 1: circle = enclose1(B[0]); break;
-        case 2: circle = enclose2(B[0], B[1]); break;
-        case 3: circle = enclose3(B[0], B[1], B[2]); break;
+      if (enclosesWeakAll(p, B)) return [p];
+
+      // If we get here then B must have at least one element.
+      for (i = 0; i < B.length; ++i) {
+        if (enclosesNot(p, B[i])
+            && enclosesWeakAll(encloseBasis2(B[i], p), B)) {
+          return [B[i], p];
+        }
       }
 
-      while (l1) {
-        p1 = l1._, l2 = l1.next;
-        if (!circle || !encloses(circle, p1)) {
+      // If we get here then B must have at least two elements.
+      for (i = 0; i < B.length - 1; ++i) {
+        for (j = i + 1; j < B.length; ++j) {
+          if (enclosesNot(encloseBasis2(B[i], B[j]), p)
+              && enclosesNot(encloseBasis2(B[i], p), B[j])
+              && enclosesNot(encloseBasis2(B[j], p), B[i])
+              && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) {
+            return [B[i], B[j], p];
+          }
+        }
+      }
 
-          // Temporarily truncate L before l1.
-          if (l0) L.tail = l0, l0.next = null;
-          else L.head = L.tail = null;
+      // If we get here then something is very wrong.
+      throw new Error;
+    }
 
-          B.push(p1);
-          circle = encloseN(L, B); // Note: reorders L!
-          B.pop();
+    function enclosesNot(a, b) {
+      var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y;
+      return dr < 0 || dr * dr < dx * dx + dy * dy;
+    }
 
-          // Move l1 to the front of L and reconnect the truncated list L.
-          if (L.head) l1.next = L.head, L.head = l1;
-          else l1.next = null, L.head = L.tail = l1;
-          l0 = L.tail, l0.next = l2;
+    function enclosesWeak(a, b) {
+      var dr = a.r - b.r + 1e-6, dx = b.x - a.x, dy = b.y - a.y;
+      return dr > 0 && dr * dr > dx * dx + dy * dy;
+    }
 
-        } else {
-          l0 = l1;
+    function enclosesWeakAll(a, B) {
+      for (var i = 0; i < B.length; ++i) {
+        if (!enclosesWeak(a, B[i])) {
+          return false;
         }
-        l1 = l2;
       }
+      return true;
+    }
 
-      L.tail = l0;
-      return circle;
+    function encloseBasis(B) {
+      switch (B.length) {
+        case 1: return encloseBasis1(B[0]);
+        case 2: return encloseBasis2(B[0], B[1]);
+        case 3: return encloseBasis3(B[0], B[1], B[2]);
+      }
     }
 
-    function enclose1(a) {
+    function encloseBasis1(a) {
       return {
         x: a.x,
         y: a.y,
@@ -413,7 +422,7 @@
       };
     }
 
-    function enclose2(a, b) {
+    function encloseBasis2(a, b) {
       var x1 = a.x, y1 = a.y, r1 = a.r,
           x2 = b.x, y2 = b.y, r2 = b.r,
           x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1,
@@ -425,70 +434,74 @@
       };
     }
 
-    function enclose3(a, b, c) {
+    function encloseBasis3(a, b, c) {
       var x1 = a.x, y1 = a.y, r1 = a.r,
           x2 = b.x, y2 = b.y, r2 = b.r,
           x3 = c.x, y3 = c.y, r3 = c.r,
-          a2 = 2 * (x1 - x2),
-          b2 = 2 * (y1 - y2),
-          c2 = 2 * (r2 - r1),
-          d2 = x1 * x1 + y1 * y1 - r1 * r1 - x2 * x2 - y2 * y2 + r2 * r2,
-          a3 = 2 * (x1 - x3),
-          b3 = 2 * (y1 - y3),
-          c3 = 2 * (r3 - r1),
-          d3 = x1 * x1 + y1 * y1 - r1 * r1 - x3 * x3 - y3 * y3 + r3 * r3,
+          a2 = x1 - x2,
+          a3 = x1 - x3,
+          b2 = y1 - y2,
+          b3 = y1 - y3,
+          c2 = r2 - r1,
+          c3 = r3 - r1,
+          d1 = x1 * x1 + y1 * y1 - r1 * r1,
+          d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2,
+          d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3,
           ab = a3 * b2 - a2 * b3,
-          xa = (b2 * d3 - b3 * d2) / ab - x1,
+          xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1,
           xb = (b3 * c2 - b2 * c3) / ab,
-          ya = (a3 * d2 - a2 * d3) / ab - y1,
+          ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1,
           yb = (a2 * c3 - a3 * c2) / ab,
           A = xb * xb + yb * yb - 1,
-          B = 2 * (xa * xb + ya * yb + r1),
+          B = 2 * (r1 + xa * xb + ya * yb),
           C = xa * xa + ya * ya - r1 * r1,
-          r = (-B - Math.sqrt(B * B - 4 * A * C)) / (2 * A);
+          r = -(A ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B);
       return {
-        x: xa + xb * r + x1,
-        y: ya + yb * r + y1,
+        x: x1 + xa + xb * r,
+        y: y1 + ya + yb * r,
         r: r
       };
     }
 
-    function place(a, b, c) {
-      var ax = a.x,
-          ay = a.y,
-          da = b.r + c.r,
-          db = a.r + c.r,
-          dx = b.x - ax,
-          dy = b.y - ay,
-          dc = dx * dx + dy * dy;
-      if (dc) {
-        var x = 0.5 + ((db *= db) - (da *= da)) / (2 * dc),
-            y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);
-        c.x = ax + x * dx + y * dy;
-        c.y = ay + x * dy - y * dx;
+    function place(b, a, c) {
+      var dx = b.x - a.x, x, a2,
+          dy = b.y - a.y, y, b2,
+          d2 = dx * dx + dy * dy;
+      if (d2) {
+        a2 = a.r + c.r, a2 *= a2;
+        b2 = b.r + c.r, b2 *= b2;
+        if (a2 > b2) {
+          x = (d2 + b2 - a2) / (2 * d2);
+          y = Math.sqrt(Math.max(0, b2 / d2 - x * x));
+          c.x = b.x - x * dx - y * dy;
+          c.y = b.y - x * dy + y * dx;
+        } else {
+          x = (d2 + a2 - b2) / (2 * d2);
+          y = Math.sqrt(Math.max(0, a2 / d2 - x * x));
+          c.x = a.x + x * dx - y * dy;
+          c.y = a.y + x * dy + y * dx;
+        }
       } else {
-        c.x = ax + db;
-        c.y = ay;
+        c.x = a.x + c.r;
+        c.y = a.y;
       }
     }
 
     function intersects(a, b) {
-      var dx = b.x - a.x,
-          dy = b.y - a.y,
-          dr = a.r + b.r;
-      return dr * dr - 1e-6 > dx * dx + dy * dy;
+      var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y;
+      return dr > 0 && dr * dr > dx * dx + dy * dy;
     }
 
-    function distance2(node, x, y) {
+    function score(node) {
       var a = node._,
           b = node.next._,
           ab = a.r + b.r,
-          dx = (a.x * b.r + b.x * a.r) / ab - x,
-          dy = (a.y * b.r + b.y * a.r) / ab - y;
+          dx = (a.x * b.r + b.x * a.r) / ab,
+          dy = (a.y * b.r + b.y * a.r) / ab;
       return dx * dx + dy * dy;
     }
 
-    function Node$2(circle) {
+    function Node$1(circle) {
       this._ = circle;
       this.next = null;
       this.previous = null;
@@ -497,7 +510,7 @@
     function packEnclose(circles) {
       if (!(n = circles.length)) return 0;
 
-      var a, b, c, n;
+      var a, b, c, n, aa, ca, i, j, k, sj, sk;
 
       // Place the first circle.
       a = circles[0], a.x = 0, a.y = 0;
@@ -510,24 +523,15 @@
       // Place the third circle.
       place(b, a, c = circles[2]);
 
-      // Initialize the weighted centroid.
-      var aa = a.r * a.r,
-          ba = b.r * b.r,
-          ca = c.r * c.r,
-          oa = aa + ba + ca,
-          ox = aa * a.x + ba * b.x + ca * c.x,
-          oy = aa * a.y + ba * b.y + ca * c.y,
-          cx, cy, i, j, k, sj, sk;
-
       // Initialize the front-chain using the first three circles a, b and c.
-      a = new Node$2(a), b = new Node$2(b), c = new Node$2(c);
+      a = new Node$1(a), b = new Node$1(b), c = new Node$1(c);
       a.next = c.previous = b;
       b.next = a.previous = c;
       c.next = b.previous = a;
 
       // Attempt to place each remaining circle…
       pack: for (i = 3; i < n; ++i) {
-        place(a._, b._, c = circles[i]), c = new Node$2(c);
+        place(a._, b._, c = circles[i]), c = new Node$1(c);
 
         // Find the closest intersecting circle on the front-chain, if any.
         // “Closeness” is determined by linear distance along the front-chain.
@@ -552,15 +556,10 @@
         // Success! Insert the new circle c between a and b.
         c.previous = a, c.next = b, a.next = b.previous = b = c;
 
-        // Update the weighted centroid.
-        oa += ca = c._.r * c._.r;
-        ox += ca * c._.x;
-        oy += ca * c._.y;
-
         // Compute the new closest circle pair to the centroid.
-        aa = distance2(a, cx = ox / oa, cy = oy / oa);
+        aa = score(a);
         while ((c = c.next) !== b) {
-          if ((ca = distance2(c, cx, cy)) < aa) {
+          if ((ca = score(c)) < aa) {
             a = c, aa = ca;
           }
         }
@@ -2120,7 +2119,7 @@
         }
       },
       arc: function(x, y, r, a0, a1, ccw) {
-        x = +x, y = +y, r = +r;
+        x = +x, y = +y, r = +r, ccw = !!ccw;
         var dx = r * Math.cos(a0),
             dy = r * Math.sin(a0),
             x0 = x + dx,
@@ -2215,7 +2214,9 @@
     function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
       var x10 = x1 - x0, y10 = y1 - y0,
           x32 = x3 - x2, y32 = y3 - y2,
-          t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10);
+          t = y32 * x10 - x32 * y10;
+      if (t * t < epsilon$1) return;
+      t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
       return [x0 + t * x10, y0 + t * y10];
     }
 
@@ -2336,12 +2337,12 @@
             var x11 = r1 * cos(a11),
                 y11 = r1 * sin(a11),
                 x00 = r0 * cos(a00),
-                y00 = r0 * sin(a00);
+                y00 = r0 * sin(a00),
+                oc;
 
             // Restrict the corner radius according to the sector angle.
-            if (da < pi$1) {
-              var oc = da0 > epsilon$1 ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10],
-                  ax = x01 - oc[0],
+            if (da < pi$1 && (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10))) {
+              var ax = x01 - oc[0],
                   ay = y01 - oc[1],
                   bx = x11 - oc[0],
                   by = y11 - oc[1],
@@ -2448,103 +2449,6 @@
       return arc;
     }
 
-    function sign(x) {
-      return x < 0 ? -1 : 1;
-    }
-
-    // Calculate the slopes of the tangents (Hermite-type interpolation) based on
-    // the following paper: Steffen, M. 1990. A Simple Method for Monotonic
-    // Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.
-    // NOV(II), P. 443, 1990.
-    function slope3(that, x2, y2) {
-      var h0 = that._x1 - that._x0,
-          h1 = x2 - that._x1,
-          s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),
-          s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),
-          p = (s0 * h1 + s1 * h0) / (h0 + h1);
-      return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;
-    }
-
-    // Calculate a one-sided slope.
-    function slope2(that, t) {
-      var h = that._x1 - that._x0;
-      return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
-    }
-
-    // According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations
-    // "you can express cubic Hermite interpolation in terms of cubic Bézier curves
-    // with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1".
-    function point(that, t0, t1) {
-      var x0 = that._x0,
-          y0 = that._y0,
-          x1 = that._x1,
-          y1 = that._y1,
-          dx = (x1 - x0) / 3;
-      that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);
-    }
-
-    function MonotoneX(context) {
-      this._context = context;
-    }
-
-    MonotoneX.prototype = {
-      areaStart: function() {
-        this._line = 0;
-      },
-      areaEnd: function() {
-        this._line = NaN;
-      },
-      lineStart: function() {
-        this._x0 = this._x1 =
-        this._y0 = this._y1 =
-        this._t0 = NaN;
-        this._point = 0;
-      },
-      lineEnd: function() {
-        switch (this._point) {
-          case 2: this._context.lineTo(this._x1, this._y1); break;
-          case 3: point(this, this._t0, slope2(this, this._t0)); break;
-        }
-        if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
-        this._line = 1 - this._line;
-      },
-      point: function(x, y) {
-        var t1 = NaN;
-
-        x = +x, y = +y;
-        if (x === this._x1 && y === this._y1) return; // Ignore coincident points.
-        switch (this._point) {
-          case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
-          case 1: this._point = 2; break;
-          case 2: this._point = 3; point(this, slope2(this, t1 = slope3(this, x, y)), t1); break;
-          default: point(this, this._t0, t1 = slope3(this, x, y)); break;
-        }
-
-        this._x0 = this._x1, this._x1 = x;
-        this._y0 = this._y1, this._y1 = y;
-        this._t0 = t1;
-      }
-    };
-
-    function MonotoneY(context) {
-      this._context = new ReflectContext(context);
-    }
-
-    (MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {
-      MonotoneX.prototype.point.call(this, y, x);
-    };
-
-    function ReflectContext(context) {
-      this._context = context;
-    }
-
-    ReflectContext.prototype = {
-      moveTo: function(x, y) { this._context.moveTo(y, x); },
-      closePath: function() { this._context.closePath(); },
-      lineTo: function(x, y) { this._context.lineTo(y, x); },
-      bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }
-    };
-
     var css_248z$3 = ".tree_Sunburst path{stroke:#fff;stroke-width:.5px;fill-rule:evenodd}";
     styleInject(css_248z$3);