@mui/x-charts-vendor 7.12.0

package/lib-vendor/d3-shape/src/symbol/star.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+const ka = 0.89081309152928522810;
+const kr = (0, _math.sin)(_math.pi / 10) / (0, _math.sin)(7 * _math.pi / 10);
+const kx = (0, _math.sin)(_math.tau / 10) * kr;
+const ky = -(0, _math.cos)(_math.tau / 10) * kr;
+var _default = exports.default = {
+  draw(context, size) {
+    const r = (0, _math.sqrt)(size * ka);
+    const x = kx * r;
+    const y = ky * r;
+    context.moveTo(0, -r);
+    context.lineTo(x, y);
+    for (let i = 1; i < 5; ++i) {
+      const a = _math.tau * i / 5;
+      const c = (0, _math.cos)(a);
+      const s = (0, _math.sin)(a);
+      context.lineTo(s * r, -c * r);
+      context.lineTo(c * x - s * y, s * x + c * y);
+    }
+    context.closePath();
+  }
+};

package/lib-vendor/d3-shape/src/symbol/times.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+var _default = exports.default = {
+  draw(context, size) {
+    const r = (0, _math.sqrt)(size - (0, _math.min)(size / 6, 1.7)) * 0.6189;
+    context.moveTo(-r, -r);
+    context.lineTo(r, r);
+    context.moveTo(-r, r);
+    context.lineTo(r, -r);
+  }
+};

package/lib-vendor/d3-shape/src/symbol/triangle.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+const sqrt3 = (0, _math.sqrt)(3);
+var _default = exports.default = {
+  draw(context, size) {
+    const y = -(0, _math.sqrt)(size / (sqrt3 * 3));
+    context.moveTo(0, y * 2);
+    context.lineTo(-sqrt3 * y, -y);
+    context.lineTo(sqrt3 * y, -y);
+    context.closePath();
+  }
+};

package/lib-vendor/d3-shape/src/symbol/triangle2.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+const sqrt3 = (0, _math.sqrt)(3);
+var _default = exports.default = {
+  draw(context, size) {
+    const s = (0, _math.sqrt)(size) * 0.6824;
+    const t = s / 2;
+    const u = s * sqrt3 / 2; // cos(Math.PI / 6)
+    context.moveTo(0, -s);
+    context.lineTo(u, t);
+    context.lineTo(-u, t);
+    context.closePath();
+  }
+};

package/lib-vendor/d3-shape/src/symbol/wye.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+const c = -0.5;
+const s = (0, _math.sqrt)(3) / 2;
+const k = 1 / (0, _math.sqrt)(12);
+const a = (k / 2 + 1) * 3;
+var _default = exports.default = {
+  draw(context, size) {
+    const r = (0, _math.sqrt)(size / a);
+    const x0 = r / 2,
+      y0 = r * k;
+    const x1 = x0,
+      y1 = r * k + r;
+    const x2 = -x1,
+      y2 = y1;
+    context.moveTo(x0, y0);
+    context.lineTo(x1, y1);
+    context.lineTo(x2, y2);
+    context.lineTo(c * x0 - s * y0, s * x0 + c * y0);
+    context.lineTo(c * x1 - s * y1, s * x1 + c * y1);
+    context.lineTo(c * x2 - s * y2, s * x2 + c * y2);
+    context.lineTo(c * x0 + s * y0, c * y0 - s * x0);
+    context.lineTo(c * x1 + s * y1, c * y1 - s * x1);
+    context.lineTo(c * x2 + s * y2, c * y2 - s * x2);
+    context.closePath();
+  }
+};

