@loopstack/loopstack-studio 0.20.2 → 0.21.0-rc.0

package/dist/node_modules/d3-shape/src/curve/monotone.js

@@ -0,0 +1,90 @@
+function sign(e) {
+	return e < 0 ? -1 : 1;
+}
+function slope3(t, n, r) {
+	var i = t._x1 - t._x0, a = n - t._x1, o = (t._y1 - t._y0) / (i || a < 0 && -0), s = (r - t._y1) / (a || i < 0 && -0), c = (o * a + s * i) / (i + a);
+	return (sign(o) + sign(s)) * Math.min(Math.abs(o), Math.abs(s), .5 * Math.abs(c)) || 0;
+}
+function slope2(e, t) {
+	var n = e._x1 - e._x0;
+	return n ? (3 * (e._y1 - e._y0) / n - t) / 2 : t;
+}
+function point(e, t, n) {
+	var r = e._x0, i = e._y0, a = e._x1, o = e._y1, s = (a - r) / 3;
+	e._context.bezierCurveTo(r + s, i + s * t, a - s, o - s * n, a, o);
+}
+function MonotoneX(e) {
+	this._context = e;
+}
+MonotoneX.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
+	},
+	lineEnd: function() {
+		switch (this._point) {
+			case 2:
+				this._context.lineTo(this._x1, this._y1);
+				break;
+			case 3:
+				point(this, this._t0, slope2(this, this._t0));
+				break;
+		}
+		(this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+	},
+	point: function(e, i) {
+		var a = NaN;
+		if (e = +e, i = +i, !(e === this._x1 && i === this._y1)) {
+			switch (this._point) {
+				case 0:
+					this._point = 1, this._line ? this._context.lineTo(e, i) : this._context.moveTo(e, i);
+					break;
+				case 1:
+					this._point = 2;
+					break;
+				case 2:
+					this._point = 3, point(this, slope2(this, a = slope3(this, e, i)), a);
+					break;
+				default:
+					point(this, this._t0, a = slope3(this, e, i));
+					break;
+			}
+			this._x0 = this._x1, this._x1 = e, this._y0 = this._y1, this._y1 = i, this._t0 = a;
+		}
+	}
+};
+function MonotoneY(e) {
+	this._context = new ReflectContext(e);
+}
+(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(e, t) {
+	MonotoneX.prototype.point.call(this, t, e);
+};
+function ReflectContext(e) {
+	this._context = e;
+}
+ReflectContext.prototype = {
+	moveTo: function(e, t) {
+		this._context.moveTo(t, e);
+	},
+	closePath: function() {
+		this._context.closePath();
+	},
+	lineTo: function(e, t) {
+		this._context.lineTo(t, e);
+	},
+	bezierCurveTo: function(e, t, n, r, i, a) {
+		this._context.bezierCurveTo(t, e, r, n, a, i);
+	}
+};
+function monotoneX(e) {
+	return new MonotoneX(e);
+}
+function monotoneY(e) {
+	return new MonotoneY(e);
+}
+export { monotoneX, monotoneY };

package/dist/node_modules/d3-shape/src/curve/natural.js

@@ -0,0 +1,35 @@
+function Natural(e) {
+	this._context = e;
+}
+Natural.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = [], this._y = [];
+	},
+	lineEnd: function() {
+		var e = this._x, n = this._y, r = e.length;
+		if (r) if (this._line ? this._context.lineTo(e[0], n[0]) : this._context.moveTo(e[0], n[0]), r === 2) this._context.lineTo(e[1], n[1]);
+		else for (var i = controlPoints(e), a = controlPoints(n), o = 0, s = 1; s < r; ++o, ++s) this._context.bezierCurveTo(i[0][o], a[0][o], i[1][o], a[1][o], e[s], n[s]);
+		(this._line || this._line !== 0 && r === 1) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;
+	},
+	point: function(e, t) {
+		this._x.push(+e), this._y.push(+t);
+	}
+};
+function controlPoints(e) {
+	var t, n = e.length - 1, r, i = Array(n), a = Array(n), o = Array(n);
+	for (i[0] = 0, a[0] = 2, o[0] = e[0] + 2 * e[1], t = 1; t < n - 1; ++t) i[t] = 1, a[t] = 4, o[t] = 4 * e[t] + 2 * e[t + 1];
+	for (i[n - 1] = 2, a[n - 1] = 7, o[n - 1] = 8 * e[n - 1] + e[n], t = 1; t < n; ++t) r = i[t] / a[t - 1], a[t] -= r, o[t] -= r * o[t - 1];
+	for (i[n - 1] = o[n - 1] / a[n - 1], t = n - 2; t >= 0; --t) i[t] = (o[t] - i[t + 1]) / a[t];
+	for (a[n - 1] = (e[n] + i[n - 1]) / 2, t = 0; t < n - 1; ++t) a[t] = 2 * e[t + 1] - i[t + 1];
+	return [i, a];
+}
+function natural_default(t) {
+	return new Natural(t);
+}
+export { natural_default as default };

