6949 lines
240 KiB
JavaScript
6949 lines
240 KiB
JavaScript
import {
|
|
__commonJS,
|
|
__name,
|
|
__toESM
|
|
} from "./chunk-DLQEHMXD.mjs";
|
|
|
|
// ../../node_modules/.pnpm/dayjs@1.11.18/node_modules/dayjs/dayjs.min.js
|
|
var require_dayjs_min = __commonJS({
|
|
"../../node_modules/.pnpm/dayjs@1.11.18/node_modules/dayjs/dayjs.min.js"(exports, module) {
|
|
"use strict";
|
|
!(function(t, e) {
|
|
"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
|
|
})(exports, (function() {
|
|
"use strict";
|
|
var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y2 = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: /* @__PURE__ */ __name(function(t4) {
|
|
var e3 = ["th", "st", "nd", "rd"], n2 = t4 % 100;
|
|
return "[" + t4 + (e3[(n2 - 20) % 10] || e3[n2] || e3[0]) + "]";
|
|
}, "ordinal") }, m = /* @__PURE__ */ __name(function(t4, e3, n2) {
|
|
var r2 = String(t4);
|
|
return !r2 || r2.length >= e3 ? t4 : "" + Array(e3 + 1 - r2.length).join(n2) + t4;
|
|
}, "m"), v = { s: m, z: /* @__PURE__ */ __name(function(t4) {
|
|
var e3 = -t4.utcOffset(), n2 = Math.abs(e3), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
|
|
return (e3 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
|
|
}, "z"), m: /* @__PURE__ */ __name(function t4(e3, n2) {
|
|
if (e3.date() < n2.date()) return -t4(n2, e3);
|
|
var r2 = 12 * (n2.year() - e3.year()) + (n2.month() - e3.month()), i2 = e3.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e3.clone().add(r2 + (s2 ? -1 : 1), c);
|
|
return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
|
|
}, "t"), a: /* @__PURE__ */ __name(function(t4) {
|
|
return t4 < 0 ? Math.ceil(t4) || 0 : Math.floor(t4);
|
|
}, "a"), p: /* @__PURE__ */ __name(function(t4) {
|
|
return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t4] || String(t4 || "").toLowerCase().replace(/s$/, "");
|
|
}, "p"), u: /* @__PURE__ */ __name(function(t4) {
|
|
return void 0 === t4;
|
|
}, "u") }, g = "en", D = {};
|
|
D[g] = M;
|
|
var p = "$isDayjsObject", S = /* @__PURE__ */ __name(function(t4) {
|
|
return t4 instanceof _ || !(!t4 || !t4[p]);
|
|
}, "S"), w = /* @__PURE__ */ __name(function t4(e3, n2, r2) {
|
|
var i2;
|
|
if (!e3) return g;
|
|
if ("string" == typeof e3) {
|
|
var s2 = e3.toLowerCase();
|
|
D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
|
|
var u2 = e3.split("-");
|
|
if (!i2 && u2.length > 1) return t4(u2[0]);
|
|
} else {
|
|
var a2 = e3.name;
|
|
D[a2] = e3, i2 = a2;
|
|
}
|
|
return !r2 && i2 && (g = i2), i2 || !r2 && g;
|
|
}, "t"), O = /* @__PURE__ */ __name(function(t4, e3) {
|
|
if (S(t4)) return t4.clone();
|
|
var n2 = "object" == typeof e3 ? e3 : {};
|
|
return n2.date = t4, n2.args = arguments, new _(n2);
|
|
}, "O"), b = v;
|
|
b.l = w, b.i = S, b.w = function(t4, e3) {
|
|
return O(t4, { locale: e3.$L, utc: e3.$u, x: e3.$x, $offset: e3.$offset });
|
|
};
|
|
var _ = (function() {
|
|
function M2(t4) {
|
|
this.$L = w(t4.locale, null, true), this.parse(t4), this.$x = this.$x || t4.x || {}, this[p] = true;
|
|
}
|
|
__name(M2, "M");
|
|
var m2 = M2.prototype;
|
|
return m2.parse = function(t4) {
|
|
this.$d = (function(t5) {
|
|
var e3 = t5.date, n2 = t5.utc;
|
|
if (null === e3) return /* @__PURE__ */ new Date(NaN);
|
|
if (b.u(e3)) return /* @__PURE__ */ new Date();
|
|
if (e3 instanceof Date) return new Date(e3);
|
|
if ("string" == typeof e3 && !/Z$/i.test(e3)) {
|
|
var r2 = e3.match($);
|
|
if (r2) {
|
|
var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
|
|
return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
|
|
}
|
|
}
|
|
return new Date(e3);
|
|
})(t4), this.init();
|
|
}, m2.init = function() {
|
|
var t4 = this.$d;
|
|
this.$y = t4.getFullYear(), this.$M = t4.getMonth(), this.$D = t4.getDate(), this.$W = t4.getDay(), this.$H = t4.getHours(), this.$m = t4.getMinutes(), this.$s = t4.getSeconds(), this.$ms = t4.getMilliseconds();
|
|
}, m2.$utils = function() {
|
|
return b;
|
|
}, m2.isValid = function() {
|
|
return !(this.$d.toString() === l);
|
|
}, m2.isSame = function(t4, e3) {
|
|
var n2 = O(t4);
|
|
return this.startOf(e3) <= n2 && n2 <= this.endOf(e3);
|
|
}, m2.isAfter = function(t4, e3) {
|
|
return O(t4) < this.startOf(e3);
|
|
}, m2.isBefore = function(t4, e3) {
|
|
return this.endOf(e3) < O(t4);
|
|
}, m2.$g = function(t4, e3, n2) {
|
|
return b.u(t4) ? this[e3] : this.set(n2, t4);
|
|
}, m2.unix = function() {
|
|
return Math.floor(this.valueOf() / 1e3);
|
|
}, m2.valueOf = function() {
|
|
return this.$d.getTime();
|
|
}, m2.startOf = function(t4, e3) {
|
|
var n2 = this, r2 = !!b.u(e3) || e3, f2 = b.p(t4), l2 = /* @__PURE__ */ __name(function(t5, e4) {
|
|
var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e4, t5) : new Date(n2.$y, e4, t5), n2);
|
|
return r2 ? i2 : i2.endOf(a);
|
|
}, "l"), $2 = /* @__PURE__ */ __name(function(t5, e4) {
|
|
return b.w(n2.toDate()[t5].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e4)), n2);
|
|
}, "$"), y3 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
|
|
switch (f2) {
|
|
case h:
|
|
return r2 ? l2(1, 0) : l2(31, 11);
|
|
case c:
|
|
return r2 ? l2(1, M3) : l2(0, M3 + 1);
|
|
case o:
|
|
var g2 = this.$locale().weekStart || 0, D2 = (y3 < g2 ? y3 + 7 : y3) - g2;
|
|
return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
|
|
case a:
|
|
case d:
|
|
return $2(v2 + "Hours", 0);
|
|
case u:
|
|
return $2(v2 + "Minutes", 1);
|
|
case s:
|
|
return $2(v2 + "Seconds", 2);
|
|
case i:
|
|
return $2(v2 + "Milliseconds", 3);
|
|
default:
|
|
return this.clone();
|
|
}
|
|
}, m2.endOf = function(t4) {
|
|
return this.startOf(t4, false);
|
|
}, m2.$set = function(t4, e3) {
|
|
var n2, o2 = b.p(t4), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e3 - this.$W) : e3;
|
|
if (o2 === c || o2 === h) {
|
|
var y3 = this.clone().set(d, 1);
|
|
y3.$d[l2]($2), y3.init(), this.$d = y3.set(d, Math.min(this.$D, y3.daysInMonth())).$d;
|
|
} else l2 && this.$d[l2]($2);
|
|
return this.init(), this;
|
|
}, m2.set = function(t4, e3) {
|
|
return this.clone().$set(t4, e3);
|
|
}, m2.get = function(t4) {
|
|
return this[b.p(t4)]();
|
|
}, m2.add = function(r2, f2) {
|
|
var d2, l2 = this;
|
|
r2 = Number(r2);
|
|
var $2 = b.p(f2), y3 = /* @__PURE__ */ __name(function(t4) {
|
|
var e3 = O(l2);
|
|
return b.w(e3.date(e3.date() + Math.round(t4 * r2)), l2);
|
|
}, "y");
|
|
if ($2 === c) return this.set(c, this.$M + r2);
|
|
if ($2 === h) return this.set(h, this.$y + r2);
|
|
if ($2 === a) return y3(1);
|
|
if ($2 === o) return y3(7);
|
|
var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
|
|
return b.w(m3, this);
|
|
}, m2.subtract = function(t4, e3) {
|
|
return this.add(-1 * t4, e3);
|
|
}, m2.format = function(t4) {
|
|
var e3 = this, n2 = this.$locale();
|
|
if (!this.isValid()) return n2.invalidDate || l;
|
|
var r2 = t4 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = /* @__PURE__ */ __name(function(t5, n3, i3, s3) {
|
|
return t5 && (t5[n3] || t5(e3, r2)) || i3[n3].slice(0, s3);
|
|
}, "h"), d2 = /* @__PURE__ */ __name(function(t5) {
|
|
return b.s(s2 % 12 || 12, t5, "0");
|
|
}, "d"), $2 = f2 || function(t5, e4, n3) {
|
|
var r3 = t5 < 12 ? "AM" : "PM";
|
|
return n3 ? r3.toLowerCase() : r3;
|
|
};
|
|
return r2.replace(y2, (function(t5, r3) {
|
|
return r3 || (function(t6) {
|
|
switch (t6) {
|
|
case "YY":
|
|
return String(e3.$y).slice(-2);
|
|
case "YYYY":
|
|
return b.s(e3.$y, 4, "0");
|
|
case "M":
|
|
return a2 + 1;
|
|
case "MM":
|
|
return b.s(a2 + 1, 2, "0");
|
|
case "MMM":
|
|
return h2(n2.monthsShort, a2, c2, 3);
|
|
case "MMMM":
|
|
return h2(c2, a2);
|
|
case "D":
|
|
return e3.$D;
|
|
case "DD":
|
|
return b.s(e3.$D, 2, "0");
|
|
case "d":
|
|
return String(e3.$W);
|
|
case "dd":
|
|
return h2(n2.weekdaysMin, e3.$W, o2, 2);
|
|
case "ddd":
|
|
return h2(n2.weekdaysShort, e3.$W, o2, 3);
|
|
case "dddd":
|
|
return o2[e3.$W];
|
|
case "H":
|
|
return String(s2);
|
|
case "HH":
|
|
return b.s(s2, 2, "0");
|
|
case "h":
|
|
return d2(1);
|
|
case "hh":
|
|
return d2(2);
|
|
case "a":
|
|
return $2(s2, u2, true);
|
|
case "A":
|
|
return $2(s2, u2, false);
|
|
case "m":
|
|
return String(u2);
|
|
case "mm":
|
|
return b.s(u2, 2, "0");
|
|
case "s":
|
|
return String(e3.$s);
|
|
case "ss":
|
|
return b.s(e3.$s, 2, "0");
|
|
case "SSS":
|
|
return b.s(e3.$ms, 3, "0");
|
|
case "Z":
|
|
return i2;
|
|
}
|
|
return null;
|
|
})(t5) || i2.replace(":", "");
|
|
}));
|
|
}, m2.utcOffset = function() {
|
|
return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
|
|
}, m2.diff = function(r2, d2, l2) {
|
|
var $2, y3 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = /* @__PURE__ */ __name(function() {
|
|
return b.m(y3, m3);
|
|
}, "D");
|
|
switch (M3) {
|
|
case h:
|
|
$2 = D2() / 12;
|
|
break;
|
|
case c:
|
|
$2 = D2();
|
|
break;
|
|
case f:
|
|
$2 = D2() / 3;
|
|
break;
|
|
case o:
|
|
$2 = (g2 - v2) / 6048e5;
|
|
break;
|
|
case a:
|
|
$2 = (g2 - v2) / 864e5;
|
|
break;
|
|
case u:
|
|
$2 = g2 / n;
|
|
break;
|
|
case s:
|
|
$2 = g2 / e;
|
|
break;
|
|
case i:
|
|
$2 = g2 / t;
|
|
break;
|
|
default:
|
|
$2 = g2;
|
|
}
|
|
return l2 ? $2 : b.a($2);
|
|
}, m2.daysInMonth = function() {
|
|
return this.endOf(c).$D;
|
|
}, m2.$locale = function() {
|
|
return D[this.$L];
|
|
}, m2.locale = function(t4, e3) {
|
|
if (!t4) return this.$L;
|
|
var n2 = this.clone(), r2 = w(t4, e3, true);
|
|
return r2 && (n2.$L = r2), n2;
|
|
}, m2.clone = function() {
|
|
return b.w(this.$d, this);
|
|
}, m2.toDate = function() {
|
|
return new Date(this.valueOf());
|
|
}, m2.toJSON = function() {
|
|
return this.isValid() ? this.toISOString() : null;
|
|
}, m2.toISOString = function() {
|
|
return this.$d.toISOString();
|
|
}, m2.toString = function() {
|
|
return this.$d.toUTCString();
|
|
}, M2;
|
|
})(), k = _.prototype;
|
|
return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach((function(t4) {
|
|
k[t4[1]] = function(e3) {
|
|
return this.$g(e3, t4[0], t4[1]);
|
|
};
|
|
})), O.extend = function(t4, e3) {
|
|
return t4.$i || (t4(e3, _, O), t4.$i = true), O;
|
|
}, O.locale = w, O.isDayjs = S, O.unix = function(t4) {
|
|
return O(1e3 * t4);
|
|
}, O.en = D[g], O.Ls = D, O.p = {}, O;
|
|
}));
|
|
}
|
|
});
|
|
|
|
// src/logger.ts
|
|
var import_dayjs = __toESM(require_dayjs_min(), 1);
|
|
var LEVELS = {
|
|
trace: 0,
|
|
debug: 1,
|
|
info: 2,
|
|
warn: 3,
|
|
error: 4,
|
|
fatal: 5
|
|
};
|
|
var log = {
|
|
trace: /* @__PURE__ */ __name((..._args) => {
|
|
}, "trace"),
|
|
debug: /* @__PURE__ */ __name((..._args) => {
|
|
}, "debug"),
|
|
info: /* @__PURE__ */ __name((..._args) => {
|
|
}, "info"),
|
|
warn: /* @__PURE__ */ __name((..._args) => {
|
|
}, "warn"),
|
|
error: /* @__PURE__ */ __name((..._args) => {
|
|
}, "error"),
|
|
fatal: /* @__PURE__ */ __name((..._args) => {
|
|
}, "fatal")
|
|
};
|
|
var setLogLevel = /* @__PURE__ */ __name(function(level = "fatal") {
|
|
let numericLevel = LEVELS.fatal;
|
|
if (typeof level === "string") {
|
|
if (level.toLowerCase() in LEVELS) {
|
|
numericLevel = LEVELS[level];
|
|
}
|
|
} else if (typeof level === "number") {
|
|
numericLevel = level;
|
|
}
|
|
log.trace = () => {
|
|
};
|
|
log.debug = () => {
|
|
};
|
|
log.info = () => {
|
|
};
|
|
log.warn = () => {
|
|
};
|
|
log.error = () => {
|
|
};
|
|
log.fatal = () => {
|
|
};
|
|
if (numericLevel <= LEVELS.fatal) {
|
|
log.fatal = console.error ? console.error.bind(console, format("FATAL"), "color: orange") : console.log.bind(console, "\x1B[35m", format("FATAL"));
|
|
}
|
|
if (numericLevel <= LEVELS.error) {
|
|
log.error = console.error ? console.error.bind(console, format("ERROR"), "color: orange") : console.log.bind(console, "\x1B[31m", format("ERROR"));
|
|
}
|
|
if (numericLevel <= LEVELS.warn) {
|
|
log.warn = console.warn ? console.warn.bind(console, format("WARN"), "color: orange") : console.log.bind(console, `\x1B[33m`, format("WARN"));
|
|
}
|
|
if (numericLevel <= LEVELS.info) {
|
|
log.info = console.info ? console.info.bind(console, format("INFO"), "color: lightblue") : console.log.bind(console, "\x1B[34m", format("INFO"));
|
|
}
|
|
if (numericLevel <= LEVELS.debug) {
|
|
log.debug = console.debug ? console.debug.bind(console, format("DEBUG"), "color: lightgreen") : console.log.bind(console, "\x1B[32m", format("DEBUG"));
|
|
}
|
|
if (numericLevel <= LEVELS.trace) {
|
|
log.trace = console.debug ? console.debug.bind(console, format("TRACE"), "color: lightgreen") : console.log.bind(console, "\x1B[32m", format("TRACE"));
|
|
}
|
|
}, "setLogLevel");
|
|
var format = /* @__PURE__ */ __name((level) => {
|
|
const time2 = (0, import_dayjs.default)().format("ss.SSS");
|
|
return `%c${time2} : ${level} : `;
|
|
}, "format");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/max.js
|
|
function max(values, valueof) {
|
|
let max4;
|
|
if (valueof === void 0) {
|
|
for (const value of values) {
|
|
if (value != null && (max4 < value || max4 === void 0 && value >= value)) {
|
|
max4 = value;
|
|
}
|
|
}
|
|
} else {
|
|
let index = -1;
|
|
for (let value of values) {
|
|
if ((value = valueof(value, ++index, values)) != null && (max4 < value || max4 === void 0 && value >= value)) {
|
|
max4 = value;
|
|
}
|
|
}
|
|
}
|
|
return max4;
|
|
}
|
|
__name(max, "max");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/min.js
|
|
function min(values, valueof) {
|
|
let min4;
|
|
if (valueof === void 0) {
|
|
for (const value of values) {
|
|
if (value != null && (min4 > value || min4 === void 0 && value >= value)) {
|
|
min4 = value;
|
|
}
|
|
}
|
|
} else {
|
|
let index = -1;
|
|
for (let value of values) {
|
|
if ((value = valueof(value, ++index, values)) != null && (min4 > value || min4 === void 0 && value >= value)) {
|
|
min4 = value;
|
|
}
|
|
}
|
|
}
|
|
return min4;
|
|
}
|
|
__name(min, "min");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ascending.js
|
|
function ascending(a, b) {
|
|
return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
|
}
|
|
__name(ascending, "ascending");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/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;
|
|
}
|
|
__name(descending, "descending");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisector.js
|
|
function bisector(f) {
|
|
let compare1, compare2, delta;
|
|
if (f.length !== 2) {
|
|
compare1 = ascending;
|
|
compare2 = /* @__PURE__ */ __name((d, x2) => ascending(f(d), x2), "compare2");
|
|
delta = /* @__PURE__ */ __name((d, x2) => f(d) - x2, "delta");
|
|
} else {
|
|
compare1 = f === ascending || f === descending ? f : zero;
|
|
compare2 = f;
|
|
delta = f;
|
|
}
|
|
function left2(a, x2, lo = 0, hi = a.length) {
|
|
if (lo < hi) {
|
|
if (compare1(x2, x2) !== 0) return hi;
|
|
do {
|
|
const mid = lo + hi >>> 1;
|
|
if (compare2(a[mid], x2) < 0) lo = mid + 1;
|
|
else hi = mid;
|
|
} while (lo < hi);
|
|
}
|
|
return lo;
|
|
}
|
|
__name(left2, "left");
|
|
function right2(a, x2, lo = 0, hi = a.length) {
|
|
if (lo < hi) {
|
|
if (compare1(x2, x2) !== 0) return hi;
|
|
do {
|
|
const mid = lo + hi >>> 1;
|
|
if (compare2(a[mid], x2) <= 0) lo = mid + 1;
|
|
else hi = mid;
|
|
} while (lo < hi);
|
|
}
|
|
return lo;
|
|
}
|
|
__name(right2, "right");
|
|
function center2(a, x2, lo = 0, hi = a.length) {
|
|
const i = left2(a, x2, lo, hi - 1);
|
|
return i > lo && delta(a[i - 1], x2) > -delta(a[i], x2) ? i - 1 : i;
|
|
}
|
|
__name(center2, "center");
|
|
return { left: left2, center: center2, right: right2 };
|
|
}
|
|
__name(bisector, "bisector");
|
|
function zero() {
|
|
return 0;
|
|
}
|
|
__name(zero, "zero");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/number.js
|
|
function number(x2) {
|
|
return x2 === null ? NaN : +x2;
|
|
}
|
|
__name(number, "number");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
|
|
var ascendingBisect = bisector(ascending);
|
|
var bisectRight = ascendingBisect.right;
|
|
var bisectLeft = ascendingBisect.left;
|
|
var bisectCenter = bisector(number).center;
|
|
var bisect_default = bisectRight;
|
|
|
|
// ../../node_modules/.pnpm/internmap@2.0.3/node_modules/internmap/src/index.js
|
|
var InternMap = class extends Map {
|
|
static {
|
|
__name(this, "InternMap");
|
|
}
|
|
constructor(entries, key = keyof) {
|
|
super();
|
|
Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
|
|
if (entries != null) for (const [key2, value] of entries) this.set(key2, 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));
|
|
}
|
|
};
|
|
function intern_get({ _intern, _key }, value) {
|
|
const key = _key(value);
|
|
return _intern.has(key) ? _intern.get(key) : value;
|
|
}
|
|
__name(intern_get, "intern_get");
|
|
function intern_set({ _intern, _key }, value) {
|
|
const key = _key(value);
|
|
if (_intern.has(key)) return _intern.get(key);
|
|
_intern.set(key, value);
|
|
return value;
|
|
}
|
|
__name(intern_set, "intern_set");
|
|
function intern_delete({ _intern, _key }, value) {
|
|
const key = _key(value);
|
|
if (_intern.has(key)) {
|
|
value = _intern.get(key);
|
|
_intern.delete(key);
|
|
}
|
|
return value;
|
|
}
|
|
__name(intern_delete, "intern_delete");
|
|
function keyof(value) {
|
|
return value !== null && typeof value === "object" ? value.valueOf() : value;
|
|
}
|
|
__name(keyof, "keyof");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ticks.js
|
|
var e10 = Math.sqrt(50);
|
|
var e5 = Math.sqrt(10);
|
|
var e2 = Math.sqrt(2);
|
|
function tickSpec(start2, stop, count2) {
|
|
const step = (stop - start2) / Math.max(0, count2), 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(start2 * inc);
|
|
i2 = Math.round(stop * inc);
|
|
if (i1 / inc < start2) ++i1;
|
|
if (i2 / inc > stop) --i2;
|
|
inc = -inc;
|
|
} else {
|
|
inc = Math.pow(10, power) * factor;
|
|
i1 = Math.round(start2 / inc);
|
|
i2 = Math.round(stop / inc);
|
|
if (i1 * inc < start2) ++i1;
|
|
if (i2 * inc > stop) --i2;
|
|
}
|
|
if (i2 < i1 && 0.5 <= count2 && count2 < 2) return tickSpec(start2, stop, count2 * 2);
|
|
return [i1, i2, inc];
|
|
}
|
|
__name(tickSpec, "tickSpec");
|
|
function ticks(start2, stop, count2) {
|
|
stop = +stop, start2 = +start2, count2 = +count2;
|
|
if (!(count2 > 0)) return [];
|
|
if (start2 === stop) return [start2];
|
|
const reverse = stop < start2, [i1, i2, inc] = reverse ? tickSpec(stop, start2, count2) : tickSpec(start2, stop, count2);
|
|
if (!(i2 >= i1)) return [];
|
|
const n = i2 - i1 + 1, ticks2 = new Array(n);
|
|
if (reverse) {
|
|
if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) / -inc;
|
|
else for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) * inc;
|
|
} else {
|
|
if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) / -inc;
|
|
else for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) * inc;
|
|
}
|
|
return ticks2;
|
|
}
|
|
__name(ticks, "ticks");
|
|
function tickIncrement(start2, stop, count2) {
|
|
stop = +stop, start2 = +start2, count2 = +count2;
|
|
return tickSpec(start2, stop, count2)[2];
|
|
}
|
|
__name(tickIncrement, "tickIncrement");
|
|
function tickStep(start2, stop, count2) {
|
|
stop = +stop, start2 = +start2, count2 = +count2;
|
|
const reverse = stop < start2, inc = reverse ? tickIncrement(stop, start2, count2) : tickIncrement(start2, stop, count2);
|
|
return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
|
|
}
|
|
__name(tickStep, "tickStep");
|
|
|
|
// ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/range.js
|
|
function range(start2, stop, step) {
|
|
start2 = +start2, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start2, start2 = 0, 1) : n < 3 ? 1 : +step;
|
|
var i = -1, n = Math.max(0, Math.ceil((stop - start2) / step)) | 0, range2 = new Array(n);
|
|
while (++i < n) {
|
|
range2[i] = start2 + i * step;
|
|
}
|
|
return range2;
|
|
}
|
|
__name(range, "range");
|
|
|
|
// ../../node_modules/.pnpm/d3-axis@3.0.0/node_modules/d3-axis/src/identity.js
|
|
function identity_default(x2) {
|
|
return x2;
|
|
}
|
|
__name(identity_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-axis@3.0.0/node_modules/d3-axis/src/axis.js
|
|
var top = 1;
|
|
var right = 2;
|
|
var bottom = 3;
|
|
var left = 4;
|
|
var epsilon = 1e-6;
|
|
function translateX(x2) {
|
|
return "translate(" + x2 + ",0)";
|
|
}
|
|
__name(translateX, "translateX");
|
|
function translateY(y2) {
|
|
return "translate(0," + y2 + ")";
|
|
}
|
|
__name(translateY, "translateY");
|
|
function number2(scale) {
|
|
return (d) => +scale(d);
|
|
}
|
|
__name(number2, "number");
|
|
function center(scale, offset) {
|
|
offset = Math.max(0, scale.bandwidth() - offset * 2) / 2;
|
|
if (scale.round()) offset = Math.round(offset);
|
|
return (d) => +scale(d) + offset;
|
|
}
|
|
__name(center, "center");
|
|
function entering() {
|
|
return !this.__axis;
|
|
}
|
|
__name(entering, "entering");
|
|
function axis(orient, scale) {
|
|
var tickArguments = [], tickValues = null, tickFormat2 = null, tickSizeInner = 6, tickSizeOuter = 6, tickPadding = 3, offset = typeof window !== "undefined" && window.devicePixelRatio > 1 ? 0 : 0.5, k = orient === top || orient === left ? -1 : 1, x2 = orient === left || orient === right ? "x" : "y", transform2 = orient === top || orient === bottom ? translateX : translateY;
|
|
function axis2(context) {
|
|
var values = tickValues == null ? scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain() : tickValues, format3 = tickFormat2 == null ? scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity_default : tickFormat2, spacing = Math.max(tickSizeInner, 0) + tickPadding, range2 = scale.range(), range0 = +range2[0] + offset, range1 = +range2[range2.length - 1] + offset, position = (scale.bandwidth ? center : number2)(scale.copy(), offset), selection2 = context.selection ? context.selection() : context, path2 = selection2.selectAll(".domain").data([null]), tick = selection2.selectAll(".tick").data(values, scale).order(), tickExit = tick.exit(), tickEnter = tick.enter().append("g").attr("class", "tick"), line = tick.select("line"), text = tick.select("text");
|
|
path2 = path2.merge(path2.enter().insert("path", ".tick").attr("class", "domain").attr("stroke", "currentColor"));
|
|
tick = tick.merge(tickEnter);
|
|
line = line.merge(tickEnter.append("line").attr("stroke", "currentColor").attr(x2 + "2", k * tickSizeInner));
|
|
text = text.merge(tickEnter.append("text").attr("fill", "currentColor").attr(x2, k * spacing).attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em"));
|
|
if (context !== selection2) {
|
|
path2 = path2.transition(context);
|
|
tick = tick.transition(context);
|
|
line = line.transition(context);
|
|
text = text.transition(context);
|
|
tickExit = tickExit.transition(context).attr("opacity", epsilon).attr("transform", function(d) {
|
|
return isFinite(d = position(d)) ? transform2(d + offset) : this.getAttribute("transform");
|
|
});
|
|
tickEnter.attr("opacity", epsilon).attr("transform", function(d) {
|
|
var p = this.parentNode.__axis;
|
|
return transform2((p && isFinite(p = p(d)) ? p : position(d)) + offset);
|
|
});
|
|
}
|
|
tickExit.remove();
|
|
path2.attr("d", orient === left || orient === right ? tickSizeOuter ? "M" + k * tickSizeOuter + "," + range0 + "H" + offset + "V" + range1 + "H" + k * tickSizeOuter : "M" + offset + "," + range0 + "V" + range1 : tickSizeOuter ? "M" + range0 + "," + k * tickSizeOuter + "V" + offset + "H" + range1 + "V" + k * tickSizeOuter : "M" + range0 + "," + offset + "H" + range1);
|
|
tick.attr("opacity", 1).attr("transform", function(d) {
|
|
return transform2(position(d) + offset);
|
|
});
|
|
line.attr(x2 + "2", k * tickSizeInner);
|
|
text.attr(x2, k * spacing).text(format3);
|
|
selection2.filter(entering).attr("fill", "none").attr("font-size", 10).attr("font-family", "sans-serif").attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle");
|
|
selection2.each(function() {
|
|
this.__axis = position;
|
|
});
|
|
}
|
|
__name(axis2, "axis");
|
|
axis2.scale = function(_) {
|
|
return arguments.length ? (scale = _, axis2) : scale;
|
|
};
|
|
axis2.ticks = function() {
|
|
return tickArguments = Array.from(arguments), axis2;
|
|
};
|
|
axis2.tickArguments = function(_) {
|
|
return arguments.length ? (tickArguments = _ == null ? [] : Array.from(_), axis2) : tickArguments.slice();
|
|
};
|
|
axis2.tickValues = function(_) {
|
|
return arguments.length ? (tickValues = _ == null ? null : Array.from(_), axis2) : tickValues && tickValues.slice();
|
|
};
|
|
axis2.tickFormat = function(_) {
|
|
return arguments.length ? (tickFormat2 = _, axis2) : tickFormat2;
|
|
};
|
|
axis2.tickSize = function(_) {
|
|
return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis2) : tickSizeInner;
|
|
};
|
|
axis2.tickSizeInner = function(_) {
|
|
return arguments.length ? (tickSizeInner = +_, axis2) : tickSizeInner;
|
|
};
|
|
axis2.tickSizeOuter = function(_) {
|
|
return arguments.length ? (tickSizeOuter = +_, axis2) : tickSizeOuter;
|
|
};
|
|
axis2.tickPadding = function(_) {
|
|
return arguments.length ? (tickPadding = +_, axis2) : tickPadding;
|
|
};
|
|
axis2.offset = function(_) {
|
|
return arguments.length ? (offset = +_, axis2) : offset;
|
|
};
|
|
return axis2;
|
|
}
|
|
__name(axis, "axis");
|
|
function axisTop(scale) {
|
|
return axis(top, scale);
|
|
}
|
|
__name(axisTop, "axisTop");
|
|
function axisBottom(scale) {
|
|
return axis(bottom, scale);
|
|
}
|
|
__name(axisBottom, "axisBottom");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selector.js
|
|
function none() {
|
|
}
|
|
__name(none, "none");
|
|
function selector_default(selector) {
|
|
return selector == null ? none : function() {
|
|
return this.querySelector(selector);
|
|
};
|
|
}
|
|
__name(selector_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/select.js
|
|
function select_default(select) {
|
|
if (typeof select !== "function") select = selector_default(select);
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
|
|
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
|
|
if ("__data__" in node) subnode.__data__ = node.__data__;
|
|
subgroup[i] = subnode;
|
|
}
|
|
}
|
|
}
|
|
return new Selection(subgroups, this._parents);
|
|
}
|
|
__name(select_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/array.js
|
|
function array(x2) {
|
|
return x2 == null ? [] : Array.isArray(x2) ? x2 : Array.from(x2);
|
|
}
|
|
__name(array, "array");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selectorAll.js
|
|
function empty() {
|
|
return [];
|
|
}
|
|
__name(empty, "empty");
|
|
function selectorAll_default(selector) {
|
|
return selector == null ? empty : function() {
|
|
return this.querySelectorAll(selector);
|
|
};
|
|
}
|
|
__name(selectorAll_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/selectAll.js
|
|
function arrayAll(select) {
|
|
return function() {
|
|
return array(select.apply(this, arguments));
|
|
};
|
|
}
|
|
__name(arrayAll, "arrayAll");
|
|
function selectAll_default(select) {
|
|
if (typeof select === "function") select = arrayAll(select);
|
|
else select = selectorAll_default(select);
|
|
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
|
|
if (node = group[i]) {
|
|
subgroups.push(select.call(node, node.__data__, i, group));
|
|
parents.push(node);
|
|
}
|
|
}
|
|
}
|
|
return new Selection(subgroups, parents);
|
|
}
|
|
__name(selectAll_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/matcher.js
|
|
function matcher_default(selector) {
|
|
return function() {
|
|
return this.matches(selector);
|
|
};
|
|
}
|
|
__name(matcher_default, "default");
|
|
function childMatcher(selector) {
|
|
return function(node) {
|
|
return node.matches(selector);
|
|
};
|
|
}
|
|
__name(childMatcher, "childMatcher");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/selectChild.js
|
|
var find = Array.prototype.find;
|
|
function childFind(match) {
|
|
return function() {
|
|
return find.call(this.children, match);
|
|
};
|
|
}
|
|
__name(childFind, "childFind");
|
|
function childFirst() {
|
|
return this.firstElementChild;
|
|
}
|
|
__name(childFirst, "childFirst");
|
|
function selectChild_default(match) {
|
|
return this.select(match == null ? childFirst : childFind(typeof match === "function" ? match : childMatcher(match)));
|
|
}
|
|
__name(selectChild_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/selectChildren.js
|
|
var filter = Array.prototype.filter;
|
|
function children() {
|
|
return Array.from(this.children);
|
|
}
|
|
__name(children, "children");
|
|
function childrenFilter(match) {
|
|
return function() {
|
|
return filter.call(this.children, match);
|
|
};
|
|
}
|
|
__name(childrenFilter, "childrenFilter");
|
|
function selectChildren_default(match) {
|
|
return this.selectAll(match == null ? children : childrenFilter(typeof match === "function" ? match : childMatcher(match)));
|
|
}
|
|
__name(selectChildren_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/filter.js
|
|
function filter_default(match) {
|
|
if (typeof match !== "function") match = matcher_default(match);
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
|
|
if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
|
|
subgroup.push(node);
|
|
}
|
|
}
|
|
}
|
|
return new Selection(subgroups, this._parents);
|
|
}
|
|
__name(filter_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/sparse.js
|
|
function sparse_default(update) {
|
|
return new Array(update.length);
|
|
}
|
|
__name(sparse_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/enter.js
|
|
function enter_default() {
|
|
return new Selection(this._enter || this._groups.map(sparse_default), this._parents);
|
|
}
|
|
__name(enter_default, "default");
|
|
function EnterNode(parent, datum2) {
|
|
this.ownerDocument = parent.ownerDocument;
|
|
this.namespaceURI = parent.namespaceURI;
|
|
this._next = null;
|
|
this._parent = parent;
|
|
this.__data__ = datum2;
|
|
}
|
|
__name(EnterNode, "EnterNode");
|
|
EnterNode.prototype = {
|
|
constructor: EnterNode,
|
|
appendChild: /* @__PURE__ */ __name(function(child) {
|
|
return this._parent.insertBefore(child, this._next);
|
|
}, "appendChild"),
|
|
insertBefore: /* @__PURE__ */ __name(function(child, next) {
|
|
return this._parent.insertBefore(child, next);
|
|
}, "insertBefore"),
|
|
querySelector: /* @__PURE__ */ __name(function(selector) {
|
|
return this._parent.querySelector(selector);
|
|
}, "querySelector"),
|
|
querySelectorAll: /* @__PURE__ */ __name(function(selector) {
|
|
return this._parent.querySelectorAll(selector);
|
|
}, "querySelectorAll")
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/constant.js
|
|
function constant_default(x2) {
|
|
return function() {
|
|
return x2;
|
|
};
|
|
}
|
|
__name(constant_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/data.js
|
|
function bindIndex(parent, group, enter, update, exit, data) {
|
|
var i = 0, node, groupLength = group.length, dataLength = data.length;
|
|
for (; i < dataLength; ++i) {
|
|
if (node = group[i]) {
|
|
node.__data__ = data[i];
|
|
update[i] = node;
|
|
} else {
|
|
enter[i] = new EnterNode(parent, data[i]);
|
|
}
|
|
}
|
|
for (; i < groupLength; ++i) {
|
|
if (node = group[i]) {
|
|
exit[i] = node;
|
|
}
|
|
}
|
|
}
|
|
__name(bindIndex, "bindIndex");
|
|
function bindKey(parent, group, enter, update, exit, data, key) {
|
|
var i, node, nodeByKeyValue = /* @__PURE__ */ new Map(), groupLength = group.length, dataLength = data.length, keyValues = new Array(groupLength), keyValue;
|
|
for (i = 0; i < groupLength; ++i) {
|
|
if (node = group[i]) {
|
|
keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + "";
|
|
if (nodeByKeyValue.has(keyValue)) {
|
|
exit[i] = node;
|
|
} else {
|
|
nodeByKeyValue.set(keyValue, node);
|
|
}
|
|
}
|
|
}
|
|
for (i = 0; i < dataLength; ++i) {
|
|
keyValue = key.call(parent, data[i], i, data) + "";
|
|
if (node = nodeByKeyValue.get(keyValue)) {
|
|
update[i] = node;
|
|
node.__data__ = data[i];
|
|
nodeByKeyValue.delete(keyValue);
|
|
} else {
|
|
enter[i] = new EnterNode(parent, data[i]);
|
|
}
|
|
}
|
|
for (i = 0; i < groupLength; ++i) {
|
|
if ((node = group[i]) && nodeByKeyValue.get(keyValues[i]) === node) {
|
|
exit[i] = node;
|
|
}
|
|
}
|
|
}
|
|
__name(bindKey, "bindKey");
|
|
function datum(node) {
|
|
return node.__data__;
|
|
}
|
|
__name(datum, "datum");
|
|
function data_default(value, key) {
|
|
if (!arguments.length) return Array.from(this, datum);
|
|
var bind = key ? bindKey : bindIndex, parents = this._parents, groups = this._groups;
|
|
if (typeof value !== "function") value = constant_default(value);
|
|
for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
|
|
var parent = parents[j], group = groups[j], groupLength = group.length, data = arraylike(value.call(parent, parent && parent.__data__, j, parents)), dataLength = data.length, enterGroup = enter[j] = new Array(dataLength), updateGroup = update[j] = new Array(dataLength), exitGroup = exit[j] = new Array(groupLength);
|
|
bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
|
|
for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
|
|
if (previous = enterGroup[i0]) {
|
|
if (i0 >= i1) i1 = i0 + 1;
|
|
while (!(next = updateGroup[i1]) && ++i1 < dataLength) ;
|
|
previous._next = next || null;
|
|
}
|
|
}
|
|
}
|
|
update = new Selection(update, parents);
|
|
update._enter = enter;
|
|
update._exit = exit;
|
|
return update;
|
|
}
|
|
__name(data_default, "default");
|
|
function arraylike(data) {
|
|
return typeof data === "object" && "length" in data ? data : Array.from(data);
|
|
}
|
|
__name(arraylike, "arraylike");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/exit.js
|
|
function exit_default() {
|
|
return new Selection(this._exit || this._groups.map(sparse_default), this._parents);
|
|
}
|
|
__name(exit_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/join.js
|
|
function join_default(onenter, onupdate, onexit) {
|
|
var enter = this.enter(), update = this, exit = this.exit();
|
|
if (typeof onenter === "function") {
|
|
enter = onenter(enter);
|
|
if (enter) enter = enter.selection();
|
|
} else {
|
|
enter = enter.append(onenter + "");
|
|
}
|
|
if (onupdate != null) {
|
|
update = onupdate(update);
|
|
if (update) update = update.selection();
|
|
}
|
|
if (onexit == null) exit.remove();
|
|
else onexit(exit);
|
|
return enter && update ? enter.merge(update).order() : update;
|
|
}
|
|
__name(join_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/merge.js
|
|
function merge_default(context) {
|
|
var selection2 = context.selection ? context.selection() : context;
|
|
for (var groups0 = this._groups, groups1 = selection2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
|
|
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
|
|
if (node = group0[i] || group1[i]) {
|
|
merge[i] = node;
|
|
}
|
|
}
|
|
}
|
|
for (; j < m0; ++j) {
|
|
merges[j] = groups0[j];
|
|
}
|
|
return new Selection(merges, this._parents);
|
|
}
|
|
__name(merge_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/order.js
|
|
function order_default() {
|
|
for (var groups = this._groups, j = -1, m = groups.length; ++j < m; ) {
|
|
for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
|
|
if (node = group[i]) {
|
|
if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
|
|
next = node;
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
__name(order_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/sort.js
|
|
function sort_default(compare) {
|
|
if (!compare) compare = ascending2;
|
|
function compareNode(a, b) {
|
|
return a && b ? compare(a.__data__, b.__data__) : !a - !b;
|
|
}
|
|
__name(compareNode, "compareNode");
|
|
for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
|
|
if (node = group[i]) {
|
|
sortgroup[i] = node;
|
|
}
|
|
}
|
|
sortgroup.sort(compareNode);
|
|
}
|
|
return new Selection(sortgroups, this._parents).order();
|
|
}
|
|
__name(sort_default, "default");
|
|
function ascending2(a, b) {
|
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
|
}
|
|
__name(ascending2, "ascending");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/call.js
|
|
function call_default() {
|
|
var callback = arguments[0];
|
|
arguments[0] = this;
|
|
callback.apply(null, arguments);
|
|
return this;
|
|
}
|
|
__name(call_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/nodes.js
|
|
function nodes_default() {
|
|
return Array.from(this);
|
|
}
|
|
__name(nodes_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/node.js
|
|
function node_default() {
|
|
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
|
|
for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
|
|
var node = group[i];
|
|
if (node) return node;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
__name(node_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/size.js
|
|
function size_default() {
|
|
let size = 0;
|
|
for (const node of this) ++size;
|
|
return size;
|
|
}
|
|
__name(size_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/empty.js
|
|
function empty_default() {
|
|
return !this.node();
|
|
}
|
|
__name(empty_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/each.js
|
|
function each_default(callback) {
|
|
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
|
|
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
|
|
if (node = group[i]) callback.call(node, node.__data__, i, group);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
__name(each_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/namespaces.js
|
|
var xhtml = "http://www.w3.org/1999/xhtml";
|
|
var namespaces_default = {
|
|
svg: "http://www.w3.org/2000/svg",
|
|
xhtml,
|
|
xlink: "http://www.w3.org/1999/xlink",
|
|
xml: "http://www.w3.org/XML/1998/namespace",
|
|
xmlns: "http://www.w3.org/2000/xmlns/"
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/namespace.js
|
|
function namespace_default(name) {
|
|
var prefix = name += "", i = prefix.indexOf(":");
|
|
if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
|
|
return namespaces_default.hasOwnProperty(prefix) ? { space: namespaces_default[prefix], local: name } : name;
|
|
}
|
|
__name(namespace_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/attr.js
|
|
function attrRemove(name) {
|
|
return function() {
|
|
this.removeAttribute(name);
|
|
};
|
|
}
|
|
__name(attrRemove, "attrRemove");
|
|
function attrRemoveNS(fullname) {
|
|
return function() {
|
|
this.removeAttributeNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
__name(attrRemoveNS, "attrRemoveNS");
|
|
function attrConstant(name, value) {
|
|
return function() {
|
|
this.setAttribute(name, value);
|
|
};
|
|
}
|
|
__name(attrConstant, "attrConstant");
|
|
function attrConstantNS(fullname, value) {
|
|
return function() {
|
|
this.setAttributeNS(fullname.space, fullname.local, value);
|
|
};
|
|
}
|
|
__name(attrConstantNS, "attrConstantNS");
|
|
function attrFunction(name, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
if (v == null) this.removeAttribute(name);
|
|
else this.setAttribute(name, v);
|
|
};
|
|
}
|
|
__name(attrFunction, "attrFunction");
|
|
function attrFunctionNS(fullname, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
|
|
else this.setAttributeNS(fullname.space, fullname.local, v);
|
|
};
|
|
}
|
|
__name(attrFunctionNS, "attrFunctionNS");
|
|
function attr_default(name, value) {
|
|
var fullname = namespace_default(name);
|
|
if (arguments.length < 2) {
|
|
var node = this.node();
|
|
return fullname.local ? node.getAttributeNS(fullname.space, fullname.local) : node.getAttribute(fullname);
|
|
}
|
|
return this.each((value == null ? fullname.local ? attrRemoveNS : attrRemove : typeof value === "function" ? fullname.local ? attrFunctionNS : attrFunction : fullname.local ? attrConstantNS : attrConstant)(fullname, value));
|
|
}
|
|
__name(attr_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/window.js
|
|
function window_default(node) {
|
|
return node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView;
|
|
}
|
|
__name(window_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/style.js
|
|
function styleRemove(name) {
|
|
return function() {
|
|
this.style.removeProperty(name);
|
|
};
|
|
}
|
|
__name(styleRemove, "styleRemove");
|
|
function styleConstant(name, value, priority) {
|
|
return function() {
|
|
this.style.setProperty(name, value, priority);
|
|
};
|
|
}
|
|
__name(styleConstant, "styleConstant");
|
|
function styleFunction(name, value, priority) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
if (v == null) this.style.removeProperty(name);
|
|
else this.style.setProperty(name, v, priority);
|
|
};
|
|
}
|
|
__name(styleFunction, "styleFunction");
|
|
function style_default(name, value, priority) {
|
|
return arguments.length > 1 ? this.each((value == null ? styleRemove : typeof value === "function" ? styleFunction : styleConstant)(name, value, priority == null ? "" : priority)) : styleValue(this.node(), name);
|
|
}
|
|
__name(style_default, "default");
|
|
function styleValue(node, name) {
|
|
return node.style.getPropertyValue(name) || window_default(node).getComputedStyle(node, null).getPropertyValue(name);
|
|
}
|
|
__name(styleValue, "styleValue");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/property.js
|
|
function propertyRemove(name) {
|
|
return function() {
|
|
delete this[name];
|
|
};
|
|
}
|
|
__name(propertyRemove, "propertyRemove");
|
|
function propertyConstant(name, value) {
|
|
return function() {
|
|
this[name] = value;
|
|
};
|
|
}
|
|
__name(propertyConstant, "propertyConstant");
|
|
function propertyFunction(name, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
if (v == null) delete this[name];
|
|
else this[name] = v;
|
|
};
|
|
}
|
|
__name(propertyFunction, "propertyFunction");
|
|
function property_default(name, value) {
|
|
return arguments.length > 1 ? this.each((value == null ? propertyRemove : typeof value === "function" ? propertyFunction : propertyConstant)(name, value)) : this.node()[name];
|
|
}
|
|
__name(property_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/classed.js
|
|
function classArray(string) {
|
|
return string.trim().split(/^|\s+/);
|
|
}
|
|
__name(classArray, "classArray");
|
|
function classList(node) {
|
|
return node.classList || new ClassList(node);
|
|
}
|
|
__name(classList, "classList");
|
|
function ClassList(node) {
|
|
this._node = node;
|
|
this._names = classArray(node.getAttribute("class") || "");
|
|
}
|
|
__name(ClassList, "ClassList");
|
|
ClassList.prototype = {
|
|
add: /* @__PURE__ */ __name(function(name) {
|
|
var i = this._names.indexOf(name);
|
|
if (i < 0) {
|
|
this._names.push(name);
|
|
this._node.setAttribute("class", this._names.join(" "));
|
|
}
|
|
}, "add"),
|
|
remove: /* @__PURE__ */ __name(function(name) {
|
|
var i = this._names.indexOf(name);
|
|
if (i >= 0) {
|
|
this._names.splice(i, 1);
|
|
this._node.setAttribute("class", this._names.join(" "));
|
|
}
|
|
}, "remove"),
|
|
contains: /* @__PURE__ */ __name(function(name) {
|
|
return this._names.indexOf(name) >= 0;
|
|
}, "contains")
|
|
};
|
|
function classedAdd(node, names) {
|
|
var list = classList(node), i = -1, n = names.length;
|
|
while (++i < n) list.add(names[i]);
|
|
}
|
|
__name(classedAdd, "classedAdd");
|
|
function classedRemove(node, names) {
|
|
var list = classList(node), i = -1, n = names.length;
|
|
while (++i < n) list.remove(names[i]);
|
|
}
|
|
__name(classedRemove, "classedRemove");
|
|
function classedTrue(names) {
|
|
return function() {
|
|
classedAdd(this, names);
|
|
};
|
|
}
|
|
__name(classedTrue, "classedTrue");
|
|
function classedFalse(names) {
|
|
return function() {
|
|
classedRemove(this, names);
|
|
};
|
|
}
|
|
__name(classedFalse, "classedFalse");
|
|
function classedFunction(names, value) {
|
|
return function() {
|
|
(value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
|
|
};
|
|
}
|
|
__name(classedFunction, "classedFunction");
|
|
function classed_default(name, value) {
|
|
var names = classArray(name + "");
|
|
if (arguments.length < 2) {
|
|
var list = classList(this.node()), i = -1, n = names.length;
|
|
while (++i < n) if (!list.contains(names[i])) return false;
|
|
return true;
|
|
}
|
|
return this.each((typeof value === "function" ? classedFunction : value ? classedTrue : classedFalse)(names, value));
|
|
}
|
|
__name(classed_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/text.js
|
|
function textRemove() {
|
|
this.textContent = "";
|
|
}
|
|
__name(textRemove, "textRemove");
|
|
function textConstant(value) {
|
|
return function() {
|
|
this.textContent = value;
|
|
};
|
|
}
|
|
__name(textConstant, "textConstant");
|
|
function textFunction(value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
this.textContent = v == null ? "" : v;
|
|
};
|
|
}
|
|
__name(textFunction, "textFunction");
|
|
function text_default(value) {
|
|
return arguments.length ? this.each(value == null ? textRemove : (typeof value === "function" ? textFunction : textConstant)(value)) : this.node().textContent;
|
|
}
|
|
__name(text_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/html.js
|
|
function htmlRemove() {
|
|
this.innerHTML = "";
|
|
}
|
|
__name(htmlRemove, "htmlRemove");
|
|
function htmlConstant(value) {
|
|
return function() {
|
|
this.innerHTML = value;
|
|
};
|
|
}
|
|
__name(htmlConstant, "htmlConstant");
|
|
function htmlFunction(value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
this.innerHTML = v == null ? "" : v;
|
|
};
|
|
}
|
|
__name(htmlFunction, "htmlFunction");
|
|
function html_default(value) {
|
|
return arguments.length ? this.each(value == null ? htmlRemove : (typeof value === "function" ? htmlFunction : htmlConstant)(value)) : this.node().innerHTML;
|
|
}
|
|
__name(html_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/raise.js
|
|
function raise() {
|
|
if (this.nextSibling) this.parentNode.appendChild(this);
|
|
}
|
|
__name(raise, "raise");
|
|
function raise_default() {
|
|
return this.each(raise);
|
|
}
|
|
__name(raise_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/lower.js
|
|
function lower() {
|
|
if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
|
|
}
|
|
__name(lower, "lower");
|
|
function lower_default() {
|
|
return this.each(lower);
|
|
}
|
|
__name(lower_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/creator.js
|
|
function creatorInherit(name) {
|
|
return function() {
|
|
var document2 = this.ownerDocument, uri = this.namespaceURI;
|
|
return uri === xhtml && document2.documentElement.namespaceURI === xhtml ? document2.createElement(name) : document2.createElementNS(uri, name);
|
|
};
|
|
}
|
|
__name(creatorInherit, "creatorInherit");
|
|
function creatorFixed(fullname) {
|
|
return function() {
|
|
return this.ownerDocument.createElementNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
__name(creatorFixed, "creatorFixed");
|
|
function creator_default(name) {
|
|
var fullname = namespace_default(name);
|
|
return (fullname.local ? creatorFixed : creatorInherit)(fullname);
|
|
}
|
|
__name(creator_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/append.js
|
|
function append_default(name) {
|
|
var create2 = typeof name === "function" ? name : creator_default(name);
|
|
return this.select(function() {
|
|
return this.appendChild(create2.apply(this, arguments));
|
|
});
|
|
}
|
|
__name(append_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/insert.js
|
|
function constantNull() {
|
|
return null;
|
|
}
|
|
__name(constantNull, "constantNull");
|
|
function insert_default(name, before) {
|
|
var create2 = typeof name === "function" ? name : creator_default(name), select = before == null ? constantNull : typeof before === "function" ? before : selector_default(before);
|
|
return this.select(function() {
|
|
return this.insertBefore(create2.apply(this, arguments), select.apply(this, arguments) || null);
|
|
});
|
|
}
|
|
__name(insert_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/remove.js
|
|
function remove() {
|
|
var parent = this.parentNode;
|
|
if (parent) parent.removeChild(this);
|
|
}
|
|
__name(remove, "remove");
|
|
function remove_default() {
|
|
return this.each(remove);
|
|
}
|
|
__name(remove_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/clone.js
|
|
function selection_cloneShallow() {
|
|
var clone = this.cloneNode(false), parent = this.parentNode;
|
|
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
|
|
}
|
|
__name(selection_cloneShallow, "selection_cloneShallow");
|
|
function selection_cloneDeep() {
|
|
var clone = this.cloneNode(true), parent = this.parentNode;
|
|
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
|
|
}
|
|
__name(selection_cloneDeep, "selection_cloneDeep");
|
|
function clone_default(deep) {
|
|
return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
|
|
}
|
|
__name(clone_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/datum.js
|
|
function datum_default(value) {
|
|
return arguments.length ? this.property("__data__", value) : this.node().__data__;
|
|
}
|
|
__name(datum_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/on.js
|
|
function contextListener(listener) {
|
|
return function(event) {
|
|
listener.call(this, event, this.__data__);
|
|
};
|
|
}
|
|
__name(contextListener, "contextListener");
|
|
function parseTypenames(typenames) {
|
|
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);
|
|
return { type: t, name };
|
|
});
|
|
}
|
|
__name(parseTypenames, "parseTypenames");
|
|
function onRemove(typename) {
|
|
return function() {
|
|
var on = this.__on;
|
|
if (!on) return;
|
|
for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
|
|
if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
|
|
this.removeEventListener(o.type, o.listener, o.options);
|
|
} else {
|
|
on[++i] = o;
|
|
}
|
|
}
|
|
if (++i) on.length = i;
|
|
else delete this.__on;
|
|
};
|
|
}
|
|
__name(onRemove, "onRemove");
|
|
function onAdd(typename, value, options) {
|
|
return function() {
|
|
var on = this.__on, o, listener = contextListener(value);
|
|
if (on) for (var j = 0, m = on.length; j < m; ++j) {
|
|
if ((o = on[j]).type === typename.type && o.name === typename.name) {
|
|
this.removeEventListener(o.type, o.listener, o.options);
|
|
this.addEventListener(o.type, o.listener = listener, o.options = options);
|
|
o.value = value;
|
|
return;
|
|
}
|
|
}
|
|
this.addEventListener(typename.type, listener, options);
|
|
o = { type: typename.type, name: typename.name, value, listener, options };
|
|
if (!on) this.__on = [o];
|
|
else on.push(o);
|
|
};
|
|
}
|
|
__name(onAdd, "onAdd");
|
|
function on_default(typename, value, options) {
|
|
var typenames = parseTypenames(typename + ""), i, n = typenames.length, t;
|
|
if (arguments.length < 2) {
|
|
var on = this.node().__on;
|
|
if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
|
|
for (i = 0, o = on[j]; i < n; ++i) {
|
|
if ((t = typenames[i]).type === o.type && t.name === o.name) {
|
|
return o.value;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
on = value ? onAdd : onRemove;
|
|
for (i = 0; i < n; ++i) this.each(on(typenames[i], value, options));
|
|
return this;
|
|
}
|
|
__name(on_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/dispatch.js
|
|
function dispatchEvent(node, type2, params) {
|
|
var window2 = window_default(node), event = window2.CustomEvent;
|
|
if (typeof event === "function") {
|
|
event = new event(type2, params);
|
|
} else {
|
|
event = window2.document.createEvent("Event");
|
|
if (params) event.initEvent(type2, params.bubbles, params.cancelable), event.detail = params.detail;
|
|
else event.initEvent(type2, false, false);
|
|
}
|
|
node.dispatchEvent(event);
|
|
}
|
|
__name(dispatchEvent, "dispatchEvent");
|
|
function dispatchConstant(type2, params) {
|
|
return function() {
|
|
return dispatchEvent(this, type2, params);
|
|
};
|
|
}
|
|
__name(dispatchConstant, "dispatchConstant");
|
|
function dispatchFunction(type2, params) {
|
|
return function() {
|
|
return dispatchEvent(this, type2, params.apply(this, arguments));
|
|
};
|
|
}
|
|
__name(dispatchFunction, "dispatchFunction");
|
|
function dispatch_default(type2, params) {
|
|
return this.each((typeof params === "function" ? dispatchFunction : dispatchConstant)(type2, params));
|
|
}
|
|
__name(dispatch_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/iterator.js
|
|
function* iterator_default() {
|
|
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
|
|
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
|
|
if (node = group[i]) yield node;
|
|
}
|
|
}
|
|
}
|
|
__name(iterator_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/selection/index.js
|
|
var root = [null];
|
|
function Selection(groups, parents) {
|
|
this._groups = groups;
|
|
this._parents = parents;
|
|
}
|
|
__name(Selection, "Selection");
|
|
function selection() {
|
|
return new Selection([[document.documentElement]], root);
|
|
}
|
|
__name(selection, "selection");
|
|
function selection_selection() {
|
|
return this;
|
|
}
|
|
__name(selection_selection, "selection_selection");
|
|
Selection.prototype = selection.prototype = {
|
|
constructor: Selection,
|
|
select: select_default,
|
|
selectAll: selectAll_default,
|
|
selectChild: selectChild_default,
|
|
selectChildren: selectChildren_default,
|
|
filter: filter_default,
|
|
data: data_default,
|
|
enter: enter_default,
|
|
exit: exit_default,
|
|
join: join_default,
|
|
merge: merge_default,
|
|
selection: selection_selection,
|
|
order: order_default,
|
|
sort: sort_default,
|
|
call: call_default,
|
|
nodes: nodes_default,
|
|
node: node_default,
|
|
size: size_default,
|
|
empty: empty_default,
|
|
each: each_default,
|
|
attr: attr_default,
|
|
style: style_default,
|
|
property: property_default,
|
|
classed: classed_default,
|
|
text: text_default,
|
|
html: html_default,
|
|
raise: raise_default,
|
|
lower: lower_default,
|
|
append: append_default,
|
|
insert: insert_default,
|
|
remove: remove_default,
|
|
clone: clone_default,
|
|
datum: datum_default,
|
|
on: on_default,
|
|
dispatch: dispatch_default,
|
|
[Symbol.iterator]: iterator_default
|
|
};
|
|
var selection_default = selection;
|
|
|
|
// ../../node_modules/.pnpm/d3-selection@3.0.0/node_modules/d3-selection/src/select.js
|
|
function select_default2(selector) {
|
|
return typeof selector === "string" ? new Selection([[document.querySelector(selector)]], [document.documentElement]) : new Selection([[selector]], root);
|
|
}
|
|
__name(select_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-color@3.1.0/node_modules/d3-color/src/define.js
|
|
function define_default(constructor, factory, prototype) {
|
|
constructor.prototype = factory.prototype = prototype;
|
|
prototype.constructor = constructor;
|
|
}
|
|
__name(define_default, "default");
|
|
function extend(parent, definition) {
|
|
var prototype = Object.create(parent.prototype);
|
|
for (var key in definition) prototype[key] = definition[key];
|
|
return prototype;
|
|
}
|
|
__name(extend, "extend");
|
|
|
|
// ../../node_modules/.pnpm/d3-color@3.1.0/node_modules/d3-color/src/color.js
|
|
function Color() {
|
|
}
|
|
__name(Color, "Color");
|
|
var darker = 0.7;
|
|
var brighter = 1 / darker;
|
|
var reI = "\\s*([+-]?\\d+)\\s*";
|
|
var reN = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*";
|
|
var reP = "\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*";
|
|
var reHex = /^#([0-9a-f]{3,8})$/;
|
|
var reRgbInteger = new RegExp(`^rgb\\(${reI},${reI},${reI}\\)$`);
|
|
var reRgbPercent = new RegExp(`^rgb\\(${reP},${reP},${reP}\\)$`);
|
|
var reRgbaInteger = new RegExp(`^rgba\\(${reI},${reI},${reI},${reN}\\)$`);
|
|
var reRgbaPercent = new RegExp(`^rgba\\(${reP},${reP},${reP},${reN}\\)$`);
|
|
var reHslPercent = new RegExp(`^hsl\\(${reN},${reP},${reP}\\)$`);
|
|
var reHslaPercent = new RegExp(`^hsla\\(${reN},${reP},${reP},${reN}\\)$`);
|
|
var named = {
|
|
aliceblue: 15792383,
|
|
antiquewhite: 16444375,
|
|
aqua: 65535,
|
|
aquamarine: 8388564,
|
|
azure: 15794175,
|
|
beige: 16119260,
|
|
bisque: 16770244,
|
|
black: 0,
|
|
blanchedalmond: 16772045,
|
|
blue: 255,
|
|
blueviolet: 9055202,
|
|
brown: 10824234,
|
|
burlywood: 14596231,
|
|
cadetblue: 6266528,
|
|
chartreuse: 8388352,
|
|
chocolate: 13789470,
|
|
coral: 16744272,
|
|
cornflowerblue: 6591981,
|
|
cornsilk: 16775388,
|
|
crimson: 14423100,
|
|
cyan: 65535,
|
|
darkblue: 139,
|
|
darkcyan: 35723,
|
|
darkgoldenrod: 12092939,
|
|
darkgray: 11119017,
|
|
darkgreen: 25600,
|
|
darkgrey: 11119017,
|
|
darkkhaki: 12433259,
|
|
darkmagenta: 9109643,
|
|
darkolivegreen: 5597999,
|
|
darkorange: 16747520,
|
|
darkorchid: 10040012,
|
|
darkred: 9109504,
|
|
darksalmon: 15308410,
|
|
darkseagreen: 9419919,
|
|
darkslateblue: 4734347,
|
|
darkslategray: 3100495,
|
|
darkslategrey: 3100495,
|
|
darkturquoise: 52945,
|
|
darkviolet: 9699539,
|
|
deeppink: 16716947,
|
|
deepskyblue: 49151,
|
|
dimgray: 6908265,
|
|
dimgrey: 6908265,
|
|
dodgerblue: 2003199,
|
|
firebrick: 11674146,
|
|
floralwhite: 16775920,
|
|
forestgreen: 2263842,
|
|
fuchsia: 16711935,
|
|
gainsboro: 14474460,
|
|
ghostwhite: 16316671,
|
|
gold: 16766720,
|
|
goldenrod: 14329120,
|
|
gray: 8421504,
|
|
green: 32768,
|
|
greenyellow: 11403055,
|
|
grey: 8421504,
|
|
honeydew: 15794160,
|
|
hotpink: 16738740,
|
|
indianred: 13458524,
|
|
indigo: 4915330,
|
|
ivory: 16777200,
|
|
khaki: 15787660,
|
|
lavender: 15132410,
|
|
lavenderblush: 16773365,
|
|
lawngreen: 8190976,
|
|
lemonchiffon: 16775885,
|
|
lightblue: 11393254,
|
|
lightcoral: 15761536,
|
|
lightcyan: 14745599,
|
|
lightgoldenrodyellow: 16448210,
|
|
lightgray: 13882323,
|
|
lightgreen: 9498256,
|
|
lightgrey: 13882323,
|
|
lightpink: 16758465,
|
|
lightsalmon: 16752762,
|
|
lightseagreen: 2142890,
|
|
lightskyblue: 8900346,
|
|
lightslategray: 7833753,
|
|
lightslategrey: 7833753,
|
|
lightsteelblue: 11584734,
|
|
lightyellow: 16777184,
|
|
lime: 65280,
|
|
limegreen: 3329330,
|
|
linen: 16445670,
|
|
magenta: 16711935,
|
|
maroon: 8388608,
|
|
mediumaquamarine: 6737322,
|
|
mediumblue: 205,
|
|
mediumorchid: 12211667,
|
|
mediumpurple: 9662683,
|
|
mediumseagreen: 3978097,
|
|
mediumslateblue: 8087790,
|
|
mediumspringgreen: 64154,
|
|
mediumturquoise: 4772300,
|
|
mediumvioletred: 13047173,
|
|
midnightblue: 1644912,
|
|
mintcream: 16121850,
|
|
mistyrose: 16770273,
|
|
moccasin: 16770229,
|
|
navajowhite: 16768685,
|
|
navy: 128,
|
|
oldlace: 16643558,
|
|
olive: 8421376,
|
|
olivedrab: 7048739,
|
|
orange: 16753920,
|
|
orangered: 16729344,
|
|
orchid: 14315734,
|
|
palegoldenrod: 15657130,
|
|
palegreen: 10025880,
|
|
paleturquoise: 11529966,
|
|
palevioletred: 14381203,
|
|
papayawhip: 16773077,
|
|
peachpuff: 16767673,
|
|
peru: 13468991,
|
|
pink: 16761035,
|
|
plum: 14524637,
|
|
powderblue: 11591910,
|
|
purple: 8388736,
|
|
rebeccapurple: 6697881,
|
|
red: 16711680,
|
|
rosybrown: 12357519,
|
|
royalblue: 4286945,
|
|
saddlebrown: 9127187,
|
|
salmon: 16416882,
|
|
sandybrown: 16032864,
|
|
seagreen: 3050327,
|
|
seashell: 16774638,
|
|
sienna: 10506797,
|
|
silver: 12632256,
|
|
skyblue: 8900331,
|
|
slateblue: 6970061,
|
|
slategray: 7372944,
|
|
slategrey: 7372944,
|
|
snow: 16775930,
|
|
springgreen: 65407,
|
|
steelblue: 4620980,
|
|
tan: 13808780,
|
|
teal: 32896,
|
|
thistle: 14204888,
|
|
tomato: 16737095,
|
|
turquoise: 4251856,
|
|
violet: 15631086,
|
|
wheat: 16113331,
|
|
white: 16777215,
|
|
whitesmoke: 16119285,
|
|
yellow: 16776960,
|
|
yellowgreen: 10145074
|
|
};
|
|
define_default(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();
|
|
}
|
|
__name(color_formatHex, "color_formatHex");
|
|
function color_formatHex8() {
|
|
return this.rgb().formatHex8();
|
|
}
|
|
__name(color_formatHex8, "color_formatHex8");
|
|
function color_formatHsl() {
|
|
return hslConvert(this).formatHsl();
|
|
}
|
|
__name(color_formatHsl, "color_formatHsl");
|
|
function color_formatRgb() {
|
|
return this.rgb().formatRgb();
|
|
}
|
|
__name(color_formatRgb, "color_formatRgb");
|
|
function color(format3) {
|
|
var m, l;
|
|
format3 = (format3 + "").trim().toLowerCase();
|
|
return (m = reHex.exec(format3)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) : l === 3 ? new Rgb(m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, (m & 15) << 4 | m & 15, 1) : l === 8 ? rgba(m >> 24 & 255, m >> 16 & 255, m >> 8 & 255, (m & 255) / 255) : l === 4 ? rgba(m >> 12 & 15 | m >> 8 & 240, m >> 8 & 15 | m >> 4 & 240, m >> 4 & 15 | m & 240, ((m & 15) << 4 | m & 15) / 255) : null) : (m = reRgbInteger.exec(format3)) ? new Rgb(m[1], m[2], m[3], 1) : (m = reRgbPercent.exec(format3)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) : (m = reRgbaInteger.exec(format3)) ? rgba(m[1], m[2], m[3], m[4]) : (m = reRgbaPercent.exec(format3)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) : (m = reHslPercent.exec(format3)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) : (m = reHslaPercent.exec(format3)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) : named.hasOwnProperty(format3) ? rgbn(named[format3]) : format3 === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
|
|
}
|
|
__name(color, "color");
|
|
function rgbn(n) {
|
|
return new Rgb(n >> 16 & 255, n >> 8 & 255, n & 255, 1);
|
|
}
|
|
__name(rgbn, "rgbn");
|
|
function rgba(r, g, b, a) {
|
|
if (a <= 0) r = g = b = NaN;
|
|
return new Rgb(r, g, b, a);
|
|
}
|
|
__name(rgba, "rgba");
|
|
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);
|
|
}
|
|
__name(rgbConvert, "rgbConvert");
|
|
function rgb(r, g, b, opacity) {
|
|
return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
|
|
}
|
|
__name(rgb, "rgb");
|
|
function Rgb(r, g, b, opacity) {
|
|
this.r = +r;
|
|
this.g = +g;
|
|
this.b = +b;
|
|
this.opacity = +opacity;
|
|
}
|
|
__name(Rgb, "Rgb");
|
|
define_default(Rgb, rgb, extend(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)}`;
|
|
}
|
|
__name(rgb_formatHex, "rgb_formatHex");
|
|
function rgb_formatHex8() {
|
|
return `#${hex(this.r)}${hex(this.g)}${hex(this.b)}${hex((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;
|
|
}
|
|
__name(rgb_formatHex8, "rgb_formatHex8");
|
|
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})`}`;
|
|
}
|
|
__name(rgb_formatRgb, "rgb_formatRgb");
|
|
function clampa(opacity) {
|
|
return isNaN(opacity) ? 1 : Math.max(0, Math.min(1, opacity));
|
|
}
|
|
__name(clampa, "clampa");
|
|
function clampi(value) {
|
|
return Math.max(0, Math.min(255, Math.round(value) || 0));
|
|
}
|
|
__name(clampi, "clampi");
|
|
function hex(value) {
|
|
value = clampi(value);
|
|
return (value < 16 ? "0" : "") + value.toString(16);
|
|
}
|
|
__name(hex, "hex");
|
|
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);
|
|
}
|
|
__name(hsla, "hsla");
|
|
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, min4 = Math.min(r, g, b), max4 = Math.max(r, g, b), h = NaN, s = max4 - min4, l = (max4 + min4) / 2;
|
|
if (s) {
|
|
if (r === max4) h = (g - b) / s + (g < b) * 6;
|
|
else if (g === max4) h = (b - r) / s + 2;
|
|
else h = (r - g) / s + 4;
|
|
s /= l < 0.5 ? max4 + min4 : 2 - max4 - min4;
|
|
h *= 60;
|
|
} else {
|
|
s = l > 0 && l < 1 ? 0 : h;
|
|
}
|
|
return new Hsl(h, s, l, o.opacity);
|
|
}
|
|
__name(hslConvert, "hslConvert");
|
|
function hsl(h, s, l, opacity) {
|
|
return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
|
|
}
|
|
__name(hsl, "hsl");
|
|
function Hsl(h, s, l, opacity) {
|
|
this.h = +h;
|
|
this.s = +s;
|
|
this.l = +l;
|
|
this.opacity = +opacity;
|
|
}
|
|
__name(Hsl, "Hsl");
|
|
define_default(Hsl, hsl, extend(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;
|
|
}
|
|
__name(clamph, "clamph");
|
|
function clampt(value) {
|
|
return Math.max(0, Math.min(1, value || 0));
|
|
}
|
|
__name(clampt, "clampt");
|
|
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;
|
|
}
|
|
__name(hsl2rgb, "hsl2rgb");
|
|
|
|
// ../../node_modules/.pnpm/d3-color@3.1.0/node_modules/d3-color/src/math.js
|
|
var radians = Math.PI / 180;
|
|
var degrees = 180 / Math.PI;
|
|
|
|
// ../../node_modules/.pnpm/d3-color@3.1.0/node_modules/d3-color/src/lab.js
|
|
var K = 18;
|
|
var Xn = 0.96422;
|
|
var Yn = 1;
|
|
var Zn = 0.82521;
|
|
var t0 = 4 / 29;
|
|
var t1 = 6 / 29;
|
|
var t2 = 3 * t1 * t1;
|
|
var 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 Rgb)) o = rgbConvert(o);
|
|
var r = rgb2lrgb(o.r), g = rgb2lrgb(o.g), b = rgb2lrgb(o.b), y2 = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x2, z;
|
|
if (r === g && g === b) x2 = z = y2;
|
|
else {
|
|
x2 = 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 * y2 - 16, 500 * (x2 - y2), 200 * (y2 - z), o.opacity);
|
|
}
|
|
__name(labConvert, "labConvert");
|
|
function lab(l, a, b, opacity) {
|
|
return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
|
|
}
|
|
__name(lab, "lab");
|
|
function Lab(l, a, b, opacity) {
|
|
this.l = +l;
|
|
this.a = +a;
|
|
this.b = +b;
|
|
this.opacity = +opacity;
|
|
}
|
|
__name(Lab, "Lab");
|
|
define_default(Lab, lab, extend(Color, {
|
|
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 y2 = (this.l + 16) / 116, x2 = isNaN(this.a) ? y2 : y2 + this.a / 500, z = isNaN(this.b) ? y2 : y2 - this.b / 200;
|
|
x2 = Xn * lab2xyz(x2);
|
|
y2 = Yn * lab2xyz(y2);
|
|
z = Zn * lab2xyz(z);
|
|
return new Rgb(
|
|
lrgb2rgb(3.1338561 * x2 - 1.6168667 * y2 - 0.4906146 * z),
|
|
lrgb2rgb(-0.9787684 * x2 + 1.9161415 * y2 + 0.033454 * z),
|
|
lrgb2rgb(0.0719453 * x2 - 0.2289914 * y2 + 1.4052427 * z),
|
|
this.opacity
|
|
);
|
|
}
|
|
}));
|
|
function xyz2lab(t) {
|
|
return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
|
|
}
|
|
__name(xyz2lab, "xyz2lab");
|
|
function lab2xyz(t) {
|
|
return t > t1 ? t * t * t : t2 * (t - t0);
|
|
}
|
|
__name(lab2xyz, "lab2xyz");
|
|
function lrgb2rgb(x2) {
|
|
return 255 * (x2 <= 31308e-7 ? 12.92 * x2 : 1.055 * Math.pow(x2, 1 / 2.4) - 0.055);
|
|
}
|
|
__name(lrgb2rgb, "lrgb2rgb");
|
|
function rgb2lrgb(x2) {
|
|
return (x2 /= 255) <= 0.04045 ? x2 / 12.92 : Math.pow((x2 + 0.055) / 1.055, 2.4);
|
|
}
|
|
__name(rgb2lrgb, "rgb2lrgb");
|
|
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) * degrees;
|
|
return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
|
|
}
|
|
__name(hclConvert, "hclConvert");
|
|
function hcl(h, c, l, opacity) {
|
|
return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
|
|
}
|
|
__name(hcl, "hcl");
|
|
function Hcl(h, c, l, opacity) {
|
|
this.h = +h;
|
|
this.c = +c;
|
|
this.l = +l;
|
|
this.opacity = +opacity;
|
|
}
|
|
__name(Hcl, "Hcl");
|
|
function hcl2lab(o) {
|
|
if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
|
|
var h = o.h * radians;
|
|
return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
|
|
}
|
|
__name(hcl2lab, "hcl2lab");
|
|
define_default(Hcl, hcl, extend(Color, {
|
|
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();
|
|
}
|
|
}));
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/constant.js
|
|
var constant_default2 = /* @__PURE__ */ __name((x2) => () => x2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/color.js
|
|
function linear(a, d) {
|
|
return function(t) {
|
|
return a + t * d;
|
|
};
|
|
}
|
|
__name(linear, "linear");
|
|
function exponential(a, b, y2) {
|
|
return a = Math.pow(a, y2), b = Math.pow(b, y2) - a, y2 = 1 / y2, function(t) {
|
|
return Math.pow(a + t * b, y2);
|
|
};
|
|
}
|
|
__name(exponential, "exponential");
|
|
function hue(a, b) {
|
|
var d = b - a;
|
|
return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant_default2(isNaN(a) ? b : a);
|
|
}
|
|
__name(hue, "hue");
|
|
function gamma(y2) {
|
|
return (y2 = +y2) === 1 ? nogamma : function(a, b) {
|
|
return b - a ? exponential(a, b, y2) : constant_default2(isNaN(a) ? b : a);
|
|
};
|
|
}
|
|
__name(gamma, "gamma");
|
|
function nogamma(a, b) {
|
|
var d = b - a;
|
|
return d ? linear(a, d) : constant_default2(isNaN(a) ? b : a);
|
|
}
|
|
__name(nogamma, "nogamma");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/hcl.js
|
|
function hcl2(hue2) {
|
|
return function(start2, end) {
|
|
var h = hue2((start2 = hcl(start2)).h, (end = hcl(end)).h), c = nogamma(start2.c, end.c), l = nogamma(start2.l, end.l), opacity = nogamma(start2.opacity, end.opacity);
|
|
return function(t) {
|
|
start2.h = h(t);
|
|
start2.c = c(t);
|
|
start2.l = l(t);
|
|
start2.opacity = opacity(t);
|
|
return start2 + "";
|
|
};
|
|
};
|
|
}
|
|
__name(hcl2, "hcl");
|
|
var hcl_default = hcl2(hue);
|
|
var hclLong = hcl2(nogamma);
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/basis.js
|
|
function basis(t13, v0, v1, v2, v3) {
|
|
var t22 = t13 * t13, t32 = t22 * t13;
|
|
return ((1 - 3 * t13 + 3 * t22 - t32) * v0 + (4 - 6 * t22 + 3 * t32) * v1 + (1 + 3 * t13 + 3 * t22 - 3 * t32) * v2 + t32 * v3) / 6;
|
|
}
|
|
__name(basis, "basis");
|
|
function basis_default(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);
|
|
};
|
|
}
|
|
__name(basis_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/basisClosed.js
|
|
function basisClosed_default(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 basis((t - i / n) * n, v0, v1, v2, v3);
|
|
};
|
|
}
|
|
__name(basisClosed_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/rgb.js
|
|
var rgb_default = (/* @__PURE__ */ __name((function rgbGamma(y2) {
|
|
var color2 = gamma(y2);
|
|
function rgb2(start2, end) {
|
|
var r = color2((start2 = rgb(start2)).r, (end = rgb(end)).r), g = color2(start2.g, end.g), b = color2(start2.b, end.b), opacity = nogamma(start2.opacity, end.opacity);
|
|
return function(t) {
|
|
start2.r = r(t);
|
|
start2.g = g(t);
|
|
start2.b = b(t);
|
|
start2.opacity = opacity(t);
|
|
return start2 + "";
|
|
};
|
|
}
|
|
__name(rgb2, "rgb");
|
|
rgb2.gamma = rgbGamma;
|
|
return rgb2;
|
|
}), "rgbGamma"))(1);
|
|
function rgbSpline(spline) {
|
|
return function(colors) {
|
|
var n = colors.length, r = new Array(n), g = new Array(n), b = new Array(n), i, color2;
|
|
for (i = 0; i < n; ++i) {
|
|
color2 = rgb(colors[i]);
|
|
r[i] = color2.r || 0;
|
|
g[i] = color2.g || 0;
|
|
b[i] = color2.b || 0;
|
|
}
|
|
r = spline(r);
|
|
g = spline(g);
|
|
b = spline(b);
|
|
color2.opacity = 1;
|
|
return function(t) {
|
|
color2.r = r(t);
|
|
color2.g = g(t);
|
|
color2.b = b(t);
|
|
return color2 + "";
|
|
};
|
|
};
|
|
}
|
|
__name(rgbSpline, "rgbSpline");
|
|
var rgbBasis = rgbSpline(basis_default);
|
|
var rgbBasisClosed = rgbSpline(basisClosed_default);
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/numberArray.js
|
|
function numberArray_default(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;
|
|
};
|
|
}
|
|
__name(numberArray_default, "default");
|
|
function isNumberArray(x2) {
|
|
return ArrayBuffer.isView(x2) && !(x2 instanceof DataView);
|
|
}
|
|
__name(isNumberArray, "isNumberArray");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/array.js
|
|
function genericArray(a, b) {
|
|
var nb = b ? b.length : 0, na = a ? Math.min(nb, a.length) : 0, x2 = new Array(na), c = new Array(nb), i;
|
|
for (i = 0; i < na; ++i) x2[i] = value_default(a[i], b[i]);
|
|
for (; i < nb; ++i) c[i] = b[i];
|
|
return function(t) {
|
|
for (i = 0; i < na; ++i) c[i] = x2[i](t);
|
|
return c;
|
|
};
|
|
}
|
|
__name(genericArray, "genericArray");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/date.js
|
|
function date_default(a, b) {
|
|
var d = /* @__PURE__ */ new Date();
|
|
return a = +a, b = +b, function(t) {
|
|
return d.setTime(a * (1 - t) + b * t), d;
|
|
};
|
|
}
|
|
__name(date_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/number.js
|
|
function number_default(a, b) {
|
|
return a = +a, b = +b, function(t) {
|
|
return a * (1 - t) + b * t;
|
|
};
|
|
}
|
|
__name(number_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/object.js
|
|
function object_default(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] = value_default(a[k], b[k]);
|
|
} else {
|
|
c[k] = b[k];
|
|
}
|
|
}
|
|
return function(t) {
|
|
for (k in i) c[k] = i[k](t);
|
|
return c;
|
|
};
|
|
}
|
|
__name(object_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/string.js
|
|
var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g;
|
|
var reB = new RegExp(reA.source, "g");
|
|
function zero2(b) {
|
|
return function() {
|
|
return b;
|
|
};
|
|
}
|
|
__name(zero2, "zero");
|
|
function one(b) {
|
|
return function(t) {
|
|
return b(t) + "";
|
|
};
|
|
}
|
|
__name(one, "one");
|
|
function string_default(a, b) {
|
|
var bi = reA.lastIndex = reB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
|
|
a = a + "", b = b + "";
|
|
while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
|
|
if ((bs = bm.index) > bi) {
|
|
bs = b.slice(bi, bs);
|
|
if (s[i]) s[i] += bs;
|
|
else s[++i] = bs;
|
|
}
|
|
if ((am = am[0]) === (bm = bm[0])) {
|
|
if (s[i]) s[i] += bm;
|
|
else s[++i] = bm;
|
|
} else {
|
|
s[++i] = null;
|
|
q.push({ i, x: number_default(am, bm) });
|
|
}
|
|
bi = reB.lastIndex;
|
|
}
|
|
if (bi < b.length) {
|
|
bs = b.slice(bi);
|
|
if (s[i]) s[i] += bs;
|
|
else s[++i] = bs;
|
|
}
|
|
return s.length < 2 ? q[0] ? one(q[0].x) : zero2(b) : (b = q.length, function(t) {
|
|
for (var i2 = 0, o; i2 < b; ++i2) s[(o = q[i2]).i] = o.x(t);
|
|
return s.join("");
|
|
});
|
|
}
|
|
__name(string_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/value.js
|
|
function value_default(a, b) {
|
|
var t = typeof b, c;
|
|
return b == null || t === "boolean" ? constant_default2(b) : (t === "number" ? number_default : t === "string" ? (c = color(b)) ? (b = c, rgb_default) : string_default : b instanceof color ? rgb_default : b instanceof Date ? date_default : isNumberArray(b) ? numberArray_default : Array.isArray(b) ? genericArray : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object_default : number_default)(a, b);
|
|
}
|
|
__name(value_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/round.js
|
|
function round_default(a, b) {
|
|
return a = +a, b = +b, function(t) {
|
|
return Math.round(a * (1 - t) + b * t);
|
|
};
|
|
}
|
|
__name(round_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/transform/decompose.js
|
|
var degrees2 = 180 / Math.PI;
|
|
var identity = {
|
|
translateX: 0,
|
|
translateY: 0,
|
|
rotate: 0,
|
|
skewX: 0,
|
|
scaleX: 1,
|
|
scaleY: 1
|
|
};
|
|
function decompose_default(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) * degrees2,
|
|
skewX: Math.atan(skewX) * degrees2,
|
|
scaleX,
|
|
scaleY
|
|
};
|
|
}
|
|
__name(decompose_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/transform/parse.js
|
|
var svgNode;
|
|
function parseCss(value) {
|
|
const m = new (typeof DOMMatrix === "function" ? DOMMatrix : WebKitCSSMatrix)(value + "");
|
|
return m.isIdentity ? identity : decompose_default(m.a, m.b, m.c, m.d, m.e, m.f);
|
|
}
|
|
__name(parseCss, "parseCss");
|
|
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_default(value.a, value.b, value.c, value.d, value.e, value.f);
|
|
}
|
|
__name(parseSvg, "parseSvg");
|
|
|
|
// ../../node_modules/.pnpm/d3-interpolate@3.0.1/node_modules/d3-interpolate/src/transform/index.js
|
|
function interpolateTransform(parse, pxComma, pxParen, degParen) {
|
|
function pop(s) {
|
|
return s.length ? s.pop() + " " : "";
|
|
}
|
|
__name(pop, "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: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
|
|
} else if (xb || yb) {
|
|
s.push("translate(" + xb + pxComma + yb + pxParen);
|
|
}
|
|
}
|
|
__name(translate, "translate");
|
|
function rotate(a, b, s, q) {
|
|
if (a !== b) {
|
|
if (a - b > 180) b += 360;
|
|
else if (b - a > 180) a += 360;
|
|
q.push({ i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number_default(a, b) });
|
|
} else if (b) {
|
|
s.push(pop(s) + "rotate(" + b + degParen);
|
|
}
|
|
}
|
|
__name(rotate, "rotate");
|
|
function skewX(a, b, s, q) {
|
|
if (a !== b) {
|
|
q.push({ i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number_default(a, b) });
|
|
} else if (b) {
|
|
s.push(pop(s) + "skewX(" + b + degParen);
|
|
}
|
|
}
|
|
__name(skewX, "skewX");
|
|
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: number_default(xa, xb) }, { i: i - 2, x: number_default(ya, yb) });
|
|
} else if (xb !== 1 || yb !== 1) {
|
|
s.push(pop(s) + "scale(" + xb + "," + yb + ")");
|
|
}
|
|
}
|
|
__name(scale, "scale");
|
|
return function(a, b) {
|
|
var s = [], q = [];
|
|
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;
|
|
return function(t) {
|
|
var i = -1, n = q.length, o;
|
|
while (++i < n) s[(o = q[i]).i] = o.x(t);
|
|
return s.join("");
|
|
};
|
|
};
|
|
}
|
|
__name(interpolateTransform, "interpolateTransform");
|
|
var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
|
|
var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatDecimal.js
|
|
function formatDecimal_default(x2) {
|
|
return Math.abs(x2 = Math.round(x2)) >= 1e21 ? x2.toLocaleString("en").replace(/,/g, "") : x2.toString(10);
|
|
}
|
|
__name(formatDecimal_default, "default");
|
|
function formatDecimalParts(x2, p) {
|
|
if ((i = (x2 = p ? x2.toExponential(p - 1) : x2.toExponential()).indexOf("e")) < 0) return null;
|
|
var i, coefficient = x2.slice(0, i);
|
|
return [
|
|
coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
|
|
+x2.slice(i + 1)
|
|
];
|
|
}
|
|
__name(formatDecimalParts, "formatDecimalParts");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/exponent.js
|
|
function exponent_default(x2) {
|
|
return x2 = formatDecimalParts(Math.abs(x2)), x2 ? x2[1] : NaN;
|
|
}
|
|
__name(exponent_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatGroup.js
|
|
function formatGroup_default(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);
|
|
};
|
|
}
|
|
__name(formatGroup_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatNumerals.js
|
|
function formatNumerals_default(numerals) {
|
|
return function(value) {
|
|
return value.replace(/[0-9]/g, function(i) {
|
|
return numerals[+i];
|
|
});
|
|
};
|
|
}
|
|
__name(formatNumerals_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatSpecifier.js
|
|
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]
|
|
});
|
|
}
|
|
__name(formatSpecifier, "formatSpecifier");
|
|
formatSpecifier.prototype = FormatSpecifier.prototype;
|
|
function FormatSpecifier(specifier) {
|
|
this.fill = specifier.fill === void 0 ? " " : specifier.fill + "";
|
|
this.align = specifier.align === void 0 ? ">" : specifier.align + "";
|
|
this.sign = specifier.sign === void 0 ? "-" : specifier.sign + "";
|
|
this.symbol = specifier.symbol === void 0 ? "" : specifier.symbol + "";
|
|
this.zero = !!specifier.zero;
|
|
this.width = specifier.width === void 0 ? void 0 : +specifier.width;
|
|
this.comma = !!specifier.comma;
|
|
this.precision = specifier.precision === void 0 ? void 0 : +specifier.precision;
|
|
this.trim = !!specifier.trim;
|
|
this.type = specifier.type === void 0 ? "" : specifier.type + "";
|
|
}
|
|
__name(FormatSpecifier, "FormatSpecifier");
|
|
FormatSpecifier.prototype.toString = function() {
|
|
return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatTrim.js
|
|
function formatTrim_default(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;
|
|
}
|
|
__name(formatTrim_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatPrefixAuto.js
|
|
var prefixExponent;
|
|
function formatPrefixAuto_default(x2, p) {
|
|
var d = formatDecimalParts(x2, p);
|
|
if (!d) return x2 + "";
|
|
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") + formatDecimalParts(x2, Math.max(0, p + i - 1))[0];
|
|
}
|
|
__name(formatPrefixAuto_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatRounded.js
|
|
function formatRounded_default(x2, p) {
|
|
var d = formatDecimalParts(x2, p);
|
|
if (!d) return x2 + "";
|
|
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");
|
|
}
|
|
__name(formatRounded_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/formatTypes.js
|
|
var formatTypes_default = {
|
|
"%": /* @__PURE__ */ __name((x2, p) => (x2 * 100).toFixed(p), "%"),
|
|
"b": /* @__PURE__ */ __name((x2) => Math.round(x2).toString(2), "b"),
|
|
"c": /* @__PURE__ */ __name((x2) => x2 + "", "c"),
|
|
"d": formatDecimal_default,
|
|
"e": /* @__PURE__ */ __name((x2, p) => x2.toExponential(p), "e"),
|
|
"f": /* @__PURE__ */ __name((x2, p) => x2.toFixed(p), "f"),
|
|
"g": /* @__PURE__ */ __name((x2, p) => x2.toPrecision(p), "g"),
|
|
"o": /* @__PURE__ */ __name((x2) => Math.round(x2).toString(8), "o"),
|
|
"p": /* @__PURE__ */ __name((x2, p) => formatRounded_default(x2 * 100, p), "p"),
|
|
"r": formatRounded_default,
|
|
"s": formatPrefixAuto_default,
|
|
"X": /* @__PURE__ */ __name((x2) => Math.round(x2).toString(16).toUpperCase(), "X"),
|
|
"x": /* @__PURE__ */ __name((x2) => Math.round(x2).toString(16), "x")
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/identity.js
|
|
function identity_default2(x2) {
|
|
return x2;
|
|
}
|
|
__name(identity_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/locale.js
|
|
var map = Array.prototype.map;
|
|
var prefixes = ["y", "z", "a", "f", "p", "n", "\xB5", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
|
|
function locale_default(locale3) {
|
|
var group = locale3.grouping === void 0 || locale3.thousands === void 0 ? identity_default2 : formatGroup_default(map.call(locale3.grouping, Number), locale3.thousands + ""), currencyPrefix = locale3.currency === void 0 ? "" : locale3.currency[0] + "", currencySuffix = locale3.currency === void 0 ? "" : locale3.currency[1] + "", decimal = locale3.decimal === void 0 ? "." : locale3.decimal + "", numerals = locale3.numerals === void 0 ? identity_default2 : formatNumerals_default(map.call(locale3.numerals, String)), percent = locale3.percent === void 0 ? "%" : locale3.percent + "", minus = locale3.minus === void 0 ? "\u2212" : locale3.minus + "", nan = locale3.nan === void 0 ? "NaN" : locale3.nan + "";
|
|
function newFormat(specifier) {
|
|
specifier = formatSpecifier(specifier);
|
|
var fill = specifier.fill, align = specifier.align, sign2 = specifier.sign, symbol = specifier.symbol, zero3 = specifier.zero, width = specifier.width, comma = specifier.comma, precision = specifier.precision, trim = specifier.trim, type2 = specifier.type;
|
|
if (type2 === "n") comma = true, type2 = "g";
|
|
else if (!formatTypes_default[type2]) precision === void 0 && (precision = 12), trim = true, type2 = "g";
|
|
if (zero3 || fill === "0" && align === "=") zero3 = true, fill = "0", align = "=";
|
|
var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type2) ? "0" + type2.toLowerCase() : "", suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type2) ? percent : "";
|
|
var formatType = formatTypes_default[type2], maybeSuffix = /[defgprs%]/.test(type2);
|
|
precision = precision === void 0 ? 6 : /[gprs]/.test(type2) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision));
|
|
function format3(value) {
|
|
var valuePrefix = prefix, valueSuffix = suffix, i, n, c;
|
|
if (type2 === "c") {
|
|
valueSuffix = formatType(value) + valueSuffix;
|
|
value = "";
|
|
} else {
|
|
value = +value;
|
|
var valueNegative = value < 0 || 1 / value < 0;
|
|
value = isNaN(value) ? nan : formatType(Math.abs(value), precision);
|
|
if (trim) value = formatTrim_default(value);
|
|
if (valueNegative && +value === 0 && sign2 !== "+") valueNegative = false;
|
|
valuePrefix = (valueNegative ? sign2 === "(" ? sign2 : minus : sign2 === "-" || sign2 === "(" ? "" : sign2) + valuePrefix;
|
|
valueSuffix = (type2 === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign2 === "(" ? ")" : "");
|
|
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 (comma && !zero3) value = group(value, Infinity);
|
|
var length = valuePrefix.length + value.length + valueSuffix.length, padding = length < width ? new Array(width - length + 1).join(fill) : "";
|
|
if (comma && zero3) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
|
|
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);
|
|
}
|
|
__name(format3, "format");
|
|
format3.toString = function() {
|
|
return specifier + "";
|
|
};
|
|
return format3;
|
|
}
|
|
__name(newFormat, "newFormat");
|
|
function formatPrefix2(specifier, value) {
|
|
var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), e = Math.max(-8, Math.min(8, Math.floor(exponent_default(value) / 3))) * 3, k = Math.pow(10, -e), prefix = prefixes[8 + e / 3];
|
|
return function(value2) {
|
|
return f(k * value2) + prefix;
|
|
};
|
|
}
|
|
__name(formatPrefix2, "formatPrefix");
|
|
return {
|
|
format: newFormat,
|
|
formatPrefix: formatPrefix2
|
|
};
|
|
}
|
|
__name(locale_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/defaultLocale.js
|
|
var locale;
|
|
var format2;
|
|
var formatPrefix;
|
|
defaultLocale({
|
|
thousands: ",",
|
|
grouping: [3],
|
|
currency: ["$", ""]
|
|
});
|
|
function defaultLocale(definition) {
|
|
locale = locale_default(definition);
|
|
format2 = locale.format;
|
|
formatPrefix = locale.formatPrefix;
|
|
return locale;
|
|
}
|
|
__name(defaultLocale, "defaultLocale");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/precisionFixed.js
|
|
function precisionFixed_default(step) {
|
|
return Math.max(0, -exponent_default(Math.abs(step)));
|
|
}
|
|
__name(precisionFixed_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/precisionPrefix.js
|
|
function precisionPrefix_default(step, value) {
|
|
return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent_default(value) / 3))) * 3 - exponent_default(Math.abs(step)));
|
|
}
|
|
__name(precisionPrefix_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-format@3.1.0/node_modules/d3-format/src/precisionRound.js
|
|
function precisionRound_default(step, max4) {
|
|
step = Math.abs(step), max4 = Math.abs(max4) - step;
|
|
return Math.max(0, exponent_default(max4) - exponent_default(step)) + 1;
|
|
}
|
|
__name(precisionRound_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/count.js
|
|
function count(node) {
|
|
var sum = 0, children2 = node.children, i = children2 && children2.length;
|
|
if (!i) sum = 1;
|
|
else while (--i >= 0) sum += children2[i].value;
|
|
node.value = sum;
|
|
}
|
|
__name(count, "count");
|
|
function count_default() {
|
|
return this.eachAfter(count);
|
|
}
|
|
__name(count_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/each.js
|
|
function each_default2(callback, that) {
|
|
let index = -1;
|
|
for (const node of this) {
|
|
callback.call(that, node, ++index, this);
|
|
}
|
|
return this;
|
|
}
|
|
__name(each_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/eachBefore.js
|
|
function eachBefore_default(callback, that) {
|
|
var node = this, nodes = [node], children2, i, index = -1;
|
|
while (node = nodes.pop()) {
|
|
callback.call(that, node, ++index, this);
|
|
if (children2 = node.children) {
|
|
for (i = children2.length - 1; i >= 0; --i) {
|
|
nodes.push(children2[i]);
|
|
}
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
__name(eachBefore_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/eachAfter.js
|
|
function eachAfter_default(callback, that) {
|
|
var node = this, nodes = [node], next = [], children2, i, n, index = -1;
|
|
while (node = nodes.pop()) {
|
|
next.push(node);
|
|
if (children2 = node.children) {
|
|
for (i = 0, n = children2.length; i < n; ++i) {
|
|
nodes.push(children2[i]);
|
|
}
|
|
}
|
|
}
|
|
while (node = next.pop()) {
|
|
callback.call(that, node, ++index, this);
|
|
}
|
|
return this;
|
|
}
|
|
__name(eachAfter_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/find.js
|
|
function find_default(callback, that) {
|
|
let index = -1;
|
|
for (const node of this) {
|
|
if (callback.call(that, node, ++index, this)) {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
__name(find_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/sum.js
|
|
function sum_default(value) {
|
|
return this.eachAfter(function(node) {
|
|
var sum = +value(node.data) || 0, children2 = node.children, i = children2 && children2.length;
|
|
while (--i >= 0) sum += children2[i].value;
|
|
node.value = sum;
|
|
});
|
|
}
|
|
__name(sum_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/sort.js
|
|
function sort_default2(compare) {
|
|
return this.eachBefore(function(node) {
|
|
if (node.children) {
|
|
node.children.sort(compare);
|
|
}
|
|
});
|
|
}
|
|
__name(sort_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/path.js
|
|
function path_default(end) {
|
|
var start2 = this, ancestor = leastCommonAncestor(start2, end), nodes = [start2];
|
|
while (start2 !== ancestor) {
|
|
start2 = start2.parent;
|
|
nodes.push(start2);
|
|
}
|
|
var k = nodes.length;
|
|
while (end !== ancestor) {
|
|
nodes.splice(k, 0, end);
|
|
end = end.parent;
|
|
}
|
|
return nodes;
|
|
}
|
|
__name(path_default, "default");
|
|
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;
|
|
}
|
|
__name(leastCommonAncestor, "leastCommonAncestor");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/ancestors.js
|
|
function ancestors_default() {
|
|
var node = this, nodes = [node];
|
|
while (node = node.parent) {
|
|
nodes.push(node);
|
|
}
|
|
return nodes;
|
|
}
|
|
__name(ancestors_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/descendants.js
|
|
function descendants_default() {
|
|
return Array.from(this);
|
|
}
|
|
__name(descendants_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/leaves.js
|
|
function leaves_default() {
|
|
var leaves = [];
|
|
this.eachBefore(function(node) {
|
|
if (!node.children) {
|
|
leaves.push(node);
|
|
}
|
|
});
|
|
return leaves;
|
|
}
|
|
__name(leaves_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/links.js
|
|
function links_default() {
|
|
var root2 = this, links = [];
|
|
root2.each(function(node) {
|
|
if (node !== root2) {
|
|
links.push({ source: node.parent, target: node });
|
|
}
|
|
});
|
|
return links;
|
|
}
|
|
__name(links_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/iterator.js
|
|
function* iterator_default2() {
|
|
var node = this, current, next = [node], children2, i, n;
|
|
do {
|
|
current = next.reverse(), next = [];
|
|
while (node = current.pop()) {
|
|
yield node;
|
|
if (children2 = node.children) {
|
|
for (i = 0, n = children2.length; i < n; ++i) {
|
|
next.push(children2[i]);
|
|
}
|
|
}
|
|
}
|
|
} while (next.length);
|
|
}
|
|
__name(iterator_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/hierarchy/index.js
|
|
function hierarchy(data, children2) {
|
|
if (data instanceof Map) {
|
|
data = [void 0, data];
|
|
if (children2 === void 0) children2 = mapChildren;
|
|
} else if (children2 === void 0) {
|
|
children2 = objectChildren;
|
|
}
|
|
var root2 = new Node(data), node, nodes = [root2], child, childs, i, n;
|
|
while (node = nodes.pop()) {
|
|
if ((childs = children2(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 root2.eachBefore(computeHeight);
|
|
}
|
|
__name(hierarchy, "hierarchy");
|
|
function node_copy() {
|
|
return hierarchy(this).eachBefore(copyData);
|
|
}
|
|
__name(node_copy, "node_copy");
|
|
function objectChildren(d) {
|
|
return d.children;
|
|
}
|
|
__name(objectChildren, "objectChildren");
|
|
function mapChildren(d) {
|
|
return Array.isArray(d) ? d[1] : null;
|
|
}
|
|
__name(mapChildren, "mapChildren");
|
|
function copyData(node) {
|
|
if (node.data.value !== void 0) node.value = node.data.value;
|
|
node.data = node.data.data;
|
|
}
|
|
__name(copyData, "copyData");
|
|
function computeHeight(node) {
|
|
var height = 0;
|
|
do
|
|
node.height = height;
|
|
while ((node = node.parent) && node.height < ++height);
|
|
}
|
|
__name(computeHeight, "computeHeight");
|
|
function Node(data) {
|
|
this.data = data;
|
|
this.depth = this.height = 0;
|
|
this.parent = null;
|
|
}
|
|
__name(Node, "Node");
|
|
Node.prototype = hierarchy.prototype = {
|
|
constructor: Node,
|
|
count: count_default,
|
|
each: each_default2,
|
|
eachAfter: eachAfter_default,
|
|
eachBefore: eachBefore_default,
|
|
find: find_default,
|
|
sum: sum_default,
|
|
sort: sort_default2,
|
|
path: path_default,
|
|
ancestors: ancestors_default,
|
|
descendants: descendants_default,
|
|
leaves: leaves_default,
|
|
links: links_default,
|
|
copy: node_copy,
|
|
[Symbol.iterator]: iterator_default2
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/treemap/round.js
|
|
function round_default2(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);
|
|
}
|
|
__name(round_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/treemap/dice.js
|
|
function dice_default(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;
|
|
}
|
|
}
|
|
__name(dice_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/treemap/slice.js
|
|
function slice_default(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;
|
|
}
|
|
}
|
|
__name(slice_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/treemap/squarify.js
|
|
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;
|
|
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);
|
|
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;
|
|
}
|
|
rows.push(row = { value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1) });
|
|
if (row.dice) dice_default(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1);
|
|
else slice_default(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1);
|
|
value -= sumValue, i0 = i1;
|
|
}
|
|
return rows;
|
|
}
|
|
__name(squarifyRatio, "squarifyRatio");
|
|
var squarify_default = (/* @__PURE__ */ __name((function custom(ratio) {
|
|
function squarify(parent, x0, y0, x1, y1) {
|
|
squarifyRatio(ratio, parent, x0, y0, x1, y1);
|
|
}
|
|
__name(squarify, "squarify");
|
|
squarify.ratio = function(x2) {
|
|
return custom((x2 = +x2) > 1 ? x2 : 1);
|
|
};
|
|
return squarify;
|
|
}), "custom"))(phi);
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/accessors.js
|
|
function required(f) {
|
|
if (typeof f !== "function") throw new Error();
|
|
return f;
|
|
}
|
|
__name(required, "required");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/constant.js
|
|
function constantZero() {
|
|
return 0;
|
|
}
|
|
__name(constantZero, "constantZero");
|
|
function constant_default3(x2) {
|
|
return function() {
|
|
return x2;
|
|
};
|
|
}
|
|
__name(constant_default3, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-hierarchy@3.1.2/node_modules/d3-hierarchy/src/treemap/index.js
|
|
function treemap_default() {
|
|
var tile = squarify_default, round = false, dx = 1, dy = 1, paddingStack = [0], paddingInner = constantZero, paddingTop = constantZero, paddingRight = constantZero, paddingBottom = constantZero, paddingLeft = constantZero;
|
|
function treemap(root2) {
|
|
root2.x0 = root2.y0 = 0;
|
|
root2.x1 = dx;
|
|
root2.y1 = dy;
|
|
root2.eachBefore(positionNode);
|
|
paddingStack = [0];
|
|
if (round) root2.eachBefore(round_default2);
|
|
return root2;
|
|
}
|
|
__name(treemap, "treemap");
|
|
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);
|
|
}
|
|
}
|
|
__name(positionNode, "positionNode");
|
|
treemap.round = function(x2) {
|
|
return arguments.length ? (round = !!x2, treemap) : round;
|
|
};
|
|
treemap.size = function(x2) {
|
|
return arguments.length ? (dx = +x2[0], dy = +x2[1], treemap) : [dx, dy];
|
|
};
|
|
treemap.tile = function(x2) {
|
|
return arguments.length ? (tile = required(x2), treemap) : tile;
|
|
};
|
|
treemap.padding = function(x2) {
|
|
return arguments.length ? treemap.paddingInner(x2).paddingOuter(x2) : treemap.paddingInner();
|
|
};
|
|
treemap.paddingInner = function(x2) {
|
|
return arguments.length ? (paddingInner = typeof x2 === "function" ? x2 : constant_default3(+x2), treemap) : paddingInner;
|
|
};
|
|
treemap.paddingOuter = function(x2) {
|
|
return arguments.length ? treemap.paddingTop(x2).paddingRight(x2).paddingBottom(x2).paddingLeft(x2) : treemap.paddingTop();
|
|
};
|
|
treemap.paddingTop = function(x2) {
|
|
return arguments.length ? (paddingTop = typeof x2 === "function" ? x2 : constant_default3(+x2), treemap) : paddingTop;
|
|
};
|
|
treemap.paddingRight = function(x2) {
|
|
return arguments.length ? (paddingRight = typeof x2 === "function" ? x2 : constant_default3(+x2), treemap) : paddingRight;
|
|
};
|
|
treemap.paddingBottom = function(x2) {
|
|
return arguments.length ? (paddingBottom = typeof x2 === "function" ? x2 : constant_default3(+x2), treemap) : paddingBottom;
|
|
};
|
|
treemap.paddingLeft = function(x2) {
|
|
return arguments.length ? (paddingLeft = typeof x2 === "function" ? x2 : constant_default3(+x2), treemap) : paddingLeft;
|
|
};
|
|
return treemap;
|
|
}
|
|
__name(treemap_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/init.js
|
|
function initRange(domain, range2) {
|
|
switch (arguments.length) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
this.range(domain);
|
|
break;
|
|
default:
|
|
this.range(range2).domain(domain);
|
|
break;
|
|
}
|
|
return this;
|
|
}
|
|
__name(initRange, "initRange");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js
|
|
var implicit = Symbol("implicit");
|
|
function ordinal() {
|
|
var index = new InternMap(), domain = [], range2 = [], unknown = implicit;
|
|
function scale(d) {
|
|
let i = index.get(d);
|
|
if (i === void 0) {
|
|
if (unknown !== implicit) return unknown;
|
|
index.set(d, i = domain.push(d) - 1);
|
|
}
|
|
return range2[i % range2.length];
|
|
}
|
|
__name(scale, "scale");
|
|
scale.domain = function(_) {
|
|
if (!arguments.length) return domain.slice();
|
|
domain = [], index = new InternMap();
|
|
for (const value of _) {
|
|
if (index.has(value)) continue;
|
|
index.set(value, domain.push(value) - 1);
|
|
}
|
|
return scale;
|
|
};
|
|
scale.range = function(_) {
|
|
return arguments.length ? (range2 = Array.from(_), scale) : range2.slice();
|
|
};
|
|
scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
};
|
|
scale.copy = function() {
|
|
return ordinal(domain, range2).unknown(unknown);
|
|
};
|
|
initRange.apply(scale, arguments);
|
|
return scale;
|
|
}
|
|
__name(ordinal, "ordinal");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/constant.js
|
|
function constants(x2) {
|
|
return function() {
|
|
return x2;
|
|
};
|
|
}
|
|
__name(constants, "constants");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/number.js
|
|
function number3(x2) {
|
|
return +x2;
|
|
}
|
|
__name(number3, "number");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/continuous.js
|
|
var unit = [0, 1];
|
|
function identity2(x2) {
|
|
return x2;
|
|
}
|
|
__name(identity2, "identity");
|
|
function normalize(a, b) {
|
|
return (b -= a = +a) ? function(x2) {
|
|
return (x2 - a) / b;
|
|
} : constants(isNaN(b) ? NaN : 0.5);
|
|
}
|
|
__name(normalize, "normalize");
|
|
function clamper(a, b) {
|
|
var t;
|
|
if (a > b) t = a, a = b, b = t;
|
|
return function(x2) {
|
|
return Math.max(a, Math.min(b, x2));
|
|
};
|
|
}
|
|
__name(clamper, "clamper");
|
|
function bimap(domain, range2, interpolate) {
|
|
var d0 = domain[0], d1 = domain[1], r0 = range2[0], r1 = range2[1];
|
|
if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);
|
|
else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
|
|
return function(x2) {
|
|
return r0(d0(x2));
|
|
};
|
|
}
|
|
__name(bimap, "bimap");
|
|
function polymap(domain, range2, interpolate) {
|
|
var j = Math.min(domain.length, range2.length) - 1, d = new Array(j), r = new Array(j), i = -1;
|
|
if (domain[j] < domain[0]) {
|
|
domain = domain.slice().reverse();
|
|
range2 = range2.slice().reverse();
|
|
}
|
|
while (++i < j) {
|
|
d[i] = normalize(domain[i], domain[i + 1]);
|
|
r[i] = interpolate(range2[i], range2[i + 1]);
|
|
}
|
|
return function(x2) {
|
|
var i2 = bisect_default(domain, x2, 1, j) - 1;
|
|
return r[i2](d[i2](x2));
|
|
};
|
|
}
|
|
__name(polymap, "polymap");
|
|
function copy(source, target) {
|
|
return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
|
|
}
|
|
__name(copy, "copy");
|
|
function transformer() {
|
|
var domain = unit, range2 = unit, interpolate = value_default, transform2, untransform, unknown, clamp = identity2, piecewise, output, input;
|
|
function rescale() {
|
|
var n = Math.min(domain.length, range2.length);
|
|
if (clamp !== identity2) clamp = clamper(domain[0], domain[n - 1]);
|
|
piecewise = n > 2 ? polymap : bimap;
|
|
output = input = null;
|
|
return scale;
|
|
}
|
|
__name(rescale, "rescale");
|
|
function scale(x2) {
|
|
return x2 == null || isNaN(x2 = +x2) ? unknown : (output || (output = piecewise(domain.map(transform2), range2, interpolate)))(transform2(clamp(x2)));
|
|
}
|
|
__name(scale, "scale");
|
|
scale.invert = function(y2) {
|
|
return clamp(untransform((input || (input = piecewise(range2, domain.map(transform2), number_default)))(y2)));
|
|
};
|
|
scale.domain = function(_) {
|
|
return arguments.length ? (domain = Array.from(_, number3), rescale()) : domain.slice();
|
|
};
|
|
scale.range = function(_) {
|
|
return arguments.length ? (range2 = Array.from(_), rescale()) : range2.slice();
|
|
};
|
|
scale.rangeRound = function(_) {
|
|
return range2 = Array.from(_), interpolate = round_default, rescale();
|
|
};
|
|
scale.clamp = function(_) {
|
|
return arguments.length ? (clamp = _ ? true : identity2, rescale()) : clamp !== identity2;
|
|
};
|
|
scale.interpolate = function(_) {
|
|
return arguments.length ? (interpolate = _, rescale()) : interpolate;
|
|
};
|
|
scale.unknown = function(_) {
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
|
};
|
|
return function(t, u) {
|
|
transform2 = t, untransform = u;
|
|
return rescale();
|
|
};
|
|
}
|
|
__name(transformer, "transformer");
|
|
function continuous() {
|
|
return transformer()(identity2, identity2);
|
|
}
|
|
__name(continuous, "continuous");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/tickFormat.js
|
|
function tickFormat(start2, stop, count2, specifier) {
|
|
var step = tickStep(start2, stop, count2), precision;
|
|
specifier = formatSpecifier(specifier == null ? ",f" : specifier);
|
|
switch (specifier.type) {
|
|
case "s": {
|
|
var value = Math.max(Math.abs(start2), Math.abs(stop));
|
|
if (specifier.precision == null && !isNaN(precision = precisionPrefix_default(step, value))) specifier.precision = precision;
|
|
return formatPrefix(specifier, value);
|
|
}
|
|
case "":
|
|
case "e":
|
|
case "g":
|
|
case "p":
|
|
case "r": {
|
|
if (specifier.precision == null && !isNaN(precision = precisionRound_default(step, Math.max(Math.abs(start2), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
|
|
break;
|
|
}
|
|
case "f":
|
|
case "%": {
|
|
if (specifier.precision == null && !isNaN(precision = precisionFixed_default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
|
|
break;
|
|
}
|
|
}
|
|
return format2(specifier);
|
|
}
|
|
__name(tickFormat, "tickFormat");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/linear.js
|
|
function linearish(scale) {
|
|
var domain = scale.domain;
|
|
scale.ticks = function(count2) {
|
|
var d = domain();
|
|
return ticks(d[0], d[d.length - 1], count2 == null ? 10 : count2);
|
|
};
|
|
scale.tickFormat = function(count2, specifier) {
|
|
var d = domain();
|
|
return tickFormat(d[0], d[d.length - 1], count2 == null ? 10 : count2, specifier);
|
|
};
|
|
scale.nice = function(count2) {
|
|
if (count2 == null) count2 = 10;
|
|
var d = domain();
|
|
var i0 = 0;
|
|
var i1 = d.length - 1;
|
|
var start2 = d[i0];
|
|
var stop = d[i1];
|
|
var prestep;
|
|
var step;
|
|
var maxIter = 10;
|
|
if (stop < start2) {
|
|
step = start2, start2 = stop, stop = step;
|
|
step = i0, i0 = i1, i1 = step;
|
|
}
|
|
while (maxIter-- > 0) {
|
|
step = tickIncrement(start2, stop, count2);
|
|
if (step === prestep) {
|
|
d[i0] = start2;
|
|
d[i1] = stop;
|
|
return domain(d);
|
|
} else if (step > 0) {
|
|
start2 = Math.floor(start2 / step) * step;
|
|
stop = Math.ceil(stop / step) * step;
|
|
} else if (step < 0) {
|
|
start2 = Math.ceil(start2 * step) / step;
|
|
stop = Math.floor(stop * step) / step;
|
|
} else {
|
|
break;
|
|
}
|
|
prestep = step;
|
|
}
|
|
return scale;
|
|
};
|
|
return scale;
|
|
}
|
|
__name(linearish, "linearish");
|
|
function linear2() {
|
|
var scale = continuous();
|
|
scale.copy = function() {
|
|
return copy(scale, linear2());
|
|
};
|
|
initRange.apply(scale, arguments);
|
|
return linearish(scale);
|
|
}
|
|
__name(linear2, "linear");
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/interval.js
|
|
var t02 = /* @__PURE__ */ new Date();
|
|
var t12 = /* @__PURE__ */ new Date();
|
|
function timeInterval(floori, offseti, count2, field) {
|
|
function interval2(date2) {
|
|
return floori(date2 = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+date2)), date2;
|
|
}
|
|
__name(interval2, "interval");
|
|
interval2.floor = (date2) => {
|
|
return floori(date2 = /* @__PURE__ */ new Date(+date2)), date2;
|
|
};
|
|
interval2.ceil = (date2) => {
|
|
return floori(date2 = new Date(date2 - 1)), offseti(date2, 1), floori(date2), date2;
|
|
};
|
|
interval2.round = (date2) => {
|
|
const d0 = interval2(date2), d1 = interval2.ceil(date2);
|
|
return date2 - d0 < d1 - date2 ? d0 : d1;
|
|
};
|
|
interval2.offset = (date2, step) => {
|
|
return offseti(date2 = /* @__PURE__ */ new Date(+date2), step == null ? 1 : Math.floor(step)), date2;
|
|
};
|
|
interval2.range = (start2, stop, step) => {
|
|
const range2 = [];
|
|
start2 = interval2.ceil(start2);
|
|
step = step == null ? 1 : Math.floor(step);
|
|
if (!(start2 < stop) || !(step > 0)) return range2;
|
|
let previous;
|
|
do
|
|
range2.push(previous = /* @__PURE__ */ new Date(+start2)), offseti(start2, step), floori(start2);
|
|
while (previous < start2 && start2 < stop);
|
|
return range2;
|
|
};
|
|
interval2.filter = (test) => {
|
|
return timeInterval((date2) => {
|
|
if (date2 >= date2) while (floori(date2), !test(date2)) date2.setTime(date2 - 1);
|
|
}, (date2, step) => {
|
|
if (date2 >= date2) {
|
|
if (step < 0) while (++step <= 0) {
|
|
while (offseti(date2, -1), !test(date2)) {
|
|
}
|
|
}
|
|
else while (--step >= 0) {
|
|
while (offseti(date2, 1), !test(date2)) {
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
if (count2) {
|
|
interval2.count = (start2, end) => {
|
|
t02.setTime(+start2), t12.setTime(+end);
|
|
floori(t02), floori(t12);
|
|
return Math.floor(count2(t02, t12));
|
|
};
|
|
interval2.every = (step) => {
|
|
step = Math.floor(step);
|
|
return !isFinite(step) || !(step > 0) ? null : !(step > 1) ? interval2 : interval2.filter(field ? (d) => field(d) % step === 0 : (d) => interval2.count(0, d) % step === 0);
|
|
};
|
|
}
|
|
return interval2;
|
|
}
|
|
__name(timeInterval, "timeInterval");
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/millisecond.js
|
|
var millisecond = timeInterval(() => {
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step);
|
|
}, (start2, end) => {
|
|
return end - start2;
|
|
});
|
|
millisecond.every = (k) => {
|
|
k = Math.floor(k);
|
|
if (!isFinite(k) || !(k > 0)) return null;
|
|
if (!(k > 1)) return millisecond;
|
|
return timeInterval((date2) => {
|
|
date2.setTime(Math.floor(date2 / k) * k);
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * k);
|
|
}, (start2, end) => {
|
|
return (end - start2) / k;
|
|
});
|
|
};
|
|
var milliseconds = millisecond.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/duration.js
|
|
var durationSecond = 1e3;
|
|
var durationMinute = durationSecond * 60;
|
|
var durationHour = durationMinute * 60;
|
|
var durationDay = durationHour * 24;
|
|
var durationWeek = durationDay * 7;
|
|
var durationMonth = durationDay * 30;
|
|
var durationYear = durationDay * 365;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/second.js
|
|
var second = timeInterval((date2) => {
|
|
date2.setTime(date2 - date2.getMilliseconds());
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * durationSecond);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationSecond;
|
|
}, (date2) => {
|
|
return date2.getUTCSeconds();
|
|
});
|
|
var seconds = second.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/minute.js
|
|
var timeMinute = timeInterval((date2) => {
|
|
date2.setTime(date2 - date2.getMilliseconds() - date2.getSeconds() * durationSecond);
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * durationMinute);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationMinute;
|
|
}, (date2) => {
|
|
return date2.getMinutes();
|
|
});
|
|
var timeMinutes = timeMinute.range;
|
|
var utcMinute = timeInterval((date2) => {
|
|
date2.setUTCSeconds(0, 0);
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * durationMinute);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationMinute;
|
|
}, (date2) => {
|
|
return date2.getUTCMinutes();
|
|
});
|
|
var utcMinutes = utcMinute.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/hour.js
|
|
var timeHour = timeInterval((date2) => {
|
|
date2.setTime(date2 - date2.getMilliseconds() - date2.getSeconds() * durationSecond - date2.getMinutes() * durationMinute);
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * durationHour);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationHour;
|
|
}, (date2) => {
|
|
return date2.getHours();
|
|
});
|
|
var timeHours = timeHour.range;
|
|
var utcHour = timeInterval((date2) => {
|
|
date2.setUTCMinutes(0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setTime(+date2 + step * durationHour);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationHour;
|
|
}, (date2) => {
|
|
return date2.getUTCHours();
|
|
});
|
|
var utcHours = utcHour.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/day.js
|
|
var timeDay = timeInterval(
|
|
(date2) => date2.setHours(0, 0, 0, 0),
|
|
(date2, step) => date2.setDate(date2.getDate() + step),
|
|
(start2, end) => (end - start2 - (end.getTimezoneOffset() - start2.getTimezoneOffset()) * durationMinute) / durationDay,
|
|
(date2) => date2.getDate() - 1
|
|
);
|
|
var timeDays = timeDay.range;
|
|
var utcDay = timeInterval((date2) => {
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCDate(date2.getUTCDate() + step);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationDay;
|
|
}, (date2) => {
|
|
return date2.getUTCDate() - 1;
|
|
});
|
|
var utcDays = utcDay.range;
|
|
var unixDay = timeInterval((date2) => {
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCDate(date2.getUTCDate() + step);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationDay;
|
|
}, (date2) => {
|
|
return Math.floor(date2 / durationDay);
|
|
});
|
|
var unixDays = unixDay.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/week.js
|
|
function timeWeekday(i) {
|
|
return timeInterval((date2) => {
|
|
date2.setDate(date2.getDate() - (date2.getDay() + 7 - i) % 7);
|
|
date2.setHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setDate(date2.getDate() + step * 7);
|
|
}, (start2, end) => {
|
|
return (end - start2 - (end.getTimezoneOffset() - start2.getTimezoneOffset()) * durationMinute) / durationWeek;
|
|
});
|
|
}
|
|
__name(timeWeekday, "timeWeekday");
|
|
var timeSunday = timeWeekday(0);
|
|
var timeMonday = timeWeekday(1);
|
|
var timeTuesday = timeWeekday(2);
|
|
var timeWednesday = timeWeekday(3);
|
|
var timeThursday = timeWeekday(4);
|
|
var timeFriday = timeWeekday(5);
|
|
var timeSaturday = timeWeekday(6);
|
|
var timeSundays = timeSunday.range;
|
|
var timeMondays = timeMonday.range;
|
|
var timeTuesdays = timeTuesday.range;
|
|
var timeWednesdays = timeWednesday.range;
|
|
var timeThursdays = timeThursday.range;
|
|
var timeFridays = timeFriday.range;
|
|
var timeSaturdays = timeSaturday.range;
|
|
function utcWeekday(i) {
|
|
return timeInterval((date2) => {
|
|
date2.setUTCDate(date2.getUTCDate() - (date2.getUTCDay() + 7 - i) % 7);
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCDate(date2.getUTCDate() + step * 7);
|
|
}, (start2, end) => {
|
|
return (end - start2) / durationWeek;
|
|
});
|
|
}
|
|
__name(utcWeekday, "utcWeekday");
|
|
var utcSunday = utcWeekday(0);
|
|
var utcMonday = utcWeekday(1);
|
|
var utcTuesday = utcWeekday(2);
|
|
var utcWednesday = utcWeekday(3);
|
|
var utcThursday = utcWeekday(4);
|
|
var utcFriday = utcWeekday(5);
|
|
var utcSaturday = utcWeekday(6);
|
|
var utcSundays = utcSunday.range;
|
|
var utcMondays = utcMonday.range;
|
|
var utcTuesdays = utcTuesday.range;
|
|
var utcWednesdays = utcWednesday.range;
|
|
var utcThursdays = utcThursday.range;
|
|
var utcFridays = utcFriday.range;
|
|
var utcSaturdays = utcSaturday.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/month.js
|
|
var timeMonth = timeInterval((date2) => {
|
|
date2.setDate(1);
|
|
date2.setHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setMonth(date2.getMonth() + step);
|
|
}, (start2, end) => {
|
|
return end.getMonth() - start2.getMonth() + (end.getFullYear() - start2.getFullYear()) * 12;
|
|
}, (date2) => {
|
|
return date2.getMonth();
|
|
});
|
|
var timeMonths = timeMonth.range;
|
|
var utcMonth = timeInterval((date2) => {
|
|
date2.setUTCDate(1);
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCMonth(date2.getUTCMonth() + step);
|
|
}, (start2, end) => {
|
|
return end.getUTCMonth() - start2.getUTCMonth() + (end.getUTCFullYear() - start2.getUTCFullYear()) * 12;
|
|
}, (date2) => {
|
|
return date2.getUTCMonth();
|
|
});
|
|
var utcMonths = utcMonth.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/year.js
|
|
var timeYear = timeInterval((date2) => {
|
|
date2.setMonth(0, 1);
|
|
date2.setHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setFullYear(date2.getFullYear() + step);
|
|
}, (start2, end) => {
|
|
return end.getFullYear() - start2.getFullYear();
|
|
}, (date2) => {
|
|
return date2.getFullYear();
|
|
});
|
|
timeYear.every = (k) => {
|
|
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date2) => {
|
|
date2.setFullYear(Math.floor(date2.getFullYear() / k) * k);
|
|
date2.setMonth(0, 1);
|
|
date2.setHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setFullYear(date2.getFullYear() + step * k);
|
|
});
|
|
};
|
|
var timeYears = timeYear.range;
|
|
var utcYear = timeInterval((date2) => {
|
|
date2.setUTCMonth(0, 1);
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCFullYear(date2.getUTCFullYear() + step);
|
|
}, (start2, end) => {
|
|
return end.getUTCFullYear() - start2.getUTCFullYear();
|
|
}, (date2) => {
|
|
return date2.getUTCFullYear();
|
|
});
|
|
utcYear.every = (k) => {
|
|
return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : timeInterval((date2) => {
|
|
date2.setUTCFullYear(Math.floor(date2.getUTCFullYear() / k) * k);
|
|
date2.setUTCMonth(0, 1);
|
|
date2.setUTCHours(0, 0, 0, 0);
|
|
}, (date2, step) => {
|
|
date2.setUTCFullYear(date2.getUTCFullYear() + step * k);
|
|
});
|
|
};
|
|
var utcYears = utcYear.range;
|
|
|
|
// ../../node_modules/.pnpm/d3-time@3.1.0/node_modules/d3-time/src/ticks.js
|
|
function ticker(year, month, week, day, hour, minute) {
|
|
const tickIntervals = [
|
|
[second, 1, durationSecond],
|
|
[second, 5, 5 * durationSecond],
|
|
[second, 15, 15 * durationSecond],
|
|
[second, 30, 30 * durationSecond],
|
|
[minute, 1, durationMinute],
|
|
[minute, 5, 5 * durationMinute],
|
|
[minute, 15, 15 * durationMinute],
|
|
[minute, 30, 30 * durationMinute],
|
|
[hour, 1, durationHour],
|
|
[hour, 3, 3 * durationHour],
|
|
[hour, 6, 6 * durationHour],
|
|
[hour, 12, 12 * durationHour],
|
|
[day, 1, durationDay],
|
|
[day, 2, 2 * durationDay],
|
|
[week, 1, durationWeek],
|
|
[month, 1, durationMonth],
|
|
[month, 3, 3 * durationMonth],
|
|
[year, 1, durationYear]
|
|
];
|
|
function ticks2(start2, stop, count2) {
|
|
const reverse = stop < start2;
|
|
if (reverse) [start2, stop] = [stop, start2];
|
|
const interval2 = count2 && typeof count2.range === "function" ? count2 : tickInterval(start2, stop, count2);
|
|
const ticks3 = interval2 ? interval2.range(start2, +stop + 1) : [];
|
|
return reverse ? ticks3.reverse() : ticks3;
|
|
}
|
|
__name(ticks2, "ticks");
|
|
function tickInterval(start2, stop, count2) {
|
|
const target = Math.abs(stop - start2) / count2;
|
|
const i = bisector(([, , step2]) => step2).right(tickIntervals, target);
|
|
if (i === tickIntervals.length) return year.every(tickStep(start2 / durationYear, stop / durationYear, count2));
|
|
if (i === 0) return millisecond.every(Math.max(tickStep(start2, stop, count2), 1));
|
|
const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
|
|
return t.every(step);
|
|
}
|
|
__name(tickInterval, "tickInterval");
|
|
return [ticks2, tickInterval];
|
|
}
|
|
__name(ticker, "ticker");
|
|
var [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute);
|
|
var [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute);
|
|
|
|
// ../../node_modules/.pnpm/d3-time-format@4.1.0/node_modules/d3-time-format/src/locale.js
|
|
function localDate(d) {
|
|
if (0 <= d.y && d.y < 100) {
|
|
var date2 = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
date2.setFullYear(d.y);
|
|
return date2;
|
|
}
|
|
return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
|
|
}
|
|
__name(localDate, "localDate");
|
|
function utcDate(d) {
|
|
if (0 <= d.y && d.y < 100) {
|
|
var date2 = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
date2.setUTCFullYear(d.y);
|
|
return date2;
|
|
}
|
|
return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
|
|
}
|
|
__name(utcDate, "utcDate");
|
|
function newDate(y2, m, d) {
|
|
return { y: y2, m, d, H: 0, M: 0, S: 0, L: 0 };
|
|
}
|
|
__name(newDate, "newDate");
|
|
function formatLocale(locale3) {
|
|
var locale_dateTime = locale3.dateTime, locale_date = locale3.date, locale_time = locale3.time, locale_periods = locale3.periods, locale_weekdays = locale3.days, locale_shortWeekdays = locale3.shortDays, locale_months = locale3.months, locale_shortMonths = locale3.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
|
|
};
|
|
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, formats2) {
|
|
return function(date2) {
|
|
var string = [], i = -1, j = 0, n = specifier.length, c, pad2, format3;
|
|
if (!(date2 instanceof Date)) date2 = /* @__PURE__ */ new Date(+date2);
|
|
while (++i < n) {
|
|
if (specifier.charCodeAt(i) === 37) {
|
|
string.push(specifier.slice(j, i));
|
|
if ((pad2 = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
|
|
else pad2 = c === "e" ? " " : "0";
|
|
if (format3 = formats2[c]) c = format3(date2, pad2);
|
|
string.push(c);
|
|
j = i + 1;
|
|
}
|
|
}
|
|
string.push(specifier.slice(j, i));
|
|
return string.join("");
|
|
};
|
|
}
|
|
__name(newFormat, "newFormat");
|
|
function newParse(specifier, Z) {
|
|
return function(string) {
|
|
var d = newDate(1900, void 0, 1), i = parseSpecifier(d, specifier, string += "", 0), week, day;
|
|
if (i != string.length) return null;
|
|
if ("Q" in d) return new Date(d.Q);
|
|
if ("s" in d) return new Date(d.s * 1e3 + ("L" in d ? d.L : 0));
|
|
if (Z && !("Z" in d)) d.Z = 0;
|
|
if ("p" in d) d.H = d.H % 12 + d.p * 12;
|
|
if (d.m === void 0) d.m = "q" in d ? d.q : 0;
|
|
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 ? utcMonday.ceil(week) : utcMonday(week);
|
|
week = utcDay.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 ? timeMonday.ceil(week) : timeMonday(week);
|
|
week = timeDay.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 ("Z" in d) {
|
|
d.H += d.Z / 100 | 0;
|
|
d.M += d.Z % 100;
|
|
return utcDate(d);
|
|
}
|
|
return localDate(d);
|
|
};
|
|
}
|
|
__name(newParse, "newParse");
|
|
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;
|
|
}
|
|
__name(parseSpecifier, "parseSpecifier");
|
|
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;
|
|
}
|
|
__name(parsePeriod, "parsePeriod");
|
|
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;
|
|
}
|
|
__name(parseShortWeekday, "parseShortWeekday");
|
|
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;
|
|
}
|
|
__name(parseWeekday, "parseWeekday");
|
|
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;
|
|
}
|
|
__name(parseShortMonth, "parseShortMonth");
|
|
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;
|
|
}
|
|
__name(parseMonth, "parseMonth");
|
|
function parseLocaleDateTime(d, string, i) {
|
|
return parseSpecifier(d, locale_dateTime, string, i);
|
|
}
|
|
__name(parseLocaleDateTime, "parseLocaleDateTime");
|
|
function parseLocaleDate(d, string, i) {
|
|
return parseSpecifier(d, locale_date, string, i);
|
|
}
|
|
__name(parseLocaleDate, "parseLocaleDate");
|
|
function parseLocaleTime(d, string, i) {
|
|
return parseSpecifier(d, locale_time, string, i);
|
|
}
|
|
__name(parseLocaleTime, "parseLocaleTime");
|
|
function formatShortWeekday(d) {
|
|
return locale_shortWeekdays[d.getDay()];
|
|
}
|
|
__name(formatShortWeekday, "formatShortWeekday");
|
|
function formatWeekday(d) {
|
|
return locale_weekdays[d.getDay()];
|
|
}
|
|
__name(formatWeekday, "formatWeekday");
|
|
function formatShortMonth(d) {
|
|
return locale_shortMonths[d.getMonth()];
|
|
}
|
|
__name(formatShortMonth, "formatShortMonth");
|
|
function formatMonth(d) {
|
|
return locale_months[d.getMonth()];
|
|
}
|
|
__name(formatMonth, "formatMonth");
|
|
function formatPeriod(d) {
|
|
return locale_periods[+(d.getHours() >= 12)];
|
|
}
|
|
__name(formatPeriod, "formatPeriod");
|
|
function formatQuarter(d) {
|
|
return 1 + ~~(d.getMonth() / 3);
|
|
}
|
|
__name(formatQuarter, "formatQuarter");
|
|
function formatUTCShortWeekday(d) {
|
|
return locale_shortWeekdays[d.getUTCDay()];
|
|
}
|
|
__name(formatUTCShortWeekday, "formatUTCShortWeekday");
|
|
function formatUTCWeekday(d) {
|
|
return locale_weekdays[d.getUTCDay()];
|
|
}
|
|
__name(formatUTCWeekday, "formatUTCWeekday");
|
|
function formatUTCShortMonth(d) {
|
|
return locale_shortMonths[d.getUTCMonth()];
|
|
}
|
|
__name(formatUTCShortMonth, "formatUTCShortMonth");
|
|
function formatUTCMonth(d) {
|
|
return locale_months[d.getUTCMonth()];
|
|
}
|
|
__name(formatUTCMonth, "formatUTCMonth");
|
|
function formatUTCPeriod(d) {
|
|
return locale_periods[+(d.getUTCHours() >= 12)];
|
|
}
|
|
__name(formatUTCPeriod, "formatUTCPeriod");
|
|
function formatUTCQuarter(d) {
|
|
return 1 + ~~(d.getUTCMonth() / 3);
|
|
}
|
|
__name(formatUTCQuarter, "formatUTCQuarter");
|
|
return {
|
|
format: /* @__PURE__ */ __name(function(specifier) {
|
|
var f = newFormat(specifier += "", formats);
|
|
f.toString = function() {
|
|
return specifier;
|
|
};
|
|
return f;
|
|
}, "format"),
|
|
parse: /* @__PURE__ */ __name(function(specifier) {
|
|
var p = newParse(specifier += "", false);
|
|
p.toString = function() {
|
|
return specifier;
|
|
};
|
|
return p;
|
|
}, "parse"),
|
|
utcFormat: /* @__PURE__ */ __name(function(specifier) {
|
|
var f = newFormat(specifier += "", utcFormats);
|
|
f.toString = function() {
|
|
return specifier;
|
|
};
|
|
return f;
|
|
}, "utcFormat"),
|
|
utcParse: /* @__PURE__ */ __name(function(specifier) {
|
|
var p = newParse(specifier += "", true);
|
|
p.toString = function() {
|
|
return specifier;
|
|
};
|
|
return p;
|
|
}, "utcParse")
|
|
};
|
|
}
|
|
__name(formatLocale, "formatLocale");
|
|
var pads = { "-": "", "_": " ", "0": "0" };
|
|
var numberRe = /^\s*\d+/;
|
|
var percentRe = /^%/;
|
|
var requoteRe = /[\\^$*+?|[\]().{}]/g;
|
|
function pad(value, fill, width) {
|
|
var sign2 = value < 0 ? "-" : "", string = (sign2 ? -value : value) + "", length = string.length;
|
|
return sign2 + (length < width ? new Array(width - length + 1).join(fill) + string : string);
|
|
}
|
|
__name(pad, "pad");
|
|
function requote(s) {
|
|
return s.replace(requoteRe, "\\$&");
|
|
}
|
|
__name(requote, "requote");
|
|
function formatRe(names) {
|
|
return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
|
|
}
|
|
__name(formatRe, "formatRe");
|
|
function formatLookup(names) {
|
|
return new Map(names.map((name, i) => [name.toLowerCase(), i]));
|
|
}
|
|
__name(formatLookup, "formatLookup");
|
|
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;
|
|
}
|
|
__name(parseWeekdayNumberSunday, "parseWeekdayNumberSunday");
|
|
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;
|
|
}
|
|
__name(parseWeekdayNumberMonday, "parseWeekdayNumberMonday");
|
|
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;
|
|
}
|
|
__name(parseWeekNumberSunday, "parseWeekNumberSunday");
|
|
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;
|
|
}
|
|
__name(parseWeekNumberISO, "parseWeekNumberISO");
|
|
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;
|
|
}
|
|
__name(parseWeekNumberMonday, "parseWeekNumberMonday");
|
|
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;
|
|
}
|
|
__name(parseFullYear, "parseFullYear");
|
|
function parseYear(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 2));
|
|
return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2e3), i + n[0].length) : -1;
|
|
}
|
|
__name(parseYear, "parseYear");
|
|
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;
|
|
}
|
|
__name(parseZone, "parseZone");
|
|
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;
|
|
}
|
|
__name(parseQuarter, "parseQuarter");
|
|
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;
|
|
}
|
|
__name(parseMonthNumber, "parseMonthNumber");
|
|
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;
|
|
}
|
|
__name(parseDayOfMonth, "parseDayOfMonth");
|
|
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;
|
|
}
|
|
__name(parseDayOfYear, "parseDayOfYear");
|
|
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;
|
|
}
|
|
__name(parseHour24, "parseHour24");
|
|
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;
|
|
}
|
|
__name(parseMinutes, "parseMinutes");
|
|
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;
|
|
}
|
|
__name(parseSeconds, "parseSeconds");
|
|
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;
|
|
}
|
|
__name(parseMilliseconds, "parseMilliseconds");
|
|
function parseMicroseconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i, i + 6));
|
|
return n ? (d.L = Math.floor(n[0] / 1e3), i + n[0].length) : -1;
|
|
}
|
|
__name(parseMicroseconds, "parseMicroseconds");
|
|
function parseLiteralPercent(d, string, i) {
|
|
var n = percentRe.exec(string.slice(i, i + 1));
|
|
return n ? i + n[0].length : -1;
|
|
}
|
|
__name(parseLiteralPercent, "parseLiteralPercent");
|
|
function parseUnixTimestamp(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i));
|
|
return n ? (d.Q = +n[0], i + n[0].length) : -1;
|
|
}
|
|
__name(parseUnixTimestamp, "parseUnixTimestamp");
|
|
function parseUnixTimestampSeconds(d, string, i) {
|
|
var n = numberRe.exec(string.slice(i));
|
|
return n ? (d.s = +n[0], i + n[0].length) : -1;
|
|
}
|
|
__name(parseUnixTimestampSeconds, "parseUnixTimestampSeconds");
|
|
function formatDayOfMonth(d, p) {
|
|
return pad(d.getDate(), p, 2);
|
|
}
|
|
__name(formatDayOfMonth, "formatDayOfMonth");
|
|
function formatHour24(d, p) {
|
|
return pad(d.getHours(), p, 2);
|
|
}
|
|
__name(formatHour24, "formatHour24");
|
|
function formatHour12(d, p) {
|
|
return pad(d.getHours() % 12 || 12, p, 2);
|
|
}
|
|
__name(formatHour12, "formatHour12");
|
|
function formatDayOfYear(d, p) {
|
|
return pad(1 + timeDay.count(timeYear(d), d), p, 3);
|
|
}
|
|
__name(formatDayOfYear, "formatDayOfYear");
|
|
function formatMilliseconds(d, p) {
|
|
return pad(d.getMilliseconds(), p, 3);
|
|
}
|
|
__name(formatMilliseconds, "formatMilliseconds");
|
|
function formatMicroseconds(d, p) {
|
|
return formatMilliseconds(d, p) + "000";
|
|
}
|
|
__name(formatMicroseconds, "formatMicroseconds");
|
|
function formatMonthNumber(d, p) {
|
|
return pad(d.getMonth() + 1, p, 2);
|
|
}
|
|
__name(formatMonthNumber, "formatMonthNumber");
|
|
function formatMinutes(d, p) {
|
|
return pad(d.getMinutes(), p, 2);
|
|
}
|
|
__name(formatMinutes, "formatMinutes");
|
|
function formatSeconds(d, p) {
|
|
return pad(d.getSeconds(), p, 2);
|
|
}
|
|
__name(formatSeconds, "formatSeconds");
|
|
function formatWeekdayNumberMonday(d) {
|
|
var day = d.getDay();
|
|
return day === 0 ? 7 : day;
|
|
}
|
|
__name(formatWeekdayNumberMonday, "formatWeekdayNumberMonday");
|
|
function formatWeekNumberSunday(d, p) {
|
|
return pad(timeSunday.count(timeYear(d) - 1, d), p, 2);
|
|
}
|
|
__name(formatWeekNumberSunday, "formatWeekNumberSunday");
|
|
function dISO(d) {
|
|
var day = d.getDay();
|
|
return day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
|
|
}
|
|
__name(dISO, "dISO");
|
|
function formatWeekNumberISO(d, p) {
|
|
d = dISO(d);
|
|
return pad(timeThursday.count(timeYear(d), d) + (timeYear(d).getDay() === 4), p, 2);
|
|
}
|
|
__name(formatWeekNumberISO, "formatWeekNumberISO");
|
|
function formatWeekdayNumberSunday(d) {
|
|
return d.getDay();
|
|
}
|
|
__name(formatWeekdayNumberSunday, "formatWeekdayNumberSunday");
|
|
function formatWeekNumberMonday(d, p) {
|
|
return pad(timeMonday.count(timeYear(d) - 1, d), p, 2);
|
|
}
|
|
__name(formatWeekNumberMonday, "formatWeekNumberMonday");
|
|
function formatYear(d, p) {
|
|
return pad(d.getFullYear() % 100, p, 2);
|
|
}
|
|
__name(formatYear, "formatYear");
|
|
function formatYearISO(d, p) {
|
|
d = dISO(d);
|
|
return pad(d.getFullYear() % 100, p, 2);
|
|
}
|
|
__name(formatYearISO, "formatYearISO");
|
|
function formatFullYear(d, p) {
|
|
return pad(d.getFullYear() % 1e4, p, 4);
|
|
}
|
|
__name(formatFullYear, "formatFullYear");
|
|
function formatFullYearISO(d, p) {
|
|
var day = d.getDay();
|
|
d = day >= 4 || day === 0 ? timeThursday(d) : timeThursday.ceil(d);
|
|
return pad(d.getFullYear() % 1e4, p, 4);
|
|
}
|
|
__name(formatFullYearISO, "formatFullYearISO");
|
|
function formatZone(d) {
|
|
var z = d.getTimezoneOffset();
|
|
return (z > 0 ? "-" : (z *= -1, "+")) + pad(z / 60 | 0, "0", 2) + pad(z % 60, "0", 2);
|
|
}
|
|
__name(formatZone, "formatZone");
|
|
function formatUTCDayOfMonth(d, p) {
|
|
return pad(d.getUTCDate(), p, 2);
|
|
}
|
|
__name(formatUTCDayOfMonth, "formatUTCDayOfMonth");
|
|
function formatUTCHour24(d, p) {
|
|
return pad(d.getUTCHours(), p, 2);
|
|
}
|
|
__name(formatUTCHour24, "formatUTCHour24");
|
|
function formatUTCHour12(d, p) {
|
|
return pad(d.getUTCHours() % 12 || 12, p, 2);
|
|
}
|
|
__name(formatUTCHour12, "formatUTCHour12");
|
|
function formatUTCDayOfYear(d, p) {
|
|
return pad(1 + utcDay.count(utcYear(d), d), p, 3);
|
|
}
|
|
__name(formatUTCDayOfYear, "formatUTCDayOfYear");
|
|
function formatUTCMilliseconds(d, p) {
|
|
return pad(d.getUTCMilliseconds(), p, 3);
|
|
}
|
|
__name(formatUTCMilliseconds, "formatUTCMilliseconds");
|
|
function formatUTCMicroseconds(d, p) {
|
|
return formatUTCMilliseconds(d, p) + "000";
|
|
}
|
|
__name(formatUTCMicroseconds, "formatUTCMicroseconds");
|
|
function formatUTCMonthNumber(d, p) {
|
|
return pad(d.getUTCMonth() + 1, p, 2);
|
|
}
|
|
__name(formatUTCMonthNumber, "formatUTCMonthNumber");
|
|
function formatUTCMinutes(d, p) {
|
|
return pad(d.getUTCMinutes(), p, 2);
|
|
}
|
|
__name(formatUTCMinutes, "formatUTCMinutes");
|
|
function formatUTCSeconds(d, p) {
|
|
return pad(d.getUTCSeconds(), p, 2);
|
|
}
|
|
__name(formatUTCSeconds, "formatUTCSeconds");
|
|
function formatUTCWeekdayNumberMonday(d) {
|
|
var dow = d.getUTCDay();
|
|
return dow === 0 ? 7 : dow;
|
|
}
|
|
__name(formatUTCWeekdayNumberMonday, "formatUTCWeekdayNumberMonday");
|
|
function formatUTCWeekNumberSunday(d, p) {
|
|
return pad(utcSunday.count(utcYear(d) - 1, d), p, 2);
|
|
}
|
|
__name(formatUTCWeekNumberSunday, "formatUTCWeekNumberSunday");
|
|
function UTCdISO(d) {
|
|
var day = d.getUTCDay();
|
|
return day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
|
|
}
|
|
__name(UTCdISO, "UTCdISO");
|
|
function formatUTCWeekNumberISO(d, p) {
|
|
d = UTCdISO(d);
|
|
return pad(utcThursday.count(utcYear(d), d) + (utcYear(d).getUTCDay() === 4), p, 2);
|
|
}
|
|
__name(formatUTCWeekNumberISO, "formatUTCWeekNumberISO");
|
|
function formatUTCWeekdayNumberSunday(d) {
|
|
return d.getUTCDay();
|
|
}
|
|
__name(formatUTCWeekdayNumberSunday, "formatUTCWeekdayNumberSunday");
|
|
function formatUTCWeekNumberMonday(d, p) {
|
|
return pad(utcMonday.count(utcYear(d) - 1, d), p, 2);
|
|
}
|
|
__name(formatUTCWeekNumberMonday, "formatUTCWeekNumberMonday");
|
|
function formatUTCYear(d, p) {
|
|
return pad(d.getUTCFullYear() % 100, p, 2);
|
|
}
|
|
__name(formatUTCYear, "formatUTCYear");
|
|
function formatUTCYearISO(d, p) {
|
|
d = UTCdISO(d);
|
|
return pad(d.getUTCFullYear() % 100, p, 2);
|
|
}
|
|
__name(formatUTCYearISO, "formatUTCYearISO");
|
|
function formatUTCFullYear(d, p) {
|
|
return pad(d.getUTCFullYear() % 1e4, p, 4);
|
|
}
|
|
__name(formatUTCFullYear, "formatUTCFullYear");
|
|
function formatUTCFullYearISO(d, p) {
|
|
var day = d.getUTCDay();
|
|
d = day >= 4 || day === 0 ? utcThursday(d) : utcThursday.ceil(d);
|
|
return pad(d.getUTCFullYear() % 1e4, p, 4);
|
|
}
|
|
__name(formatUTCFullYearISO, "formatUTCFullYearISO");
|
|
function formatUTCZone() {
|
|
return "+0000";
|
|
}
|
|
__name(formatUTCZone, "formatUTCZone");
|
|
function formatLiteralPercent() {
|
|
return "%";
|
|
}
|
|
__name(formatLiteralPercent, "formatLiteralPercent");
|
|
function formatUnixTimestamp(d) {
|
|
return +d;
|
|
}
|
|
__name(formatUnixTimestamp, "formatUnixTimestamp");
|
|
function formatUnixTimestampSeconds(d) {
|
|
return Math.floor(+d / 1e3);
|
|
}
|
|
__name(formatUnixTimestampSeconds, "formatUnixTimestampSeconds");
|
|
|
|
// ../../node_modules/.pnpm/d3-time-format@4.1.0/node_modules/d3-time-format/src/defaultLocale.js
|
|
var locale2;
|
|
var timeFormat;
|
|
var timeParse;
|
|
var utcFormat;
|
|
var utcParse;
|
|
defaultLocale2({
|
|
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 defaultLocale2(definition) {
|
|
locale2 = formatLocale(definition);
|
|
timeFormat = locale2.format;
|
|
timeParse = locale2.parse;
|
|
utcFormat = locale2.utcFormat;
|
|
utcParse = locale2.utcParse;
|
|
return locale2;
|
|
}
|
|
__name(defaultLocale2, "defaultLocale");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/nice.js
|
|
function nice(domain, interval2) {
|
|
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] = interval2.floor(x0);
|
|
domain[i1] = interval2.ceil(x1);
|
|
return domain;
|
|
}
|
|
__name(nice, "nice");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/time.js
|
|
function date(t) {
|
|
return new Date(t);
|
|
}
|
|
__name(date, "date");
|
|
function number4(t) {
|
|
return t instanceof Date ? +t : +/* @__PURE__ */ new Date(+t);
|
|
}
|
|
__name(number4, "number");
|
|
function calendar(ticks2, tickInterval, year, month, week, day, hour, minute, second2, format3) {
|
|
var scale = continuous(), invert = scale.invert, domain = scale.domain;
|
|
var formatMillisecond = format3(".%L"), formatSecond = format3(":%S"), formatMinute = format3("%I:%M"), formatHour = format3("%I %p"), formatDay = format3("%a %d"), formatWeek = format3("%b %d"), formatMonth = format3("%B"), formatYear2 = format3("%Y");
|
|
function tickFormat2(date2) {
|
|
return (second2(date2) < date2 ? formatMillisecond : minute(date2) < date2 ? formatSecond : hour(date2) < date2 ? formatMinute : day(date2) < date2 ? formatHour : month(date2) < date2 ? week(date2) < date2 ? formatDay : formatWeek : year(date2) < date2 ? formatMonth : formatYear2)(date2);
|
|
}
|
|
__name(tickFormat2, "tickFormat");
|
|
scale.invert = function(y2) {
|
|
return new Date(invert(y2));
|
|
};
|
|
scale.domain = function(_) {
|
|
return arguments.length ? domain(Array.from(_, number4)) : domain().map(date);
|
|
};
|
|
scale.ticks = function(interval2) {
|
|
var d = domain();
|
|
return ticks2(d[0], d[d.length - 1], interval2 == null ? 10 : interval2);
|
|
};
|
|
scale.tickFormat = function(count2, specifier) {
|
|
return specifier == null ? tickFormat2 : format3(specifier);
|
|
};
|
|
scale.nice = function(interval2) {
|
|
var d = domain();
|
|
if (!interval2 || typeof interval2.range !== "function") interval2 = tickInterval(d[0], d[d.length - 1], interval2 == null ? 10 : interval2);
|
|
return interval2 ? domain(nice(d, interval2)) : scale;
|
|
};
|
|
scale.copy = function() {
|
|
return copy(scale, calendar(ticks2, tickInterval, year, month, week, day, hour, minute, second2, format3));
|
|
};
|
|
return scale;
|
|
}
|
|
__name(calendar, "calendar");
|
|
function time() {
|
|
return initRange.apply(calendar(timeTicks, timeTickInterval, timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute, second, timeFormat).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
|
|
}
|
|
__name(time, "time");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale@4.0.2/node_modules/d3-scale/src/band.js
|
|
function band() {
|
|
var scale = ordinal().unknown(void 0), domain = scale.domain, ordinalRange = scale.range, r0 = 0, r1 = 1, step, bandwidth, round = false, paddingInner = 0, paddingOuter = 0, align = 0.5;
|
|
delete scale.unknown;
|
|
function rescale() {
|
|
var n = domain().length, reverse = r1 < r0, start2 = reverse ? r1 : r0, stop = reverse ? r0 : r1;
|
|
step = (stop - start2) / Math.max(1, n - paddingInner + paddingOuter * 2);
|
|
if (round) step = Math.floor(step);
|
|
start2 += (stop - start2 - step * (n - paddingInner)) * align;
|
|
bandwidth = step * (1 - paddingInner);
|
|
if (round) start2 = Math.round(start2), bandwidth = Math.round(bandwidth);
|
|
var values = range(n).map(function(i) {
|
|
return start2 + step * i;
|
|
});
|
|
return ordinalRange(reverse ? values.reverse() : values);
|
|
}
|
|
__name(rescale, "rescale");
|
|
scale.domain = function(_) {
|
|
return arguments.length ? (domain(_), rescale()) : domain();
|
|
};
|
|
scale.range = function(_) {
|
|
return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
|
|
};
|
|
scale.rangeRound = function(_) {
|
|
return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
|
|
};
|
|
scale.bandwidth = function() {
|
|
return bandwidth;
|
|
};
|
|
scale.step = function() {
|
|
return step;
|
|
};
|
|
scale.round = function(_) {
|
|
return arguments.length ? (round = !!_, rescale()) : round;
|
|
};
|
|
scale.padding = function(_) {
|
|
return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
|
|
};
|
|
scale.paddingInner = function(_) {
|
|
return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
|
|
};
|
|
scale.paddingOuter = function(_) {
|
|
return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
|
|
};
|
|
scale.align = function(_) {
|
|
return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
|
|
};
|
|
scale.copy = function() {
|
|
return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
|
|
};
|
|
return initRange.apply(rescale(), arguments);
|
|
}
|
|
__name(band, "band");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale-chromatic@3.1.0/node_modules/d3-scale-chromatic/src/colors.js
|
|
function colors_default(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;
|
|
}
|
|
__name(colors_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-scale-chromatic@3.1.0/node_modules/d3-scale-chromatic/src/categorical/Tableau10.js
|
|
var Tableau10_default = colors_default("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/constant.js
|
|
function constant_default4(x2) {
|
|
return /* @__PURE__ */ __name(function constant() {
|
|
return x2;
|
|
}, "constant");
|
|
}
|
|
__name(constant_default4, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/math.js
|
|
var abs = Math.abs;
|
|
var atan2 = Math.atan2;
|
|
var cos = Math.cos;
|
|
var max2 = Math.max;
|
|
var min2 = Math.min;
|
|
var sin = Math.sin;
|
|
var sqrt = Math.sqrt;
|
|
var epsilon2 = 1e-12;
|
|
var pi = Math.PI;
|
|
var halfPi = pi / 2;
|
|
var tau = 2 * pi;
|
|
function acos(x2) {
|
|
return x2 > 1 ? 0 : x2 < -1 ? pi : Math.acos(x2);
|
|
}
|
|
__name(acos, "acos");
|
|
function asin(x2) {
|
|
return x2 >= 1 ? halfPi : x2 <= -1 ? -halfPi : Math.asin(x2);
|
|
}
|
|
__name(asin, "asin");
|
|
|
|
// ../../node_modules/.pnpm/d3-path@3.1.0/node_modules/d3-path/src/path.js
|
|
var pi2 = Math.PI;
|
|
var tau2 = 2 * pi2;
|
|
var epsilon3 = 1e-6;
|
|
var tauEpsilon = tau2 - epsilon3;
|
|
function append(strings) {
|
|
this._ += strings[0];
|
|
for (let i = 1, n = strings.length; i < n; ++i) {
|
|
this._ += arguments[i] + strings[i];
|
|
}
|
|
}
|
|
__name(append, "append");
|
|
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];
|
|
}
|
|
};
|
|
}
|
|
__name(appendRound, "appendRound");
|
|
var Path = class {
|
|
static {
|
|
__name(this, "Path");
|
|
}
|
|
constructor(digits) {
|
|
this._x0 = this._y0 = // start of current subpath
|
|
this._x1 = this._y1 = null;
|
|
this._ = "";
|
|
this._append = digits == null ? append : appendRound(digits);
|
|
}
|
|
moveTo(x2, y2) {
|
|
this._append`M${this._x0 = this._x1 = +x2},${this._y0 = this._y1 = +y2}`;
|
|
}
|
|
closePath() {
|
|
if (this._x1 !== null) {
|
|
this._x1 = this._x0, this._y1 = this._y0;
|
|
this._append`Z`;
|
|
}
|
|
}
|
|
lineTo(x2, y2) {
|
|
this._append`L${this._x1 = +x2},${this._y1 = +y2}`;
|
|
}
|
|
quadraticCurveTo(x1, y1, x2, y2) {
|
|
this._append`Q${+x1},${+y1},${this._x1 = +x2},${this._y1 = +y2}`;
|
|
}
|
|
bezierCurveTo(x1, y1, x2, y2, x3, y3) {
|
|
this._append`C${+x1},${+y1},${+x2},${+y2},${this._x1 = +x3},${this._y1 = +y3}`;
|
|
}
|
|
arcTo(x1, y1, x2, y2, r) {
|
|
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
|
|
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;
|
|
if (this._x1 === null) {
|
|
this._append`M${this._x1 = x1},${this._y1 = y1}`;
|
|
} else if (!(l01_2 > epsilon3)) ;
|
|
else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon3) || !r) {
|
|
this._append`L${this._x1 = x1},${this._y1 = y1}`;
|
|
} 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((pi2 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l / l01, t21 = l / l21;
|
|
if (Math.abs(t01 - 1) > epsilon3) {
|
|
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(x2, y2, r, a0, a1, ccw) {
|
|
x2 = +x2, y2 = +y2, r = +r, ccw = !!ccw;
|
|
if (r < 0) throw new Error(`negative radius: ${r}`);
|
|
let dx = r * Math.cos(a0), dy = r * Math.sin(a0), x0 = x2 + dx, y0 = y2 + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0;
|
|
if (this._x1 === null) {
|
|
this._append`M${x0},${y0}`;
|
|
} else if (Math.abs(this._x1 - x0) > epsilon3 || Math.abs(this._y1 - y0) > epsilon3) {
|
|
this._append`L${x0},${y0}`;
|
|
}
|
|
if (!r) return;
|
|
if (da < 0) da = da % tau2 + tau2;
|
|
if (da > tauEpsilon) {
|
|
this._append`A${r},${r},0,1,${cw},${x2 - dx},${y2 - dy}A${r},${r},0,1,${cw},${this._x1 = x0},${this._y1 = y0}`;
|
|
} else if (da > epsilon3) {
|
|
this._append`A${r},${r},0,${+(da >= pi2)},${cw},${this._x1 = x2 + r * Math.cos(a1)},${this._y1 = y2 + r * Math.sin(a1)}`;
|
|
}
|
|
}
|
|
rect(x2, y2, w, h) {
|
|
this._append`M${this._x0 = this._x1 = +x2},${this._y0 = this._y1 = +y2}h${w = +w}v${+h}h${-w}Z`;
|
|
}
|
|
toString() {
|
|
return this._;
|
|
}
|
|
};
|
|
function path() {
|
|
return new Path();
|
|
}
|
|
__name(path, "path");
|
|
path.prototype = Path.prototype;
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/path.js
|
|
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 Path(digits);
|
|
}
|
|
__name(withPath, "withPath");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/arc.js
|
|
function arcInnerRadius(d) {
|
|
return d.innerRadius;
|
|
}
|
|
__name(arcInnerRadius, "arcInnerRadius");
|
|
function arcOuterRadius(d) {
|
|
return d.outerRadius;
|
|
}
|
|
__name(arcOuterRadius, "arcOuterRadius");
|
|
function arcStartAngle(d) {
|
|
return d.startAngle;
|
|
}
|
|
__name(arcStartAngle, "arcStartAngle");
|
|
function arcEndAngle(d) {
|
|
return d.endAngle;
|
|
}
|
|
__name(arcEndAngle, "arcEndAngle");
|
|
function arcPadAngle(d) {
|
|
return d && d.padAngle;
|
|
}
|
|
__name(arcPadAngle, "arcPadAngle");
|
|
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 < epsilon2) return;
|
|
t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
|
|
return [x0 + t * x10, y0 + t * y10];
|
|
}
|
|
__name(intersect, "intersect");
|
|
function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
|
|
var x01 = x0 - x1, y01 = y0 - y1, lo = (cw ? rc : -rc) / sqrt(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) * sqrt(max2(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;
|
|
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)
|
|
};
|
|
}
|
|
__name(cornerTangents, "cornerTangents");
|
|
function arc_default() {
|
|
var innerRadius = arcInnerRadius, outerRadius = arcOuterRadius, cornerRadius = constant_default4(0), padRadius = null, startAngle = arcStartAngle, endAngle = arcEndAngle, padAngle = arcPadAngle, context = null, path2 = withPath(arc);
|
|
function arc() {
|
|
var buffer, r, r0 = +innerRadius.apply(this, arguments), r1 = +outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) - halfPi, a1 = endAngle.apply(this, arguments) - halfPi, da = abs(a1 - a0), cw = a1 > a0;
|
|
if (!context) context = buffer = path2();
|
|
if (r1 < r0) r = r1, r1 = r0, r0 = r;
|
|
if (!(r1 > epsilon2)) context.moveTo(0, 0);
|
|
else if (da > tau - epsilon2) {
|
|
context.moveTo(r1 * cos(a0), r1 * sin(a0));
|
|
context.arc(0, 0, r1, a0, a1, !cw);
|
|
if (r0 > epsilon2) {
|
|
context.moveTo(r0 * cos(a1), r0 * sin(a1));
|
|
context.arc(0, 0, r0, a1, a0, cw);
|
|
}
|
|
} else {
|
|
var a01 = a0, a11 = a1, a00 = a0, a10 = a1, da0 = da, da1 = da, ap = padAngle.apply(this, arguments) / 2, rp = ap > epsilon2 && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), rc = min2(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), rc0 = rc, rc1 = rc, t03, t13;
|
|
if (rp > epsilon2) {
|
|
var p0 = asin(rp / r0 * sin(ap)), p1 = asin(rp / r1 * sin(ap));
|
|
if ((da0 -= p0 * 2) > epsilon2) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;
|
|
else da0 = 0, a00 = a10 = (a0 + a1) / 2;
|
|
if ((da1 -= p1 * 2) > epsilon2) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;
|
|
else da1 = 0, a01 = a11 = (a0 + a1) / 2;
|
|
}
|
|
var x01 = r1 * cos(a01), y01 = r1 * sin(a01), x10 = r0 * cos(a10), y10 = r0 * sin(a10);
|
|
if (rc > epsilon2) {
|
|
var x11 = r1 * cos(a11), y11 = r1 * sin(a11), x00 = r0 * cos(a00), y00 = r0 * sin(a00), oc;
|
|
if (da < 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 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
|
|
rc0 = min2(rc, (r0 - lc) / (kc - 1));
|
|
rc1 = min2(rc, (r1 - lc) / (kc + 1));
|
|
} else {
|
|
rc0 = rc1 = 0;
|
|
}
|
|
}
|
|
}
|
|
if (!(da1 > epsilon2)) context.moveTo(x01, y01);
|
|
else if (rc1 > epsilon2) {
|
|
t03 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
|
|
t13 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
|
|
context.moveTo(t03.cx + t03.x01, t03.cy + t03.y01);
|
|
if (rc1 < rc) context.arc(t03.cx, t03.cy, rc1, atan2(t03.y01, t03.x01), atan2(t13.y01, t13.x01), !cw);
|
|
else {
|
|
context.arc(t03.cx, t03.cy, rc1, atan2(t03.y01, t03.x01), atan2(t03.y11, t03.x11), !cw);
|
|
context.arc(0, 0, r1, atan2(t03.cy + t03.y11, t03.cx + t03.x11), atan2(t13.cy + t13.y11, t13.cx + t13.x11), !cw);
|
|
context.arc(t13.cx, t13.cy, rc1, atan2(t13.y11, t13.x11), atan2(t13.y01, t13.x01), !cw);
|
|
}
|
|
} else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
|
|
if (!(r0 > epsilon2) || !(da0 > epsilon2)) context.lineTo(x10, y10);
|
|
else if (rc0 > epsilon2) {
|
|
t03 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
|
|
t13 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
|
|
context.lineTo(t03.cx + t03.x01, t03.cy + t03.y01);
|
|
if (rc0 < rc) context.arc(t03.cx, t03.cy, rc0, atan2(t03.y01, t03.x01), atan2(t13.y01, t13.x01), !cw);
|
|
else {
|
|
context.arc(t03.cx, t03.cy, rc0, atan2(t03.y01, t03.x01), atan2(t03.y11, t03.x11), !cw);
|
|
context.arc(0, 0, r0, atan2(t03.cy + t03.y11, t03.cx + t03.x11), atan2(t13.cy + t13.y11, t13.cx + t13.x11), cw);
|
|
context.arc(t13.cx, t13.cy, rc0, atan2(t13.y11, t13.x11), atan2(t13.y01, t13.x01), !cw);
|
|
}
|
|
} else context.arc(0, 0, r0, a10, a00, cw);
|
|
}
|
|
context.closePath();
|
|
if (buffer) return context = null, buffer + "" || null;
|
|
}
|
|
__name(arc, "arc");
|
|
arc.centroid = function() {
|
|
var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2;
|
|
return [cos(a) * r, sin(a) * r];
|
|
};
|
|
arc.innerRadius = function(_) {
|
|
return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant_default4(+_), arc) : innerRadius;
|
|
};
|
|
arc.outerRadius = function(_) {
|
|
return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant_default4(+_), arc) : outerRadius;
|
|
};
|
|
arc.cornerRadius = function(_) {
|
|
return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant_default4(+_), arc) : cornerRadius;
|
|
};
|
|
arc.padRadius = function(_) {
|
|
return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant_default4(+_), arc) : padRadius;
|
|
};
|
|
arc.startAngle = function(_) {
|
|
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default4(+_), arc) : startAngle;
|
|
};
|
|
arc.endAngle = function(_) {
|
|
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default4(+_), arc) : endAngle;
|
|
};
|
|
arc.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default4(+_), arc) : padAngle;
|
|
};
|
|
arc.context = function(_) {
|
|
return arguments.length ? (context = _ == null ? null : _, arc) : context;
|
|
};
|
|
return arc;
|
|
}
|
|
__name(arc_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/linear.js
|
|
function Linear(context) {
|
|
this._context = context;
|
|
}
|
|
__name(Linear, "Linear");
|
|
Linear.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
// falls through
|
|
default:
|
|
this._context.lineTo(x2, y2);
|
|
break;
|
|
}
|
|
}, "point")
|
|
};
|
|
function linear_default(context) {
|
|
return new Linear(context);
|
|
}
|
|
__name(linear_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/array.js
|
|
var slice = Array.prototype.slice;
|
|
function array_default(x2) {
|
|
return typeof x2 === "object" && "length" in x2 ? x2 : Array.from(x2);
|
|
}
|
|
__name(array_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/point.js
|
|
function x(p) {
|
|
return p[0];
|
|
}
|
|
__name(x, "x");
|
|
function y(p) {
|
|
return p[1];
|
|
}
|
|
__name(y, "y");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/line.js
|
|
function line_default(x2, y2) {
|
|
var defined = constant_default4(true), context = null, curve = linear_default, output = null, path2 = withPath(line);
|
|
x2 = typeof x2 === "function" ? x2 : x2 === void 0 ? x : constant_default4(x2);
|
|
y2 = typeof y2 === "function" ? y2 : y2 === void 0 ? y : constant_default4(y2);
|
|
function line(data) {
|
|
var i, n = (data = array_default(data)).length, d, defined0 = false, buffer;
|
|
if (context == null) output = curve(buffer = path2());
|
|
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(+x2(d, i, data), +y2(d, i, data));
|
|
}
|
|
if (buffer) return output = null, buffer + "" || null;
|
|
}
|
|
__name(line, "line");
|
|
line.x = function(_) {
|
|
return arguments.length ? (x2 = typeof _ === "function" ? _ : constant_default4(+_), line) : x2;
|
|
};
|
|
line.y = function(_) {
|
|
return arguments.length ? (y2 = typeof _ === "function" ? _ : constant_default4(+_), line) : y2;
|
|
};
|
|
line.defined = function(_) {
|
|
return arguments.length ? (defined = typeof _ === "function" ? _ : constant_default4(!!_), 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;
|
|
}
|
|
__name(line_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/descending.js
|
|
function descending_default(a, b) {
|
|
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
|
|
}
|
|
__name(descending_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/identity.js
|
|
function identity_default3(d) {
|
|
return d;
|
|
}
|
|
__name(identity_default3, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/pie.js
|
|
function pie_default() {
|
|
var value = identity_default3, sortValues = descending_default, sort = null, startAngle = constant_default4(0), endAngle = constant_default4(tau), padAngle = constant_default4(0);
|
|
function pie(data) {
|
|
var i, n = (data = array_default(data)).length, j, k, sum = 0, index = new Array(n), arcs = new Array(n), a0 = +startAngle.apply(this, arguments), da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), a1, p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), pa = p * (da < 0 ? -1 : 1), v;
|
|
for (i = 0; i < n; ++i) {
|
|
if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) {
|
|
sum += v;
|
|
}
|
|
}
|
|
if (sortValues != null) index.sort(function(i2, j2) {
|
|
return sortValues(arcs[i2], arcs[j2]);
|
|
});
|
|
else if (sort != null) index.sort(function(i2, j2) {
|
|
return sort(data[i2], data[j2]);
|
|
});
|
|
for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) {
|
|
j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = {
|
|
data: data[j],
|
|
index: i,
|
|
value: v,
|
|
startAngle: a0,
|
|
endAngle: a1,
|
|
padAngle: p
|
|
};
|
|
}
|
|
return arcs;
|
|
}
|
|
__name(pie, "pie");
|
|
pie.value = function(_) {
|
|
return arguments.length ? (value = typeof _ === "function" ? _ : constant_default4(+_), pie) : value;
|
|
};
|
|
pie.sortValues = function(_) {
|
|
return arguments.length ? (sortValues = _, sort = null, pie) : sortValues;
|
|
};
|
|
pie.sort = function(_) {
|
|
return arguments.length ? (sort = _, sortValues = null, pie) : sort;
|
|
};
|
|
pie.startAngle = function(_) {
|
|
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant_default4(+_), pie) : startAngle;
|
|
};
|
|
pie.endAngle = function(_) {
|
|
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant_default4(+_), pie) : endAngle;
|
|
};
|
|
pie.padAngle = function(_) {
|
|
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant_default4(+_), pie) : padAngle;
|
|
};
|
|
return pie;
|
|
}
|
|
__name(pie_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/bump.js
|
|
var Bump = class {
|
|
static {
|
|
__name(this, "Bump");
|
|
}
|
|
constructor(context, x2) {
|
|
this._context = context;
|
|
this._x = x2;
|
|
}
|
|
areaStart() {
|
|
this._line = 0;
|
|
}
|
|
areaEnd() {
|
|
this._line = NaN;
|
|
}
|
|
lineStart() {
|
|
this._point = 0;
|
|
}
|
|
lineEnd() {
|
|
if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}
|
|
point(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0: {
|
|
this._point = 1;
|
|
if (this._line) this._context.lineTo(x2, y2);
|
|
else this._context.moveTo(x2, y2);
|
|
break;
|
|
}
|
|
case 1:
|
|
this._point = 2;
|
|
// falls through
|
|
default: {
|
|
if (this._x) this._context.bezierCurveTo(this._x0 = (this._x0 + x2) / 2, this._y0, this._x0, y2, x2, y2);
|
|
else this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + y2) / 2, x2, this._y0, x2, y2);
|
|
break;
|
|
}
|
|
}
|
|
this._x0 = x2, this._y0 = y2;
|
|
}
|
|
};
|
|
function bumpX(context) {
|
|
return new Bump(context, true);
|
|
}
|
|
__name(bumpX, "bumpX");
|
|
function bumpY(context) {
|
|
return new Bump(context, false);
|
|
}
|
|
__name(bumpY, "bumpY");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basis.js
|
|
function point2(that, x2, y2) {
|
|
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 + x2) / 6,
|
|
(that._y0 + 4 * that._y1 + y2) / 6
|
|
);
|
|
}
|
|
__name(point2, "point");
|
|
function Basis(context) {
|
|
this._context = context;
|
|
}
|
|
__name(Basis, "Basis");
|
|
Basis.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
switch (this._point) {
|
|
case 3:
|
|
point2(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;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
|
|
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:
|
|
point2(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = x2;
|
|
this._y0 = this._y1, this._y1 = y2;
|
|
}, "point")
|
|
};
|
|
function basis_default2(context) {
|
|
return new Basis(context);
|
|
}
|
|
__name(basis_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/noop.js
|
|
function noop_default() {
|
|
}
|
|
__name(noop_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basisClosed.js
|
|
function BasisClosed(context) {
|
|
this._context = context;
|
|
}
|
|
__name(BasisClosed, "BasisClosed");
|
|
BasisClosed.prototype = {
|
|
areaStart: noop_default,
|
|
areaEnd: noop_default,
|
|
lineStart: /* @__PURE__ */ __name(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;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(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;
|
|
}
|
|
}
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._x2 = x2, this._y2 = y2;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
this._x3 = x2, this._y3 = y2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
this._x4 = x2, this._y4 = y2;
|
|
this._context.moveTo((this._x0 + 4 * this._x1 + x2) / 6, (this._y0 + 4 * this._y1 + y2) / 6);
|
|
break;
|
|
default:
|
|
point2(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = x2;
|
|
this._y0 = this._y1, this._y1 = y2;
|
|
}, "point")
|
|
};
|
|
function basisClosed_default2(context) {
|
|
return new BasisClosed(context);
|
|
}
|
|
__name(basisClosed_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/basisOpen.js
|
|
function BasisOpen(context) {
|
|
this._context = context;
|
|
}
|
|
__name(BasisOpen, "BasisOpen");
|
|
BasisOpen.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
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 + x2) / 6, y0 = (this._y0 + 4 * this._y1 + y2) / 6;
|
|
this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0);
|
|
break;
|
|
case 3:
|
|
this._point = 4;
|
|
// falls through
|
|
default:
|
|
point2(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = x2;
|
|
this._y0 = this._y1, this._y1 = y2;
|
|
}, "point")
|
|
};
|
|
function basisOpen_default(context) {
|
|
return new BasisOpen(context);
|
|
}
|
|
__name(basisOpen_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/bundle.js
|
|
function Bundle(context, beta) {
|
|
this._basis = new Basis(context);
|
|
this._beta = beta;
|
|
}
|
|
__name(Bundle, "Bundle");
|
|
Bundle.prototype = {
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x = [];
|
|
this._y = [];
|
|
this._basis.lineStart();
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
var x2 = this._x, y2 = this._y, j = x2.length - 1;
|
|
if (j > 0) {
|
|
var x0 = x2[0], y0 = y2[0], dx = x2[j] - x0, dy = y2[j] - y0, i = -1, t;
|
|
while (++i <= j) {
|
|
t = i / j;
|
|
this._basis.point(
|
|
this._beta * x2[i] + (1 - this._beta) * (x0 + t * dx),
|
|
this._beta * y2[i] + (1 - this._beta) * (y0 + t * dy)
|
|
);
|
|
}
|
|
}
|
|
this._x = this._y = null;
|
|
this._basis.lineEnd();
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
this._x.push(+x2);
|
|
this._y.push(+y2);
|
|
}, "point")
|
|
};
|
|
var bundle_default = (/* @__PURE__ */ __name((function custom2(beta) {
|
|
function bundle(context) {
|
|
return beta === 1 ? new Basis(context) : new Bundle(context, beta);
|
|
}
|
|
__name(bundle, "bundle");
|
|
bundle.beta = function(beta2) {
|
|
return custom2(+beta2);
|
|
};
|
|
return bundle;
|
|
}), "custom"))(0.85);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinal.js
|
|
function point3(that, x2, y2) {
|
|
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 - x2),
|
|
that._y2 + that._k * (that._y1 - y2),
|
|
that._x2,
|
|
that._y2
|
|
);
|
|
}
|
|
__name(point3, "point");
|
|
function Cardinal(context, tension) {
|
|
this._context = context;
|
|
this._k = (1 - tension) / 6;
|
|
}
|
|
__name(Cardinal, "Cardinal");
|
|
Cardinal.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
switch (this._point) {
|
|
case 2:
|
|
this._context.lineTo(this._x2, this._y2);
|
|
break;
|
|
case 3:
|
|
point3(this, this._x1, this._y1);
|
|
break;
|
|
}
|
|
if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
this._x1 = x2, this._y1 = y2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
// falls through
|
|
default:
|
|
point3(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var cardinal_default = (/* @__PURE__ */ __name((function custom3(tension) {
|
|
function cardinal(context) {
|
|
return new Cardinal(context, tension);
|
|
}
|
|
__name(cardinal, "cardinal");
|
|
cardinal.tension = function(tension2) {
|
|
return custom3(+tension2);
|
|
};
|
|
return cardinal;
|
|
}), "custom"))(0);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinalClosed.js
|
|
function CardinalClosed(context, tension) {
|
|
this._context = context;
|
|
this._k = (1 - tension) / 6;
|
|
}
|
|
__name(CardinalClosed, "CardinalClosed");
|
|
CardinalClosed.prototype = {
|
|
areaStart: noop_default,
|
|
areaEnd: noop_default,
|
|
lineStart: /* @__PURE__ */ __name(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;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(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;
|
|
}
|
|
}
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._x3 = x2, this._y3 = y2;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
this._context.moveTo(this._x4 = x2, this._y4 = y2);
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
this._x5 = x2, this._y5 = y2;
|
|
break;
|
|
default:
|
|
point3(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var cardinalClosed_default = (/* @__PURE__ */ __name((function custom4(tension) {
|
|
function cardinal(context) {
|
|
return new CardinalClosed(context, tension);
|
|
}
|
|
__name(cardinal, "cardinal");
|
|
cardinal.tension = function(tension2) {
|
|
return custom4(+tension2);
|
|
};
|
|
return cardinal;
|
|
}), "custom"))(0);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/cardinalOpen.js
|
|
function CardinalOpen(context, tension) {
|
|
this._context = context;
|
|
this._k = (1 - tension) / 6;
|
|
}
|
|
__name(CardinalOpen, "CardinalOpen");
|
|
CardinalOpen.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
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:
|
|
point3(this, x2, y2);
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var cardinalOpen_default = (/* @__PURE__ */ __name((function custom5(tension) {
|
|
function cardinal(context) {
|
|
return new CardinalOpen(context, tension);
|
|
}
|
|
__name(cardinal, "cardinal");
|
|
cardinal.tension = function(tension2) {
|
|
return custom5(+tension2);
|
|
};
|
|
return cardinal;
|
|
}), "custom"))(0);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRom.js
|
|
function point4(that, x2, y2) {
|
|
var x1 = that._x1, y1 = that._y1, x22 = that._x2, y22 = that._y2;
|
|
if (that._l01_a > epsilon2) {
|
|
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 > epsilon2) {
|
|
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);
|
|
x22 = (x22 * b + that._x1 * that._l23_2a - x2 * that._l12_2a) / m;
|
|
y22 = (y22 * b + that._y1 * that._l23_2a - y2 * that._l12_2a) / m;
|
|
}
|
|
that._context.bezierCurveTo(x1, y1, x22, y22, that._x2, that._y2);
|
|
}
|
|
__name(point4, "point");
|
|
function CatmullRom(context, alpha) {
|
|
this._context = context;
|
|
this._alpha = alpha;
|
|
}
|
|
__name(CatmullRom, "CatmullRom");
|
|
CatmullRom.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(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;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(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;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
if (this._point) {
|
|
var x23 = this._x2 - x2, y23 = this._y2 - y2;
|
|
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(x2, y2) : this._context.moveTo(x2, y2);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
// falls through
|
|
default:
|
|
point4(this, x2, y2);
|
|
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 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var catmullRom_default = (/* @__PURE__ */ __name((function custom6(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);
|
|
}
|
|
__name(catmullRom, "catmullRom");
|
|
catmullRom.alpha = function(alpha2) {
|
|
return custom6(+alpha2);
|
|
};
|
|
return catmullRom;
|
|
}), "custom"))(0.5);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRomClosed.js
|
|
function CatmullRomClosed(context, alpha) {
|
|
this._context = context;
|
|
this._alpha = alpha;
|
|
}
|
|
__name(CatmullRomClosed, "CatmullRomClosed");
|
|
CatmullRomClosed.prototype = {
|
|
areaStart: noop_default,
|
|
areaEnd: noop_default,
|
|
lineStart: /* @__PURE__ */ __name(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;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(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;
|
|
}
|
|
}
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
if (this._point) {
|
|
var x23 = this._x2 - x2, y23 = this._y2 - y2;
|
|
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 = x2, this._y3 = y2;
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
this._context.moveTo(this._x4 = x2, this._y4 = y2);
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
this._x5 = x2, this._y5 = y2;
|
|
break;
|
|
default:
|
|
point4(this, x2, y2);
|
|
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 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var catmullRomClosed_default = (/* @__PURE__ */ __name((function custom7(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);
|
|
}
|
|
__name(catmullRom, "catmullRom");
|
|
catmullRom.alpha = function(alpha2) {
|
|
return custom7(+alpha2);
|
|
};
|
|
return catmullRom;
|
|
}), "custom"))(0.5);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/catmullRomOpen.js
|
|
function CatmullRomOpen(context, alpha) {
|
|
this._context = context;
|
|
this._alpha = alpha;
|
|
}
|
|
__name(CatmullRomOpen, "CatmullRomOpen");
|
|
CatmullRomOpen.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(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;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
if (this._point) {
|
|
var x23 = this._x2 - x2, y23 = this._y2 - y2;
|
|
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:
|
|
point4(this, x2, y2);
|
|
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 = x2;
|
|
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y2;
|
|
}, "point")
|
|
};
|
|
var catmullRomOpen_default = (/* @__PURE__ */ __name((function custom8(alpha) {
|
|
function catmullRom(context) {
|
|
return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);
|
|
}
|
|
__name(catmullRom, "catmullRom");
|
|
catmullRom.alpha = function(alpha2) {
|
|
return custom8(+alpha2);
|
|
};
|
|
return catmullRom;
|
|
}), "custom"))(0.5);
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/linearClosed.js
|
|
function LinearClosed(context) {
|
|
this._context = context;
|
|
}
|
|
__name(LinearClosed, "LinearClosed");
|
|
LinearClosed.prototype = {
|
|
areaStart: noop_default,
|
|
areaEnd: noop_default,
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
if (this._point) this._context.closePath();
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
if (this._point) this._context.lineTo(x2, y2);
|
|
else this._point = 1, this._context.moveTo(x2, y2);
|
|
}, "point")
|
|
};
|
|
function linearClosed_default(context) {
|
|
return new LinearClosed(context);
|
|
}
|
|
__name(linearClosed_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/monotone.js
|
|
function sign(x2) {
|
|
return x2 < 0 ? -1 : 1;
|
|
}
|
|
__name(sign, "sign");
|
|
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;
|
|
}
|
|
__name(slope3, "slope3");
|
|
function slope2(that, t) {
|
|
var h = that._x1 - that._x0;
|
|
return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
|
|
}
|
|
__name(slope2, "slope2");
|
|
function point5(that, t03, t13) {
|
|
var x0 = that._x0, y0 = that._y0, x1 = that._x1, y1 = that._y1, dx = (x1 - x0) / 3;
|
|
that._context.bezierCurveTo(x0 + dx, y0 + dx * t03, x1 - dx, y1 - dx * t13, x1, y1);
|
|
}
|
|
__name(point5, "point");
|
|
function MonotoneX(context) {
|
|
this._context = context;
|
|
}
|
|
__name(MonotoneX, "MonotoneX");
|
|
MonotoneX.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
switch (this._point) {
|
|
case 2:
|
|
this._context.lineTo(this._x1, this._y1);
|
|
break;
|
|
case 3:
|
|
point5(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;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
var t13 = NaN;
|
|
x2 = +x2, y2 = +y2;
|
|
if (x2 === this._x1 && y2 === this._y1) return;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
break;
|
|
case 2:
|
|
this._point = 3;
|
|
point5(this, slope2(this, t13 = slope3(this, x2, y2)), t13);
|
|
break;
|
|
default:
|
|
point5(this, this._t0, t13 = slope3(this, x2, y2));
|
|
break;
|
|
}
|
|
this._x0 = this._x1, this._x1 = x2;
|
|
this._y0 = this._y1, this._y1 = y2;
|
|
this._t0 = t13;
|
|
}, "point")
|
|
};
|
|
function MonotoneY(context) {
|
|
this._context = new ReflectContext(context);
|
|
}
|
|
__name(MonotoneY, "MonotoneY");
|
|
(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x2, y2) {
|
|
MonotoneX.prototype.point.call(this, y2, x2);
|
|
};
|
|
function ReflectContext(context) {
|
|
this._context = context;
|
|
}
|
|
__name(ReflectContext, "ReflectContext");
|
|
ReflectContext.prototype = {
|
|
moveTo: /* @__PURE__ */ __name(function(x2, y2) {
|
|
this._context.moveTo(y2, x2);
|
|
}, "moveTo"),
|
|
closePath: /* @__PURE__ */ __name(function() {
|
|
this._context.closePath();
|
|
}, "closePath"),
|
|
lineTo: /* @__PURE__ */ __name(function(x2, y2) {
|
|
this._context.lineTo(y2, x2);
|
|
}, "lineTo"),
|
|
bezierCurveTo: /* @__PURE__ */ __name(function(x1, y1, x2, y2, x3, y3) {
|
|
this._context.bezierCurveTo(y1, x1, y2, x2, y3, x3);
|
|
}, "bezierCurveTo")
|
|
};
|
|
function monotoneX(context) {
|
|
return new MonotoneX(context);
|
|
}
|
|
__name(monotoneX, "monotoneX");
|
|
function monotoneY(context) {
|
|
return new MonotoneY(context);
|
|
}
|
|
__name(monotoneY, "monotoneY");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/natural.js
|
|
function Natural(context) {
|
|
this._context = context;
|
|
}
|
|
__name(Natural, "Natural");
|
|
Natural.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x = [];
|
|
this._y = [];
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(function() {
|
|
var x2 = this._x, y2 = this._y, n = x2.length;
|
|
if (n) {
|
|
this._line ? this._context.lineTo(x2[0], y2[0]) : this._context.moveTo(x2[0], y2[0]);
|
|
if (n === 2) {
|
|
this._context.lineTo(x2[1], y2[1]);
|
|
} else {
|
|
var px = controlPoints(x2), py = controlPoints(y2);
|
|
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], x2[i1], y2[i1]);
|
|
}
|
|
}
|
|
}
|
|
if (this._line || this._line !== 0 && n === 1) this._context.closePath();
|
|
this._line = 1 - this._line;
|
|
this._x = this._y = null;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
this._x.push(+x2);
|
|
this._y.push(+y2);
|
|
}, "point")
|
|
};
|
|
function controlPoints(x2) {
|
|
var i, n = x2.length - 1, m, a = new Array(n), b = new Array(n), r = new Array(n);
|
|
a[0] = 0, b[0] = 2, r[0] = x2[0] + 2 * x2[1];
|
|
for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x2[i] + 2 * x2[i + 1];
|
|
a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x2[n - 1] + x2[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] = (x2[n] + a[n - 1]) / 2;
|
|
for (i = 0; i < n - 1; ++i) b[i] = 2 * x2[i + 1] - a[i + 1];
|
|
return [a, b];
|
|
}
|
|
__name(controlPoints, "controlPoints");
|
|
function natural_default(context) {
|
|
return new Natural(context);
|
|
}
|
|
__name(natural_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-shape@3.2.0/node_modules/d3-shape/src/curve/step.js
|
|
function Step(context, t) {
|
|
this._context = context;
|
|
this._t = t;
|
|
}
|
|
__name(Step, "Step");
|
|
Step.prototype = {
|
|
areaStart: /* @__PURE__ */ __name(function() {
|
|
this._line = 0;
|
|
}, "areaStart"),
|
|
areaEnd: /* @__PURE__ */ __name(function() {
|
|
this._line = NaN;
|
|
}, "areaEnd"),
|
|
lineStart: /* @__PURE__ */ __name(function() {
|
|
this._x = this._y = NaN;
|
|
this._point = 0;
|
|
}, "lineStart"),
|
|
lineEnd: /* @__PURE__ */ __name(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;
|
|
}, "lineEnd"),
|
|
point: /* @__PURE__ */ __name(function(x2, y2) {
|
|
x2 = +x2, y2 = +y2;
|
|
switch (this._point) {
|
|
case 0:
|
|
this._point = 1;
|
|
this._line ? this._context.lineTo(x2, y2) : this._context.moveTo(x2, y2);
|
|
break;
|
|
case 1:
|
|
this._point = 2;
|
|
// falls through
|
|
default: {
|
|
if (this._t <= 0) {
|
|
this._context.lineTo(this._x, y2);
|
|
this._context.lineTo(x2, y2);
|
|
} else {
|
|
var x1 = this._x * (1 - this._t) + x2 * this._t;
|
|
this._context.lineTo(x1, this._y);
|
|
this._context.lineTo(x1, y2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
this._x = x2, this._y = y2;
|
|
}, "point")
|
|
};
|
|
function step_default(context) {
|
|
return new Step(context, 0.5);
|
|
}
|
|
__name(step_default, "default");
|
|
function stepBefore(context) {
|
|
return new Step(context, 0);
|
|
}
|
|
__name(stepBefore, "stepBefore");
|
|
function stepAfter(context) {
|
|
return new Step(context, 1);
|
|
}
|
|
__name(stepAfter, "stepAfter");
|
|
|
|
// ../../node_modules/.pnpm/d3-dispatch@3.0.1/node_modules/d3-dispatch/src/dispatch.js
|
|
var noop = { value: /* @__PURE__ */ __name(() => {
|
|
}, "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(_);
|
|
}
|
|
__name(dispatch, "dispatch");
|
|
function Dispatch(_) {
|
|
this._ = _;
|
|
}
|
|
__name(Dispatch, "Dispatch");
|
|
function parseTypenames2(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(parseTypenames2, "parseTypenames");
|
|
Dispatch.prototype = dispatch.prototype = {
|
|
constructor: Dispatch,
|
|
on: /* @__PURE__ */ __name(function(typename, callback) {
|
|
var _ = this._, T = parseTypenames2(typename + "", _), t, i = -1, n = T.length;
|
|
if (arguments.length < 2) {
|
|
while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
|
|
return;
|
|
}
|
|
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;
|
|
}, "on"),
|
|
copy: /* @__PURE__ */ __name(function() {
|
|
var copy2 = {}, _ = this._;
|
|
for (var t in _) copy2[t] = _[t].slice();
|
|
return new Dispatch(copy2);
|
|
}, "copy"),
|
|
call: /* @__PURE__ */ __name(function(type2, 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(type2)) throw new Error("unknown type: " + type2);
|
|
for (t = this._[type2], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
|
|
}, "call"),
|
|
apply: /* @__PURE__ */ __name(function(type2, that, args) {
|
|
if (!this._.hasOwnProperty(type2)) throw new Error("unknown type: " + type2);
|
|
for (var t = this._[type2], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
|
|
}, "apply")
|
|
};
|
|
function get(type2, name) {
|
|
for (var i = 0, n = type2.length, c; i < n; ++i) {
|
|
if ((c = type2[i]).name === name) {
|
|
return c.value;
|
|
}
|
|
}
|
|
}
|
|
__name(get, "get");
|
|
function set(type2, name, callback) {
|
|
for (var i = 0, n = type2.length; i < n; ++i) {
|
|
if (type2[i].name === name) {
|
|
type2[i] = noop, type2 = type2.slice(0, i).concat(type2.slice(i + 1));
|
|
break;
|
|
}
|
|
}
|
|
if (callback != null) type2.push({ name, value: callback });
|
|
return type2;
|
|
}
|
|
__name(set, "set");
|
|
var dispatch_default2 = dispatch;
|
|
|
|
// ../../node_modules/.pnpm/d3-timer@3.0.1/node_modules/d3-timer/src/timer.js
|
|
var frame = 0;
|
|
var timeout = 0;
|
|
var interval = 0;
|
|
var pokeDelay = 1e3;
|
|
var taskHead;
|
|
var taskTail;
|
|
var clockLast = 0;
|
|
var clockNow = 0;
|
|
var clockSkew = 0;
|
|
var clock = typeof performance === "object" && performance.now ? performance : Date;
|
|
var 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);
|
|
}
|
|
__name(now, "now");
|
|
function clearNow() {
|
|
clockNow = 0;
|
|
}
|
|
__name(clearNow, "clearNow");
|
|
function Timer() {
|
|
this._call = this._time = this._next = null;
|
|
}
|
|
__name(Timer, "Timer");
|
|
Timer.prototype = timer.prototype = {
|
|
constructor: Timer,
|
|
restart: /* @__PURE__ */ __name(function(callback, delay, time2) {
|
|
if (typeof callback !== "function") throw new TypeError("callback is not a function");
|
|
time2 = (time2 == null ? now() : +time2) + (delay == null ? 0 : +delay);
|
|
if (!this._next && taskTail !== this) {
|
|
if (taskTail) taskTail._next = this;
|
|
else taskHead = this;
|
|
taskTail = this;
|
|
}
|
|
this._call = callback;
|
|
this._time = time2;
|
|
sleep();
|
|
}, "restart"),
|
|
stop: /* @__PURE__ */ __name(function() {
|
|
if (this._call) {
|
|
this._call = null;
|
|
this._time = Infinity;
|
|
sleep();
|
|
}
|
|
}, "stop")
|
|
};
|
|
function timer(callback, delay, time2) {
|
|
var t = new Timer();
|
|
t.restart(callback, delay, time2);
|
|
return t;
|
|
}
|
|
__name(timer, "timer");
|
|
function timerFlush() {
|
|
now();
|
|
++frame;
|
|
var t = taskHead, e;
|
|
while (t) {
|
|
if ((e = clockNow - t._time) >= 0) t._call.call(void 0, e);
|
|
t = t._next;
|
|
}
|
|
--frame;
|
|
}
|
|
__name(timerFlush, "timerFlush");
|
|
function wake() {
|
|
clockNow = (clockLast = clock.now()) + clockSkew;
|
|
frame = timeout = 0;
|
|
try {
|
|
timerFlush();
|
|
} finally {
|
|
frame = 0;
|
|
nap();
|
|
clockNow = 0;
|
|
}
|
|
}
|
|
__name(wake, "wake");
|
|
function poke() {
|
|
var now2 = clock.now(), delay = now2 - clockLast;
|
|
if (delay > pokeDelay) clockSkew -= delay, clockLast = now2;
|
|
}
|
|
__name(poke, "poke");
|
|
function nap() {
|
|
var t03, t13 = taskHead, t22, time2 = Infinity;
|
|
while (t13) {
|
|
if (t13._call) {
|
|
if (time2 > t13._time) time2 = t13._time;
|
|
t03 = t13, t13 = t13._next;
|
|
} else {
|
|
t22 = t13._next, t13._next = null;
|
|
t13 = t03 ? t03._next = t22 : taskHead = t22;
|
|
}
|
|
}
|
|
taskTail = t03;
|
|
sleep(time2);
|
|
}
|
|
__name(nap, "nap");
|
|
function sleep(time2) {
|
|
if (frame) return;
|
|
if (timeout) timeout = clearTimeout(timeout);
|
|
var delay = time2 - clockNow;
|
|
if (delay > 24) {
|
|
if (time2 < Infinity) timeout = setTimeout(wake, time2 - clock.now() - clockSkew);
|
|
if (interval) interval = clearInterval(interval);
|
|
} else {
|
|
if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
|
|
frame = 1, setFrame(wake);
|
|
}
|
|
}
|
|
__name(sleep, "sleep");
|
|
|
|
// ../../node_modules/.pnpm/d3-timer@3.0.1/node_modules/d3-timer/src/timeout.js
|
|
function timeout_default(callback, delay, time2) {
|
|
var t = new Timer();
|
|
delay = delay == null ? 0 : +delay;
|
|
t.restart((elapsed) => {
|
|
t.stop();
|
|
callback(elapsed + delay);
|
|
}, delay, time2);
|
|
return t;
|
|
}
|
|
__name(timeout_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/schedule.js
|
|
var emptyOn = dispatch_default2("start", "end", "cancel", "interrupt");
|
|
var emptyTween = [];
|
|
var CREATED = 0;
|
|
var SCHEDULED = 1;
|
|
var STARTING = 2;
|
|
var STARTED = 3;
|
|
var RUNNING = 4;
|
|
var ENDING = 5;
|
|
var ENDED = 6;
|
|
function schedule_default(node, name, id2, index, group, timing) {
|
|
var schedules = node.__transition;
|
|
if (!schedules) node.__transition = {};
|
|
else if (id2 in schedules) return;
|
|
create(node, id2, {
|
|
name,
|
|
index,
|
|
// For context during callback.
|
|
group,
|
|
// For context during callback.
|
|
on: emptyOn,
|
|
tween: emptyTween,
|
|
time: timing.time,
|
|
delay: timing.delay,
|
|
duration: timing.duration,
|
|
ease: timing.ease,
|
|
timer: null,
|
|
state: CREATED
|
|
});
|
|
}
|
|
__name(schedule_default, "default");
|
|
function init(node, id2) {
|
|
var schedule = get2(node, id2);
|
|
if (schedule.state > CREATED) throw new Error("too late; already scheduled");
|
|
return schedule;
|
|
}
|
|
__name(init, "init");
|
|
function set2(node, id2) {
|
|
var schedule = get2(node, id2);
|
|
if (schedule.state > STARTED) throw new Error("too late; already running");
|
|
return schedule;
|
|
}
|
|
__name(set2, "set");
|
|
function get2(node, id2) {
|
|
var schedule = node.__transition;
|
|
if (!schedule || !(schedule = schedule[id2])) throw new Error("transition not found");
|
|
return schedule;
|
|
}
|
|
__name(get2, "get");
|
|
function create(node, id2, self2) {
|
|
var schedules = node.__transition, tween;
|
|
schedules[id2] = self2;
|
|
self2.timer = timer(schedule, 0, self2.time);
|
|
function schedule(elapsed) {
|
|
self2.state = SCHEDULED;
|
|
self2.timer.restart(start2, self2.delay, self2.time);
|
|
if (self2.delay <= elapsed) start2(elapsed - self2.delay);
|
|
}
|
|
__name(schedule, "schedule");
|
|
function start2(elapsed) {
|
|
var i, j, n, o;
|
|
if (self2.state !== SCHEDULED) return stop();
|
|
for (i in schedules) {
|
|
o = schedules[i];
|
|
if (o.name !== self2.name) continue;
|
|
if (o.state === STARTED) return timeout_default(start2);
|
|
if (o.state === RUNNING) {
|
|
o.state = ENDED;
|
|
o.timer.stop();
|
|
o.on.call("interrupt", node, node.__data__, o.index, o.group);
|
|
delete schedules[i];
|
|
} else if (+i < id2) {
|
|
o.state = ENDED;
|
|
o.timer.stop();
|
|
o.on.call("cancel", node, node.__data__, o.index, o.group);
|
|
delete schedules[i];
|
|
}
|
|
}
|
|
timeout_default(function() {
|
|
if (self2.state === STARTED) {
|
|
self2.state = RUNNING;
|
|
self2.timer.restart(tick, self2.delay, self2.time);
|
|
tick(elapsed);
|
|
}
|
|
});
|
|
self2.state = STARTING;
|
|
self2.on.call("start", node, node.__data__, self2.index, self2.group);
|
|
if (self2.state !== STARTING) return;
|
|
self2.state = STARTED;
|
|
tween = new Array(n = self2.tween.length);
|
|
for (i = 0, j = -1; i < n; ++i) {
|
|
if (o = self2.tween[i].value.call(node, node.__data__, self2.index, self2.group)) {
|
|
tween[++j] = o;
|
|
}
|
|
}
|
|
tween.length = j + 1;
|
|
}
|
|
__name(start2, "start");
|
|
function tick(elapsed) {
|
|
var t = elapsed < self2.duration ? self2.ease.call(null, elapsed / self2.duration) : (self2.timer.restart(stop), self2.state = ENDING, 1), i = -1, n = tween.length;
|
|
while (++i < n) {
|
|
tween[i].call(node, t);
|
|
}
|
|
if (self2.state === ENDING) {
|
|
self2.on.call("end", node, node.__data__, self2.index, self2.group);
|
|
stop();
|
|
}
|
|
}
|
|
__name(tick, "tick");
|
|
function stop() {
|
|
self2.state = ENDED;
|
|
self2.timer.stop();
|
|
delete schedules[id2];
|
|
for (var i in schedules) return;
|
|
delete node.__transition;
|
|
}
|
|
__name(stop, "stop");
|
|
}
|
|
__name(create, "create");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/interrupt.js
|
|
function interrupt_default(node, name) {
|
|
var schedules = node.__transition, schedule, active, empty2 = true, i;
|
|
if (!schedules) return;
|
|
name = name == null ? null : name + "";
|
|
for (i in schedules) {
|
|
if ((schedule = schedules[i]).name !== name) {
|
|
empty2 = false;
|
|
continue;
|
|
}
|
|
active = schedule.state > STARTING && schedule.state < ENDING;
|
|
schedule.state = ENDED;
|
|
schedule.timer.stop();
|
|
schedule.on.call(active ? "interrupt" : "cancel", node, node.__data__, schedule.index, schedule.group);
|
|
delete schedules[i];
|
|
}
|
|
if (empty2) delete node.__transition;
|
|
}
|
|
__name(interrupt_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/selection/interrupt.js
|
|
function interrupt_default2(name) {
|
|
return this.each(function() {
|
|
interrupt_default(this, name);
|
|
});
|
|
}
|
|
__name(interrupt_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/tween.js
|
|
function tweenRemove(id2, name) {
|
|
var tween0, tween1;
|
|
return function() {
|
|
var schedule = set2(this, id2), tween = schedule.tween;
|
|
if (tween !== tween0) {
|
|
tween1 = tween0 = tween;
|
|
for (var i = 0, n = tween1.length; i < n; ++i) {
|
|
if (tween1[i].name === name) {
|
|
tween1 = tween1.slice();
|
|
tween1.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
schedule.tween = tween1;
|
|
};
|
|
}
|
|
__name(tweenRemove, "tweenRemove");
|
|
function tweenFunction(id2, name, value) {
|
|
var tween0, tween1;
|
|
if (typeof value !== "function") throw new Error();
|
|
return function() {
|
|
var schedule = set2(this, id2), tween = schedule.tween;
|
|
if (tween !== tween0) {
|
|
tween1 = (tween0 = tween).slice();
|
|
for (var t = { name, value }, i = 0, n = tween1.length; i < n; ++i) {
|
|
if (tween1[i].name === name) {
|
|
tween1[i] = t;
|
|
break;
|
|
}
|
|
}
|
|
if (i === n) tween1.push(t);
|
|
}
|
|
schedule.tween = tween1;
|
|
};
|
|
}
|
|
__name(tweenFunction, "tweenFunction");
|
|
function tween_default(name, value) {
|
|
var id2 = this._id;
|
|
name += "";
|
|
if (arguments.length < 2) {
|
|
var tween = get2(this.node(), id2).tween;
|
|
for (var i = 0, n = tween.length, t; i < n; ++i) {
|
|
if ((t = tween[i]).name === name) {
|
|
return t.value;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return this.each((value == null ? tweenRemove : tweenFunction)(id2, name, value));
|
|
}
|
|
__name(tween_default, "default");
|
|
function tweenValue(transition2, name, value) {
|
|
var id2 = transition2._id;
|
|
transition2.each(function() {
|
|
var schedule = set2(this, id2);
|
|
(schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments);
|
|
});
|
|
return function(node) {
|
|
return get2(node, id2).value[name];
|
|
};
|
|
}
|
|
__name(tweenValue, "tweenValue");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/interpolate.js
|
|
function interpolate_default(a, b) {
|
|
var c;
|
|
return (typeof b === "number" ? number_default : b instanceof color ? rgb_default : (c = color(b)) ? (b = c, rgb_default) : string_default)(a, b);
|
|
}
|
|
__name(interpolate_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/attr.js
|
|
function attrRemove2(name) {
|
|
return function() {
|
|
this.removeAttribute(name);
|
|
};
|
|
}
|
|
__name(attrRemove2, "attrRemove");
|
|
function attrRemoveNS2(fullname) {
|
|
return function() {
|
|
this.removeAttributeNS(fullname.space, fullname.local);
|
|
};
|
|
}
|
|
__name(attrRemoveNS2, "attrRemoveNS");
|
|
function attrConstant2(name, interpolate, value1) {
|
|
var string00, string1 = value1 + "", interpolate0;
|
|
return function() {
|
|
var string0 = this.getAttribute(name);
|
|
return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
|
|
};
|
|
}
|
|
__name(attrConstant2, "attrConstant");
|
|
function attrConstantNS2(fullname, interpolate, value1) {
|
|
var string00, string1 = value1 + "", interpolate0;
|
|
return function() {
|
|
var string0 = this.getAttributeNS(fullname.space, fullname.local);
|
|
return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
|
|
};
|
|
}
|
|
__name(attrConstantNS2, "attrConstantNS");
|
|
function attrFunction2(name, interpolate, value) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0, value1 = value(this), string1;
|
|
if (value1 == null) return void this.removeAttribute(name);
|
|
string0 = this.getAttribute(name);
|
|
string1 = value1 + "";
|
|
return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
|
|
};
|
|
}
|
|
__name(attrFunction2, "attrFunction");
|
|
function attrFunctionNS2(fullname, interpolate, value) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0, value1 = value(this), string1;
|
|
if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local);
|
|
string0 = this.getAttributeNS(fullname.space, fullname.local);
|
|
string1 = value1 + "";
|
|
return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
|
|
};
|
|
}
|
|
__name(attrFunctionNS2, "attrFunctionNS");
|
|
function attr_default2(name, value) {
|
|
var fullname = namespace_default(name), i = fullname === "transform" ? interpolateTransformSvg : interpolate_default;
|
|
return this.attrTween(name, typeof value === "function" ? (fullname.local ? attrFunctionNS2 : attrFunction2)(fullname, i, tweenValue(this, "attr." + name, value)) : value == null ? (fullname.local ? attrRemoveNS2 : attrRemove2)(fullname) : (fullname.local ? attrConstantNS2 : attrConstant2)(fullname, i, value));
|
|
}
|
|
__name(attr_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/attrTween.js
|
|
function attrInterpolate(name, i) {
|
|
return function(t) {
|
|
this.setAttribute(name, i.call(this, t));
|
|
};
|
|
}
|
|
__name(attrInterpolate, "attrInterpolate");
|
|
function attrInterpolateNS(fullname, i) {
|
|
return function(t) {
|
|
this.setAttributeNS(fullname.space, fullname.local, i.call(this, t));
|
|
};
|
|
}
|
|
__name(attrInterpolateNS, "attrInterpolateNS");
|
|
function attrTweenNS(fullname, value) {
|
|
var t03, i0;
|
|
function tween() {
|
|
var i = value.apply(this, arguments);
|
|
if (i !== i0) t03 = (i0 = i) && attrInterpolateNS(fullname, i);
|
|
return t03;
|
|
}
|
|
__name(tween, "tween");
|
|
tween._value = value;
|
|
return tween;
|
|
}
|
|
__name(attrTweenNS, "attrTweenNS");
|
|
function attrTween(name, value) {
|
|
var t03, i0;
|
|
function tween() {
|
|
var i = value.apply(this, arguments);
|
|
if (i !== i0) t03 = (i0 = i) && attrInterpolate(name, i);
|
|
return t03;
|
|
}
|
|
__name(tween, "tween");
|
|
tween._value = value;
|
|
return tween;
|
|
}
|
|
__name(attrTween, "attrTween");
|
|
function attrTween_default(name, value) {
|
|
var key = "attr." + name;
|
|
if (arguments.length < 2) return (key = this.tween(key)) && key._value;
|
|
if (value == null) return this.tween(key, null);
|
|
if (typeof value !== "function") throw new Error();
|
|
var fullname = namespace_default(name);
|
|
return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value));
|
|
}
|
|
__name(attrTween_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/delay.js
|
|
function delayFunction(id2, value) {
|
|
return function() {
|
|
init(this, id2).delay = +value.apply(this, arguments);
|
|
};
|
|
}
|
|
__name(delayFunction, "delayFunction");
|
|
function delayConstant(id2, value) {
|
|
return value = +value, function() {
|
|
init(this, id2).delay = value;
|
|
};
|
|
}
|
|
__name(delayConstant, "delayConstant");
|
|
function delay_default(value) {
|
|
var id2 = this._id;
|
|
return arguments.length ? this.each((typeof value === "function" ? delayFunction : delayConstant)(id2, value)) : get2(this.node(), id2).delay;
|
|
}
|
|
__name(delay_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/duration.js
|
|
function durationFunction(id2, value) {
|
|
return function() {
|
|
set2(this, id2).duration = +value.apply(this, arguments);
|
|
};
|
|
}
|
|
__name(durationFunction, "durationFunction");
|
|
function durationConstant(id2, value) {
|
|
return value = +value, function() {
|
|
set2(this, id2).duration = value;
|
|
};
|
|
}
|
|
__name(durationConstant, "durationConstant");
|
|
function duration_default(value) {
|
|
var id2 = this._id;
|
|
return arguments.length ? this.each((typeof value === "function" ? durationFunction : durationConstant)(id2, value)) : get2(this.node(), id2).duration;
|
|
}
|
|
__name(duration_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/ease.js
|
|
function easeConstant(id2, value) {
|
|
if (typeof value !== "function") throw new Error();
|
|
return function() {
|
|
set2(this, id2).ease = value;
|
|
};
|
|
}
|
|
__name(easeConstant, "easeConstant");
|
|
function ease_default(value) {
|
|
var id2 = this._id;
|
|
return arguments.length ? this.each(easeConstant(id2, value)) : get2(this.node(), id2).ease;
|
|
}
|
|
__name(ease_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/easeVarying.js
|
|
function easeVarying(id2, value) {
|
|
return function() {
|
|
var v = value.apply(this, arguments);
|
|
if (typeof v !== "function") throw new Error();
|
|
set2(this, id2).ease = v;
|
|
};
|
|
}
|
|
__name(easeVarying, "easeVarying");
|
|
function easeVarying_default(value) {
|
|
if (typeof value !== "function") throw new Error();
|
|
return this.each(easeVarying(this._id, value));
|
|
}
|
|
__name(easeVarying_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/filter.js
|
|
function filter_default2(match) {
|
|
if (typeof match !== "function") match = matcher_default(match);
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
|
|
if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
|
|
subgroup.push(node);
|
|
}
|
|
}
|
|
}
|
|
return new Transition(subgroups, this._parents, this._name, this._id);
|
|
}
|
|
__name(filter_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/merge.js
|
|
function merge_default2(transition2) {
|
|
if (transition2._id !== this._id) throw new Error();
|
|
for (var groups0 = this._groups, groups1 = transition2._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
|
|
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
|
|
if (node = group0[i] || group1[i]) {
|
|
merge[i] = node;
|
|
}
|
|
}
|
|
}
|
|
for (; j < m0; ++j) {
|
|
merges[j] = groups0[j];
|
|
}
|
|
return new Transition(merges, this._parents, this._name, this._id);
|
|
}
|
|
__name(merge_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/on.js
|
|
function start(name) {
|
|
return (name + "").trim().split(/^|\s+/).every(function(t) {
|
|
var i = t.indexOf(".");
|
|
if (i >= 0) t = t.slice(0, i);
|
|
return !t || t === "start";
|
|
});
|
|
}
|
|
__name(start, "start");
|
|
function onFunction(id2, name, listener) {
|
|
var on0, on1, sit = start(name) ? init : set2;
|
|
return function() {
|
|
var schedule = sit(this, id2), on = schedule.on;
|
|
if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener);
|
|
schedule.on = on1;
|
|
};
|
|
}
|
|
__name(onFunction, "onFunction");
|
|
function on_default2(name, listener) {
|
|
var id2 = this._id;
|
|
return arguments.length < 2 ? get2(this.node(), id2).on.on(name) : this.each(onFunction(id2, name, listener));
|
|
}
|
|
__name(on_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/remove.js
|
|
function removeFunction(id2) {
|
|
return function() {
|
|
var parent = this.parentNode;
|
|
for (var i in this.__transition) if (+i !== id2) return;
|
|
if (parent) parent.removeChild(this);
|
|
};
|
|
}
|
|
__name(removeFunction, "removeFunction");
|
|
function remove_default2() {
|
|
return this.on("end.remove", removeFunction(this._id));
|
|
}
|
|
__name(remove_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/select.js
|
|
function select_default3(select) {
|
|
var name = this._name, id2 = this._id;
|
|
if (typeof select !== "function") select = selector_default(select);
|
|
for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
|
|
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
|
|
if ("__data__" in node) subnode.__data__ = node.__data__;
|
|
subgroup[i] = subnode;
|
|
schedule_default(subgroup[i], name, id2, i, subgroup, get2(node, id2));
|
|
}
|
|
}
|
|
}
|
|
return new Transition(subgroups, this._parents, name, id2);
|
|
}
|
|
__name(select_default3, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/selectAll.js
|
|
function selectAll_default2(select) {
|
|
var name = this._name, id2 = this._id;
|
|
if (typeof select !== "function") select = selectorAll_default(select);
|
|
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
|
|
if (node = group[i]) {
|
|
for (var children2 = select.call(node, node.__data__, i, group), child, inherit2 = get2(node, id2), k = 0, l = children2.length; k < l; ++k) {
|
|
if (child = children2[k]) {
|
|
schedule_default(child, name, id2, k, children2, inherit2);
|
|
}
|
|
}
|
|
subgroups.push(children2);
|
|
parents.push(node);
|
|
}
|
|
}
|
|
}
|
|
return new Transition(subgroups, parents, name, id2);
|
|
}
|
|
__name(selectAll_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/selection.js
|
|
var Selection2 = selection_default.prototype.constructor;
|
|
function selection_default2() {
|
|
return new Selection2(this._groups, this._parents);
|
|
}
|
|
__name(selection_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/style.js
|
|
function styleNull(name, interpolate) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0 = styleValue(this, name), string1 = (this.style.removeProperty(name), styleValue(this, name));
|
|
return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : interpolate0 = interpolate(string00 = string0, string10 = string1);
|
|
};
|
|
}
|
|
__name(styleNull, "styleNull");
|
|
function styleRemove2(name) {
|
|
return function() {
|
|
this.style.removeProperty(name);
|
|
};
|
|
}
|
|
__name(styleRemove2, "styleRemove");
|
|
function styleConstant2(name, interpolate, value1) {
|
|
var string00, string1 = value1 + "", interpolate0;
|
|
return function() {
|
|
var string0 = styleValue(this, name);
|
|
return string0 === string1 ? null : string0 === string00 ? interpolate0 : interpolate0 = interpolate(string00 = string0, value1);
|
|
};
|
|
}
|
|
__name(styleConstant2, "styleConstant");
|
|
function styleFunction2(name, interpolate, value) {
|
|
var string00, string10, interpolate0;
|
|
return function() {
|
|
var string0 = styleValue(this, name), value1 = value(this), string1 = value1 + "";
|
|
if (value1 == null) string1 = value1 = (this.style.removeProperty(name), styleValue(this, name));
|
|
return string0 === string1 ? null : string0 === string00 && string1 === string10 ? interpolate0 : (string10 = string1, interpolate0 = interpolate(string00 = string0, value1));
|
|
};
|
|
}
|
|
__name(styleFunction2, "styleFunction");
|
|
function styleMaybeRemove(id2, name) {
|
|
var on0, on1, listener0, key = "style." + name, event = "end." + key, remove2;
|
|
return function() {
|
|
var schedule = set2(this, id2), on = schedule.on, listener = schedule.value[key] == null ? remove2 || (remove2 = styleRemove2(name)) : void 0;
|
|
if (on !== on0 || listener0 !== listener) (on1 = (on0 = on).copy()).on(event, listener0 = listener);
|
|
schedule.on = on1;
|
|
};
|
|
}
|
|
__name(styleMaybeRemove, "styleMaybeRemove");
|
|
function style_default2(name, value, priority) {
|
|
var i = (name += "") === "transform" ? interpolateTransformCss : interpolate_default;
|
|
return value == null ? this.styleTween(name, styleNull(name, i)).on("end.style." + name, styleRemove2(name)) : typeof value === "function" ? this.styleTween(name, styleFunction2(name, i, tweenValue(this, "style." + name, value))).each(styleMaybeRemove(this._id, name)) : this.styleTween(name, styleConstant2(name, i, value), priority).on("end.style." + name, null);
|
|
}
|
|
__name(style_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/styleTween.js
|
|
function styleInterpolate(name, i, priority) {
|
|
return function(t) {
|
|
this.style.setProperty(name, i.call(this, t), priority);
|
|
};
|
|
}
|
|
__name(styleInterpolate, "styleInterpolate");
|
|
function styleTween(name, value, priority) {
|
|
var t, i0;
|
|
function tween() {
|
|
var i = value.apply(this, arguments);
|
|
if (i !== i0) t = (i0 = i) && styleInterpolate(name, i, priority);
|
|
return t;
|
|
}
|
|
__name(tween, "tween");
|
|
tween._value = value;
|
|
return tween;
|
|
}
|
|
__name(styleTween, "styleTween");
|
|
function styleTween_default(name, value, priority) {
|
|
var key = "style." + (name += "");
|
|
if (arguments.length < 2) return (key = this.tween(key)) && key._value;
|
|
if (value == null) return this.tween(key, null);
|
|
if (typeof value !== "function") throw new Error();
|
|
return this.tween(key, styleTween(name, value, priority == null ? "" : priority));
|
|
}
|
|
__name(styleTween_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/text.js
|
|
function textConstant2(value) {
|
|
return function() {
|
|
this.textContent = value;
|
|
};
|
|
}
|
|
__name(textConstant2, "textConstant");
|
|
function textFunction2(value) {
|
|
return function() {
|
|
var value1 = value(this);
|
|
this.textContent = value1 == null ? "" : value1;
|
|
};
|
|
}
|
|
__name(textFunction2, "textFunction");
|
|
function text_default2(value) {
|
|
return this.tween("text", typeof value === "function" ? textFunction2(tweenValue(this, "text", value)) : textConstant2(value == null ? "" : value + ""));
|
|
}
|
|
__name(text_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/textTween.js
|
|
function textInterpolate(i) {
|
|
return function(t) {
|
|
this.textContent = i.call(this, t);
|
|
};
|
|
}
|
|
__name(textInterpolate, "textInterpolate");
|
|
function textTween(value) {
|
|
var t03, i0;
|
|
function tween() {
|
|
var i = value.apply(this, arguments);
|
|
if (i !== i0) t03 = (i0 = i) && textInterpolate(i);
|
|
return t03;
|
|
}
|
|
__name(tween, "tween");
|
|
tween._value = value;
|
|
return tween;
|
|
}
|
|
__name(textTween, "textTween");
|
|
function textTween_default(value) {
|
|
var key = "text";
|
|
if (arguments.length < 1) return (key = this.tween(key)) && key._value;
|
|
if (value == null) return this.tween(key, null);
|
|
if (typeof value !== "function") throw new Error();
|
|
return this.tween(key, textTween(value));
|
|
}
|
|
__name(textTween_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/transition.js
|
|
function transition_default() {
|
|
var name = this._name, id0 = this._id, id1 = newId();
|
|
for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
|
|
if (node = group[i]) {
|
|
var inherit2 = get2(node, id0);
|
|
schedule_default(node, name, id1, i, group, {
|
|
time: inherit2.time + inherit2.delay + inherit2.duration,
|
|
delay: 0,
|
|
duration: inherit2.duration,
|
|
ease: inherit2.ease
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return new Transition(groups, this._parents, name, id1);
|
|
}
|
|
__name(transition_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/end.js
|
|
function end_default() {
|
|
var on0, on1, that = this, id2 = that._id, size = that.size();
|
|
return new Promise(function(resolve, reject) {
|
|
var cancel = { value: reject }, end = { value: /* @__PURE__ */ __name(function() {
|
|
if (--size === 0) resolve();
|
|
}, "value") };
|
|
that.each(function() {
|
|
var schedule = set2(this, id2), on = schedule.on;
|
|
if (on !== on0) {
|
|
on1 = (on0 = on).copy();
|
|
on1._.cancel.push(cancel);
|
|
on1._.interrupt.push(cancel);
|
|
on1._.end.push(end);
|
|
}
|
|
schedule.on = on1;
|
|
});
|
|
if (size === 0) resolve();
|
|
});
|
|
}
|
|
__name(end_default, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/transition/index.js
|
|
var id = 0;
|
|
function Transition(groups, parents, name, id2) {
|
|
this._groups = groups;
|
|
this._parents = parents;
|
|
this._name = name;
|
|
this._id = id2;
|
|
}
|
|
__name(Transition, "Transition");
|
|
function transition(name) {
|
|
return selection_default().transition(name);
|
|
}
|
|
__name(transition, "transition");
|
|
function newId() {
|
|
return ++id;
|
|
}
|
|
__name(newId, "newId");
|
|
var selection_prototype = selection_default.prototype;
|
|
Transition.prototype = transition.prototype = {
|
|
constructor: Transition,
|
|
select: select_default3,
|
|
selectAll: selectAll_default2,
|
|
selectChild: selection_prototype.selectChild,
|
|
selectChildren: selection_prototype.selectChildren,
|
|
filter: filter_default2,
|
|
merge: merge_default2,
|
|
selection: selection_default2,
|
|
transition: transition_default,
|
|
call: selection_prototype.call,
|
|
nodes: selection_prototype.nodes,
|
|
node: selection_prototype.node,
|
|
size: selection_prototype.size,
|
|
empty: selection_prototype.empty,
|
|
each: selection_prototype.each,
|
|
on: on_default2,
|
|
attr: attr_default2,
|
|
attrTween: attrTween_default,
|
|
style: style_default2,
|
|
styleTween: styleTween_default,
|
|
text: text_default2,
|
|
textTween: textTween_default,
|
|
remove: remove_default2,
|
|
tween: tween_default,
|
|
delay: delay_default,
|
|
duration: duration_default,
|
|
ease: ease_default,
|
|
easeVarying: easeVarying_default,
|
|
end: end_default,
|
|
[Symbol.iterator]: selection_prototype[Symbol.iterator]
|
|
};
|
|
|
|
// ../../node_modules/.pnpm/d3-ease@3.0.1/node_modules/d3-ease/src/cubic.js
|
|
function cubicInOut(t) {
|
|
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
|
|
}
|
|
__name(cubicInOut, "cubicInOut");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/selection/transition.js
|
|
var defaultTiming = {
|
|
time: null,
|
|
// Set on use.
|
|
delay: 0,
|
|
duration: 250,
|
|
ease: cubicInOut
|
|
};
|
|
function inherit(node, id2) {
|
|
var timing;
|
|
while (!(timing = node.__transition) || !(timing = timing[id2])) {
|
|
if (!(node = node.parentNode)) {
|
|
throw new Error(`transition ${id2} not found`);
|
|
}
|
|
}
|
|
return timing;
|
|
}
|
|
__name(inherit, "inherit");
|
|
function transition_default2(name) {
|
|
var id2, timing;
|
|
if (name instanceof Transition) {
|
|
id2 = name._id, name = name._name;
|
|
} else {
|
|
id2 = newId(), (timing = defaultTiming).time = now(), name = name == null ? null : name + "";
|
|
}
|
|
for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) {
|
|
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
|
|
if (node = group[i]) {
|
|
schedule_default(node, name, id2, i, group, timing || inherit(node, id2));
|
|
}
|
|
}
|
|
}
|
|
return new Transition(groups, this._parents, name, id2);
|
|
}
|
|
__name(transition_default2, "default");
|
|
|
|
// ../../node_modules/.pnpm/d3-transition@3.0.1_d3-selection@3.0.0/node_modules/d3-transition/src/selection/index.js
|
|
selection_default.prototype.interrupt = interrupt_default2;
|
|
selection_default.prototype.transition = transition_default2;
|
|
|
|
// ../../node_modules/.pnpm/d3-brush@3.0.0/node_modules/d3-brush/src/brush.js
|
|
var { abs: abs2, max: max3, min: min3 } = Math;
|
|
function number1(e) {
|
|
return [+e[0], +e[1]];
|
|
}
|
|
__name(number1, "number1");
|
|
function number22(e) {
|
|
return [number1(e[0]), number1(e[1])];
|
|
}
|
|
__name(number22, "number2");
|
|
var X = {
|
|
name: "x",
|
|
handles: ["w", "e"].map(type),
|
|
input: /* @__PURE__ */ __name(function(x2, e) {
|
|
return x2 == null ? null : [[+x2[0], e[0][1]], [+x2[1], e[1][1]]];
|
|
}, "input"),
|
|
output: /* @__PURE__ */ __name(function(xy) {
|
|
return xy && [xy[0][0], xy[1][0]];
|
|
}, "output")
|
|
};
|
|
var Y = {
|
|
name: "y",
|
|
handles: ["n", "s"].map(type),
|
|
input: /* @__PURE__ */ __name(function(y2, e) {
|
|
return y2 == null ? null : [[e[0][0], +y2[0]], [e[1][0], +y2[1]]];
|
|
}, "input"),
|
|
output: /* @__PURE__ */ __name(function(xy) {
|
|
return xy && [xy[0][1], xy[1][1]];
|
|
}, "output")
|
|
};
|
|
var XY = {
|
|
name: "xy",
|
|
handles: ["n", "w", "e", "s", "nw", "ne", "sw", "se"].map(type),
|
|
input: /* @__PURE__ */ __name(function(xy) {
|
|
return xy == null ? null : number22(xy);
|
|
}, "input"),
|
|
output: /* @__PURE__ */ __name(function(xy) {
|
|
return xy;
|
|
}, "output")
|
|
};
|
|
function type(t) {
|
|
return { type: t };
|
|
}
|
|
__name(type, "type");
|
|
|
|
// ../../node_modules/.pnpm/d3-zoom@3.0.0/node_modules/d3-zoom/src/transform.js
|
|
function Transform(k, x2, y2) {
|
|
this.k = k;
|
|
this.x = x2;
|
|
this.y = y2;
|
|
}
|
|
__name(Transform, "Transform");
|
|
Transform.prototype = {
|
|
constructor: Transform,
|
|
scale: /* @__PURE__ */ __name(function(k) {
|
|
return k === 1 ? this : new Transform(this.k * k, this.x, this.y);
|
|
}, "scale"),
|
|
translate: /* @__PURE__ */ __name(function(x2, y2) {
|
|
return x2 === 0 & y2 === 0 ? this : new Transform(this.k, this.x + this.k * x2, this.y + this.k * y2);
|
|
}, "translate"),
|
|
apply: /* @__PURE__ */ __name(function(point6) {
|
|
return [point6[0] * this.k + this.x, point6[1] * this.k + this.y];
|
|
}, "apply"),
|
|
applyX: /* @__PURE__ */ __name(function(x2) {
|
|
return x2 * this.k + this.x;
|
|
}, "applyX"),
|
|
applyY: /* @__PURE__ */ __name(function(y2) {
|
|
return y2 * this.k + this.y;
|
|
}, "applyY"),
|
|
invert: /* @__PURE__ */ __name(function(location) {
|
|
return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];
|
|
}, "invert"),
|
|
invertX: /* @__PURE__ */ __name(function(x2) {
|
|
return (x2 - this.x) / this.k;
|
|
}, "invertX"),
|
|
invertY: /* @__PURE__ */ __name(function(y2) {
|
|
return (y2 - this.y) / this.k;
|
|
}, "invertY"),
|
|
rescaleX: /* @__PURE__ */ __name(function(x2) {
|
|
return x2.copy().domain(x2.range().map(this.invertX, this).map(x2.invert, x2));
|
|
}, "rescaleX"),
|
|
rescaleY: /* @__PURE__ */ __name(function(y2) {
|
|
return y2.copy().domain(y2.range().map(this.invertY, this).map(y2.invert, y2));
|
|
}, "rescaleY"),
|
|
toString: /* @__PURE__ */ __name(function() {
|
|
return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")";
|
|
}, "toString")
|
|
};
|
|
var identity3 = new Transform(1, 0, 0);
|
|
transform.prototype = Transform.prototype;
|
|
function transform(node) {
|
|
while (!node.__zoom) if (!(node = node.parentNode)) return identity3;
|
|
return node.__zoom;
|
|
}
|
|
__name(transform, "transform");
|
|
|
|
export {
|
|
require_dayjs_min,
|
|
log,
|
|
setLogLevel,
|
|
max,
|
|
min,
|
|
axisTop,
|
|
axisBottom,
|
|
select_default2 as select_default,
|
|
hcl_default,
|
|
format2 as format,
|
|
hierarchy,
|
|
treemap_default,
|
|
ordinal,
|
|
band,
|
|
linear2 as linear,
|
|
millisecond,
|
|
second,
|
|
timeMinute,
|
|
timeHour,
|
|
timeDay,
|
|
timeSunday,
|
|
timeMonday,
|
|
timeTuesday,
|
|
timeWednesday,
|
|
timeThursday,
|
|
timeFriday,
|
|
timeSaturday,
|
|
timeMonth,
|
|
timeFormat,
|
|
time,
|
|
Tableau10_default,
|
|
arc_default,
|
|
linear_default,
|
|
line_default,
|
|
pie_default,
|
|
bumpX,
|
|
bumpY,
|
|
basis_default2 as basis_default,
|
|
basisClosed_default2 as basisClosed_default,
|
|
basisOpen_default,
|
|
bundle_default,
|
|
cardinal_default,
|
|
cardinalClosed_default,
|
|
cardinalOpen_default,
|
|
catmullRom_default,
|
|
catmullRomClosed_default,
|
|
catmullRomOpen_default,
|
|
linearClosed_default,
|
|
monotoneX,
|
|
monotoneY,
|
|
natural_default,
|
|
step_default,
|
|
stepBefore,
|
|
stepAfter
|
|
};
|