blazeplot 0.1.0

package/dist/index.js

@@ -0,0 +1,669 @@
+import e from "regl";
+//#region src/core/RingBuffer.ts
+var t = class {
+	capacity;
+	_length = 0;
+	_head = 0;
+	xData;
+	yData;
+	constructor(e) {
+		if (!Number.isInteger(e) || e <= 0) throw RangeError("RingBuffer capacity must be a positive integer.");
+		this.capacity = e, this.xData = new Float64Array(e), this.yData = new Float32Array(e);
+	}
+	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) {
+		this.xData[this._head] = e, this.yData[this._head] = t, this._head = (this._head + 1) % this.capacity, this._length < this.capacity && this._length++;
+	}
+	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) {
+		let t = 0, n = this._length;
+		for (; t < n;) {
+			let r = t + (n - t >> 1);
+			this.getX(r) < e ? t = r + 1 : n = r;
+		}
+		return t;
+	}
+	upperBoundX(e) {
+		let t = 0, n = this._length;
+		for (; t < n;) {
+			let r = t + (n - t >> 1);
+			this.getX(r) <= e ? t = r + 1 : n = r;
+		}
+		return t;
+	}
+	clear() {
+		this._length = 0, this._head = 0;
+	}
+	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}`);
+	}
+}, n = 16, r = class {
+	bucketSize;
+	levels = [];
+	levelLengths;
+	levelSampleWidths;
+	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(n), this.levelSampleWidths = new Uint32Array(n);
+	}
+	build(e) {
+		this.levels = [], this.levelLengths.fill(0), this.levelSampleWidths.fill(0);
+		let t = e.length;
+		if (t === 0) return;
+		let r = null, i = 0;
+		for (; t > 0 && i < n;) {
+			let n = Math.ceil(t / this.bucketSize), a = new Float32Array(n * 2);
+			for (let n = 0; n < t; n += this.bucketSize) {
+				let i = Infinity, o = -Infinity, s = Math.min(n + this.bucketSize, t);
+				for (let t = n; t < s; t++) if (r) {
+					let e = r[t * 2], n = r[t * 2 + 1];
+					e < i && (i = e), n > o && (o = n);
+				} else {
+					let n = e.getY(t);
+					n < i && (i = n), n > o && (o = n);
+				}
+				let c = Math.floor(n / this.bucketSize);
+				a[c * 2] = i, a[c * 2 + 1] = o;
+			}
+			if (this.levels[i] = a, this.levelLengths[i] = n, this.levelSampleWidths[i] = this.bucketSize ** (i + 1), n === 1) break;
+			r = a, t = n, i++;
+		}
+	}
+	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
+		};
+	}
+}, i = class {
+	config;
+	style;
+	buffer;
+	pyramid;
+	_dirty = !1;
+	_visible = !0;
+	constructor(e, n) {
+		this.config = e, this.buffer = new t(e.capacity), this.pyramid = new r(), this.style = n;
+	}
+	get dirty() {
+		return this._dirty;
+	}
+	get length() {
+		return this.buffer.length;
+	}
+	get visible() {
+		return this._visible;
+	}
+	setVisible(e) {
+		this._visible = e;
+	}
+	append(e, t) {
+		let n = Math.min(e.length, t.length);
+		for (let r = 0; r < n; r++) this.buffer.push(e[r], t[r]);
+		this._dirty = !0;
+	}
+	clear() {
+		this.buffer.clear(), this.pyramid.build(this.buffer), this._dirty = !1;
+	}
+	rebuildPyramid() {
+		this._dirty &&= (this.pyramid.build(this.buffer), !1);
+	}
+	query(e, t) {
+		if (!this.buffer.range) return {
+			buckets: new Float32Array(),
+			bucketCount: 0,
+			level: 0,
+			samplesPerPixel: 0
+		};
+		let n = this.buffer.lowerBoundX(e.xMin), r = this.buffer.upperBoundX(e.xMax);
+		return this.pyramid.query(e, t, {
+			start: n,
+			length: Math.max(0, r - n)
+		});
+	}
+	visibleSampleCount(e) {
+		let t = this.buffer.lowerBoundX(e.xMin), n = this.buffer.upperBoundX(e.xMax);
+		return Math.max(0, n - t);
+	}
+	copyRawVisible(e, t, n) {
+		if (n <= 0 || t.length < n * 2) return 0;
+		let r = this.buffer.lowerBoundX(e.xMin), i = this.buffer.upperBoundX(e.xMax), a = i - r;
+		if (a <= 0) return 0;
+		let o = Math.max(1, Math.ceil(a / n)), s = 0;
+		for (let e = r; e < i && s < n; e += o) t[s * 2] = this.buffer.getX(e), t[s * 2 + 1] = this.buffer.getY(e), s++;
+		return s;
+	}
+	copyMinMaxVisible(e, t, n) {
+		if (n <= 0 || t.length < n * 4) return 0;
+		let r = this.buffer.lowerBoundX(e.xMin), i = this.buffer.upperBoundX(e.xMax), a = i - r;
+		if (a <= 0) return 0;
+		let o = Math.min(n, a), s = 0;
+		for (let e = 0; e < o; e++) {
+			let n = r + Math.floor(e * a / o), c = r + Math.max(Math.floor((e + 1) * a / o), Math.floor(e * a / o) + 1), l = Math.min(i, c), u = Infinity, d = -Infinity;
+			for (let e = n; e < l; e++) {
+				let t = this.buffer.getY(e);
+				t < u && (u = t), t > d && (d = t);
+			}
+			let f = this.buffer.getX(n + (l - n >> 1));
+			t[s * 2] = f, t[s * 2 + 1] = u, s++, t[s * 2] = f, t[s * 2 + 1] = d, s++;
+		}
+		return s;
+	}
+}, a = {
+	line: {
+		vert: "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",
+		frag: "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n"
+	},
+	segment: {
+		vert: "attribute float aX;\nattribute float aMinY;\nattribute float aMaxY;\n\nuniform vec2 uScale;\nuniform vec2 uOffset;\n\nvoid main() {\n  float y = (gl_VertexID == 0) ? 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",
+		frag: "precision mediump float;\n\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n"
+	}
+}, o = class {
+	backend;
+	lineProgram;
+	scaleUniform = new Float32Array(2);
+	offsetUniform = new Float32Array(2);
+	constructor(e) {
+		this.backend = e, this.lineProgram = this.backend.createProgram(a.line.vert, a.line.frag);
+	}
+	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) {
+		this.backend.updateBuffer(e, t);
+	}
+	viewport(e, t, n, r) {
+		this.backend.viewport(e, t, n, r);
+	}
+	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);
+	}
+	drawLinePrimitive(e, t, n, r, i) {
+		this.scaleUniform[0] = i.xScale, this.scaleUniform[1] = i.yScale, this.offsetUniform[0] = i.xOffset, this.offsetUniform[1] = i.yOffset, this.backend.draw({
+			program: this.lineProgram,
+			primitive: e,
+			count: n,
+			attributes: { position: t },
+			uniforms: {
+				uScale: this.scaleUniform,
+				uOffset: this.offsetUniform,
+				uColor: r.color
+			}
+		});
+	}
+	drawMinMaxSegments(e, t, n, r) {
+		this.drawLines(e, t, n, r);
+	}
+	dispose() {
+		this.backend.destroy();
+	}
+};
+//#endregion
+//#region src/render/ReglBackend.ts
+function s(e) {
+	return e;
+}
+var c = class {
+	gl;
+	regl;
+	nextProgramId = 1;
+	commandCache = /* @__PURE__ */ new Map();
+	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: s(this.gl),
+			extensions: [],
+			optionalExtensions: ["ext_disjoint_timer_query_webgl2"]
+		});
+	}
+	createBuffer(e) {
+		let t = e.type === "float" ? 4 : 2;
+		return {
+			length: e.length,
+			type: e.type,
+			buffer: this.regl.buffer({
+				length: e.length * t,
+				usage: e.usage,
+				type: e.type === "float" ? "float" : "uint16"
+			})
+		};
+	}
+	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.asReglBuffer(e.attributes[t]).buffer;
+		a({
+			count: e.count,
+			instances: e.instances ?? 0,
+			attributes: o,
+			uniforms: e.uniforms
+		});
+	}
+	dispose(e) {
+		this.isReglBuffer(e) && e.buffer.destroy();
+	}
+	clear(e, t, n, r) {
+		this.regl.clear({ color: [
+			e,
+			t,
+			n,
+			r
+		] });
+	}
+	viewport(e, t, n, r) {}
+	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 }
+		});
+	}
+	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;
+		}
+	}
+}, l = class {
+	canvas;
+	camera;
+	policy;
+	_enabled = !0;
+	activePointerId = null;
+	lastX = 0;
+	lastY = 0;
+	constructor(e, t, n) {
+		this.canvas = e, this.camera = t, this.policy = n, this.bindEvents();
+	}
+	get enabled() {
+		return this._enabled;
+	}
+	set enabled(e) {
+		this._enabled = e;
+	}
+	bindEvents() {
+		this.canvas.addEventListener("pointerdown", this.onPointerDown), this.canvas.addEventListener("pointermove", this.onPointerMove), this.canvas.addEventListener("pointerup", this.onPointerUp), this.canvas.addEventListener("pointercancel", this.onPointerUp), this.canvas.addEventListener("wheel", this.onWheel, { passive: !1 });
+	}
+	onPointerDown = (e) => {
+		!this._enabled || this.activePointerId !== null || (this.activePointerId = e.pointerId, this.lastX = e.clientX, this.lastY = e.clientY, this.canvas.setPointerCapture(e.pointerId));
+	};
+	onPointerMove = (e) => {
+		if (!this._enabled || e.pointerId !== this.activePointerId) return;
+		let t = this.canvas.getBoundingClientRect(), n = t.width > 0 ? (this.lastX - e.clientX) / t.width : 0, r = t.height > 0 ? (e.clientY - this.lastY) / t.height : 0, i = this.applyPanPolicy({
+			dx: n,
+			dy: r
+		});
+		i && this.camera.pan(i), this.lastX = e.clientX, this.lastY = e.clientY;
+	};
+	onPointerUp = (e) => {
+		e.pointerId === this.activePointerId && (this.activePointerId = null, this.canvas.hasPointerCapture(e.pointerId) && this.canvas.releasePointerCapture(e.pointerId));
+	};
+	onWheel = (e) => {
+		if (!this._enabled) return;
+		e.preventDefault();
+		let t = e.deltaY < 0 ? 1.1 : .9, n = this.canvas.getBoundingClientRect(), r = n.width > 0 ? (e.clientX - n.left) / n.width : .5, i = n.height > 0 ? 1 - (e.clientY - n.top) / n.height : .5, a = this.applyZoomPolicy({
+			factor: t,
+			cx: r,
+			cy: i,
+			axis: "xy"
+		});
+		a && this.camera.zoom(a);
+	};
+	applyPanPolicy(e) {
+		return this.policy?.beforePan ? this.policy.beforePan(this.camera, e) : e;
+	}
+	applyZoomPolicy(e) {
+		return this.policy?.beforeZoom ? this.policy.beforeZoom(this.camera, e) : e;
+	}
+	dispose() {
+		this.canvas.removeEventListener("pointerdown", this.onPointerDown), this.canvas.removeEventListener("pointermove", this.onPointerMove), this.canvas.removeEventListener("pointerup", this.onPointerUp), this.canvas.removeEventListener("pointercancel", this.onPointerUp), this.canvas.removeEventListener("wheel", this.onWheel);
+	}
+}, u = 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.`);
+	}
+}, d = class {
+	camera;
+	constructor(e) {
+		this.camera = e;
+	}
+	getXTickValues(e, t = 10, n = []) {
+		return this.getTickValues(this.camera.xMin, this.camera.xMax, e, t, 80, n);
+	}
+	getYTickValues(e, t = 10, n = []) {
+		return this.getTickValues(this.camera.yMin, this.camera.yMax, e, t, 48, n);
+	}
+	formatValue(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);
+	}
+	getTickValues(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;
+	}
+	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;
+	}
+}, f = 16384, p = 64, m = class {
+	canvas;
+	options;
+	series = [];
+	camera;
+	axis;
+	renderer;
+	input;
+	rawLineBuffer;
+	rawLineData;
+	gridBuffer;
+	gridData;
+	gridStyle;
+	xTicks = [];
+	yTicks = [];
+	stats = {
+		fps: 0,
+		frameMs: 0,
+		pointsRendered: 0,
+		drawCalls: 0,
+		uploadBytes: 0,
+		renderMode: "none"
+	};
+	resizeObserver = null;
+	lastFrameAt = 0;
+	_rafId = 0;
+	constructor(e, t = {}) {
+		this.canvas = e, this.options = t, this.applyCanvasSize(), this.camera = new u(), this.axis = new d(this.camera), this.renderer = new o(new c(e)), this.input = new l(e, this.camera, t.viewportPolicy), this.rawLineData = new Float32Array(f * 2), this.rawLineBuffer = this.renderer.createFloatBuffer(this.rawLineData.length), this.gridData = new Float32Array(p * 2), this.gridBuffer = this.renderer.createFloatBuffer(this.gridData.length), this.gridStyle = {
+			color: t.gridStyle?.color ?? [
+				.22,
+				.3,
+				.44,
+				.45
+			],
+			lineWidth: t.gridStyle?.lineWidth ?? 1
+		}, typeof ResizeObserver < "u" && (this.resizeObserver = new ResizeObserver(() => this.resize()), this.resizeObserver.observe(this.canvas));
+	}
+	addSeries(e, t) {
+		let n = new i(e, {
+			color: t?.color ?? [
+				.3,
+				.6,
+				1,
+				1
+			],
+			lineWidth: t?.lineWidth ?? 1
+		});
+		return this.series.push(n), n;
+	}
+	removeSeries(e) {
+		let t = this.series.indexOf(e);
+		return t === -1 ? !1 : (this.series.splice(t, 1), !0);
+	}
+	setViewport(e) {
+		this.camera.setViewport(e);
+	}
+	resize(e = globalThis.devicePixelRatio) {
+		let t = this.applyCanvasSize(e);
+		return t && this.renderer.viewport(0, 0, this.canvas.width, this.canvas.height), 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;
+	}
+	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.renderer.clear(.08, .1, .16, 1);
+		let t = this.camera.viewport;
+		if (this.options.grid !== !1) {
+			let e = this.writeGridVertices(t);
+			e > 0 && (this.renderer.updateFloatBuffer(this.gridBuffer, this.gridData), this.renderer.drawLines(this.gridBuffer, e, this.gridStyle, this.camera), this.stats.drawCalls++, this.stats.uploadBytes += this.gridData.byteLength);
+		}
+		for (let e of this.series) {
+			if (!e.visible) continue;
+			let n = e.visibleSampleCount(t) > f, r = n ? e.copyMinMaxVisible(t, this.rawLineData, Math.min(this.canvas.width, f >> 1)) : e.copyRawVisible(t, this.rawLineData, f);
+			r < 2 || (this.renderer.updateFloatBuffer(this.rawLineBuffer, this.rawLineData), n ? (this.renderer.drawMinMaxSegments(this.rawLineBuffer, r, e.style, this.camera), this.recordRenderMode("minmax")) : (this.renderer.drawLineStrip(this.rawLineBuffer, r, e.style, this.camera), this.recordRenderMode("raw")), this.stats.pointsRendered += r, this.stats.drawCalls++, this.stats.uploadBytes += this.rawLineData.byteLength);
+		}
+		this.stats.frameMs = performance.now() - e;
+	}
+	dispose() {
+		this.stop(), this.resizeObserver?.disconnect(), this.input.dispose(), this.renderer.dispose();
+	}
+	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);
+	}
+	writeGridVertices(e) {
+		this.axis.getXTickValues(this.canvas.width, 12, this.xTicks), this.axis.getYTickValues(this.canvas.height, 8, this.yTicks);
+		let t = 0;
+		for (let n of this.xTicks) {
+			if (t + 2 > p) return t;
+			this.gridData[t * 2] = n, this.gridData[t * 2 + 1] = e.yMin, t++, this.gridData[t * 2] = n, this.gridData[t * 2 + 1] = e.yMax, t++;
+		}
+		for (let n of this.yTicks) {
+			if (t + 2 > p) return t;
+			this.gridData[t * 2] = e.xMin, this.gridData[t * 2 + 1] = n, t++, this.gridData[t * 2] = e.xMax, this.gridData[t * 2 + 1] = n, t++;
+		}
+		return t;
+	}
+	recordRenderMode(e) {
+		this.stats.renderMode === "none" ? this.stats.renderMode = e : this.stats.renderMode !== e && (this.stats.renderMode = "mixed");
+	}
+};
+//#endregion
+export { d as AxisController, u as Camera2D, m as Chart, r as MinMaxPyramid, t as RingBuffer, i as SeriesStore };
+
+//# sourceMappingURL=index.js.map