package/dist/node_modules/d3-shape/src/curve/step.js

@@ -0,0 +1,43 @@
+function Step(e, n) {
+	this._context = e, this._t = n;
+}
+Step.prototype = {
+	areaStart: function() {
+		this._line = 0;
+	},
+	areaEnd: function() {
+		this._line = NaN;
+	},
+	lineStart: function() {
+		this._x = this._y = NaN, this._point = 0;
+	},
+	lineEnd: function() {
+		0 < this._t && this._t < 1 && this._point === 2 && this._context.lineTo(this._x, this._y), (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);
+	},
+	point: function(e, n) {
+		switch (e = +e, n = +n, this._point) {
+			case 0:
+				this._point = 1, this._line ? this._context.lineTo(e, n) : this._context.moveTo(e, n);
+				break;
+			case 1: this._point = 2;
+			default:
+				if (this._t <= 0) this._context.lineTo(this._x, n), this._context.lineTo(e, n);
+				else {
+					var r = this._x * (1 - this._t) + e * this._t;
+					this._context.lineTo(r, this._y), this._context.lineTo(r, n);
+				}
+				break;
+		}
+		this._x = e, this._y = n;
+	}
+};
+function step_default(n) {
+	return new Step(n, .5);
+}
+function stepBefore(n) {
+	return new Step(n, 0);
+}
+function stepAfter(n) {
+	return new Step(n, 1);
+}
+export { step_default as default, stepAfter, stepBefore };

package/dist/node_modules/d3-shape/src/descending.js

@@ -0,0 +1,4 @@
+function descending_default(e, t) {
+	return t < e ? -1 : t > e ? 1 : t >= e ? 0 : NaN;
+}
+export { descending_default as default };

package/dist/node_modules/d3-shape/src/identity.js

@@ -0,0 +1,4 @@
+function identity_default(e) {
+	return e;
+}
+export { identity_default as default };

package/dist/node_modules/d3-shape/src/line.js

@@ -0,0 +1,26 @@
+import constant_default from "./constant.js";
+import { withPath } from "./path.js";
+import array_default from "./array.js";
+import linear_default from "./curve/linear.js";
+import { x, y } from "./point.js";
+function line_default(o, s) {
+	var c = constant_default(!0), l = null, u = linear_default, d = null, f = withPath(p);
+	o = typeof o == "function" ? o : o === void 0 ? x : constant_default(o), s = typeof s == "function" ? s : s === void 0 ? y : constant_default(s);
+	function p(e) {
+		var n, r = (e = array_default(e)).length, i, a = !1, p;
+		for (l ?? (d = u(p = f())), n = 0; n <= r; ++n) !(n < r && c(i = e[n], n, e)) === a && ((a = !a) ? d.lineStart() : d.lineEnd()), a && d.point(+o(i, n, e), +s(i, n, e));
+		if (p) return d = null, p + "" || null;
+	}
+	return p.x = function(n) {
+		return arguments.length ? (o = typeof n == "function" ? n : constant_default(+n), p) : o;
+	}, p.y = function(n) {
+		return arguments.length ? (s = typeof n == "function" ? n : constant_default(+n), p) : s;
+	}, p.defined = function(n) {
+		return arguments.length ? (c = typeof n == "function" ? n : constant_default(!!n), p) : c;
+	}, p.curve = function(e) {
+		return arguments.length ? (u = e, l != null && (d = u(l)), p) : u;
+	}, p.context = function(e) {
+		return arguments.length ? (e == null ? l = d = null : d = u(l = e), p) : l;
+	}, p;
+}
+export { line_default as default };

