victory-vendor 36.4.0

package/lib-vendor/d3-array/src/count.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = count;
+
+function count(values, valueof) {
+  let count = 0;
+
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        ++count;
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        ++count;
+      }
+    }
+  }
+
+  return count;
+}

package/lib-vendor/d3-array/src/cross.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cross;
+
+function length(array) {
+  return array.length | 0;
+}
+
+function empty(length) {
+  return !(length > 0);
+}
+
+function arrayify(values) {
+  return typeof values !== "object" || "length" in values ? values : Array.from(values);
+}
+
+function reducer(reduce) {
+  return values => reduce(...values);
+}
+
+function cross(...values) {
+  const reduce = typeof values[values.length - 1] === "function" && reducer(values.pop());
+  values = values.map(arrayify);
+  const lengths = values.map(length);
+  const j = values.length - 1;
+  const index = new Array(j + 1).fill(0);
+  const product = [];
+  if (j < 0 || lengths.some(empty)) return product;
+
+  while (true) {
+    product.push(index.map((j, i) => values[i][j]));
+    let i = j;
+
+    while (++index[i] === lengths[i]) {
+      if (i === 0) return reduce ? product.map(reduce) : product;
+      index[i--] = 0;
+    }
+  }
+}

package/lib-vendor/d3-array/src/cumsum.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cumsum;
+
+function cumsum(values, valueof) {
+  var sum = 0,
+      index = 0;
+  return Float64Array.from(values, valueof === undefined ? v => sum += +v || 0 : v => sum += +valueof(v, index++, values) || 0);
+}

package/lib-vendor/d3-array/src/descending.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = descending;
+
+function descending(a, b) {
+  return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}

