|
|
"use strict";
|
|
|
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[6577],{
|
|
|
|
|
|
/***/ 31655:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ ascending)
|
|
|
/* harmony export */ });
|
|
|
function ascending(a, b) {
|
|
|
return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 10321:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Nw: () => (/* binding */ bisectLeft),
|
|
|
/* harmony export */ ZP: () => (__WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ ml: () => (/* binding */ bisectRight)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export bisectCenter */
|
|
|
/* harmony import */ var _ascending_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(31655);
|
|
|
/* harmony import */ var _bisector_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2518);
|
|
|
/* harmony import */ var _number_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(53612);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const ascendingBisect = (0,_bisector_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(_ascending_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z);
|
|
|
const bisectRight = ascendingBisect.right;
|
|
|
const bisectLeft = ascendingBisect.left;
|
|
|
const bisectCenter = (0,_bisector_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(_number_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z).center;
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (bisectRight);
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 2518:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
Z: () => (/* binding */ bisector)
|
|
|
});
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-array/src/ascending.js
|
|
|
var ascending = __webpack_require__(31655);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-array/src/descending.js
|
|
|
function descending(a, b) {
|
|
|
return a == null || b == null ? NaN
|
|
|
: b < a ? -1
|
|
|
: b > a ? 1
|
|
|
: b >= a ? 0
|
|
|
: NaN;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-array/src/bisector.js
|
|
|
|
|
|
|
|
|
|
|
|
function bisector(f) {
|
|
|
let compare1, compare2, delta;
|
|
|
|
|
|
// If an accessor is specified, promote it to a comparator. In this case we
|
|
|
// can test whether the search value is (self-) comparable. We can’t do this
|
|
|
// for a comparator (except for specific, known comparators) because we can’t
|
|
|
// tell if the comparator is symmetric, and an asymmetric comparator can’t be
|
|
|
// used to test whether a single value is comparable.
|
|
|
if (f.length !== 2) {
|
|
|
compare1 = ascending/* default */.Z;
|
|
|
compare2 = (d, x) => (0,ascending/* default */.Z)(f(d), x);
|
|
|
delta = (d, x) => f(d) - x;
|
|
|
} else {
|
|
|
compare1 = f === ascending/* default */.Z || f === descending ? f : zero;
|
|
|
compare2 = f;
|
|
|
delta = f;
|
|
|
}
|
|
|
|
|
|
function left(a, x, lo = 0, hi = a.length) {
|
|
|
if (lo < hi) {
|
|
|
if (compare1(x, x) !== 0) return hi;
|
|
|
do {
|
|
|
const mid = (lo + hi) >>> 1;
|
|
|
if (compare2(a[mid], x) < 0) lo = mid + 1;
|
|
|
else hi = mid;
|
|
|
} while (lo < hi);
|
|
|
}
|
|
|
return lo;
|
|
|
}
|
|
|
|
|
|
function right(a, x, lo = 0, hi = a.length) {
|
|
|
if (lo < hi) {
|
|
|
if (compare1(x, x) !== 0) return hi;
|
|
|
do {
|
|
|
const mid = (lo + hi) >>> 1;
|
|
|
if (compare2(a[mid], x) <= 0) lo = mid + 1;
|
|
|
else hi = mid;
|
|
|
} while (lo < hi);
|
|
|
}
|
|
|
return lo;
|
|
|
}
|
|
|
|
|
|
function center(a, x, lo = 0, hi = a.length) {
|
|
|
const i = left(a, x, lo, hi - 1);
|
|
|
return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
|
|
|
}
|
|
|
|
|
|
return {left, center, right};
|
|
|
}
|
|
|
|
|
|
function zero() {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 53856:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ max)
|
|
|
/* harmony export */ });
|
|
|
function max(values, valueof) {
|
|
|
let max;
|
|
|
if (valueof === undefined) {
|
|
|
for (const value of values) {
|
|
|
if (value != null
|
|
|
&& (max < value || (max === undefined && value >= value))) {
|
|
|
max = value;
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
let index = -1;
|
|
|
for (let value of values) {
|
|
|
if ((value = valueof(value, ++index, values)) != null
|
|
|
&& (max < value || (max === undefined && value >= value))) {
|
|
|
max = value;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return max;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 93571:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ min)
|
|
|
/* harmony export */ });
|
|
|
function min(values, valueof) {
|
|
|
let min;
|
|
|
if (valueof === undefined) {
|
|
|
for (const value of values) {
|
|
|
if (value != null
|
|
|
&& (min > value || (min === undefined && value >= value))) {
|
|
|
min = value;
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
let index = -1;
|
|
|
for (let value of values) {
|
|
|
if ((value = valueof(value, ++index, values)) != null
|
|
|
&& (min > value || (min === undefined && value >= value))) {
|
|
|
min = value;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return min;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 53612:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ K: () => (/* binding */ numbers),
|
|
|
/* harmony export */ Z: () => (/* binding */ number)
|
|
|
/* harmony export */ });
|
|
|
function number(x) {
|
|
|
return x === null ? NaN : +x;
|
|
|
}
|
|
|
|
|
|
function* numbers(values, valueof) {
|
|
|
if (valueof === undefined) {
|
|
|
for (let value of values) {
|
|
|
if (value != null && (value = +value) >= value) {
|
|
|
yield value;
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
let index = -1;
|
|
|
for (let value of values) {
|
|
|
if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
|
|
|
yield value;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 53353:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ range)
|
|
|
/* harmony export */ });
|
|
|
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,
|
|
|
n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
|
|
|
range = new Array(n);
|
|
|
|
|
|
while (++i < n) {
|
|
|
range[i] = start + i * step;
|
|
|
}
|
|
|
|
|
|
return range;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 73002:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ G9: () => (/* binding */ tickIncrement),
|
|
|
/* harmony export */ ZP: () => (/* binding */ ticks),
|
|
|
/* harmony export */ ly: () => (/* binding */ tickStep)
|
|
|
/* harmony export */ });
|
|
|
const e10 = Math.sqrt(50),
|
|
|
e5 = Math.sqrt(10),
|
|
|
e2 = Math.sqrt(2);
|
|
|
|
|
|
function tickSpec(start, stop, count) {
|
|
|
const step = (stop - start) / Math.max(0, count),
|
|
|
power = Math.floor(Math.log10(step)),
|
|
|
error = step / Math.pow(10, power),
|
|
|
factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
|
|
|
let i1, i2, inc;
|
|
|
if (power < 0) {
|
|
|
inc = Math.pow(10, -power) / factor;
|
|
|
i1 = Math.round(start * inc);
|
|
|
i2 = Math.round(stop * inc);
|
|
|
if (i1 / inc < start) ++i1;
|
|
|
if (i2 / inc > stop) --i2;
|
|
|
inc = -inc;
|
|
|
} else {
|
|
|
inc = Math.pow(10, power) * factor;
|
|
|
i1 = Math.round(start / inc);
|
|
|
i2 = Math.round(stop / inc);
|
|
|
if (i1 * inc < start) ++i1;
|
|
|
if (i2 * inc > stop) --i2;
|
|
|
}
|
|
|
if (i2 < i1 && 0.5 <= count && count < 2) return tickSpec(start, stop, count * 2);
|
|
|
return [i1, i2, inc];
|
|
|
}
|
|
|
|
|
|
function ticks(start, stop, count) {
|
|
|
stop = +stop, start = +start, count = +count;
|
|
|
if (!(count > 0)) return [];
|
|
|
if (start === stop) return [start];
|
|
|
const reverse = stop < start, [i1, i2, inc] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count);
|
|
|
if (!(i2 >= i1)) return [];
|
|
|
const n = i2 - i1 + 1, ticks = new Array(n);
|
|
|
if (reverse) {
|
|
|
if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) / -inc;
|
|
|
else for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) * inc;
|
|
|
} else {
|
|
|
if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) / -inc;
|
|
|
else for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) * inc;
|
|
|
}
|
|
|
return ticks;
|
|
|
}
|
|
|
|
|
|
function tickIncrement(start, stop, count) {
|
|
|
stop = +stop, start = +start, count = +count;
|
|
|
return tickSpec(start, stop, count)[2];
|
|
|
}
|
|
|
|
|
|
function tickStep(start, stop, count) {
|
|
|
stop = +stop, start = +start, count = +count;
|
|
|
const reverse = stop < start, inc = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count);
|
|
|
return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 12738:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ B8: () => (/* binding */ rgb),
|
|
|
/* harmony export */ Il: () => (/* binding */ Color),
|
|
|
/* harmony export */ J5: () => (/* binding */ brighter),
|
|
|
/* harmony export */ SU: () => (/* binding */ rgbConvert),
|
|
|
/* harmony export */ Ss: () => (/* binding */ Rgb),
|
|
|
/* harmony export */ Ym: () => (/* binding */ hsl),
|
|
|
/* harmony export */ ZP: () => (/* binding */ color),
|
|
|
/* harmony export */ xV: () => (/* binding */ darker)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export hslConvert */
|
|
|
/* harmony import */ var _define_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77551);
|
|
|
|
|
|
|
|
|
function Color() {}
|
|
|
|
|
|
var darker = 0.7;
|
|
|
var brighter = 1 / darker;
|
|
|
|
|
|
var reI = "\\s*([+-]?\\d+)\\s*",
|
|
|
reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",
|
|
|
reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
|
|
|
reHex = /^#([0-9a-f]{3,8})$/,
|
|
|
reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`),
|
|
|
reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`),
|
|
|
reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`),
|
|
|
reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`),
|
|
|
reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`),
|
|
|
reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
|
|
|
|
|
|
var named = {
|
|
|
aliceblue: 0xf0f8ff,
|
|
|
antiquewhite: 0xfaebd7,
|
|
|
aqua: 0x00ffff,
|
|
|
aquamarine: 0x7fffd4,
|
|
|
azure: 0xf0ffff,
|
|
|
beige: 0xf5f5dc,
|
|
|
bisque: 0xffe4c4,
|
|
|
black: 0x000000,
|
|
|
blanchedalmond: 0xffebcd,
|
|
|
blue: 0x0000ff,
|
|
|
blueviolet: 0x8a2be2,
|
|
|
brown: 0xa52a2a,
|
|
|
burlywood: 0xdeb887,
|
|
|
cadetblue: 0x5f9ea0,
|
|
|
chartreuse: 0x7fff00,
|
|
|
chocolate: 0xd2691e,
|
|
|
coral: 0xff7f50,
|
|
|
cornflowerblue: 0x6495ed,
|
|
|
cornsilk: 0xfff8dc,
|
|
|
crimson: 0xdc143c,
|
|
|
cyan: 0x00ffff,
|
|
|
darkblue: 0x00008b,
|
|
|
darkcyan: 0x008b8b,
|
|
|
darkgoldenrod: 0xb8860b,
|
|
|
darkgray: 0xa9a9a9,
|
|
|
darkgreen: 0x006400,
|
|
|
darkgrey: 0xa9a9a9,
|
|
|
darkkhaki: 0xbdb76b,
|
|
|
darkmagenta: 0x8b008b,
|
|
|
darkolivegreen: 0x556b2f,
|
|
|
darkorange: 0xff8c00,
|
|
|
darkorchid: 0x9932cc,
|
|
|
darkred: 0x8b0000,
|
|
|
darksalmon: 0xe9967a,
|
|
|
darkseagreen: 0x8fbc8f,
|
|
|
darkslateblue: 0x483d8b,
|
|
|
darkslategray: 0x2f4f4f,
|
|
|
darkslategrey: 0x2f4f4f,
|
|
|
darkturquoise: 0x00ced1,
|
|
|
darkviolet: 0x9400d3,
|
|
|
deeppink: 0xff1493,
|
|
|
deepskyblue: 0x00bfff,
|
|
|
dimgray: 0x696969,
|
|
|
dimgrey: 0x696969,
|
|
|
dodgerblue: 0x1e90ff,
|
|
|
firebrick: 0xb22222,
|
|
|
floralwhite: 0xfffaf0,
|
|
|
forestgreen: 0x228b22,
|
|
|
fuchsia: 0xff00ff,
|
|
|
gainsboro: 0xdcdcdc,
|
|
|
ghostwhite: 0xf8f8ff,
|
|
|
gold: 0xffd700,
|
|
|
goldenrod: 0xdaa520,
|
|
|
gray: 0x808080,
|
|
|
green: 0x008000,
|
|
|
greenyellow: 0xadff2f,
|
|
|
grey: 0x808080,
|
|
|
honeydew: 0xf0fff0,
|
|
|
hotpink: 0xff69b4,
|
|
|
indianred: 0xcd5c5c,
|
|
|
indigo: 0x4b0082,
|
|
|
ivory: 0xfffff0,
|
|
|
khaki: 0xf0e68c,
|
|
|
lavender: 0xe6e6fa,
|
|
|
lavenderblush: 0xfff0f5,
|
|
|
lawngreen: 0x7cfc00,
|
|
|
lemonchiffon: 0xfffacd,
|
|
|
lightblue: 0xadd8e6,
|
|
|
lightcoral: 0xf08080,
|
|
|
lightcyan: 0xe0ffff,
|
|
|
lightgoldenrodyellow: 0xfafad2,
|
|
|
lightgray: 0xd3d3d3,
|
|
|
lightgreen: 0x90ee90,
|
|
|
lightgrey: 0xd3d3d3,
|
|
|
lightpink: 0xffb6c1,
|
|
|
lightsalmon: 0xffa07a,
|
|
|
lightseagreen: 0x20b2aa,
|
|
|
lightskyblue: 0x87cefa,
|
|
|
lightslategray: 0x778899,
|
|
|
lightslategrey: 0x778899,
|
|
|
lightsteelblue: 0xb0c4de,
|
|
|
lightyellow: 0xffffe0,
|
|
|
lime: 0x00ff00,
|
|
|
limegreen: 0x32cd32,
|
|
|
linen: 0xfaf0e6,
|
|
|
magenta: 0xff00ff,
|
|
|
maroon: 0x800000,
|
|
|
mediumaquamarine: 0x66cdaa,
|
|
|
mediumblue: 0x0000cd,
|
|
|
mediumorchid: 0xba55d3,
|
|
|
mediumpurple: 0x9370db,
|
|
|
mediumseagreen: 0x3cb371,
|
|
|
mediumslateblue: 0x7b68ee,
|
|
|
mediumspringgreen: 0x00fa9a,
|
|
|
mediumturquoise: 0x48d1cc,
|
|
|
mediumvioletred: 0xc71585,
|
|
|
midnightblue: 0x191970,
|
|
|
mintcream: 0xf5fffa,
|
|
|
mistyrose: 0xffe4e1,
|
|
|
moccasin: 0xffe4b5,
|
|
|
navajowhite: 0xffdead,
|
|
|
navy: 0x000080,
|
|
|
oldlace: 0xfdf5e6,
|
|
|
olive: 0x808000,
|
|
|
olivedrab: 0x6b8e23,
|
|
|
orange: 0xffa500,
|
|
|
orangered: 0xff4500,
|
|
|
orchid: 0xda70d6,
|
|
|
palegoldenrod: 0xeee8aa,
|
|
|
palegreen: 0x98fb98,
|
|
|
paleturquoise: 0xafeeee,
|
|
|
palevioletred: 0xdb7093,
|
|
|
papayawhip: 0xffefd5,
|
|
|
peachpuff: 0xffdab9,
|
|
|
peru: 0xcd853f,
|
|
|
pink: 0xffc0cb,
|
|
|
plum: 0xdda0dd,
|
|
|
powderblue: 0xb0e0e6,
|
|
|
purple: 0x800080,
|
|
|
rebeccapurple: 0x663399,
|
|
|
red: 0xff0000,
|
|
|
rosybrown: 0xbc8f8f,
|
|
|
royalblue: 0x4169e1,
|
|
|
saddlebrown: 0x8b4513,
|
|
|
salmon: 0xfa8072,
|
|
|
sandybrown: 0xf4a460,
|
|
|
seagreen: 0x2e8b57,
|
|
|
seashell: 0xfff5ee,
|
|
|
sienna: 0xa0522d,
|
|
|
silver: 0xc0c0c0,
|
|
|
skyblue: 0x87ceeb,
|
|
|
slateblue: 0x6a5acd,
|
|
|
slategray: 0x708090,
|
|
|
slategrey: 0x708090,
|
|
|
snow: 0xfffafa,
|
|
|
springgreen: 0x00ff7f,
|
|
|
steelblue: 0x4682b4,
|
|
|
tan: 0xd2b48c,
|
|
|
teal: 0x008080,
|
|
|
thistle: 0xd8bfd8,
|
|
|
tomato: 0xff6347,
|
|
|
turquoise: 0x40e0d0,
|
|
|
violet: 0xee82ee,
|
|
|
wheat: 0xf5deb3,
|
|
|
white: 0xffffff,
|
|
|
whitesmoke: 0xf5f5f5,
|
|
|
yellow: 0xffff00,
|
|
|
yellowgreen: 0x9acd32
|
|
|
};
|
|
|
|
|
|
(0,_define_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Color, color, {
|
|
|
copy(channels) {
|
|
|
return Object.assign(new this.constructor, this, channels);
|
|
|
},
|
|
|
displayable() {
|
|
|
return this.rgb().displayable();
|
|
|
},
|
|
|
hex: color_formatHex, // Deprecated! Use color.formatHex.
|
|
|
formatHex: color_formatHex,
|
|
|
formatHex8: color_formatHex8,
|
|
|
formatHsl: color_formatHsl,
|
|
|
formatRgb: color_formatRgb,
|
|
|
toString: color_formatRgb
|
|
|
});
|
|
|
|
|
|
function color_formatHex() {
|
|
|
return this.rgb().formatHex();
|
|
|
}
|
|
|
|
|
|
function color_formatHex8() {
|
|
|
return this.rgb().formatHex8();
|
|
|
}
|
|
|
|
|
|
function color_formatHsl() {
|
|
|
return hslConvert(this).formatHsl();
|
|
|
}
|
|
|
|
|
|
function color_formatRgb() {
|
|
|
return this.rgb().formatRgb();
|
|
|
}
|
|
|
|
|
|
function color(format) {
|
|
|
var m, l;
|
|
|
format = (format + "").trim().toLowerCase();
|
|
|
return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
|
|
|
: l === 3 ? new Rgb((m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1) // #f00
|
|
|
: l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
|
|
|
: l === 4 ? rgba((m >> 12 & 0xf) | (m >> 8 & 0xf0), (m >> 8 & 0xf) | (m >> 4 & 0xf0), (m >> 4 & 0xf) | (m & 0xf0), (((m & 0xf) << 4) | (m & 0xf)) / 0xff) // #f000
|
|
|
: null) // invalid hex
|
|
|
: (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
|
|
|
: (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
|
|
|
: (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
|
|
|
: (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
|
|
|
: (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
|
|
|
: (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
|
|
|
: named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins
|
|
|
: format === "transparent" ? new Rgb(NaN, NaN, NaN, 0)
|
|
|
: null;
|
|
|
}
|
|
|
|
|
|
function rgbn(n) {
|
|
|
return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
|
|
|
}
|
|
|
|
|
|
function rgba(r, g, b, a) {
|
|
|
if (a <= 0) r = g = b = NaN;
|
|
|
return new Rgb(r, g, b, a);
|
|
|
}
|
|
|
|
|
|
function rgbConvert(o) {
|
|
|
if (!(o instanceof Color)) o = color(o);
|
|
|
if (!o) return new Rgb;
|
|
|
o = o.rgb();
|
|
|
return new Rgb(o.r, o.g, o.b, o.opacity);
|
|
|
}
|
|
|
|
|
|
function rgb(r, g, b, opacity) {
|
|
|
return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function Rgb(r, g, b, opacity) {
|
|
|
this.r = +r;
|
|
|
this.g = +g;
|
|
|
this.b = +b;
|
|
|
this.opacity = +opacity;
|
|
|
}
|
|
|
|
|
|
(0,_define_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Rgb, rgb, (0,_define_js__WEBPACK_IMPORTED_MODULE_0__/* .extend */ .l)(Color, {
|
|
|
brighter(k) {
|
|
|
k = k == null ? brighter : Math.pow(brighter, k);
|
|
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
|
|
|
},
|
|
|
darker(k) {
|
|
|
k = k == null ? darker : Math.pow(darker, k);
|
|
|
return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
|
|
|
},
|
|
|
rgb() {
|
|
|
return this;
|
|
|
},
|
|
|
clamp() {
|
|
|
return new Rgb(clampi(this.r), clampi(this.g), clampi(this.b), clampa(this.opacity));
|
|
|
},
|
|
|
displayable() {
|
|
|
return (-0.5 <= this.r && this.r < 255.5)
|
|
|
&& (-0.5 <= this.g && this.g < 255.5)
|
|
|
&& (-0.5 <= this.b && this.b < 255.5)
|
|
|
&& (0 <= this.opacity && this.opacity <= 1);
|
|
|
},
|
|
|
hex: rgb_formatHex, // Deprecated! Use color.formatHex.
|
|
|
formatHex: rgb_formatHex,
|
|
|
formatHex8: rgb_formatHex8,
|
|
|
formatRgb: rgb_formatRgb,
|
|
|
toString: rgb_formatRgb
|
|
|
}));
|
|
|
|
|
|
function rgb_formatHex() {
|
|
|
return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}`;
|
|
|
}
|
|
|
|
|
|
function rgb_formatHex8() {
|
|
|
return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
|
|
|
}
|
|
|
|
|
|
function rgb_formatRgb() {
|
|
|
const a = clampa(this.opacity);
|
|
|
return `${a === 1 ? "rgb(" : "rgba("}${clampi(this.r)}, ${clampi(this.g)}, ${clampi(this.b)}${a === 1 ? ")" : `, ${a})`}`;
|
|
|
}
|
|
|
|
|
|
function clampa(opacity) {
|
|
|
return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
|
|
|
}
|
|
|
|
|
|
function clampi(value) {
|
|
|
return Math.max(0, Math.min(255, Math.round(value) || 0));
|
|
|
}
|
|
|
|
|
|
function hex(value) {
|
|
|
value = clampi(value);
|
|
|
return (value < 16 ? "0" : "") + value.toString(16);
|
|
|
}
|
|
|
|
|
|
function hsla(h, s, l, a) {
|
|
|
if (a <= 0) h = s = l = NaN;
|
|
|
else if (l <= 0 || l >= 1) h = s = NaN;
|
|
|
else if (s <= 0) h = NaN;
|
|
|
return new Hsl(h, s, l, a);
|
|
|
}
|
|
|
|
|
|
function hslConvert(o) {
|
|
|
if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
|
|
|
if (!(o instanceof Color)) o = color(o);
|
|
|
if (!o) return new Hsl;
|
|
|
if (o instanceof Hsl) return o;
|
|
|
o = o.rgb();
|
|
|
var r = o.r / 255,
|
|
|
g = o.g / 255,
|
|
|
b = o.b / 255,
|
|
|
min = Math.min(r, g, b),
|
|
|
max = Math.max(r, g, b),
|
|
|
h = NaN,
|
|
|
s = max - min,
|
|
|
l = (max + min) / 2;
|
|
|
if (s) {
|
|
|
if (r === max) h = (g - b) / s + (g < b) * 6;
|
|
|
else if (g === max) h = (b - r) / s + 2;
|
|
|
else h = (r - g) / s + 4;
|
|
|
s /= l < 0.5 ? max + min : 2 - max - min;
|
|
|
h *= 60;
|
|
|
} else {
|
|
|
s = l > 0 && l < 1 ? 0 : h;
|
|
|
}
|
|
|
return new Hsl(h, s, l, o.opacity);
|
|
|
}
|
|
|
|
|
|
function hsl(h, s, l, opacity) {
|
|
|
return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function Hsl(h, s, l, opacity) {
|
|
|
this.h = +h;
|
|
|
this.s = +s;
|
|
|
this.l = +l;
|
|
|
this.opacity = +opacity;
|
|
|
}
|
|
|
|
|
|
(0,_define_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Hsl, hsl, (0,_define_js__WEBPACK_IMPORTED_MODULE_0__/* .extend */ .l)(Color, {
|
|
|
brighter(k) {
|
|
|
k = k == null ? brighter : Math.pow(brighter, k);
|
|
|
return new Hsl(this.h, this.s, this.l * k, this.opacity);
|
|
|
},
|
|
|
darker(k) {
|
|
|
k = k == null ? darker : Math.pow(darker, k);
|
|
|
return new Hsl(this.h, this.s, this.l * k, this.opacity);
|
|
|
},
|
|
|
rgb() {
|
|
|
var h = this.h % 360 + (this.h < 0) * 360,
|
|
|
s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
|
|
|
l = this.l,
|
|
|
m2 = l + (l < 0.5 ? l : 1 - l) * s,
|
|
|
m1 = 2 * l - m2;
|
|
|
return new Rgb(
|
|
|
hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
|
|
|
hsl2rgb(h, m1, m2),
|
|
|
hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
|
|
|
this.opacity
|
|
|
);
|
|
|
},
|
|
|
clamp() {
|
|
|
return new Hsl(clamph(this.h), clampt(this.s), clampt(this.l), clampa(this.opacity));
|
|
|
},
|
|
|
displayable() {
|
|
|
return (0 <= this.s && this.s <= 1 || isNaN(this.s))
|
|
|
&& (0 <= this.l && this.l <= 1)
|
|
|
&& (0 <= this.opacity && this.opacity <= 1);
|
|
|
},
|
|
|
formatHsl() {
|
|
|
const a = clampa(this.opacity);
|
|
|
return `${a === 1 ? "hsl(" : "hsla("}${clamph(this.h)}, ${clampt(this.s) * 100}%, ${clampt(this.l) * 100}%${a === 1 ? ")" : `, ${a})`}`;
|
|
|
}
|
|
|
}));
|
|
|
|
|
|
function clamph(value) {
|
|
|
value = (value || 0) % 360;
|
|
|
return value < 0 ? value + 360 : value;
|
|
|
}
|
|
|
|
|
|
function clampt(value) {
|
|
|
return Math.max(0, Math.min(1, value || 0));
|
|
|
}
|
|
|
|
|
|
/* From FvD 13.37, CSS Color Module Level 3 */
|
|
|
function hsl2rgb(h, m1, m2) {
|
|
|
return (h < 60 ? m1 + (m2 - m1) * h / 60
|
|
|
: h < 180 ? m2
|
|
|
: h < 240 ? m1 + (m2 - m1) * (240 - h) / 60
|
|
|
: m1) * 255;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 77551:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ l: () => (/* binding */ extend)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(constructor, factory, prototype) {
|
|
|
constructor.prototype = factory.prototype = prototype;
|
|
|
prototype.constructor = constructor;
|
|
|
}
|
|
|
|
|
|
function extend(parent, definition) {
|
|
|
var prototype = Object.create(parent.prototype);
|
|
|
for (var key in definition) prototype[key] = definition[key];
|
|
|
return prototype;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 64836:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Uc: () => (/* binding */ hcl),
|
|
|
/* harmony export */ ZP: () => (/* binding */ lab)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports gray, Lab, lch, Hcl */
|
|
|
/* harmony import */ var _define_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(77551);
|
|
|
/* harmony import */ var _color_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12738);
|
|
|
/* harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(56091);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// https://observablehq.com/@mbostock/lab-and-rgb
|
|
|
const K = 18,
|
|
|
Xn = 0.96422,
|
|
|
Yn = 1,
|
|
|
Zn = 0.82521,
|
|
|
t0 = 4 / 29,
|
|
|
t1 = 6 / 29,
|
|
|
t2 = 3 * t1 * t1,
|
|
|
t3 = t1 * t1 * t1;
|
|
|
|
|
|
function labConvert(o) {
|
|
|
if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
|
|
|
if (o instanceof Hcl) return hcl2lab(o);
|
|
|
if (!(o instanceof _color_js__WEBPACK_IMPORTED_MODULE_0__/* .Rgb */ .Ss)) o = (0,_color_js__WEBPACK_IMPORTED_MODULE_0__/* .rgbConvert */ .SU)(o);
|
|
|
var r = rgb2lrgb(o.r),
|
|
|
g = rgb2lrgb(o.g),
|
|
|
b = rgb2lrgb(o.b),
|
|
|
y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z;
|
|
|
if (r === g && g === b) x = z = y; else {
|
|
|
x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn);
|
|
|
z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn);
|
|
|
}
|
|
|
return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
|
|
|
}
|
|
|
|
|
|
function gray(l, opacity) {
|
|
|
return new Lab(l, 0, 0, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function lab(l, a, b, opacity) {
|
|
|
return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function Lab(l, a, b, opacity) {
|
|
|
this.l = +l;
|
|
|
this.a = +a;
|
|
|
this.b = +b;
|
|
|
this.opacity = +opacity;
|
|
|
}
|
|
|
|
|
|
(0,_define_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(Lab, lab, (0,_define_js__WEBPACK_IMPORTED_MODULE_1__/* .extend */ .l)(_color_js__WEBPACK_IMPORTED_MODULE_0__/* .Color */ .Il, {
|
|
|
brighter(k) {
|
|
|
return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity);
|
|
|
},
|
|
|
darker(k) {
|
|
|
return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity);
|
|
|
},
|
|
|
rgb() {
|
|
|
var y = (this.l + 16) / 116,
|
|
|
x = isNaN(this.a) ? y : y + this.a / 500,
|
|
|
z = isNaN(this.b) ? y : y - this.b / 200;
|
|
|
x = Xn * lab2xyz(x);
|
|
|
y = Yn * lab2xyz(y);
|
|
|
z = Zn * lab2xyz(z);
|
|
|
return new _color_js__WEBPACK_IMPORTED_MODULE_0__/* .Rgb */ .Ss(
|
|
|
lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z),
|
|
|
lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z),
|
|
|
lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z),
|
|
|
this.opacity
|
|
|
);
|
|
|
}
|
|
|
}));
|
|
|
|
|
|
function xyz2lab(t) {
|
|
|
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
|
|
|
}
|
|
|
|
|
|
function lab2xyz(t) {
|
|
|
return t > t1 ? t * t * t : t2 * (t - t0);
|
|
|
}
|
|
|
|
|
|
function lrgb2rgb(x) {
|
|
|
return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
|
|
|
}
|
|
|
|
|
|
function rgb2lrgb(x) {
|
|
|
return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
|
|
|
}
|
|
|
|
|
|
function hclConvert(o) {
|
|
|
if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
|
|
|
if (!(o instanceof Lab)) o = labConvert(o);
|
|
|
if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity);
|
|
|
var h = Math.atan2(o.b, o.a) * _math_js__WEBPACK_IMPORTED_MODULE_2__/* .degrees */ .R;
|
|
|
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
|
|
|
}
|
|
|
|
|
|
function lch(l, c, h, opacity) {
|
|
|
return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function hcl(h, c, l, opacity) {
|
|
|
return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function Hcl(h, c, l, opacity) {
|
|
|
this.h = +h;
|
|
|
this.c = +c;
|
|
|
this.l = +l;
|
|
|
this.opacity = +opacity;
|
|
|
}
|
|
|
|
|
|
function hcl2lab(o) {
|
|
|
if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
|
|
|
var h = o.h * _math_js__WEBPACK_IMPORTED_MODULE_2__/* .radians */ .u;
|
|
|
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
|
|
|
}
|
|
|
|
|
|
(0,_define_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(Hcl, hcl, (0,_define_js__WEBPACK_IMPORTED_MODULE_1__/* .extend */ .l)(_color_js__WEBPACK_IMPORTED_MODULE_0__/* .Color */ .Il, {
|
|
|
brighter(k) {
|
|
|
return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity);
|
|
|
},
|
|
|
darker(k) {
|
|
|
return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity);
|
|
|
},
|
|
|
rgb() {
|
|
|
return hcl2lab(this).rgb();
|
|
|
}
|
|
|
}));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 56091:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ R: () => (/* binding */ degrees),
|
|
|
/* harmony export */ u: () => (/* binding */ radians)
|
|
|
/* harmony export */ });
|
|
|
const radians = Math.PI / 180;
|
|
|
const degrees = 180 / Math.PI;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 65043:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
var noop = {value: () => {}};
|
|
|
|
|
|
function dispatch() {
|
|
|
for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
|
|
|
if (!(t = arguments[i] + "") || (t in _) || /[\s.]/.test(t)) throw new Error("illegal type: " + t);
|
|
|
_[t] = [];
|
|
|
}
|
|
|
return new Dispatch(_);
|
|
|
}
|
|
|
|
|
|
function Dispatch(_) {
|
|
|
this._ = _;
|
|
|
}
|
|
|
|
|
|
function parseTypenames(typenames, types) {
|
|
|
return typenames.trim().split(/^|\s+/).map(function(t) {
|
|
|
var name = "", i = t.indexOf(".");
|
|
|
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
|
|
|
if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
|
|
|
return {type: t, name: name};
|
|
|
});
|
|
|
}
|
|
|
|
|
|
Dispatch.prototype = dispatch.prototype = {
|
|
|
constructor: Dispatch,
|
|
|
on: function(typename, callback) {
|
|
|
var _ = this._,
|
|
|
T = parseTypenames(typename + "", _),
|
|
|
t,
|
|
|
i = -1,
|
|
|
n = T.length;
|
|
|
|
|
|
// If no callback was specified, return the callback of the given type and name.
|
|
|
if (arguments.length < 2) {
|
|
|
while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// If a type was specified, set the callback for the given type and name.
|
|
|
// Otherwise, if a null callback was specified, remove callbacks of the given name.
|
|
|
if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
|
|
|
while (++i < n) {
|
|
|
if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
|
|
|
else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
|
|
|
}
|
|
|
|
|
|
return this;
|
|
|
},
|
|
|
copy: function() {
|
|
|
var copy = {}, _ = this._;
|
|
|
for (var t in _) copy[t] = _[t].slice();
|
|
|
return new Dispatch(copy);
|
|
|
},
|
|
|
call: function(type, that) {
|
|
|
if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];
|
|
|
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
|
|
|
for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
|
|
|
},
|
|
|
apply: function(type, that, args) {
|
|
|
if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
|
|
|
for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function get(type, name) {
|
|
|
for (var i = 0, n = type.length, c; i < n; ++i) {
|
|
|
if ((c = type[i]).name === name) {
|
|
|
return c.value;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function set(type, name, callback) {
|
|
|
for (var i = 0, n = type.length; i < n; ++i) {
|
|
|
if (type[i].name === name) {
|
|
|
type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if (callback != null) type.push({name: name, value: callback});
|
|
|
return type;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (dispatch);
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 90741:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ WU: () => (/* binding */ format),
|
|
|
/* harmony export */ jH: () => (/* binding */ formatPrefix)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export default */
|
|
|
/* harmony import */ var _locale_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(63770);
|
|
|
|
|
|
|
|
|
var locale;
|
|
|
var format;
|
|
|
var formatPrefix;
|
|
|
|
|
|
defaultLocale({
|
|
|
thousands: ",",
|
|
|
grouping: [3],
|
|
|
currency: ["$", ""]
|
|
|
});
|
|
|
|
|
|
function defaultLocale(definition) {
|
|
|
locale = (0,_locale_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(definition);
|
|
|
format = locale.format;
|
|
|
formatPrefix = locale.formatPrefix;
|
|
|
return locale;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 3044:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(47583);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x) {
|
|
|
return x = (0,_formatDecimal_js__WEBPACK_IMPORTED_MODULE_0__/* .formatDecimalParts */ .V)(Math.abs(x)), x ? x[1] : NaN;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 47583:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ V: () => (/* binding */ formatDecimalParts),
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x) {
|
|
|
return Math.abs(x = Math.round(x)) >= 1e21
|
|
|
? x.toLocaleString("en").replace(/,/g, "")
|
|
|
: x.toString(10);
|
|
|
}
|
|
|
|
|
|
// Computes the decimal coefficient and exponent of the specified number x with
|
|
|
// significant digits p, where x is positive and p is in [1, 21] or undefined.
|
|
|
// For example, formatDecimalParts(1.23) returns ["123", 0].
|
|
|
function formatDecimalParts(x, p) {
|
|
|
if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity
|
|
|
var i, coefficient = x.slice(0, i);
|
|
|
|
|
|
// The string returned by toExponential either has the form \d\.\d+e[-+]\d+
|
|
|
// (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3).
|
|
|
return [
|
|
|
coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
|
|
|
+x.slice(i + 1)
|
|
|
];
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 32159:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ formatSpecifier)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export FormatSpecifier */
|
|
|
// [[fill]align][sign][symbol][0][width][,][.precision][~][type]
|
|
|
var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
|
|
|
|
|
|
function formatSpecifier(specifier) {
|
|
|
if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
|
|
|
var match;
|
|
|
return new FormatSpecifier({
|
|
|
fill: match[1],
|
|
|
align: match[2],
|
|
|
sign: match[3],
|
|
|
symbol: match[4],
|
|
|
zero: match[5],
|
|
|
width: match[6],
|
|
|
comma: match[7],
|
|
|
precision: match[8] && match[8].slice(1),
|
|
|
trim: match[9],
|
|
|
type: match[10]
|
|
|
});
|
|
|
}
|
|
|
|
|
|
formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof
|
|
|
|
|
|
function FormatSpecifier(specifier) {
|
|
|
this.fill = specifier.fill === undefined ? " " : specifier.fill + "";
|
|
|
this.align = specifier.align === undefined ? ">" : specifier.align + "";
|
|
|
this.sign = specifier.sign === undefined ? "-" : specifier.sign + "";
|
|
|
this.symbol = specifier.symbol === undefined ? "" : specifier.symbol + "";
|
|
|
this.zero = !!specifier.zero;
|
|
|
this.width = specifier.width === undefined ? undefined : +specifier.width;
|
|
|
this.comma = !!specifier.comma;
|
|
|
this.precision = specifier.precision === undefined ? undefined : +specifier.precision;
|
|
|
this.trim = !!specifier.trim;
|
|
|
this.type = specifier.type === undefined ? "" : specifier.type + "";
|
|
|
}
|
|
|
|
|
|
FormatSpecifier.prototype.toString = function() {
|
|
|
return this.fill
|
|
|
+ this.align
|
|
|
+ this.sign
|
|
|
+ this.symbol
|
|
|
+ (this.zero ? "0" : "")
|
|
|
+ (this.width === undefined ? "" : Math.max(1, this.width | 0))
|
|
|
+ (this.comma ? "," : "")
|
|
|
+ (this.precision === undefined ? "" : "." + Math.max(0, this.precision | 0))
|
|
|
+ (this.trim ? "~" : "")
|
|
|
+ this.type;
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 63770:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
Z: () => (/* binding */ locale)
|
|
|
});
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-format/src/exponent.js
|
|
|
var exponent = __webpack_require__(3044);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatGroup.js
|
|
|
/* harmony default export */ function formatGroup(grouping, thousands) {
|
|
|
return function(value, width) {
|
|
|
var i = value.length,
|
|
|
t = [],
|
|
|
j = 0,
|
|
|
g = grouping[0],
|
|
|
length = 0;
|
|
|
|
|
|
while (i > 0 && g > 0) {
|
|
|
if (length + g + 1 > width) g = Math.max(1, width - length);
|
|
|
t.push(value.substring(i -= g, i + g));
|
|
|
if ((length += g + 1) > width) break;
|
|
|
g = grouping[j = (j + 1) % grouping.length];
|
|
|
}
|
|
|
|
|
|
return t.reverse().join(thousands);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatNumerals.js
|
|
|
/* harmony default export */ function formatNumerals(numerals) {
|
|
|
return function(value) {
|
|
|
return value.replace(/[0-9]/g, function(i) {
|
|
|
return numerals[+i];
|
|
|
});
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-format/src/formatSpecifier.js
|
|
|
var formatSpecifier = __webpack_require__(32159);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatTrim.js
|
|
|
// Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k.
|
|
|
/* harmony default export */ function formatTrim(s) {
|
|
|
out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) {
|
|
|
switch (s[i]) {
|
|
|
case ".": i0 = i1 = i; break;
|
|
|
case "0": if (i0 === 0) i0 = i; i1 = i; break;
|
|
|
default: if (!+s[i]) break out; if (i0 > 0) i0 = 0; break;
|
|
|
}
|
|
|
}
|
|
|
return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-format/src/formatDecimal.js
|
|
|
var formatDecimal = __webpack_require__(47583);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatPrefixAuto.js
|
|
|
|
|
|
|
|
|
var prefixExponent;
|
|
|
|
|
|
/* harmony default export */ function formatPrefixAuto(x, p) {
|
|
|
var d = (0,formatDecimal/* formatDecimalParts */.V)(x, p);
|
|
|
if (!d) return x + "";
|
|
|
var coefficient = d[0],
|
|
|
exponent = d[1],
|
|
|
i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,
|
|
|
n = coefficient.length;
|
|
|
return i === n ? coefficient
|
|
|
: i > n ? coefficient + new Array(i - n + 1).join("0")
|
|
|
: i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i)
|
|
|
: "0." + new Array(1 - i).join("0") + (0,formatDecimal/* formatDecimalParts */.V)(x, Math.max(0, p + i - 1))[0]; // less than 1y!
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatRounded.js
|
|
|
|
|
|
|
|
|
/* harmony default export */ function formatRounded(x, p) {
|
|
|
var d = (0,formatDecimal/* formatDecimalParts */.V)(x, p);
|
|
|
if (!d) return x + "";
|
|
|
var coefficient = d[0],
|
|
|
exponent = d[1];
|
|
|
return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient
|
|
|
: coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1)
|
|
|
: coefficient + new Array(exponent - coefficient.length + 2).join("0");
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/formatTypes.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ const formatTypes = ({
|
|
|
"%": (x, p) => (x * 100).toFixed(p),
|
|
|
"b": (x) => Math.round(x).toString(2),
|
|
|
"c": (x) => x + "",
|
|
|
"d": formatDecimal/* default */.Z,
|
|
|
"e": (x, p) => x.toExponential(p),
|
|
|
"f": (x, p) => x.toFixed(p),
|
|
|
"g": (x, p) => x.toPrecision(p),
|
|
|
"o": (x) => Math.round(x).toString(8),
|
|
|
"p": (x, p) => formatRounded(x * 100, p),
|
|
|
"r": formatRounded,
|
|
|
"s": formatPrefixAuto,
|
|
|
"X": (x) => Math.round(x).toString(16).toUpperCase(),
|
|
|
"x": (x) => Math.round(x).toString(16)
|
|
|
});
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/identity.js
|
|
|
/* harmony default export */ function identity(x) {
|
|
|
return x;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-format/src/locale.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var map = Array.prototype.map,
|
|
|
prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];
|
|
|
|
|
|
/* harmony default export */ function locale(locale) {
|
|
|
var group = locale.grouping === undefined || locale.thousands === undefined ? identity : formatGroup(map.call(locale.grouping, Number), locale.thousands + ""),
|
|
|
currencyPrefix = locale.currency === undefined ? "" : locale.currency[0] + "",
|
|
|
currencySuffix = locale.currency === undefined ? "" : locale.currency[1] + "",
|
|
|
decimal = locale.decimal === undefined ? "." : locale.decimal + "",
|
|
|
numerals = locale.numerals === undefined ? identity : formatNumerals(map.call(locale.numerals, String)),
|
|
|
percent = locale.percent === undefined ? "%" : locale.percent + "",
|
|
|
minus = locale.minus === undefined ? "−" : locale.minus + "",
|
|
|
nan = locale.nan === undefined ? "NaN" : locale.nan + "";
|
|
|
|
|
|
function newFormat(specifier) {
|
|
|
specifier = (0,formatSpecifier/* default */.Z)(specifier);
|
|
|
|
|
|
var fill = specifier.fill,
|
|
|
align = specifier.align,
|
|
|
sign = specifier.sign,
|
|
|
symbol = specifier.symbol,
|
|
|
zero = specifier.zero,
|
|
|
width = specifier.width,
|
|
|
comma = specifier.comma,
|
|
|
precision = specifier.precision,
|
|
|
trim = specifier.trim,
|
|
|
type = specifier.type;
|
|
|
|
|
|
// The "n" type is an alias for ",g".
|
|
|
if (type === "n") comma = true, type = "g";
|
|
|
|
|
|
// The "" type, and any invalid type, is an alias for ".12~g".
|
|
|
else if (!formatTypes[type]) precision === undefined && (precision = 12), trim = true, type = "g";
|
|
|
|
|
|
// If zero fill is specified, padding goes after sign and before digits.
|
|
|
if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "=";
|
|
|
|
|
|
// Compute the prefix and suffix.
|
|
|
// For SI-prefix, the suffix is lazily computed.
|
|
|
var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "",
|
|
|
suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : "";
|
|
|
|
|
|
// What format function should we use?
|
|
|
// Is this an integer type?
|
|
|
// Can this type generate exponential notation?
|
|
|
var formatType = formatTypes[type],
|
|
|
maybeSuffix = /[defgprs%]/.test(type);
|
|
|
|
|
|
// Set the default precision if not specified,
|
|
|
// or clamp the specified precision to the supported range.
|
|
|
// For significant precision, it must be in [1, 21].
|
|
|
// For fixed precision, it must be in [0, 20].
|
|
|
precision = precision === undefined ? 6
|
|
|
: /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))
|
|
|
: Math.max(0, Math.min(20, precision));
|
|
|
|
|
|
function format(value) {
|
|
|
var valuePrefix = prefix,
|
|
|
valueSuffix = suffix,
|
|
|
i, n, c;
|
|
|
|
|
|
if (type === "c") {
|
|
|
valueSuffix = formatType(value) + valueSuffix;
|
|
|
value = "";
|
|
|
} else {
|
|
|
value = +value;
|
|
|
|
|
|
// Determine the sign. -0 is not less than 0, but 1 / -0 is!
|
|
|
var valueNegative = value < 0 || 1 / value < 0;
|
|
|
|
|
|
// Perform the initial formatting.
|
|
|
value = isNaN(value) ? nan : formatType(Math.abs(value), precision);
|
|
|
|
|
|
// Trim insignificant zeros.
|
|
|
if (trim) value = formatTrim(value);
|
|
|
|
|
|
// If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign.
|
|
|
if (valueNegative && +value === 0 && sign !== "+") valueNegative = false;
|
|
|
|
|
|
// Compute the prefix and suffix.
|
|
|
valuePrefix = (valueNegative ? (sign === "(" ? sign : minus) : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
|
|
|
valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : "");
|
|
|
|
|
|
// Break the formatted value into the integer “value” part that can be
|
|
|
// grouped, and fractional or exponential “suffix” part that is not.
|
|
|
if (maybeSuffix) {
|
|
|
i = -1, n = value.length;
|
|
|
while (++i < n) {
|
|
|
if (c = value.charCodeAt(i), 48 > c || c > 57) {
|
|
|
valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
|
|
|
value = value.slice(0, i);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// If the fill character is not "0", grouping is applied before padding.
|
|
|
if (comma && !zero) value = group(value, Infinity);
|
|
|
|
|
|
// Compute the padding.
|
|
|
var length = valuePrefix.length + value.length + valueSuffix.length,
|
|
|
padding = length < width ? new Array(width - length + 1).join(fill) : "";
|
|
|
|
|
|
// If the fill character is "0", grouping is applied after padding.
|
|
|
if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
|
|
|
|
|
|
// Reconstruct the final output based on the desired alignment.
|
|
|
switch (align) {
|
|
|
case "<": value = valuePrefix + value + valueSuffix + padding; break;
|
|
|
case "=": value = valuePrefix + padding + value + valueSuffix; break;
|
|
|
case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break;
|
|
|
default: value = padding + valuePrefix + value + valueSuffix; break;
|
|
|
}
|
|
|
|
|
|
return numerals(value);
|
|
|
}
|
|
|
|
|
|
format.toString = function() {
|
|
|
return specifier + "";
|
|
|
};
|
|
|
|
|
|
return format;
|
|
|
}
|
|
|
|
|
|
function formatPrefix(specifier, value) {
|
|
|
var f = newFormat((specifier = (0,formatSpecifier/* default */.Z)(specifier), specifier.type = "f", specifier)),
|
|
|
e = Math.max(-8, Math.min(8, Math.floor((0,exponent/* default */.Z)(value) / 3))) * 3,
|
|
|
k = Math.pow(10, -e),
|
|
|
prefix = prefixes[8 + e / 3];
|
|
|
return function(value) {
|
|
|
return f(k * value) + prefix;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
format: newFormat,
|
|
|
formatPrefix: formatPrefix
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 39155:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3044);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(step) {
|
|
|
return Math.max(0, -(0,_exponent_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Math.abs(step)));
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 61816:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3044);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(step, value) {
|
|
|
return Math.max(0, Math.max(-8, Math.min(8, Math.floor((0,_exponent_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(value) / 3))) * 3 - (0,_exponent_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Math.abs(step)));
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 84767:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _exponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3044);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(step, max) {
|
|
|
step = Math.abs(step), max = Math.abs(max) - step;
|
|
|
return Math.max(0, (0,_exponent_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(max) - (0,_exponent_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(step)) + 1;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 4474:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ C: () => (/* binding */ required),
|
|
|
/* harmony export */ j: () => (/* binding */ optional)
|
|
|
/* harmony export */ });
|
|
|
function optional(f) {
|
|
|
return f == null ? null : required(f);
|
|
|
}
|
|
|
|
|
|
function required(f) {
|
|
|
if (typeof f !== "function") throw new Error;
|
|
|
return f;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 10174:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ G: () => (/* binding */ constantZero),
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
function constantZero() {
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x) {
|
|
|
return function() {
|
|
|
return x;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 68775:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
NB: () => (/* binding */ Node),
|
|
|
le: () => (/* binding */ computeHeight),
|
|
|
ZP: () => (/* binding */ hierarchy)
|
|
|
});
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/count.js
|
|
|
function count(node) {
|
|
|
var sum = 0,
|
|
|
children = node.children,
|
|
|
i = children && children.length;
|
|
|
if (!i) sum = 1;
|
|
|
else while (--i >= 0) sum += children[i].value;
|
|
|
node.value = sum;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function hierarchy_count() {
|
|
|
return this.eachAfter(count);
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/each.js
|
|
|
/* harmony default export */ function each(callback, that) {
|
|
|
let index = -1;
|
|
|
for (const node of this) {
|
|
|
callback.call(that, node, ++index, this);
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/eachBefore.js
|
|
|
/* harmony default export */ function eachBefore(callback, that) {
|
|
|
var node = this, nodes = [node], children, i, index = -1;
|
|
|
while (node = nodes.pop()) {
|
|
|
callback.call(that, node, ++index, this);
|
|
|
if (children = node.children) {
|
|
|
for (i = children.length - 1; i >= 0; --i) {
|
|
|
nodes.push(children[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/eachAfter.js
|
|
|
/* harmony default export */ function eachAfter(callback, that) {
|
|
|
var node = this, nodes = [node], next = [], children, i, n, index = -1;
|
|
|
while (node = nodes.pop()) {
|
|
|
next.push(node);
|
|
|
if (children = node.children) {
|
|
|
for (i = 0, n = children.length; i < n; ++i) {
|
|
|
nodes.push(children[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
while (node = next.pop()) {
|
|
|
callback.call(that, node, ++index, this);
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/find.js
|
|
|
/* harmony default export */ function find(callback, that) {
|
|
|
let index = -1;
|
|
|
for (const node of this) {
|
|
|
if (callback.call(that, node, ++index, this)) {
|
|
|
return node;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/sum.js
|
|
|
/* harmony default export */ function sum(value) {
|
|
|
return this.eachAfter(function(node) {
|
|
|
var sum = +value(node.data) || 0,
|
|
|
children = node.children,
|
|
|
i = children && children.length;
|
|
|
while (--i >= 0) sum += children[i].value;
|
|
|
node.value = sum;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/sort.js
|
|
|
/* harmony default export */ function sort(compare) {
|
|
|
return this.eachBefore(function(node) {
|
|
|
if (node.children) {
|
|
|
node.children.sort(compare);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/path.js
|
|
|
/* harmony default export */ function path(end) {
|
|
|
var start = this,
|
|
|
ancestor = leastCommonAncestor(start, end),
|
|
|
nodes = [start];
|
|
|
while (start !== ancestor) {
|
|
|
start = start.parent;
|
|
|
nodes.push(start);
|
|
|
}
|
|
|
var k = nodes.length;
|
|
|
while (end !== ancestor) {
|
|
|
nodes.splice(k, 0, end);
|
|
|
end = end.parent;
|
|
|
}
|
|
|
return nodes;
|
|
|
}
|
|
|
|
|
|
function leastCommonAncestor(a, b) {
|
|
|
if (a === b) return a;
|
|
|
var aNodes = a.ancestors(),
|
|
|
bNodes = b.ancestors(),
|
|
|
c = null;
|
|
|
a = aNodes.pop();
|
|
|
b = bNodes.pop();
|
|
|
while (a === b) {
|
|
|
c = a;
|
|
|
a = aNodes.pop();
|
|
|
b = bNodes.pop();
|
|
|
}
|
|
|
return c;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/ancestors.js
|
|
|
/* harmony default export */ function ancestors() {
|
|
|
var node = this, nodes = [node];
|
|
|
while (node = node.parent) {
|
|
|
nodes.push(node);
|
|
|
}
|
|
|
return nodes;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/descendants.js
|
|
|
/* harmony default export */ function descendants() {
|
|
|
return Array.from(this);
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/leaves.js
|
|
|
/* harmony default export */ function leaves() {
|
|
|
var leaves = [];
|
|
|
this.eachBefore(function(node) {
|
|
|
if (!node.children) {
|
|
|
leaves.push(node);
|
|
|
}
|
|
|
});
|
|
|
return leaves;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/links.js
|
|
|
/* harmony default export */ function links() {
|
|
|
var root = this, links = [];
|
|
|
root.each(function(node) {
|
|
|
if (node !== root) { // Don’t include the root’s parent, if any.
|
|
|
links.push({source: node.parent, target: node});
|
|
|
}
|
|
|
});
|
|
|
return links;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/iterator.js
|
|
|
/* harmony default export */ function* iterator() {
|
|
|
var node = this, current, next = [node], children, i, n;
|
|
|
do {
|
|
|
current = next.reverse(), next = [];
|
|
|
while (node = current.pop()) {
|
|
|
yield node;
|
|
|
if (children = node.children) {
|
|
|
for (i = 0, n = children.length; i < n; ++i) {
|
|
|
next.push(children[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} while (next.length);
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-hierarchy/src/hierarchy/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function hierarchy(data, children) {
|
|
|
if (data instanceof Map) {
|
|
|
data = [undefined, data];
|
|
|
if (children === undefined) children = mapChildren;
|
|
|
} else if (children === undefined) {
|
|
|
children = objectChildren;
|
|
|
}
|
|
|
|
|
|
var root = new Node(data),
|
|
|
node,
|
|
|
nodes = [root],
|
|
|
child,
|
|
|
childs,
|
|
|
i,
|
|
|
n;
|
|
|
|
|
|
while (node = nodes.pop()) {
|
|
|
if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) {
|
|
|
node.children = childs;
|
|
|
for (i = n - 1; i >= 0; --i) {
|
|
|
nodes.push(child = childs[i] = new Node(childs[i]));
|
|
|
child.parent = node;
|
|
|
child.depth = node.depth + 1;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return root.eachBefore(computeHeight);
|
|
|
}
|
|
|
|
|
|
function node_copy() {
|
|
|
return hierarchy(this).eachBefore(copyData);
|
|
|
}
|
|
|
|
|
|
function objectChildren(d) {
|
|
|
return d.children;
|
|
|
}
|
|
|
|
|
|
function mapChildren(d) {
|
|
|
return Array.isArray(d) ? d[1] : null;
|
|
|
}
|
|
|
|
|
|
function copyData(node) {
|
|
|
if (node.data.value !== undefined) node.value = node.data.value;
|
|
|
node.data = node.data.data;
|
|
|
}
|
|
|
|
|
|
function computeHeight(node) {
|
|
|
var height = 0;
|
|
|
do node.height = height;
|
|
|
while ((node = node.parent) && (node.height < ++height));
|
|
|
}
|
|
|
|
|
|
function Node(data) {
|
|
|
this.data = data;
|
|
|
this.depth =
|
|
|
this.height = 0;
|
|
|
this.parent = null;
|
|
|
}
|
|
|
|
|
|
Node.prototype = hierarchy.prototype = {
|
|
|
constructor: Node,
|
|
|
count: hierarchy_count,
|
|
|
each: each,
|
|
|
eachAfter: eachAfter,
|
|
|
eachBefore: eachBefore,
|
|
|
find: find,
|
|
|
sum: sum,
|
|
|
sort: sort,
|
|
|
path: path,
|
|
|
ancestors: ancestors,
|
|
|
descendants: descendants,
|
|
|
leaves: leaves,
|
|
|
links: links,
|
|
|
copy: node_copy,
|
|
|
[Symbol.iterator]: iterator
|
|
|
};
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 98039:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(parent, x0, y0, x1, y1) {
|
|
|
var nodes = parent.children,
|
|
|
node,
|
|
|
i = -1,
|
|
|
n = nodes.length,
|
|
|
k = parent.value && (x1 - x0) / parent.value;
|
|
|
|
|
|
while (++i < n) {
|
|
|
node = nodes[i], node.y0 = y0, node.y1 = y1;
|
|
|
node.x0 = x0, node.x1 = x0 += node.value * k;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 99375:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _round_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(41916);
|
|
|
/* harmony import */ var _squarify_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20737);
|
|
|
/* harmony import */ var _accessors_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4474);
|
|
|
/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10174);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__() {
|
|
|
var tile = _squarify_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP,
|
|
|
round = false,
|
|
|
dx = 1,
|
|
|
dy = 1,
|
|
|
paddingStack = [0],
|
|
|
paddingInner = _constant_js__WEBPACK_IMPORTED_MODULE_1__/* .constantZero */ .G,
|
|
|
paddingTop = _constant_js__WEBPACK_IMPORTED_MODULE_1__/* .constantZero */ .G,
|
|
|
paddingRight = _constant_js__WEBPACK_IMPORTED_MODULE_1__/* .constantZero */ .G,
|
|
|
paddingBottom = _constant_js__WEBPACK_IMPORTED_MODULE_1__/* .constantZero */ .G,
|
|
|
paddingLeft = _constant_js__WEBPACK_IMPORTED_MODULE_1__/* .constantZero */ .G;
|
|
|
|
|
|
function treemap(root) {
|
|
|
root.x0 =
|
|
|
root.y0 = 0;
|
|
|
root.x1 = dx;
|
|
|
root.y1 = dy;
|
|
|
root.eachBefore(positionNode);
|
|
|
paddingStack = [0];
|
|
|
if (round) root.eachBefore(_round_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z);
|
|
|
return root;
|
|
|
}
|
|
|
|
|
|
function positionNode(node) {
|
|
|
var p = paddingStack[node.depth],
|
|
|
x0 = node.x0 + p,
|
|
|
y0 = node.y0 + p,
|
|
|
x1 = node.x1 - p,
|
|
|
y1 = node.y1 - p;
|
|
|
if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
|
|
|
if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
|
|
|
node.x0 = x0;
|
|
|
node.y0 = y0;
|
|
|
node.x1 = x1;
|
|
|
node.y1 = y1;
|
|
|
if (node.children) {
|
|
|
p = paddingStack[node.depth + 1] = paddingInner(node) / 2;
|
|
|
x0 += paddingLeft(node) - p;
|
|
|
y0 += paddingTop(node) - p;
|
|
|
x1 -= paddingRight(node) - p;
|
|
|
y1 -= paddingBottom(node) - p;
|
|
|
if (x1 < x0) x0 = x1 = (x0 + x1) / 2;
|
|
|
if (y1 < y0) y0 = y1 = (y0 + y1) / 2;
|
|
|
tile(node, x0, y0, x1, y1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
treemap.round = function(x) {
|
|
|
return arguments.length ? (round = !!x, treemap) : round;
|
|
|
};
|
|
|
|
|
|
treemap.size = function(x) {
|
|
|
return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];
|
|
|
};
|
|
|
|
|
|
treemap.tile = function(x) {
|
|
|
return arguments.length ? (tile = (0,_accessors_js__WEBPACK_IMPORTED_MODULE_3__/* .required */ .C)(x), treemap) : tile;
|
|
|
};
|
|
|
|
|
|
treemap.padding = function(x) {
|
|
|
return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();
|
|
|
};
|
|
|
|
|
|
treemap.paddingInner = function(x) {
|
|
|
return arguments.length ? (paddingInner = typeof x === "function" ? x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+x), treemap) : paddingInner;
|
|
|
};
|
|
|
|
|
|
treemap.paddingOuter = function(x) {
|
|
|
return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();
|
|
|
};
|
|
|
|
|
|
treemap.paddingTop = function(x) {
|
|
|
return arguments.length ? (paddingTop = typeof x === "function" ? x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+x), treemap) : paddingTop;
|
|
|
};
|
|
|
|
|
|
treemap.paddingRight = function(x) {
|
|
|
return arguments.length ? (paddingRight = typeof x === "function" ? x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+x), treemap) : paddingRight;
|
|
|
};
|
|
|
|
|
|
treemap.paddingBottom = function(x) {
|
|
|
return arguments.length ? (paddingBottom = typeof x === "function" ? x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+x), treemap) : paddingBottom;
|
|
|
};
|
|
|
|
|
|
treemap.paddingLeft = function(x) {
|
|
|
return arguments.length ? (paddingLeft = typeof x === "function" ? x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+x), treemap) : paddingLeft;
|
|
|
};
|
|
|
|
|
|
return treemap;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 41916:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(node) {
|
|
|
node.x0 = Math.round(node.x0);
|
|
|
node.y0 = Math.round(node.y0);
|
|
|
node.x1 = Math.round(node.x1);
|
|
|
node.y1 = Math.round(node.y1);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 4915:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(parent, x0, y0, x1, y1) {
|
|
|
var nodes = parent.children,
|
|
|
node,
|
|
|
i = -1,
|
|
|
n = nodes.length,
|
|
|
k = parent.value && (y1 - y0) / parent.value;
|
|
|
|
|
|
while (++i < n) {
|
|
|
node = nodes[i], node.x0 = x0, node.x1 = x1;
|
|
|
node.y0 = y0, node.y1 = y0 += node.value * k;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 20737:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ DD: () => (/* binding */ squarifyRatio),
|
|
|
/* harmony export */ Sk: () => (/* binding */ phi),
|
|
|
/* harmony export */ ZP: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _dice_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98039);
|
|
|
/* harmony import */ var _slice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4915);
|
|
|
|
|
|
|
|
|
|
|
|
var phi = (1 + Math.sqrt(5)) / 2;
|
|
|
|
|
|
function squarifyRatio(ratio, parent, x0, y0, x1, y1) {
|
|
|
var rows = [],
|
|
|
nodes = parent.children,
|
|
|
row,
|
|
|
nodeValue,
|
|
|
i0 = 0,
|
|
|
i1 = 0,
|
|
|
n = nodes.length,
|
|
|
dx, dy,
|
|
|
value = parent.value,
|
|
|
sumValue,
|
|
|
minValue,
|
|
|
maxValue,
|
|
|
newRatio,
|
|
|
minRatio,
|
|
|
alpha,
|
|
|
beta;
|
|
|
|
|
|
while (i0 < n) {
|
|
|
dx = x1 - x0, dy = y1 - y0;
|
|
|
|
|
|
// Find the next non-empty node.
|
|
|
do sumValue = nodes[i1++].value; while (!sumValue && i1 < n);
|
|
|
minValue = maxValue = sumValue;
|
|
|
alpha = Math.max(dy / dx, dx / dy) / (value * ratio);
|
|
|
beta = sumValue * sumValue * alpha;
|
|
|
minRatio = Math.max(maxValue / beta, beta / minValue);
|
|
|
|
|
|
// Keep adding nodes while the aspect ratio maintains or improves.
|
|
|
for (; i1 < n; ++i1) {
|
|
|
sumValue += nodeValue = nodes[i1].value;
|
|
|
if (nodeValue < minValue) minValue = nodeValue;
|
|
|
if (nodeValue > maxValue) maxValue = nodeValue;
|
|
|
beta = sumValue * sumValue * alpha;
|
|
|
newRatio = Math.max(maxValue / beta, beta / minValue);
|
|
|
if (newRatio > minRatio) { sumValue -= nodeValue; break; }
|
|
|
minRatio = newRatio;
|
|
|
}
|
|
|
|
|
|
// Position and record the row orientation.
|
|
|
rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)});
|
|
|
if (row.dice) (0,_dice_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);
|
|
|
else (0,_slice_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);
|
|
|
value -= sumValue, i0 = i1;
|
|
|
}
|
|
|
|
|
|
return rows;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(ratio) {
|
|
|
|
|
|
function squarify(parent, x0, y0, x1, y1) {
|
|
|
squarifyRatio(ratio, parent, x0, y0, x1, y1);
|
|
|
}
|
|
|
|
|
|
squarify.ratio = function(x) {
|
|
|
return custom((x = +x) > 1 ? x : 1);
|
|
|
};
|
|
|
|
|
|
return squarify;
|
|
|
})(phi));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 5368:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ M: () => (/* binding */ genericArray),
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _value_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(54289);
|
|
|
/* harmony import */ var _numberArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11083);
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
return ((0,_numberArray_js__WEBPACK_IMPORTED_MODULE_0__/* .isNumberArray */ .v)(b) ? _numberArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z : genericArray)(a, b);
|
|
|
}
|
|
|
|
|
|
function genericArray(a, b) {
|
|
|
var nb = b ? b.length : 0,
|
|
|
na = a ? Math.min(nb, a.length) : 0,
|
|
|
x = new Array(na),
|
|
|
c = new Array(nb),
|
|
|
i;
|
|
|
|
|
|
for (i = 0; i < na; ++i) x[i] = (0,_value_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(a[i], b[i]);
|
|
|
for (; i < nb; ++i) c[i] = b[i];
|
|
|
|
|
|
return function(t) {
|
|
|
for (i = 0; i < na; ++i) c[i] = x[i](t);
|
|
|
return c;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 31639:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ t: () => (/* binding */ basis)
|
|
|
/* harmony export */ });
|
|
|
function basis(t1, v0, v1, v2, v3) {
|
|
|
var t2 = t1 * t1, t3 = t2 * t1;
|
|
|
return ((1 - 3 * t1 + 3 * t2 - t3) * v0
|
|
|
+ (4 - 6 * t2 + 3 * t3) * v1
|
|
|
+ (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
|
|
|
+ t3 * v3) / 6;
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(values) {
|
|
|
var n = values.length - 1;
|
|
|
return function(t) {
|
|
|
var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
|
|
|
v1 = values[i],
|
|
|
v2 = values[i + 1],
|
|
|
v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
|
|
|
v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
|
|
|
return basis((t - i / n) * n, v0, v1, v2, v3);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 16772:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _basis_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31639);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(values) {
|
|
|
var n = values.length;
|
|
|
return function(t) {
|
|
|
var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
|
|
|
v0 = values[(i + n - 1) % n],
|
|
|
v1 = values[i % n],
|
|
|
v2 = values[(i + 1) % n],
|
|
|
v3 = values[(i + 2) % n];
|
|
|
return (0,_basis_js__WEBPACK_IMPORTED_MODULE_0__/* .basis */ .t)((t - i / n) * n, v0, v1, v2, v3);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 43133:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ ZP: () => (/* binding */ nogamma),
|
|
|
/* harmony export */ wx: () => (/* binding */ hue),
|
|
|
/* harmony export */ yi: () => (/* binding */ gamma)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(93064);
|
|
|
|
|
|
|
|
|
function linear(a, d) {
|
|
|
return function(t) {
|
|
|
return a + t * d;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function exponential(a, b, y) {
|
|
|
return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
|
|
|
return Math.pow(a + t * b, y);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function hue(a, b) {
|
|
|
var d = b - a;
|
|
|
return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(isNaN(a) ? b : a);
|
|
|
}
|
|
|
|
|
|
function gamma(y) {
|
|
|
return (y = +y) === 1 ? nogamma : function(a, b) {
|
|
|
return b - a ? exponential(a, b, y) : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(isNaN(a) ? b : a);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function nogamma(a, b) {
|
|
|
var d = b - a;
|
|
|
return d ? linear(a, d) : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(isNaN(a) ? b : a);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 93064:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (x => () => x);
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 54446:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
var d = new Date;
|
|
|
return a = +a, b = +b, function(t) {
|
|
|
return d.setTime(a * (1 - t) + b * t), d;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 69004:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
// ESM COMPAT FLAG
|
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
interpolate: () => (/* reexport */ value/* default */.Z),
|
|
|
interpolateArray: () => (/* reexport */ array/* default */.Z),
|
|
|
interpolateBasis: () => (/* reexport */ basis/* default */.Z),
|
|
|
interpolateBasisClosed: () => (/* reexport */ basisClosed/* default */.Z),
|
|
|
interpolateCubehelix: () => (/* reexport */ src_cubehelix),
|
|
|
interpolateCubehelixLong: () => (/* reexport */ cubehelixLong),
|
|
|
interpolateDate: () => (/* reexport */ date/* default */.Z),
|
|
|
interpolateDiscrete: () => (/* reexport */ discrete),
|
|
|
interpolateHcl: () => (/* reexport */ src_hcl),
|
|
|
interpolateHclLong: () => (/* reexport */ hclLong),
|
|
|
interpolateHsl: () => (/* reexport */ src_hsl),
|
|
|
interpolateHslLong: () => (/* reexport */ hslLong),
|
|
|
interpolateHue: () => (/* reexport */ hue),
|
|
|
interpolateLab: () => (/* reexport */ lab_lab),
|
|
|
interpolateNumber: () => (/* reexport */ number/* default */.Z),
|
|
|
interpolateNumberArray: () => (/* reexport */ numberArray/* default */.Z),
|
|
|
interpolateObject: () => (/* reexport */ object/* default */.Z),
|
|
|
interpolateRgb: () => (/* reexport */ rgb/* default */.ZP),
|
|
|
interpolateRgbBasis: () => (/* reexport */ rgb/* rgbBasis */.hD),
|
|
|
interpolateRgbBasisClosed: () => (/* reexport */ rgb/* rgbBasisClosed */.YD),
|
|
|
interpolateRound: () => (/* reexport */ round/* default */.Z),
|
|
|
interpolateString: () => (/* reexport */ string/* default */.Z),
|
|
|
interpolateTransformCss: () => (/* reexport */ transform/* interpolateTransformCss */.Y),
|
|
|
interpolateTransformSvg: () => (/* reexport */ transform/* interpolateTransformSvg */.w),
|
|
|
interpolateZoom: () => (/* reexport */ zoom),
|
|
|
piecewise: () => (/* reexport */ piecewise/* default */.Z),
|
|
|
quantize: () => (/* reexport */ quantize)
|
|
|
});
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/value.js
|
|
|
var value = __webpack_require__(54289);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/array.js
|
|
|
var array = __webpack_require__(5368);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/basis.js
|
|
|
var basis = __webpack_require__(31639);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/basisClosed.js
|
|
|
var basisClosed = __webpack_require__(16772);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/date.js
|
|
|
var date = __webpack_require__(54446);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/discrete.js
|
|
|
/* harmony default export */ function discrete(range) {
|
|
|
var n = range.length;
|
|
|
return function(t) {
|
|
|
return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/color.js
|
|
|
var color = __webpack_require__(43133);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/hue.js
|
|
|
|
|
|
|
|
|
/* harmony default export */ function hue(a, b) {
|
|
|
var i = (0,color/* hue */.wx)(+a, +b);
|
|
|
return function(t) {
|
|
|
var x = i(t);
|
|
|
return x - 360 * Math.floor(x / 360);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/number.js
|
|
|
var number = __webpack_require__(75381);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/numberArray.js
|
|
|
var numberArray = __webpack_require__(11083);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/object.js
|
|
|
var object = __webpack_require__(38863);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/round.js
|
|
|
var round = __webpack_require__(58687);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/string.js
|
|
|
var string = __webpack_require__(39493);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/transform/index.js + 2 modules
|
|
|
var transform = __webpack_require__(52087);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/zoom.js
|
|
|
var epsilon2 = 1e-12;
|
|
|
|
|
|
function cosh(x) {
|
|
|
return ((x = Math.exp(x)) + 1 / x) / 2;
|
|
|
}
|
|
|
|
|
|
function sinh(x) {
|
|
|
return ((x = Math.exp(x)) - 1 / x) / 2;
|
|
|
}
|
|
|
|
|
|
function tanh(x) {
|
|
|
return ((x = Math.exp(2 * x)) - 1) / (x + 1);
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const zoom = ((function zoomRho(rho, rho2, rho4) {
|
|
|
|
|
|
// p0 = [ux0, uy0, w0]
|
|
|
// p1 = [ux1, uy1, w1]
|
|
|
function zoom(p0, p1) {
|
|
|
var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
|
|
|
ux1 = p1[0], uy1 = p1[1], w1 = p1[2],
|
|
|
dx = ux1 - ux0,
|
|
|
dy = uy1 - uy0,
|
|
|
d2 = dx * dx + dy * dy,
|
|
|
i,
|
|
|
S;
|
|
|
|
|
|
// Special case for u0 ≅ u1.
|
|
|
if (d2 < epsilon2) {
|
|
|
S = Math.log(w1 / w0) / rho;
|
|
|
i = function(t) {
|
|
|
return [
|
|
|
ux0 + t * dx,
|
|
|
uy0 + t * dy,
|
|
|
w0 * Math.exp(rho * t * S)
|
|
|
];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// General case.
|
|
|
else {
|
|
|
var d1 = Math.sqrt(d2),
|
|
|
b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),
|
|
|
b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),
|
|
|
r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
|
|
|
r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
|
|
|
S = (r1 - r0) / rho;
|
|
|
i = function(t) {
|
|
|
var s = t * S,
|
|
|
coshr0 = cosh(r0),
|
|
|
u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
|
|
|
return [
|
|
|
ux0 + u * dx,
|
|
|
uy0 + u * dy,
|
|
|
w0 * coshr0 / cosh(rho * s + r0)
|
|
|
];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
i.duration = S * 1000 * rho / Math.SQRT2;
|
|
|
|
|
|
return i;
|
|
|
}
|
|
|
|
|
|
zoom.rho = function(_) {
|
|
|
var _1 = Math.max(1e-3, +_), _2 = _1 * _1, _4 = _2 * _2;
|
|
|
return zoomRho(_1, _2, _4);
|
|
|
};
|
|
|
|
|
|
return zoom;
|
|
|
})(Math.SQRT2, 2, 4));
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/rgb.js
|
|
|
var rgb = __webpack_require__(32278);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-color/src/color.js
|
|
|
var src_color = __webpack_require__(12738);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/hsl.js
|
|
|
|
|
|
|
|
|
|
|
|
function hsl(hue) {
|
|
|
return function(start, end) {
|
|
|
var h = hue((start = (0,src_color/* hsl */.Ym)(start)).h, (end = (0,src_color/* hsl */.Ym)(end)).h),
|
|
|
s = (0,color/* default */.ZP)(start.s, end.s),
|
|
|
l = (0,color/* default */.ZP)(start.l, end.l),
|
|
|
opacity = (0,color/* default */.ZP)(start.opacity, end.opacity);
|
|
|
return function(t) {
|
|
|
start.h = h(t);
|
|
|
start.s = s(t);
|
|
|
start.l = l(t);
|
|
|
start.opacity = opacity(t);
|
|
|
return start + "";
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const src_hsl = (hsl(color/* hue */.wx));
|
|
|
var hslLong = hsl(color/* default */.ZP);
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-color/src/lab.js
|
|
|
var lab = __webpack_require__(64836);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/lab.js
|
|
|
|
|
|
|
|
|
|
|
|
function lab_lab(start, end) {
|
|
|
var l = (0,color/* default */.ZP)((start = (0,lab/* default */.ZP)(start)).l, (end = (0,lab/* default */.ZP)(end)).l),
|
|
|
a = (0,color/* default */.ZP)(start.a, end.a),
|
|
|
b = (0,color/* default */.ZP)(start.b, end.b),
|
|
|
opacity = (0,color/* default */.ZP)(start.opacity, end.opacity);
|
|
|
return function(t) {
|
|
|
start.l = l(t);
|
|
|
start.a = a(t);
|
|
|
start.b = b(t);
|
|
|
start.opacity = opacity(t);
|
|
|
return start + "";
|
|
|
};
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/hcl.js
|
|
|
|
|
|
|
|
|
|
|
|
function hcl(hue) {
|
|
|
return function(start, end) {
|
|
|
var h = hue((start = (0,lab/* hcl */.Uc)(start)).h, (end = (0,lab/* hcl */.Uc)(end)).h),
|
|
|
c = (0,color/* default */.ZP)(start.c, end.c),
|
|
|
l = (0,color/* default */.ZP)(start.l, end.l),
|
|
|
opacity = (0,color/* default */.ZP)(start.opacity, end.opacity);
|
|
|
return function(t) {
|
|
|
start.h = h(t);
|
|
|
start.c = c(t);
|
|
|
start.l = l(t);
|
|
|
start.opacity = opacity(t);
|
|
|
return start + "";
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const src_hcl = (hcl(color/* hue */.wx));
|
|
|
var hclLong = hcl(color/* default */.ZP);
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-color/src/define.js
|
|
|
var src_define = __webpack_require__(77551);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-color/src/math.js
|
|
|
var math = __webpack_require__(56091);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-color/src/cubehelix.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var A = -0.14861,
|
|
|
B = +1.78277,
|
|
|
C = -0.29227,
|
|
|
D = -0.90649,
|
|
|
E = +1.97294,
|
|
|
ED = E * D,
|
|
|
EB = E * B,
|
|
|
BC_DA = B * C - D * A;
|
|
|
|
|
|
function cubehelixConvert(o) {
|
|
|
if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
|
|
|
if (!(o instanceof src_color/* Rgb */.Ss)) o = (0,src_color/* rgbConvert */.SU)(o);
|
|
|
var r = o.r / 255,
|
|
|
g = o.g / 255,
|
|
|
b = o.b / 255,
|
|
|
l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
|
|
|
bl = b - l,
|
|
|
k = (E * (g - l) - C * bl) / D,
|
|
|
s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1
|
|
|
h = s ? Math.atan2(k, bl) * math/* degrees */.R - 120 : NaN;
|
|
|
return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
|
|
|
}
|
|
|
|
|
|
function cubehelix_cubehelix(h, s, l, opacity) {
|
|
|
return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);
|
|
|
}
|
|
|
|
|
|
function Cubehelix(h, s, l, opacity) {
|
|
|
this.h = +h;
|
|
|
this.s = +s;
|
|
|
this.l = +l;
|
|
|
this.opacity = +opacity;
|
|
|
}
|
|
|
|
|
|
(0,src_define/* default */.Z)(Cubehelix, cubehelix_cubehelix, (0,src_define/* extend */.l)(src_color/* Color */.Il, {
|
|
|
brighter(k) {
|
|
|
k = k == null ? src_color/* brighter */.J5 : Math.pow(src_color/* brighter */.J5, k);
|
|
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
|
|
|
},
|
|
|
darker(k) {
|
|
|
k = k == null ? src_color/* darker */.xV : Math.pow(src_color/* darker */.xV, k);
|
|
|
return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
|
|
|
},
|
|
|
rgb() {
|
|
|
var h = isNaN(this.h) ? 0 : (this.h + 120) * math/* radians */.u,
|
|
|
l = +this.l,
|
|
|
a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
|
|
|
cosh = Math.cos(h),
|
|
|
sinh = Math.sin(h);
|
|
|
return new src_color/* Rgb */.Ss(
|
|
|
255 * (l + a * (A * cosh + B * sinh)),
|
|
|
255 * (l + a * (C * cosh + D * sinh)),
|
|
|
255 * (l + a * (E * cosh)),
|
|
|
this.opacity
|
|
|
);
|
|
|
}
|
|
|
}));
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/cubehelix.js
|
|
|
|
|
|
|
|
|
|
|
|
function cubehelix(hue) {
|
|
|
return (function cubehelixGamma(y) {
|
|
|
y = +y;
|
|
|
|
|
|
function cubehelix(start, end) {
|
|
|
var h = hue((start = cubehelix_cubehelix(start)).h, (end = cubehelix_cubehelix(end)).h),
|
|
|
s = (0,color/* default */.ZP)(start.s, end.s),
|
|
|
l = (0,color/* default */.ZP)(start.l, end.l),
|
|
|
opacity = (0,color/* default */.ZP)(start.opacity, end.opacity);
|
|
|
return function(t) {
|
|
|
start.h = h(t);
|
|
|
start.s = s(t);
|
|
|
start.l = l(Math.pow(t, y));
|
|
|
start.opacity = opacity(t);
|
|
|
return start + "";
|
|
|
};
|
|
|
}
|
|
|
|
|
|
cubehelix.gamma = cubehelixGamma;
|
|
|
|
|
|
return cubehelix;
|
|
|
})(1);
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ const src_cubehelix = (cubehelix(color/* hue */.wx));
|
|
|
var cubehelixLong = cubehelix(color/* default */.ZP);
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/piecewise.js
|
|
|
var piecewise = __webpack_require__(73682);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/quantize.js
|
|
|
/* harmony default export */ function quantize(interpolator, n) {
|
|
|
var samples = new Array(n);
|
|
|
for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));
|
|
|
return samples;
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 75381:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
return a = +a, b = +b, function(t) {
|
|
|
return a * (1 - t) + b * t;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 11083:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ v: () => (/* binding */ isNumberArray)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
if (!b) b = [];
|
|
|
var n = a ? Math.min(b.length, a.length) : 0,
|
|
|
c = b.slice(),
|
|
|
i;
|
|
|
return function(t) {
|
|
|
for (i = 0; i < n; ++i) c[i] = a[i] * (1 - t) + b[i] * t;
|
|
|
return c;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function isNumberArray(x) {
|
|
|
return ArrayBuffer.isView(x) && !(x instanceof DataView);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 38863:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _value_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(54289);
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
var i = {},
|
|
|
c = {},
|
|
|
k;
|
|
|
|
|
|
if (a === null || typeof a !== "object") a = {};
|
|
|
if (b === null || typeof b !== "object") b = {};
|
|
|
|
|
|
for (k in b) {
|
|
|
if (k in a) {
|
|
|
i[k] = (0,_value_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(a[k], b[k]);
|
|
|
} else {
|
|
|
c[k] = b[k];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return function(t) {
|
|
|
for (k in i) c[k] = i[k](t);
|
|
|
return c;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 73682:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ piecewise)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _value_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(54289);
|
|
|
|
|
|
|
|
|
function piecewise(interpolate, values) {
|
|
|
if (values === undefined) values = interpolate, interpolate = _value_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z;
|
|
|
var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n);
|
|
|
while (i < n) I[i] = interpolate(v, v = values[++i]);
|
|
|
return function(t) {
|
|
|
var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));
|
|
|
return I[i](t - i);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 32278:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ YD: () => (/* binding */ rgbBasisClosed),
|
|
|
/* harmony export */ ZP: () => (__WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ hD: () => (/* binding */ rgbBasis)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12738);
|
|
|
/* harmony import */ var _basis_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(31639);
|
|
|
/* harmony import */ var _basisClosed_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(16772);
|
|
|
/* harmony import */ var _color_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(43133);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function rgbGamma(y) {
|
|
|
var color = (0,_color_js__WEBPACK_IMPORTED_MODULE_0__/* .gamma */ .yi)(y);
|
|
|
|
|
|
function rgb(start, end) {
|
|
|
var r = color((start = (0,d3_color__WEBPACK_IMPORTED_MODULE_1__/* .rgb */ .B8)(start)).r, (end = (0,d3_color__WEBPACK_IMPORTED_MODULE_1__/* .rgb */ .B8)(end)).r),
|
|
|
g = color(start.g, end.g),
|
|
|
b = color(start.b, end.b),
|
|
|
opacity = (0,_color_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(start.opacity, end.opacity);
|
|
|
return function(t) {
|
|
|
start.r = r(t);
|
|
|
start.g = g(t);
|
|
|
start.b = b(t);
|
|
|
start.opacity = opacity(t);
|
|
|
return start + "";
|
|
|
};
|
|
|
}
|
|
|
|
|
|
rgb.gamma = rgbGamma;
|
|
|
|
|
|
return rgb;
|
|
|
})(1));
|
|
|
|
|
|
function rgbSpline(spline) {
|
|
|
return function(colors) {
|
|
|
var n = colors.length,
|
|
|
r = new Array(n),
|
|
|
g = new Array(n),
|
|
|
b = new Array(n),
|
|
|
i, color;
|
|
|
for (i = 0; i < n; ++i) {
|
|
|
color = (0,d3_color__WEBPACK_IMPORTED_MODULE_1__/* .rgb */ .B8)(colors[i]);
|
|
|
r[i] = color.r || 0;
|
|
|
g[i] = color.g || 0;
|
|
|
b[i] = color.b || 0;
|
|
|
}
|
|
|
r = spline(r);
|
|
|
g = spline(g);
|
|
|
b = spline(b);
|
|
|
color.opacity = 1;
|
|
|
return function(t) {
|
|
|
color.r = r(t);
|
|
|
color.g = g(t);
|
|
|
color.b = b(t);
|
|
|
return color + "";
|
|
|
};
|
|
|
};
|
|
|
}
|
|
|
|
|
|
var rgbBasis = rgbSpline(_basis_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z);
|
|
|
var rgbBasisClosed = rgbSpline(_basisClosed_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z);
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 58687:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
return a = +a, b = +b, function(t) {
|
|
|
return Math.round(a * (1 - t) + b * t);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 39493:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _number_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(75381);
|
|
|
|
|
|
|
|
|
var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
|
|
|
reB = new RegExp(reA.source, "g");
|
|
|
|
|
|
function zero(b) {
|
|
|
return function() {
|
|
|
return b;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function one(b) {
|
|
|
return function(t) {
|
|
|
return b(t) + "";
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
|
|
|
am, // current match in a
|
|
|
bm, // current match in b
|
|
|
bs, // string preceding current number in b, if any
|
|
|
i = -1, // index in s
|
|
|
s = [], // string constants and placeholders
|
|
|
q = []; // number interpolators
|
|
|
|
|
|
// Coerce inputs to strings.
|
|
|
a = a + "", b = b + "";
|
|
|
|
|
|
// Interpolate pairs of numbers in a & b.
|
|
|
while ((am = reA.exec(a))
|
|
|
&& (bm = reB.exec(b))) {
|
|
|
if ((bs = bm.index) > bi) { // a string precedes the next number in b
|
|
|
bs = b.slice(bi, bs);
|
|
|
if (s[i]) s[i] += bs; // coalesce with previous string
|
|
|
else s[++i] = bs;
|
|
|
}
|
|
|
if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
|
|
|
if (s[i]) s[i] += bm; // coalesce with previous string
|
|
|
else s[++i] = bm;
|
|
|
} else { // interpolate non-matching numbers
|
|
|
s[++i] = null;
|
|
|
q.push({i: i, x: (0,_number_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(am, bm)});
|
|
|
}
|
|
|
bi = reB.lastIndex;
|
|
|
}
|
|
|
|
|
|
// Add remains of b.
|
|
|
if (bi < b.length) {
|
|
|
bs = b.slice(bi);
|
|
|
if (s[i]) s[i] += bs; // coalesce with previous string
|
|
|
else s[++i] = bs;
|
|
|
}
|
|
|
|
|
|
// Special optimization for only a single match.
|
|
|
// Otherwise, interpolate each of the numbers and rejoin the string.
|
|
|
return s.length < 2 ? (q[0]
|
|
|
? one(q[0].x)
|
|
|
: zero(b))
|
|
|
: (b = q.length, function(t) {
|
|
|
for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
|
|
|
return s.join("");
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 52087:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
Y: () => (/* binding */ interpolateTransformCss),
|
|
|
w: () => (/* binding */ interpolateTransformSvg)
|
|
|
});
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/number.js
|
|
|
var number = __webpack_require__(75381);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/transform/decompose.js
|
|
|
var degrees = 180 / Math.PI;
|
|
|
|
|
|
var identity = {
|
|
|
translateX: 0,
|
|
|
translateY: 0,
|
|
|
rotate: 0,
|
|
|
skewX: 0,
|
|
|
scaleX: 1,
|
|
|
scaleY: 1
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function decompose(a, b, c, d, e, f) {
|
|
|
var scaleX, scaleY, skewX;
|
|
|
if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;
|
|
|
if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;
|
|
|
if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;
|
|
|
if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
|
|
|
return {
|
|
|
translateX: e,
|
|
|
translateY: f,
|
|
|
rotate: Math.atan2(b, a) * degrees,
|
|
|
skewX: Math.atan(skewX) * degrees,
|
|
|
scaleX: scaleX,
|
|
|
scaleY: scaleY
|
|
|
};
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/transform/parse.js
|
|
|
|
|
|
|
|
|
var svgNode;
|
|
|
|
|
|
/* eslint-disable no-undef */
|
|
|
function parseCss(value) {
|
|
|
const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
|
|
|
return m.isIdentity ? identity : decompose(m.a, m.b, m.c, m.d, m.e, m.f);
|
|
|
}
|
|
|
|
|
|
function parseSvg(value) {
|
|
|
if (value == null) return identity;
|
|
|
if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
|
|
|
svgNode.setAttribute("transform", value);
|
|
|
if (!(value = svgNode.transform.baseVal.consolidate())) return identity;
|
|
|
value = value.matrix;
|
|
|
return decompose(value.a, value.b, value.c, value.d, value.e, value.f);
|
|
|
}
|
|
|
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-interpolate/src/transform/index.js
|
|
|
|
|
|
|
|
|
|
|
|
function interpolateTransform(parse, pxComma, pxParen, degParen) {
|
|
|
|
|
|
function pop(s) {
|
|
|
return s.length ? s.pop() + " " : "";
|
|
|
}
|
|
|
|
|
|
function translate(xa, ya, xb, yb, s, q) {
|
|
|
if (xa !== xb || ya !== yb) {
|
|
|
var i = s.push("translate(", null, pxComma, null, pxParen);
|
|
|
q.push({i: i - 4, x: (0,number/* default */.Z)(xa, xb)}, {i: i - 2, x: (0,number/* default */.Z)(ya, yb)});
|
|
|
} else if (xb || yb) {
|
|
|
s.push("translate(" + xb + pxComma + yb + pxParen);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function rotate(a, b, s, q) {
|
|
|
if (a !== b) {
|
|
|
if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
|
|
|
q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: (0,number/* default */.Z)(a, b)});
|
|
|
} else if (b) {
|
|
|
s.push(pop(s) + "rotate(" + b + degParen);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function skewX(a, b, s, q) {
|
|
|
if (a !== b) {
|
|
|
q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: (0,number/* default */.Z)(a, b)});
|
|
|
} else if (b) {
|
|
|
s.push(pop(s) + "skewX(" + b + degParen);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function scale(xa, ya, xb, yb, s, q) {
|
|
|
if (xa !== xb || ya !== yb) {
|
|
|
var i = s.push(pop(s) + "scale(", null, ",", null, ")");
|
|
|
q.push({i: i - 4, x: (0,number/* default */.Z)(xa, xb)}, {i: i - 2, x: (0,number/* default */.Z)(ya, yb)});
|
|
|
} else if (xb !== 1 || yb !== 1) {
|
|
|
s.push(pop(s) + "scale(" + xb + "," + yb + ")");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return function(a, b) {
|
|
|
var s = [], // string constants and placeholders
|
|
|
q = []; // number interpolators
|
|
|
a = parse(a), b = parse(b);
|
|
|
translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
|
|
|
rotate(a.rotate, b.rotate, s, q);
|
|
|
skewX(a.skewX, b.skewX, s, q);
|
|
|
scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
|
|
|
a = b = null; // gc
|
|
|
return function(t) {
|
|
|
var i = -1, n = q.length, o;
|
|
|
while (++i < n) s[(o = q[i]).i] = o.x(t);
|
|
|
return s.join("");
|
|
|
};
|
|
|
};
|
|
|
}
|
|
|
|
|
|
var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
|
|
|
var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 54289:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12738);
|
|
|
/* harmony import */ var _rgb_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(32278);
|
|
|
/* harmony import */ var _array_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(5368);
|
|
|
/* harmony import */ var _date_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(54446);
|
|
|
/* harmony import */ var _number_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(75381);
|
|
|
/* harmony import */ var _object_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(38863);
|
|
|
/* harmony import */ var _string_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(39493);
|
|
|
/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(93064);
|
|
|
/* harmony import */ var _numberArray_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(11083);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(a, b) {
|
|
|
var t = typeof b, c;
|
|
|
return b == null || t === "boolean" ? (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(b)
|
|
|
: (t === "number" ? _number_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z
|
|
|
: t === "string" ? ((c = (0,d3_color__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .ZP)(b)) ? (b = c, _rgb_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .ZP) : _string_js__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)
|
|
|
: b instanceof d3_color__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .ZP ? _rgb_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .ZP
|
|
|
: b instanceof Date ? _date_js__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z
|
|
|
: (0,_numberArray_js__WEBPACK_IMPORTED_MODULE_6__/* .isNumberArray */ .v)(b) ? _numberArray_js__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z
|
|
|
: Array.isArray(b) ? _array_js__WEBPACK_IMPORTED_MODULE_7__/* .genericArray */ .M
|
|
|
: typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? _object_js__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z
|
|
|
: _number_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(a, b);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 3791:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ ET: () => (/* binding */ path),
|
|
|
/* harmony export */ y$: () => (/* binding */ Path)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export pathRound */
|
|
|
const pi = Math.PI,
|
|
|
tau = 2 * pi,
|
|
|
epsilon = 1e-6,
|
|
|
tauEpsilon = tau - epsilon;
|
|
|
|
|
|
function append(strings) {
|
|
|
this._ += strings[0];
|
|
|
for (let i = 1, n = strings.length; i < n; ++i) {
|
|
|
this._ += arguments[i] + strings[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function appendRound(digits) {
|
|
|
let d = Math.floor(digits);
|
|
|
if (!(d >= 0)) throw new Error(`invalid digits: ${digits}`);
|
|
|
if (d > 15) return append;
|
|
|
const k = 10 ** d;
|
|
|
return function(strings) {
|
|
|
this._ += strings[0];
|
|
|
for (let i = 1, n = strings.length; i < n; ++i) {
|
|
|
this._ += Math.round(arguments[i] * k) / k + strings[i];
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
|
|
|
class Path {
|
|
|
constructor(digits) {
|
|
|
this._x0 = this._y0 = // start of current subpath
|
|
|
this._x1 = this._y1 = null; // end of current subpath
|
|
|
this._ = "";
|
|
|
this._append = digits == null ? append : appendRound(digits);
|
|
|
}
|
|
|
moveTo(x, y) {
|
|
|
this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`;
|
|
|
}
|
|
|
closePath() {
|
|
|
if (this._x1 !== null) {
|
|
|
this._x1 = this._x0, this._y1 = this._y0;
|
|
|
this._append`Z`;
|
|
|
}
|
|
|
}
|
|
|
lineTo(x, y) {
|
|
|
this._append`L${this._x1 = +x},${this._y1 = +y}`;
|
|
|
}
|
|
|
quadraticCurveTo(x1, y1, x, y) {
|
|
|
this._append`Q${+x1},${+y1},${this._x1 = +x},${this._y1 = +y}`;
|
|
|
}
|
|
|
bezierCurveTo(x1, y1, x2, y2, x, y) {
|
|
|
this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x},${this._y1 = +y}`;
|
|
|
}
|
|
|
arcTo(x1, y1, x2, y2, r) {
|
|
|
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
|
|
|
|
|
|
// Is the radius negative? Error.
|
|
|
if (r < 0) throw new Error(`negative radius: ${r}`);
|
|
|
|
|
|
let x0 = this._x1,
|
|
|
y0 = this._y1,
|
|
|
x21 = x2 - x1,
|
|
|
y21 = y2 - y1,
|
|
|
x01 = x0 - x1,
|
|
|
y01 = y0 - y1,
|
|
|
l01_2 = x01 * x01 + y01 * y01;
|
|
|
|
|
|
// Is this path empty? Move to (x1,y1).
|
|
|
if (this._x1 === null) {
|
|
|
this._append`M${this._x1 = x1},${this._y1 = y1}`;
|
|
|
}
|
|
|
|
|
|
// Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
|
|
|
else if (!(l01_2 > epsilon));
|
|
|
|
|
|
// Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
|
|
|
// Equivalently, is (x1,y1) coincident with (x2,y2)?
|
|
|
// Or, is the radius zero? Line to (x1,y1).
|
|
|
else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) {
|
|
|
this._append`L${this._x1 = x1},${this._y1 = y1}`;
|
|
|
}
|
|
|
|
|
|
// Otherwise, draw an arc!
|
|
|
else {
|
|
|
let x20 = x2 - x0,
|
|
|
y20 = y2 - y0,
|
|
|
l21_2 = x21 * x21 + y21 * y21,
|
|
|
l20_2 = x20 * x20 + y20 * y20,
|
|
|
l21 = Math.sqrt(l21_2),
|
|
|
l01 = Math.sqrt(l01_2),
|
|
|
l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
|
|
|
t01 = l / l01,
|
|
|
t21 = l / l21;
|
|
|
|
|
|
// If the start tangent is not coincident with (x0,y0), line to.
|
|
|
if (Math.abs(t01 - 1) > epsilon) {
|
|
|
this._append`L${x1 + t01 * x01},${y1 + t01 * y01}`;
|
|
|
}
|
|
|
|
|
|
this._append`A${r},${r},0,0,${+(y01 * x20 > x01 * y20)},${this._x1 = x1 + t21 * x21},${this._y1 = y1 + t21 * y21}`;
|
|
|
}
|
|
|
}
|
|
|
arc(x, y, r, a0, a1, ccw) {
|
|
|
x = +x, y = +y, r = +r, ccw = !!ccw;
|
|
|
|
|
|
// Is the radius negative? Error.
|
|
|
if (r < 0) throw new Error(`negative radius: ${r}`);
|
|
|
|
|
|
let dx = r * Math.cos(a0),
|
|
|
dy = r * Math.sin(a0),
|
|
|
x0 = x + dx,
|
|
|
y0 = y + dy,
|
|
|
cw = 1 ^ ccw,
|
|
|
da = ccw ? a0 - a1 : a1 - a0;
|
|
|
|
|
|
// Is this path empty? Move to (x0,y0).
|
|
|
if (this._x1 === null) {
|
|
|
this._append`M${x0},${y0}`;
|
|
|
}
|
|
|
|
|
|
// Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
|
|
|
else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {
|
|
|
this._append`L${x0},${y0}`;
|
|
|
}
|
|
|
|
|
|
// Is this arc empty? We’re done.
|
|
|
if (!r) return;
|
|
|
|
|
|
// Does the angle go the wrong way? Flip the direction.
|
|
|
if (da < 0) da = da % tau + tau;
|
|
|
|
|
|
// Is this a complete circle? Draw two arcs to complete the circle.
|
|
|
if (da > tauEpsilon) {
|
|
|
this._append`A${r},${r},0,1,${cw},${x - dx},${y - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`;
|
|
|
}
|
|
|
|
|
|
// Is this arc non-empty? Draw an arc!
|
|
|
else if (da > epsilon) {
|
|
|
this._append`A${r},${r},0,${+(da >= pi)},${cw},${this._x1 = x + r * Math.cos(a1)},${this._y1 = y + r * Math.sin(a1)}`;
|
|
|
}
|
|
|
}
|
|
|
rect(x, y, w, h) {
|
|
|
this._append`M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${w = +w}v${+h}h${-w}Z`;
|
|
|
}
|
|
|
toString() {
|
|
|
return this._;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function path() {
|
|
|
return new Path;
|
|
|
}
|
|
|
|
|
|
// Allow instanceof d3.path
|
|
|
path.prototype = Path.prototype;
|
|
|
|
|
|
function pathRound(digits = 3) {
|
|
|
return new Path(+digits);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 37505:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(specifier) {
|
|
|
var n = specifier.length / 6 | 0, colors = new Array(n), i = 0;
|
|
|
while (i < n) colors[i] = "#" + specifier.slice(i * 6, ++i * 6);
|
|
|
return colors;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 20356:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
|
|
|
// EXPORTS
|
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
|
JG: () => (/* binding */ copy),
|
|
|
ZP: () => (/* binding */ continuous),
|
|
|
yR: () => (/* binding */ identity),
|
|
|
l4: () => (/* binding */ transformer)
|
|
|
});
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-array/src/bisect.js
|
|
|
var bisect = __webpack_require__(10321);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/value.js
|
|
|
var value = __webpack_require__(54289);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/number.js
|
|
|
var number = __webpack_require__(75381);
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-interpolate/src/round.js
|
|
|
var round = __webpack_require__(58687);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-scale/src/constant.js
|
|
|
function constants(x) {
|
|
|
return function() {
|
|
|
return x;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
// EXTERNAL MODULE: ../node_modules/d3-scale/src/number.js
|
|
|
var src_number = __webpack_require__(26481);
|
|
|
;// CONCATENATED MODULE: ../node_modules/d3-scale/src/continuous.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var unit = [0, 1];
|
|
|
|
|
|
function identity(x) {
|
|
|
return x;
|
|
|
}
|
|
|
|
|
|
function normalize(a, b) {
|
|
|
return (b -= (a = +a))
|
|
|
? function(x) { return (x - a) / b; }
|
|
|
: constants(isNaN(b) ? NaN : 0.5);
|
|
|
}
|
|
|
|
|
|
function clamper(a, b) {
|
|
|
var t;
|
|
|
if (a > b) t = a, a = b, b = t;
|
|
|
return function(x) { return Math.max(a, Math.min(b, x)); };
|
|
|
}
|
|
|
|
|
|
// normalize(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].
|
|
|
// interpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding range value x in [a,b].
|
|
|
function bimap(domain, range, interpolate) {
|
|
|
var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
|
|
|
if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
|
|
|
else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
|
|
|
return function(x) { return r0(d0(x)); };
|
|
|
}
|
|
|
|
|
|
function polymap(domain, range, interpolate) {
|
|
|
var j = Math.min(domain.length, range.length) - 1,
|
|
|
d = new Array(j),
|
|
|
r = new Array(j),
|
|
|
i = -1;
|
|
|
|
|
|
// Reverse descending domains.
|
|
|
if (domain[j] < domain[0]) {
|
|
|
domain = domain.slice().reverse();
|
|
|
range = range.slice().reverse();
|
|
|
}
|
|
|
|
|
|
while (++i < j) {
|
|
|
d[i] = normalize(domain[i], domain[i + 1]);
|
|
|
r[i] = interpolate(range[i], range[i + 1]);
|
|
|
}
|
|
|
|
|
|
return function(x) {
|
|
|
var i = (0,bisect/* default */.ZP)(domain, x, 1, j) - 1;
|
|
|
return r[i](d[i](x));
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function copy(source, target) {
|
|
|
return target
|
|
|
.domain(source.domain())
|
|
|
.range(source.range())
|
|
|
.interpolate(source.interpolate())
|
|
|
.clamp(source.clamp())
|
|
|
.unknown(source.unknown());
|
|
|
}
|
|
|
|
|
|
function transformer() {
|
|
|
var domain = unit,
|
|
|
range = unit,
|
|
|
interpolate = value/* default */.Z,
|
|
|
transform,
|
|
|
untransform,
|
|
|
unknown,
|
|
|
clamp = identity,
|
|
|
piecewise,
|
|
|
output,
|
|
|
input;
|
|
|
|
|
|
function rescale() {
|
|
|
var n = Math.min(domain.length, range.length);
|
|
|
if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
|
|
|
piecewise = n > 2 ? polymap : bimap;
|
|
|
output = input = null;
|
|
|
return scale;
|
|
|
}
|
|
|
|
|
|
function scale(x) {
|
|
|
return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x)));
|
|
|
}
|
|
|
|
|
|
scale.invert = function(y) {
|
|
|
return clamp(untransform((input || (input = piecewise(range, domain.map(transform), number/* default */.Z)))(y)));
|
|
|
};
|
|
|
|
|
|
scale.domain = function(_) {
|
|
|
return arguments.length ? (domain = Array.from(_, src_number/* default */.Z), rescale()) : domain.slice();
|
|
|
};
|
|
|
|
|
|
scale.range = function(_) {
|
|
|
return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
|
|
|
};
|
|
|
|
|
|
scale.rangeRound = function(_) {
|
|
|
return range = Array.from(_), interpolate = round/* default */.Z, rescale();
|
|
|
};
|
|
|
|
|
|
scale.clamp = function(_) {
|
|
|
return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
|
|
|
};
|
|
|
|
|
|
scale.interpolate = function(_) {
|
|
|
return arguments.length ? (interpolate = _, rescale()) : interpolate;
|
|
|
};
|
|
|
|
|
|
scale.unknown = function(_) {
|
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
|
};
|
|
|
|
|
|
return function(t, u) {
|
|
|
transform = t, untransform = u;
|
|
|
return rescale();
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function continuous() {
|
|
|
return transformer()(identity, identity);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 42287:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ O: () => (/* binding */ initInterpolator),
|
|
|
/* harmony export */ o: () => (/* binding */ initRange)
|
|
|
/* harmony export */ });
|
|
|
function initRange(domain, range) {
|
|
|
switch (arguments.length) {
|
|
|
case 0: break;
|
|
|
case 1: this.range(domain); break;
|
|
|
default: this.range(range).domain(domain); break;
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
function initInterpolator(domain, interpolator) {
|
|
|
switch (arguments.length) {
|
|
|
case 0: break;
|
|
|
case 1: {
|
|
|
if (typeof domain === "function") this.interpolator(domain);
|
|
|
else this.range(domain);
|
|
|
break;
|
|
|
}
|
|
|
default: {
|
|
|
this.domain(domain);
|
|
|
if (typeof interpolator === "function") this.interpolator(interpolator);
|
|
|
else this.range(interpolator);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 29387:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Q: () => (/* binding */ linearish),
|
|
|
/* harmony export */ Z: () => (/* binding */ linear)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73002);
|
|
|
/* harmony import */ var _continuous_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(20356);
|
|
|
/* harmony import */ var _init_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42287);
|
|
|
/* harmony import */ var _tickFormat_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(35828);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function linearish(scale) {
|
|
|
var domain = scale.domain;
|
|
|
|
|
|
scale.ticks = function(count) {
|
|
|
var d = domain();
|
|
|
return (0,d3_array__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(d[0], d[d.length - 1], count == null ? 10 : count);
|
|
|
};
|
|
|
|
|
|
scale.tickFormat = function(count, specifier) {
|
|
|
var d = domain();
|
|
|
return (0,_tickFormat_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
|
|
|
};
|
|
|
|
|
|
scale.nice = function(count) {
|
|
|
if (count == null) count = 10;
|
|
|
|
|
|
var d = domain();
|
|
|
var i0 = 0;
|
|
|
var i1 = d.length - 1;
|
|
|
var start = d[i0];
|
|
|
var stop = d[i1];
|
|
|
var prestep;
|
|
|
var step;
|
|
|
var maxIter = 10;
|
|
|
|
|
|
if (stop < start) {
|
|
|
step = start, start = stop, stop = step;
|
|
|
step = i0, i0 = i1, i1 = step;
|
|
|
}
|
|
|
|
|
|
while (maxIter-- > 0) {
|
|
|
step = (0,d3_array__WEBPACK_IMPORTED_MODULE_0__/* .tickIncrement */ .G9)(start, stop, count);
|
|
|
if (step === prestep) {
|
|
|
d[i0] = start
|
|
|
d[i1] = stop
|
|
|
return domain(d);
|
|
|
} else if (step > 0) {
|
|
|
start = Math.floor(start / step) * step;
|
|
|
stop = Math.ceil(stop / step) * step;
|
|
|
} else if (step < 0) {
|
|
|
start = Math.ceil(start * step) / step;
|
|
|
stop = Math.floor(stop * step) / step;
|
|
|
} else {
|
|
|
break;
|
|
|
}
|
|
|
prestep = step;
|
|
|
}
|
|
|
|
|
|
return scale;
|
|
|
};
|
|
|
|
|
|
return scale;
|
|
|
}
|
|
|
|
|
|
function linear() {
|
|
|
var scale = (0,_continuous_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .ZP)();
|
|
|
|
|
|
scale.copy = function() {
|
|
|
return (0,_continuous_js__WEBPACK_IMPORTED_MODULE_2__/* .copy */ .JG)(scale, linear());
|
|
|
};
|
|
|
|
|
|
_init_js__WEBPACK_IMPORTED_MODULE_3__/* .initRange */ .o.apply(scale, arguments);
|
|
|
|
|
|
return linearish(scale);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 78319:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ nice)
|
|
|
/* harmony export */ });
|
|
|
function nice(domain, interval) {
|
|
|
domain = domain.slice();
|
|
|
|
|
|
var i0 = 0,
|
|
|
i1 = domain.length - 1,
|
|
|
x0 = domain[i0],
|
|
|
x1 = domain[i1],
|
|
|
t;
|
|
|
|
|
|
if (x1 < x0) {
|
|
|
t = i0, i0 = i1, i1 = t;
|
|
|
t = x0, x0 = x1, x1 = t;
|
|
|
}
|
|
|
|
|
|
domain[i0] = interval.floor(x0);
|
|
|
domain[i1] = interval.ceil(x1);
|
|
|
return domain;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 26481:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ number)
|
|
|
/* harmony export */ });
|
|
|
function number(x) {
|
|
|
return +x;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 81406:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ O: () => (/* binding */ implicit),
|
|
|
/* harmony export */ Z: () => (/* binding */ ordinal)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18694);
|
|
|
/* harmony import */ var _init_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(42287);
|
|
|
|
|
|
|
|
|
|
|
|
const implicit = Symbol("implicit");
|
|
|
|
|
|
function ordinal() {
|
|
|
var index = new d3_array__WEBPACK_IMPORTED_MODULE_0__/* .InternMap */ .L(),
|
|
|
domain = [],
|
|
|
range = [],
|
|
|
unknown = implicit;
|
|
|
|
|
|
function scale(d) {
|
|
|
let i = index.get(d);
|
|
|
if (i === undefined) {
|
|
|
if (unknown !== implicit) return unknown;
|
|
|
index.set(d, i = domain.push(d) - 1);
|
|
|
}
|
|
|
return range[i % range.length];
|
|
|
}
|
|
|
|
|
|
scale.domain = function(_) {
|
|
|
if (!arguments.length) return domain.slice();
|
|
|
domain = [], index = new d3_array__WEBPACK_IMPORTED_MODULE_0__/* .InternMap */ .L();
|
|
|
for (const value of _) {
|
|
|
if (index.has(value)) continue;
|
|
|
index.set(value, domain.push(value) - 1);
|
|
|
}
|
|
|
return scale;
|
|
|
};
|
|
|
|
|
|
scale.range = function(_) {
|
|
|
return arguments.length ? (range = Array.from(_), scale) : range.slice();
|
|
|
};
|
|
|
|
|
|
scale.unknown = function(_) {
|
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
|
};
|
|
|
|
|
|
scale.copy = function() {
|
|
|
return ordinal(domain, range).unknown(unknown);
|
|
|
};
|
|
|
|
|
|
_init_js__WEBPACK_IMPORTED_MODULE_1__/* .initRange */ .o.apply(scale, arguments);
|
|
|
|
|
|
return scale;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 35828:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ tickFormat)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73002);
|
|
|
/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(32159);
|
|
|
/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(61816);
|
|
|
/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(90741);
|
|
|
/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84767);
|
|
|
/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(39155);
|
|
|
|
|
|
|
|
|
|
|
|
function tickFormat(start, stop, count, specifier) {
|
|
|
var step = (0,d3_array__WEBPACK_IMPORTED_MODULE_0__/* .tickStep */ .ly)(start, stop, count),
|
|
|
precision;
|
|
|
specifier = (0,d3_format__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(specifier == null ? ",f" : specifier);
|
|
|
switch (specifier.type) {
|
|
|
case "s": {
|
|
|
var value = Math.max(Math.abs(start), Math.abs(stop));
|
|
|
if (specifier.precision == null && !isNaN(precision = (0,d3_format__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(step, value))) specifier.precision = precision;
|
|
|
return (0,d3_format__WEBPACK_IMPORTED_MODULE_3__/* .formatPrefix */ .jH)(specifier, value);
|
|
|
}
|
|
|
case "":
|
|
|
case "e":
|
|
|
case "g":
|
|
|
case "p":
|
|
|
case "r": {
|
|
|
if (specifier.precision == null && !isNaN(precision = (0,d3_format__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
|
|
|
break;
|
|
|
}
|
|
|
case "f":
|
|
|
case "%": {
|
|
|
if (specifier.precision == null && !isNaN(precision = (0,d3_format__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z)(step))) specifier.precision = precision - (specifier.type === "%") * 2;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return (0,d3_format__WEBPACK_IMPORTED_MODULE_3__/* .format */ .WU)(specifier);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 61941:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Y: () => (/* binding */ calendar),
|
|
|
/* harmony export */ Z: () => (/* binding */ time)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(18744);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(47878);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(43155);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(24645);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6054);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(75458);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(5957);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(58887);
|
|
|
/* harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(94031);
|
|
|
/* harmony import */ var _continuous_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20356);
|
|
|
/* harmony import */ var _init_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(42287);
|
|
|
/* harmony import */ var _nice_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(78319);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function date(t) {
|
|
|
return new Date(t);
|
|
|
}
|
|
|
|
|
|
function number(t) {
|
|
|
return t instanceof Date ? +t : +new Date(+t);
|
|
|
}
|
|
|
|
|
|
function calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format) {
|
|
|
var scale = (0,_continuous_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .ZP)(),
|
|
|
invert = scale.invert,
|
|
|
domain = scale.domain;
|
|
|
|
|
|
var formatMillisecond = format(".%L"),
|
|
|
formatSecond = format(":%S"),
|
|
|
formatMinute = format("%I:%M"),
|
|
|
formatHour = format("%I %p"),
|
|
|
formatDay = format("%a %d"),
|
|
|
formatWeek = format("%b %d"),
|
|
|
formatMonth = format("%B"),
|
|
|
formatYear = format("%Y");
|
|
|
|
|
|
function tickFormat(date) {
|
|
|
return (second(date) < date ? formatMillisecond
|
|
|
: minute(date) < date ? formatSecond
|
|
|
: hour(date) < date ? formatMinute
|
|
|
: day(date) < date ? formatHour
|
|
|
: month(date) < date ? (week(date) < date ? formatDay : formatWeek)
|
|
|
: year(date) < date ? formatMonth
|
|
|
: formatYear)(date);
|
|
|
}
|
|
|
|
|
|
scale.invert = function(y) {
|
|
|
return new Date(invert(y));
|
|
|
};
|
|
|
|
|
|
scale.domain = function(_) {
|
|
|
return arguments.length ? domain(Array.from(_, number)) : domain().map(date);
|
|
|
};
|
|
|
|
|
|
scale.ticks = function(interval) {
|
|
|
var d = domain();
|
|
|
return ticks(d[0], d[d.length - 1], interval == null ? 10 : interval);
|
|
|
};
|
|
|
|
|
|
scale.tickFormat = function(count, specifier) {
|
|
|
return specifier == null ? tickFormat : format(specifier);
|
|
|
};
|
|
|
|
|
|
scale.nice = function(interval) {
|
|
|
var d = domain();
|
|
|
if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval);
|
|
|
return interval ? domain((0,_nice_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(d, interval)) : scale;
|
|
|
};
|
|
|
|
|
|
scale.copy = function() {
|
|
|
return (0,_continuous_js__WEBPACK_IMPORTED_MODULE_0__/* .copy */ .JG)(scale, calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format));
|
|
|
};
|
|
|
|
|
|
return scale;
|
|
|
}
|
|
|
|
|
|
function time() {
|
|
|
return _init_js__WEBPACK_IMPORTED_MODULE_2__/* .initRange */ .o.apply(calendar(d3_time__WEBPACK_IMPORTED_MODULE_3__/* .timeTicks */ .jK, d3_time__WEBPACK_IMPORTED_MODULE_3__/* .timeTickInterval */ ._g, d3_time__WEBPACK_IMPORTED_MODULE_4__/* .timeYear */ .jB, d3_time__WEBPACK_IMPORTED_MODULE_5__/* .timeMonth */ .F0, d3_time__WEBPACK_IMPORTED_MODULE_6__/* .timeSunday */ .Zy, d3_time__WEBPACK_IMPORTED_MODULE_7__/* .timeDay */ .rr, d3_time__WEBPACK_IMPORTED_MODULE_8__/* .timeHour */ .WQ, d3_time__WEBPACK_IMPORTED_MODULE_9__/* .timeMinute */ .Z_, d3_time__WEBPACK_IMPORTED_MODULE_10__/* .second */ .E, d3_time_format__WEBPACK_IMPORTED_MODULE_11__/* .timeFormat */ .i$).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]), arguments);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 87826:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(17728);
|
|
|
/* harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90596);
|
|
|
/* harmony import */ var _path_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(53863);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function arcInnerRadius(d) {
|
|
|
return d.innerRadius;
|
|
|
}
|
|
|
|
|
|
function arcOuterRadius(d) {
|
|
|
return d.outerRadius;
|
|
|
}
|
|
|
|
|
|
function arcStartAngle(d) {
|
|
|
return d.startAngle;
|
|
|
}
|
|
|
|
|
|
function arcEndAngle(d) {
|
|
|
return d.endAngle;
|
|
|
}
|
|
|
|
|
|
function arcPadAngle(d) {
|
|
|
return d && d.padAngle; // Note: optional!
|
|
|
}
|
|
|
|
|
|
function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
|
|
|
var x10 = x1 - x0, y10 = y1 - y0,
|
|
|
x32 = x3 - x2, y32 = y3 - y2,
|
|
|
t = y32 * x10 - x32 * y10;
|
|
|
if (t * t < _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) return;
|
|
|
t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
|
|
|
return [x0 + t * x10, y0 + t * y10];
|
|
|
}
|
|
|
|
|
|
// Compute perpendicular offset line of length rc.
|
|
|
// http://mathworld.wolfram.com/Circle-LineIntersection.html
|
|
|
function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
|
|
|
var x01 = x0 - x1,
|
|
|
y01 = y0 - y1,
|
|
|
lo = (cw ? rc : -rc) / (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)(x01 * x01 + y01 * y01),
|
|
|
ox = lo * y01,
|
|
|
oy = -lo * x01,
|
|
|
x11 = x0 + ox,
|
|
|
y11 = y0 + oy,
|
|
|
x10 = x1 + ox,
|
|
|
y10 = y1 + oy,
|
|
|
x00 = (x11 + x10) / 2,
|
|
|
y00 = (y11 + y10) / 2,
|
|
|
dx = x10 - x11,
|
|
|
dy = y10 - y11,
|
|
|
d2 = dx * dx + dy * dy,
|
|
|
r = r1 - rc,
|
|
|
D = x11 * y10 - x10 * y11,
|
|
|
d = (dy < 0 ? -1 : 1) * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)((0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .max */ .Fp)(0, r * r * d2 - D * D)),
|
|
|
cx0 = (D * dy - dx * d) / d2,
|
|
|
cy0 = (-D * dx - dy * d) / d2,
|
|
|
cx1 = (D * dy + dx * d) / d2,
|
|
|
cy1 = (-D * dx + dy * d) / d2,
|
|
|
dx0 = cx0 - x00,
|
|
|
dy0 = cy0 - y00,
|
|
|
dx1 = cx1 - x00,
|
|
|
dy1 = cy1 - y00;
|
|
|
|
|
|
// Pick the closer of the two intersection points.
|
|
|
// TODO Is there a faster way to determine which intersection to use?
|
|
|
if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
|
|
|
|
|
|
return {
|
|
|
cx: cx0,
|
|
|
cy: cy0,
|
|
|
x01: -ox,
|
|
|
y01: -oy,
|
|
|
x11: cx0 * (r1 / r - 1),
|
|
|
y11: cy0 * (r1 / r - 1)
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__() {
|
|
|
var innerRadius = arcInnerRadius,
|
|
|
outerRadius = arcOuterRadius,
|
|
|
cornerRadius = (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(0),
|
|
|
padRadius = null,
|
|
|
startAngle = arcStartAngle,
|
|
|
endAngle = arcEndAngle,
|
|
|
padAngle = arcPadAngle,
|
|
|
context = null,
|
|
|
path = (0,_path_js__WEBPACK_IMPORTED_MODULE_2__/* .withPath */ .d)(arc);
|
|
|
|
|
|
function arc() {
|
|
|
var buffer,
|
|
|
r,
|
|
|
r0 = +innerRadius.apply(this, arguments),
|
|
|
r1 = +outerRadius.apply(this, arguments),
|
|
|
a0 = startAngle.apply(this, arguments) - _math_js__WEBPACK_IMPORTED_MODULE_0__/* .halfPi */ .ou,
|
|
|
a1 = endAngle.apply(this, arguments) - _math_js__WEBPACK_IMPORTED_MODULE_0__/* .halfPi */ .ou,
|
|
|
da = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .abs */ .Wn)(a1 - a0),
|
|
|
cw = a1 > a0;
|
|
|
|
|
|
if (!context) context = buffer = path();
|
|
|
|
|
|
// Ensure that the outer radius is always larger than the inner radius.
|
|
|
if (r1 < r0) r = r1, r1 = r0, r0 = r;
|
|
|
|
|
|
// Is it a point?
|
|
|
if (!(r1 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho)) context.moveTo(0, 0);
|
|
|
|
|
|
// Or is it a circle or annulus?
|
|
|
else if (da > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .tau */ .BZ - _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
context.moveTo(r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a0), r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a0));
|
|
|
context.arc(0, 0, r1, a0, a1, !cw);
|
|
|
if (r0 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
context.moveTo(r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a1), r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a1));
|
|
|
context.arc(0, 0, r0, a1, a0, cw);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Or is it a circular or annular sector?
|
|
|
else {
|
|
|
var a01 = a0,
|
|
|
a11 = a1,
|
|
|
a00 = a0,
|
|
|
a10 = a1,
|
|
|
da0 = da,
|
|
|
da1 = da,
|
|
|
ap = padAngle.apply(this, arguments) / 2,
|
|
|
rp = (ap > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) && (padRadius ? +padRadius.apply(this, arguments) : (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)(r0 * r0 + r1 * r1)),
|
|
|
rc = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .min */ .VV)((0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .abs */ .Wn)(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),
|
|
|
rc0 = rc,
|
|
|
rc1 = rc,
|
|
|
t0,
|
|
|
t1;
|
|
|
|
|
|
// Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.
|
|
|
if (rp > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
var p0 = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .asin */ .ZR)(rp / r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(ap)),
|
|
|
p1 = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .asin */ .ZR)(rp / r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(ap));
|
|
|
if ((da0 -= p0 * 2) > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;
|
|
|
else da0 = 0, a00 = a10 = (a0 + a1) / 2;
|
|
|
if ((da1 -= p1 * 2) > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;
|
|
|
else da1 = 0, a01 = a11 = (a0 + a1) / 2;
|
|
|
}
|
|
|
|
|
|
var x01 = r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a01),
|
|
|
y01 = r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a01),
|
|
|
x10 = r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a10),
|
|
|
y10 = r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a10);
|
|
|
|
|
|
// Apply rounded corners?
|
|
|
if (rc > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
var x11 = r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a11),
|
|
|
y11 = r1 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a11),
|
|
|
x00 = r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a00),
|
|
|
y00 = r0 * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a00),
|
|
|
oc;
|
|
|
|
|
|
// Restrict the corner radius according to the sector angle. If this
|
|
|
// intersection fails, it’s probably because the arc is too small, so
|
|
|
// disable the corner radius entirely.
|
|
|
if (da < _math_js__WEBPACK_IMPORTED_MODULE_0__.pi) {
|
|
|
if (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],
|
|
|
kc = 1 / (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)((0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .acos */ .Kh)((ax * bx + ay * by) / ((0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)(ax * ax + ay * ay) * (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)(bx * bx + by * by))) / 2),
|
|
|
lc = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sqrt */ ._b)(oc[0] * oc[0] + oc[1] * oc[1]);
|
|
|
rc0 = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .min */ .VV)(rc, (r0 - lc) / (kc - 1));
|
|
|
rc1 = (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .min */ .VV)(rc, (r1 - lc) / (kc + 1));
|
|
|
} else {
|
|
|
rc0 = rc1 = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Is the sector collapsed to a line?
|
|
|
if (!(da1 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho)) context.moveTo(x01, y01);
|
|
|
|
|
|
// Does the sector’s outer ring have rounded corners?
|
|
|
else if (rc1 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
|
|
|
t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
|
|
|
|
|
|
context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);
|
|
|
|
|
|
// Have the corners merged?
|
|
|
if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y01, t0.x01), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y01, t1.x01), !cw);
|
|
|
|
|
|
// Otherwise, draw the two corners and the ring.
|
|
|
else {
|
|
|
context.arc(t0.cx, t0.cy, rc1, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y01, t0.x01), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y11, t0.x11), !cw);
|
|
|
context.arc(0, 0, r1, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.cy + t0.y11, t0.cx + t0.x11), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.cy + t1.y11, t1.cx + t1.x11), !cw);
|
|
|
context.arc(t1.cx, t1.cy, rc1, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y11, t1.x11), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y01, t1.x01), !cw);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Or is the outer ring just a circular arc?
|
|
|
else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
|
|
|
|
|
|
// Is there no inner ring, and it’s a circular sector?
|
|
|
// Or perhaps it’s an annular sector collapsed due to padding?
|
|
|
if (!(r0 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) || !(da0 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho)) context.lineTo(x10, y10);
|
|
|
|
|
|
// Does the sector’s inner ring (or point) have rounded corners?
|
|
|
else if (rc0 > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
|
|
|
t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
|
|
|
|
|
|
context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);
|
|
|
|
|
|
// Have the corners merged?
|
|
|
if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y01, t0.x01), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y01, t1.x01), !cw);
|
|
|
|
|
|
// Otherwise, draw the two corners and the ring.
|
|
|
else {
|
|
|
context.arc(t0.cx, t0.cy, rc0, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y01, t0.x01), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.y11, t0.x11), !cw);
|
|
|
context.arc(0, 0, r0, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t0.cy + t0.y11, t0.cx + t0.x11), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.cy + t1.y11, t1.cx + t1.x11), cw);
|
|
|
context.arc(t1.cx, t1.cy, rc0, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y11, t1.x11), (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .atan2 */ .fv)(t1.y01, t1.x01), !cw);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Or is the inner ring just a circular arc?
|
|
|
else context.arc(0, 0, r0, a10, a00, cw);
|
|
|
}
|
|
|
|
|
|
context.closePath();
|
|
|
|
|
|
if (buffer) return context = null, buffer + "" || null;
|
|
|
}
|
|
|
|
|
|
arc.centroid = function() {
|
|
|
var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,
|
|
|
a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - _math_js__WEBPACK_IMPORTED_MODULE_0__.pi / 2;
|
|
|
return [(0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .cos */ .mC)(a) * r, (0,_math_js__WEBPACK_IMPORTED_MODULE_0__/* .sin */ .O$)(a) * r];
|
|
|
};
|
|
|
|
|
|
arc.innerRadius = function(_) {
|
|
|
return arguments.length ? (innerRadius = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : innerRadius;
|
|
|
};
|
|
|
|
|
|
arc.outerRadius = function(_) {
|
|
|
return arguments.length ? (outerRadius = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : outerRadius;
|
|
|
};
|
|
|
|
|
|
arc.cornerRadius = function(_) {
|
|
|
return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : cornerRadius;
|
|
|
};
|
|
|
|
|
|
arc.padRadius = function(_) {
|
|
|
return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : padRadius;
|
|
|
};
|
|
|
|
|
|
arc.startAngle = function(_) {
|
|
|
return arguments.length ? (startAngle = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : startAngle;
|
|
|
};
|
|
|
|
|
|
arc.endAngle = function(_) {
|
|
|
return arguments.length ? (endAngle = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : endAngle;
|
|
|
};
|
|
|
|
|
|
arc.padAngle = function(_) {
|
|
|
return arguments.length ? (padAngle = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z)(+_), arc) : padAngle;
|
|
|
};
|
|
|
|
|
|
arc.context = function(_) {
|
|
|
return arguments.length ? ((context = _ == null ? null : _), arc) : context;
|
|
|
};
|
|
|
|
|
|
return arc;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 89555:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export slice */
|
|
|
var slice = Array.prototype.slice;
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x) {
|
|
|
return typeof x === "object" && "length" in x
|
|
|
? x // Array, TypedArray, NodeList, array-like
|
|
|
: Array.from(x); // Map, Set, iterable, string, or anything else
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 17728:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x) {
|
|
|
return function constant() {
|
|
|
return x;
|
|
|
};
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 73021:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ ZP: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ fE: () => (/* binding */ Basis),
|
|
|
/* harmony export */ xm: () => (/* binding */ point)
|
|
|
/* harmony export */ });
|
|
|
function point(that, x, y) {
|
|
|
that._context.bezierCurveTo(
|
|
|
(2 * that._x0 + that._x1) / 3,
|
|
|
(2 * that._y0 + that._y1) / 3,
|
|
|
(that._x0 + 2 * that._x1) / 3,
|
|
|
(that._y0 + 2 * that._y1) / 3,
|
|
|
(that._x0 + 4 * that._x1 + x) / 6,
|
|
|
(that._y0 + 4 * that._y1 + y) / 6
|
|
|
);
|
|
|
}
|
|
|
|
|
|
function Basis(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
Basis.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 =
|
|
|
this._y0 = this._y1 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 3: point(this, this._x1, this._y1); // falls through
|
|
|
case 2: this._context.lineTo(this._x1, this._y1); break;
|
|
|
}
|
|
|
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
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; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // falls through
|
|
|
default: point(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = x;
|
|
|
this._y0 = this._y1, this._y1 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new Basis(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 88973:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _noop_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98010);
|
|
|
/* harmony import */ var _basis_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73021);
|
|
|
|
|
|
|
|
|
|
|
|
function BasisClosed(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
BasisClosed.prototype = {
|
|
|
areaStart: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
areaEnd: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =
|
|
|
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 1: {
|
|
|
this._context.moveTo(this._x2, this._y2);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 2: {
|
|
|
this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);
|
|
|
this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 3: {
|
|
|
this.point(this._x2, this._y2);
|
|
|
this.point(this._x3, this._y3);
|
|
|
this.point(this._x4, this._y4);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; this._x2 = x, this._y2 = y; break;
|
|
|
case 1: this._point = 2; this._x3 = x, this._y3 = y; break;
|
|
|
case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;
|
|
|
default: (0,_basis_js__WEBPACK_IMPORTED_MODULE_1__/* .point */ .xm)(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = x;
|
|
|
this._y0 = this._y1, this._y1 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new BasisClosed(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 74372:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _basis_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73021);
|
|
|
|
|
|
|
|
|
function BasisOpen(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
BasisOpen.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 =
|
|
|
this._y0 = this._y1 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; break;
|
|
|
case 1: this._point = 2; break;
|
|
|
case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;
|
|
|
case 3: this._point = 4; // falls through
|
|
|
default: (0,_basis_js__WEBPACK_IMPORTED_MODULE_0__/* .point */ .xm)(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = x;
|
|
|
this._y0 = this._y1, this._y1 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new BasisOpen(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 32830:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _basis_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73021);
|
|
|
|
|
|
|
|
|
function Bundle(context, beta) {
|
|
|
this._basis = new _basis_js__WEBPACK_IMPORTED_MODULE_0__/* .Basis */ .fE(context);
|
|
|
this._beta = beta;
|
|
|
}
|
|
|
|
|
|
Bundle.prototype = {
|
|
|
lineStart: function() {
|
|
|
this._x = [];
|
|
|
this._y = [];
|
|
|
this._basis.lineStart();
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
var x = this._x,
|
|
|
y = this._y,
|
|
|
j = x.length - 1;
|
|
|
|
|
|
if (j > 0) {
|
|
|
var x0 = x[0],
|
|
|
y0 = y[0],
|
|
|
dx = x[j] - x0,
|
|
|
dy = y[j] - y0,
|
|
|
i = -1,
|
|
|
t;
|
|
|
|
|
|
while (++i <= j) {
|
|
|
t = i / j;
|
|
|
this._basis.point(
|
|
|
this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),
|
|
|
this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this._x = this._y = null;
|
|
|
this._basis.lineEnd();
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
this._x.push(+x);
|
|
|
this._y.push(+y);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(beta) {
|
|
|
|
|
|
function bundle(context) {
|
|
|
return beta === 1 ? new _basis_js__WEBPACK_IMPORTED_MODULE_0__/* .Basis */ .fE(context) : new Bundle(context, beta);
|
|
|
}
|
|
|
|
|
|
bundle.beta = function(beta) {
|
|
|
return custom(+beta);
|
|
|
};
|
|
|
|
|
|
return bundle;
|
|
|
})(0.85));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 88800:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ ZP: () => (__WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ pC: () => (/* binding */ Cardinal),
|
|
|
/* harmony export */ xm: () => (/* binding */ point)
|
|
|
/* harmony export */ });
|
|
|
function point(that, x, y) {
|
|
|
that._context.bezierCurveTo(
|
|
|
that._x1 + that._k * (that._x2 - that._x0),
|
|
|
that._y1 + that._k * (that._y2 - that._y0),
|
|
|
that._x2 + that._k * (that._x1 - x),
|
|
|
that._y2 + that._k * (that._y1 - y),
|
|
|
that._x2,
|
|
|
that._y2
|
|
|
);
|
|
|
}
|
|
|
|
|
|
function Cardinal(context, tension) {
|
|
|
this._context = context;
|
|
|
this._k = (1 - tension) / 6;
|
|
|
}
|
|
|
|
|
|
Cardinal.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 =
|
|
|
this._y0 = this._y1 = this._y2 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 2: this._context.lineTo(this._x2, this._y2); break;
|
|
|
case 3: point(this, this._x1, this._y1); break;
|
|
|
}
|
|
|
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
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; this._x1 = x, this._y1 = y; break;
|
|
|
case 2: this._point = 3; // falls through
|
|
|
default: point(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(tension) {
|
|
|
|
|
|
function cardinal(context) {
|
|
|
return new Cardinal(context, tension);
|
|
|
}
|
|
|
|
|
|
cardinal.tension = function(tension) {
|
|
|
return custom(+tension);
|
|
|
};
|
|
|
|
|
|
return cardinal;
|
|
|
})(0));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 91390:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ U: () => (/* binding */ CardinalClosed),
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _noop_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98010);
|
|
|
/* harmony import */ var _cardinal_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(88800);
|
|
|
|
|
|
|
|
|
|
|
|
function CardinalClosed(context, tension) {
|
|
|
this._context = context;
|
|
|
this._k = (1 - tension) / 6;
|
|
|
}
|
|
|
|
|
|
CardinalClosed.prototype = {
|
|
|
areaStart: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
areaEnd: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =
|
|
|
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 1: {
|
|
|
this._context.moveTo(this._x3, this._y3);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 2: {
|
|
|
this._context.lineTo(this._x3, this._y3);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 3: {
|
|
|
this.point(this._x3, this._y3);
|
|
|
this.point(this._x4, this._y4);
|
|
|
this.point(this._x5, this._y5);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; this._x3 = x, this._y3 = y; break;
|
|
|
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;
|
|
|
case 2: this._point = 3; this._x5 = x, this._y5 = y; break;
|
|
|
default: (0,_cardinal_js__WEBPACK_IMPORTED_MODULE_1__/* .point */ .xm)(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(tension) {
|
|
|
|
|
|
function cardinal(context) {
|
|
|
return new CardinalClosed(context, tension);
|
|
|
}
|
|
|
|
|
|
cardinal.tension = function(tension) {
|
|
|
return custom(+tension);
|
|
|
};
|
|
|
|
|
|
return cardinal;
|
|
|
})(0));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 41599:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ T: () => (/* binding */ CardinalOpen),
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _cardinal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(88800);
|
|
|
|
|
|
|
|
|
function CardinalOpen(context, tension) {
|
|
|
this._context = context;
|
|
|
this._k = (1 - tension) / 6;
|
|
|
}
|
|
|
|
|
|
CardinalOpen.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 =
|
|
|
this._y0 = this._y1 = this._y2 = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; break;
|
|
|
case 1: this._point = 2; break;
|
|
|
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;
|
|
|
case 3: this._point = 4; // falls through
|
|
|
default: (0,_cardinal_js__WEBPACK_IMPORTED_MODULE_0__/* .point */ .xm)(this, x, y); break;
|
|
|
}
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(tension) {
|
|
|
|
|
|
function cardinal(context) {
|
|
|
return new CardinalOpen(context, tension);
|
|
|
}
|
|
|
|
|
|
cardinal.tension = function(tension) {
|
|
|
return custom(+tension);
|
|
|
};
|
|
|
|
|
|
return cardinal;
|
|
|
})(0));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 48917:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ x: () => (/* binding */ point)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90596);
|
|
|
/* harmony import */ var _cardinal_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(88800);
|
|
|
|
|
|
|
|
|
|
|
|
function point(that, x, y) {
|
|
|
var x1 = that._x1,
|
|
|
y1 = that._y1,
|
|
|
x2 = that._x2,
|
|
|
y2 = that._y2;
|
|
|
|
|
|
if (that._l01_a > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,
|
|
|
n = 3 * that._l01_a * (that._l01_a + that._l12_a);
|
|
|
x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;
|
|
|
y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;
|
|
|
}
|
|
|
|
|
|
if (that._l23_a > _math_js__WEBPACK_IMPORTED_MODULE_0__/* .epsilon */ .Ho) {
|
|
|
var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,
|
|
|
m = 3 * that._l23_a * (that._l23_a + that._l12_a);
|
|
|
x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;
|
|
|
y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;
|
|
|
}
|
|
|
|
|
|
that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);
|
|
|
}
|
|
|
|
|
|
function CatmullRom(context, alpha) {
|
|
|
this._context = context;
|
|
|
this._alpha = alpha;
|
|
|
}
|
|
|
|
|
|
CatmullRom.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 =
|
|
|
this._y0 = this._y1 = this._y2 = NaN;
|
|
|
this._l01_a = this._l12_a = this._l23_a =
|
|
|
this._l01_2a = this._l12_2a = this._l23_2a =
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 2: this._context.lineTo(this._x2, this._y2); break;
|
|
|
case 3: this.point(this._x2, this._y2); break;
|
|
|
}
|
|
|
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
|
|
|
if (this._point) {
|
|
|
var x23 = this._x2 - x,
|
|
|
y23 = this._y2 - y;
|
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
|
}
|
|
|
|
|
|
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; // falls through
|
|
|
default: point(this, x, y); break;
|
|
|
}
|
|
|
|
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
|
|
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(alpha) {
|
|
|
|
|
|
function catmullRom(context) {
|
|
|
return alpha ? new CatmullRom(context, alpha) : new _cardinal_js__WEBPACK_IMPORTED_MODULE_1__/* .Cardinal */ .pC(context, 0);
|
|
|
}
|
|
|
|
|
|
catmullRom.alpha = function(alpha) {
|
|
|
return custom(+alpha);
|
|
|
};
|
|
|
|
|
|
return catmullRom;
|
|
|
})(0.5));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 7391:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _cardinalClosed_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91390);
|
|
|
/* harmony import */ var _noop_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98010);
|
|
|
/* harmony import */ var _catmullRom_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(48917);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function CatmullRomClosed(context, alpha) {
|
|
|
this._context = context;
|
|
|
this._alpha = alpha;
|
|
|
}
|
|
|
|
|
|
CatmullRomClosed.prototype = {
|
|
|
areaStart: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
areaEnd: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =
|
|
|
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
|
|
|
this._l01_a = this._l12_a = this._l23_a =
|
|
|
this._l01_2a = this._l12_2a = this._l23_2a =
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
switch (this._point) {
|
|
|
case 1: {
|
|
|
this._context.moveTo(this._x3, this._y3);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 2: {
|
|
|
this._context.lineTo(this._x3, this._y3);
|
|
|
this._context.closePath();
|
|
|
break;
|
|
|
}
|
|
|
case 3: {
|
|
|
this.point(this._x3, this._y3);
|
|
|
this.point(this._x4, this._y4);
|
|
|
this.point(this._x5, this._y5);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
|
|
|
if (this._point) {
|
|
|
var x23 = this._x2 - x,
|
|
|
y23 = this._y2 - y;
|
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
|
}
|
|
|
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; this._x3 = x, this._y3 = y; break;
|
|
|
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;
|
|
|
case 2: this._point = 3; this._x5 = x, this._y5 = y; break;
|
|
|
default: (0,_catmullRom_js__WEBPACK_IMPORTED_MODULE_1__/* .point */ .x)(this, x, y); break;
|
|
|
}
|
|
|
|
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
|
|
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(alpha) {
|
|
|
|
|
|
function catmullRom(context) {
|
|
|
return alpha ? new CatmullRomClosed(context, alpha) : new _cardinalClosed_js__WEBPACK_IMPORTED_MODULE_2__/* .CardinalClosed */ .U(context, 0);
|
|
|
}
|
|
|
|
|
|
catmullRom.alpha = function(alpha) {
|
|
|
return custom(+alpha);
|
|
|
};
|
|
|
|
|
|
return catmullRom;
|
|
|
})(0.5));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 63703:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (__WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _cardinalOpen_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(41599);
|
|
|
/* harmony import */ var _catmullRom_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(48917);
|
|
|
|
|
|
|
|
|
|
|
|
function CatmullRomOpen(context, alpha) {
|
|
|
this._context = context;
|
|
|
this._alpha = alpha;
|
|
|
}
|
|
|
|
|
|
CatmullRomOpen.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x0 = this._x1 = this._x2 =
|
|
|
this._y0 = this._y1 = this._y2 = NaN;
|
|
|
this._l01_a = this._l12_a = this._l23_a =
|
|
|
this._l01_2a = this._l12_2a = this._l23_2a =
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
|
|
|
if (this._point) {
|
|
|
var x23 = this._x2 - x,
|
|
|
y23 = this._y2 - y;
|
|
|
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
|
|
}
|
|
|
|
|
|
switch (this._point) {
|
|
|
case 0: this._point = 1; break;
|
|
|
case 1: this._point = 2; break;
|
|
|
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;
|
|
|
case 3: this._point = 4; // falls through
|
|
|
default: (0,_catmullRom_js__WEBPACK_IMPORTED_MODULE_0__/* .point */ .x)(this, x, y); break;
|
|
|
}
|
|
|
|
|
|
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
|
|
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ((function custom(alpha) {
|
|
|
|
|
|
function catmullRom(context) {
|
|
|
return alpha ? new CatmullRomOpen(context, alpha) : new _cardinalOpen_js__WEBPACK_IMPORTED_MODULE_1__/* .CardinalOpen */ .T(context, 0);
|
|
|
}
|
|
|
|
|
|
catmullRom.alpha = function(alpha) {
|
|
|
return custom(+alpha);
|
|
|
};
|
|
|
|
|
|
return catmullRom;
|
|
|
})(0.5));
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 4224:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
function Linear(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
Linear.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
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; // falls through
|
|
|
default: this._context.lineTo(x, y); break;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new Linear(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 29458:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _noop_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(98010);
|
|
|
|
|
|
|
|
|
function LinearClosed(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
LinearClosed.prototype = {
|
|
|
areaStart: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
areaEnd: _noop_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z,
|
|
|
lineStart: function() {
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (this._point) this._context.closePath();
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
if (this._point) this._context.lineTo(x, y);
|
|
|
else this._point = 1, this._context.moveTo(x, y);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new LinearClosed(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 78509:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ monotoneX),
|
|
|
/* harmony export */ s: () => (/* binding */ monotoneY)
|
|
|
/* harmony export */ });
|
|
|
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); }
|
|
|
};
|
|
|
|
|
|
function monotoneX(context) {
|
|
|
return new MonotoneX(context);
|
|
|
}
|
|
|
|
|
|
function monotoneY(context) {
|
|
|
return new MonotoneY(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 3499:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
function Natural(context) {
|
|
|
this._context = context;
|
|
|
}
|
|
|
|
|
|
Natural.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x = [];
|
|
|
this._y = [];
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
var x = this._x,
|
|
|
y = this._y,
|
|
|
n = x.length;
|
|
|
|
|
|
if (n) {
|
|
|
this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);
|
|
|
if (n === 2) {
|
|
|
this._context.lineTo(x[1], y[1]);
|
|
|
} else {
|
|
|
var px = controlPoints(x),
|
|
|
py = controlPoints(y);
|
|
|
for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {
|
|
|
this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();
|
|
|
this._line = 1 - this._line;
|
|
|
this._x = this._y = null;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
this._x.push(+x);
|
|
|
this._y.push(+y);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// See https://www.particleincell.com/2012/bezier-splines/ for derivation.
|
|
|
function controlPoints(x) {
|
|
|
var i,
|
|
|
n = x.length - 1,
|
|
|
m,
|
|
|
a = new Array(n),
|
|
|
b = new Array(n),
|
|
|
r = new Array(n);
|
|
|
a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];
|
|
|
for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];
|
|
|
a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];
|
|
|
for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];
|
|
|
a[n - 1] = r[n - 1] / b[n - 1];
|
|
|
for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];
|
|
|
b[n - 1] = (x[n] + a[n - 1]) / 2;
|
|
|
for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];
|
|
|
return [a, b];
|
|
|
}
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new Natural(context);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 21468:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ RN: () => (/* binding */ stepBefore),
|
|
|
/* harmony export */ ZP: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__),
|
|
|
/* harmony export */ cD: () => (/* binding */ stepAfter)
|
|
|
/* harmony export */ });
|
|
|
function Step(context, t) {
|
|
|
this._context = context;
|
|
|
this._t = t;
|
|
|
}
|
|
|
|
|
|
Step.prototype = {
|
|
|
areaStart: function() {
|
|
|
this._line = 0;
|
|
|
},
|
|
|
areaEnd: function() {
|
|
|
this._line = NaN;
|
|
|
},
|
|
|
lineStart: function() {
|
|
|
this._x = this._y = NaN;
|
|
|
this._point = 0;
|
|
|
},
|
|
|
lineEnd: function() {
|
|
|
if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);
|
|
|
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
|
|
if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;
|
|
|
},
|
|
|
point: function(x, y) {
|
|
|
x = +x, y = +y;
|
|
|
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; // falls through
|
|
|
default: {
|
|
|
if (this._t <= 0) {
|
|
|
this._context.lineTo(this._x, y);
|
|
|
this._context.lineTo(x, y);
|
|
|
} else {
|
|
|
var x1 = this._x * (1 - this._t) + x * this._t;
|
|
|
this._context.lineTo(x1, this._y);
|
|
|
this._context.lineTo(x1, y);
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
this._x = x, this._y = y;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(context) {
|
|
|
return new Step(context, 0.5);
|
|
|
}
|
|
|
|
|
|
function stepBefore(context) {
|
|
|
return new Step(context, 0);
|
|
|
}
|
|
|
|
|
|
function stepAfter(context) {
|
|
|
return new Step(context, 1);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 40652:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var _array_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(89555);
|
|
|
/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(17728);
|
|
|
/* harmony import */ var _curve_linear_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4224);
|
|
|
/* harmony import */ var _path_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(53863);
|
|
|
/* harmony import */ var _point_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(41221);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(x, y) {
|
|
|
var defined = (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(true),
|
|
|
context = null,
|
|
|
curve = _curve_linear_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z,
|
|
|
output = null,
|
|
|
path = (0,_path_js__WEBPACK_IMPORTED_MODULE_2__/* .withPath */ .d)(line);
|
|
|
|
|
|
x = typeof x === "function" ? x : (x === undefined) ? _point_js__WEBPACK_IMPORTED_MODULE_3__.x : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(x);
|
|
|
y = typeof y === "function" ? y : (y === undefined) ? _point_js__WEBPACK_IMPORTED_MODULE_3__.y : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(y);
|
|
|
|
|
|
function line(data) {
|
|
|
var i,
|
|
|
n = (data = (0,_array_js__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Z)(data)).length,
|
|
|
d,
|
|
|
defined0 = false,
|
|
|
buffer;
|
|
|
|
|
|
if (context == null) output = curve(buffer = path());
|
|
|
|
|
|
for (i = 0; i <= n; ++i) {
|
|
|
if (!(i < n && defined(d = data[i], i, data)) === defined0) {
|
|
|
if (defined0 = !defined0) output.lineStart();
|
|
|
else output.lineEnd();
|
|
|
}
|
|
|
if (defined0) output.point(+x(d, i, data), +y(d, i, data));
|
|
|
}
|
|
|
|
|
|
if (buffer) return output = null, buffer + "" || null;
|
|
|
}
|
|
|
|
|
|
line.x = function(_) {
|
|
|
return arguments.length ? (x = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(+_), line) : x;
|
|
|
};
|
|
|
|
|
|
line.y = function(_) {
|
|
|
return arguments.length ? (y = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(+_), line) : y;
|
|
|
};
|
|
|
|
|
|
line.defined = function(_) {
|
|
|
return arguments.length ? (defined = typeof _ === "function" ? _ : (0,_constant_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(!!_), line) : defined;
|
|
|
};
|
|
|
|
|
|
line.curve = function(_) {
|
|
|
return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;
|
|
|
};
|
|
|
|
|
|
line.context = function(_) {
|
|
|
return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;
|
|
|
};
|
|
|
|
|
|
return line;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 90596:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ BZ: () => (/* binding */ tau),
|
|
|
/* harmony export */ Fp: () => (/* binding */ max),
|
|
|
/* harmony export */ Ho: () => (/* binding */ epsilon),
|
|
|
/* harmony export */ Kh: () => (/* binding */ acos),
|
|
|
/* harmony export */ O$: () => (/* binding */ sin),
|
|
|
/* harmony export */ VV: () => (/* binding */ min),
|
|
|
/* harmony export */ Wn: () => (/* binding */ abs),
|
|
|
/* harmony export */ ZR: () => (/* binding */ asin),
|
|
|
/* harmony export */ _b: () => (/* binding */ sqrt),
|
|
|
/* harmony export */ fv: () => (/* binding */ atan2),
|
|
|
/* harmony export */ mC: () => (/* binding */ cos),
|
|
|
/* harmony export */ ou: () => (/* binding */ halfPi),
|
|
|
/* harmony export */ pi: () => (/* binding */ pi)
|
|
|
/* harmony export */ });
|
|
|
const abs = Math.abs;
|
|
|
const atan2 = Math.atan2;
|
|
|
const cos = Math.cos;
|
|
|
const max = Math.max;
|
|
|
const min = Math.min;
|
|
|
const sin = Math.sin;
|
|
|
const sqrt = Math.sqrt;
|
|
|
|
|
|
const epsilon = 1e-12;
|
|
|
const pi = Math.PI;
|
|
|
const halfPi = pi / 2;
|
|
|
const tau = 2 * pi;
|
|
|
|
|
|
function acos(x) {
|
|
|
return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
|
|
|
}
|
|
|
|
|
|
function asin(x) {
|
|
|
return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 98010:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
|
|
|
/* harmony export */ });
|
|
|
/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__() {}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 53863:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ d: () => (/* binding */ withPath)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3791);
|
|
|
|
|
|
|
|
|
function withPath(shape) {
|
|
|
let digits = 3;
|
|
|
|
|
|
shape.digits = function(_) {
|
|
|
if (!arguments.length) return digits;
|
|
|
if (_ == null) {
|
|
|
digits = null;
|
|
|
} else {
|
|
|
const d = Math.floor(_);
|
|
|
if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
|
|
|
digits = d;
|
|
|
}
|
|
|
return shape;
|
|
|
};
|
|
|
|
|
|
return () => new d3_path__WEBPACK_IMPORTED_MODULE_0__/* .Path */ .y$(digits);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 41221:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ x: () => (/* binding */ x),
|
|
|
/* harmony export */ y: () => (/* binding */ y)
|
|
|
/* harmony export */ });
|
|
|
function x(p) {
|
|
|
return p[0];
|
|
|
}
|
|
|
|
|
|
function y(p) {
|
|
|
return p[1];
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 94031:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z1: () => (/* binding */ timeParse),
|
|
|
/* harmony export */ g0: () => (/* binding */ utcFormat),
|
|
|
/* harmony export */ i$: () => (/* binding */ timeFormat),
|
|
|
/* harmony export */ wp: () => (/* binding */ utcParse)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export default */
|
|
|
/* harmony import */ var _locale_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6367);
|
|
|
|
|
|
|
|
|
var locale;
|
|
|
var timeFormat;
|
|
|
var timeParse;
|
|
|
var utcFormat;
|
|
|
var utcParse;
|
|
|
|
|
|
defaultLocale({
|
|
|
dateTime: "%x, %X",
|
|
|
date: "%-m/%-d/%Y",
|
|
|
time: "%-I:%M:%S %p",
|
|
|
periods: ["AM", "PM"],
|
|
|
days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
|
|
|
shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
|
|
|
months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
|
|
|
shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
|
|
|
});
|
|
|
|
|
|
function defaultLocale(definition) {
|
|
|
locale = (0,_locale_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(definition);
|
|
|
timeFormat = locale.format;
|
|
|
timeParse = locale.parse;
|
|
|
utcFormat = locale.utcFormat;
|
|
|
utcParse = locale.utcParse;
|
|
|
return locale;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 6367:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z: () => (/* binding */ formatLocale)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24645);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6054);
|
|
|
/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(47878);
|
|
|
|
|
|
|
|
|
function localDate(d) {
|
|
|
if (0 <= d.y && d.y < 100) {
|
|
|
var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
|
date.setFullYear(d.y);
|
|
|
return date;
|
|
|
}
|
|
|
return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
|
}
|
|
|
|
|
|
function utcDate(d) {
|
|
|
if (0 <= d.y && d.y < 100) {
|
|
|
var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
|
date.setUTCFullYear(d.y);
|
|
|
return date;
|
|
|
}
|
|
|
return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
|
}
|
|
|
|
|
|
function newDate(y, m, d) {
|
|
|
return {y: y, m: m, d: d, H: 0, M: 0, S: 0, L: 0};
|
|
|
}
|
|
|
|
|
|
function formatLocale(locale) {
|
|
|
var locale_dateTime = locale.dateTime,
|
|
|
locale_date = locale.date,
|
|
|
locale_time = locale.time,
|
|
|
locale_periods = locale.periods,
|
|
|
locale_weekdays = locale.days,
|
|
|
locale_shortWeekdays = locale.shortDays,
|
|
|
locale_months = locale.months,
|
|
|
locale_shortMonths = locale.shortMonths;
|
|
|
|
|
|
var periodRe = formatRe(locale_periods),
|
|
|
periodLookup = formatLookup(locale_periods),
|
|
|
weekdayRe = formatRe(locale_weekdays),
|
|
|
weekdayLookup = formatLookup(locale_weekdays),
|
|
|
shortWeekdayRe = formatRe(locale_shortWeekdays),
|
|
|
shortWeekdayLookup = formatLookup(locale_shortWeekdays),
|
|
|
monthRe = formatRe(locale_months),
|
|
|
monthLookup = formatLookup(locale_months),
|
|
|
shortMonthRe = formatRe(locale_shortMonths),
|
|
|
shortMonthLookup = formatLookup(locale_shortMonths);
|
|
|
|
|
|
var formats = {
|
|
|
"a": formatShortWeekday,
|
|
|
"A": formatWeekday,
|
|
|
"b": formatShortMonth,
|
|
|
"B": formatMonth,
|
|
|
"c": null,
|
|
|
"d": formatDayOfMonth,
|
|
|
"e": formatDayOfMonth,
|
|
|
"f": formatMicroseconds,
|
|
|
"g": formatYearISO,
|
|
|
"G": formatFullYearISO,
|
|
|
"H": formatHour24,
|
|
|
"I": formatHour12,
|
|
|
"j": formatDayOfYear,
|
|
|
"L": formatMilliseconds,
|
|
|
"m": formatMonthNumber,
|
|
|
"M": formatMinutes,
|
|
|
"p": formatPeriod,
|
|
|
"q": formatQuarter,
|
|
|
"Q": formatUnixTimestamp,
|
|
|
"s": formatUnixTimestampSeconds,
|
|
|
"S": formatSeconds,
|
|
|
"u": formatWeekdayNumberMonday,
|
|
|
"U": formatWeekNumberSunday,
|
|
|
"V": formatWeekNumberISO,
|
|
|
"w": formatWeekdayNumberSunday,
|
|
|
"W": formatWeekNumberMonday,
|
|
|
"x": null,
|
|
|
"X": null,
|
|
|
"y": formatYear,
|
|
|
"Y": formatFullYear,
|
|
|
"Z": formatZone,
|
|
|
"%": formatLiteralPercent
|
|
|
};
|
|
|
|
|
|
var utcFormats = {
|
|
|
"a": formatUTCShortWeekday,
|
|
|
"A": formatUTCWeekday,
|
|
|
"b": formatUTCShortMonth,
|
|
|
"B": formatUTCMonth,
|
|
|
"c": null,
|
|
|
"d": formatUTCDayOfMonth,
|
|
|
"e": formatUTCDayOfMonth,
|
|
|
"f": formatUTCMicroseconds,
|
|
|
"g": formatUTCYearISO,
|
|
|
"G": formatUTCFullYearISO,
|
|
|
"H": formatUTCHour24,
|
|
|
"I": formatUTCHour12,
|
|
|
"j": formatUTCDayOfYear,
|
|
|
"L": formatUTCMilliseconds,
|
|
|
"m": formatUTCMonthNumber,
|
|
|
"M": formatUTCMinutes,
|
|
|
"p": formatUTCPeriod,
|
|
|
"q": formatUTCQuarter,
|
|
|
"Q": formatUnixTimestamp,
|
|
|
"s": formatUnixTimestampSeconds,
|
|
|
"S": formatUTCSeconds,
|
|
|
"u": formatUTCWeekdayNumberMonday,
|
|
|
"U": formatUTCWeekNumberSunday,
|
|
|
"V": formatUTCWeekNumberISO,
|
|
|
"w": formatUTCWeekdayNumberSunday,
|
|
|
"W": formatUTCWeekNumberMonday,
|
|
|
"x": null,
|
|
|
"X": null,
|
|
|
"y": formatUTCYear,
|
|
|
"Y": formatUTCFullYear,
|
|
|
"Z": formatUTCZone,
|
|
|
"%": formatLiteralPercent
|
|
|
};
|
|
|
|
|
|
var parses = {
|
|
|
"a": parseShortWeekday,
|
|
|
"A": parseWeekday,
|
|
|
"b": parseShortMonth,
|
|
|
"B": parseMonth,
|
|
|
"c": parseLocaleDateTime,
|
|
|
"d": parseDayOfMonth,
|
|
|
"e": parseDayOfMonth,
|
|
|
"f": parseMicroseconds,
|
|
|
"g": parseYear,
|
|
|
"G": parseFullYear,
|
|
|
"H": parseHour24,
|
|
|
"I": parseHour24,
|
|
|
"j": parseDayOfYear,
|
|
|
"L": parseMilliseconds,
|
|
|
"m": parseMonthNumber,
|
|
|
"M": parseMinutes,
|
|
|
"p": parsePeriod,
|
|
|
"q": parseQuarter,
|
|
|
"Q": parseUnixTimestamp,
|
|
|
"s": parseUnixTimestampSeconds,
|
|
|
"S": parseSeconds,
|
|
|
"u": parseWeekdayNumberMonday,
|
|
|
"U": parseWeekNumberSunday,
|
|
|
"V": parseWeekNumberISO,
|
|
|
"w": parseWeekdayNumberSunday,
|
|
|
"W": parseWeekNumberMonday,
|
|
|
"x": parseLocaleDate,
|
|
|
"X": parseLocaleTime,
|
|
|
"y": parseYear,
|
|
|
"Y": parseFullYear,
|
|
|
"Z": parseZone,
|
|
|
"%": parseLiteralPercent
|
|
|
};
|
|
|
|
|
|
// These recursive directive definitions must be deferred.
|
|
|
formats.x = newFormat(locale_date, formats);
|
|
|
formats.X = newFormat(locale_time, formats);
|
|
|
formats.c = newFormat(locale_dateTime, formats);
|
|
|
utcFormats.x = newFormat(locale_date, utcFormats);
|
|
|
utcFormats.X = newFormat(locale_time, utcFormats);
|
|
|
utcFormats.c = newFormat(locale_dateTime, utcFormats);
|
|
|
|
|
|
function newFormat(specifier, formats) {
|
|
|
return function(date) {
|
|
|
var string = [],
|
|
|
i = -1,
|
|
|
j = 0,
|
|
|
n = specifier.length,
|
|
|
c,
|
|
|
pad,
|
|
|
format;
|
|
|
|
|
|
if (!(date instanceof Date)) date = new Date(+date);
|
|
|
|
|
|
while (++i < n) {
|
|
|
if (specifier.charCodeAt(i) === 37) {
|
|
|
string.push(specifier.slice(j, i));
|
|
|
if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
|
|
|
else pad = c === "e" ? " " : "0";
|
|
|
if (format = formats[c]) c = format(date, pad);
|
|
|
string.push(c);
|
|
|
j = i + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
string.push(specifier.slice(j, i));
|
|
|
return string.join("");
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function newParse(specifier, Z) {
|
|
|
return function(string) {
|
|
|
var d = newDate(1900, undefined, 1),
|
|
|
i = parseSpecifier(d, specifier, string += "", 0),
|
|
|
week, day;
|
|
|
if (i != string.length) return null;
|
|
|
|
|
|
// If a UNIX timestamp is specified, return it.
|
|
|
if ("Q" in d) return new Date(d.Q);
|
|
|
if ("s" in d) return new Date(d.s * 1000 + ("L" in d ? d.L : 0));
|
|
|
|
|
|
// If this is utcParse, never use the local timezone.
|
|
|
if (Z && !("Z" in d)) d.Z = 0;
|
|
|
|
|
|
// The am-pm flag is 0 for AM, and 1 for PM.
|
|
|
if ("p" in d) d.H = d.H % 12 + d.p * 12;
|
|
|
|
|
|
// If the month was not specified, inherit from the quarter.
|
|
|
if (d.m === undefined) d.m = "q" in d ? d.q : 0;
|
|
|
|
|
|
// Convert day-of-week and week-of-year to day-of-year.
|
|
|
if ("V" in d) {
|
|
|
if (d.V < 1 || d.V > 53) return null;
|
|
|
if (!("w" in d)) d.w = 1;
|
|
|
if ("Z" in d) {
|
|
|
week = utcDate(newDate(d.y, 0, 1)), day = week.getUTCDay();
|
|
|
week = day > 4 || day === 0 ? d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcMonday */ .l6.ceil(week) : (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcMonday */ .l6)(week);
|
|
|
week = d3_time__WEBPACK_IMPORTED_MODULE_1__/* .utcDay */ .AN.offset(week, (d.V - 1) * 7);
|
|
|
d.y = week.getUTCFullYear();
|
|
|
d.m = week.getUTCMonth();
|
|
|
d.d = week.getUTCDate() + (d.w + 6) % 7;
|
|
|
} else {
|
|
|
week = localDate(newDate(d.y, 0, 1)), day = week.getDay();
|
|
|
week = day > 4 || day === 0 ? d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeMonday */ .Ox.ceil(week) : (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeMonday */ .Ox)(week);
|
|
|
week = d3_time__WEBPACK_IMPORTED_MODULE_1__/* .timeDay */ .rr.offset(week, (d.V - 1) * 7);
|
|
|
d.y = week.getFullYear();
|
|
|
d.m = week.getMonth();
|
|
|
d.d = week.getDate() + (d.w + 6) % 7;
|
|
|
}
|
|
|
} else if ("W" in d || "U" in d) {
|
|
|
if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0;
|
|
|
day = "Z" in d ? utcDate(newDate(d.y, 0, 1)).getUTCDay() : localDate(newDate(d.y, 0, 1)).getDay();
|
|
|
d.m = 0;
|
|
|
d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7;
|
|
|
}
|
|
|
|
|
|
// If a time zone is specified, all fields are interpreted as UTC and then
|
|
|
// offset according to the specified time zone.
|
|
|
if ("Z" in d) {
|
|
|
d.H += d.Z / 100 | 0;
|
|
|
d.M += d.Z % 100;
|
|
|
return utcDate(d);
|
|
|
}
|
|
|
|
|
|
// Otherwise, all fields are in local time.
|
|
|
return localDate(d);
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function parseSpecifier(d, specifier, string, j) {
|
|
|
var i = 0,
|
|
|
n = specifier.length,
|
|
|
m = string.length,
|
|
|
c,
|
|
|
parse;
|
|
|
|
|
|
while (i < n) {
|
|
|
if (j >= m) return -1;
|
|
|
c = specifier.charCodeAt(i++);
|
|
|
if (c === 37) {
|
|
|
c = specifier.charAt(i++);
|
|
|
parse = parses[c in pads ? specifier.charAt(i++) : c];
|
|
|
if (!parse || ((j = parse(d, string, j)) < 0)) return -1;
|
|
|
} else if (c != string.charCodeAt(j++)) {
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return j;
|
|
|
}
|
|
|
|
|
|
function parsePeriod(d, string, i) {
|
|
|
var n = periodRe.exec(string.slice(i));
|
|
|
return n ? (d.p = periodLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseShortWeekday(d, string, i) {
|
|
|
var n = shortWeekdayRe.exec(string.slice(i));
|
|
|
return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseWeekday(d, string, i) {
|
|
|
var n = weekdayRe.exec(string.slice(i));
|
|
|
return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseShortMonth(d, string, i) {
|
|
|
var n = shortMonthRe.exec(string.slice(i));
|
|
|
return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseMonth(d, string, i) {
|
|
|
var n = monthRe.exec(string.slice(i));
|
|
|
return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseLocaleDateTime(d, string, i) {
|
|
|
return parseSpecifier(d, locale_dateTime, string, i);
|
|
|
}
|
|
|
|
|
|
function parseLocaleDate(d, string, i) {
|
|
|
return parseSpecifier(d, locale_date, string, i);
|
|
|
}
|
|
|
|
|
|
function parseLocaleTime(d, string, i) {
|
|
|
return parseSpecifier(d, locale_time, string, i);
|
|
|
}
|
|
|
|
|
|
function formatShortWeekday(d) {
|
|
|
return locale_shortWeekdays[d.getDay()];
|
|
|
}
|
|
|
|
|
|
function formatWeekday(d) {
|
|
|
return locale_weekdays[d.getDay()];
|
|
|
}
|
|
|
|
|
|
function formatShortMonth(d) {
|
|
|
return locale_shortMonths[d.getMonth()];
|
|
|
}
|
|
|
|
|
|
function formatMonth(d) {
|
|
|
return locale_months[d.getMonth()];
|
|
|
}
|
|
|
|
|
|
function formatPeriod(d) {
|
|
|
return locale_periods[+(d.getHours() >= 12)];
|
|
|
}
|
|
|
|
|
|
function formatQuarter(d) {
|
|
|
return 1 + ~~(d.getMonth() / 3);
|
|
|
}
|
|
|
|
|
|
function formatUTCShortWeekday(d) {
|
|
|
return locale_shortWeekdays[d.getUTCDay()];
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekday(d) {
|
|
|
return locale_weekdays[d.getUTCDay()];
|
|
|
}
|
|
|
|
|
|
function formatUTCShortMonth(d) {
|
|
|
return locale_shortMonths[d.getUTCMonth()];
|
|
|
}
|
|
|
|
|
|
function formatUTCMonth(d) {
|
|
|
return locale_months[d.getUTCMonth()];
|
|
|
}
|
|
|
|
|
|
function formatUTCPeriod(d) {
|
|
|
return locale_periods[+(d.getUTCHours() >= 12)];
|
|
|
}
|
|
|
|
|
|
function formatUTCQuarter(d) {
|
|
|
return 1 + ~~(d.getUTCMonth() / 3);
|
|
|
}
|
|
|
|
|
|
return {
|
|
|
format: function(specifier) {
|
|
|
var f = newFormat(specifier += "", formats);
|
|
|
f.toString = function() { return specifier; };
|
|
|
return f;
|
|
|
},
|
|
|
parse: function(specifier) {
|
|
|
var p = newParse(specifier += "", false);
|
|
|
p.toString = function() { return specifier; };
|
|
|
return p;
|
|
|
},
|
|
|
utcFormat: function(specifier) {
|
|
|
var f = newFormat(specifier += "", utcFormats);
|
|
|
f.toString = function() { return specifier; };
|
|
|
return f;
|
|
|
},
|
|
|
utcParse: function(specifier) {
|
|
|
var p = newParse(specifier += "", true);
|
|
|
p.toString = function() { return specifier; };
|
|
|
return p;
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
|
|
|
var pads = {"-": "", "_": " ", "0": "0"},
|
|
|
numberRe = /^\s*\d+/, // note: ignores next directive
|
|
|
percentRe = /^%/,
|
|
|
requoteRe = /[\\^$*+?|[\]().{}]/g;
|
|
|
|
|
|
function pad(value, fill, width) {
|
|
|
var sign = value < 0 ? "-" : "",
|
|
|
string = (sign ? -value : value) + "",
|
|
|
length = string.length;
|
|
|
return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
|
|
|
}
|
|
|
|
|
|
function requote(s) {
|
|
|
return s.replace(requoteRe, "\\$&");
|
|
|
}
|
|
|
|
|
|
function formatRe(names) {
|
|
|
return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
|
|
|
}
|
|
|
|
|
|
function formatLookup(names) {
|
|
|
return new Map(names.map((name, i) => [name.toLowerCase(), i]));
|
|
|
}
|
|
|
|
|
|
function parseWeekdayNumberSunday(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
|
return n ? (d.w = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseWeekdayNumberMonday(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
|
return n ? (d.u = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseWeekNumberSunday(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.U = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseWeekNumberISO(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.V = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseWeekNumberMonday(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.W = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseFullYear(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 4));
|
|
|
return n ? (d.y = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseYear(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseZone(d, string, i) {
|
|
|
var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6));
|
|
|
return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseQuarter(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 1));
|
|
|
return n ? (d.q = n[0] * 3 - 3, i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseMonthNumber(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseDayOfMonth(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.d = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseDayOfYear(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 3));
|
|
|
return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseHour24(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.H = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseMinutes(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.M = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseSeconds(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
|
return n ? (d.S = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseMilliseconds(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 3));
|
|
|
return n ? (d.L = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseMicroseconds(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i, i + 6));
|
|
|
return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseLiteralPercent(d, string, i) {
|
|
|
var n = percentRe.exec(string.slice(i, i + 1));
|
|
|
return n ? i + n[0].length : -1;
|
|
|
}
|
|
|
|
|
|
function parseUnixTimestamp(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i));
|
|
|
return n ? (d.Q = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function parseUnixTimestampSeconds(d, string, i) {
|
|
|
var n = numberRe.exec(string.slice(i));
|
|
|
return n ? (d.s = +n[0], i + n[0].length) : -1;
|
|
|
}
|
|
|
|
|
|
function formatDayOfMonth(d, p) {
|
|
|
return pad(d.getDate(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatHour24(d, p) {
|
|
|
return pad(d.getHours(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatHour12(d, p) {
|
|
|
return pad(d.getHours() % 12 || 12, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatDayOfYear(d, p) {
|
|
|
return pad(1 + d3_time__WEBPACK_IMPORTED_MODULE_1__/* .timeDay */ .rr.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .timeYear */ .jB)(d), d), p, 3);
|
|
|
}
|
|
|
|
|
|
function formatMilliseconds(d, p) {
|
|
|
return pad(d.getMilliseconds(), p, 3);
|
|
|
}
|
|
|
|
|
|
function formatMicroseconds(d, p) {
|
|
|
return formatMilliseconds(d, p) + "000";
|
|
|
}
|
|
|
|
|
|
function formatMonthNumber(d, p) {
|
|
|
return pad(d.getMonth() + 1, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatMinutes(d, p) {
|
|
|
return pad(d.getMinutes(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatSeconds(d, p) {
|
|
|
return pad(d.getSeconds(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatWeekdayNumberMonday(d) {
|
|
|
var day = d.getDay();
|
|
|
return day === 0 ? 7 : day;
|
|
|
}
|
|
|
|
|
|
function formatWeekNumberSunday(d, p) {
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeSunday */ .Zy.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .timeYear */ .jB)(d) - 1, d), p, 2);
|
|
|
}
|
|
|
|
|
|
function dISO(d) {
|
|
|
var day = d.getDay();
|
|
|
return (day >= 4 || day === 0) ? (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeThursday */ .Ig)(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeThursday */ .Ig.ceil(d);
|
|
|
}
|
|
|
|
|
|
function formatWeekNumberISO(d, p) {
|
|
|
d = dISO(d);
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeThursday */ .Ig.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .timeYear */ .jB)(d), d) + ((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .timeYear */ .jB)(d).getDay() === 4), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatWeekdayNumberSunday(d) {
|
|
|
return d.getDay();
|
|
|
}
|
|
|
|
|
|
function formatWeekNumberMonday(d, p) {
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeMonday */ .Ox.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .timeYear */ .jB)(d) - 1, d), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatYear(d, p) {
|
|
|
return pad(d.getFullYear() % 100, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatYearISO(d, p) {
|
|
|
d = dISO(d);
|
|
|
return pad(d.getFullYear() % 100, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatFullYear(d, p) {
|
|
|
return pad(d.getFullYear() % 10000, p, 4);
|
|
|
}
|
|
|
|
|
|
function formatFullYearISO(d, p) {
|
|
|
var day = d.getDay();
|
|
|
d = (day >= 4 || day === 0) ? (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeThursday */ .Ig)(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__/* .timeThursday */ .Ig.ceil(d);
|
|
|
return pad(d.getFullYear() % 10000, p, 4);
|
|
|
}
|
|
|
|
|
|
function formatZone(d) {
|
|
|
var z = d.getTimezoneOffset();
|
|
|
return (z > 0 ? "-" : (z *= -1, "+"))
|
|
|
+ pad(z / 60 | 0, "0", 2)
|
|
|
+ pad(z % 60, "0", 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCDayOfMonth(d, p) {
|
|
|
return pad(d.getUTCDate(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCHour24(d, p) {
|
|
|
return pad(d.getUTCHours(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCHour12(d, p) {
|
|
|
return pad(d.getUTCHours() % 12 || 12, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCDayOfYear(d, p) {
|
|
|
return pad(1 + d3_time__WEBPACK_IMPORTED_MODULE_1__/* .utcDay */ .AN.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .utcYear */ .ol)(d), d), p, 3);
|
|
|
}
|
|
|
|
|
|
function formatUTCMilliseconds(d, p) {
|
|
|
return pad(d.getUTCMilliseconds(), p, 3);
|
|
|
}
|
|
|
|
|
|
function formatUTCMicroseconds(d, p) {
|
|
|
return formatUTCMilliseconds(d, p) + "000";
|
|
|
}
|
|
|
|
|
|
function formatUTCMonthNumber(d, p) {
|
|
|
return pad(d.getUTCMonth() + 1, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCMinutes(d, p) {
|
|
|
return pad(d.getUTCMinutes(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCSeconds(d, p) {
|
|
|
return pad(d.getUTCSeconds(), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekdayNumberMonday(d) {
|
|
|
var dow = d.getUTCDay();
|
|
|
return dow === 0 ? 7 : dow;
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekNumberSunday(d, p) {
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcSunday */ .pI.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .utcYear */ .ol)(d) - 1, d), p, 2);
|
|
|
}
|
|
|
|
|
|
function UTCdISO(d) {
|
|
|
var day = d.getUTCDay();
|
|
|
return (day >= 4 || day === 0) ? (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcThursday */ .hB)(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcThursday */ .hB.ceil(d);
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekNumberISO(d, p) {
|
|
|
d = UTCdISO(d);
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcThursday */ .hB.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .utcYear */ .ol)(d), d) + ((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .utcYear */ .ol)(d).getUTCDay() === 4), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekdayNumberSunday(d) {
|
|
|
return d.getUTCDay();
|
|
|
}
|
|
|
|
|
|
function formatUTCWeekNumberMonday(d, p) {
|
|
|
return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcMonday */ .l6.count((0,d3_time__WEBPACK_IMPORTED_MODULE_2__/* .utcYear */ .ol)(d) - 1, d), p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCYear(d, p) {
|
|
|
return pad(d.getUTCFullYear() % 100, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCYearISO(d, p) {
|
|
|
d = UTCdISO(d);
|
|
|
return pad(d.getUTCFullYear() % 100, p, 2);
|
|
|
}
|
|
|
|
|
|
function formatUTCFullYear(d, p) {
|
|
|
return pad(d.getUTCFullYear() % 10000, p, 4);
|
|
|
}
|
|
|
|
|
|
function formatUTCFullYearISO(d, p) {
|
|
|
var day = d.getUTCDay();
|
|
|
d = (day >= 4 || day === 0) ? (0,d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcThursday */ .hB)(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__/* .utcThursday */ .hB.ceil(d);
|
|
|
return pad(d.getUTCFullYear() % 10000, p, 4);
|
|
|
}
|
|
|
|
|
|
function formatUTCZone() {
|
|
|
return "+0000";
|
|
|
}
|
|
|
|
|
|
function formatLiteralPercent() {
|
|
|
return "%";
|
|
|
}
|
|
|
|
|
|
function formatUnixTimestamp(d) {
|
|
|
return +d;
|
|
|
}
|
|
|
|
|
|
function formatUnixTimestampSeconds(d) {
|
|
|
return Math.floor(+d / 1000);
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 6054:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ AN: () => (/* binding */ utcDay),
|
|
|
/* harmony export */ KB: () => (/* binding */ unixDay),
|
|
|
/* harmony export */ rr: () => (/* binding */ timeDay)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeDays, utcDays, unixDays */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
|
|
|
|
|
|
|
|
|
const timeDay = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)(
|
|
|
date => date.setHours(0, 0, 0, 0),
|
|
|
(date, step) => date.setDate(date.getDate() + step),
|
|
|
(start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD,
|
|
|
date => date.getDate() - 1
|
|
|
);
|
|
|
|
|
|
const timeDays = timeDay.range;
|
|
|
|
|
|
const utcDay = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setUTCHours(0, 0, 0, 0);
|
|
|
}, (date, step) => {
|
|
|
date.setUTCDate(date.getUTCDate() + step);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD;
|
|
|
}, (date) => {
|
|
|
return date.getUTCDate() - 1;
|
|
|
});
|
|
|
|
|
|
const utcDays = utcDay.range;
|
|
|
|
|
|
const unixDay = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setUTCHours(0, 0, 0, 0);
|
|
|
}, (date, step) => {
|
|
|
date.setUTCDate(date.getUTCDate() + step);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD;
|
|
|
}, (date) => {
|
|
|
return Math.floor(date / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD);
|
|
|
});
|
|
|
|
|
|
const unixDays = unixDay.range;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 45022:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ UD: () => (/* binding */ durationDay),
|
|
|
/* harmony export */ Y2: () => (/* binding */ durationHour),
|
|
|
/* harmony export */ Ym: () => (/* binding */ durationSecond),
|
|
|
/* harmony export */ iM: () => (/* binding */ durationWeek),
|
|
|
/* harmony export */ jz: () => (/* binding */ durationMonth),
|
|
|
/* harmony export */ qz: () => (/* binding */ durationYear),
|
|
|
/* harmony export */ yB: () => (/* binding */ durationMinute)
|
|
|
/* harmony export */ });
|
|
|
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;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 75458:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ WQ: () => (/* binding */ timeHour),
|
|
|
/* harmony export */ lM: () => (/* binding */ utcHour)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeHours, utcHours */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
|
|
|
|
|
|
|
|
|
const timeHour = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setTime(date - date.getMilliseconds() - date.getSeconds() * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym - date.getMinutes() * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB);
|
|
|
}, (date, step) => {
|
|
|
date.setTime(+date + step * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2;
|
|
|
}, (date) => {
|
|
|
return date.getHours();
|
|
|
});
|
|
|
|
|
|
const timeHours = timeHour.range;
|
|
|
|
|
|
const utcHour = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setUTCMinutes(0, 0, 0);
|
|
|
}, (date, step) => {
|
|
|
date.setTime(+date + step * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2;
|
|
|
}, (date) => {
|
|
|
return date.getUTCHours();
|
|
|
});
|
|
|
|
|
|
const utcHours = utcHour.range;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 66712:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ J: () => (/* binding */ timeInterval)
|
|
|
/* harmony export */ });
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 17540:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ A: () => (/* binding */ millisecond)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export milliseconds */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
|
|
|
|
|
|
const millisecond = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)(() => {
|
|
|
// 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 (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 5957:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ Z_: () => (/* binding */ timeMinute),
|
|
|
/* harmony export */ rz: () => (/* binding */ utcMinute)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeMinutes, utcMinutes */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
|
|
|
|
|
|
|
|
|
const timeMinute = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setTime(date - date.getMilliseconds() - date.getSeconds() * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym);
|
|
|
}, (date, step) => {
|
|
|
date.setTime(+date + step * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB;
|
|
|
}, (date) => {
|
|
|
return date.getMinutes();
|
|
|
});
|
|
|
|
|
|
const timeMinutes = timeMinute.range;
|
|
|
|
|
|
const utcMinute = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setUTCSeconds(0, 0);
|
|
|
}, (date, step) => {
|
|
|
date.setTime(+date + step * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB;
|
|
|
}, (date) => {
|
|
|
return date.getUTCMinutes();
|
|
|
});
|
|
|
|
|
|
const utcMinutes = utcMinute.range;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 43155:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ F0: () => (/* binding */ timeMonth),
|
|
|
/* harmony export */ me: () => (/* binding */ utcMonth)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeMonths, utcMonths */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
|
|
|
|
|
|
const timeMonth = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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 = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 58887:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ E: () => (/* binding */ second)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export seconds */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
|
|
|
|
|
|
|
|
|
const second = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((date) => {
|
|
|
date.setTime(date - date.getMilliseconds());
|
|
|
}, (date, step) => {
|
|
|
date.setTime(+date + step * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym);
|
|
|
}, (start, end) => {
|
|
|
return (end - start) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym;
|
|
|
}, (date) => {
|
|
|
return date.getUTCSeconds();
|
|
|
});
|
|
|
|
|
|
const seconds = second.range;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 18744:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ WG: () => (/* binding */ utcTicks),
|
|
|
/* harmony export */ _g: () => (/* binding */ timeTickInterval),
|
|
|
/* harmony export */ jK: () => (/* binding */ timeTicks),
|
|
|
/* harmony export */ jo: () => (/* binding */ utcTickInterval)
|
|
|
/* harmony export */ });
|
|
|
/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2518);
|
|
|
/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(73002);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
/* harmony import */ var _millisecond_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(17540);
|
|
|
/* harmony import */ var _second_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(58887);
|
|
|
/* harmony import */ var _minute_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(5957);
|
|
|
/* harmony import */ var _hour_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(75458);
|
|
|
/* harmony import */ var _day_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(6054);
|
|
|
/* harmony import */ var _week_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(24645);
|
|
|
/* harmony import */ var _month_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(43155);
|
|
|
/* harmony import */ var _year_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(47878);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function ticker(year, month, week, day, hour, minute) {
|
|
|
|
|
|
const tickIntervals = [
|
|
|
[_second_js__WEBPACK_IMPORTED_MODULE_0__/* .second */ .E, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym],
|
|
|
[_second_js__WEBPACK_IMPORTED_MODULE_0__/* .second */ .E, 5, 5 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym],
|
|
|
[_second_js__WEBPACK_IMPORTED_MODULE_0__/* .second */ .E, 15, 15 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym],
|
|
|
[_second_js__WEBPACK_IMPORTED_MODULE_0__/* .second */ .E, 30, 30 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationSecond */ .Ym],
|
|
|
[minute, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB],
|
|
|
[minute, 5, 5 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB],
|
|
|
[minute, 15, 15 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB],
|
|
|
[minute, 30, 30 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB],
|
|
|
[ hour, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2 ],
|
|
|
[ hour, 3, 3 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2 ],
|
|
|
[ hour, 6, 6 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2 ],
|
|
|
[ hour, 12, 12 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationHour */ .Y2 ],
|
|
|
[ day, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD ],
|
|
|
[ day, 2, 2 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationDay */ .UD ],
|
|
|
[ week, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationWeek */ .iM ],
|
|
|
[ month, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMonth */ .jz ],
|
|
|
[ month, 3, 3 * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMonth */ .jz ],
|
|
|
[ year, 1, _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationYear */ .qz ]
|
|
|
];
|
|
|
|
|
|
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 = (0,d3_array__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z)(([,, step]) => step).right(tickIntervals, target);
|
|
|
if (i === tickIntervals.length) return year.every((0,d3_array__WEBPACK_IMPORTED_MODULE_3__/* .tickStep */ .ly)(start / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationYear */ .qz, stop / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationYear */ .qz, count));
|
|
|
if (i === 0) return _millisecond_js__WEBPACK_IMPORTED_MODULE_4__/* .millisecond */ .A.every(Math.max((0,d3_array__WEBPACK_IMPORTED_MODULE_3__/* .tickStep */ .ly)(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(_year_js__WEBPACK_IMPORTED_MODULE_5__/* .utcYear */ .ol, _month_js__WEBPACK_IMPORTED_MODULE_6__/* .utcMonth */ .me, _week_js__WEBPACK_IMPORTED_MODULE_7__/* .utcSunday */ .pI, _day_js__WEBPACK_IMPORTED_MODULE_8__/* .unixDay */ .KB, _hour_js__WEBPACK_IMPORTED_MODULE_9__/* .utcHour */ .lM, _minute_js__WEBPACK_IMPORTED_MODULE_10__/* .utcMinute */ .rz);
|
|
|
const [timeTicks, timeTickInterval] = ticker(_year_js__WEBPACK_IMPORTED_MODULE_5__/* .timeYear */ .jB, _month_js__WEBPACK_IMPORTED_MODULE_6__/* .timeMonth */ .F0, _week_js__WEBPACK_IMPORTED_MODULE_7__/* .timeSunday */ .Zy, _day_js__WEBPACK_IMPORTED_MODULE_8__/* .timeDay */ .rr, _hour_js__WEBPACK_IMPORTED_MODULE_9__/* .timeHour */ .WQ, _minute_js__WEBPACK_IMPORTED_MODULE_10__/* .timeMinute */ .Z_);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 24645:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ EF: () => (/* binding */ timeWednesday),
|
|
|
/* harmony export */ Ig: () => (/* binding */ timeThursday),
|
|
|
/* harmony export */ Lq: () => (/* binding */ timeSaturday),
|
|
|
/* harmony export */ Ox: () => (/* binding */ timeMonday),
|
|
|
/* harmony export */ YD: () => (/* binding */ timeTuesday),
|
|
|
/* harmony export */ Zy: () => (/* binding */ timeSunday),
|
|
|
/* harmony export */ hB: () => (/* binding */ utcThursday),
|
|
|
/* harmony export */ l6: () => (/* binding */ utcMonday),
|
|
|
/* harmony export */ pI: () => (/* binding */ utcSunday),
|
|
|
/* harmony export */ y2: () => (/* binding */ timeFriday)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeSundays, timeMondays, timeTuesdays, timeWednesdays, timeThursdays, timeFridays, timeSaturdays, utcTuesday, utcWednesday, utcFriday, utcSaturday, utcSundays, utcMondays, utcTuesdays, utcWednesdays, utcThursdays, utcFridays, utcSaturdays */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
/* harmony import */ var _duration_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45022);
|
|
|
|
|
|
|
|
|
|
|
|
function timeWeekday(i) {
|
|
|
return (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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()) * _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationMinute */ .yB) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationWeek */ .iM;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
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 (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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) / _duration_js__WEBPACK_IMPORTED_MODULE_1__/* .durationWeek */ .iM;
|
|
|
});
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 47878:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ jB: () => (/* binding */ timeYear),
|
|
|
/* harmony export */ ol: () => (/* binding */ utcYear)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony exports timeYears, utcYears */
|
|
|
/* harmony import */ var _interval_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66712);
|
|
|
|
|
|
|
|
|
const timeYear = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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 : (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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 = (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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 : (0,_interval_js__WEBPACK_IMPORTED_MODULE_0__/* .timeInterval */ .J)((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;
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 11647:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ B7: () => (/* binding */ Timer),
|
|
|
/* harmony export */ HT: () => (/* binding */ timer),
|
|
|
/* harmony export */ zO: () => (/* binding */ now)
|
|
|
/* harmony export */ });
|
|
|
/* unused harmony export timerFlush */
|
|
|
var frame = 0, // is an animation frame pending?
|
|
|
timeout = 0, // is a timeout pending?
|
|
|
interval = 0, // are any timers active?
|
|
|
pokeDelay = 1000, // how frequently we check for clock skew
|
|
|
taskHead,
|
|
|
taskTail,
|
|
|
clockLast = 0,
|
|
|
clockNow = 0,
|
|
|
clockSkew = 0,
|
|
|
clock = typeof performance === "object" && performance.now ? performance : Date,
|
|
|
setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };
|
|
|
|
|
|
function now() {
|
|
|
return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
|
|
|
}
|
|
|
|
|
|
function clearNow() {
|
|
|
clockNow = 0;
|
|
|
}
|
|
|
|
|
|
function Timer() {
|
|
|
this._call =
|
|
|
this._time =
|
|
|
this._next = null;
|
|
|
}
|
|
|
|
|
|
Timer.prototype = timer.prototype = {
|
|
|
constructor: Timer,
|
|
|
restart: function(callback, delay, time) {
|
|
|
if (typeof callback !== "function") throw new TypeError("callback is not a function");
|
|
|
time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
|
|
|
if (!this._next && taskTail !== this) {
|
|
|
if (taskTail) taskTail._next = this;
|
|
|
else taskHead = this;
|
|
|
taskTail = this;
|
|
|
}
|
|
|
this._call = callback;
|
|
|
this._time = time;
|
|
|
sleep();
|
|
|
},
|
|
|
stop: function() {
|
|
|
if (this._call) {
|
|
|
this._call = null;
|
|
|
this._time = Infinity;
|
|
|
sleep();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
function timer(callback, delay, time) {
|
|
|
var t = new Timer;
|
|
|
t.restart(callback, delay, time);
|
|
|
return t;
|
|
|
}
|
|
|
|
|
|
function timerFlush() {
|
|
|
now(); // Get the current time, if not already set.
|
|
|
++frame; // Pretend we’ve set an alarm, if we haven’t already.
|
|
|
var t = taskHead, e;
|
|
|
while (t) {
|
|
|
if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e);
|
|
|
t = t._next;
|
|
|
}
|
|
|
--frame;
|
|
|
}
|
|
|
|
|
|
function wake() {
|
|
|
clockNow = (clockLast = clock.now()) + clockSkew;
|
|
|
frame = timeout = 0;
|
|
|
try {
|
|
|
timerFlush();
|
|
|
} finally {
|
|
|
frame = 0;
|
|
|
nap();
|
|
|
clockNow = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function poke() {
|
|
|
var now = clock.now(), delay = now - clockLast;
|
|
|
if (delay > pokeDelay) clockSkew -= delay, clockLast = now;
|
|
|
}
|
|
|
|
|
|
function nap() {
|
|
|
var t0, t1 = taskHead, t2, time = Infinity;
|
|
|
while (t1) {
|
|
|
if (t1._call) {
|
|
|
if (time > t1._time) time = t1._time;
|
|
|
t0 = t1, t1 = t1._next;
|
|
|
} else {
|
|
|
t2 = t1._next, t1._next = null;
|
|
|
t1 = t0 ? t0._next = t2 : taskHead = t2;
|
|
|
}
|
|
|
}
|
|
|
taskTail = t0;
|
|
|
sleep(time);
|
|
|
}
|
|
|
|
|
|
function sleep(time) {
|
|
|
if (frame) return; // Soonest alarm already set, or will be.
|
|
|
if (timeout) timeout = clearTimeout(timeout);
|
|
|
var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
|
|
|
if (delay > 24) {
|
|
|
if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
|
|
|
if (interval) interval = clearInterval(interval);
|
|
|
} else {
|
|
|
if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
|
|
|
frame = 1, setFrame(wake);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
|
|
/***/ 18694:
|
|
|
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
|
|
|
|
|
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
|
|
|
/* harmony export */ H: () => (/* binding */ InternSet),
|
|
|
/* harmony export */ L: () => (/* binding */ InternMap)
|
|
|
/* harmony export */ });
|
|
|
class InternMap extends Map {
|
|
|
constructor(entries, key = keyof) {
|
|
|
super();
|
|
|
Object.defineProperties(this, {_intern: {value: new Map()}, _key: {value: key}});
|
|
|
if (entries != null) for (const [key, value] of entries) this.set(key, value);
|
|
|
}
|
|
|
get(key) {
|
|
|
return super.get(intern_get(this, key));
|
|
|
}
|
|
|
has(key) {
|
|
|
return super.has(intern_get(this, key));
|
|
|
}
|
|
|
set(key, value) {
|
|
|
return super.set(intern_set(this, key), value);
|
|
|
}
|
|
|
delete(key) {
|
|
|
return super.delete(intern_delete(this, key));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class InternSet extends Set {
|
|
|
constructor(values, key = keyof) {
|
|
|
super();
|
|
|
Object.defineProperties(this, {_intern: {value: new Map()}, _key: {value: key}});
|
|
|
if (values != null) for (const value of values) this.add(value);
|
|
|
}
|
|
|
has(value) {
|
|
|
return super.has(intern_get(this, value));
|
|
|
}
|
|
|
add(value) {
|
|
|
return super.add(intern_set(this, value));
|
|
|
}
|
|
|
delete(value) {
|
|
|
return super.delete(intern_delete(this, value));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
function intern_get({_intern, _key}, value) {
|
|
|
const key = _key(value);
|
|
|
return _intern.has(key) ? _intern.get(key) : value;
|
|
|
}
|
|
|
|
|
|
function intern_set({_intern, _key}, value) {
|
|
|
const key = _key(value);
|
|
|
if (_intern.has(key)) return _intern.get(key);
|
|
|
_intern.set(key, value);
|
|
|
return value;
|
|
|
}
|
|
|
|
|
|
function intern_delete({_intern, _key}, value) {
|
|
|
const key = _key(value);
|
|
|
if (_intern.has(key)) {
|
|
|
value = _intern.get(value);
|
|
|
_intern.delete(key);
|
|
|
}
|
|
|
return value;
|
|
|
}
|
|
|
|
|
|
function keyof(value) {
|
|
|
return value !== null && typeof value === "object" ? value.valueOf() : value;
|
|
|
}
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
|
|
}]);
|
|
|
//# sourceMappingURL=6577.203d60a6845c78be9991.js.map?v=203d60a6845c78be9991
|