package/dist/node_modules/d3-shape/src/math.js

@@ -0,0 +1,8 @@
+const abs = Math.abs, atan2 = Math.atan2, cos = Math.cos, max = Math.max, min = Math.min, sin = Math.sin, sqrt = Math.sqrt, epsilon = 1e-12, pi = Math.PI, halfPi = pi / 2, tau = 2 * pi;
+function acos(e) {
+	return e > 1 ? 0 : e < -1 ? pi : Math.acos(e);
+}
+function asin(e) {
+	return e >= 1 ? halfPi : e <= -1 ? -halfPi : Math.asin(e);
+}
+export { abs, acos, asin, atan2, cos, epsilon, halfPi, max, min, pi, sin, sqrt, tau };

package/dist/node_modules/d3-shape/src/noop.js

@@ -0,0 +1,2 @@
+function noop_default() {}
+export { noop_default as default };

package/dist/node_modules/d3-shape/src/path.js

@@ -0,0 +1,15 @@
+import { Path } from "../../d3-path/src/path.js";
+function withPath(t) {
+	let n = 3;
+	return t.digits = function(e) {
+		if (!arguments.length) return n;
+		if (e == null) n = null;
+		else {
+			let t = Math.floor(e);
+			if (!(t >= 0)) throw RangeError(`invalid digits: ${e}`);
+			n = t;
+		}
+		return t;
+	}, () => new Path(n);
+}
+export { withPath };

package/dist/node_modules/d3-shape/src/pie.js

@@ -0,0 +1,39 @@
+import constant_default from "./constant.js";
+import { tau } from "./math.js";
+import array_default from "./array.js";
+import descending_default from "./descending.js";
+import identity_default from "./identity.js";
+function pie_default() {
+	var a = identity_default, o = descending_default, s = null, c = constant_default(0), l = constant_default(tau), u = constant_default(0);
+	function d(e) {
+		var r, i = (e = array_default(e)).length, d, f, p = 0, m = Array(i), h = Array(i), g = +c.apply(this, arguments), _ = Math.min(tau, Math.max(-tau, l.apply(this, arguments) - g)), v, y = Math.min(Math.abs(_) / i, u.apply(this, arguments)), b = y * (_ < 0 ? -1 : 1), x;
+		for (r = 0; r < i; ++r) (x = h[m[r] = r] = +a(e[r], r, e)) > 0 && (p += x);
+		for (o == null ? s != null && m.sort(function(t, n) {
+			return s(e[t], e[n]);
+		}) : m.sort(function(e, t) {
+			return o(h[e], h[t]);
+		}), r = 0, f = p ? (_ - i * b) / p : 0; r < i; ++r, g = v) d = m[r], x = h[d], v = g + (x > 0 ? x * f : 0) + b, h[d] = {
+			data: e[d],
+			index: r,
+			value: x,
+			startAngle: g,
+			endAngle: v,
+			padAngle: y
+		};
+		return h;
+	}
+	return d.value = function(t) {
+		return arguments.length ? (a = typeof t == "function" ? t : constant_default(+t), d) : a;
+	}, d.sortValues = function(e) {
+		return arguments.length ? (o = e, s = null, d) : o;
+	}, d.sort = function(e) {
+		return arguments.length ? (s = e, o = null, d) : s;
+	}, d.startAngle = function(t) {
+		return arguments.length ? (c = typeof t == "function" ? t : constant_default(+t), d) : c;
+	}, d.endAngle = function(t) {
+		return arguments.length ? (l = typeof t == "function" ? t : constant_default(+t), d) : l;
+	}, d.padAngle = function(t) {
+		return arguments.length ? (u = typeof t == "function" ? t : constant_default(+t), d) : u;
+	}, d;
+}
+export { pie_default as default };

