@hpcc-js/common 2.71.15 → 2.71.16

package/dist/index.js

@@ -5,8 +5,8 @@
 })(this, (function (exports, util) { 'use strict';
 
   var PKG_NAME = "@hpcc-js/common";
-  var PKG_VERSION = "2.71.15";
-  var BUILD_VERSION = "2.104.37";
+  var PKG_VERSION = "2.71.16";
+  var BUILD_VERSION = "2.105.6";
 
   /******************************************************************************
   Copyright (c) Microsoft Corporation.
@@ -3464,12 +3464,12 @@
     return null;
   }
 
-  function ascending(a, b) {
+  function d3Ascending(a, b) {
     return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
   }
 
-  function bisector(compare) {
-    if (compare.length === 1) compare = ascendingComparator(compare);
+  function bisector$1(compare) {
+    if (compare.length === 1) compare = ascendingComparator$1(compare);
     return {
       left: function(a, x, lo, hi) {
         if (lo == null) lo = 0;
@@ -3494,15 +3494,15 @@
     };
   }
 
-  function ascendingComparator(f) {
+  function ascendingComparator$1(f) {
     return function(d, x) {
-      return ascending(f(d), x);
+      return d3Ascending(f(d), x);
     };
   }
 
-  var ascendingBisect = bisector(ascending);
-  var bisectRight = ascendingBisect.right;
-  var bisectLeft = ascendingBisect.left;
+  var ascendingBisect$1 = bisector$1(d3Ascending);
+  var bisectRight$1 = ascendingBisect$1.right;
+  var bisectLeft = ascendingBisect$1.left;
 
   function pairs(array, f) {
     if (f == null) f = pair;
@@ -3539,7 +3539,7 @@
     return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
   }
 
-  function number$2(x) {
+  function number$3(x) {
     return x === null ? NaN : +x;
   }
 
@@ -3554,7 +3554,7 @@
 
     if (valueof == null) {
       while (++i < n) {
-        if (!isNaN(value = number$2(values[i]))) {
+        if (!isNaN(value = number$3(values[i]))) {
           delta = value - mean;
           mean += delta / ++m;
           sum += delta * (value - mean);
@@ -3564,7 +3564,7 @@
 
     else {
       while (++i < n) {
-        if (!isNaN(value = number$2(valueof(values[i], i, values)))) {
+        if (!isNaN(value = number$3(valueof(values[i], i, values)))) {
           delta = value - mean;
           mean += delta / ++m;
           sum += delta * (value - mean);
@@ -3633,7 +3633,7 @@
     return x;
   }
 
-  function sequence(start, stop, step) {
+  function range(start, stop, step) {
     start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
 
     var i = -1,
@@ -3647,11 +3647,11 @@
     return range;
   }
 
-  var e10 = Math.sqrt(50),
-      e5 = Math.sqrt(10),
-      e2 = Math.sqrt(2);
+  var e10$1 = Math.sqrt(50),
+      e5$1 = Math.sqrt(10),
+      e2$1 = Math.sqrt(2);
 
-  function ticks(start, stop, count) {
+  function ticks$1(start, stop, count) {
     var reverse,
         i = -1,
         n,
@@ -3661,7 +3661,7 @@
     stop = +stop, start = +start, count = +count;
     if (start === stop && count > 0) return [start];
     if (reverse = stop < start) n = start, start = stop, stop = n;
-    if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+    if ((step = tickIncrement$1(start, stop, count)) === 0 || !isFinite(step)) return [];
 
     if (step > 0) {
       start = Math.ceil(start / step);
@@ -3680,22 +3680,22 @@
     return ticks;
   }
 
-  function tickIncrement(start, stop, count) {
+  function tickIncrement$1(start, stop, count) {
     var step = (stop - start) / Math.max(0, count),
         power = Math.floor(Math.log(step) / Math.LN10),
         error = step / Math.pow(10, power);
     return power >= 0
-        ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
-        : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+        ? (error >= e10$1 ? 10 : error >= e5$1 ? 5 : error >= e2$1 ? 2 : 1) * Math.pow(10, power)
+        : -Math.pow(10, -power) / (error >= e10$1 ? 10 : error >= e5$1 ? 5 : error >= e2$1 ? 2 : 1);
   }
 
-  function tickStep(start, stop, count) {
+  function tickStep$1(start, stop, count) {
     var step0 = Math.abs(stop - start) / Math.max(0, count),
         step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
         error = step0 / step1;
-    if (error >= e10) step1 *= 10;
-    else if (error >= e5) step1 *= 5;
-    else if (error >= e2) step1 *= 2;
+    if (error >= e10$1) step1 *= 10;
+    else if (error >= e5$1) step1 *= 5;
+    else if (error >= e2$1) step1 *= 2;
     return stop < start ? -step1 : step1;
   }
 
@@ -3725,8 +3725,8 @@
 
       // Convert number of thresholds into uniform thresholds.
       if (!Array.isArray(tz)) {
-        tz = tickStep(x0, x1, tz);
-        tz = sequence(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
+        tz = tickStep$1(x0, x1, tz);
+        tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
       }
 
       // Remove any thresholds outside the domain.
@@ -3748,7 +3748,7 @@
       for (i = 0; i < n; ++i) {
         x = values[i];
         if (x0 <= x && x <= x1) {
-          bins[bisectRight(tz, x, 0, m)].push(data[i]);
+          bins[bisectRight$1(tz, x, 0, m)].push(data[i]);
         }
       }
 
@@ -3770,8 +3770,8 @@
     return histogram;
   }
 
-  function threshold$1(values, p, valueof) {
-    if (valueof == null) valueof = number$2;
+  function quantile$1(values, p, valueof) {
+    if (valueof == null) valueof = number$3;
     if (!(n = values.length)) return;
     if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
     if (p >= 1) return +valueof(values[n - 1], n - 1, values);
@@ -3784,8 +3784,8 @@
   }
 
   function freedmanDiaconis(values, min, max) {
-    values = map$3.call(values, number$2).sort(ascending);
-    return Math.ceil((max - min) / (2 * (threshold$1(values, 0.75) - threshold$1(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+    values = map$3.call(values, number$3).sort(d3Ascending);
+    return Math.ceil((max - min) / (2 * (quantile$1(values, 0.75) - quantile$1(values, 0.25)) * Math.pow(values.length, -1 / 3)));
   }
 
   function scott(values, min, max) {
@@ -3836,14 +3836,14 @@
 
     if (valueof == null) {
       while (++i < n) {
-        if (!isNaN(value = number$2(values[i]))) sum += value;
+        if (!isNaN(value = number$3(values[i]))) sum += value;
         else --m;
       }
     }
 
     else {
       while (++i < n) {
-        if (!isNaN(value = number$2(valueof(values[i], i, values)))) sum += value;
+        if (!isNaN(value = number$3(valueof(values[i], i, values)))) sum += value;
         else --m;
       }
     }
@@ -3859,7 +3859,7 @@
 
     if (valueof == null) {
       while (++i < n) {
-        if (!isNaN(value = number$2(values[i]))) {
+        if (!isNaN(value = number$3(values[i]))) {
           numbers.push(value);
         }
       }
@@ -3867,13 +3867,13 @@
 
     else {
       while (++i < n) {
-        if (!isNaN(value = number$2(valueof(values[i], i, values)))) {
+        if (!isNaN(value = number$3(valueof(values[i], i, values)))) {
           numbers.push(value);
         }
       }
     }
 
-    return threshold$1(numbers.sort(ascending), 0.5);
+    return quantile$1(numbers.sort(d3Ascending), 0.5);
   }
 
   function merge(arrays) {
@@ -3947,7 +3947,7 @@
         xi,
         xj = values[j];
 
-    if (compare == null) compare = ascending;
+    if (compare == null) compare = d3Ascending;
 
     while (++i < n) {
       if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
@@ -7028,7 +7028,7 @@
                   var lVal = l[sortBy[i].idx];
                   var rVal = r[sortBy[i].idx];
                   if (lVal !== rVal) {
-                      return sortBy[i].reverse ? d3Descending(lVal, rVal) : ascending(lVal, rVal);
+                      return sortBy[i].reverse ? d3Descending(lVal, rVal) : d3Ascending(lVal, rVal);
                   }
               }
               return 0;
@@ -10121,6 +10121,128 @@
     'default': index
   });
 
+  function ascending(a, b) {
+    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+  }
+
+  function bisector(compare) {
+    if (compare.length === 1) compare = ascendingComparator(compare);
+    return {
+      left: function(a, x, lo, hi) {
+        if (lo == null) lo = 0;
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+          var mid = lo + hi >>> 1;
+          if (compare(a[mid], x) < 0) lo = mid + 1;
+          else hi = mid;
+        }
+        return lo;
+      },
+      right: function(a, x, lo, hi) {
+        if (lo == null) lo = 0;
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+          var mid = lo + hi >>> 1;
+          if (compare(a[mid], x) > 0) hi = mid;
+          else lo = mid + 1;
+        }
+        return lo;
+      }
+    };
+  }
+
+  function ascendingComparator(f) {
+    return function(d, x) {
+      return ascending(f(d), x);
+    };
+  }
+
+  var ascendingBisect = bisector(ascending);
+  var bisectRight = ascendingBisect.right;
+
+  function number$2(x) {
+    return x === null ? NaN : +x;
+  }
+
+  function sequence(start, stop, step) {
+    start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+
+    var i = -1,
+        n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+        range = new Array(n);
+
+    while (++i < n) {
+      range[i] = start + i * step;
+    }
+
+    return range;
+  }
+
+  var e10 = Math.sqrt(50),
+      e5 = Math.sqrt(10),
+      e2 = Math.sqrt(2);
+
+  function ticks(start, stop, count) {
+    var reverse,
+        i = -1,
+        n,
+        ticks,
+        step;
+
+    stop = +stop, start = +start, count = +count;
+    if (start === stop && count > 0) return [start];
+    if (reverse = stop < start) n = start, start = stop, stop = n;
+    if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+    if (step > 0) {
+      start = Math.ceil(start / step);
+      stop = Math.floor(stop / step);
+      ticks = new Array(n = Math.ceil(stop - start + 1));
+      while (++i < n) ticks[i] = (start + i) * step;
+    } else {
+      start = Math.floor(start * step);
+      stop = Math.ceil(stop * step);
+      ticks = new Array(n = Math.ceil(start - stop + 1));
+      while (++i < n) ticks[i] = (start - i) / step;
+    }
+
+    if (reverse) ticks.reverse();
+
+    return ticks;
+  }
+
+  function tickIncrement(start, stop, count) {
+    var step = (stop - start) / Math.max(0, count),
+        power = Math.floor(Math.log(step) / Math.LN10),
+        error = step / Math.pow(10, power);
+    return power >= 0
+        ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
+        : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+  }
+
+  function tickStep(start, stop, count) {
+    var step0 = Math.abs(stop - start) / Math.max(0, count),
+        step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+        error = step0 / step1;
+    if (error >= e10) step1 *= 10;
+    else if (error >= e5) step1 *= 5;
+    else if (error >= e2) step1 *= 2;
+    return stop < start ? -step1 : step1;
+  }
+
+  function threshold$1(values, p, valueof) {
+    if (valueof == null) valueof = number$2;
+    if (!(n = values.length)) return;
+    if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+    if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+    var n,
+        i = (n - 1) * p,
+        i0 = Math.floor(i),
+        value0 = +valueof(values[i0], i0, values),
+        value1 = +valueof(values[i0 + 1], i0 + 1, values);
+    return value0 + (value1 - value0) * (i - i0);
+  }
+
   var array = Array.prototype;
 
   var map = array.map;
@@ -15140,12 +15262,12 @@
   exports.Widget = Widget;
   exports.WidgetArray = WidgetArray;
   exports.active = active;
-  exports.ascending = ascending;
+  exports.ascending = d3Ascending;
   exports.autoType = autoType;
-  exports.bisect = bisectRight;
+  exports.bisect = bisectRight$1;
   exports.bisectLeft = bisectLeft;
-  exports.bisectRight = bisectRight;
-  exports.bisector = bisector;
+  exports.bisectRight = bisectRight$1;
+  exports.bisector = bisector$1;
   exports.brush = brush;
   exports.brushSelection = brushSelection;
   exports.brushX = brushX;
@@ -15278,9 +15400,9 @@
   exports.precisionRound = precisionRound;
   exports.publish = publish;
   exports.publishProxy = publishProxy;
-  exports.quantile = threshold$1;
+  exports.quantile = quantile$1;
   exports.quantize = quantize$1;
-  exports.range = sequence;
+  exports.range = range;
   exports.rgb = rgb;
   exports.scaleBand = band;
   exports.scaleIdentity = identity$1;
@@ -15314,9 +15436,9 @@
   exports.thresholdFreedmanDiaconis = freedmanDiaconis;
   exports.thresholdScott = scott;
   exports.thresholdSturges = sturges;
-  exports.tickIncrement = tickIncrement;
-  exports.tickStep = tickStep;
-  exports.ticks = ticks;
+  exports.tickIncrement = tickIncrement$1;
+  exports.tickStep = tickStep$1;
+  exports.ticks = ticks$1;
   exports.timeFormatDefaultLocale = defaultLocale;
   exports.timeFormatLocale = formatLocale;
   exports.touch = touch;