blazeplot 0.2.2 → 0.3.0

package/dist/Chart-BW9JaHs6.js

@@ -0,0 +1,2903 @@
+import e from "regl";
+//#region src/core/MinMaxPyramid.ts
+var t = 16, n = class {
+	bucketSize;
+	levels = [];
+	levelLengths;
+	levelSampleWidths;
+	_builtLen = 0;
+	_lastRangeStart = NaN;
+	constructor(e = 2) {
+		if (this.bucketSize = e, !Number.isInteger(e) || e < 2) throw RangeError("MinMaxPyramid bucketSize must be an integer >= 2.");
+		this.levelLengths = new Uint32Array(t), this.levelSampleWidths = new Uint32Array(t);
+	}
+	build(e) {
+		this.levels = [], this.levelLengths.fill(0), this.levelSampleWidths.fill(0);
+		let n = e.length;
+		if (n === 0) {
+			this._builtLen = 0, this._lastRangeStart = NaN;
+			return;
+		}
+		let r = null, i = 0;
+		for (; n > 0 && i < t;) {
+			let t = Math.ceil(n / this.bucketSize), a = new Float32Array(t * 2);
+			for (let t = 0; t < n; t += this.bucketSize) {
+				let i = Infinity, o = -Infinity, s = Math.min(t + this.bucketSize, n);
+				for (let n = t; n < s; n++) if (r) {
+					let e = r[n * 2], t = r[n * 2 + 1];
+					e < i && (i = e), t > o && (o = t);
+				} else {
+					let t = e.getY(n);
+					t < i && (i = t), t > o && (o = t);
+				}
+				let c = Math.floor(t / this.bucketSize);
+				a[c * 2] = i, a[c * 2 + 1] = o;
+			}
+			if (this.levels[i] = a, this.levelLengths[i] = t, this.levelSampleWidths[i] = this.bucketSize ** (i + 1), t === 1) break;
+			r = a, n = t, i++;
+		}
+		this._builtLen = e.length, this._lastRangeStart = e.range?.start ?? NaN;
+	}
+	incrementalBuild(e) {
+		let t = e.length, n = e.range?.start ?? NaN;
+		if (t === 0) {
+			this.levels = [], this.levelLengths.fill(0), this.levelSampleWidths.fill(0), this._builtLen = 0, this._lastRangeStart = NaN;
+			return;
+		}
+		if (t < this._builtLen || n !== this._lastRangeStart) {
+			this.build(e);
+			return;
+		}
+		t !== this._builtLen && (this.appendTail(e, t - this._builtLen), this._builtLen = t);
+	}
+	appendTail(e, n) {
+		let r = e.length, i = this.bucketSize, a = r - n;
+		for (let n = 0; n < t; n++) {
+			let t = n === 0 ? r : this.levelLengths[n - 1], o = Math.floor(a / i), s = Math.ceil(t / i) - 1;
+			if (o > s) break;
+			this.levelSampleWidths[n] = i ** (n + 1), this.ensureLevelData(n, s + 1);
+			for (let r = o; r <= s; r++) {
+				let a = r * i, o = Math.min((r + 1) * i, t), s = Infinity, c = -Infinity;
+				if (n === 0) for (let t = a; t < o; t++) {
+					let n = e.getY(t);
+					n < s && (s = n), n > c && (c = n);
+				}
+				else {
+					let e = this.levels[n - 1];
+					for (let t = a; t < o; t++) {
+						let n = e[t * 2], r = e[t * 2 + 1];
+						n < s && (s = n), r > c && (c = r);
+					}
+				}
+				let l = this.levels[n];
+				l[r * 2] = s, l[r * 2 + 1] = c;
+			}
+			if (this.levelLengths[n] = s + 1, a = o, this.levelLengths[n] <= 1) break;
+		}
+	}
+	ensureLevelData(e, t) {
+		let n = t * 2, r = this.levels[e];
+		if (r && r.length >= n) return;
+		let i = r?.length ?? 0;
+		if (i <= 0) i = n;
+		else for (; i < n;) i = Math.max(n, Math.ceil(i * 1.5));
+		let a = new Float32Array(i);
+		r && a.set(r), this.levels[e] = a;
+	}
+	rangeMinMax(e, t, n) {
+		let r = Math.max(0, Math.floor(t)), i = Math.min(e.length, Math.ceil(n));
+		if (i <= r) return null;
+		let a = Infinity, o = -Infinity, s = r;
+		for (; s < i;) {
+			let t = -1, n = 1;
+			for (let e = this.levels.length - 1; e >= 0; e--) {
+				let r = this.levelSampleWidths[e], a = Math.floor(s / r);
+				if (r > 0 && s % r === 0 && s + r <= i && a < this.levelLengths[e]) {
+					t = e, n = r;
+					break;
+				}
+			}
+			if (t >= 0) {
+				let e = Math.floor(s / n), r = this.levels[t], i = r[e * 2], c = r[e * 2 + 1];
+				i < a && (a = i), c > o && (o = c), s += n;
+			} else {
+				let t = e.getY(s);
+				t < a && (a = t), t > o && (o = t), s++;
+			}
+		}
+		return Number.isFinite(a) && Number.isFinite(o) ? {
+			minY: a,
+			maxY: o
+		} : null;
+	}
+	query(e, t, n) {
+		if (t <= 0 || n.length <= 0) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: 0,
+			samplesPerPixel: 0
+		};
+		let r = n.length, i = Math.max(1, r / t), a = Math.min(Math.max(0, Math.ceil(Math.log2(i)) - 1), this.levels.length - 1), o = this.levels[a], s = this.levelLengths[a], c = this.levelSampleWidths[a];
+		if (!o || s === void 0 || c === void 0 || s === 0 || c === 0) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: 0,
+			samplesPerPixel: i
+		};
+		let l = Math.max(0, n.start), u = l + n.length, d = Math.max(0, Math.floor(l / c)), f = Math.min(s, Math.ceil(u / c)) - d;
+		if (f <= 0) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: a,
+			samplesPerPixel: i
+		};
+		let p = new Float32Array(f * 2);
+		for (let e = 0; e < f; e++) {
+			let t = (d + e) * 2;
+			p[e * 2] = o[t], p[e * 2 + 1] = o[t + 1];
+		}
+		return {
+			buckets: p,
+			bucketCount: f,
+			level: a,
+			samplesPerPixel: i
+		};
+	}
+};
+//#endregion
+//#region src/core/SeriesStore.ts
+function r(e) {
+	return "rangeMinMaxY" in e;
+}
+function i(e) {
+	return "getOpen" in e && "getHigh" in e && "getLow" in e && "getClose" in e;
+}
+function a(e) {
+	return "appendY" in e;
+}
+function o(e) {
+	return "copySamplesRange" in e;
+}
+function s(e) {
+	return "copyMinMaxSegments" in e;
+}
+function c(e) {
+	return "copyVisibleSamples" in e;
+}
+function l(e) {
+	return "copyVisiblePoints" in e;
+}
+var u = 64, d = 64, f = 1024;
+function p(e, t, n, r, i) {
+	if (n === e) return t;
+	let a = (i - e) / (n - e);
+	return t + (r - t) * a;
+}
+var m = class {
+	config;
+	style;
+	dataset;
+	pyramid;
+	_dirty = !1;
+	_useDatasetRangeMinMax = !1;
+	_useRawMinMaxScan = !1;
+	_lastBuildLength = 0;
+	_lastBuildRangeStart = NaN;
+	_visible = !0;
+	constructor(e, t, i) {
+		this.dataset = e, this.config = t, this.pyramid = (t.mode === "line" || t.mode === "bar" || t.mode === "scatter") && t.downsample !== "none" ? new n() : null, this._useDatasetRangeMinMax = r(e), this.style = i, this.pyramid && e.length > 0 && !this._useDatasetRangeMinMax && this.pyramid.build(e), this._lastBuildLength = e.length, this._lastBuildRangeStart = e.range?.start ?? NaN;
+	}
+	get hasLOD() {
+		return this.pyramid !== null;
+	}
+	get dirty() {
+		return this._dirty;
+	}
+	get length() {
+		return this.dataset.length;
+	}
+	get visible() {
+		return this._visible;
+	}
+	setVisible(e) {
+		this._visible = e;
+	}
+	append(e, t) {
+		if (!("push" in this.dataset)) throw TypeError("SeriesStore dataset is not appendable.");
+		this.dataset.append(e, t), this._dirty = !0;
+	}
+	appendY(e) {
+		if (!a(this.dataset)) throw TypeError("SeriesStore dataset does not support appendY.");
+		this.dataset.appendY(e), this._dirty = !0;
+	}
+	markDirty() {
+		this._dirty = !0;
+	}
+	clear() {
+		if (!("clear" in this.dataset)) throw TypeError("SeriesStore dataset is not clearable.");
+		this.dataset.clear(), this._useDatasetRangeMinMax = r(this.dataset), this._useRawMinMaxScan = !1, this.pyramid && !this._useDatasetRangeMinMax && this.pyramid.build(this.dataset), this._lastBuildLength = this.dataset.length, this._lastBuildRangeStart = this.dataset.range?.start ?? NaN, this._dirty = !1;
+	}
+	rebuildPyramid() {
+		if (this._dirty) {
+			if (this.pyramid) {
+				let e = this.dataset.length, t = this.dataset.range?.start ?? NaN, n = e === this._lastBuildLength && t !== this._lastBuildRangeStart;
+				r(this.dataset) ? (this._useDatasetRangeMinMax = !0, this._useRawMinMaxScan = !1) : n ? (this._useDatasetRangeMinMax = !1, this._useRawMinMaxScan = !0) : (this.pyramid.incrementalBuild(this.dataset), this._useDatasetRangeMinMax = !1, this._useRawMinMaxScan = !1), this._lastBuildLength = e, this._lastBuildRangeStart = t;
+			}
+			this._dirty = !1;
+		}
+	}
+	query(e, t) {
+		if (!this.pyramid || !this.dataset.range) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: 0,
+			samplesPerPixel: 0
+		};
+		let n = this.dataset.lowerBoundX(e.xMin), r = this.dataset.upperBoundX(e.xMax), i = Math.max(0, r - n);
+		return this._useDatasetRangeMinMax ? this.queryRangeMinMax(n, i, t) : this.pyramid.query(e, t, {
+			start: n,
+			length: i
+		});
+	}
+	visibleSampleCount(e) {
+		let t = this.dataset.lowerBoundX(e.xMin), n = this.dataset.upperBoundX(e.xMax);
+		return Math.max(0, n - t);
+	}
+	sampleAt(e) {
+		return e < 0 || e >= this.dataset.length ? null : {
+			index: e,
+			x: this.dataset.getX(e),
+			y: this.dataset.getY(e)
+		};
+	}
+	nearestSampleByX(e, t) {
+		let n = this.visibleIndexRange(t);
+		if (n.start >= n.end) return null;
+		let r = this.dataset.lowerBoundX(e), i = Math.min(Math.max(r, n.start), n.end - 1), a = i - 1;
+		if (a >= n.start) {
+			let t = Math.abs(this.dataset.getX(i) - e);
+			Math.abs(this.dataset.getX(a) - e) <= t && (i = a);
+		}
+		return this.sampleAt(i);
+	}
+	nearestSampleByPoint(e, t, n, r, i, a = Infinity) {
+		let o = this.visibleIndexRange(n), s = n.xMax - n.xMin, c = n.yMax - n.yMin;
+		if (o.start >= o.end || r <= 0 || i <= 0 || s <= 0 || c <= 0) return null;
+		let l = r / s, d = i / c, f = -1, p = a < 0 ? -1 : Number.isFinite(a) ? a * a : Infinity, m = (n) => {
+			let r = (this.dataset.getX(n) - e) * l, i = (this.dataset.getY(n) - t) * d, a = r * r + i * i;
+			(a < p || f < 0 && a <= p) && (p = a, f = n);
+		}, h = this.dataset.lowerBoundX(e), g = Math.min(Math.max(h, o.start), o.end - 1);
+		if (m(g), g > o.start && m(g - 1), g + 1 < o.end && m(g + 1), this.hasPointIntervalBounds() && o.end - o.start > u) {
+			let n = this.pointIntervalDistanceSq(o.start, o.end, e, t, l, d), r = n <= p ? [{
+				start: o.start,
+				end: o.end,
+				lowerBoundSq: n
+			}] : [];
+			for (; r.length > 0;) {
+				let n = r.pop();
+				if (n.lowerBoundSq > p) continue;
+				let i = n.end - n.start;
+				if (i <= u) {
+					for (let e = n.start; e < n.end; e++) m(e);
+					continue;
+				}
+				let a = n.start + (i >> 1), o = this.pointIntervalDistanceSq(n.start, a, e, t, l, d), s = this.pointIntervalDistanceSq(a, n.end, e, t, l, d), c = {
+					start: n.start,
+					end: a,
+					lowerBoundSq: o
+				}, f = {
+					start: a,
+					end: n.end,
+					lowerBoundSq: s
+				};
+				o < s ? (s <= p && r.push(f), o <= p && r.push(c)) : (o <= p && r.push(c), s <= p && r.push(f));
+			}
+		} else {
+			let t = Math.min(h - 1, o.end - 1), n = Math.max(h, o.start);
+			for (; t >= o.start || n < o.end;) {
+				let r = t >= o.start ? this.pointXDistanceSq(t, e, l) : Infinity, i = n < o.end ? this.pointXDistanceSq(n, e, l) : Infinity;
+				if (r > p && i > p) break;
+				r <= i ? (r <= p && m(t), t--) : (i <= p && m(n), n++);
+			}
+		}
+		if (f < 0) return null;
+		let _ = this.sampleAt(f);
+		return _ ? {
+			..._,
+			distancePx: Math.sqrt(p)
+		} : null;
+	}
+	copyRawVisible(e, t, n, r = 0) {
+		return this.copyVisibleSamples(e, t, n, "points", 0, r);
+	}
+	copyScatterVisible(e, t, n, r, i, a, o = 0) {
+		return this.copyVisiblePoints(e, t, n, r, i, a, o);
+	}
+	copyScatterRange(e, t, n, r, i, a = 0, o = 0, s = 0) {
+		if (i <= 0 || r.length < i * 2) return 0;
+		let c = Math.max(0, Math.floor(e)), l = Math.min(this.dataset.length, Math.ceil(t));
+		if (l <= c) return 0;
+		let u = n.yMax - n.yMin, d = Math.max(0, Math.floor(o)), f = u > 0 && d > 0 ? (Number.isFinite(s) ? Math.max(0, s) : 0) * .5 / d * u : 0, p = n.yMin - f, m = n.yMax + f, h = 0;
+		for (let e = c; e < l && h < i; e++) {
+			let t = this.dataset.getY(e);
+			if (t < p || t > m) continue;
+			let n = h * 2;
+			r[n] = this.dataset.getX(e) - a, r[n + 1] = t, h++;
+		}
+		return h;
+	}
+	copyRawVisibleClipped(e, t, n, r = 0) {
+		return this.copyClippedVisibleLine(e, t, n, r, "data");
+	}
+	copyRawVisibleClipSpace(e, t, n) {
+		return this.copyClippedVisibleLine(e, t, n, 0, "clip");
+	}
+	copyRawRange(e, t, n, r, i = 0) {
+		return this.copySampleRange(e, t, n, r, "points", 0, i);
+	}
+	copyAreaVisible(e, t, n, r = 0, i = 0) {
+		return this.copyVisibleSamples(e, t, n, "area", r, i) * 2;
+	}
+	copyAreaRange(e, t, n, r, i = 0, a = 0) {
+		return this.copySampleRange(e, t, n, r, "area", i, a) * 2;
+	}
+	copyMinMaxVisible(e, t, n, r = 0) {
+		return this.copyMinMaxSegments(e, t, n, "line-list", r) * 2;
+	}
+	copyMinMaxInstanced(e, t, n, r = 0) {
+		return this.copyMinMaxSegments(e, t, n, "instanced", r);
+	}
+	copyOhlcRange(e, t, n, r, a, o = 0) {
+		if (!i(this.dataset) || r <= 0 || n.length < r * 12) return 0;
+		let s = Math.max(0, Math.floor(e)), c = Math.min(this.dataset.length, Math.ceil(t)), l = Math.min(r, Math.max(0, c - s)), u = a * .5;
+		for (let e = 0; e < l; e++) {
+			let t = s + e, r = this.dataset.getX(t) - o, i = this.dataset.getOpen(t), a = this.dataset.getHigh(t), c = this.dataset.getLow(t), l = this.dataset.getClose(t), d = e * 12;
+			n[d] = r, n[d + 1] = c, n[d + 2] = r, n[d + 3] = a, n[d + 4] = r - u, n[d + 5] = i, n[d + 6] = r, n[d + 7] = i, n[d + 8] = r, n[d + 9] = l, n[d + 10] = r + u, n[d + 11] = l;
+		}
+		return l;
+	}
+	copyOhlcTuplesRange(e, t, n, r, a = 0) {
+		if (!i(this.dataset) || r <= 0 || n.length < r * 5) return 0;
+		let o = Math.max(0, Math.floor(e)), s = Math.min(this.dataset.length, Math.ceil(t)), c = Math.min(r, Math.max(0, s - o));
+		for (let e = 0; e < c; e++) {
+			let t = o + e, r = e * 5;
+			n[r] = this.dataset.getX(t) - a, n[r + 1] = this.dataset.getOpen(t), n[r + 2] = this.dataset.getHigh(t), n[r + 3] = this.dataset.getLow(t), n[r + 4] = this.dataset.getClose(t);
+		}
+		return c;
+	}
+	visibleIndexRange(e, t = 0) {
+		if (!e) return {
+			start: 0,
+			end: this.dataset.length
+		};
+		let n = Math.max(0, Math.floor(t));
+		return {
+			start: Math.max(0, this.dataset.lowerBoundX(e.xMin) - n),
+			end: Math.min(this.dataset.length, this.dataset.upperBoundX(e.xMax) + n)
+		};
+	}
+	pointXDistanceSq(e, t, n) {
+		let r = (this.dataset.getX(e) - t) * n;
+		return r * r;
+	}
+	pointIntervalDistanceSq(e, t, n, r, i, a) {
+		if (t <= e) return Infinity;
+		let o = this.dataset.getX(e), s = this.dataset.getX(t - 1), c = n < o ? (o - n) * i : n > s ? (n - s) * i : 0, l = this.pointIntervalMinMaxY(e, t);
+		if (!l) return Infinity;
+		let u = r < l.minY ? (l.minY - r) * a : r > l.maxY ? (r - l.maxY) * a : 0;
+		return c * c + u * u;
+	}
+	hasPointIntervalBounds() {
+		return r(this.dataset) || this.pyramid !== null && !this._dirty && !this._useRawMinMaxScan;
+	}
+	pointIntervalMinMaxY(e, t) {
+		return r(this.dataset) ? this.dataset.rangeMinMaxY(e, t) : this.pyramid && !this._dirty && !this._useRawMinMaxScan ? this.pyramid.rangeMinMax(this.dataset, e, t) : null;
+	}
+	copyClippedVisibleLine(e, t, n, r, i) {
+		if (n <= 0 || t.length < n * 2) return 0;
+		let a = e.xMax - e.xMin, o = e.yMax - e.yMin;
+		if (i === "clip" && (a <= 0 || o <= 0)) return 0;
+		let s = Math.max(0, this.dataset.lowerBoundX(e.xMin) - 1), c = Math.min(this.dataset.length, this.dataset.upperBoundX(e.xMax) + 1);
+		if (c - s <= 0) return 0;
+		let l = 0, u = NaN, d = NaN, f = (s, c) => {
+			let f = i === "clip" ? (s - e.xMin) / a * 2 - 1 : s - r, p = i === "clip" ? (c - e.yMin) / o * 2 - 1 : c;
+			if (l > 0 && f === u && p === d) return !0;
+			if (l >= n) return !1;
+			let m = l * 2;
+			return t[m] = f, t[m + 1] = p, l++, u = f, d = p, !0;
+		};
+		if (c - s === 1) {
+			let t = this.dataset.getX(s);
+			return t < e.xMin || t > e.xMax ? 0 : f(t, this.dataset.getY(s)) ? l : 0;
+		}
+		for (let t = s; t + 1 < c; t++) {
+			let n = this.dataset.getX(t), r = this.dataset.getY(t), i = this.dataset.getX(t + 1), a = this.dataset.getY(t + 1);
+			if (i < e.xMin || n > e.xMax) continue;
+			let o = Math.max(n, e.xMin), s = Math.min(i, e.xMax);
+			if (s < o) continue;
+			let c = p(n, r, i, a, o), l = p(n, r, i, a, s);
+			if (!f(o, c) || !f(s, l)) break;
+		}
+		return l;
+	}
+	copyVisiblePoints(e, t, n, r, i, a, o) {
+		if (l(this.dataset)) return this.dataset.copyVisiblePoints(e, t, n, o, r, i, a);
+		if (n <= 0 || t.length < n * 2) return 0;
+		let s = e.xMax - e.xMin, c = e.yMax - e.yMin, u = Math.max(1, Math.floor(r)), d = Math.max(1, Math.floor(i));
+		if (s <= 0 || c <= 0) return 0;
+		let f = (Number.isFinite(a) ? Math.max(0, a) : 0) * .5, p = f / u * s, m = f / d * c, h = e.xMin - p, g = e.xMax + p, _ = e.yMin - m, v = e.yMax + m, y = this.dataset.lowerBoundX(h), b = this.dataset.upperBoundX(g);
+		if (b <= y) return 0;
+		if (b - y <= n) return this.copyVisiblePointRange(y, b, _, v, t, n, o);
+		let x = this.hasPointIntervalBounds(), S = x ? this.pointIntervalMinMaxY(y, b) : null;
+		if (S && (S.maxY < _ || S.minY > v)) return 0;
+		if (b - y <= n * 4) {
+			let e = this.copyVisiblePointsExact(y, b, _, v, t, n, o);
+			if (!e.overflow) return e.count;
+		}
+		let ee = S !== null && S.minY >= _ && S.maxY <= v;
+		return this.copyVisiblePointBuckets(y, b, _, v, t, n, o, ee, x);
+	}
+	copyVisiblePointRange(e, t, n, r, i, a, o) {
+		let s = 0;
+		for (let c = e; c < t && s < a; c++) {
+			let e = this.dataset.getY(c);
+			if (e < n || e > r) continue;
+			let t = s * 2;
+			i[t] = this.dataset.getX(c) - o, i[t + 1] = e, s++;
+		}
+		return s;
+	}
+	copyVisiblePointBuckets(e, t, n, r, i, a, o, s, c) {
+		let l = t - e, u = this.stableScatterBucketWidth(l, a), d = Math.floor(e / u) * u, p = 0, m = (e) => {
+			let t = p * 2;
+			i[t] = this.dataset.getX(e) - o, i[t + 1] = this.dataset.getY(e), p++;
+		};
+		for (let l = d; l < t && p < a; l += u) {
+			let a = Math.min(t, l + u), d = Math.max(e, l);
+			if (a <= d) continue;
+			let h = Math.max(d, Math.min(a - 1, l + (u >> 1)));
+			if (s) {
+				m(h);
+				continue;
+			}
+			let g = c && a - d >= f ? this.pointIntervalMinMaxY(d, a) : null;
+			if (!(g && (g.maxY < n || g.minY > r))) {
+				if (g && g.minY >= n && g.maxY <= r) {
+					m(h);
+					continue;
+				}
+				for (let e = d; e < a; e++) {
+					let t = this.dataset.getY(e);
+					if (t < n || t > r) continue;
+					let a = p * 2;
+					i[a] = this.dataset.getX(e) - o, i[a + 1] = t, p++;
+					break;
+				}
+			}
+		}
+		return p;
+	}
+	stableScatterBucketWidth(e, t) {
+		let n = Math.max(1, Math.ceil(e / Math.max(1, t)));
+		return n <= 8 ? n : Math.ceil(n / 8) * 8;
+	}
+	copyVisiblePointsExact(e, t, n, r, i, a, o) {
+		let s = 0, c = !1, l = this.hasPointIntervalBounds(), u = (e) => {
+			let t = this.dataset.getY(e);
+			if (t < n || t > r) return !0;
+			if (s >= a) return c = !0, !1;
+			let l = s * 2;
+			return i[l] = this.dataset.getX(e) - o, i[l + 1] = t, s++, !0;
+		}, f = (e, t) => {
+			for (let n = e; n < t; n++) if (!u(n)) return !1;
+			return !0;
+		}, p = (e, t) => {
+			if (t <= e) return !0;
+			let i = l ? this.pointIntervalMinMaxY(e, t) : null;
+			if (i && (i.maxY < n || i.minY > r)) return !0;
+			if (t - e <= d || !l) return f(e, t);
+			let a = e + (t - e >> 1);
+			return p(e, a) && p(a, t);
+		};
+		return p(e, t), {
+			count: s,
+			overflow: c
+		};
+	}
+	copyVisibleSamples(e, t, n, r, i, a) {
+		if (c(this.dataset)) return this.dataset.copyVisibleSamples(e, t, n, r, i, a);
+		let o = r === "points" ? 2 : 4;
+		if (n <= 0 || t.length < n * o) return 0;
+		let s = this.dataset.lowerBoundX(e.xMin), l = this.dataset.upperBoundX(e.xMax), u = l - s;
+		if (u <= 0) return 0;
+		let d = Math.max(1, Math.ceil(u / n)), f = 0;
+		for (let e = s; e < l && f < n; e += d) {
+			let n = this.dataset.getX(e) - a, o = this.dataset.getY(e);
+			if (r === "points") {
+				let e = f * 2;
+				t[e] = n, t[e + 1] = o;
+			} else {
+				let e = f * 4;
+				t[e] = n, t[e + 1] = i, t[e + 2] = n, t[e + 3] = o;
+			}
+			f++;
+		}
+		return f;
+	}
+	copySampleRange(e, t, n, r, i, a, s) {
+		if (o(this.dataset)) return this.dataset.copySamplesRange(e, t, n, r, i, a, s);
+		let c = i === "points" ? 2 : 4;
+		if (r <= 0 || n.length < r * c) return 0;
+		let l = Math.max(0, Math.floor(e)), u = Math.min(this.dataset.length, Math.ceil(t)), d = Math.min(r, Math.max(0, u - l));
+		for (let e = 0; e < d; e++) {
+			let t = l + e, r = this.dataset.getX(t) - s, o = this.dataset.getY(t);
+			if (i === "points") {
+				let t = e * 2;
+				n[t] = r, n[t + 1] = o;
+			} else {
+				let t = e * 4;
+				n[t] = r, n[t + 1] = a, n[t + 2] = r, n[t + 3] = o;
+			}
+		}
+		return d;
+	}
+	copyMinMaxSegments(e, t, n, r, i) {
+		if (s(this.dataset)) return this.dataset.copyMinMaxSegments(e, t, n, r, i);
+		let a = r === "line-list" ? 4 : 3;
+		if (!this.pyramid || n <= 0 || t.length < n * a) return 0;
+		let o = this.dataset.lowerBoundX(e.xMin), c = this.dataset.upperBoundX(e.xMax), l = c - o;
+		if (l <= 0) return 0;
+		let u = Math.min(n, l);
+		for (let e = 0; e < u; e++) {
+			let n = o + Math.floor(e * l / u), a = o + Math.max(Math.floor((e + 1) * l / u), Math.floor(e * l / u) + 1), s = Math.min(c, a), d = this.minMaxForRange(n, s);
+			if (!d) continue;
+			let f = this.dataset.getX(n + (s - n >> 1)) - i, { minY: p, maxY: m } = d;
+			if (r === "line-list") {
+				let n = e * 4;
+				t[n] = f, t[n + 1] = p, t[n + 2] = f, t[n + 3] = m;
+			} else {
+				let n = e * 3;
+				t[n] = f, t[n + 1] = p, t[n + 2] = m;
+			}
+		}
+		return u;
+	}
+	minMaxForRange(e, t) {
+		return this._useDatasetRangeMinMax && r(this.dataset) ? this.dataset.rangeMinMaxY(e, t) : !this.pyramid || this._useRawMinMaxScan ? this.rawMinMaxForRange(e, t) : this.pyramid.rangeMinMax(this.dataset, e, t);
+	}
+	queryRangeMinMax(e, t, n) {
+		if (n <= 0 || t <= 0 || !r(this.dataset)) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: 0,
+			samplesPerPixel: 0
+		};
+		let i = Math.max(1, t / n), a = Math.max(0, Math.ceil(Math.log2(i)) - 1), o = 2 ** (a + 1), s = Math.max(0, e), c = s + t, l = Math.ceil(this.dataset.length / o), u = Math.max(0, Math.floor(s / o)), d = Math.min(l, Math.ceil(c / o)), f = Math.max(0, d - u), p = new Float32Array(f * 2);
+		for (let e = 0; e < f; e++) {
+			let t = (u + e) * o, n = Math.min(this.dataset.length, t + o), r = this.dataset.rangeMinMaxY(t, n);
+			r && (p[e * 2] = r.minY, p[e * 2 + 1] = r.maxY);
+		}
+		return {
+			buckets: p,
+			bucketCount: f,
+			level: a,
+			samplesPerPixel: i
+		};
+	}
+	rawMinMaxForRange(e, t) {
+		if (r(this.dataset)) return this.dataset.rangeMinMaxY(e, t);
+		let n = Math.max(0, Math.floor(e)), i = Math.min(this.dataset.length, Math.ceil(t));
+		if (i <= n) return null;
+		let a = Infinity, o = -Infinity;
+		for (let e = n; e < i; e++) {
+			let t = this.dataset.getY(e);
+			t < a && (a = t), t > o && (o = t);
+		}
+		return {
+			minY: a,
+			maxY: o
+		};
+	}
+};
+//#endregion
+//#region src/core/search.ts
+function h(e, t, n) {
+	let r = 0, i = e;
+	for (; r < i;) {
+		let e = r + (i - r >> 1);
+		t(e) < n ? r = e + 1 : i = e;
+	}
+	return r;
+}
+function g(e, t, n) {
+	let r = 0, i = e;
+	for (; r < i;) {
+		let e = r + (i - r >> 1);
+		t(e) <= n ? r = e + 1 : i = e;
+	}
+	return r;
+}
+//#endregion
+//#region src/core/RingBuffer.ts
+var _ = class e {
+	capacity;
+	_length = 0;
+	_head = 0;
+	xData;
+	yData;
+	treeBase;
+	minTree;
+	maxTree;
+	overflow;
+	constructor(t, n = {}) {
+		if (!Number.isInteger(t) || t <= 0) throw RangeError("RingBuffer capacity must be a positive integer.");
+		this.capacity = t, this.overflow = n.overflow ?? "wrap", this.xData = new Float64Array(t), this.yData = new Float32Array(t), this.treeBase = e.nextPowerOfTwo(t), this.minTree = new Float32Array(this.treeBase * 2), this.maxTree = new Float32Array(this.treeBase * 2), this.minTree.fill(Infinity), this.maxTree.fill(-Infinity);
+	}
+	get length() {
+		return this._length;
+	}
+	get range() {
+		return this._length === 0 ? null : {
+			start: this.getX(0),
+			end: this.getX(this._length - 1)
+		};
+	}
+	push(e, t) {
+		if (this._length >= this.capacity) {
+			if (this.overflow === "drop-new") return;
+			if (this.overflow === "error") throw RangeError("RingBuffer capacity exceeded.");
+		}
+		this.xData[this._head] = e, this.yData[this._head] = t, this.setTreeLeaf(this._head, t), this._head = (this._head + 1) % this.capacity, this._length < this.capacity && this._length++;
+	}
+	append(e, t) {
+		let n = Math.min(e.length, t.length);
+		if (!(n <= 0)) {
+			if (this.overflow !== "wrap") {
+				let r = this.capacity - this._length;
+				if (n > r && this.overflow === "error") throw RangeError("RingBuffer capacity exceeded.");
+				let i = Math.min(n, r);
+				if (i <= 0) return;
+				this.appendNoWrap(e, t, 0, i);
+				return;
+			}
+			if (n >= this.capacity) {
+				let r = n - this.capacity;
+				this._head = 0, this._length = this.capacity, this.copyIntoPhysical(0, e, t, r, this.capacity);
+				return;
+			}
+			this.appendNoWrap(e, t, 0, n);
+		}
+	}
+	get(e) {
+		return e < 0 || e >= this._length ? null : {
+			x: this.getX(e),
+			y: this.getY(e)
+		};
+	}
+	getX(e) {
+		return this.assertValidIndex(e), this.xData[this.logicalToPhysical(e)];
+	}
+	getY(e) {
+		return this.assertValidIndex(e), this.yData[this.logicalToPhysical(e)];
+	}
+	lowerBoundX(e) {
+		return h(this._length, (e) => this.getX(e), e);
+	}
+	upperBoundX(e) {
+		return g(this._length, (e) => this.getX(e), e);
+	}
+	rangeMinMaxY(e, t) {
+		let n = Math.max(0, Math.floor(e)), r = Math.min(this._length, Math.ceil(t));
+		if (r <= n) return null;
+		let i = this.logicalToPhysical(n), a = r - n;
+		if (i + a <= this.capacity) return this.queryPhysicalMinMax(i, i + a);
+		let o = this.queryPhysicalMinMax(i, this.capacity), s = this.queryPhysicalMinMax(0, (i + a) % this.capacity);
+		return o ? s ? {
+			minY: Math.min(o.minY, s.minY),
+			maxY: Math.max(o.maxY, s.maxY)
+		} : o : s;
+	}
+	clear() {
+		this._length = 0, this._head = 0, this.minTree.fill(Infinity), this.maxTree.fill(-Infinity);
+	}
+	appendNoWrap(e, t, n, r) {
+		let i = n, a = r;
+		for (; a > 0;) {
+			let n = Math.min(a, this.capacity - this._head);
+			this.copyIntoPhysical(this._head, e, t, i, n), this._head = (this._head + n) % this.capacity, this._length = Math.min(this.capacity, this._length + n), i += n, a -= n;
+		}
+	}
+	copyIntoPhysical(e, t, n, r, i) {
+		for (let a = 0; a < i; a++) {
+			let i = e + a, o = n[r + a];
+			this.xData[i] = t[r + a], this.yData[i] = o;
+			let s = this.treeBase + i;
+			this.minTree[s] = o, this.maxTree[s] = o;
+		}
+		this.recomputeTreeRange(e, e + i);
+	}
+	setTreeLeaf(e, t) {
+		let n = this.treeBase + e;
+		for (this.minTree[n] = t, this.maxTree[n] = t, n >>= 1; n >= 1;) this.recomputeTreeNode(n), n >>= 1;
+	}
+	recomputeTreeRange(e, t) {
+		let n = this.treeBase + e >> 1, r = this.treeBase + t - 1 >> 1;
+		for (; n >= 1;) {
+			for (let e = n; e <= r; e++) this.recomputeTreeNode(e);
+			if (n === 1) break;
+			n >>= 1, r >>= 1;
+		}
+	}
+	recomputeTreeNode(e) {
+		let t = e << 1, n = t + 1, r = this.minTree[t], i = this.minTree[n], a = this.maxTree[t], o = this.maxTree[n];
+		this.minTree[e] = r < i ? r : i, this.maxTree[e] = a > o ? a : o;
+	}
+	queryPhysicalMinMax(e, t) {
+		if (t <= e) return null;
+		let n = this.treeBase + e, r = this.treeBase + t, i = Infinity, a = -Infinity;
+		for (; n < r;) {
+			if (n & 1) {
+				let e = this.minTree[n], t = this.maxTree[n];
+				e < i && (i = e), t > a && (a = t), n++;
+			}
+			if (r & 1) {
+				r--;
+				let e = this.minTree[r], t = this.maxTree[r];
+				e < i && (i = e), t > a && (a = t);
+			}
+			n >>= 1, r >>= 1;
+		}
+		return Number.isFinite(i) && Number.isFinite(a) ? {
+			minY: i,
+			maxY: a
+		} : null;
+	}
+	logicalToPhysical(e) {
+		return (this._head - this._length + e + this.capacity) % this.capacity;
+	}
+	assertValidIndex(e) {
+		if (!Number.isInteger(e) || e < 0 || e >= this._length) throw RangeError(`RingBuffer index out of range: ${e}`);
+	}
+	static nextPowerOfTwo(e) {
+		return 2 ** Math.ceil(Math.log2(e));
+	}
+}, v = "attribute vec2 position;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\n\nvoid main() {\n  vec2 clipSpace = position * uScale + uOffset;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n}\n", y = "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n", b = "attribute float aX;\nattribute float aMinY;\nattribute float aMaxY;\nattribute float aSelect;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\n\nvoid main() {\n  float y = (aSelect < 0.5) ? aMinY : aMaxY;\n  vec2 position = vec2(aX, y);\n  vec2 clipSpace = position * uScale + uOffset;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n}\n", x = "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n", S = "attribute vec2 aPosition;\nattribute vec2 aCorner;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\nuniform vec2 uCanvasSize;\nuniform float uPointSize;\n\nvoid main() {\n  vec2 centerClip = aPosition * uScale + uOffset;\n  vec2 pointSizeClip = vec2(2.0 / uCanvasSize.x, 2.0 / uCanvasSize.y) * uPointSize * 0.5;\n  vec2 clipSpace = centerClip + aCorner * pointSizeClip;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n}\n", ee = "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n", te = "attribute vec2 aPosition;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\nuniform float uPointSize;\n\nvoid main() {\n  vec2 clipSpace = aPosition * uScale + uOffset;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n  gl_PointSize = uPointSize;\n}\n", ne = "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  vec2 p = gl_PointCoord * 2.0 - 1.0;\n  if (dot(p, p) > 1.0) discard;\n  gl_FragColor = uColor;\n}\n", re = "attribute vec2 aPosition;\nattribute vec2 aCorner;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\nuniform float uBarWidth;\nuniform float uBaseline;\n\nvoid main() {\n  float x = aPosition.x + aCorner.x * uBarWidth;\n  float y = mix(uBaseline, aPosition.y, aCorner.y);\n  vec2 clipSpace = vec2(x, y) * uScale + uOffset;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n}\n", ie = "attribute float aX;\nattribute float aMinY;\nattribute float aMaxY;\nattribute vec2 aCorner;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\nuniform float uBarWidth;\n\nvoid main() {\n  float x = aX + aCorner.x * uBarWidth;\n  float y = mix(aMinY, aMaxY, aCorner.y);\n  vec2 clipSpace = vec2(x, y) * uScale + uOffset;\n  gl_Position = vec4(clipSpace, 0.0, 1.0);\n}\n", ae = "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n", C = {
+	line: {
+		vert: v,
+		frag: y
+	},
+	segment: {
+		vert: b,
+		frag: x
+	},
+	point: {
+		vert: S,
+		frag: ee
+	},
+	pointSprite: {
+		vert: te,
+		frag: ne
+	},
+	bar: {
+		vert: re,
+		frag: ae
+	},
+	barRange: {
+		vert: ie,
+		frag: ae
+	}
+}, w = 3, T = 2, E = 4, oe = 4, se = .8, ce = 0, le = class {
+	backend;
+	lineProgram;
+	segmentProgram;
+	pointProgram;
+	pointSpriteProgram;
+	barProgram;
+	barRangeProgram;
+	segmentSelectBuffer;
+	pointCornerBuffer;
+	barCornerBuffer;
+	scaleUniform = new Float32Array(2);
+	offsetUniform = new Float32Array(2);
+	canvasSizeUniform = new Float32Array(2);
+	xOrigin = 0;
+	constructor(e) {
+		this.backend = e, this.lineProgram = this.backend.createProgram(C.line.vert, C.line.frag), this.segmentProgram = this.backend.createProgram(C.segment.vert, C.segment.frag), this.pointProgram = this.backend.createProgram(C.point.vert, C.point.frag), this.pointSpriteProgram = this.backend.createProgram(C.pointSprite.vert, C.pointSprite.frag), this.barProgram = this.backend.createProgram(C.bar.vert, C.bar.frag), this.barRangeProgram = this.backend.createProgram(C.barRange.vert, C.barRange.frag), this.segmentSelectBuffer = this.backend.createBuffer({
+			usage: "static",
+			type: "float",
+			length: 2
+		}), this.backend.updateBuffer(this.segmentSelectBuffer, new Float32Array([0, 1])), this.pointCornerBuffer = this.backend.createBuffer({
+			usage: "static",
+			type: "float",
+			length: 8
+		}), this.backend.updateBuffer(this.pointCornerBuffer, new Float32Array([
+			-1,
+			-1,
+			1,
+			-1,
+			-1,
+			1,
+			1,
+			1
+		])), this.barCornerBuffer = this.backend.createBuffer({
+			usage: "static",
+			type: "float",
+			length: 8
+		}), this.backend.updateBuffer(this.barCornerBuffer, new Float32Array([
+			-.5,
+			0,
+			.5,
+			0,
+			-.5,
+			1,
+			.5,
+			1
+		]));
+	}
+	get supportsInstancedSegments() {
+		return this.backend.capabilities.instancing;
+	}
+	get supportsInstancedPoints() {
+		return this.backend.capabilities.instancing;
+	}
+	get supportsInstancedBars() {
+		return this.backend.capabilities.instancing;
+	}
+	clear(e, t, n, r) {
+		this.backend.clear(e, t, n, r);
+	}
+	createFloatBuffer(e) {
+		return this.backend.createBuffer({
+			usage: "stream",
+			type: "float",
+			length: e
+		});
+	}
+	updateFloatBuffer(e, t, n = t.length) {
+		let r = Math.max(0, Math.min(n, t.length));
+		this.backend.updateBuffer(e, r === t.length ? t : t.subarray(0, r));
+	}
+	viewport(e, t, n, r) {
+		this.backend.viewport(e, t, n, r);
+	}
+	setXOrigin(e) {
+		this.xOrigin = Number.isFinite(e) ? e : 0;
+	}
+	getWebGLContext() {
+		return this.backend.getContext?.() ?? null;
+	}
+	drawLines(e, t, n, r) {
+		this.drawLinePrimitive("lines", e, t, n, r);
+	}
+	drawLineStrip(e, t, n, r) {
+		this.drawLinePrimitive("line_strip", e, t, n, r);
+	}
+	drawClipLineStrip(e, t, n) {
+		this.drawClipPrimitive("line_strip", e, t, n);
+	}
+	drawClipLines(e, t, n) {
+		this.drawClipPrimitive("lines", e, t, n);
+	}
+	drawMinMaxSegments(e, t, n, r) {
+		this.drawLines(e, t, n, r);
+	}
+	drawMinMaxSegmentsInstanced(e, t, n, r) {
+		this.writeCameraUniforms(r);
+		let i = w * E, a = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: 0
+		}, o = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: E
+		}, s = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: E * 2
+		}, c = {
+			buffer: this.segmentSelectBuffer,
+			divisor: 0,
+			stride: E,
+			offset: 0
+		};
+		this.backend.draw({
+			program: this.segmentProgram,
+			primitive: "lines",
+			count: 2,
+			instances: t,
+			attributes: {
+				aMaxY: s,
+				aMinY: o,
+				aSelect: c,
+				aX: a
+			},
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: n.color
+			}
+		});
+	}
+	drawPoints(e, t, n, r, i, a) {
+		this.supportsInstancedPoints ? this.drawPointsInstanced(e, t, n, r, i, a) : this.drawPointSprites(e, t, n, r);
+	}
+	drawPointsInstanced(e, t, n, r, i, a) {
+		this.writeCameraUniforms(r), this.canvasSizeUniform[0] = Math.max(1, i), this.canvasSizeUniform[1] = Math.max(1, a);
+		let o = {
+			buffer: e,
+			divisor: 1,
+			stride: T * E,
+			offset: 0,
+			size: 2
+		}, s = {
+			buffer: this.pointCornerBuffer,
+			divisor: 0,
+			stride: T * E,
+			offset: 0,
+			size: 2
+		};
+		this.backend.draw({
+			program: this.pointProgram,
+			primitive: "triangle_strip",
+			count: 4,
+			instances: t,
+			attributes: {
+				aCorner: s,
+				aPosition: o
+			},
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uCanvasSize: this.canvasSizeUniform,
+				uPointSize: n.pointSize ?? oe,
+				uColor: n.color
+			}
+		});
+	}
+	drawPointSprites(e, t, n, r) {
+		this.writeCameraUniforms(r), this.backend.draw({
+			program: this.pointSpriteProgram,
+			primitive: "points",
+			count: t,
+			attributes: { aPosition: e },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uPointSize: n.pointSize ?? oe,
+				uColor: n.color
+			}
+		});
+	}
+	drawAreaStrip(e, t, n, r) {
+		this.writeCameraUniforms(r), this.backend.draw({
+			program: this.lineProgram,
+			primitive: "triangle_strip",
+			count: t,
+			attributes: { position: e },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: n.fillColor ?? n.color
+			}
+		});
+	}
+	drawBarsInstanced(e, t, n, r) {
+		this.writeCameraUniforms(r);
+		let i = {
+			buffer: e,
+			divisor: 1,
+			stride: T * E,
+			offset: 0,
+			size: 2
+		}, a = {
+			buffer: this.barCornerBuffer,
+			divisor: 0,
+			stride: T * E,
+			offset: 0,
+			size: 2
+		};
+		this.backend.draw({
+			program: this.barProgram,
+			primitive: "triangle_strip",
+			count: 4,
+			instances: t,
+			attributes: {
+				aCorner: a,
+				aPosition: i
+			},
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uBarWidth: n.barWidth ?? se,
+				uBaseline: n.baseline ?? ce,
+				uColor: n.color
+			}
+		});
+	}
+	drawBarRangesInstanced(e, t, n, r) {
+		this.writeCameraUniforms(r);
+		let i = w * E, a = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: 0
+		}, o = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: E
+		}, s = {
+			buffer: e,
+			divisor: 1,
+			stride: i,
+			offset: E * 2
+		}, c = {
+			buffer: this.barCornerBuffer,
+			divisor: 0,
+			stride: T * E,
+			offset: 0,
+			size: 2
+		};
+		this.backend.draw({
+			program: this.barRangeProgram,
+			primitive: "triangle_strip",
+			count: 4,
+			instances: t,
+			attributes: {
+				aCorner: c,
+				aMaxY: s,
+				aMinY: o,
+				aX: a
+			},
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uBarWidth: n.barWidth ?? se,
+				uColor: n.color
+			}
+		});
+	}
+	drawBarTriangles(e, t, n, r) {
+		this.drawTrianglePrimitive(e, t, n, r);
+	}
+	drawLinePrimitive(e, t, n, r, i) {
+		this.writeCameraUniforms(i), this.backend.draw({
+			program: this.lineProgram,
+			primitive: e,
+			count: n,
+			attributes: { position: t },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: r.color
+			}
+		});
+	}
+	drawTrianglePrimitive(e, t, n, r) {
+		this.writeCameraUniforms(r), this.backend.draw({
+			program: this.lineProgram,
+			primitive: "triangles",
+			count: t,
+			attributes: { position: e },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: n.color
+			}
+		});
+	}
+	drawClipPrimitive(e, t, n, r) {
+		this.scaleUniform[0] = 1, this.scaleUniform[1] = 1, this.offsetUniform[0] = 0, this.offsetUniform[1] = 0, this.backend.draw({
+			program: this.lineProgram,
+			primitive: e,
+			count: n,
+			attributes: { position: t },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: r.color
+			}
+		});
+	}
+	writeCameraUniforms(e) {
+		let t = e.xMin - this.xOrigin, n = e.xMax - this.xOrigin;
+		this.scaleUniform[0] = e.xScale, this.scaleUniform[1] = e.yScale, this.offsetUniform[0] = -(t + n) / (n - t), this.offsetUniform[1] = e.yOffset;
+	}
+	dispose() {
+		this.backend.destroy();
+	}
+}, D = [
+	1024,
+	4096,
+	16384,
+	32768,
+	131072
+], ue = class {
+	regl;
+	pool = [];
+	preAllocated = !1;
+	constructor(e) {
+		this.regl = e;
+	}
+	get reglInstance() {
+		return this.regl;
+	}
+	preAllocate() {
+		if (!this.preAllocated) {
+			this.preAllocated = !0;
+			for (let e of D) this.pool.push(this.createEntry(e, "stream"));
+		}
+	}
+	acquire(e, t = "stream") {
+		let n = e, r = this.findFree(n);
+		if (!r) {
+			let e = this.roundUp(n);
+			r = this.createEntry(e, t), this.pool.push(r);
+		}
+		return r.inUse = !0, {
+			buffer: r.buffer,
+			array: r.floatArray
+		};
+	}
+	release(e) {
+		for (let t of this.pool) if (t.buffer === e) {
+			t.inUse = !1;
+			return;
+		}
+	}
+	destroy() {
+		for (let e of this.pool) e.buffer.destroy();
+		this.pool.length = 0, this.preAllocated = !1;
+	}
+	createEntry(e, t) {
+		return {
+			buffer: this.regl.buffer({
+				length: e * 4,
+				usage: t,
+				type: "float"
+			}),
+			floatArray: new Float32Array(e),
+			floatCapacity: e,
+			inUse: !1
+		};
+	}
+	findFree(e) {
+		return this.pool.find((t) => !t.inUse && t.floatCapacity >= e);
+	}
+	roundUp(e) {
+		for (let t of D) if (t >= e) return t;
+		let t = D[D.length - 1], n = 1 << 32 - Math.clz32(e - 1);
+		return Math.max(t * 2, n);
+	}
+};
+//#endregion
+//#region src/render/ReglBackend.ts
+function de(e) {
+	return e;
+}
+var fe = class {
+	gl;
+	regl;
+	resources;
+	nextProgramId = 1;
+	commandCache = /* @__PURE__ */ new Map();
+	scissorBox = null;
+	capabilities;
+	constructor(t) {
+		let n = t.getContext("webgl2", {
+			alpha: !0,
+			antialias: !1,
+			depth: !1,
+			stencil: !1,
+			premultipliedAlpha: !1,
+			preserveDrawingBuffer: !1,
+			powerPreference: "high-performance"
+		});
+		if (!n) throw Error("BlazePlot requires WebGL2, but this browser/context does not support it.");
+		this.gl = n, this.regl = e({
+			gl: de(this.gl),
+			extensions: [],
+			optionalExtensions: ["angle_instanced_arrays", "ext_disjoint_timer_query_webgl2"]
+		}), this.capabilities = { instancing: this.regl.hasExtension("angle_instanced_arrays") }, this.resources = new ue(this.regl), this.resources.preAllocate();
+	}
+	createBuffer(e) {
+		let { buffer: t } = this.resources.acquire(e.length, e.usage);
+		return {
+			length: e.length,
+			type: e.type,
+			buffer: t
+		};
+	}
+	updateBuffer(e, t, n = 0) {
+		if (t.length + n > e.length) throw RangeError("GPU buffer update exceeds allocated buffer length.");
+		let r = e.type === "float" ? 4 : 2;
+		this.asReglBuffer(e).buffer.subdata(t, n * r);
+	}
+	createProgram(e, t) {
+		return {
+			id: this.nextProgramId++,
+			vert: e,
+			frag: t
+		};
+	}
+	draw(e) {
+		if (e.count <= 0) return;
+		let t = this.asReglProgram(e.program), n = Object.keys(e.attributes).sort(), r = Object.keys(e.uniforms).sort(), i = [
+			t.id,
+			e.primitive,
+			n.join(","),
+			r.join(","),
+			e.instances === void 0 ? 0 : 1
+		].join("|"), a = this.commandCache.get(i);
+		a || (a = this.createDrawCommand(t, e.primitive, n, r, e.instances !== void 0), this.commandCache.set(i, a));
+		let o = {};
+		for (let t of n) o[t] = this.resolveAttribute(e.attributes[t]);
+		let s = {
+			count: e.count,
+			instances: e.instances ?? 0,
+			attributes: o,
+			uniforms: e.uniforms
+		};
+		this.scissorBox && (s.scissorEnable = !0, s.scissorBox = {
+			x: this.scissorBox.x,
+			y: this.scissorBox.y,
+			width: this.scissorBox.w,
+			height: this.scissorBox.h
+		}), a(s);
+	}
+	dispose(e) {
+		this.isReglBuffer(e) && this.resources.release(e.buffer);
+	}
+	clear(e, t, n, r) {
+		this.regl.clear({ color: [
+			e,
+			t,
+			n,
+			r
+		] });
+	}
+	viewport(e, t, n, r) {
+		this.regl.poll(), this.scissorBox = {
+			x: e,
+			y: t,
+			w: n,
+			h: r
+		};
+	}
+	getContext() {
+		return this.gl;
+	}
+	destroy() {
+		this.resources.destroy(), this.regl.destroy();
+	}
+	createDrawCommand(e, t, n, r, i) {
+		let a = {};
+		for (let e of n) a[e] = (t, n) => n.attributes[e];
+		let o = {};
+		for (let e of r) o[e] = (t, n) => n.uniforms[e];
+		return this.regl({
+			vert: e.vert,
+			frag: e.frag,
+			attributes: a,
+			uniforms: o,
+			primitive: this.toReglPrimitive(t),
+			count: (e, t) => t.count,
+			instances: i ? (e, t) => t.instances : void 0,
+			depth: { enable: !1 },
+			scissor: {
+				enable: (e, t) => t.scissorEnable ?? !1,
+				box: (e, t) => t.scissorBox ?? {
+					x: 0,
+					y: 0,
+					width: 0,
+					height: 0
+				}
+			}
+		});
+	}
+	resolveAttribute(e) {
+		return "divisor" in e ? {
+			buffer: this.asReglBuffer(e.buffer).buffer,
+			divisor: e.divisor,
+			stride: e.stride,
+			offset: e.offset,
+			size: e.size
+		} : this.asReglBuffer(e).buffer;
+	}
+	asReglBuffer(e) {
+		return e;
+	}
+	asReglProgram(e) {
+		return e;
+	}
+	isReglBuffer(e) {
+		return "length" in e && "type" in e && "buffer" in e;
+	}
+	toReglPrimitive(e) {
+		switch (e) {
+			case "line_strip": return "line strip";
+			case "triangle_strip": return "triangle strip";
+			default: return e;
+		}
+	}
+}, O = class e {
+	_xMin = 0;
+	_xMax = 1;
+	_yMin = 0;
+	_yMax = 1;
+	get xMin() {
+		return this._xMin;
+	}
+	get xMax() {
+		return this._xMax;
+	}
+	get yMin() {
+		return this._yMin;
+	}
+	get yMax() {
+		return this._yMax;
+	}
+	get viewport() {
+		return {
+			xMin: this._xMin,
+			xMax: this._xMax,
+			yMin: this._yMin,
+			yMax: this._yMax
+		};
+	}
+	get xScale() {
+		return 2 / (this._xMax - this._xMin);
+	}
+	get xOffset() {
+		return -(this._xMin + this._xMax) / (this._xMax - this._xMin);
+	}
+	get yScale() {
+		return 2 / (this._yMax - this._yMin);
+	}
+	get yOffset() {
+		return -(this._yMin + this._yMax) / (this._yMax - this._yMin);
+	}
+	setViewport(t) {
+		let n = {
+			xMin: t.xMin ?? this._xMin,
+			xMax: t.xMax ?? this._xMax,
+			yMin: t.yMin ?? this._yMin,
+			yMax: t.yMax ?? this._yMax
+		};
+		e.assertValidViewport(n), this._xMin = n.xMin, this._xMax = n.xMax, this._yMin = n.yMin, this._yMax = n.yMax;
+	}
+	pan(t) {
+		let { dx: n, dy: r } = t;
+		e.assertFinite("dx", n), e.assertFinite("dy", r);
+		let i = this._xMax - this._xMin, a = this._yMax - this._yMin;
+		this.setViewport({
+			xMin: this._xMin + n * i,
+			xMax: this._xMax + n * i,
+			yMin: this._yMin + r * a,
+			yMax: this._yMax + r * a
+		});
+	}
+	zoom(t) {
+		let { factor: n, cx: r, cy: i, axis: a } = t;
+		if (e.assertFinite("factor", n), e.assertFinite("cx", r), e.assertFinite("cy", i), n <= 0) throw RangeError("Camera2D zoom factor must be > 0.");
+		let o = this._xMax - this._xMin, s = this._yMax - this._yMin, c = this._xMin + o * r, l = this._yMin + s * i, u = a === "y" ? o : o / n, d = a === "x" ? s : s / n;
+		this.setViewport({
+			xMin: c - u * r,
+			xMax: c + u * (1 - r),
+			yMin: l - d * i,
+			yMax: l + d * (1 - i)
+		});
+	}
+	toClip(e, t) {
+		return [e * this.xScale + this.xOffset, t * this.yScale + this.yOffset];
+	}
+	toScreen(e, t, n, r) {
+		return [(e + 1) * .5 * n, (1 - t) * .5 * r];
+	}
+	clone() {
+		let t = new e();
+		return t.setViewport(this.viewport), t;
+	}
+	static assertValidViewport(t) {
+		if (e.assertFinite("xMin", t.xMin), e.assertFinite("xMax", t.xMax), e.assertFinite("yMin", t.yMin), e.assertFinite("yMax", t.yMax), t.xMax <= t.xMin) throw RangeError("Camera2D requires xMax > xMin.");
+		if (t.yMax <= t.yMin) throw RangeError("Camera2D requires yMax > yMin.");
+	}
+	static assertFinite(e, t) {
+		if (!Number.isFinite(t)) throw RangeError(`Camera2D ${e} must be finite.`);
+	}
+}, k = 1e3, A = 60 * k, j = 60 * A, M = 24 * j, N = 30 * M, P = 365 * M, pe = [
+	{
+		unit: "millisecond",
+		count: 1,
+		approxMs: 1
+	},
+	{
+		unit: "millisecond",
+		count: 5,
+		approxMs: 5
+	},
+	{
+		unit: "millisecond",
+		count: 10,
+		approxMs: 10
+	},
+	{
+		unit: "millisecond",
+		count: 50,
+		approxMs: 50
+	},
+	{
+		unit: "millisecond",
+		count: 100,
+		approxMs: 100
+	},
+	{
+		unit: "millisecond",
+		count: 250,
+		approxMs: 250
+	},
+	{
+		unit: "millisecond",
+		count: 500,
+		approxMs: 500
+	},
+	{
+		unit: "second",
+		count: 1,
+		approxMs: k
+	},
+	{
+		unit: "second",
+		count: 5,
+		approxMs: 5 * k
+	},
+	{
+		unit: "second",
+		count: 15,
+		approxMs: 15 * k
+	},
+	{
+		unit: "second",
+		count: 30,
+		approxMs: 30 * k
+	},
+	{
+		unit: "minute",
+		count: 1,
+		approxMs: A
+	},
+	{
+		unit: "minute",
+		count: 5,
+		approxMs: 5 * A
+	},
+	{
+		unit: "minute",
+		count: 15,
+		approxMs: 15 * A
+	},
+	{
+		unit: "minute",
+		count: 30,
+		approxMs: 30 * A
+	},
+	{
+		unit: "hour",
+		count: 1,
+		approxMs: j
+	},
+	{
+		unit: "hour",
+		count: 3,
+		approxMs: 3 * j
+	},
+	{
+		unit: "hour",
+		count: 6,
+		approxMs: 6 * j
+	},
+	{
+		unit: "hour",
+		count: 12,
+		approxMs: 12 * j
+	},
+	{
+		unit: "day",
+		count: 1,
+		approxMs: M
+	},
+	{
+		unit: "day",
+		count: 2,
+		approxMs: 2 * M
+	},
+	{
+		unit: "day",
+		count: 7,
+		approxMs: 7 * M
+	},
+	{
+		unit: "month",
+		count: 1,
+		approxMs: N
+	},
+	{
+		unit: "month",
+		count: 3,
+		approxMs: 3 * N
+	},
+	{
+		unit: "month",
+		count: 6,
+		approxMs: 6 * N
+	},
+	{
+		unit: "year",
+		count: 1,
+		approxMs: P
+	},
+	{
+		unit: "year",
+		count: 2,
+		approxMs: 2 * P
+	},
+	{
+		unit: "year",
+		count: 5,
+		approxMs: 5 * P
+	},
+	{
+		unit: "year",
+		count: 10,
+		approxMs: 10 * P
+	}
+], me = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+], he = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+], ge = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+], _e = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+], F = class {
+	camera;
+	options;
+	lastXTimeInterval = null;
+	lastYTimeInterval = null;
+	constructor(e, t = {}) {
+		this.camera = e, this.options = t;
+	}
+	setOptions(e) {
+		this.options = e, this.lastXTimeInterval = null, this.lastYTimeInterval = null;
+	}
+	getXTickValues(e, t = 10, n = []) {
+		let r = this.options.x;
+		if (r?.scale === "time") {
+			let i = this.getTimeTickValues(this.camera.xMin, this.camera.xMax, e, t, 80, n, r);
+			return this.lastXTimeInterval = this.lastTimeInterval, i;
+		}
+		return this.lastXTimeInterval = null, this.getScaledTickValues(this.camera.xMin, this.camera.xMax, e, t, 80, n, r, "x");
+	}
+	getYTickValues(e, t = 10, n = []) {
+		let r = this.options.y;
+		if (r?.scale === "time") {
+			let i = this.getTimeTickValues(this.camera.yMin, this.camera.yMax, e, t, 48, n, r);
+			return this.lastYTimeInterval = this.lastTimeInterval, i;
+		}
+		return this.lastYTimeInterval = null, this.getScaledTickValues(this.camera.yMin, this.camera.yMax, e, t, 48, n, r, "y");
+	}
+	formatValue(e, t = "y") {
+		let n = t === "x" ? this.options.x : this.options.y, r = n?.tickFormat;
+		if (typeof r == "function") return r(e, t);
+		if (n?.scale && typeof n.scale == "object") return n.scale.formatTick?.(e, t) ?? this.formatLinearValue(e);
+		if (n?.scale === "categorical") {
+			let t = Math.round(e);
+			return n.categories?.[t] ?? String(t);
+		}
+		if (n?.scale === "time") {
+			let i = t === "x" ? this.lastXTimeInterval : this.lastYTimeInterval;
+			return this.formatTimeValue(e, r, n.timezone ?? "local", i);
+		}
+		return this.formatLinearValue(e);
+	}
+	lastTimeInterval = null;
+	getScaledTickValues(e, t, n, r, i, a, o, s) {
+		let c = o?.scale;
+		if (c && typeof c == "object") {
+			a.length = 0;
+			let n = c.ticks?.(e, t, r) ?? [];
+			for (let e of n) a.push(e);
+			return a;
+		}
+		return c === "log" ? this.getLogTickValues(e, t, n, r, i, a, o?.logBase) : c === "categorical" ? this.getCategoricalTickValues(e, t, r, a, o?.categories) : c === "symlog" ? this.getSymlogTickValues(e, t, n, r, i, a, o?.symlogConstant) : this.getLinearTickValues(e, t, n, r, i, a);
+	}
+	getLogTickValues(e, t, n, r, i, a, o = 10) {
+		a.length = 0;
+		let s = Number.isFinite(o) && o > 1 ? o : 10;
+		if (n <= 0 || r <= 0 || e <= 0 || t <= e) return a;
+		let c = Math.max(2, Math.min(r, Math.floor(n / i))), l = Math.floor(Math.log(e) / Math.log(s)), u = Math.ceil(Math.log(t) / Math.log(s)), d = Math.max(1, Math.ceil((u - l) / Math.max(1, c - 1)));
+		for (let n = l; n <= u && a.length < r + 2; n += d) {
+			let r = s ** n;
+			r >= e / s && r <= t * s && a.push(r);
+		}
+		return a;
+	}
+	getSymlogTickValues(e, t, n, r, i, a, o = 1) {
+		let s = Number.isFinite(o) && o > 0 ? o : 1, c = (e) => Math.sign(e) * Math.log1p(Math.abs(e) / s), l = (e) => Math.sign(e) * s * Math.expm1(Math.abs(e)), u = this.getLinearTickValues(c(e), c(t), n, r, i, a);
+		for (let e = 0; e < u.length; e++) u[e] = this.normalizeTick(l(u[e]), Math.abs(l(u[1] ?? u[0] ?? 1) - l(u[0] ?? 0)) || 1);
+		return u;
+	}
+	getCategoricalTickValues(e, t, n, r, i) {
+		r.length = 0;
+		let a = Math.max(0, Math.ceil(e)), o = Math.min(i ? i.length - 1 : Math.floor(t), Math.floor(t));
+		if (o < a || n <= 0) return r;
+		let s = Math.max(1, Math.ceil((o - a + 1) / n));
+		for (let e = a; e <= o && r.length < n; e += s) r.push(e);
+		return r;
+	}
+	formatLinearValue(e) {
+		if (Math.abs(e) < 1e-12) return "0";
+		let t = Math.abs(e);
+		return t >= 1e6 || t < .001 ? e.toExponential(2) : t >= 100 ? e.toFixed(0) : t >= 10 ? e.toFixed(1) : e.toFixed(2);
+	}
+	getLinearTickValues(e, t, n, r, i, a) {
+		if (a.length = 0, n <= 0 || r <= 0) return a;
+		let o = t - e;
+		if (!Number.isFinite(o) || o <= 0) return a;
+		let s = Math.max(2, Math.min(r, Math.floor(n / i))), c = this.niceStep(o / (s - 1)), l = Math.floor(e / c), u = Math.ceil(t / c);
+		for (let e = l; e <= u && a.length < r + 2; e++) a.push(this.normalizeTick(e * c, c));
+		return a;
+	}
+	getTimeTickValues(e, t, n, r, i, a, o) {
+		if (a.length = 0, this.lastTimeInterval = null, n <= 0 || r <= 0) return a;
+		let s = t - e;
+		if (!Number.isFinite(s) || s <= 0) return a;
+		let c = Math.max(2, Math.min(r, Math.floor(n / i))), l = this.chooseTimeInterval(s / (c - 1)), u = o.timezone ?? "local";
+		this.lastTimeInterval = l;
+		let d = this.floorTime(e, l, u), f = 0;
+		for (; d < e && f < 4;) {
+			let e = this.advanceTime(d, l, u);
+			if (e <= d) break;
+			d = e, f++;
+		}
+		let p = this.floorTime(e, l, u);
+		p < d && a.length === 0 && (d = p);
+		for (let e = 0; e < r + 2 && d <= t; e++) {
+			a.push(d);
+			let e = this.advanceTime(d, l, u);
+			if (e <= d) break;
+			d = e;
+		}
+		return a.length === 0 && a.push(e, t), a;
+	}
+	chooseTimeInterval(e) {
+		for (let t of pe) if (t.approxMs >= e) return t;
+		let t = Math.max(10, Math.ceil(e / P)), n = 10 ** Math.floor(Math.log10(t)), r = t / n, i = r <= 1 ? n : r <= 2 ? 2 * n : r <= 5 ? 5 * n : 10 * n;
+		return {
+			unit: "year",
+			count: i,
+			approxMs: i * P
+		};
+	}
+	floorTime(e, t, n) {
+		if (!Number.isFinite(e)) return e;
+		if (t.unit === "millisecond") return Math.floor(e / t.count) * t.count;
+		let r = new Date(e), i = n === "utc", a = i ? r.getUTCFullYear() : r.getFullYear(), o = i ? r.getUTCMonth() : r.getMonth(), s = i ? r.getUTCDate() : r.getDate(), c = i ? r.getUTCHours() : r.getHours(), l = i ? r.getUTCMinutes() : r.getMinutes(), u = i ? r.getUTCSeconds() : r.getSeconds();
+		switch (t.unit) {
+			case "second": return this.makeTime(n, a, o, s, c, l, Math.floor(u / t.count) * t.count, 0);
+			case "minute": return this.makeTime(n, a, o, s, c, Math.floor(l / t.count) * t.count, 0, 0);
+			case "hour": return this.makeTime(n, a, o, s, Math.floor(c / t.count) * t.count, 0, 0, 0);
+			case "day": return this.makeTime(n, a, o, Math.floor((s - 1) / t.count) * t.count + 1, 0, 0, 0, 0);
+			case "month": return this.makeTime(n, a, Math.floor(o / t.count) * t.count, 1, 0, 0, 0, 0);
+			case "year": return this.makeTime(n, Math.floor(a / t.count) * t.count, 0, 1, 0, 0, 0, 0);
+		}
+	}
+	advanceTime(e, t, n) {
+		let r = new Date(e), i = n === "utc";
+		switch (t.unit) {
+			case "millisecond": return e + t.count;
+			case "second": return i ? r.setUTCSeconds(r.getUTCSeconds() + t.count) : r.setSeconds(r.getSeconds() + t.count), r.getTime();
+			case "minute": return i ? r.setUTCMinutes(r.getUTCMinutes() + t.count) : r.setMinutes(r.getMinutes() + t.count), r.getTime();
+			case "hour": return i ? r.setUTCHours(r.getUTCHours() + t.count) : r.setHours(r.getHours() + t.count), r.getTime();
+			case "day": return i ? r.setUTCDate(r.getUTCDate() + t.count) : r.setDate(r.getDate() + t.count), r.getTime();
+			case "month": return i ? r.setUTCMonth(r.getUTCMonth() + t.count) : r.setMonth(r.getMonth() + t.count), r.getTime();
+			case "year": return i ? r.setUTCFullYear(r.getUTCFullYear() + t.count) : r.setFullYear(r.getFullYear() + t.count), r.getTime();
+		}
+	}
+	makeTime(e, t, n, r, i, a, o, s) {
+		return e === "utc" ? Date.UTC(t, n, r, i, a, o, s) : new Date(t, n, r, i, a, o, s).getTime();
+	}
+	formatTimeValue(e, t, n, r) {
+		let i = new Date(e);
+		if (t) return this.formatTimePattern(i, t, n);
+		let a = r?.approxMs ?? 0;
+		return a > 0 && a < k ? this.formatTimePattern(i, "%H:%M:%S.%L", n) : a > 0 && a < M ? this.formatTimePattern(i, "%H:%M:%S", n) : a > 0 && a < P ? this.formatTimePattern(i, "%b %d", n) : this.formatTimePattern(i, "%Y", n);
+	}
+	formatTimePattern(e, t, n) {
+		let r = n === "utc", i = r ? e.getUTCFullYear() : e.getFullYear(), a = r ? e.getUTCMonth() : e.getMonth(), o = r ? e.getUTCDate() : e.getDate(), s = r ? e.getUTCDay() : e.getDay(), c = r ? e.getUTCHours() : e.getHours(), l = r ? e.getUTCMinutes() : e.getMinutes(), u = r ? e.getUTCSeconds() : e.getSeconds(), d = r ? e.getUTCMilliseconds() : e.getMilliseconds();
+		return t.replace(/%[YymdbBaAHMSL%]/g, (e) => {
+			switch (e) {
+				case "%Y": return String(i).padStart(4, "0");
+				case "%y": return String(i % 100).padStart(2, "0");
+				case "%m": return String(a + 1).padStart(2, "0");
+				case "%d": return String(o).padStart(2, "0");
+				case "%b": return me[a] ?? "";
+				case "%B": return he[a] ?? "";
+				case "%a": return ge[s] ?? "";
+				case "%A": return _e[s] ?? "";
+				case "%H": return String(c).padStart(2, "0");
+				case "%M": return String(l).padStart(2, "0");
+				case "%S": return String(u).padStart(2, "0");
+				case "%L": return String(d).padStart(3, "0");
+				case "%%": return "%";
+				default: return e;
+			}
+		});
+	}
+	niceStep(e) {
+		let t = 10 ** Math.floor(Math.log10(e)), n = e / t;
+		return n <= 1.5 ? t : n <= 3 ? 2 * t : n <= 7 ? 5 * t : 10 * t;
+	}
+	normalizeTick(e, t) {
+		let n = Math.max(0, -Math.floor(Math.log10(t)) + 2), r = Number(e.toFixed(n));
+		return Object.is(r, -0) ? 0 : r;
+	}
+}, I = class {
+	layout;
+	config;
+	options;
+	xPool = [];
+	yPool = [];
+	y2Pool = [];
+	xTicks = [];
+	yTicks = [];
+	y2Ticks = [];
+	constructor(e, t, n = {}) {
+		this.layout = e, this.config = t, this.options = n;
+	}
+	setOptions(e) {
+		this.options = e;
+		for (let e of [
+			...this.xPool,
+			...this.yPool,
+			...this.y2Pool
+		]) e.style.font = this.options.font ?? "11px ui-monospace, monospace, sans-serif", e.style.color = this.options.color ?? "#bfd6ff";
+	}
+	update(e, t, n = e, r = t) {
+		let i = Math.max(1, this.layout.plot.clientWidth), a = Math.max(1, this.layout.plot.clientHeight);
+		this.config.x.visible ? t.getXTickValues(i, 12, this.xTicks) : this.xTicks.length = 0, this.config.y.visible ? t.getYTickValues(a, 8, this.yTicks) : this.yTicks.length = 0, this.config.y2.visible ? r.getYTickValues(a, 8, this.y2Ticks) : this.y2Ticks.length = 0, this.updateAxis(this.xPool, this.xTicks, "x", e, i, a, t), this.updateAxis(this.yPool, this.yTicks, "y", e, i, a, t), this.updateAxis(this.y2Pool, this.y2Ticks, "y2", n, i, a, r);
+	}
+	dispose() {
+		for (let e of this.xPool) e.remove();
+		for (let e of this.yPool) e.remove();
+		for (let e of this.y2Pool) e.remove();
+		this.xPool = [], this.yPool = [], this.y2Pool = [];
+	}
+	parentForAxis(e) {
+		return e === "x" ? this.config.x.position === "outside" ? this.layout.xAxis : this.layout.plot : e === "y2" ? this.config.y2.position === "outside" ? this.layout.y2Axis : this.layout.plot : this.config.y.position === "outside" ? this.layout.yAxis : this.layout.plot;
+	}
+	updateAxis(e, t, n, r, i, a, o) {
+		let s = this.parentForAxis(n);
+		for (; e.length < t.length;) {
+			let t = document.createElement("div");
+			t.style.position = "absolute", t.style.pointerEvents = "none", t.style.whiteSpace = "nowrap", t.style.font = this.options.font ?? "11px ui-monospace, monospace, sans-serif", t.style.color = this.options.color ?? "#bfd6ff", t.style.userSelect = "none", s.appendChild(t), e.push(t);
+		}
+		for (let t of e) t.parentElement !== s && s.appendChild(t);
+		for (let n = t.length; n < e.length; n++) e[n].style.display = "none";
+		for (let s = 0; s < t.length; s++) {
+			let c = e[s], l = t[s], u = o.formatValue(l, n === "x" ? "x" : "y");
+			if (c.textContent !== u && (c.textContent = u), c.style.display = "block", n === "x") {
+				let [e] = r.toClip(l, r.yMin), t = (e + 1) * .5 * i;
+				c.style.left = `${t}px`, c.style.right = "auto", c.style.transform = "translateX(-50%)", this.config.x.position === "outside" ? (c.style.top = "4px", c.style.bottom = "auto") : (c.style.top = "auto", c.style.bottom = "4px");
+			} else {
+				let e = n === "y2", t = e ? this.config.y2 : this.config.y, [, i] = r.toClip(r.xMin, l), o = (1 - i) * .5 * a;
+				c.style.top = `${o}px`, c.style.bottom = "auto", c.style.transform = "translateY(-50%)", t.position === "outside" ? (c.style.left = e ? "4px" : "auto", c.style.right = e ? "auto" : "4px") : (c.style.left = e ? "auto" : "4px", c.style.right = e ? "4px" : "auto");
+			}
+		}
+	}
+}, ve = class {
+	root;
+	plot;
+	canvas;
+	xAxis;
+	yAxis;
+	y2Axis;
+	corner;
+	cornerRight;
+	title;
+	subtitle;
+	xAxisTitle;
+	yAxisTitle;
+	y2AxisTitle;
+	externalCanvas;
+	originalCanvasCssText;
+	originalCanvasParent;
+	constructor(e, t) {
+		let n = e instanceof HTMLCanvasElement ? e : null;
+		this.externalCanvas = n !== null, this.originalCanvasCssText = n?.style.cssText ?? "", this.originalCanvasParent = n?.parentElement ?? null, this.root = document.createElement("div"), this.plot = document.createElement("div"), this.canvas = n ?? document.createElement("canvas"), this.xAxis = document.createElement("div"), this.yAxis = document.createElement("div"), this.y2Axis = document.createElement("div"), this.corner = document.createElement("div"), this.cornerRight = document.createElement("div"), this.title = document.createElement("div"), this.subtitle = document.createElement("div"), this.xAxisTitle = document.createElement("div"), this.yAxisTitle = document.createElement("div"), this.y2AxisTitle = document.createElement("div"), this.root.className = "blazeplot-root", this.plot.className = "blazeplot-plot", this.canvas.classList.add("blazeplot-canvas"), this.xAxis.className = "blazeplot-axis blazeplot-axis-x", this.yAxis.className = "blazeplot-axis blazeplot-axis-y", this.y2Axis.className = "blazeplot-axis blazeplot-axis-y2", this.corner.className = "blazeplot-axis-corner", this.cornerRight.className = "blazeplot-axis-corner blazeplot-axis-corner-right", this.title.className = "blazeplot-title", this.subtitle.className = "blazeplot-subtitle", this.xAxisTitle.className = "blazeplot-axis-title blazeplot-axis-title-x", this.yAxisTitle.className = "blazeplot-axis-title blazeplot-axis-title-y", this.y2AxisTitle.className = "blazeplot-axis-title blazeplot-axis-title-y2", this.applyBaseStyles(), this.mount(e), this.update(t);
+	}
+	update(e) {
+		let t = e.y.visible && e.y.position === "outside", n = e.y2.visible && e.y2.position === "outside", r = e.x.visible && e.x.position === "outside";
+		this.root.style.gridTemplateColumns = `${t ? 52 : 0}px minmax(0, 1fr) ${n ? 52 : 0}px`, this.root.style.gridTemplateRows = `minmax(0, 1fr) ${r ? 28 : 0}px`, this.yAxis.style.display = t ? "block" : "none", this.y2Axis.style.display = n ? "block" : "none", this.xAxis.style.display = r ? "block" : "none", this.corner.style.display = r && t ? "block" : "none", this.cornerRight.style.display = r && n ? "block" : "none";
+	}
+	dispose() {
+		this.externalCanvas && this.originalCanvasParent && (this.canvas.style.cssText = this.originalCanvasCssText, this.originalCanvasParent.insertBefore(this.canvas, this.root)), this.root.remove();
+	}
+	mount(e) {
+		this.externalCanvas ? this.originalCanvasParent?.insertBefore(this.root, e) : e.appendChild(this.root), this.root.appendChild(this.yAxis), this.root.appendChild(this.plot), this.root.appendChild(this.y2Axis), this.root.appendChild(this.corner), this.root.appendChild(this.xAxis), this.root.appendChild(this.cornerRight), this.root.appendChild(this.title), this.root.appendChild(this.subtitle), this.root.appendChild(this.xAxisTitle), this.root.appendChild(this.yAxisTitle), this.root.appendChild(this.y2AxisTitle), this.plot.appendChild(this.canvas);
+	}
+	applyBaseStyles() {
+		this.root.style.position = "relative", this.root.style.display = "grid", this.root.style.width = "100%", this.root.style.height = "100%", this.root.style.minWidth = "0", this.root.style.minHeight = "0", this.root.style.overflow = "hidden", this.root.style.boxSizing = "border-box", this.plot.style.position = "relative", this.plot.style.gridColumn = "2", this.plot.style.gridRow = "1", this.plot.style.minWidth = "0", this.plot.style.minHeight = "0", this.plot.style.overflow = "hidden", this.canvas.style.position = "absolute", this.canvas.style.inset = "0", this.canvas.style.display = "block", this.canvas.style.width = "100%", this.canvas.style.height = "100%", this.canvas.style.touchAction = "none", this.yAxis.style.position = "relative", this.yAxis.style.gridColumn = "1", this.yAxis.style.gridRow = "1", this.yAxis.style.minWidth = "0", this.yAxis.style.minHeight = "0", this.yAxis.style.overflow = "hidden", this.yAxis.style.pointerEvents = "none", this.y2Axis.style.position = "relative", this.y2Axis.style.gridColumn = "3", this.y2Axis.style.gridRow = "1", this.y2Axis.style.minWidth = "0", this.y2Axis.style.minHeight = "0", this.y2Axis.style.overflow = "hidden", this.y2Axis.style.pointerEvents = "none", this.xAxis.style.position = "relative", this.xAxis.style.gridColumn = "2", this.xAxis.style.gridRow = "2", this.xAxis.style.minWidth = "0", this.xAxis.style.minHeight = "0", this.xAxis.style.overflow = "hidden", this.xAxis.style.pointerEvents = "none", this.corner.style.gridColumn = "1", this.corner.style.gridRow = "2", this.corner.style.minWidth = "0", this.corner.style.minHeight = "0", this.corner.style.pointerEvents = "none", this.cornerRight.style.gridColumn = "3", this.cornerRight.style.gridRow = "2", this.cornerRight.style.minWidth = "0", this.cornerRight.style.minHeight = "0", this.cornerRight.style.pointerEvents = "none";
+		for (let e of [
+			this.title,
+			this.subtitle,
+			this.xAxisTitle,
+			this.yAxisTitle,
+			this.y2AxisTitle
+		]) e.style.position = "absolute", e.style.pointerEvents = "none", e.style.userSelect = "none", e.style.whiteSpace = "nowrap", e.style.zIndex = "18", e.style.display = "none";
+		this.title.style.top = "6px", this.title.style.left = "50%", this.title.style.transform = "translateX(-50%)", this.title.style.textAlign = "center", this.subtitle.style.top = "26px", this.subtitle.style.left = "50%", this.subtitle.style.transform = "translateX(-50%)", this.subtitle.style.textAlign = "center", this.xAxisTitle.style.left = "50%", this.xAxisTitle.style.bottom = "4px", this.xAxisTitle.style.transform = "translateX(-50%)", this.xAxisTitle.style.textAlign = "center", this.yAxisTitle.style.left = "4px", this.yAxisTitle.style.top = "50%", this.yAxisTitle.style.transform = "translateY(-50%) rotate(-90deg)", this.yAxisTitle.style.transformOrigin = "left center", this.y2AxisTitle.style.right = "4px", this.y2AxisTitle.style.top = "50%", this.y2AxisTitle.style.transform = "translateY(-50%) rotate(90deg)", this.y2AxisTitle.style.transformOrigin = "right center";
+	}
+}, L = {
+	backgroundColor: [
+		.02,
+		.02,
+		.02,
+		1
+	],
+	backgroundCssColor: "rgba(5, 5, 5, 1)",
+	gridColor: [
+		.22,
+		.22,
+		.22,
+		.45
+	],
+	axisColor: "#d4d4d4",
+	axisFont: "11px ui-monospace, monospace, sans-serif",
+	seriesColors: [
+		[
+			.3,
+			.6,
+			1,
+			1
+		],
+		[
+			.95,
+			.35,
+			.35,
+			1
+		],
+		[
+			.2,
+			.8,
+			.4,
+			.9
+		],
+		[
+			.95,
+			.72,
+			.25,
+			1
+		],
+		[
+			.72,
+			.45,
+			.95,
+			1
+		],
+		[
+			.25,
+			.85,
+			.95,
+			1
+		]
+	],
+	tooltipBackgroundColor: "rgba(10, 10, 10, 0.88)",
+	tooltipTextColor: "#e5e5e5",
+	tooltipFont: "11px/1.35 ui-monospace, monospace",
+	legendBackgroundColor: "rgba(10, 10, 10, 0.88)",
+	legendBorderColor: "transparent",
+	legendTextColor: "#e5e5e5",
+	legendMutedTextColor: "#888",
+	legendFont: "11px/1.35 ui-monospace, monospace",
+	titleColor: "#f8fafc",
+	titleFont: "600 14px system-ui, sans-serif",
+	subtitleColor: "#cbd5e1",
+	subtitleFont: "12px system-ui, sans-serif",
+	axisTitleColor: "#d4d4d4",
+	axisTitleFont: "12px system-ui, sans-serif"
+};
+function R(e, t) {
+	if (!e) return L;
+	let n = z(e.backgroundColor, L.backgroundColor, t), r = e.seriesColors?.length ? e.seriesColors.map((e, n) => z(e, L.seriesColors[n % L.seriesColors.length], t)) : L.seriesColors;
+	return {
+		backgroundColor: n,
+		backgroundCssColor: ye(e.backgroundColor, L.backgroundCssColor),
+		gridColor: z(e.gridColor, L.gridColor, t),
+		axisColor: e.axisColor ?? L.axisColor,
+		axisFont: e.axisFont ?? L.axisFont,
+		seriesColors: r,
+		tooltipBackgroundColor: e.tooltipBackgroundColor ?? L.tooltipBackgroundColor,
+		tooltipTextColor: e.tooltipTextColor ?? L.tooltipTextColor,
+		tooltipFont: e.tooltipFont ?? L.tooltipFont,
+		legendBackgroundColor: e.legendBackgroundColor ?? L.legendBackgroundColor,
+		legendBorderColor: e.legendBorderColor ?? L.legendBorderColor,
+		legendTextColor: e.legendTextColor ?? L.legendTextColor,
+		legendMutedTextColor: e.legendMutedTextColor ?? L.legendMutedTextColor,
+		legendFont: e.legendFont ?? L.legendFont,
+		titleColor: e.titleColor ?? L.titleColor,
+		titleFont: e.titleFont ?? L.titleFont,
+		subtitleColor: e.subtitleColor ?? L.subtitleColor,
+		subtitleFont: e.subtitleFont ?? L.subtitleFont,
+		axisTitleColor: e.axisTitleColor ?? L.axisTitleColor,
+		axisTitleFont: e.axisTitleFont ?? L.axisTitleFont
+	};
+}
+function z(e, t, n) {
+	if (!e) return t;
+	if (typeof e != "string") return e;
+	let r = be(e, n), i = xe(r ?? e, n);
+	return V(r ?? e) ?? V(i ?? "") ?? t;
+}
+function ye(e, t) {
+	return e ? typeof e == "string" ? e : B(e) : t;
+}
+function B(e) {
+	return `rgba(${Math.round(e[0] * 255)}, ${Math.round(e[1] * 255)}, ${Math.round(e[2] * 255)}, ${e[3]})`;
+}
+function be(e, t) {
+	let n = t?.ownerDocument ?? globalThis.document;
+	if (!n?.documentElement || typeof getComputedStyle > "u") return null;
+	let r = t instanceof HTMLElement ? t : n.documentElement, i = n.createElement("span");
+	i.style.position = "absolute", i.style.visibility = "hidden", i.style.pointerEvents = "none", i.style.color = e, r.appendChild(i);
+	let a = getComputedStyle(i).color;
+	return i.remove(), a || null;
+}
+function V(e) {
+	let t = e.trim();
+	return Se(t) ?? Ce(t) ?? we(t);
+}
+function xe(e, t) {
+	let n = t?.ownerDocument ?? globalThis.document;
+	if (!n?.createElement) return null;
+	let r = n.createElement("canvas").getContext("2d");
+	if (!r) return null;
+	let i = "#010203";
+	r.fillStyle = i, r.fillStyle = e;
+	let a = String(r.fillStyle);
+	return a === i ? null : a;
+}
+function Se(e) {
+	let t = e.match(/^rgba?\((.*)\)$/i);
+	if (!t) return null;
+	let n = t[1].trim().split("/").map((e) => e.trim()), r = n[0], i = n[1], a = r.includes(",") ? r.split(",").map((e) => e.trim()).filter(Boolean) : r.split(/\s+/).filter(Boolean);
+	if (a.length < 3) return null;
+	let o = H(a[0]), s = H(a[1]), c = H(a[2]), l = W(i ?? (a.length > 3 ? a[3] : void 0));
+	return o === null || s === null || c === null || l === null ? null : [
+		o,
+		s,
+		c,
+		l
+	];
+}
+function Ce(e) {
+	let t = e.match(/^color\(\s*srgb\s+(.+)\)$/i);
+	if (!t) return null;
+	let n = t[1].split("/").map((e) => e.trim()), r = n[0].split(/\s+/).filter(Boolean);
+	if (r.length < 3) return null;
+	let i = U(r[0]), a = U(r[1]), o = U(r[2]), s = W(n[1]);
+	return i === null || a === null || o === null || s === null ? null : [
+		i,
+		a,
+		o,
+		s
+	];
+}
+function we(e) {
+	let t = e.startsWith("#") ? e.slice(1) : "";
+	if (![
+		3,
+		4,
+		6,
+		8
+	].includes(t.length) || !/^[\da-f]+$/i.test(t)) return null;
+	let n = t.length <= 4 ? [...t].map((e) => e + e).join("") : t, r = Number.parseInt(n, 16);
+	return Number.isFinite(r) ? [
+		(r >> (n.length === 8 ? 24 : 16) & 255) / 255,
+		(r >> (n.length === 8 ? 16 : 8) & 255) / 255,
+		(r >> (n.length === 8 ? 8 : 0) & 255) / 255,
+		n.length === 8 ? (r & 255) / 255 : 1
+	] : null;
+}
+function H(e) {
+	return e.endsWith("%") ? G(Number.parseFloat(e) / 100) : G(Number.parseFloat(e) / 255);
+}
+function U(e) {
+	return e.endsWith("%") ? G(Number.parseFloat(e) / 100) : G(Number.parseFloat(e));
+}
+function W(e) {
+	return e ? e.endsWith("%") ? G(Number.parseFloat(e) / 100) : G(Number.parseFloat(e)) : 1;
+}
+function G(e) {
+	return Number.isFinite(e) ? Math.min(1, Math.max(0, e)) : null;
+}
+//#endregion
+//#region src/ui/Chart.ts
+var K = 16384, q = K >> 1, Te = K >> 1, J = 3, Ee = 4096, De = 12, Oe = 12, Y = 5, X = 64, ke = 4, Ae = K * 4;
+function Z(e) {
+	return e === !1 ? {
+		visible: !1,
+		position: "inside"
+	} : e === !0 || e === void 0 ? {
+		visible: !0,
+		position: "inside"
+	} : {
+		visible: e.visible !== !1,
+		position: e.position ?? "inside",
+		scale: e.scale,
+		tickFormat: e.tickFormat,
+		timezone: e.timezone,
+		title: e.title
+	};
+}
+function je(e) {
+	return e === !1 ? {
+		x: {
+			visible: !1,
+			position: "inside"
+		},
+		y: {
+			visible: !1,
+			position: "inside"
+		},
+		y2: {
+			visible: !1,
+			position: "inside"
+		}
+	} : e === !0 || e === void 0 ? {
+		x: {
+			visible: !0,
+			position: "inside"
+		},
+		y: {
+			visible: !0,
+			position: "inside"
+		},
+		y2: {
+			visible: !1,
+			position: "inside"
+		}
+	} : {
+		x: Z(e.x),
+		y: Z(e.y),
+		y2: Z(e.y2 ?? !1)
+	};
+}
+function Me(e) {
+	return typeof e == "string" ? e : e?.text ?? "";
+}
+function Ne(e) {
+	return typeof e == "string" ? e.length > 0 : !!e && e.visible !== !1 && e.text.length > 0;
+}
+function Q(e) {
+	return typeof e == "string" ? 0 : e?.offsetX ?? 0;
+}
+function $(e) {
+	return typeof e == "string" ? 0 : e?.offsetY ?? 0;
+}
+var Pe = class {
+	options;
+	series = [];
+	camera;
+	rightCamera;
+	axis;
+	rightAxis;
+	renderer;
+	rawLineBuffer;
+	rawLineData;
+	minMaxInstanceBuffer;
+	minMaxInstanceData;
+	barTriangleBuffer;
+	barTriangleData;
+	gridBuffer;
+	gridData;
+	gridStyle;
+	xTicks = [];
+	yTicks = [];
+	axisOverlay = null;
+	normalizedAxes;
+	resolvedTheme;
+	_gridVisible;
+	layout;
+	stats = {
+		fps: 0,
+		frameMs: 0,
+		pointsRendered: 0,
+		drawCalls: 0,
+		uploadBytes: 0,
+		renderMode: "none"
+	};
+	resizeObserver = null;
+	pluginDisposers = [];
+	hoverSubscribers = /* @__PURE__ */ new Set();
+	seriesSubscribers = /* @__PURE__ */ new Set();
+	themeSubscribers = /* @__PURE__ */ new Set();
+	renderSubscribers = /* @__PURE__ */ new Set();
+	layoutReservations = /* @__PURE__ */ new Map();
+	viewportSubscribers = /* @__PURE__ */ new Set();
+	selectSubscribers = /* @__PURE__ */ new Set();
+	seriesClickSubscribers = /* @__PURE__ */ new Set();
+	pointerSubscribers = {
+		click: /* @__PURE__ */ new Set(),
+		dblclick: /* @__PURE__ */ new Set(),
+		pointerdown: /* @__PURE__ */ new Set(),
+		pointerup: /* @__PURE__ */ new Set(),
+		pointermove: /* @__PURE__ */ new Set()
+	};
+	currentHover = null;
+	lastPointerClientX = 0;
+	lastPointerClientY = 0;
+	pointerInPlot = !1;
+	lastFrameAt = 0;
+	currentXOrigin = 0;
+	_rafId = 0;
+	_hoverRafId = 0;
+	handlePointerMove = (e) => {
+		this.pointerInPlot = !0, this.lastPointerClientX = e.clientX, this.lastPointerClientY = e.clientY, this.scheduleHoverRefresh(), this.pointerSubscribers.pointermove.size > 0 && this.emitPointerEvent("pointermove", e);
+	};
+	handlePointerDown = (e) => {
+		this.emitPointerEvent("pointerdown", e);
+	};
+	handlePointerUp = (e) => {
+		this.emitPointerEvent("pointerup", e);
+	};
+	handleClick = (e) => {
+		let t = this.emitPointerEvent("click", e), n = t?.items[0];
+		t && n && this.emitSeriesClick({
+			...t,
+			item: n
+		});
+	};
+	handleDoubleClick = (e) => {
+		this.emitPointerEvent("dblclick", e);
+	};
+	handlePointerLeave = () => {
+		this.pointerInPlot = !1, this.emitHover(null);
+	};
+	constructor(e, t = {}) {
+		this.options = t, this.resolvedTheme = R(t.theme, e), this.normalizedAxes = je(t.axes), this._gridVisible = t.grid !== !1, this.layout = new ve(e, this.normalizedAxes), this.layout.root.style.background = this.resolvedTheme.backgroundCssColor, this.applyCanvasSize(), this.camera = new O(), this.rightCamera = new O(), this.axis = new F(this.camera, {
+			x: this.normalizedAxes.x,
+			y: this.normalizedAxes.y
+		}), this.rightAxis = new F(this.rightCamera, {
+			x: this.normalizedAxes.x,
+			y: this.normalizedAxes.y2
+		}), this.renderer = new le(new fe(this.layout.canvas)), this.rawLineData = new Float32Array(K * 2), this.rawLineBuffer = this.renderer.createFloatBuffer(this.rawLineData.length), this.minMaxInstanceData = new Float32Array(Te * J), this.minMaxInstanceBuffer = this.renderer.createFloatBuffer(this.minMaxInstanceData.length), this.barTriangleData = new Float32Array(Ee * De), this.barTriangleBuffer = this.renderer.createFloatBuffer(this.barTriangleData.length), this.gridData = new Float32Array(X * 2), this.gridBuffer = this.renderer.createFloatBuffer(this.gridData.length), this.gridStyle = {
+			color: t.gridStyle?.color ?? this.resolvedTheme.gridColor,
+			lineWidth: t.gridStyle?.lineWidth ?? 1
+		}, (this.normalizedAxes.x.visible || this.normalizedAxes.y.visible || this.normalizedAxes.y2.visible) && (this.axisOverlay = new I(this.layout, this.normalizedAxes, {
+			color: this.resolvedTheme.axisColor,
+			font: this.resolvedTheme.axisFont
+		})), this.updateTextOverlays(), this.canvas.addEventListener("pointermove", this.handlePointerMove), this.canvas.addEventListener("pointerdown", this.handlePointerDown), this.canvas.addEventListener("pointerup", this.handlePointerUp), this.canvas.addEventListener("pointerleave", this.handlePointerLeave), this.canvas.addEventListener("click", this.handleClick), this.canvas.addEventListener("dblclick", this.handleDoubleClick), typeof ResizeObserver < "u" && (this.resizeObserver = new ResizeObserver(() => this.resize()), this.resizeObserver.observe(this.layout.plot));
+		for (let e of t.plugins ?? []) {
+			let t = e.install(this);
+			typeof t == "function" ? this.pluginDisposers.push(t) : t && this.pluginDisposers.push(() => t.dispose());
+		}
+	}
+	get canvas() {
+		return this.layout.canvas;
+	}
+	get rootElement() {
+		return this.layout.root;
+	}
+	get plotElement() {
+		return this.layout.plot;
+	}
+	get xAxisElement() {
+		return this.layout.xAxis;
+	}
+	get yAxisElement() {
+		return this.layout.yAxis;
+	}
+	get y2AxisElement() {
+		return this.layout.y2Axis;
+	}
+	get theme() {
+		return this.resolvedTheme;
+	}
+	getWebGLContext() {
+		return this.renderer.getWebGLContext();
+	}
+	getCamera(e = "left") {
+		return e === "right" ? this.rightCamera : this.camera;
+	}
+	dataToPlot(e, t, n = "left") {
+		let r = this.getCamera(n), [i, a] = r.toClip(e, t);
+		return r.toScreen(i, a, this.canvas.clientWidth, this.canvas.clientHeight);
+	}
+	clientToData(e, t, n = "left") {
+		let r = this.canvas.getBoundingClientRect();
+		if (r.width <= 0 || r.height <= 0) return null;
+		let i = e - r.left, a = t - r.top;
+		if (i < 0 || a < 0 || i > r.width || a > r.height) return null;
+		let o = this.getCamera(n).viewport;
+		return [o.xMin + i / r.width * (o.xMax - o.xMin), o.yMax - a / r.height * (o.yMax - o.yMin)];
+	}
+	getViewport(e = "left") {
+		return this.getCamera(e).viewport;
+	}
+	pan(e) {
+		this.camera.pan(e), this.syncRightCameraX(), this.emitViewportChange(), this.refreshHover();
+	}
+	zoom(e) {
+		this.camera.zoom(e), this.syncRightCameraX(), this.emitViewportChange(), this.refreshHover();
+	}
+	addSeries(e, t) {
+		if ((e.mode === "ohlc" || e.mode === "candlestick") && !e.dataset) throw TypeError("OHLC and candlestick series require an OhlcDataset.");
+		let n = e.dataset ?? this.createDefaultDataset(e), r = this.resolvedTheme.seriesColors, i = r[this.series.length % r.length] ?? this.resolvedTheme.seriesColors[0], a = t?.color ?? i, o = new m(n, e, {
+			color: a,
+			lineWidth: t?.lineWidth ?? 1,
+			pointSize: t?.pointSize ?? 4,
+			barWidth: t?.barWidth ?? .8,
+			baseline: t?.baseline ?? 0,
+			fillColor: t?.fillColor ?? [
+				a[0],
+				a[1],
+				a[2],
+				a[3] * .25
+			],
+			tickWidth: t?.tickWidth ?? t?.barWidth ?? .8,
+			upColor: t?.upColor ?? a,
+			downColor: t?.downColor ?? t?.fillColor ?? [
+				a[0],
+				a[1],
+				a[2],
+				a[3] * .45
+			],
+			wickColor: t?.wickColor ?? a
+		});
+		return this.series.push(o), this.emitSeriesChange(), o;
+	}
+	addLine(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "line"
+		}, t);
+	}
+	addArea(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "area"
+		}, t);
+	}
+	addScatter(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "scatter"
+		}, t);
+	}
+	addBar(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "bar"
+		}, t);
+	}
+	addOhlc(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "ohlc"
+		}, t);
+	}
+	addCandlestick(e, t) {
+		return this.addSeries({
+			...e,
+			mode: "candlestick"
+		}, t);
+	}
+	createDefaultDataset(e) {
+		let { capacity: t } = e;
+		if (typeof t != "number" || !Number.isInteger(t) || t <= 0) throw TypeError("Series capacity must be a positive integer when no dataset is provided.");
+		return new _(t, { overflow: e.overflow });
+	}
+	removeSeries(e) {
+		let t = this.series.indexOf(e);
+		return t === -1 ? !1 : (this.series.splice(t, 1), this.emitSeriesChange(), !0);
+	}
+	setSeriesVisible(e, t) {
+		return this.series.includes(e) ? e.visible === t ? !0 : (e.setVisible(t), this.emitSeriesChange(), !0) : !1;
+	}
+	getSeriesState() {
+		return this.series.map((e, t) => ({
+			series: e,
+			index: t,
+			id: e.config.id,
+			name: e.config.name,
+			mode: e.config.mode,
+			visible: e.visible,
+			color: e.style.color,
+			yAxis: e.config.yAxis ?? "left"
+		}));
+	}
+	setViewport(e) {
+		this.camera.setViewport(e), this.rightCamera.setViewport(e), this.emitViewportChange(), this.refreshHover();
+	}
+	setYViewport(e, t) {
+		this.getCamera(e).setViewport(t), this.emitViewportChange(), this.refreshHover();
+	}
+	resize(e = globalThis.devicePixelRatio) {
+		let t = this.applyCanvasSize(e);
+		return t && this.refreshHover(), t;
+	}
+	getFrameStats(e = {
+		fps: 0,
+		frameMs: 0,
+		pointsRendered: 0,
+		drawCalls: 0,
+		uploadBytes: 0,
+		renderMode: "none"
+	}) {
+		return e.fps = this.stats.fps, e.frameMs = this.stats.frameMs, e.pointsRendered = this.stats.pointsRendered, e.drawCalls = this.stats.drawCalls, e.uploadBytes = this.stats.uploadBytes, e.renderMode = this.stats.renderMode, e;
+	}
+	getHoverState() {
+		return this.currentHover;
+	}
+	setLayoutReservation(e, t) {
+		t ? this.layoutReservations.set(e, t) : this.layoutReservations.delete(e), this.applyLayoutReservations(), this.resize();
+	}
+	subscribe(e, t) {
+		if (e === "hover") {
+			let e = t;
+			return this.hoverSubscribers.add(e), () => this.hoverSubscribers.delete(e);
+		}
+		if (e === "themechange") {
+			let e = t;
+			return this.themeSubscribers.add(e), () => this.themeSubscribers.delete(e);
+		}
+		if (e === "render") {
+			let e = t;
+			return this.renderSubscribers.add(e), () => this.renderSubscribers.delete(e);
+		}
+		if (e === "viewportchange") {
+			let e = t;
+			return this.viewportSubscribers.add(e), () => this.viewportSubscribers.delete(e);
+		}
+		if (e === "select") {
+			let e = t;
+			return this.selectSubscribers.add(e), () => this.selectSubscribers.delete(e);
+		}
+		if (e === "seriesclick") {
+			let e = t;
+			return this.seriesClickSubscribers.add(e), () => this.seriesClickSubscribers.delete(e);
+		}
+		if (e in this.pointerSubscribers) {
+			let n = t;
+			return this.pointerSubscribers[e].add(n), () => this.pointerSubscribers[e].delete(n);
+		}
+		let n = t;
+		return this.seriesSubscribers.add(n), () => this.seriesSubscribers.delete(n);
+	}
+	emitSelect(e) {
+		let t = { selection: e };
+		for (let e of this.selectSubscribers) e(t);
+	}
+	setTheme(e) {
+		this.resolvedTheme = R(e, this.layout.root), this.applyTheme(), this.emitThemeChange(), this.refreshHover();
+	}
+	setGridVisible(e) {
+		this._gridVisible = e;
+	}
+	getGridVisible() {
+		return this._gridVisible;
+	}
+	setAxes(e) {
+		this.normalizedAxes = je(e), this.axis.setOptions({
+			x: this.normalizedAxes.x,
+			y: this.normalizedAxes.y
+		}), this.rightAxis.setOptions({
+			x: this.normalizedAxes.x,
+			y: this.normalizedAxes.y2
+		}), this.layout.update(this.normalizedAxes), this.axisOverlay?.dispose(), this.axisOverlay = null, (this.normalizedAxes.x.visible || this.normalizedAxes.y.visible || this.normalizedAxes.y2.visible) && (this.axisOverlay = new I(this.layout, this.normalizedAxes, {
+			color: this.resolvedTheme.axisColor,
+			font: this.resolvedTheme.axisFont
+		})), this.updateTextOverlays(), this.resize(), this.refreshHover();
+	}
+	pick(e, t, n = {}) {
+		let r = this.canvas.getBoundingClientRect();
+		if (r.width <= 0 || r.height <= 0) return null;
+		let i = e - r.left, a = t - r.top;
+		if (i < 0 || a < 0 || i > r.width || a > r.height) return null;
+		let o = this.camera.viewport, s = o.xMin + i / r.width * (o.xMax - o.xMin), c = o.yMax - a / r.height * (o.yMax - o.yMin), l = n.mode ?? this.options.hover?.mode ?? "nearest-x", u = n.group ?? this.options.hover?.group ?? "x", d = n.maxDistancePx ?? this.options.hover?.maxDistancePx ?? Infinity, f = l === "nearest-point" ? this.findNearestPointCandidate(s, a, r.width, r.height, d) : this.findNearestXCandidate(s, r.width, d);
+		if (!f) return null;
+		let p = f.sample.x;
+		return {
+			clientX: e,
+			clientY: t,
+			plotX: i,
+			plotY: a,
+			dataX: s,
+			dataY: c,
+			anchorX: p,
+			mode: l,
+			group: u,
+			maxDistancePx: d,
+			items: u === "none" ? [this.createPickItem(f.sample, f.series, f.seriesIndex, e, t, r)] : this.collectPickItems(p, e, t, r)
+		};
+	}
+	async screenshot(e = {}) {
+		this.render();
+		let t = this.layout.root.getBoundingClientRect(), n = this.layout.plot.getBoundingClientRect(), r = Number.isFinite(e.dpr) ? Math.max(1, e.dpr) : Math.max(1, globalThis.devicePixelRatio || 1), i = Math.max(1, Math.round(t.width * r)), a = Math.max(1, Math.round(t.height * r)), o = document.createElement("canvas");
+		o.width = i, o.height = a;
+		let s = o.getContext("2d");
+		if (!s) throw Error("Unable to create a 2D canvas context for screenshot export.");
+		return s.fillStyle = e.background ?? B(this.resolvedTheme.backgroundColor), s.fillRect(0, 0, i, a), s.drawImage(this.canvas, (n.left - t.left) * r, (n.top - t.top) * r, n.width * r, n.height * r), this.drawDomTextForScreenshot(s, t, r), new Promise((t, n) => {
+			o.toBlob((e) => e ? t(e) : n(/* @__PURE__ */ Error("Unable to encode chart screenshot.")), e.type ?? "image/png", e.quality);
+		});
+	}
+	start() {
+		let e = () => {
+			this._rafId = requestAnimationFrame(e), this.render();
+		};
+		this._rafId = requestAnimationFrame(e);
+	}
+	stop() {
+		cancelAnimationFrame(this._rafId);
+	}
+	render() {
+		let e = performance.now();
+		this.lastFrameAt > 0 && (this.stats.fps = 1e3 / (e - this.lastFrameAt)), this.lastFrameAt = e, this.stats.pointsRendered = 0, this.stats.drawCalls = 0, this.stats.uploadBytes = 0, this.stats.renderMode = "none", this.options.viewportPolicy?.beforeRender?.(this.camera), this.syncRightCameraX();
+		let [t, n, r, i] = this.resolvedTheme.backgroundColor;
+		this.renderer.viewport(0, 0, this.canvas.width, this.canvas.height), this.renderer.clear(t, n, r, i);
+		let a = this.camera.viewport;
+		if (this.currentXOrigin = a.xMin, this.renderer.setXOrigin(this.currentXOrigin), this._gridVisible) {
+			let e = this.writeGridVertices(a);
+			e > 0 && (this.uploadGridData(e), this.renderer.drawClipLines(this.gridBuffer, e, this.gridStyle), this.stats.drawCalls++);
+		}
+		for (let e of this.series) e.visible && (e.rebuildPyramid(), this.drawSeries(e));
+		this.axisOverlay?.update(this.camera, this.axis, this.rightCamera, this.rightAxis), this.emitRender(), this.stats.frameMs = performance.now() - e, this._hoverRafId !== 0 && (cancelAnimationFrame(this._hoverRafId), this._hoverRafId = 0), this.refreshHover();
+	}
+	dispose() {
+		this.stop(), this.resizeObserver?.disconnect(), this._hoverRafId !== 0 && cancelAnimationFrame(this._hoverRafId), this._hoverRafId = 0, this.canvas.removeEventListener("pointermove", this.handlePointerMove), this.canvas.removeEventListener("pointerdown", this.handlePointerDown), this.canvas.removeEventListener("pointerup", this.handlePointerUp), this.canvas.removeEventListener("pointerleave", this.handlePointerLeave), this.canvas.removeEventListener("click", this.handleClick), this.canvas.removeEventListener("dblclick", this.handleDoubleClick);
+		for (let e of this.pluginDisposers.splice(0)) e();
+		this.axisOverlay?.dispose(), this.renderer.dispose(), this.layout.dispose();
+	}
+	applyTheme() {
+		this.layout.root.style.background = this.resolvedTheme.backgroundCssColor, this.options.gridStyle?.color === void 0 && (this.gridStyle = {
+			...this.gridStyle,
+			color: this.resolvedTheme.gridColor
+		}), this.axisOverlay?.setOptions({
+			color: this.resolvedTheme.axisColor,
+			font: this.resolvedTheme.axisFont
+		}), this.updateTextOverlays();
+	}
+	updateTextOverlays() {
+		this.applyChartTextOverlay(this.layout.title, this.options.title, {
+			color: this.resolvedTheme.titleColor,
+			font: this.resolvedTheme.titleFont,
+			top: 6
+		}), this.applyChartTextOverlay(this.layout.subtitle, this.options.subtitle, {
+			color: this.resolvedTheme.subtitleColor,
+			font: this.resolvedTheme.subtitleFont,
+			top: 26
+		}), this.applyAxisTitleOverlay(this.layout.xAxisTitle, this.normalizedAxes.x.title, "x"), this.applyAxisTitleOverlay(this.layout.yAxisTitle, this.normalizedAxes.y.title, "y"), this.applyAxisTitleOverlay(this.layout.y2AxisTitle, this.normalizedAxes.y2.title, "y2");
+	}
+	applyChartTextOverlay(e, t, n) {
+		let r = Ne(t);
+		if (e.textContent = Me(t), e.style.display = r ? "block" : "none", !r) return;
+		let i = typeof t == "string" ? "center" : t?.align ?? "center";
+		e.style.color = typeof t == "string" ? n.color : t?.color ?? n.color, e.style.font = typeof t == "string" ? n.font : t?.font ?? n.font, e.style.top = `${n.top + $(t)}px`, e.style.left = i === "left" ? `${8 + Q(t)}px` : i === "right" ? "auto" : `calc(50% + ${Q(t)}px)`, e.style.right = i === "right" ? `${8 - Q(t)}px` : "auto", e.style.transform = i === "center" ? "translateX(-50%)" : "none", e.style.textAlign = i;
+	}
+	applyAxisTitleOverlay(e, t, n) {
+		let r = Ne(t);
+		e.textContent = Me(t), e.style.display = r ? "block" : "none", r && (e.style.color = typeof t == "string" ? this.resolvedTheme.axisTitleColor : t?.color ?? this.resolvedTheme.axisTitleColor, e.style.font = typeof t == "string" ? this.resolvedTheme.axisTitleFont : t?.font ?? this.resolvedTheme.axisTitleFont, n === "x" ? (e.style.left = `calc(50% + ${Q(t)}px)`, e.style.bottom = `${4 - $(t)}px`, e.style.transform = "translateX(-50%)") : n === "y" ? (e.style.left = `${4 + Q(t)}px`, e.style.top = `calc(50% + ${$(t)}px)`, e.style.transform = "translateY(-50%) rotate(-90deg)") : (e.style.right = `${4 - Q(t)}px`, e.style.top = `calc(50% + ${$(t)}px)`, e.style.transform = "translateY(-50%) rotate(90deg)"));
+	}
+	applyLayoutReservations() {
+		let e = 0, t = 0, n = 0, r = 0;
+		for (let i of this.layoutReservations.values()) e += Math.max(0, i.top ?? 0), t += Math.max(0, i.right ?? 0), n += Math.max(0, i.bottom ?? 0), r += Math.max(0, i.left ?? 0);
+		this.layout.root.style.padding = `${e}px ${t}px ${n}px ${r}px`;
+	}
+	applyCanvasSize(e = globalThis.devicePixelRatio) {
+		let t = Number.isFinite(e) ? Math.max(1, e) : 1, n = Math.max(1, Math.floor(this.canvas.clientWidth * t)), r = Math.max(1, Math.floor(this.canvas.clientHeight * t));
+		return this.canvas.width === n && this.canvas.height === r ? !1 : (this.canvas.width = n, this.canvas.height = r, !0);
+	}
+	cameraForSeries(e) {
+		return e.config.yAxis === "right" ? this.rightCamera : this.camera;
+	}
+	syncRightCameraX() {
+		this.rightCamera.setViewport({
+			xMin: this.camera.xMin,
+			xMax: this.camera.xMax
+		});
+	}
+	drawSeries(e) {
+		let t = this.cameraForSeries(e), n = t.viewport;
+		switch (e.config.mode) {
+			case "area":
+				this.drawAreaSeries(e, n, t);
+				return;
+			case "bar":
+				this.drawBarSeries(e, n, t);
+				return;
+			case "ohlc":
+				this.drawOhlcSeries(e, n, t);
+				return;
+			case "candlestick":
+				this.drawCandlestickSeries(e, n, t);
+				return;
+			case "scatter":
+				this.drawScatterSeries(e, n, t);
+				return;
+			default: this.drawLineSeries(e, n, t);
+		}
+	}
+	drawLineSeries(e, t, n) {
+		let r = e.visibleSampleCount(t), i = e.hasLOD && r > K - 2;
+		if (i && this.renderer.supportsInstancedSegments) {
+			let r = e.copyMinMaxInstanced(t, this.minMaxInstanceData, this.maxMinMaxSegments(), this.currentXOrigin);
+			if (r <= 0) return;
+			this.uploadMinMaxInstanceData(r), this.renderer.drawMinMaxSegmentsInstanced(this.minMaxInstanceBuffer, r, e.style, n), this.recordDraw("minmax", r * 2);
+			return;
+		}
+		if (i) {
+			let r = e.copyMinMaxVisible(t, this.rawLineData, this.maxMinMaxSegments(), this.currentXOrigin);
+			if (r < 2) return;
+			this.uploadRawLineData(r), this.renderer.drawMinMaxSegments(this.rawLineBuffer, r, e.style, n), this.recordDraw("minmax", r);
+			return;
+		}
+		let a = e.copyRawVisibleClipSpace(t, this.rawLineData, K);
+		a < 2 || (this.uploadRawLineData(a), this.renderer.drawClipLineStrip(this.rawLineBuffer, a, e.style), this.recordDraw("raw", a));
+	}
+	drawAreaSeries(e, t, n) {
+		let r = e.visibleIndexRange(t, 1);
+		if (r.end - r.start < 2) return;
+		let i = e.style.baseline ?? 0;
+		if (r.end - r.start > q) {
+			let r = e.copyAreaVisible(t, this.rawLineData, q, i, this.currentXOrigin);
+			r >= 4 && (this.uploadRawLineData(r), this.renderer.drawAreaStrip(this.rawLineBuffer, r, e.style, n), this.recordDraw("area", r));
+			let a = e.copyRawVisible(t, this.rawLineData, q, this.currentXOrigin);
+			a >= 2 && (this.uploadRawLineData(a), this.renderer.drawLineStrip(this.rawLineBuffer, a, e.style, n), this.recordDraw("area", a));
+			return;
+		}
+		for (let t = r.start; t < r.end;) {
+			let a = e.copyAreaRange(t, r.end, this.rawLineData, q, i, this.currentXOrigin);
+			if (a < 4) break;
+			this.uploadRawLineData(a), this.renderer.drawAreaStrip(this.rawLineBuffer, a, e.style, n), this.recordDraw("area", a), t += Math.max(1, (a >> 1) - 1);
+		}
+		for (let t = r.start; t < r.end;) {
+			let i = e.copyRawRange(t, r.end, this.rawLineData, q, this.currentXOrigin);
+			if (i < 2) break;
+			this.uploadRawLineData(i), this.renderer.drawLineStrip(this.rawLineBuffer, i, e.style, n), this.recordDraw("area", i), t += Math.max(1, i - 1);
+		}
+	}
+	drawOhlcSeries(e, t, n) {
+		let r = e.visibleIndexRange(t), i = Math.floor(this.rawLineData.length / Oe);
+		for (let t = r.start; t < r.end;) {
+			let a = e.copyOhlcRange(t, r.end, this.rawLineData, i, e.style.tickWidth ?? e.style.barWidth ?? .8, this.currentXOrigin);
+			if (a <= 0) break;
+			let o = a * 6;
+			this.uploadRawLineData(o), this.renderer.drawLines(this.rawLineBuffer, o, e.style, n), this.recordDraw("raw", o), t += a;
+		}
+	}
+	drawCandlestickSeries(e, t, n) {
+		let r = e.visibleIndexRange(t, 1), i = Math.min(Math.floor(this.rawLineData.length / Y), this.maxBarTriangleBars()), a = {
+			...e.style,
+			color: e.style.wickColor ?? e.style.color
+		}, o = {
+			...e.style,
+			color: e.style.upColor ?? e.style.color
+		}, s = {
+			...e.style,
+			color: e.style.downColor ?? e.style.fillColor ?? e.style.color
+		};
+		for (let t = r.start; t < r.end;) {
+			let c = e.copyOhlcTuplesRange(t, r.end, this.rawLineData, i, this.currentXOrigin);
+			if (c <= 0) break;
+			let l = this.writeCandlestickWicks(c);
+			l > 0 && (this.uploadBarTriangleData(l), this.renderer.drawLines(this.barTriangleBuffer, l, a, n), this.recordDraw("raw", l));
+			let u = e.style.barWidth ?? e.style.tickWidth ?? .8;
+			this.drawCandlestickBodies(c, u, "up", o, n), this.drawCandlestickBodies(c, u, "down", s, n), t += c;
+		}
+	}
+	drawScatterSeries(e, t, n) {
+		let r = e.style.pointSize ?? ke, i = e.visibleSampleCount(t);
+		if (e.config.downsample === "none" && i <= Ae) {
+			let i = e.visibleIndexRange(t);
+			for (let a = i.start; a < i.end; a += K) {
+				let o = e.copyScatterRange(a, Math.min(i.end, a + K), t, this.rawLineData, K, this.currentXOrigin, this.canvas.height, r);
+				o <= 0 || (this.uploadRawLineData(o), this.renderer.drawPoints(this.rawLineBuffer, o, e.style, n, this.canvas.width, this.canvas.height), this.recordDraw("points", o));
+			}
+			return;
+		}
+		let a = e.copyScatterVisible(t, this.rawLineData, K, this.canvas.width, this.canvas.height, r, this.currentXOrigin);
+		a <= 0 || (this.uploadRawLineData(a), this.renderer.drawPoints(this.rawLineBuffer, a, e.style, n, this.canvas.width, this.canvas.height), this.recordDraw("points", a));
+	}
+	drawBarSeries(e, t, n) {
+		let r = e.visibleSampleCount(t), i = this.maxRawBarInstances();
+		if (e.hasLOD && r > i) {
+			let r = e.copyMinMaxInstanced(t, this.minMaxInstanceData, this.maxBarTriangleBars(), this.currentXOrigin);
+			if (r <= 0) return;
+			this.includeBaselineInBarRanges(r, e.style.baseline ?? 0);
+			let i = this.writeBarBucketTriangles(r, t);
+			this.drawBarTriangles(i, e.style, n);
+			return;
+		}
+		let a = e.visibleIndexRange(t, 1), o = e.copyRawRange(a.start, a.end, this.rawLineData, i, this.currentXOrigin);
+		if (o <= 0) return;
+		if (this.renderer.supportsInstancedBars) {
+			this.uploadRawLineData(o), this.renderer.drawBarsInstanced(this.rawLineBuffer, o, e.style, n), this.recordDraw("bars", o);
+			return;
+		}
+		let s = this.writeBarTriangles(o, e.style.baseline ?? 0, e.style.barWidth ?? .8);
+		this.drawBarTriangles(s, e.style, n);
+	}
+	uploadRawLineData(e) {
+		this.uploadFloatData(this.rawLineBuffer, this.rawLineData, e * 2);
+	}
+	uploadMinMaxInstanceData(e) {
+		this.uploadFloatData(this.minMaxInstanceBuffer, this.minMaxInstanceData, e * J);
+	}
+	uploadBarTriangleData(e) {
+		this.uploadFloatData(this.barTriangleBuffer, this.barTriangleData, e * 2);
+	}
+	uploadGridData(e) {
+		this.uploadFloatData(this.gridBuffer, this.gridData, e * 2);
+	}
+	uploadFloatData(e, t, n) {
+		let r = Math.max(0, Math.min(n, t.length));
+		this.renderer.updateFloatBuffer(e, t, r), this.stats.uploadBytes += r * Float32Array.BYTES_PER_ELEMENT;
+	}
+	includeBaselineInBarRanges(e, t) {
+		for (let n = 0; n < e; n++) {
+			let e = n * J, r = this.minMaxInstanceData[e + 1], i = this.minMaxInstanceData[e + 2];
+			this.minMaxInstanceData[e + 1] = Math.min(t, r), this.minMaxInstanceData[e + 2] = Math.max(t, i);
+		}
+	}
+	writeBarTriangles(e, t, n) {
+		let r = Math.min(e, this.maxBarTriangleBars());
+		for (let e = 0; e < r; e++) {
+			let r = this.rawLineData[e * 2], i = this.rawLineData[e * 2 + 1];
+			this.writeBarTriangle(e, r - n * .5, r + n * .5, t, i);
+		}
+		return r * 6;
+	}
+	writeBarBucketTriangles(e, t) {
+		let n = Math.min(e, this.maxBarTriangleBars());
+		for (let e = 0; e < n; e++) {
+			let r = this.minMaxInstanceData[e * 3 + 1], i = this.minMaxInstanceData[e * 3 + 2], [a, o] = this.barBucketBounds(e, n, t);
+			this.writeBarTriangle(e, a, o, r, i);
+		}
+		return n * 6;
+	}
+	barBucketBounds(e, t, n) {
+		let r = this.minMaxInstanceData[e * 3], i = n.xMin - this.currentXOrigin, a = n.xMax - this.currentXOrigin, o = a - i;
+		if (t <= 1) {
+			let e = Math.max(0, o * .5);
+			return [Math.max(i, r - e), Math.min(a, r + e)];
+		}
+		let s = e > 0 ? this.minMaxInstanceData[(e - 1) * 3] : NaN, c = e + 1 < t ? this.minMaxInstanceData[(e + 1) * 3] : NaN, l = e === 0 ? r - (c - r) * .5 : (s + r) * .5, u = e + 1 === t ? r + (r - s) * .5 : (r + c) * .5;
+		if (!Number.isFinite(l) || !Number.isFinite(u) || u <= l) {
+			let n = o / Math.max(1, t);
+			l = i + e * n, u = e + 1 === t ? a : l + n;
+		}
+		return [Math.max(i, l), Math.min(a, u)];
+	}
+	writeCandlestickWicks(e) {
+		for (let t = 0; t < e; t++) {
+			let e = t * Y, n = t * 4, r = this.rawLineData[e], i = this.rawLineData[e + 2], a = this.rawLineData[e + 3];
+			this.barTriangleData[n] = r, this.barTriangleData[n + 1] = a, this.barTriangleData[n + 2] = r, this.barTriangleData[n + 3] = i;
+		}
+		return e * 2;
+	}
+	drawCandlestickBodies(e, t, n, r, i) {
+		let a = t * .5, o = 0;
+		for (let t = 0; t < e && o < this.maxBarTriangleBars(); t++) {
+			let e = t * Y, r = this.rawLineData[e], i = this.rawLineData[e + 1], s = this.rawLineData[e + 4];
+			n === "up" == s >= i && (this.writeBarTriangle(o, r - a, r + a, Math.min(i, s), Math.max(i, s)), o++);
+		}
+		this.drawBarTriangles(o * 6, r, i);
+	}
+	writeBarTriangle(e, t, n, r, i) {
+		let a = e * De;
+		this.barTriangleData[a] = t, this.barTriangleData[a + 1] = r, this.barTriangleData[a + 2] = n, this.barTriangleData[a + 3] = r, this.barTriangleData[a + 4] = t, this.barTriangleData[a + 5] = i, this.barTriangleData[a + 6] = t, this.barTriangleData[a + 7] = i, this.barTriangleData[a + 8] = n, this.barTriangleData[a + 9] = r, this.barTriangleData[a + 10] = n, this.barTriangleData[a + 11] = i;
+	}
+	drawBarTriangles(e, t, n, r = "bars") {
+		e <= 0 || (this.uploadBarTriangleData(e), this.renderer.drawBarTriangles(this.barTriangleBuffer, e, t, n), this.recordDraw(r, e));
+	}
+	recordDraw(e, t, n = 1) {
+		this.recordRenderMode(e), this.stats.pointsRendered += t, this.stats.drawCalls += n;
+	}
+	findNearestXCandidate(e, t, n) {
+		let r = null, i = Infinity;
+		for (let n = 0; n < this.series.length; n++) {
+			let a = this.series[n];
+			if (!a.visible) continue;
+			let o = this.cameraForSeries(a).viewport, s = t / (o.xMax - o.xMin), c = a.nearestSampleByX(e, o);
+			if (!c) continue;
+			let l = Math.abs(c.x - e) * s;
+			l < i && (r = {
+				sample: c,
+				series: a,
+				seriesIndex: n
+			}, i = l);
+		}
+		return r && i <= n ? r : null;
+	}
+	findNearestPointCandidate(e, t, n, r, i) {
+		let a = null;
+		for (let o = 0; o < this.series.length; o++) {
+			let s = this.series[o];
+			if (!s.visible) continue;
+			let c = this.cameraForSeries(s).viewport, l = c.yMax - t / r * (c.yMax - c.yMin), u = s.nearestSampleByPoint(e, l, c, n, r, i);
+			u && (!a || (u.distancePx ?? Infinity) < (a.sample.distancePx ?? Infinity)) && (a = {
+				sample: u,
+				series: s,
+				seriesIndex: o
+			});
+		}
+		return a && (a.sample.distancePx ?? Infinity) <= i ? a : null;
+	}
+	collectPickItems(e, t, n, r) {
+		let i = [];
+		for (let a = 0; a < this.series.length; a++) {
+			let o = this.series[a];
+			if (!o.visible) continue;
+			let s = o.nearestSampleByX(e, this.cameraForSeries(o).viewport);
+			s && i.push(this.createPickItem(s, o, a, t, n, r));
+		}
+		return i;
+	}
+	createPickItem(e, t, n, r, i, a) {
+		let o = this.cameraForSeries(t), [s, c] = o.toClip(e.x, e.y), [l, u] = o.toScreen(s, c, a.width, a.height), d = a.left + l, f = a.top + u, p = d - r, m = f - i;
+		return {
+			...e,
+			distancePx: Math.hypot(p, m),
+			series: t,
+			seriesIndex: n,
+			id: t.config.id,
+			name: t.config.name,
+			mode: t.config.mode,
+			plotX: l,
+			plotY: u,
+			clientX: d,
+			clientY: f
+		};
+	}
+	scheduleHoverRefresh() {
+		this._hoverRafId === 0 && (this._hoverRafId = requestAnimationFrame(() => {
+			this._hoverRafId = 0, this.refreshHover();
+		}));
+	}
+	refreshHover() {
+		this.pointerInPlot && this.emitHover(this.pick(this.lastPointerClientX, this.lastPointerClientY));
+	}
+	emitHover(e) {
+		this.currentHover = e;
+		for (let t of this.hoverSubscribers) t(e);
+	}
+	emitPointerEvent(e, t) {
+		let n = this.canvas.getBoundingClientRect();
+		if (n.width <= 0 || n.height <= 0) return null;
+		let r = t.clientX - n.left, i = t.clientY - n.top;
+		if (r < 0 || i < 0 || r > n.width || i > n.height) return null;
+		let a = this.camera.viewport, o = a.xMin + r / n.width * (a.xMax - a.xMin), s = a.yMax - i / n.height * (a.yMax - a.yMin), c = this.pick(t.clientX, t.clientY, this.options.hover), l = {
+			type: e,
+			clientX: t.clientX,
+			clientY: t.clientY,
+			plotX: r,
+			plotY: i,
+			dataX: o,
+			dataY: s,
+			button: t.button,
+			buttons: t.buttons,
+			altKey: t.altKey,
+			ctrlKey: t.ctrlKey,
+			metaKey: t.metaKey,
+			shiftKey: t.shiftKey,
+			items: c?.items ?? []
+		};
+		for (let t of this.pointerSubscribers[e]) t(l);
+		return l;
+	}
+	emitSeriesClick(e) {
+		for (let t of this.seriesClickSubscribers) t(e);
+	}
+	emitViewportChange() {
+		let e = {
+			viewport: this.camera.viewport,
+			rightViewport: this.rightCamera.viewport
+		};
+		for (let t of this.viewportSubscribers) t(e);
+	}
+	emitSeriesChange() {
+		for (let e of this.seriesSubscribers) e();
+		this.refreshHover();
+	}
+	emitThemeChange() {
+		for (let e of this.themeSubscribers) e();
+	}
+	emitRender() {
+		for (let e of this.renderSubscribers) e(this);
+	}
+	drawDomTextForScreenshot(e, t, n) {
+		let r = this.layout.root.querySelectorAll("div");
+		for (let i of r) {
+			let r = i.textContent;
+			if (!r || i.children.length > 0) continue;
+			let a = getComputedStyle(i);
+			if (a.display === "none" || a.visibility === "hidden" || a.opacity === "0") continue;
+			let o = i.getBoundingClientRect();
+			o.width <= 0 || o.height <= 0 || (e.save(), e.scale(n, n), e.font = a.font, e.fillStyle = a.color, e.textBaseline = "top", e.textAlign = "left", e.fillText(r, o.left - t.left, o.top - t.top), e.restore());
+		}
+	}
+	maxMinMaxSegments() {
+		return Math.min(this.canvas.width, Te);
+	}
+	maxBarTriangleBars() {
+		return Math.min(Ee, K);
+	}
+	maxRawBarInstances() {
+		return this.renderer.supportsInstancedBars ? K : this.maxBarTriangleBars();
+	}
+	writeGridVertices(e) {
+		let t = Math.max(1, this.canvas.clientWidth), n = Math.max(1, this.canvas.clientHeight);
+		this.axis.getXTickValues(t, 12, this.xTicks), this.axis.getYTickValues(n, 8, this.yTicks);
+		let r = 0;
+		for (let t of this.xTicks) {
+			if (r + 2 > X) return r;
+			this.gridData[r * 2] = this.xToClip(t, e), this.gridData[r * 2 + 1] = -1, r++, this.gridData[r * 2] = this.xToClip(t, e), this.gridData[r * 2 + 1] = 1, r++;
+		}
+		for (let t of this.yTicks) {
+			if (r + 2 > X) return r;
+			this.gridData[r * 2] = -1, this.gridData[r * 2 + 1] = this.yToClip(t, e), r++, this.gridData[r * 2] = 1, this.gridData[r * 2 + 1] = this.yToClip(t, e), r++;
+		}
+		return r;
+	}
+	xToClip(e, t) {
+		return (e - t.xMin) / (t.xMax - t.xMin) * 2 - 1;
+	}
+	yToClip(e, t) {
+		return (e - t.yMin) / (t.yMax - t.yMin) * 2 - 1;
+	}
+	recordRenderMode(e) {
+		this.stats.renderMode === "none" ? this.stats.renderMode = e : this.stats.renderMode !== e && (this.stats.renderMode = "mixed");
+	}
+};
+//#endregion
+export { _ as a, m as c, O as i, n as l, L as n, h as o, F as r, g as s, Pe as t };
+
+//# sourceMappingURL=Chart-BW9JaHs6.js.map