package/dist/node_modules/d3-shape/src/point.js

@@ -0,0 +1,7 @@
+function x(e) {
+	return e[0];
+}
+function y(e) {
+	return e[1];
+}
+export { x, y };

package/dist/node_modules/d3-time/src/day.js

@@ -0,0 +1,17 @@
+import { timeInterval } from "./interval.js";
+import { durationDay, durationMinute } from "./duration.js";
+const timeDay = timeInterval((e) => e.setHours(0, 0, 0, 0), (e, r) => e.setDate(e.getDate() + r), (e, a) => (a - e - (a.getTimezoneOffset() - e.getTimezoneOffset()) * durationMinute) / durationDay, (e) => e.getDate() - 1);
+timeDay.range;
+const utcDay = timeInterval((e) => {
+	e.setUTCHours(0, 0, 0, 0);
+}, (e, r) => {
+	e.setUTCDate(e.getUTCDate() + r);
+}, (e, i) => (i - e) / durationDay, (e) => e.getUTCDate() - 1);
+utcDay.range;
+const unixDay = timeInterval((e) => {
+	e.setUTCHours(0, 0, 0, 0);
+}, (e, r) => {
+	e.setUTCDate(e.getUTCDate() + r);
+}, (e, i) => (i - e) / durationDay, (e) => Math.floor(e / durationDay));
+unixDay.range;
+export { timeDay, unixDay, utcDay };

package/dist/node_modules/d3-time/src/duration.js

@@ -0,0 +1,2 @@
+const durationSecond = 1e3, durationMinute = durationSecond * 60, durationHour = durationMinute * 60, durationDay = durationHour * 24, durationWeek = durationDay * 7, durationMonth = durationDay * 30, durationYear = durationDay * 365;
+export { durationDay, durationHour, durationMinute, durationMonth, durationSecond, durationWeek, durationYear };

package/dist/node_modules/d3-time/src/hour.js

@@ -0,0 +1,15 @@
+import { timeInterval } from "./interval.js";
+import { durationHour, durationMinute, durationSecond } from "./duration.js";
+const timeHour = timeInterval((e) => {
+	e.setTime(e - e.getMilliseconds() - e.getSeconds() * durationSecond - e.getMinutes() * durationMinute);
+}, (e, a) => {
+	e.setTime(+e + a * durationHour);
+}, (e, a) => (a - e) / durationHour, (e) => e.getHours());
+timeHour.range;
+const utcHour = timeInterval((e) => {
+	e.setUTCMinutes(0, 0, 0);
+}, (e, a) => {
+	e.setTime(+e + a * durationHour);
+}, (e, a) => (a - e) / durationHour, (e) => e.getUTCHours());
+utcHour.range;
+export { timeHour, utcHour };

package/dist/node_modules/d3-time/src/interval.js