package/lib-vendor/d3-shape/src/symbol.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Symbol;
+exports.symbolsStroke = exports.symbolsFill = void 0;
+var _constant = _interopRequireDefault(require("./constant.js"));
+var _path = require("./path.js");
+var _asterisk = _interopRequireDefault(require("./symbol/asterisk.js"));
+var _circle = _interopRequireDefault(require("./symbol/circle.js"));
+var _cross = _interopRequireDefault(require("./symbol/cross.js"));
+var _diamond = _interopRequireDefault(require("./symbol/diamond.js"));
+var _diamond2 = _interopRequireDefault(require("./symbol/diamond2.js"));
+var _plus = _interopRequireDefault(require("./symbol/plus.js"));
+var _square = _interopRequireDefault(require("./symbol/square.js"));
+var _square2 = _interopRequireDefault(require("./symbol/square2.js"));
+var _star = _interopRequireDefault(require("./symbol/star.js"));
+var _triangle = _interopRequireDefault(require("./symbol/triangle.js"));
+var _triangle2 = _interopRequireDefault(require("./symbol/triangle2.js"));
+var _wye = _interopRequireDefault(require("./symbol/wye.js"));
+var _times = _interopRequireDefault(require("./symbol/times.js"));
+// These symbols are designed to be filled.
+const symbolsFill = exports.symbolsFill = [_circle.default, _cross.default, _diamond.default, _square.default, _star.default, _triangle.default, _wye.default];
+
+// These symbols are designed to be stroked (with a width of 1.5px and round caps).
+const symbolsStroke = exports.symbolsStroke = [_circle.default, _plus.default, _times.default, _triangle2.default, _asterisk.default, _square2.default, _diamond2.default];
+function Symbol(type, size) {
+  let context = null,
+    path = (0, _path.withPath)(symbol);
+  type = typeof type === "function" ? type : (0, _constant.default)(type || _circle.default);
+  size = typeof size === "function" ? size : (0, _constant.default)(size === undefined ? 64 : +size);
+  function symbol() {
+    let buffer;
+    if (!context) context = buffer = path();
+    type.apply(this, arguments).draw(context, +size.apply(this, arguments));
+    if (buffer) return context = null, buffer + "" || null;
+  }
+  symbol.type = function (_) {
+    return arguments.length ? (type = typeof _ === "function" ? _ : (0, _constant.default)(_), symbol) : type;
+  };
+  symbol.size = function (_) {
+    return arguments.length ? (size = typeof _ === "function" ? _ : (0, _constant.default)(+_), symbol) : size;
+  };
+  symbol.context = function (_) {
+    return arguments.length ? (context = _ == null ? null : _, symbol) : context;
+  };
+  return symbol;
+}

package/lib-vendor/d3-time/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010-2022 Mike Bostock
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/lib-vendor/d3-time/dist/d3-time.js

