@tradecanvas/core 1.4.0 → 1.10.0

package/dist/WebGLSeriesRenderer-DQOPCwno.js

@@ -0,0 +1,1643 @@
+import { i as e, o as t, r as n, t as r } from "./gridLines-kFhXyH-u.js";
+import { resolveVolumeColors as i } from "@tradecanvas/commons";
+var a = (e, t) => e.time === t.time && e.open === t.open && e.high === t.high && e.low === t.low && e.close === t.close && e.volume === t.volume, o = class {
+	buffer = new Float32Array();
+	count = 0;
+	basePrice = 0;
+	samples = [];
+	last = null;
+	source = null;
+	get values() {
+		return this.buffer;
+	}
+	get length() {
+		return this.count;
+	}
+	get base() {
+		return this.basePrice;
+	}
+	sync(e) {
+		let t = e.length;
+		if (t === 0) return this.reset(), {
+			full: !0,
+			from: 0,
+			to: 0
+		};
+		let n = this.count;
+		if (!(e === this.source && n > 0 && t >= n && this.samples.every(({ index: t, bar: n }) => a(e[t], n)))) return this.basePrice = e[t - 1].close, this.ensure(t), this.write(e, 0, t), this.remember(e), {
+			full: !0,
+			from: 0,
+			to: t
+		};
+		let r = this.last !== null && a(e[n - 1], this.last) ? n : n - 1;
+		return t > this.buffer.length / 6 ? (this.ensure(t), this.write(e, 0, t), this.remember(e), {
+			full: !0,
+			from: 0,
+			to: t
+		}) : (this.write(e, r, t), this.remember(e), {
+			full: !1,
+			from: r,
+			to: t
+		});
+	}
+	reset() {
+		this.count = 0, this.samples = [], this.last = null, this.source = null;
+	}
+	ensure(e) {
+		e * 6 <= this.buffer.length || (this.buffer = new Float32Array(Math.max(e + 1024, Math.ceil(e * 1.25)) * 6));
+	}
+	write(e, t, n) {
+		let r = this.buffer, i = this.basePrice;
+		for (let a = t; a < n; a++) {
+			let t = e[a], n = a * 6;
+			r[n] = t.open - i, r[n + 1] = t.high - i, r[n + 2] = t.low - i, r[n + 3] = t.close - i, r[n + 4] = t.volume, r[n + 5] = +(t.close >= t.open);
+		}
+		this.count = n;
+	}
+	remember(e) {
+		let t = e.length, n = t - 1, r = /* @__PURE__ */ new Set();
+		if (n > 0) for (let e = 0; e < 16; e++) r.add(Math.min(n - 1, Math.round(e * (n - 1) / 15)));
+		this.samples = [...r].map((t) => ({
+			index: t,
+			bar: { ...e[t] }
+		})), this.last = { ...e[t - 1] }, this.source = e;
+	}
+}, s = /* @__PURE__ */ new Map(), c;
+function l(e, t) {
+	return e.endsWith("%") ? parseFloat(e) / 100 : parseFloat(e) / t;
+}
+function u(e) {
+	let t = e.trim();
+	if (t.toLowerCase() === "transparent") return [
+		0,
+		0,
+		0,
+		0
+	];
+	let n = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(t);
+	if (n) {
+		let e = n[1];
+		e.length <= 4 && (e = [...e].map((e) => e + e).join(""));
+		let t = (t) => parseInt(e.slice(t, t + 2), 16) / 255;
+		return [
+			t(0),
+			t(2),
+			t(4),
+			e.length === 8 ? t(6) : 1
+		];
+	}
+	let r = /^rgba?\(\s*([\d.]+%?)[\s,]+([\d.]+%?)[\s,]+([\d.]+%?)(?:\s*[,/]\s*([\d.]+%?))?\s*\)$/i.exec(t);
+	return r ? [
+		l(r[1], 255),
+		l(r[2], 255),
+		l(r[3], 255),
+		r[4] === void 0 ? 1 : l(r[4], 1)
+	] : null;
+}
+function d() {
+	if (c !== void 0) return c;
+	try {
+		c = typeof OffscreenCanvas < "u" ? new OffscreenCanvas(1, 1).getContext("2d") : typeof document < "u" ? document.createElement("canvas").getContext("2d") : null;
+	} catch {
+		c = null;
+	}
+	return c;
+}
+function f(e) {
+	let t = d();
+	if (!t) return null;
+	t.fillStyle = "#000", t.fillStyle = e;
+	let n = String(t.fillStyle);
+	if (t.fillStyle = "#fff", t.fillStyle = e, String(t.fillStyle) !== n) return null;
+	let r = u(n);
+	if (r) return r;
+	t.clearRect(0, 0, 1, 1), t.fillRect(0, 0, 1, 1);
+	let i = t.getImageData(0, 0, 1, 1).data;
+	return [
+		i[0] / 255,
+		i[1] / 255,
+		i[2] / 255,
+		i[3] / 255
+	];
+}
+var p = /* @__PURE__ */ new Set();
+function m(e) {
+	let t = s.get(e);
+	if (t) return t;
+	if (p.has(e)) return null;
+	let n = u(e) ?? f(e);
+	return s.size > 256 && s.clear(), p.size > 256 && p.clear(), n ? s.set(e, n) : p.add(e), n;
+}
+function h(e) {
+	return m(e) ?? [
+		0,
+		0,
+		0,
+		0
+	];
+}
+function g([e, t, n, r]) {
+	return [
+		e * r,
+		t * r,
+		n * r,
+		r
+	];
+}
+//#endregion
+//#region src/webgl/yMapping.ts
+function _(e, t) {
+	let { min: n, max: r } = e.priceRange, { y: i, height: a } = e.chartRect, o = +(e.invertScale === !0), s = {
+		log: 0,
+		invert: o,
+		yA: i + a / 2,
+		yB: 0,
+		logOffset: 0,
+		min: 1,
+		logFloor: 0,
+		logK: 0,
+		top: i,
+		bottom: i + a
+	};
+	if (e.logScale && n > 0 && r > 0) {
+		let e = Math.log(r) - Math.log(n);
+		return e === 0 ? s : {
+			...s,
+			log: 1,
+			logOffset: t - n,
+			min: n,
+			logFloor: 2 ** -52 / n,
+			logK: a / e
+		};
+	}
+	let c = r - n;
+	if (c === 0) return s;
+	let l = a / c;
+	return o ? {
+		...s,
+		yA: i + (t - n) * l,
+		yB: l
+	} : {
+		...s,
+		yA: i + (r - t) * l,
+		yB: -l
+	};
+}
+//#endregion
+//#region src/webgl/glKit.ts
+var v = class {
+	constructor(e) {
+		this.gl = e;
+	}
+	program(e, t, n) {
+		let r = this.gl, i = (e, t) => {
+			let n = r.createShader(e);
+			if (!n) throw Error("WebGL: no shader");
+			if (r.shaderSource(n, t), r.compileShader(n), !r.getShaderParameter(n, r.COMPILE_STATUS)) {
+				let e = r.getShaderInfoLog(n);
+				throw r.deleteShader(n), Error(`WebGL shader: ${e}`);
+			}
+			return n;
+		}, a = i(r.VERTEX_SHADER, e), o = i(r.FRAGMENT_SHADER, t), s = r.createProgram();
+		if (!s) throw Error("WebGL: no program");
+		if (r.attachShader(s, a), r.attachShader(s, o), r.linkProgram(s), r.deleteShader(a), r.deleteShader(o), !r.getProgramParameter(s, r.LINK_STATUS)) throw Error(`WebGL program: ${r.getProgramInfoLog(s)}`);
+		let c = r.createVertexArray();
+		if (!c) throw Error("WebGL: no vertex array");
+		let l = /* @__PURE__ */ new Map();
+		for (let e of n) l.set(e, r.getAttribLocation(s, e));
+		return {
+			program: s,
+			vao: c,
+			uniforms: /* @__PURE__ */ new Map(),
+			attribs: l
+		};
+	}
+	buffer() {
+		let e = this.gl.createBuffer();
+		if (!e) throw Error("WebGL: no buffer");
+		return e;
+	}
+	use(e) {
+		return this.gl.useProgram(e.program), this.gl.bindVertexArray(e.vao), e;
+	}
+	attrib(e, t, n, r, i, a = 1) {
+		let o = e.attribs.get(t);
+		if (o === void 0 || o < 0) return;
+		let s = this.gl;
+		s.enableVertexAttribArray(o), s.vertexAttribPointer(o, n, s.FLOAT, !1, r, i), s.vertexAttribDivisor(o, a);
+	}
+	int(e, t, n) {
+		this.gl.uniform1i(this.loc(e, t), n);
+	}
+	float(e, t, n) {
+		this.gl.uniform1f(this.loc(e, t), n);
+	}
+	vec2(e, t, n, r) {
+		this.gl.uniform2f(this.loc(e, t), n, r);
+	}
+	vec4(e, t, n) {
+		this.gl.uniform4f(this.loc(e, t), n[0], n[1], n[2], n[3]);
+	}
+	loc(e, t) {
+		return e.uniforms.has(t) || e.uniforms.set(t, this.gl.getUniformLocation(e.program, t)), e.uniforms.get(t) ?? null;
+	}
+	deleteProgram(e) {
+		this.gl.deleteVertexArray(e.vao), this.gl.deleteProgram(e.program);
+	}
+	scissor(e, t, n, r, i, a) {
+		let o = Math.max(0, Math.floor(e)), s = Math.max(0, Math.floor(t)), c = Math.min(i, Math.ceil(n)), l = Math.min(a, Math.ceil(r));
+		if (!(c > o && l > s)) return !1;
+		let u = this.gl;
+		return u.enable(u.SCISSOR_TEST), u.scissor(o, a - l, c - o, l - s), !0;
+	}
+};
+//#endregion
+//#region src/webgl/polygonSpans.ts
+function ee(e) {
+	let t = e.length / 2;
+	if (t < 3) return [];
+	let n = 0, r = 0;
+	for (let i = 1; i < t; i++) e[2 * i] < e[2 * n] && (n = i), e[2 * i] > e[2 * r] && (r = i);
+	if (e[2 * n] === e[2 * r]) return [];
+	let i = b(e, n, r, 1, t), a = b(e, n, r, -1, t);
+	return !i || !a ? null : te(i, a);
+}
+function y(e) {
+	let t = 0, n = e.length / 2;
+	for (let r = 0; r < n; r++) {
+		let i = (r + 1) % n;
+		t += e[2 * r] * e[2 * i + 1] - e[2 * i] * e[2 * r + 1];
+	}
+	return t / 2;
+}
+function b(e, t, n, r, i) {
+	let a = [e[2 * t], e[2 * t + 1]];
+	for (let o = t; o !== n;) {
+		if (o = (o + r + i) % i, e[2 * o] < a[a.length - 2]) return null;
+		a.push(e[2 * o], e[2 * o + 1]);
+	}
+	return a;
+}
+var x = class {
+	i = 0;
+	constructor(e) {
+		this.c = e;
+	}
+	at(e, t) {
+		let n = this.c;
+		for (; this.i + 5 < n.length && (n[this.i + 2] < t || n[this.i + 2] === n[this.i]);) this.i += 2;
+		let r = n[this.i], i = n[this.i + 1], a = n[this.i + 2], o = n[this.i + 3], s = (e) => a === r ? i : i + (o - i) * (e - r) / (a - r);
+		return [s(e), s(t)];
+	}
+};
+function te(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	for (let t = 0; t < e.length; t += 2) n.add(e[t]);
+	for (let e = 0; e < t.length; e += 2) n.add(t[e]);
+	let r = [...n].sort((e, t) => e - t), i = new x(e), a = new x(t), o = [], s = r.length - 2;
+	for (let e = 0; e <= s; e++) {
+		let t = r[e], n = r[e + 1], [c, l] = i.at(t, n), [u, d] = a.at(t, n);
+		c === u && l === d || o.push(t, n, c, l, u, d, +(e === 0), +(e === s));
+	}
+	return o;
+}
+//#endregion
+//#region src/webgl/recordedShaders.ts
+var S = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n", C = "\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n", w = "\n// This fragment's pixel centre in device pixels, y down.\nvec2 pixelCentre() { return vec2(gl_FragCoord.x, u_canvas.y - gl_FragCoord.y); }\n\n// The share of the pixel centred at p inside the clip.\nfloat clipCoverage(vec2 p) {\n  vec2 lo = p - 0.5;\n  vec2 c = clamp(min(lo + 1.0, u_clip.zw) - max(lo, u_clip.xy), 0.0, 1.0);\n  return c.x * c.y;\n}\n", ne = `${S}${C}
+uniform float u_hw;
+in vec4 a_p0;
+in vec4 a_p1;
+in vec4 a_p2;
+in vec4 a_p3;
+in vec4 a_p4;
+in vec4 a_p5;
+flat out vec4 v_p0;
+flat out vec4 v_p1;
+flat out vec4 v_p2;
+flat out vec4 v_p3;
+flat out vec4 v_p4;
+flat out vec4 v_p5;
+
+void main() {
+  v_p0 = a_p0; v_p1 = a_p1; v_p2 = a_p2; v_p3 = a_p3; v_p4 = a_p4; v_p5 = a_p5;
+  if (a_p2.z < 0.5 || a_p3.z < 0.5) { gl_Position = NOWHERE; return; }
+  vec2 a = a_p2.xy;
+  vec2 b = a_p3.xy;
+  vec2 d = b - a;
+  float len = length(d);
+  vec2 dir = len > 0.0 ? d / len : vec2(1.0, 0.0);
+  vec2 n = vec2(-dir.y, dir.x);
+  float m = u_hw + 1.0;
+  vec2 cr = corner(gl_VertexID % 6);
+  vec2 pos = mix(a - dir * m, b + dir * m, cr.x) + n * mix(-m, m, cr.y);
+  gl_Position = toClip(pos);
+}
+`, re = `${S}${w}
+uniform vec4 u_color;
+uniform float u_hw;
+uniform int u_cap;
+uniform vec4 u_dash;
+flat in vec4 v_p0;
+flat in vec4 v_p1;
+flat in vec4 v_p2;
+flat in vec4 v_p3;
+flat in vec4 v_p4;
+flat in vec4 v_p5;
+out vec4 outColor;
+
+float segDist(vec2 p, vec2 a, vec2 b) {
+  vec2 ab = b - a;
+  float l2 = dot(ab, ab);
+  float t = l2 > 0.0 ? clamp(dot(p - a, ab) / l2, 0.0, 1.0) : 0.0;
+  return length(p - a - t * ab);
+}
+
+bool joined(vec4 a, vec4 b) { return a.z > -0.5 && b.z > -0.5; }
+
+// The share of a pixel at distance d from the centre line inside a line hw either side.
+float across(float d) { return clamp(min(u_hw, d + 0.5) - max(-u_hw, d - 0.5), 0.0, 1.0); }
+
+// The share of [s - 0.5, s + 0.5] inside [lo, hi].
+float span(float s, float lo, float hi) { return clamp(min(s + 0.5, hi) - max(s - 0.5, lo), 0.0, 1.0); }
+
+// The share of [s - 0.5, s + 0.5] on a dash.
+float onDash(float s) {
+  float period = u_dash.x + u_dash.y + u_dash.z + u_dash.w;
+  float base = s - mod(s, period);
+  float on = 0.0;
+  for (int k = -1; k <= 1; k++) {
+    float p0 = base + float(k) * period;
+    on += span(s, p0, p0 + u_dash.x);
+    on += span(s, p0 + u_dash.x + u_dash.y, p0 + u_dash.x + u_dash.y + u_dash.z);
+  }
+  return min(on, 1.0);
+}
+
+void main() {
+  vec2 p = pixelCentre();
+  float clipCov = clipCoverage(p);
+  if (clipCov <= 0.0) discard;
+  vec2 a = v_p2.xy;
+  vec2 b = v_p3.xy;
+  vec2 ab = b - a;
+  float len = length(ab);
+  vec2 dir = len > 0.0 ? ab / len : vec2(1.0, 0.0);
+  float along = dot(p - a, dir);
+  float perp = abs(dot(p - a, vec2(-dir.y, dir.x)));
+  bool startEnd = v_p1.z < -0.5;
+  bool finalEnd = v_p4.z < -0.5;
+
+  float cov;
+  if (u_dash.x + u_dash.y > 0.0) {
+    cov = across(perp) * onDash(v_p2.w + along) * span(along, 0.0, len);
+  } else {
+    float self = segDist(p, a, b);
+    float nearest = self;
+    if (joined(v_p0, v_p1)) { float d = segDist(p, v_p0.xy, v_p1.xy); if (d <= self) discard; nearest = min(nearest, d); }
+    if (joined(v_p1, v_p2)) { float d = segDist(p, v_p1.xy, v_p2.xy); if (d <= self) discard; nearest = min(nearest, d); }
+    if (joined(v_p3, v_p4)) { float d = segDist(p, v_p3.xy, v_p4.xy); if (d < self) discard; nearest = min(nearest, d); }
+    if (joined(v_p4, v_p5)) { float d = segDist(p, v_p4.xy, v_p5.xy); if (d < self) discard; nearest = min(nearest, d); }
+    cov = across(nearest);
+    // Past an end of the line: its cap, square-ended (butt or square) or round.
+    float before = startEnd ? -along : -1e9;
+    float after = finalEnd ? along - len : -1e9;
+    if (u_cap != 1 && (before > -0.5 || after > -0.5)) {
+      float reach = u_cap == 2 ? u_hw : 0.0;
+      float lo = startEnd ? -reach : -1e9;
+      float hi = finalEnd ? len + reach : 1e9;
+      cov = across(perp) * span(along, lo, hi);
+    }
+  }
+  if (cov <= 0.0) discard;
+  outColor = u_color * (cov * clipCov);
+}
+`, ie = `${S}${C}
+in vec2 a_x;
+in vec4 a_ab;
+in vec2 a_ends;
+flat out vec2 v_x;
+flat out vec4 v_ab;
+flat out vec2 v_ends;
+
+void main() {
+  v_x = a_x;
+  v_ab = a_ab;
+  v_ends = a_ends;
+  float lo = min(min(a_ab.x, a_ab.y), min(a_ab.z, a_ab.w));
+  float hi = max(max(a_ab.x, a_ab.y), max(a_ab.z, a_ab.w));
+  vec2 cr = corner(gl_VertexID % 6);
+  gl_Position = toClip(mix(vec2(floor(a_x.x), floor(lo) - 1.0), vec2(ceil(a_x.y), ceil(hi) + 1.0), cr));
+}
+`, ae = `${S}${w}
+uniform int u_kind;
+uniform vec4 u_color;
+uniform vec4 u_line;
+uniform vec4 u_offsets;
+uniform int u_stops;
+uniform vec4 u_stop0;
+uniform vec4 u_stop1;
+uniform vec4 u_stop2;
+uniform vec4 u_stop3;
+flat in vec2 v_x;
+flat in vec4 v_ab;
+flat in vec2 v_ends;
+out vec4 outColor;
+
+vec4 stopColor(int i) {
+  if (i == 0) return u_stop0;
+  if (i == 1) return u_stop1;
+  if (i == 2) return u_stop2;
+  return u_stop3;
+}
+
+vec4 gradient(vec2 p) {
+  vec2 g = u_line.zw - u_line.xy;
+  float l2 = dot(g, g);
+  // A gradient of no length paints nothing.
+  if (l2 <= 0.0) return vec4(0.0);
+  float t = dot(p - u_line.xy, g) / l2;
+  vec4 c = stopColor(0);
+  for (int i = 1; i < 4; i++) {
+    if (i >= u_stops) break;
+    float o0 = u_offsets[i - 1];
+    float o1 = u_offsets[i];
+    if (t >= o1) c = stopColor(i);
+    else if (t > o0) { c = mix(stopColor(i - 1), stopColor(i), (t - o0) / max(o1 - o0, 1e-6)); break; }
+    else break;
+  }
+  return vec4(c.rgb * c.a, c.a);
+}
+
+void main() {
+  vec2 p = pixelCentre();
+  float x0 = v_x.x;
+  float x1 = v_x.y;
+  float left = v_ends.x > 0.5 ? clamp(p.x + 0.5 - x0, 0.0, 1.0) : (p.x >= x0 ? 1.0 : 0.0);
+  float right = v_ends.y > 0.5 ? clamp(x1 - (p.x - 0.5), 0.0, 1.0) : (p.x < x1 ? 1.0 : 0.0);
+  float along = v_ends.x > 0.5 && v_ends.y > 0.5
+    ? clamp(min(p.x + 0.5, x1) - max(p.x - 0.5, x0), 0.0, 1.0)
+    : min(left, right);
+  float t = clamp((clamp(p.x, x0, x1) - x0) / max(x1 - x0, 1e-6), 0.0, 1.0);
+  float ya = mix(v_ab.x, v_ab.y, t);
+  float yb = mix(v_ab.z, v_ab.w, t);
+  float across = clamp(min(p.y + 0.5, max(ya, yb)) - max(p.y - 0.5, min(ya, yb)), 0.0, 1.0);
+  float cov = along * across * clipCoverage(p);
+  if (cov <= 0.0) discard;
+  vec4 color = u_kind == 1 ? gradient(p) : u_color;
+  outColor = color * cov;
+}
+`, oe = `${S}${C}
+in vec3 a_disc;
+in vec4 a_color;
+flat out vec3 v_disc;
+flat out vec4 v_color;
+void main() {
+  v_disc = a_disc;
+  v_color = a_color;
+  float m = a_disc.z + 1.0;
+  gl_Position = toClip(mix(a_disc.xy - m, a_disc.xy + m, corner(gl_VertexID % 6)));
+}
+`, se = `${S}${w}
+flat in vec3 v_disc;
+flat in vec4 v_color;
+out vec4 outColor;
+void main() {
+  vec2 p = pixelCentre();
+  float cov = clamp(v_disc.z + 0.5 - length(p - v_disc.xy), 0.0, 1.0) * clipCoverage(p);
+  if (cov <= 0.0) discard;
+  outColor = v_color * cov;
+}
+`, T = 4, E = T * 4, D = 32, O = 7, k = O * 4, A = class {
+	stroke;
+	span;
+	disc;
+	buffer;
+	constructor(e) {
+		this.kit = e, this.stroke = e.program(ne, re, [
+			"a_p0",
+			"a_p1",
+			"a_p2",
+			"a_p3",
+			"a_p4",
+			"a_p5"
+		]), this.span = e.program(ie, ae, [
+			"a_x",
+			"a_ab",
+			"a_ends"
+		]), this.disc = e.program(oe, se, ["a_disc", "a_color"]), this.buffer = e.buffer();
+	}
+	draw(e, t, n, r) {
+		let i = this.kit.gl;
+		i.enable(i.BLEND);
+		for (let a of e) i.blendFunc(i.ONE, i.ONE_MINUS_SRC_ALPHA), i.disable(i.SCISSOR_TEST), a.type === "rects" ? this.drawRects(a.values, r) : a.type === "stroke" ? this.drawStroke(a, t, n) : a.type === "fill" ? this.drawFill(a, t, n) : this.drawDiscs(a.values, a.clip, t, n);
+		i.disable(i.SCISSOR_TEST);
+	}
+	destroy() {
+		for (let e of [
+			this.stroke,
+			this.span,
+			this.disc
+		]) this.kit.deleteProgram(e);
+		this.kit.gl.deleteBuffer(this.buffer);
+	}
+	upload(e) {
+		let t = this.kit.gl;
+		t.bindBuffer(t.ARRAY_BUFFER, this.buffer), t.bufferData(t.ARRAY_BUFFER, e, t.STREAM_DRAW);
+	}
+	common(e, t, n, r) {
+		let i = this.kit;
+		return i.scissor(t.x0, t.y0, t.x1, t.y1, n, r) ? (i.use(e), i.vec2(e, "u_canvas", n, r), i.vec4(e, "u_clip", [
+			t.x0,
+			t.y0,
+			Math.min(t.x1, n),
+			Math.min(t.y1, r)
+		]), !0) : !1;
+	}
+	drawRects(e, t) {
+		let n = e.length / 8, r = new Float32Array(n * 10);
+		for (let t = 0; t < n; t++) for (let n = 0; n < 8; n++) r[t * 10 + n] = e[t * 8 + n];
+		t(r, n);
+	}
+	drawStroke(e, t, n) {
+		let r = this.stroke;
+		if (!this.common(r, e.clip, t, n)) return;
+		let i = this.kit;
+		i.vec4(r, "u_color", e.color), i.float(r, "u_hw", e.width / 2), i.int(r, "u_cap", e.cap), i.vec4(r, "u_dash", e.dash ?? [
+			0,
+			0,
+			0,
+			0
+		]), this.upload(new Float32Array(e.points));
+		for (let e = 0; e < 6; e++) i.attrib(r, `a_p${e}`, 4, E, e * E);
+		let a = e.points.length / T - 5;
+		a > 0 && i.gl.drawArraysInstanced(i.gl.TRIANGLES, 0, 6, a);
+	}
+	drawFill(e, t, n) {
+		let r = this.kit, i = e.bounds;
+		if (!r.scissor(i.x0, i.y0, i.x1, i.y1, t, n)) return;
+		let a = r.use(this.span);
+		r.vec2(a, "u_canvas", t, n), r.vec4(a, "u_clip", [
+			e.clip.x0,
+			e.clip.y0,
+			Math.min(e.clip.x1, t),
+			Math.min(e.clip.y1, n)
+		]), this.upload(new Float32Array(e.spans)), r.attrib(a, "a_x", 2, D, 0), r.attrib(a, "a_ab", 4, D, 8), r.attrib(a, "a_ends", 2, D, 24), this.paint(a, e.paint), r.gl.drawArraysInstanced(r.gl.TRIANGLES, 0, 6, e.spans.length / 8);
+	}
+	paint(e, t) {
+		let n = this.kit;
+		if (t.kind === "solid") {
+			n.int(e, "u_kind", 0), n.vec4(e, "u_color", t.color);
+			return;
+		}
+		n.int(e, "u_kind", 1), n.vec4(e, "u_line", [
+			t.x0,
+			t.y0,
+			t.x1,
+			t.y1
+		]);
+		let r = [
+			0,
+			0,
+			0,
+			0
+		];
+		t.stops.forEach((e, t) => {
+			r[t] = e.offset;
+		}), n.vec4(e, "u_offsets", r), n.int(e, "u_stops", t.stops.length);
+		for (let r = 0; r < 4; r++) n.vec4(e, `u_stop${r}`, (t.stops[r] ?? t.stops[t.stops.length - 1]).color);
+	}
+	drawDiscs(e, t, n, r) {
+		let i = this.disc;
+		this.common(i, t, n, r) && (this.upload(new Float32Array(e)), this.kit.attrib(i, "a_disc", 3, k, 0), this.kit.attrib(i, "a_color", 4, k, 12), this.kit.gl.drawArraysInstanced(this.kit.gl.TRIANGLES, 0, 6, e.length / O));
+	}
+}, j = (e, t) => ({
+	x0: Math.max(e.x0, t.x0),
+	y0: Math.max(e.y0, t.y0),
+	x1: Math.min(e.x1, t.x1),
+	y1: Math.min(e.y1, t.y1)
+}), M = (e) => !(e.x1 > e.x0 && e.y1 > e.y0);
+function N(e, t = 0) {
+	let n = Infinity, r = Infinity, i = -Infinity, a = -Infinity;
+	for (let t = 0; t < e.length; t += 2) {
+		let o = e[t], s = e[t + 1];
+		o < n && (n = o), o > i && (i = o), s < r && (r = s), s > a && (a = s);
+	}
+	return {
+		x0: n - t,
+		y0: r - t,
+		x1: i + t,
+		y1: a + t
+	};
+}
+function P(e) {
+	let t = [...e].sort((e, t) => e.x0 - t.x0), n = [];
+	for (let e of t) {
+		for (let t = n.length - 1; t >= 0; t--) n[t].x1 <= e.x0 && n.splice(t, 1);
+		for (let t of n) if (t.y0 < e.y1 && e.y0 < t.y1) return !0;
+		n.push(e);
+	}
+	return !1;
+}
+//#endregion
+//#region src/webgl/recordedPath.ts
+var F = class {
+	stops = [];
+	constructor(e, t, n, r) {
+		this.x0 = e, this.y0 = t, this.x1 = n, this.y1 = r;
+	}
+	addColorStop(e, t) {
+		if (!(e >= 0 && e <= 1)) throw RangeError("offset out of range");
+		this.stops.push({
+			offset: e,
+			color: t
+		});
+	}
+}, I = typeof Path2D == "function" ? Path2D : class {}, L = class e extends I {
+	calls = [];
+	unsupported = !1;
+	constructor(t) {
+		super(t), t instanceof e ? (this.calls.push(...t.calls), this.unsupported = t.unsupported) : t !== void 0 && (this.unsupported = !0);
+	}
+	note(e, t, n = t) {
+		this.calls.push([e, t]), I.prototype[e]?.apply(this, n);
+	}
+	unfollowed(e, t) {
+		this.unsupported = !0, this.note(e, [], t);
+	}
+	moveTo(e, t) {
+		this.note("moveTo", [e, t]);
+	}
+	lineTo(e, t) {
+		this.note("lineTo", [e, t]);
+	}
+	closePath() {
+		this.note("closePath", []);
+	}
+	rect(e, t, n, r) {
+		this.note("rect", [
+			e,
+			t,
+			n,
+			r
+		]);
+	}
+	arc(e, t, n, r, i, a) {
+		this.note("arc", [
+			e,
+			t,
+			n,
+			r,
+			i,
+			+!!a
+		]);
+	}
+	quadraticCurveTo(e, t, n, r) {
+		this.note("quadraticCurveTo", [
+			e,
+			t,
+			n,
+			r
+		]);
+	}
+	bezierCurveTo(e, t, n, r, i, a) {
+		this.note("bezierCurveTo", [
+			e,
+			t,
+			n,
+			r,
+			i,
+			a
+		]);
+	}
+	arcTo(...e) {
+		this.unfollowed("arcTo", e);
+	}
+	ellipse(...e) {
+		this.unfollowed("ellipse", e);
+	}
+	roundRect(...e) {
+		this.unfollowed("roundRect", e);
+	}
+	addPath(t, n) {
+		!(t instanceof e) || n !== void 0 ? this.unsupported = !0 : (this.calls.push(...t.calls), this.unsupported ||= t.unsupported), I.prototype.addPath?.call(this, t, n);
+	}
+};
+function ce(e) {
+	let t = globalThis, n = Object.prototype.hasOwnProperty.call(t, "Path2D"), r = t.Path2D;
+	t.Path2D = L;
+	try {
+		e();
+	} finally {
+		n ? t.Path2D = r : delete t.Path2D;
+	}
+}
+//#endregion
+//#region src/webgl/strokeGeometry.ts
+var le = .25;
+function ue(e, t, n, r) {
+	if (n === "round") return !1;
+	let i = e.points, a = i.length / 2, o = +!e.closed, s = e.closed ? a : a - 1;
+	for (let e = o; e < s; e++) {
+		let o = (e - 1 + a) % a, s = (e + 1) % a, c = i[2 * e] - i[2 * o], l = i[2 * e + 1] - i[2 * o + 1], u = i[2 * s] - i[2 * e], d = i[2 * s + 1] - i[2 * e + 1], f = Math.hypot(c, l), p = Math.hypot(u, d);
+		if (f === 0 || p === 0) continue;
+		let m = Math.max(-1, Math.min(1, (c * u + l * d) / (f * p))), h = Math.sqrt((1 + m) / 2);
+		if ((n === "miter" && h > 0 && 1 / h <= r ? t * (1 / h - 1) : t * (1 - h)) > le) return !0;
+	}
+	return !1;
+}
+function de(e, t) {
+	let n = e.points;
+	for (let e = 2; e < n.length; e += 2) if (Math.hypot(n[e] - n[e - 2], n[e + 1] - n[e - 1]) < t) return !0;
+	return !1;
+}
+function fe(e) {
+	let t = [], n = () => t.push(0, 0, -1, 0);
+	n(), n();
+	for (let { points: r, closed: i } of e) {
+		let e = r.length / 2, a = i && e >= 3;
+		a && t.push(r[2 * (e - 2)], r[2 * (e - 2) + 1], 0, 0, r[2 * (e - 1)], r[2 * (e - 1) + 1], 0, 0);
+		let o = 0;
+		for (let n = 0; n < e; n++) n > 0 && (o += Math.hypot(r[2 * n] - r[2 * n - 2], r[2 * n + 1] - r[2 * n - 1])), t.push(r[2 * n], r[2 * n + 1], 1, o);
+		a && (o += Math.hypot(r[0] - r[2 * (e - 1)], r[1] - r[2 * (e - 1) + 1]), t.push(r[0], r[1], 1, o), t.push(r[2], r[3], 0, 0, r[4], r[5], 0, 0)), n();
+	}
+	return n(), t;
+}
+//#endregion
+//#region src/webgl/recorder.ts
+var R = Math.PI * 2;
+function pe(e, t) {
+	let n = 2 * Math.sqrt(Math.max(.2 / Math.max(e, .1), 1e-6));
+	return Math.min(512, Math.max(4, Math.ceil(Math.abs(t) / Math.min(n, Math.PI / 4))));
+}
+var z = new Set([
+	"fillStyle",
+	"strokeStyle",
+	"lineWidth",
+	"lineCap",
+	"lineJoin",
+	"miterLimit",
+	"globalAlpha",
+	"globalCompositeOperation",
+	"lineDashOffset",
+	"font",
+	"textAlign",
+	"textBaseline",
+	"direction",
+	"shadowBlur",
+	"shadowColor",
+	"shadowOffsetX",
+	"shadowOffsetY",
+	"filter"
+]), B = new Set([
+	"fontKerning",
+	"fontStretch",
+	"fontVariantCaps",
+	"letterSpacing",
+	"wordSpacing",
+	"textRendering"
+]), V = new Set(["imageSmoothingEnabled", "imageSmoothingQuality"]), H = (e) => !!(e.rect || e.circle) || e.points.length >= 6, U = class {
+	commands = [];
+	ctx;
+	texts = [];
+	state;
+	stack = [];
+	path = [];
+	ok = !0;
+	constructor(e, t) {
+		this.dpr = e, this.measure = t, this.reset({
+			x0: 0,
+			y0: 0,
+			x1: Infinity,
+			y1: Infinity
+		}), this.ctx = this.proxy();
+	}
+	region(e) {
+		let t = this.dpr, n = {
+			x0: e.x * t,
+			y0: e.y * t,
+			x1: (e.x + e.width) * t,
+			y1: (e.y + e.height) * t
+		}, r = [];
+		return {
+			step: (e) => {
+				this.reset(n), this.texts = r;
+				let t = {
+					commands: this.commands.length,
+					texts: r.length
+				};
+				this.ok = !0;
+				try {
+					ce(() => e(this.ctx));
+				} catch {
+					this.ok = !1;
+				}
+				return this.ok ? !0 : (this.commands.length = t.commands, r.length = t.texts, !1);
+			},
+			drawText: (e) => me(e, r)
+		};
+	}
+	reset(e) {
+		this.state = {
+			fillStyle: "#000000",
+			strokeStyle: "#000000",
+			lineWidth: 1,
+			lineCap: "butt",
+			lineJoin: "miter",
+			miterLimit: 10,
+			globalAlpha: 1,
+			globalCompositeOperation: "source-over",
+			lineDash: [],
+			lineDashOffset: 0,
+			font: "10px sans-serif",
+			textAlign: "start",
+			textBaseline: "alphabetic",
+			direction: "inherit",
+			shadowBlur: 0,
+			shadowColor: "rgba(0, 0, 0, 0)",
+			shadowOffsetX: 0,
+			shadowOffsetY: 0,
+			filter: "none",
+			textExtras: {},
+			transform: [
+				this.dpr,
+				0,
+				0,
+				this.dpr,
+				0,
+				0
+			],
+			clip: e
+		}, this.stack = [], this.path = [];
+	}
+	unsupported() {
+		this.ok = !1;
+	}
+	copyState() {
+		let e = this.state;
+		return {
+			...e,
+			lineDash: [...e.lineDash],
+			textExtras: { ...e.textExtras }
+		};
+	}
+	axisAligned() {
+		let e = this.state.transform;
+		return e[1] === 0 && e[2] === 0;
+	}
+	uniform() {
+		let e = this.state.transform;
+		return this.axisAligned() && Math.abs(e[0]) === Math.abs(e[3]);
+	}
+	setMatrix(e) {
+		e.every(Number.isFinite) && (this.state.transform = e);
+	}
+	multiply(e, t, n, r, i, a) {
+		let [o, s, c, l, u, d] = this.state.transform;
+		this.setMatrix([
+			o * e + c * t,
+			s * e + l * t,
+			o * n + c * r,
+			s * n + l * r,
+			o * i + c * a + u,
+			s * i + l * a + d
+		]);
+	}
+	current() {
+		return this.path[this.path.length - 1];
+	}
+	moveTo(e, t) {
+		if (!Number.isFinite(e) || !Number.isFinite(t)) return;
+		let n = this.state.transform;
+		this.path.push({
+			points: [n[0] * e + n[2] * t + n[4], n[1] * e + n[3] * t + n[5]],
+			closed: !1
+		});
+	}
+	lineTo(e, t) {
+		if (!Number.isFinite(e) || !Number.isFinite(t)) return;
+		let n = this.current();
+		if (!n || n.closed) return this.moveTo(e, t);
+		let r = this.state.transform;
+		n.points.push(r[0] * e + r[2] * t + r[4], r[1] * e + r[3] * t + r[5]), n.rect = void 0, n.circle = void 0;
+	}
+	closePath() {
+		let e = this.current();
+		!e || e.closed || (e.closed = !0, this.path.push({
+			points: [e.points[0], e.points[1]],
+			closed: !1
+		}));
+	}
+	rect(e, t, n, r) {
+		if (![
+			e,
+			t,
+			n,
+			r
+		].every(Number.isFinite)) return;
+		let i = this.state.transform, a = i[0] * e + i[2] * t + i[4], o = i[1] * e + i[3] * t + i[5], s = i[0] * (e + n) + i[2] * t + i[4], c = i[1] * (e + n) + i[3] * t + i[5], l = i[0] * (e + n) + i[2] * (t + r) + i[4], u = i[1] * (e + n) + i[3] * (t + r) + i[5], d = {
+			points: [
+				a,
+				o,
+				s,
+				c,
+				l,
+				u,
+				i[0] * e + i[2] * (t + r) + i[4],
+				i[1] * e + i[3] * (t + r) + i[5]
+			],
+			closed: !0
+		};
+		this.axisAligned() && (d.rect = {
+			x0: Math.min(a, l),
+			y0: Math.min(o, u),
+			x1: Math.max(a, l),
+			y1: Math.max(o, u)
+		}), this.path.push(d), this.path.push({
+			points: [a, o],
+			closed: !1
+		});
+	}
+	arc(e, t, n, r, i, a = !1) {
+		if (![
+			e,
+			t,
+			n,
+			r,
+			i
+		].every(Number.isFinite)) return;
+		if (n < 0) throw new DOMException("negative radius", "IndexSizeError");
+		let o = i - r;
+		o = !a && o >= R ? R : a && -o >= R ? -R : a ? -(((r - i) % R + R) % R) : (o % R + R) % R;
+		let s = this.current(), c = this.state.transform, l = e + n * Math.cos(r), u = t + n * Math.sin(r), d = !s || s.closed || s.points.length === 2 && Math.abs(s.points[0] - (c[0] * l + c[2] * u + c[4])) < 1e-6 && Math.abs(s.points[1] - (c[1] * l + c[3] * u + c[5])) < 1e-6, f = pe(n * Math.abs(c[0]), o);
+		for (let i = 0; i <= f; i++) {
+			let a = r + o * i / f;
+			this.lineTo(e + n * Math.cos(a), t + n * Math.sin(a));
+		}
+		let p = this.current();
+		Math.abs(o) >= R - 1e-9 && d && this.uniform() && p && (p.circle = {
+			x: c[0] * e + c[4],
+			y: c[3] * t + c[5],
+			r: n * Math.abs(c[0])
+		});
+	}
+	curve(e, t) {
+		(!this.current() || this.current().closed) && this.moveTo(e[0], e[1]);
+		let n = this.current(), r = this.state.transform;
+		if (!n || !this.axisAligned() || r[0] === 0 || r[3] === 0) return this.unsupported();
+		let i = [
+			(n.points[n.points.length - 2] - r[4]) / r[0],
+			(n.points[n.points.length - 1] - r[5]) / r[3],
+			...e,
+			...t
+		], a = 0;
+		for (let e = 2; e < i.length; e += 2) a += Math.hypot((i[e] - i[e - 2]) * r[0], (i[e + 1] - i[e - 1]) * r[3]);
+		let o = Math.max(4, Math.min(64, Math.ceil(a / 3)));
+		for (let e = 1; e <= o; e++) {
+			let t = e / o, n = i.length === 6 ? [
+				(1 - t) ** 2,
+				2 * t * (1 - t),
+				t * t
+			] : [
+				(1 - t) ** 3,
+				3 * t * (1 - t) ** 2,
+				3 * t * t * (1 - t),
+				t ** 3
+			], r = 0, a = 0;
+			n.forEach((e, t) => {
+				r += e * i[2 * t], a += e * i[2 * t + 1];
+			}), this.lineTo(r, a);
+		}
+	}
+	withPath(e, t) {
+		let n = this.path;
+		this.path = [], e(), t(), this.path = n;
+	}
+	onPath(e, t) {
+		if (!(e instanceof L) || e.unsupported) return this.unsupported();
+		this.withPath(() => {
+			for (let [t, n] of e.calls) t === "moveTo" ? this.moveTo(n[0], n[1]) : t === "lineTo" ? this.lineTo(n[0], n[1]) : t === "closePath" ? this.closePath() : t === "rect" ? this.rect(n[0], n[1], n[2], n[3]) : t === "arc" ? this.arc(n[0], n[1], n[2], n[3], n[4], !!n[5]) : t === "quadraticCurveTo" ? this.curve([n[0], n[1]], [n[2], n[3]]) : t === "bezierCurveTo" && this.curve([
+				n[0],
+				n[1],
+				n[2],
+				n[3]
+			], [n[4], n[5]]);
+		}, t);
+	}
+	paint(e) {
+		let t = Math.max(0, Math.min(1, this.state.globalAlpha));
+		if (typeof e == "string") {
+			let n = g(h(e));
+			return {
+				kind: "solid",
+				color: [
+					n[0] * t,
+					n[1] * t,
+					n[2] * t,
+					n[3] * t
+				]
+			};
+		}
+		if (!(e instanceof F)) return null;
+		if (e.stops.length === 0) return {
+			kind: "solid",
+			color: [
+				0,
+				0,
+				0,
+				0
+			]
+		};
+		if (e.stops.length > 4) return null;
+		let n = this.state.transform, r = e.x0 === e.x1 || e.y0 === e.y1;
+		if (!this.axisAligned() || !this.uniform() && !r) return null;
+		let i = [...e.stops].sort((e, t) => e.offset - t.offset).map((e) => {
+			let n = h(e.color);
+			return {
+				offset: e.offset,
+				color: [
+					n[0],
+					n[1],
+					n[2],
+					n[3] * t
+				]
+			};
+		});
+		return {
+			kind: "linear",
+			x0: n[0] * e.x0 + n[4],
+			y0: n[3] * e.y0 + n[5],
+			x1: n[0] * e.x1 + n[4],
+			y1: n[3] * e.y1 + n[5],
+			stops: i
+		};
+	}
+	plain() {
+		let e = this.state;
+		return e.globalCompositeOperation !== "source-over" || e.filter !== "none" ? !1 : !(h(e.shadowColor)[3] > 0 && (e.shadowBlur > 0 || e.shadowOffsetX !== 0 || e.shadowOffsetY !== 0));
+	}
+	fill(e = "nonzero") {
+		if (!this.plain()) return this.unsupported();
+		let t = this.paint(this.state.fillStyle);
+		if (!t) return this.unsupported();
+		let n = this.path.filter(H);
+		if (n.length === 0 || t.kind === "solid" && t.color[3] === 0) return;
+		if (n.length > 1 && P(n.map((e) => N(e.points)))) {
+			let r = t.kind === "solid" && t.color[3] >= 1, i = Math.sign(y(n[0].points));
+			if (!r || e !== "nonzero" || n.some((e) => Math.sign(y(e.points)) !== i)) return this.unsupported();
+		}
+		if (t.kind === "solid" && n.every((e) => e.rect)) return this.fillRects(n, t.color);
+		if (t.kind === "solid" && n.every((e) => e.circle)) {
+			let e = [];
+			for (let r of n) e.push(r.circle.x, r.circle.y, r.circle.r, ...t.color);
+			this.commands.push({
+				type: "circles",
+				values: e,
+				clip: this.state.clip
+			});
+			return;
+		}
+		let r = [];
+		for (let e of n) {
+			let t = ee(e.points);
+			if (!t) return this.unsupported();
+			for (let e of t) r.push(e);
+		}
+		let i = N(n.flatMap((e) => e.points)), a = j({
+			x0: Math.floor(i.x0),
+			y0: Math.floor(i.y0),
+			x1: Math.ceil(i.x1),
+			y1: Math.ceil(i.y1)
+		}, this.state.clip);
+		r.length > 0 && !M(a) && this.commands.push({
+			type: "fill",
+			spans: r,
+			bounds: a,
+			paint: t,
+			clip: this.state.clip
+		});
+	}
+	fillRects(e, t) {
+		let n = [];
+		for (let r of e) {
+			let e = j(r.rect, this.state.clip);
+			M(e) || n.push(e.x0, e.y0, e.x1, e.y1, t[0], t[1], t[2], t[3]);
+		}
+		n.length && this.commands.push({
+			type: "rects",
+			values: n
+		});
+	}
+	stroke() {
+		if (!this.plain()) return this.unsupported();
+		let e = this.paint(this.state.strokeStyle);
+		if (!e || e.kind !== "solid" || !this.uniform()) return this.unsupported();
+		if (e.color[3] === 0) return;
+		let t = this.state, n = Math.abs(t.transform[0]), r = t.lineWidth * n, i = this.path.filter((e) => e.points.length >= 4 && (t.lineCap !== "butt" || e.points.some((t, n) => t !== e.points[n % 2])));
+		if (i.length === 0) return;
+		let a = this.dash(i, n);
+		if (a === void 0 || !this.drawsAlike(i, r, e.color[3])) return this.unsupported();
+		let o = t.lineCap === "round" ? 1 : t.lineCap === "square" ? 2 : 0;
+		this.commands.push({
+			type: "stroke",
+			points: fe(i),
+			color: e.color,
+			width: r,
+			cap: o,
+			dash: a,
+			clip: t.clip
+		});
+	}
+	dash(e, t) {
+		let n = this.state;
+		if (n.lineDash.length === 0) return null;
+		if (n.lineDash.length > 4 || n.lineDashOffset !== 0 || n.lineCap !== "butt" || e.some((e) => e.closed || e.points.length !== 4)) return;
+		let r = n.lineDash.map((e) => e * t);
+		for (; r.length < 4;) r.push(...r.slice(0, 4 - r.length));
+		return r;
+	}
+	drawsAlike(e, t, n) {
+		let r = this.state, i = t / 2;
+		if (t > 1 && e.some((e) => ue(e, i, r.lineJoin, r.miterLimit))) return !1;
+		let a = i + (r.lineCap === "butt" ? 0 : i);
+		return !(e.length > 1 && P(e.map((e) => N(e.points, a))) || n < 1 && e.some((e) => de(e, t)));
+	}
+	clip() {
+		let e = this.path.filter(H);
+		if (e.length !== 1 || !e[0].rect) return this.unsupported();
+		this.state.clip = j(this.state.clip, e[0].rect);
+	}
+	text(e, t, n, r, i) {
+		if (typeof (e ? this.state.strokeStyle : this.state.fillStyle) != "string" || !this.plain()) return this.unsupported();
+		this.texts.push({
+			stroke: e,
+			text: String(t),
+			x: n,
+			y: r,
+			maxWidth: i,
+			state: this.copyState()
+		});
+	}
+	measureText(e) {
+		let t = this.measure;
+		if (!t) return { width: String(e).length * 6 };
+		let n = t.font;
+		t.font = this.state.font;
+		let r = t.measureText(e);
+		return t.font = n, r;
+	}
+	methods() {
+		let e = () => this.state, t = Object.create(null);
+		return Object.assign(t, {
+			save: () => {
+				this.stack.push(this.copyState());
+			},
+			restore: () => {
+				let e = this.stack.pop();
+				e && (this.state = e);
+			},
+			beginPath: () => {
+				this.path = [];
+			},
+			moveTo: (e, t) => this.moveTo(e, t),
+			lineTo: (e, t) => this.lineTo(e, t),
+			closePath: () => this.closePath(),
+			rect: (e, t, n, r) => this.rect(e, t, n, r),
+			arc: (e, t, n, r, i, a) => this.arc(e, t, n, r, i, a),
+			quadraticCurveTo: (e, t, n, r) => this.curve([e, t], [n, r]),
+			bezierCurveTo: (e, t, n, r, i, a) => this.curve([
+				e,
+				t,
+				n,
+				r
+			], [i, a]),
+			fill: (e, t) => typeof e == "object" ? this.onPath(e, () => this.fill(t)) : this.fill(e),
+			stroke: (e) => e ? this.onPath(e, () => this.stroke()) : this.stroke(),
+			clip: (e) => typeof e == "object" ? this.onPath(e, () => this.clip()) : this.clip(),
+			fillRect: (e, t, n, r) => this.withPath(() => this.rect(e, t, n, r), () => this.fill()),
+			strokeRect: (e, t, n, r) => this.withPath(() => this.rect(e, t, n, r), () => this.stroke()),
+			fillText: (e, t, n, r) => this.text(!1, e, t, n, r),
+			strokeText: (e, t, n, r) => this.text(!0, e, t, n, r),
+			measureText: (e) => this.measureText(e),
+			setLineDash: (t) => {
+				t.every((e) => Number.isFinite(e) && e >= 0) && (e().lineDash = t.length % 2 ? [...t, ...t] : [...t]);
+			},
+			getLineDash: () => [...e().lineDash],
+			translate: (e, t) => this.multiply(1, 0, 0, 1, e, t),
+			scale: (e, t) => this.multiply(e, 0, 0, t, 0, 0),
+			rotate: (e) => this.multiply(Math.cos(e), Math.sin(e), -Math.sin(e), Math.cos(e), 0, 0),
+			transform: (e, t, n, r, i, a) => this.multiply(e, t, n, r, i, a),
+			setTransform: (e, t, n, r, i, a) => typeof e == "number" ? this.setMatrix([
+				e,
+				t ?? 0,
+				n ?? 0,
+				r ?? 1,
+				i ?? 0,
+				a ?? 0
+			]) : this.unsupported(),
+			resetTransform: () => this.setMatrix([
+				1,
+				0,
+				0,
+				1,
+				0,
+				0
+			]),
+			getTransform: () => {
+				let [t, n, r, i, a, o] = e().transform;
+				return {
+					a: t,
+					b: n,
+					c: r,
+					d: i,
+					e: a,
+					f: o,
+					m11: t,
+					m12: n,
+					m21: r,
+					m22: i,
+					m41: a,
+					m42: o,
+					is2D: !0,
+					isIdentity: t === 1 && n === 0 && r === 0 && i === 1 && a === 0 && o === 0
+				};
+			},
+			createLinearGradient: (e, t, n, r) => new F(e, t, n, r)
+		}), t;
+	}
+	proxy() {
+		let e = this.methods();
+		return new Proxy({}, {
+			get: (t, n) => {
+				if (typeof n == "string") {
+					if (n in e) return e[n];
+					if (z.has(n)) return this.state[n];
+					if (B.has(n)) return this.state.textExtras[n];
+					if (n === "canvas") return this.measure?.canvas;
+					if (!V.has(n)) return this.unsupported(), () => void 0;
+				}
+			},
+			set: (e, t, n) => (typeof t == "string" && this.setProp(t, n), !0)
+		});
+	}
+	setProp(e, t) {
+		let n = this.state;
+		e === "lineWidth" || e === "miterLimit" ? typeof t == "number" && Number.isFinite(t) && t > 0 && (n[e] = t) : e === "globalAlpha" ? typeof t == "number" && Number.isFinite(t) && t >= 0 && t <= 1 && (n.globalAlpha = t) : e === "fillStyle" || e === "strokeStyle" ? t instanceof F ? n[e] = t : typeof t == "string" ? m(t) && (n[e] = t) : this.unsupported() : z.has(e) ? n[e] = t : B.has(e) ? this.state.textExtras[e] = t : V.has(e) || this.unsupported();
+	}
+};
+function me(e, t) {
+	for (let n of t) {
+		let t = n.state;
+		if (M(t.clip)) continue;
+		e.save(), e.setTransform(1, 0, 0, 1, 0, 0), Number.isFinite(t.clip.x1) && Number.isFinite(t.clip.y1) && (e.beginPath(), e.rect(t.clip.x0, t.clip.y0, t.clip.x1 - t.clip.x0, t.clip.y1 - t.clip.y0), e.clip());
+		let [r, i, a, o, s, c] = t.transform;
+		e.setTransform(r, i, a, o, s, c), e.font = t.font, e.textAlign = t.textAlign, e.textBaseline = t.textBaseline, e.direction = t.direction, e.globalAlpha = t.globalAlpha, Object.assign(e, t.textExtras), n.stroke ? (e.strokeStyle = t.strokeStyle, e.lineWidth = t.lineWidth, e.strokeText(n.text, n.x, n.y, n.maxWidth)) : (e.fillStyle = t.fillStyle, e.fillText(n.text, n.x, n.y, n.maxWidth)), e.restore();
+	}
+}
+function he(e, t) {
+	return new U(e, t);
+}
+//#endregion
+//#region src/webgl/shaders.ts
+var W = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n", ge = `${W}
+in vec4 a_ohlc;
+in vec2 a_vd;
+uniform float u_x0;
+uniform float u_unit;
+uniform float u_wick;
+uniform float u_body;
+uniform vec4 u_upBody;
+uniform vec4 u_downBody;
+uniform vec4 u_upWick;
+uniform vec4 u_downWick;
+
+void main() {
+  int vid = gl_VertexID % 12;
+  vec2 cr = corner(vid % 6);
+  bool up = a_vd.y > 0.5;
+  float cx = (u_x0 + float(gl_InstanceID) * u_unit) * u_dpr;
+  float wickLeft = snap(cx - u_wick * 0.5);
+  float left;
+  float width;
+  float top;
+  float height;
+  if (vid < 6) {
+    float h = snap(cssY(a_ohlc.y) * u_dpr);
+    float l = snap(cssY(a_ohlc.z) * u_dpr);
+    left = wickLeft;
+    width = u_wick;
+    top = min(h, l);
+    height = max(abs(l - h), 1.0);
+    v_color = up ? u_upWick : u_downWick;
+  } else {
+    float o = snap(cssY(a_ohlc.x) * u_dpr);
+    float c = snap(cssY(a_ohlc.w) * u_dpr);
+    left = wickLeft - (u_body - u_wick) * 0.5;
+    width = u_body;
+    top = min(o, c);
+    height = max(abs(c - o), u_wick);
+    v_color = up ? u_upBody : u_downBody;
+  }
+  gl_Position = toClip(vec2(left + cr.x * width, top + cr.y * height));
+}
+`, _e = `${W}
+in vec4 a_ohlc;
+in vec2 a_vd;
+uniform float u_x0;
+uniform float u_unit;
+uniform float u_wick;
+uniform float u_body;
+uniform float u_volBottom;
+uniform float u_volScale;
+uniform vec4 u_volUp;
+uniform vec4 u_volDown;
+
+void main() {
+  vec2 cr = corner(gl_VertexID % 6);
+  float cx = (u_x0 + float(gl_InstanceID) * u_unit) * u_dpr;
+  float left = snap(cx - u_wick * 0.5) - (u_body - u_wick) * 0.5;
+  float bottom = snap(u_volBottom * u_dpr);
+  float top = snap((u_volBottom - a_vd.x * u_volScale) * u_dpr);
+  if (bottom - top < 1.0) { gl_Position = NOWHERE; v_color = vec4(0.0); return; }
+  v_color = a_vd.y > 0.5 ? u_volUp : u_volDown;
+  gl_Position = toClip(vec2(left + cr.x * u_body, top + cr.y * (bottom - top)));
+}
+`, ve = `${W}
+in vec4 a_col;
+in float a_up;
+uniform vec4 u_upBody;
+uniform vec4 u_downBody;
+
+void main() {
+  vec2 cr = corner(gl_VertexID % 6);
+  float left = snap(a_col.x * u_dpr);
+  float width = max(1.0, snap((a_col.x + 1.0) * u_dpr) - left);
+  float t = snap(cssY(a_col.y) * u_dpr);
+  float b = snap(cssY(a_col.z) * u_dpr);
+  v_color = a_up > 0.5 ? u_upBody : u_downBody;
+  gl_Position = toClip(vec2(left + cr.x * width, min(t, b) + cr.y * max(abs(b - t), 1.0)));
+}
+`, ye = `${W}
+in vec4 a_col;
+in float a_up;
+uniform float u_volBottom;
+uniform float u_volScale;
+uniform vec4 u_volUp;
+uniform vec4 u_volDown;
+
+void main() {
+  vec2 cr = corner(gl_VertexID % 6);
+  float left = snap(a_col.x * u_dpr);
+  float width = max(1.0, snap((a_col.x + 1.0) * u_dpr) - left);
+  float bottom = snap(u_volBottom * u_dpr);
+  float top = snap((u_volBottom - a_col.w * u_volScale) * u_dpr);
+  if (bottom - top < 1.0) { gl_Position = NOWHERE; v_color = vec4(0.0); return; }
+  v_color = a_up > 0.5 ? u_volUp : u_volDown;
+  gl_Position = toClip(vec2(left + cr.x * width, top + cr.y * (bottom - top)));
+}
+`, be = `${W}
+in vec4 a_rect;
+in vec4 a_color;
+in vec2 a_dash;
+flat out vec4 v_rect;
+flat out vec2 v_dash;
+
+void main() {
+  vec2 cr = corner(gl_VertexID % 6);
+  v_rect = a_rect * u_dpr;
+  v_dash = a_dash * u_dpr;
+  v_color = a_color;
+  gl_Position = toClip(mix(floor(v_rect.xy), ceil(v_rect.zw), cr));
+}
+`, xe = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform int u_union;\nin vec4 v_color;\nflat in vec4 v_rect;\nflat in vec2 v_dash;\nout vec4 outColor;\n\n// The share of rows [y, y + 1] inside the rectangle and, dashed, on a dash.\nfloat rows(float y) {\n  float lo = max(y, v_rect.y);\n  float hi = min(y + 1.0, v_rect.w);\n  if (hi <= lo) return 0.0;\n  if (v_dash.x <= 0.0) return hi - lo;\n  // A dash period is longer than a device pixel, so the row meets the dash\n  // of the period it starts in and the next (a third to spare).\n  float period = v_dash.x + v_dash.y;\n  float first = v_rect.y + floor((lo - v_rect.y) / period) * period;\n  float on = 0.0;\n  for (int i = 0; i < 3; i++) {\n    float start = first + float(i) * period;\n    on += max(0.0, min(hi, start + v_dash.x) - max(lo, start));\n  }\n  return on;\n}\n\nvoid main() {\n  // This pixel's top-left corner in device pixels, y down.\n  vec2 p = vec2(floor(gl_FragCoord.x), u_canvas.y - floor(gl_FragCoord.y) - 1.0);\n  float coverage = clamp(min(p.x + 1.0, v_rect.z) - max(p.x, v_rect.x), 0.0, 1.0) * rows(p.y);\n  outColor = u_union == 1 ? vec4(v_color.rgb * coverage, coverage) : v_color * coverage;\n}\n", G = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\nin vec4 v_color;\nout vec4 outColor;\n\nvoid main() {\n  vec2 p = vec2(floor(gl_FragCoord.x), u_canvas.y - floor(gl_FragCoord.y) - 1.0);\n  vec2 c = clamp(min(p + 1.0, u_clip.zw) - max(p, u_clip.xy), 0.0, 1.0);\n  outColor = v_color * (c.x * c.y);\n}\n", K = 24, q = 5, J = q * 4, Y = 10, X = Y * 4, Z = [
+	"a_ohlc",
+	"a_vd",
+	"a_col",
+	"a_up",
+	"a_rect",
+	"a_color",
+	"a_dash"
+], Se = class a {
+	label;
+	gl;
+	kit;
+	drawer;
+	candleBars;
+	volumeBars;
+	candleColumns;
+	volumeColumns;
+	rects;
+	seriesBuffer;
+	columnBuffer;
+	rectBuffer;
+	uploads = new o();
+	gpuFloats = 0;
+	columns = new Float32Array(4096 * q);
+	rectValues = new Float32Array(64 * Y);
+	clip = [
+		0,
+		0,
+		0,
+		0
+	];
+	lost = !1;
+	lostCallback = null;
+	static create(e = {}) {
+		if (typeof document > "u") return null;
+		let t = document.createElement("canvas"), n = null;
+		try {
+			n = t.getContext("webgl2", {
+				alpha: !0,
+				premultipliedAlpha: !0,
+				antialias: !1,
+				depth: !1,
+				stencil: !1,
+				preserveDrawingBuffer: !1,
+				failIfMajorPerformanceCaveat: e.failIfMajorPerformanceCaveat ?? !1
+			});
+		} catch (e) {
+			return $(e), null;
+		}
+		if (!n) return null;
+		try {
+			return new a(t, n);
+		} catch (e) {
+			return $(e), Q(n), null;
+		}
+	}
+	constructor(e, t) {
+		this.canvas = e, this.gl = t, this.kit = new v(t);
+		let n = t.getExtension("WEBGL_debug_renderer_info");
+		this.label = String(n ? t.getParameter(n.UNMASKED_RENDERER_WEBGL) : t.getParameter(t.RENDERER));
+		let r = this.kit;
+		this.candleBars = r.program(ge, G, Z), this.volumeBars = r.program(_e, G, Z), this.candleColumns = r.program(ve, G, Z), this.volumeColumns = r.program(ye, G, Z), this.rects = r.program(be, xe, Z), this.seriesBuffer = r.buffer(), this.columnBuffer = r.buffer(), this.rectBuffer = r.buffer(), this.drawer = new A(r), e.addEventListener("webglcontextlost", this.handleLost);
+	}
+	onLost(e) {
+		this.lostCallback = e, (this.lost || this.gl.isContextLost()) && (this.lost = !0, queueMicrotask(() => {
+			this.lostCallback === e && e();
+		}));
+	}
+	recorder(e, t) {
+		return he(e, t);
+	}
+	render(e) {
+		let t = this.gl;
+		if (this.lost || t.isContextLost()) return {
+			series: !1,
+			volume: !1,
+			background: !1,
+			recorded: !1
+		};
+		let n = Ce(e.recorded) ? e.recorded : null, r = {
+			series: e.candles,
+			volume: e.volume !== null,
+			background: e.background !== null,
+			recorded: n !== null
+		};
+		return t.viewport(0, 0, this.canvas.width, this.canvas.height), t.disable(t.SCISSOR_TEST), t.clearColor(0, 0, 0, 0), t.clear(t.COLOR_BUFFER_BIT), t.enable(t.BLEND), e.background && this.drawBackground(e, e.background), this.drawSeries(e), n && n.commands.length > 0 && this.drawer.draw(n.commands, this.canvas.width, this.canvas.height, (t, n) => this.drawRecordedRects(e, t, n)), r;
+	}
+	drawSeries(t) {
+		let n = this.gl, { data: r, viewport: i, dpr: a } = t;
+		if (r.length === 0 || !t.candles && !t.volume) return;
+		this.syncSeries(t);
+		let o = Math.max(0, i.visibleRange.from), s = Math.min(i.visibleRange.to, r.length - 1);
+		if (s < o) return;
+		let { chartRect: c } = i;
+		this.clip = [
+			c.x * a,
+			c.y * a,
+			(c.x + c.width) * a,
+			(c.y + c.height) * a
+		];
+		let l = Math.floor(this.clip[0]), u = Math.floor(this.clip[1]), d = Math.ceil(this.clip[2]) - l, f = Math.ceil(this.clip[3]) - u;
+		n.enable(n.SCISSOR_TEST), n.scissor(l, this.canvas.height - u - f, Math.max(0, d), Math.max(0, f)), n.blendFunc(n.ONE, n.ONE_MINUS_SRC_ALPHA);
+		let p = e(i), m = p ? this.buildColumns(t, o, s) : 0;
+		t.volume && this.drawVolume(t, o, s, p, m);
+		let { min: h, max: g } = i.priceRange;
+		t.candles && g - h !== 0 && this.drawCandles(t, o, s, p, m), n.disable(n.SCISSOR_TEST);
+	}
+	drawRecordedRects(e, t, n) {
+		let r = this.gl, i = this.use(this.rects, e);
+		this.kit.float(i, "u_dpr", 1), this.kit.int(i, "u_union", 0), r.bindBuffer(r.ARRAY_BUFFER, this.rectBuffer), r.bufferData(r.ARRAY_BUFFER, t, r.STREAM_DRAW), this.bindRects(i, 0), r.drawArraysInstanced(r.TRIANGLES, 0, 6, n);
+	}
+	destroy() {
+		this.canvas.removeEventListener("webglcontextlost", this.handleLost), this.lostCallback = null;
+		let e = this.gl;
+		if (!e.isContextLost()) {
+			for (let e of [
+				this.candleBars,
+				this.volumeBars,
+				this.candleColumns,
+				this.volumeColumns,
+				this.rects
+			]) this.kit.deleteProgram(e);
+			this.drawer.destroy(), e.deleteBuffer(this.seriesBuffer), e.deleteBuffer(this.columnBuffer), e.deleteBuffer(this.rectBuffer), Q(e);
+		}
+		this.canvas.remove();
+	}
+	handleLost = (e) => {
+		e.preventDefault(), !this.lost && (this.lost = !0, this.lostCallback?.());
+	};
+	syncSeries(e) {
+		let t = this.gl, n = this.uploads.sync(e.data), r = this.uploads.values;
+		t.bindBuffer(t.ARRAY_BUFFER, this.seriesBuffer), n.full || r.length !== this.gpuFloats ? (t.bufferData(t.ARRAY_BUFFER, r, t.DYNAMIC_DRAW), this.gpuFloats = r.length) : n.to > n.from && t.bufferSubData(t.ARRAY_BUFFER, n.from * K, r, n.from * 6, (n.to - n.from) * 6);
+	}
+	buildColumns(e, t, r) {
+		let { viewport: i, data: a } = e, o = i.barWidth + i.barSpacing, s = -i.offset + i.chartRect.x + i.barWidth / 2, c = this.uploads.base, l = 0;
+		n(a, t, r, (e) => e * o + s, (e) => {
+			if ((l + 1) * q > this.columns.length) {
+				let e = new Float32Array(this.columns.length * 2);
+				e.set(this.columns), this.columns = e;
+			}
+			let t = l * q;
+			this.columns[t] = e.x, this.columns[t + 1] = e.high - c, this.columns[t + 2] = e.low - c, this.columns[t + 3] = e.volume, this.columns[t + 4] = +(e.close >= e.open), l++;
+		});
+		let u = this.gl;
+		return u.bindBuffer(u.ARRAY_BUFFER, this.columnBuffer), u.bufferData(u.ARRAY_BUFFER, this.columns.subarray(0, l * q), u.STREAM_DRAW), l;
+	}
+	drawBackground(e, t) {
+		let { viewport: n, theme: i } = e, a = t.grid ? r(n) : {
+			horizontal: [],
+			vertical: []
+		}, o = a.horizontal.length + a.vertical.length, s = o + t.rects.length;
+		if (s === 0) return;
+		this.rectValues.length < s * Y && (this.rectValues = new Float32Array(s * Y * 2));
+		let c = this.rectValues, l = 0, u = (e, t, n, r, i, a, o) => {
+			c[l++] = e, c[l++] = t, c[l++] = n, c[l++] = r;
+			for (let e = 0; e < 4; e++) c[l++] = i[e] * a;
+			c[l++] = o ? o[0] : 0, c[l++] = o ? o[1] : 0;
+		}, d = g(h(i.grid)), { chartRect: f } = n;
+		for (let e of a.horizontal) u(f.x, e - .5, f.x + f.width, e + .5, d, 1);
+		for (let e of a.vertical) u(e - .5, f.y, e + .5, f.y + f.height, d, 1);
+		let p = "", m = d;
+		for (let e of t.rects) e.color !== p && (p = e.color, m = g(h(e.color))), u(e.x, e.y, e.x + e.width, e.y + e.height, m, e.alpha, e.dash);
+		let _ = this.gl, v = this.use(this.rects, e);
+		_.bindBuffer(_.ARRAY_BUFFER, this.rectBuffer), _.bufferData(_.ARRAY_BUFFER, c.subarray(0, l), _.STREAM_DRAW), o > 0 && (_.uniform1i(this.loc(v, "u_union"), 1), _.blendColor(0, 0, 0, d[3]), _.blendFuncSeparate(_.ONE, _.ONE_MINUS_SRC_ALPHA, _.CONSTANT_ALPHA, _.ONE_MINUS_SRC_ALPHA), this.bindRects(v, 0), _.drawArraysInstanced(_.TRIANGLES, 0, 6, o)), t.rects.length > 0 && (_.uniform1i(this.loc(v, "u_union"), 0), _.blendFunc(_.ONE, _.ONE_MINUS_SRC_ALPHA), this.bindRects(v, o), _.drawArraysInstanced(_.TRIANGLES, 0, 6, t.rects.length));
+	}
+	drawCandles(e, t, n, r, i) {
+		let { theme: a, viewport: o, dpr: s } = e, c = g(h(a.candleUp)), l = g(h(a.candleDown));
+		if (r) {
+			let t = this.use(this.candleColumns, e);
+			this.vec4(t, "u_upBody", c), this.vec4(t, "u_downBody", l), this.bindColumns(t), this.gl.drawArraysInstanced(this.gl.TRIANGLES, 0, 6, i);
+			return;
+		}
+		let u = this.use(this.candleBars, e);
+		this.barUniforms(u, o, t, s), this.vec4(u, "u_upBody", c), this.vec4(u, "u_downBody", l), this.vec4(u, "u_upWick", g(h(a.candleUpWick))), this.vec4(u, "u_downWick", g(h(a.candleDownWick))), this.bindBars(u, t), this.gl.drawArraysInstanced(this.gl.TRIANGLES, 0, 12, n - t + 1);
+	}
+	drawVolume(e, t, n, r, a) {
+		let { data: o, viewport: s, theme: c, dpr: l } = e, u = 0;
+		for (let e = t; e <= n; e++) o[e].volume > u && (u = o[e].volume);
+		if (u === 0) return;
+		let { chartRect: d } = s, f = i(c), p = this.use(r ? this.volumeColumns : this.volumeBars, e);
+		if (this.float(p, "u_volBottom", d.y + d.height), this.float(p, "u_volScale", d.height * (e.volume?.heightRatio ?? .15) / u), this.vec4(p, "u_volUp", g(h(f.up))), this.vec4(p, "u_volDown", g(h(f.down))), r) {
+			this.bindColumns(p), this.gl.drawArraysInstanced(this.gl.TRIANGLES, 0, 6, a);
+			return;
+		}
+		this.barUniforms(p, s, t, l), this.bindBars(p, t), this.gl.drawArraysInstanced(this.gl.TRIANGLES, 0, 6, n - t + 1);
+	}
+	barUniforms(e, n, r, i) {
+		let a = n.barWidth + n.barSpacing, o = -n.offset + n.chartRect.x + n.barWidth / 2, { body: s, wick: c } = t(n.barWidth, i);
+		this.float(e, "u_x0", r * a + o), this.float(e, "u_unit", a), this.float(e, "u_wick", c), this.float(e, "u_body", s);
+	}
+	use(e, t) {
+		let n = this.gl;
+		this.kit.use(e), n.uniform2f(this.loc(e, "u_canvas"), this.canvas.width, this.canvas.height), this.vec4(e, "u_clip", this.clip), this.float(e, "u_dpr", t.dpr);
+		let r = _(t.viewport, this.uploads.base);
+		return n.uniform1i(this.loc(e, "u_log"), r.log), n.uniform1i(this.loc(e, "u_invert"), r.invert), this.float(e, "u_yA", r.yA), this.float(e, "u_yB", r.yB), this.float(e, "u_logOffset", r.logOffset), this.float(e, "u_min", r.min), this.float(e, "u_logFloor", r.logFloor), this.float(e, "u_logK", r.logK), this.float(e, "u_top", r.top), this.float(e, "u_bottom", r.bottom), e;
+	}
+	bindBars(e, t) {
+		let n = this.gl;
+		n.bindBuffer(n.ARRAY_BUFFER, this.seriesBuffer), this.attrib(e, "a_ohlc", 4, K, t * K), this.attrib(e, "a_vd", 2, K, t * K + 16);
+	}
+	bindRects(e, t) {
+		this.attrib(e, "a_rect", 4, X, t * X), this.attrib(e, "a_color", 4, X, t * X + 16), this.attrib(e, "a_dash", 2, X, t * X + 32);
+	}
+	bindColumns(e) {
+		let t = this.gl;
+		t.bindBuffer(t.ARRAY_BUFFER, this.columnBuffer), this.attrib(e, "a_col", 4, J, 0), this.attrib(e, "a_up", 1, J, 16);
+	}
+	attrib(e, t, n, r, i) {
+		this.kit.attrib(e, t, n, r, i);
+	}
+	float(e, t, n) {
+		this.kit.float(e, t, n);
+	}
+	vec4(e, t, n) {
+		this.kit.vec4(e, t, n);
+	}
+	loc(e, t) {
+		return this.kit.loc(e, t);
+	}
+};
+function Ce(e) {
+	return typeof e == "object" && !!e && Array.isArray(e.commands);
+}
+function Q(e) {
+	e.getExtension("WEBGL_lose_context")?.loseContext();
+}
+function $(e) {
+	console.warn("TradeCanvas: WebGL renderer unavailable, drawing with Canvas 2D.", e);
+}
+//#endregion
+export { Se as WebGLSeriesRenderer };
+
+//# sourceMappingURL=WebGLSeriesRenderer-DQOPCwno.js.map