@@ -0,0 +1,24 @@
+var t0 = /* @__PURE__ */ new Date(), t1 = /* @__PURE__ */ new Date();
+function timeInterval(r, i, a, o) {
+	function s(e) {
+		return r(e = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+e)), e;
+	}
+	return s.floor = (e) => (r(e = /* @__PURE__ */ new Date(+e)), e), s.ceil = (e) => (r(e = /* @__PURE__ */ new Date(e - 1)), i(e, 1), r(e), e), s.round = (e) => {
+		let t = s(e), n = s.ceil(e);
+		return e - t < n - e ? t : n;
+	}, s.offset = (e, t) => (i(e = /* @__PURE__ */ new Date(+e), t == null ? 1 : Math.floor(t)), e), s.range = (e, t, n) => {
+		let a = [];
+		if (e = s.ceil(e), n = n == null ? 1 : Math.floor(n), !(e < t) || !(n > 0)) return a;
+		let o;
+		do
+			a.push(o = /* @__PURE__ */ new Date(+e)), i(e, n), r(e);
+		while (o < e && e < t);
+		return a;
+	}, s.filter = (e) => timeInterval((t) => {
+		if (t >= t) for (; r(t), !e(t);) t.setTime(t - 1);
+	}, (t, n) => {
+		if (t >= t) if (n < 0) for (; ++n <= 0;) for (; i(t, -1), !e(t););
+		else for (; --n >= 0;) for (; i(t, 1), !e(t););
+	}), a && (s.count = (n, i) => (t0.setTime(+n), t1.setTime(+i), r(t0), r(t1), Math.floor(a(t0, t1))), s.every = (e) => (e = Math.floor(e), !isFinite(e) || !(e > 0) ? null : e > 1 ? s.filter(o ? (t) => o(t) % e === 0 : (t) => s.count(0, t) % e === 0) : s)), s;
+}
+export { timeInterval };

package/dist/node_modules/d3-time/src/millisecond.js

@@ -0,0 +1,10 @@
+import { timeInterval } from "./interval.js";
+const millisecond = timeInterval(() => {}, (e, t) => {
+	e.setTime(+e + t);
+}, (e, t) => t - e);
+millisecond.every = (n) => (n = Math.floor(n), !isFinite(n) || !(n > 0) ? null : n > 1 ? timeInterval((e) => {
+	e.setTime(Math.floor(e / n) * n);
+}, (e, t) => {
+	e.setTime(+e + t * n);
+}, (e, t) => (t - e) / n) : millisecond), millisecond.range;
+export { millisecond };

package/dist/node_modules/d3-time/src/minute.js

@@ -0,0 +1,15 @@
+import { timeInterval } from "./interval.js";
+import { durationMinute, durationSecond } from "./duration.js";
+const timeMinute = timeInterval((e) => {
+	e.setTime(e - e.getMilliseconds() - e.getSeconds() * durationSecond);
+}, (e, i) => {
+	e.setTime(+e + i * durationMinute);
+}, (e, i) => (i - e) / durationMinute, (e) => e.getMinutes());
+timeMinute.range;
+const utcMinute = timeInterval((e) => {
+	e.setUTCSeconds(0, 0);
+}, (e, i) => {
+	e.setTime(+e + i * durationMinute);
+}, (e, i) => (i - e) / durationMinute, (e) => e.getUTCMinutes());
+utcMinute.range;
+export { timeMinute, utcMinute };

package/dist/node_modules/d3-time/src/month.js

@@ -0,0 +1,14 @@
+import { timeInterval } from "./interval.js";
+const timeMonth = timeInterval((e) => {
+	e.setDate(1), e.setHours(0, 0, 0, 0);
+}, (e, n) => {
+	e.setMonth(e.getMonth() + n);
+}, (e, n) => n.getMonth() - e.getMonth() + (n.getFullYear() - e.getFullYear()) * 12, (e) => e.getMonth());
+timeMonth.range;
+const utcMonth = timeInterval((e) => {
+	e.setUTCDate(1), e.setUTCHours(0, 0, 0, 0);
+}, (e, n) => {
+	e.setUTCMonth(e.getUTCMonth() + n);
+}, (e, n) => n.getUTCMonth() - e.getUTCMonth() + (n.getUTCFullYear() - e.getUTCFullYear()) * 12, (e) => e.getUTCMonth());
+utcMonth.range;
+export { timeMonth, utcMonth };

package/dist/node_modules/d3-time/src/second.js

@@ -0,0 +1,9 @@
+import { timeInterval } from "./interval.js";
+import { durationSecond } from "./duration.js";
+const second = timeInterval((e) => {
+	e.setTime(e - e.getMilliseconds());
+}, (e, n) => {
+	e.setTime(+e + n * durationSecond);
+}, (e, n) => (n - e) / durationSecond, (e) => e.getUTCSeconds());
+second.range;
+export { second };