package/lib-vendor/d3-array/src/deviation.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = deviation;
+
+var _variance = _interopRequireDefault(require("./variance.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function deviation(values, valueof) {
+  const v = (0, _variance.default)(values, valueof);
+  return v ? Math.sqrt(v) : v;
+}

package/lib-vendor/d3-array/src/difference.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = difference;
+
+var _index = require("../../../lib-vendor/internmap/src/index.js");
+
+function difference(values, ...others) {
+  values = new _index.InternSet(values);
+
+  for (const other of others) {
+    for (const value of other) {
+      values.delete(value);
+    }
+  }
+
+  return values;
+}

package/lib-vendor/d3-array/src/disjoint.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = disjoint;
+
+var _index = require("../../../lib-vendor/internmap/src/index.js");
+
+function disjoint(values, other) {
+  const iterator = other[Symbol.iterator](),
+        set = new _index.InternSet();
+
+  for (const v of values) {
+    if (set.has(v)) return false;
+    let value, done;
+
+    while (({
+      value,
+      done
+    } = iterator.next())) {
+      if (done) break;
+      if (Object.is(v, value)) return false;
+      set.add(value);
+    }
+  }
+
+  return true;
+}

package/lib-vendor/d3-array/src/every.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = every;
+
+function every(values, test) {
+  if (typeof test !== "function") throw new TypeError("test is not a function");
+  let index = -1;
+
+  for (const value of values) {
+    if (!test(value, ++index, values)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/lib-vendor/d3-array/src/extent.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = extent;
+
+function extent(values, valueof) {
+  let min;
+  let max;
+
+  if (valueof === undefined) {
+    for (const value of values) {
+      if (value != null) {
+        if (min === undefined) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null) {
+        if (min === undefined) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    }
+  }
+
+  return [min, max];
+}

package/lib-vendor/d3-array/src/filter.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = filter;
+
+function filter(values, test) {
+  if (typeof test !== "function") throw new TypeError("test is not a function");
+  const array = [];
+  let index = -1;
+
+  for (const value of values) {
+    if (test(value, ++index, values)) {
+      array.push(value);
+    }
+  }
+
+  return array;
+}

package/lib-vendor/d3-array/src/fsum.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Adder = void 0;
+exports.fcumsum = fcumsum;
+exports.fsum = fsum;
+
+// https://github.com/python/cpython/blob/a74eea238f5baba15797e2e8b570d153bc8690a7/Modules/mathmodule.c#L1423
+class Adder {
+  constructor() {
+    this._partials = new Float64Array(32);
+    this._n = 0;
+  }
+
+  add(x) {
+    const p = this._partials;
+    let i = 0;
+
+    for (let j = 0; j < this._n && j < 32; j++) {
+      const y = p[j],
+            hi = x + y,
+            lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
+      if (lo) p[i++] = lo;
+      x = hi;
+    }
+
+    p[i] = x;
+    this._n = i + 1;
+    return this;
+  }
+
+  valueOf() {
+    const p = this._partials;
+    let n = this._n,
+        x,
+        y,
+        lo,
+        hi = 0;
+
+    if (n > 0) {
+      hi = p[--n];
+
+      while (n > 0) {
+        x = hi;
+        y = p[--n];
+        hi = x + y;
+        lo = y - (hi - x);
+        if (lo) break;
+      }
+
+      if (n > 0 && (lo < 0 && p[n - 1] < 0 || lo > 0 && p[n - 1] > 0)) {
+        y = lo * 2;
+        x = hi + y;
+        if (y == x - hi) hi = x;
+      }
+    }
+
+    return hi;
+  }
+
+}
+
+exports.Adder = Adder;
+
+function fsum(values, valueof) {
+  const adder = new Adder();
+
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value = +value) {
+        adder.add(value);
+      }
+    }
+  } else {
+    let index = -1;
+
+    for (let value of values) {
+      if (value = +valueof(value, ++index, values)) {
+        adder.add(value);
+      }
+    }
+  }
+
+  return +adder;
+}
+
+function fcumsum(values, valueof) {
+  const adder = new Adder();
+  let index = -1;
+  return Float64Array.from(values, valueof === undefined ? v => adder.add(+v || 0) : v => adder.add(+valueof(v, ++index, values) || 0));
+}

package/lib-vendor/d3-array/src/greatest.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = greatest;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function greatest(values, compare = _ascending.default) {
+  let max;
+  let defined = false;
+
+  if (compare.length === 1) {
+    let maxValue;
+
+    for (const element of values) {
+      const value = compare(element);
+
+      if (defined ? (0, _ascending.default)(value, maxValue) > 0 : (0, _ascending.default)(value, value) === 0) {
+        max = element;
+        maxValue = value;
+        defined = true;
+      }
+    }
+  } else {
+    for (const value of values) {
+      if (defined ? compare(value, max) > 0 : compare(value, value) === 0) {
+        max = value;
+        defined = true;
+      }
+    }
+  }
+
+  return max;
+}

package/lib-vendor/d3-array/src/greatestIndex.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = greatestIndex;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+var _maxIndex = _interopRequireDefault(require("./maxIndex.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function greatestIndex(values, compare = _ascending.default) {
+  if (compare.length === 1) return (0, _maxIndex.default)(values, compare);
+  let maxValue;
+  let max = -1;
+  let index = -1;
+
+  for (const value of values) {
+    ++index;
+
+    if (max < 0 ? compare(value, value) === 0 : compare(value, maxValue) > 0) {
+      maxValue = value;
+      max = index;
+    }
+  }
+
+  return max;
+}

package/lib-vendor/d3-array/src/group.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = group;
+exports.flatGroup = flatGroup;
+exports.flatRollup = flatRollup;
+exports.groups = groups;
+exports.index = index;
+exports.indexes = indexes;
+exports.rollup = rollup;
+exports.rollups = rollups;
+
+var _index = require("../../../lib-vendor/internmap/src/index.js");
+
+var _identity = _interopRequireDefault(require("./identity.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function group(values, ...keys) {
+  return nest(values, _identity.default, _identity.default, keys);
+}
+
+function groups(values, ...keys) {
+  return nest(values, Array.from, _identity.default, keys);
+}
+
+function flatten(groups, keys) {
+  for (let i = 1, n = keys.length; i < n; ++i) {
+    groups = groups.flatMap(g => g.pop().map(([key, value]) => [...g, key, value]));
+  }
+
+  return groups;
+}
+
+function flatGroup(values, ...keys) {
+  return flatten(groups(values, ...keys), keys);
+}
+
+function flatRollup(values, reduce, ...keys) {
+  return flatten(rollups(values, reduce, ...keys), keys);
+}
+
+function rollup(values, reduce, ...keys) {
+  return nest(values, _identity.default, reduce, keys);
+}
+
+function rollups(values, reduce, ...keys) {
+  return nest(values, Array.from, reduce, keys);
+}
+
+function index(values, ...keys) {
+  return nest(values, _identity.default, unique, keys);
+}
+
+function indexes(values, ...keys) {
+  return nest(values, Array.from, unique, keys);
+}
+
+function unique(values) {
+  if (values.length !== 1) throw new Error("duplicate key");
+  return values[0];
+}
+
+function nest(values, map, reduce, keys) {
+  return function regroup(values, i) {
+    if (i >= keys.length) return reduce(values);
+    const groups = new _index.InternMap();
+    const keyof = keys[i++];
+    let index = -1;
+
+    for (const value of values) {
+      const key = keyof(value, ++index, values);
+      const group = groups.get(key);
+      if (group) group.push(value);else groups.set(key, [value]);
+    }
+
+    for (const [key, values] of groups) {
+      groups.set(key, regroup(values, i));
+    }
+
+    return map(groups);
+  }(values, 0);
+}

package/lib-vendor/d3-array/src/groupSort.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = groupSort;
+
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+
+var _group = _interopRequireWildcard(require("./group.js"));
+
+var _sort = _interopRequireDefault(require("./sort.js"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function groupSort(values, reduce, key) {
+  return (reduce.length !== 2 ? (0, _sort.default)((0, _group.rollup)(values, reduce, key), ([ak, av], [bk, bv]) => (0, _ascending.default)(av, bv) || (0, _ascending.default)(ak, bk)) : (0, _sort.default)((0, _group.default)(values, key), ([ak, av], [bk, bv]) => reduce(av, bv) || (0, _ascending.default)(ak, bk))).map(([key]) => key);
+}

package/lib-vendor/d3-array/src/identity.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = identity;
+
+function identity(x) {
+  return x;
+}