@mui/x-charts-vendor 7.12.0

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

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = greatestIndex;
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+var _maxIndex = _interopRequireDefault(require("./maxIndex.js"));
+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,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 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,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = identity;
+function identity(x) {
+  return x;
+}

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

@@ -0,0 +1,539 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Adder", {
+  enumerable: true,
+  get: function () {
+    return _fsum.Adder;
+  }
+});
+Object.defineProperty(exports, "InternMap", {
+  enumerable: true,
+  get: function () {
+    return _index.InternMap;
+  }
+});
+Object.defineProperty(exports, "InternSet", {
+  enumerable: true,
+  get: function () {
+    return _index.InternSet;
+  }
+});
+Object.defineProperty(exports, "ascending", {
+  enumerable: true,
+  get: function () {
+    return _ascending.default;
+  }
+});
+Object.defineProperty(exports, "bin", {
+  enumerable: true,
+  get: function () {
+    return _bin.default;
+  }
+});
+Object.defineProperty(exports, "bisect", {
+  enumerable: true,
+  get: function () {
+    return _bisect.default;
+  }
+});
+Object.defineProperty(exports, "bisectCenter", {
+  enumerable: true,
+  get: function () {
+    return _bisect.bisectCenter;
+  }
+});
+Object.defineProperty(exports, "bisectLeft", {
+  enumerable: true,
+  get: function () {
+    return _bisect.bisectLeft;
+  }
+});
+Object.defineProperty(exports, "bisectRight", {
+  enumerable: true,
+  get: function () {
+    return _bisect.bisectRight;
+  }
+});
+Object.defineProperty(exports, "bisector", {
+  enumerable: true,
+  get: function () {
+    return _bisector.default;
+  }
+});
+Object.defineProperty(exports, "blur", {
+  enumerable: true,
+  get: function () {
+    return _blur.blur;
+  }
+});
+Object.defineProperty(exports, "blur2", {
+  enumerable: true,
+  get: function () {
+    return _blur.blur2;
+  }
+});
+Object.defineProperty(exports, "blurImage", {
+  enumerable: true,
+  get: function () {
+    return _blur.blurImage;
+  }
+});
+Object.defineProperty(exports, "count", {
+  enumerable: true,
+  get: function () {
+    return _count.default;
+  }
+});
+Object.defineProperty(exports, "cross", {
+  enumerable: true,
+  get: function () {
+    return _cross.default;
+  }
+});
+Object.defineProperty(exports, "cumsum", {
+  enumerable: true,
+  get: function () {
+    return _cumsum.default;
+  }
+});
+Object.defineProperty(exports, "descending", {
+  enumerable: true,
+  get: function () {
+    return _descending.default;
+  }
+});
+Object.defineProperty(exports, "deviation", {
+  enumerable: true,
+  get: function () {
+    return _deviation.default;
+  }
+});
+Object.defineProperty(exports, "difference", {
+  enumerable: true,
+  get: function () {
+    return _difference.default;
+  }
+});
+Object.defineProperty(exports, "disjoint", {
+  enumerable: true,
+  get: function () {
+    return _disjoint.default;
+  }
+});
+Object.defineProperty(exports, "every", {
+  enumerable: true,
+  get: function () {
+    return _every.default;
+  }
+});
+Object.defineProperty(exports, "extent", {
+  enumerable: true,
+  get: function () {
+    return _extent.default;
+  }
+});
+Object.defineProperty(exports, "fcumsum", {
+  enumerable: true,
+  get: function () {
+    return _fsum.fcumsum;
+  }
+});
+Object.defineProperty(exports, "filter", {
+  enumerable: true,
+  get: function () {
+    return _filter.default;
+  }
+});
+Object.defineProperty(exports, "flatGroup", {
+  enumerable: true,
+  get: function () {
+    return _group.flatGroup;
+  }
+});
+Object.defineProperty(exports, "flatRollup", {
+  enumerable: true,
+  get: function () {
+    return _group.flatRollup;
+  }
+});
+Object.defineProperty(exports, "fsum", {
+  enumerable: true,
+  get: function () {
+    return _fsum.fsum;
+  }
+});
+Object.defineProperty(exports, "greatest", {
+  enumerable: true,
+  get: function () {
+    return _greatest.default;
+  }
+});
+Object.defineProperty(exports, "greatestIndex", {
+  enumerable: true,
+  get: function () {
+    return _greatestIndex.default;
+  }
+});
+Object.defineProperty(exports, "group", {
+  enumerable: true,
+  get: function () {
+    return _group.default;
+  }
+});
+Object.defineProperty(exports, "groupSort", {
+  enumerable: true,
+  get: function () {
+    return _groupSort.default;
+  }
+});
+Object.defineProperty(exports, "groups", {
+  enumerable: true,
+  get: function () {
+    return _group.groups;
+  }
+});
+Object.defineProperty(exports, "histogram", {
+  enumerable: true,
+  get: function () {
+    return _bin.default;
+  }
+});
+Object.defineProperty(exports, "index", {
+  enumerable: true,
+  get: function () {
+    return _group.index;
+  }
+});
+Object.defineProperty(exports, "indexes", {
+  enumerable: true,
+  get: function () {
+    return _group.indexes;
+  }
+});
+Object.defineProperty(exports, "intersection", {
+  enumerable: true,
+  get: function () {
+    return _intersection.default;
+  }
+});
+Object.defineProperty(exports, "least", {
+  enumerable: true,
+  get: function () {
+    return _least.default;
+  }
+});
+Object.defineProperty(exports, "leastIndex", {
+  enumerable: true,
+  get: function () {
+    return _leastIndex.default;
+  }
+});
+Object.defineProperty(exports, "map", {
+  enumerable: true,
+  get: function () {
+    return _map.default;
+  }
+});
+Object.defineProperty(exports, "max", {
+  enumerable: true,
+  get: function () {
+    return _max.default;
+  }
+});
+Object.defineProperty(exports, "maxIndex", {
+  enumerable: true,
+  get: function () {
+    return _maxIndex.default;
+  }
+});
+Object.defineProperty(exports, "mean", {
+  enumerable: true,
+  get: function () {
+    return _mean.default;
+  }
+});
+Object.defineProperty(exports, "median", {
+  enumerable: true,
+  get: function () {
+    return _median.default;
+  }
+});
+Object.defineProperty(exports, "medianIndex", {
+  enumerable: true,
+  get: function () {
+    return _median.medianIndex;
+  }
+});
+Object.defineProperty(exports, "merge", {
+  enumerable: true,
+  get: function () {
+    return _merge.default;
+  }
+});
+Object.defineProperty(exports, "min", {
+  enumerable: true,
+  get: function () {
+    return _min.default;
+  }
+});
+Object.defineProperty(exports, "minIndex", {
+  enumerable: true,
+  get: function () {
+    return _minIndex.default;
+  }
+});
+Object.defineProperty(exports, "mode", {
+  enumerable: true,
+  get: function () {
+    return _mode.default;
+  }
+});
+Object.defineProperty(exports, "nice", {
+  enumerable: true,
+  get: function () {
+    return _nice.default;
+  }
+});
+Object.defineProperty(exports, "pairs", {
+  enumerable: true,
+  get: function () {
+    return _pairs.default;
+  }
+});
+Object.defineProperty(exports, "permute", {
+  enumerable: true,
+  get: function () {
+    return _permute.default;
+  }
+});
+Object.defineProperty(exports, "quantile", {
+  enumerable: true,
+  get: function () {
+    return _quantile.default;
+  }
+});
+Object.defineProperty(exports, "quantileIndex", {
+  enumerable: true,
+  get: function () {
+    return _quantile.quantileIndex;
+  }
+});
+Object.defineProperty(exports, "quantileSorted", {
+  enumerable: true,
+  get: function () {
+    return _quantile.quantileSorted;
+  }
+});
+Object.defineProperty(exports, "quickselect", {
+  enumerable: true,
+  get: function () {
+    return _quickselect.default;
+  }
+});
+Object.defineProperty(exports, "range", {
+  enumerable: true,
+  get: function () {
+    return _range.default;
+  }
+});
+Object.defineProperty(exports, "rank", {
+  enumerable: true,
+  get: function () {
+    return _rank.default;
+  }
+});
+Object.defineProperty(exports, "reduce", {
+  enumerable: true,
+  get: function () {
+    return _reduce.default;
+  }
+});
+Object.defineProperty(exports, "reverse", {
+  enumerable: true,
+  get: function () {
+    return _reverse.default;
+  }
+});
+Object.defineProperty(exports, "rollup", {
+  enumerable: true,
+  get: function () {
+    return _group.rollup;
+  }
+});
+Object.defineProperty(exports, "rollups", {
+  enumerable: true,
+  get: function () {
+    return _group.rollups;
+  }
+});
+Object.defineProperty(exports, "scan", {
+  enumerable: true,
+  get: function () {
+    return _scan.default;
+  }
+});
+Object.defineProperty(exports, "shuffle", {
+  enumerable: true,
+  get: function () {
+    return _shuffle.default;
+  }
+});
+Object.defineProperty(exports, "shuffler", {
+  enumerable: true,
+  get: function () {
+    return _shuffle.shuffler;
+  }
+});
+Object.defineProperty(exports, "some", {
+  enumerable: true,
+  get: function () {
+    return _some.default;
+  }
+});
+Object.defineProperty(exports, "sort", {
+  enumerable: true,
+  get: function () {
+    return _sort.default;
+  }
+});
+Object.defineProperty(exports, "subset", {
+  enumerable: true,
+  get: function () {
+    return _subset.default;
+  }
+});
+Object.defineProperty(exports, "sum", {
+  enumerable: true,
+  get: function () {
+    return _sum.default;
+  }
+});
+Object.defineProperty(exports, "superset", {
+  enumerable: true,
+  get: function () {
+    return _superset.default;
+  }
+});
+Object.defineProperty(exports, "thresholdFreedmanDiaconis", {
+  enumerable: true,
+  get: function () {
+    return _freedmanDiaconis.default;
+  }
+});
+Object.defineProperty(exports, "thresholdScott", {
+  enumerable: true,
+  get: function () {
+    return _scott.default;
+  }
+});
+Object.defineProperty(exports, "thresholdSturges", {
+  enumerable: true,
+  get: function () {
+    return _sturges.default;
+  }
+});
+Object.defineProperty(exports, "tickIncrement", {
+  enumerable: true,
+  get: function () {
+    return _ticks.tickIncrement;
+  }
+});
+Object.defineProperty(exports, "tickStep", {
+  enumerable: true,
+  get: function () {
+    return _ticks.tickStep;
+  }
+});
+Object.defineProperty(exports, "ticks", {
+  enumerable: true,
+  get: function () {
+    return _ticks.default;
+  }
+});
+Object.defineProperty(exports, "transpose", {
+  enumerable: true,
+  get: function () {
+    return _transpose.default;
+  }
+});
+Object.defineProperty(exports, "union", {
+  enumerable: true,
+  get: function () {
+    return _union.default;
+  }
+});
+Object.defineProperty(exports, "variance", {
+  enumerable: true,
+  get: function () {
+    return _variance.default;
+  }
+});
+Object.defineProperty(exports, "zip", {
+  enumerable: true,
+  get: function () {
+    return _zip.default;
+  }
+});
+var _bisect = _interopRequireWildcard(require("./bisect.js"));
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+var _bisector = _interopRequireDefault(require("./bisector.js"));
+var _blur = require("./blur.js");
+var _count = _interopRequireDefault(require("./count.js"));
+var _cross = _interopRequireDefault(require("./cross.js"));
+var _cumsum = _interopRequireDefault(require("./cumsum.js"));
+var _descending = _interopRequireDefault(require("./descending.js"));
+var _deviation = _interopRequireDefault(require("./deviation.js"));
+var _extent = _interopRequireDefault(require("./extent.js"));
+var _fsum = require("./fsum.js");
+var _group = _interopRequireWildcard(require("./group.js"));
+var _groupSort = _interopRequireDefault(require("./groupSort.js"));
+var _bin = _interopRequireDefault(require("./bin.js"));
+var _freedmanDiaconis = _interopRequireDefault(require("./threshold/freedmanDiaconis.js"));
+var _scott = _interopRequireDefault(require("./threshold/scott.js"));
+var _sturges = _interopRequireDefault(require("./threshold/sturges.js"));
+var _max = _interopRequireDefault(require("./max.js"));
+var _maxIndex = _interopRequireDefault(require("./maxIndex.js"));
+var _mean = _interopRequireDefault(require("./mean.js"));
+var _median = _interopRequireWildcard(require("./median.js"));
+var _merge = _interopRequireDefault(require("./merge.js"));
+var _min = _interopRequireDefault(require("./min.js"));
+var _minIndex = _interopRequireDefault(require("./minIndex.js"));
+var _mode = _interopRequireDefault(require("./mode.js"));
+var _nice = _interopRequireDefault(require("./nice.js"));
+var _pairs = _interopRequireDefault(require("./pairs.js"));
+var _permute = _interopRequireDefault(require("./permute.js"));
+var _quantile = _interopRequireWildcard(require("./quantile.js"));
+var _quickselect = _interopRequireDefault(require("./quickselect.js"));
+var _range = _interopRequireDefault(require("./range.js"));
+var _rank = _interopRequireDefault(require("./rank.js"));
+var _least = _interopRequireDefault(require("./least.js"));
+var _leastIndex = _interopRequireDefault(require("./leastIndex.js"));
+var _greatest = _interopRequireDefault(require("./greatest.js"));
+var _greatestIndex = _interopRequireDefault(require("./greatestIndex.js"));
+var _scan = _interopRequireDefault(require("./scan.js"));
+var _shuffle = _interopRequireWildcard(require("./shuffle.js"));
+var _sum = _interopRequireDefault(require("./sum.js"));
+var _ticks = _interopRequireWildcard(require("./ticks.js"));
+var _transpose = _interopRequireDefault(require("./transpose.js"));
+var _variance = _interopRequireDefault(require("./variance.js"));
+var _zip = _interopRequireDefault(require("./zip.js"));
+var _every = _interopRequireDefault(require("./every.js"));
+var _some = _interopRequireDefault(require("./some.js"));
+var _filter = _interopRequireDefault(require("./filter.js"));
+var _map = _interopRequireDefault(require("./map.js"));
+var _reduce = _interopRequireDefault(require("./reduce.js"));
+var _reverse = _interopRequireDefault(require("./reverse.js"));
+var _sort = _interopRequireDefault(require("./sort.js"));
+var _difference = _interopRequireDefault(require("./difference.js"));
+var _disjoint = _interopRequireDefault(require("./disjoint.js"));
+var _intersection = _interopRequireDefault(require("./intersection.js"));
+var _subset = _interopRequireDefault(require("./subset.js"));
+var _superset = _interopRequireDefault(require("./superset.js"));
+var _union = _interopRequireDefault(require("./union.js"));
+var _index = require("../../../lib-vendor/internmap/src/index.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = intersection;
+var _index = require("../../../lib-vendor/internmap/src/index.js");
+function intersection(values, ...others) {
+  values = new _index.InternSet(values);
+  others = others.map(set);
+  out: for (const value of values) {
+    for (const other of others) {
+      if (!other.has(value)) {
+        values.delete(value);
+        continue out;
+      }
+    }
+  }
+  return values;
+}
+function set(values) {
+  return values instanceof _index.InternSet ? values : new _index.InternSet(values);
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = least;
+var _ascending = _interopRequireDefault(require("./ascending.js"));
+function least(values, compare = _ascending.default) {
+  let min;
+  let defined = false;
+  if (compare.length === 1) {
+    let minValue;
+    for (const element of values) {
+      const value = compare(element);
+      if (defined ? (0, _ascending.default)(value, minValue) < 0 : (0, _ascending.default)(value, value) === 0) {
+        min = element;
+        minValue = value;
+        defined = true;
+      }
+    }
+  } else {
+    for (const value of values) {
+      if (defined ? compare(value, min) < 0 : compare(value, value) === 0) {
+        min = value;
+        defined = true;
+      }
+    }
+  }
+  return min;
+}