package/dist/node_modules/d3-time/src/ticks.js

@@ -0,0 +1,121 @@
+import bisector from "../../d3-array/src/bisector.js";
+import { tickStep } from "../../d3-array/src/ticks.js";
+import { millisecond } from "./millisecond.js";
+import { durationDay, durationHour, durationMinute, durationMonth, durationSecond, durationWeek, durationYear } from "./duration.js";
+import { second } from "./second.js";
+import { timeMinute, utcMinute } from "./minute.js";
+import { timeHour, utcHour } from "./hour.js";
+import { timeDay, unixDay } from "./day.js";
+import { timeSunday, utcSunday } from "./week.js";
+import { timeMonth, utcMonth } from "./month.js";
+import { timeYear, utcYear } from "./year.js";
+function ticker(y, b, x, S, C, w) {
+	let T = [
+		[
+			second,
+			1,
+			durationSecond
+		],
+		[
+			second,
+			5,
+			5 * durationSecond
+		],
+		[
+			second,
+			15,
+			15 * durationSecond
+		],
+		[
+			second,
+			30,
+			30 * durationSecond
+		],
+		[
+			w,
+			1,
+			durationMinute
+		],
+		[
+			w,
+			5,
+			5 * durationMinute
+		],
+		[
+			w,
+			15,
+			15 * durationMinute
+		],
+		[
+			w,
+			30,
+			30 * durationMinute
+		],
+		[
+			C,
+			1,
+			durationHour
+		],
+		[
+			C,
+			3,
+			3 * durationHour
+		],
+		[
+			C,
+			6,
+			6 * durationHour
+		],
+		[
+			C,
+			12,
+			12 * durationHour
+		],
+		[
+			S,
+			1,
+			durationDay
+		],
+		[
+			S,
+			2,
+			2 * durationDay
+		],
+		[
+			x,
+			1,
+			durationWeek
+		],
+		[
+			b,
+			1,
+			durationMonth
+		],
+		[
+			b,
+			3,
+			3 * durationMonth
+		],
+		[
+			y,
+			1,
+			durationYear
+		]
+	];
+	function E(e, u, d) {
+		let f = u < e;
+		f && ([e, u] = [u, e]);
+		let p = d && typeof d.range == "function" ? d : D(e, u, d), m = p ? p.range(e, +u + 1) : [];
+		return f ? m.reverse() : m;
+	}
+	function D(f, p, m) {
+		let h = Math.abs(p - f) / m, g = bisector(([, , e]) => e).right(T, h);
+		if (g === T.length) return y.every(tickStep(f / durationYear, p / durationYear, m));
+		if (g === 0) return millisecond.every(Math.max(tickStep(f, p, m), 1));
+		let [_, v] = T[h / T[g - 1][2] < T[g][2] / h ? g - 1 : g];
+		return _.every(v);
+	}
+	return [E, D];
+}
+var [utcTicks, utcTickInterval] = ticker(utcYear, utcMonth, utcSunday, unixDay, utcHour, utcMinute), [timeTicks, timeTickInterval] = ticker(timeYear, timeMonth, timeSunday, timeDay, timeHour, timeMinute);
+export { timeTickInterval, timeTicks };

package/dist/node_modules/d3-time/src/week.js