@@ -0,0 +1,367 @@
+"use strict";
+
+// https://d3js.org/d3-time/ v3.1.0 Copyright 2010-2022 Mike Bostock
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require("../../../lib-vendor/d3-array/src/index.js")) : typeof define === 'function' && define.amd ? define(['exports', 'd3-array'], factory) : (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.d3 = global.d3 || {}, global.d3));
+})(this, function (exports, d3Array) {
+  'use strict';
+
+  const t0 = new Date(),
+    t1 = new Date();
+  function timeInterval(floori, offseti, count, field) {
+    function interval(date) {
+      return floori(date = arguments.length === 0 ? new Date() : new Date(+date)), date;
+    }
+    interval.floor = date => {
+      return floori(date = new Date(+date)), date;
+    };
+    interval.ceil = date => {
+      return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+    };
+    interval.round = date => {
+      const d0 = interval(date),
+        d1 = interval.ceil(date);
+      return date - d0 < d1 - date ? d0 : d1;
+    };
+    interval.offset = (date, step) => {
+      return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
+    };
+    interval.range = (start, stop, step) => {
+      const range = [];
+      start = interval.ceil(start);
+      step = step == null ? 1 : Math.floor(step);
+      if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
+      let previous;
+      do range.push(previous = new Date(+start)), offseti(start, step), floori(start); while (previous < start && start < stop);
+      return range;
+    };
+    interval.filter = test => {
+      return timeInterval(date => {
+        if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
+      }, (date, step) => {
+        if (date >= date) {
+          if (step < 0) while (++step <= 0) {
+            while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty
+          } else while (--step >= 0) {
+            while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty
+          }
+        }
+      });
+    };
+    if (count) {
+      interval.count = (start, end) => {
+        t0.setTime(+start), t1.setTime(+end);
+        floori(t0), floori(t1);
+        return Math.floor(count(t0, t1));
+      };
+      interval.every = step => {
+        step = Math.floor(step);
+        return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval : interval.filter(field ? d => field(d) % step === 0 : d => interval.count(0, d) % step === 0);
+      };
+    }
+    return interval;
+  }
+  const millisecond = timeInterval(() => {
+    // noop
+  }, (date, step) => {
+    date.setTime(+date + step);
+  }, (start, end) => {
+    return end - start;
+  });
+
+  // An optimized implementation for this simple case.
+  millisecond.every = k => {
+    k = Math.floor(k);
+    if (!isFinite(k) || !(k > 0)) return null;
+    if (!(k > 1)) return millisecond;
+    return timeInterval(date => {
+      date.setTime(Math.floor(date / k) * k);
+    }, (date, step) => {
+      date.setTime(+date + step * k);
+    }, (start, end) => {
+      return (end - start) / k;
+    });
+  };
+  const milliseconds = millisecond.range;
+  const durationSecond = 1000;
+  const durationMinute = durationSecond * 60;
+  const durationHour = durationMinute * 60;
+  const durationDay = durationHour * 24;
+  const durationWeek = durationDay * 7;
+  const durationMonth = durationDay * 30;
+  const durationYear = durationDay * 365;
+  const second = timeInterval(date => {
+    date.setTime(date - date.getMilliseconds());
+  }, (date, step) => {
+    date.setTime(+date + step * durationSecond);
+  }, (start, end) => {
+    return (end - start) / durationSecond;
+  }, date => {
+    return date.getUTCSeconds();
+  });
+  const seconds = second.range;
+  const timeMinute = timeInterval(date => {
+    date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond);
+  }, (date, step) => {
+    date.setTime(+date + step * durationMinute);
+  }, (start, end) => {
+    return (end - start) / durationMinute;
+  }, date => {
+    return date.getMinutes();
+  });
+  const timeMinutes = timeMinute.range;
+  const utcMinute = timeInterval(date => {
+    date.setUTCSeconds(0, 0);
+  }, (date, step) => {
+    date.setTime(+date + step * durationMinute);
+  }, (start, end) => {
+    return (end - start) / durationMinute;
+  }, date => {
+    return date.getUTCMinutes();
+  });
+  const utcMinutes = utcMinute.range;
+  const timeHour = timeInterval(date => {
+    date.setTime(date - date.getMilliseconds() - date.getSeconds() * durationSecond - date.getMinutes() * durationMinute);
+  }, (date, step) => {
+    date.setTime(+date + step * durationHour);
+  }, (start, end) => {
+    return (end - start) / durationHour;
+  }, date => {
+    return date.getHours();
+  });
+  const timeHours = timeHour.range;
+  const utcHour = timeInterval(date => {
+    date.setUTCMinutes(0, 0, 0);
+  }, (date, step) => {
+    date.setTime(+date + step * durationHour);
+  }, (start, end) => {
+    return (end - start) / durationHour;
+  }, date => {
+    return date.getUTCHours();
+  });
+  const utcHours = utcHour.range;
+  const timeDay = timeInterval(date => date.setHours(0, 0, 0, 0), (date, step) => date.setDate(date.getDate() + step), (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay, date => date.getDate() - 1);
+  const timeDays = timeDay.range;
+  const utcDay = timeInterval(date => {
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCDate(date.getUTCDate() + step);
+  }, (start, end) => {
+    return (end - start) / durationDay;
+  }, date => {
+    return date.getUTCDate() - 1;
+  });
+  const utcDays = utcDay.range;
+  const unixDay = timeInterval(date => {
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCDate(date.getUTCDate() + step);
+  }, (start, end) => {
+    return (end - start) / durationDay;
+  }, date => {
+    return Math.floor(date / durationDay);
+  });
+  const unixDays = unixDay.range;
+  function timeWeekday(i) {
+    return timeInterval(date => {
+      date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+      date.setHours(0, 0, 0, 0);
+    }, (date, step) => {
+      date.setDate(date.getDate() + step * 7);
+    }, (start, end) => {
+      return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek;
+    });
+  }
+  const timeSunday = timeWeekday(0);
+  const timeMonday = timeWeekday(1);
+  const timeTuesday = timeWeekday(2);
+  const timeWednesday = timeWeekday(3);
+  const timeThursday = timeWeekday(4);
+  const timeFriday = timeWeekday(5);
+  const timeSaturday = timeWeekday(6);
+  const timeSundays = timeSunday.range;
+  const timeMondays = timeMonday.range;
+  const timeTuesdays = timeTuesday.range;
+  const timeWednesdays = timeWednesday.range;
+  const timeThursdays = timeThursday.range;
+  const timeFridays = timeFriday.range;
+  const timeSaturdays = timeSaturday.range;
+  function utcWeekday(i) {
+    return timeInterval(date => {
+      date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+      date.setUTCHours(0, 0, 0, 0);
+    }, (date, step) => {
+      date.setUTCDate(date.getUTCDate() + step * 7);
+    }, (start, end) => {
+      return (end - start) / durationWeek;
+    });
+  }
+  const utcSunday = utcWeekday(0);
+  const utcMonday = utcWeekday(1);
+  const utcTuesday = utcWeekday(2);
+  const utcWednesday = utcWeekday(3);
+  const utcThursday = utcWeekday(4);
+  const utcFriday = utcWeekday(5);
+  const utcSaturday = utcWeekday(6);
+  const utcSundays = utcSunday.range;
+  const utcMondays = utcMonday.range;
+  const utcTuesdays = utcTuesday.range;
+  const utcWednesdays = utcWednesday.range;
+  const utcThursdays = utcThursday.range;
+  const utcFridays = utcFriday.range;
+  const utcSaturdays = utcSaturday.range;
+  const timeMonth = timeInterval(date => {
+    date.setDate(1);
+    date.setHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setMonth(date.getMonth() + step);
+  }, (start, end) => {
+    return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+  }, date => {
+    return date.getMonth();
+  });
+  const timeMonths = timeMonth.range;
+  const utcMonth = timeInterval(date => {
+    date.setUTCDate(1);
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCMonth(date.getUTCMonth() + step);
+  }, (start, end) => {
+    return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+  }, date => {
+    return date.getUTCMonth();
+  });
+  const utcMonths = utcMonth.range;
+  const timeYear = timeInterval(date => {
+    date.setMonth(0, 1);
+    date.setHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setFullYear(date.getFullYear() + step);
+  }, (start, end) => {
+    return end.getFullYear() - start.getFullYear();
+  }, date => {
+    return date.getFullYear();
+  });
+
+  // An optimized implementation for this simple case.
+  timeYear.every = k => {
+    return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval(date => {
+      date.setFullYear(Math.floor(date.getFullYear() / k) * k);
+      date.setMonth(0, 1);
+      date.setHours(0, 0, 0, 0);
+    }, (date, step) => {
+      date.setFullYear(date.getFullYear() + step * k);
+    });
+  };
+  const timeYears = timeYear.range;
+  const utcYear = timeInterval(date => {
+    date.setUTCMonth(0, 1);
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCFullYear(date.getUTCFullYear() + step);
+  }, (start, end) => {
+    return end.getUTCFullYear() - start.getUTCFullYear();
+  }, date => {
+    return date.getUTCFullYear();
+  });
+
+  // An optimized implementation for this simple case.
+  utcYear.every = k => {
+    return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval(date => {
+      date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k);
+      date.setUTCMonth(0, 1);
+      date.setUTCHours(0, 0, 0, 0);
+    }, (date, step) => {
+      date.setUTCFullYear(date.getUTCFullYear() + step * k);
+    });
+  };
+  const utcYears = utcYear.range;
+  function ticker(year, month, week, day, hour, minute) {
+    const tickIntervals = [[second, 1, durationSecond], [second, 5, 5 * durationSecond], [second, 15, 15 * durationSecond], [second, 30, 30 * durationSecond], [minute, 1, durationMinute], [minute, 5, 5 * durationMinute], [minute, 15, 15 * durationMinute], [minute, 30, 30 * durationMinute], [hour, 1, durationHour], [hour, 3, 3 * durationHour], [hour, 6, 6 * durationHour], [hour, 12, 12 * durationHour], [day, 1, durationDay], [day, 2, 2 * durationDay], [week, 1, durationWeek], [month, 1, durationMonth], [month, 3, 3 * durationMonth], [year, 1, durationYear]];
+    function ticks(start, stop, count) {
+      const reverse = stop < start;
+      if (reverse) [start, stop] = [stop, start];
+      const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count);
+      const ticks = interval ? interval.range(start, +stop + 1) : []; // inclusive stop
+      return reverse ? ticks.reverse() : ticks;
+    }
+    function tickInterval(start, stop, count) {
+      const target = Math.abs(stop - start) / count;
+      const i = d3Array.bisector(([,, step]) => step).right(tickIntervals, target);
+      if (i === tickIntervals.length) return year.every(d3Array.tickStep(start / durationYear, stop / durationYear, count));
+      if (i === 0) return millisecond.every(Math.max(d3Array.tickStep(start, stop, count), 1));
+      const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
+      return t.every(step);
+    }
+    return [ticks, tickInterval];
+  }
+  const [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute);
+  const [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute);
+  exports.timeDay = timeDay;
+  exports.timeDays = timeDays;
+  exports.timeFriday = timeFriday;
+  exports.timeFridays = timeFridays;
+  exports.timeHour = timeHour;
+  exports.timeHours = timeHours;
+  exports.timeInterval = timeInterval;
+  exports.timeMillisecond = millisecond;
+  exports.timeMilliseconds = milliseconds;
+  exports.timeMinute = timeMinute;
+  exports.timeMinutes = timeMinutes;
+  exports.timeMonday = timeMonday;
+  exports.timeMondays = timeMondays;
+  exports.timeMonth = timeMonth;
+  exports.timeMonths = timeMonths;
+  exports.timeSaturday = timeSaturday;
+  exports.timeSaturdays = timeSaturdays;
+  exports.timeSecond = second;
+  exports.timeSeconds = seconds;
+  exports.timeSunday = timeSunday;
+  exports.timeSundays = timeSundays;
+  exports.timeThursday = timeThursday;
+  exports.timeThursdays = timeThursdays;
+  exports.timeTickInterval = timeTickInterval;
+  exports.timeTicks = timeTicks;
+  exports.timeTuesday = timeTuesday;
+  exports.timeTuesdays = timeTuesdays;
+  exports.timeWednesday = timeWednesday;
+  exports.timeWednesdays = timeWednesdays;
+  exports.timeWeek = timeSunday;
+  exports.timeWeeks = timeSundays;
+  exports.timeYear = timeYear;
+  exports.timeYears = timeYears;
+  exports.unixDay = unixDay;
+  exports.unixDays = unixDays;
+  exports.utcDay = utcDay;
+  exports.utcDays = utcDays;
+  exports.utcFriday = utcFriday;
+  exports.utcFridays = utcFridays;
+  exports.utcHour = utcHour;
+  exports.utcHours = utcHours;
+  exports.utcMillisecond = millisecond;
+  exports.utcMilliseconds = milliseconds;
+  exports.utcMinute = utcMinute;
+  exports.utcMinutes = utcMinutes;
+  exports.utcMonday = utcMonday;
+  exports.utcMondays = utcMondays;
+  exports.utcMonth = utcMonth;
+  exports.utcMonths = utcMonths;
+  exports.utcSaturday = utcSaturday;
+  exports.utcSaturdays = utcSaturdays;
+  exports.utcSecond = second;
+  exports.utcSeconds = seconds;
+  exports.utcSunday = utcSunday;
+  exports.utcSundays = utcSundays;
+  exports.utcThursday = utcThursday;
+  exports.utcThursdays = utcThursdays;
+  exports.utcTickInterval = utcTickInterval;
+  exports.utcTicks = utcTicks;
+  exports.utcTuesday = utcTuesday;
+  exports.utcTuesdays = utcTuesdays;
+  exports.utcWednesday = utcWednesday;
+  exports.utcWednesdays = utcWednesdays;
+  exports.utcWeek = utcSunday;
+  exports.utcWeeks = utcSundays;
+  exports.utcYear = utcYear;
+  exports.utcYears = utcYears;
+});