@@ -0,0 +1,21 @@
+import { timeInterval } from "./interval.js";
+import { durationMinute, durationWeek } from "./duration.js";
+function timeWeekday(v) {
+	return timeInterval((e) => {
+		e.setDate(e.getDate() - (e.getDay() + 7 - v) % 7), e.setHours(0, 0, 0, 0);
+	}, (e, _) => {
+		e.setDate(e.getDate() + _ * 7);
+	}, (e, v) => (v - e - (v.getTimezoneOffset() - e.getTimezoneOffset()) * durationMinute) / durationWeek);
+}
+const timeSunday = timeWeekday(0), timeMonday = timeWeekday(1), timeTuesday = timeWeekday(2), timeWednesday = timeWeekday(3), timeThursday = timeWeekday(4), timeFriday = timeWeekday(5), timeSaturday = timeWeekday(6);
+timeSunday.range, timeMonday.range, timeTuesday.range, timeWednesday.range, timeThursday.range, timeFriday.range, timeSaturday.range;
+function utcWeekday(_) {
+	return timeInterval((e) => {
+		e.setUTCDate(e.getUTCDate() - (e.getUTCDay() + 7 - _) % 7), e.setUTCHours(0, 0, 0, 0);
+	}, (e, _) => {
+		e.setUTCDate(e.getUTCDate() + _ * 7);
+	}, (e, _) => (_ - e) / durationWeek);
+}
+const utcSunday = utcWeekday(0), utcMonday = utcWeekday(1), utcTuesday = utcWeekday(2), utcWednesday = utcWeekday(3), utcThursday = utcWeekday(4), utcFriday = utcWeekday(5), utcSaturday = utcWeekday(6);
+utcSunday.range, utcMonday.range, utcTuesday.range, utcWednesday.range, utcThursday.range, utcFriday.range, utcSaturday.range;
+export { timeFriday, timeMonday, timeSaturday, timeSunday, timeThursday, timeTuesday, timeWednesday, utcFriday, utcMonday, utcSaturday, utcSunday, utcThursday, utcTuesday, utcWednesday };

package/dist/node_modules/d3-time/src/year.js

@@ -0,0 +1,22 @@
+import { timeInterval } from "./interval.js";
+const timeYear = timeInterval((e) => {
+	e.setMonth(0, 1), e.setHours(0, 0, 0, 0);
+}, (e, t) => {
+	e.setFullYear(e.getFullYear() + t);
+}, (e, t) => t.getFullYear() - e.getFullYear(), (e) => e.getFullYear());
+timeYear.every = (t) => !isFinite(t = Math.floor(t)) || !(t > 0) ? null : timeInterval((e) => {
+	e.setFullYear(Math.floor(e.getFullYear() / t) * t), e.setMonth(0, 1), e.setHours(0, 0, 0, 0);
+}, (e, n) => {
+	e.setFullYear(e.getFullYear() + n * t);
+}), timeYear.range;
+const utcYear = timeInterval((e) => {
+	e.setUTCMonth(0, 1), e.setUTCHours(0, 0, 0, 0);
+}, (e, t) => {
+	e.setUTCFullYear(e.getUTCFullYear() + t);
+}, (e, t) => t.getUTCFullYear() - e.getUTCFullYear(), (e) => e.getUTCFullYear());
+utcYear.every = (t) => !isFinite(t = Math.floor(t)) || !(t > 0) ? null : timeInterval((e) => {
+	e.setUTCFullYear(Math.floor(e.getUTCFullYear() / t) * t), e.setUTCMonth(0, 1), e.setUTCHours(0, 0, 0, 0);
+}, (e, n) => {
+	e.setUTCFullYear(e.getUTCFullYear() + n * t);
+}), utcYear.range;
+export { timeYear, utcYear };

package/dist/node_modules/d3-time-format/src/defaultLocale.js

@@ -0,0 +1,58 @@
+import formatLocale from "./locale.js";
+var locale, timeFormat, timeParse, utcFormat, utcParse;
+defaultLocale({
+	dateTime: "%x, %X",
+	date: "%-m/%-d/%Y",
+	time: "%-I:%M:%S %p",
+	periods: ["AM", "PM"],
+	days: [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	shortDays: [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	months: [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	shortMonths: [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	]
+});
+function defaultLocale(o) {
+	return locale = formatLocale(o), timeFormat = locale.format, timeParse = locale.parse, utcFormat = locale.utcFormat, utcParse = locale.utcParse, locale;
+}
+export { defaultLocale as default, timeFormat, timeParse, utcFormat, utcParse };