velo-plot 1.15.0 → 1.19.0

package/dist/gpuRenderer-BpaMYz-k.js

@@ -0,0 +1,1848 @@
+var D = Object.defineProperty;
+var R = (o, e, t) => e in o ? D(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var l = (o, e, t) => R(o, typeof e != "symbol" ? e + "" : e, t);
+const L = `
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) color: vec4<f32>,
+};
+
+@vertex
+fn vs_main(
+  @location(0) position: vec2<f32>,
+  @location(1) color: vec4<f32>
+) -> VSOut {
+  var out: VSOut;
+  out.pos = vec4<f32>(position, 0.0, 1.0);
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  return in.color;
+}
+`;
+function F(o, e) {
+  const t = o.createShaderModule({ code: L }), r = 6 * 4;
+  return { pipeline: o.createRenderPipeline({
+    layout: "auto",
+    vertex: {
+      module: t,
+      entryPoint: "vs_main",
+      buffers: [
+        {
+          arrayStride: r,
+          attributes: [
+            { shaderLocation: 0, offset: 0, format: "float32x2" },
+            { shaderLocation: 1, offset: 2 * 4, format: "float32x4" }
+          ]
+        }
+      ]
+    },
+    fragment: {
+      module: t,
+      entryPoint: "fs_main",
+      targets: [{ format: e }]
+    },
+    primitive: {
+      topology: "triangle-list",
+      cullMode: "none"
+    }
+  }), vertexStride: r };
+}
+const G = `
+// Uniform buffer for transforms and color
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  color: vec4<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  out.pos = vec4<f32>(transformed, 0.0, 1.0);
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  return uniforms.color;
+}
+`, B = 2 * 4, I = 32;
+function V(o, e) {
+  const t = o.createShaderModule({ code: G }), r = globalThis.GPUShaderStage, i = globalThis.GPUBufferUsage, a = o.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: r.VERTEX | r.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = o.createBuffer({
+    size: I,
+    usage: i.UNIFORM | i.COPY_DST
+  }), s = o.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), c = o.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: o.createRenderPipeline({
+      layout: c,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: B,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "line-strip",
+        stripIndexFormat: void 0
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: s,
+    vertexStride: B
+  };
+}
+function A(o, e, t) {
+  const r = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3]
+  ]);
+  o.queue.writeBuffer(e, 0, r);
+}
+const O = `
+// Uniform buffer for transforms, color, point properties
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  color: vec4<f32>,
+  pointSize: f32,
+  symbol: i32,
+  viewport: vec2<f32>, // viewport dimensions for proper sizing
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,  // point center position
+  @location(1) quadOffset: vec2<f32>, // quad vertex offset (-1 to 1)
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>, // -0.5 to 0.5 for SDF
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  
+  // Transform point position to NDC
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  
+  // Calculate point size in NDC
+  let pointSizeNDC = vec2<f32>(
+    uniforms.pointSize / uniforms.viewport.x * 2.0,
+    uniforms.pointSize / uniforms.viewport.y * 2.0
+  );
+  
+  // Apply quad offset
+  let offset = in.quadOffset * pointSizeNDC * 0.5;
+  
+  out.pos = vec4<f32>(transformed + offset, 0.0, 1.0);
+  out.uv = in.quadOffset * 0.5; // -0.5 to 0.5
+  
+  return out;
+}
+
+// SDF functions
+fn sdCircle(p: vec2<f32>, r: f32) -> f32 {
+  return length(p) - r;
+}
+
+fn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {
+  let d = abs(p) - b;
+  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);
+}
+
+fn sdDiamond(p: vec2<f32>, r: f32) -> f32 {
+  return (abs(p.x) + abs(p.y)) - r;
+}
+
+fn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {
+  let k = sqrt(3.0);
+  var p = p_in;
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) {
+    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+  }
+  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+
+fn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {
+  let d = abs(p);
+  let s1 = sdBox(d, vec2<f32>(r, thickness));
+  let s2 = sdBox(d, vec2<f32>(thickness, r));
+  return min(s1, s2);
+}
+
+fn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {
+  let c = cos(0.785398);
+  let s = sin(0.785398);
+  let m = mat2x2<f32>(c, -s, s, c);
+  return sdCross(m * p, r, thickness);
+}
+
+fn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {
+  let k1 = vec2<f32>(0.80901699, -0.58778525);
+  let k2 = vec2<f32>(-k1.x, k1.y);
+  var p = p_in;
+  p.x = abs(p.x);
+  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;
+  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;
+  p.x = abs(p.x);
+  p.y = p.y - r;
+  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);
+  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  var d: f32 = 0.0;
+  
+  if (uniforms.symbol == 0) {
+    d = sdCircle(in.uv, 0.45);
+  } else if (uniforms.symbol == 1) {
+    d = sdBox(in.uv, vec2<f32>(0.35));
+  } else if (uniforms.symbol == 2) {
+    d = sdDiamond(in.uv, 0.45);
+  } else if (uniforms.symbol == 3) {
+    d = sdTriangle(vec2<f32>(in.uv.x, in.uv.y + 0.1), 0.4);
+  } else if (uniforms.symbol == 4) {
+    d = sdTriangle(vec2<f32>(in.uv.x, -in.uv.y + 0.1), 0.4);
+  } else if (uniforms.symbol == 5) {
+    d = sdCross(in.uv, 0.45, 0.15);
+  } else if (uniforms.symbol == 6) {
+    d = sdX(in.uv, 0.45, 0.15);
+  } else if (uniforms.symbol == 7) {
+    d = sdStar(in.uv, 0.45, 0.4);
+  }
+  
+  if (d > 0.02) {
+    discard;
+  }
+  
+  let alpha = 1.0 - smoothstep(0.0, 0.02, d);
+  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);
+}
+`, _ = 2 * 4, z = 48, E = new Float32Array([
+  -1,
+  -1,
+  // bottom-left
+  1,
+  -1,
+  // bottom-right
+  -1,
+  1,
+  // top-left
+  -1,
+  1,
+  // top-left
+  1,
+  -1,
+  // bottom-right
+  1,
+  1
+  // top-right
+]);
+function W(o, e) {
+  const t = o.createShaderModule({ code: O }), r = globalThis.GPUShaderStage, i = globalThis.GPUBufferUsage, a = o.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: r.VERTEX | r.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = o.createBuffer({
+    size: z,
+    usage: i.UNIFORM | i.COPY_DST
+  }), s = o.createBuffer({
+    size: E.byteLength,
+    usage: i.VERTEX | i.COPY_DST,
+    mappedAtCreation: !0
+  });
+  new Float32Array(s.getMappedRange()).set(E), s.unmap();
+  const c = o.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), u = o.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: o.createRenderPipeline({
+      layout: u,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          // Point positions (instanced)
+          {
+            arrayStride: _,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          },
+          // Quad vertex offsets (per-vertex)
+          {
+            arrayStride: 8,
+            // 2 floats
+            stepMode: "vertex",
+            attributes: [
+              { shaderLocation: 1, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-list",
+        cullMode: "none"
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: c,
+    quadBuffer: s,
+    vertexStride: _
+  };
+}
+function N(o, e, t) {
+  const r = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3],
+    t.pointSize,
+    t.symbol,
+    // Will be cast to i32 in shader via bitcast
+    t.viewport[0],
+    t.viewport[1]
+  ]);
+  o.queue.writeBuffer(e, 0, r);
+}
+const X = {
+  circle: 0,
+  square: 1,
+  diamond: 2,
+  triangle: 3,
+  triangleDown: 4,
+  cross: 5,
+  x: 6,
+  star: 7
+}, H = 32;
+function Y(o, e) {
+  const t = o.createShaderModule({ code: G }), r = globalThis.GPUShaderStage, i = globalThis.GPUBufferUsage, a = o.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: r.VERTEX | r.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = o.createBuffer({
+    size: H,
+    usage: i.UNIFORM | i.COPY_DST
+  }), s = o.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), c = o.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: o.createRenderPipeline({
+      layout: c,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: B,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-strip",
+        // Key difference from line pipeline
+        stripIndexFormat: void 0
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: s,
+    vertexStride: B
+  };
+}
+function $(o, e, t) {
+  const r = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3]
+  ]);
+  o.queue.writeBuffer(e, 0, r);
+}
+const q = `
+// Uniform buffer for transforms and value range
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  minValue: f32,
+  maxValue: f32,
+  _padding: vec2<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+@group(0) @binding(1)
+var colormapSampler: sampler;
+
+@group(0) @binding(2)
+var colormapTexture: texture_1d<f32>;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,
+  @location(1) value: f32,
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) value: f32,
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  out.pos = vec4<f32>(transformed, 0.0, 1.0);
+  out.value = in.value;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  let range = uniforms.maxValue - uniforms.minValue;
+  var t: f32;
+  if (range != 0.0) {
+    t = (in.value - uniforms.minValue) / range;
+  } else {
+    t = 0.0;
+  }
+  t = clamp(t, 0.0, 1.0);
+  
+  return textureSample(colormapTexture, colormapSampler, t);
+}
+`, k = 3 * 4, j = 32;
+function K(o, e) {
+  const t = o.createShaderModule({ code: q }), r = globalThis.GPUShaderStage, i = globalThis.GPUBufferUsage, a = o.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: r.VERTEX | r.FRAGMENT,
+        buffer: { type: "uniform" }
+      },
+      {
+        binding: 1,
+        visibility: r.FRAGMENT,
+        sampler: {}
+      },
+      {
+        binding: 2,
+        visibility: r.FRAGMENT,
+        texture: {
+          sampleType: "float",
+          viewDimension: "1d"
+        }
+      }
+    ]
+  }), n = o.createBuffer({
+    size: j,
+    usage: i.UNIFORM | i.COPY_DST
+  }), s = o.createSampler({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge"
+  }), c = o.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: o.createRenderPipeline({
+      layout: c,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: k,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" },
+              // position
+              { shaderLocation: 1, offset: 8, format: "float32" }
+              // value
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-list",
+        cullMode: "none"
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    sampler: s,
+    vertexStride: k
+  };
+}
+function Z(o, e, t, r, i) {
+  return o.createBindGroup({
+    layout: e,
+    entries: [
+      { binding: 0, resource: { buffer: t } },
+      { binding: 1, resource: r },
+      { binding: 2, resource: i.createView() }
+    ]
+  });
+}
+function Q(o, e, t) {
+  const r = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.minValue,
+    t.maxValue,
+    0,
+    // padding
+    0
+    // padding
+  ]);
+  o.queue.writeBuffer(e, 0, r);
+}
+function J(o) {
+  const e = o.xMax - o.xMin, t = o.yMax - o.yMin, r = e > 0 ? 2 / e : 1, i = t > 0 ? 2 / t : 1, a = -1 - o.xMin * r, n = -1 - o.yMin * i;
+  return {
+    scale: [r, i],
+    translate: [a, n]
+  };
+}
+function ee(o) {
+  const e = (o == null ? void 0 : o.color) ?? [1, 0, 0.3, 1], t = (o == null ? void 0 : o.opacity) ?? 1;
+  return Array.isArray(e) ? [e[0], e[1], e[2], (e[3] ?? 1) * t] : [1, 0, 0.3, t];
+}
+class v {
+  constructor(e, t = {}) {
+    l(this, "info");
+    l(this, "canvas");
+    l(this, "opts");
+    l(this, "viewport", null);
+    l(this, "adapter");
+    l(this, "device");
+    l(this, "context");
+    l(this, "format", null);
+    l(this, "buffers", /* @__PURE__ */ new Map());
+    l(this, "textures", /* @__PURE__ */ new Map());
+    // Pipelines for different draw types
+    l(this, "trianglePipeline", null);
+    l(this, "linePipeline", null);
+    l(this, "pointPipeline", null);
+    l(this, "bandPipeline", null);
+    l(this, "heatmapPipeline", null);
+    // Heatmap bind groups (per texture)
+    l(this, "heatmapBindGroups", /* @__PURE__ */ new Map());
+    this.canvas = e, this.opts = t, this.info = {
+      type: "webgpu",
+      available: v.isSupported()
+    };
+  }
+  static isSupported() {
+    return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
+  }
+  async init() {
+    if (!this.info.available)
+      throw new Error("[gpu] WebGPU not supported");
+    const e = globalThis.navigator.gpu;
+    if (this.adapter = await e.requestAdapter({
+      powerPreference: this.opts.powerPreference ?? "high-performance"
+    }), !this.adapter)
+      throw new Error("[gpu] Failed to request WebGPU adapter");
+    this.device = await this.adapter.requestDevice();
+    const t = this.canvas.getContext("webgpu");
+    if (!t)
+      throw new Error("[gpu] Failed to get WebGPU canvas context");
+    this.context = t;
+    const r = this.opts.preferredFormat ?? (e.getPreferredCanvasFormat ? e.getPreferredCanvasFormat() : "bgra8unorm");
+    this.format = r, this.context.configure({
+      device: this.device,
+      format: r,
+      alphaMode: "premultiplied"
+    });
+  }
+  setViewport(e) {
+    this.viewport = e;
+    const t = Math.max(1, Math.floor(e.width * e.dpr)), r = Math.max(1, Math.floor(e.height * e.dpr));
+    this.canvas.width !== t && (this.canvas.width = t), this.canvas.height !== r && (this.canvas.height = r);
+  }
+  createOrUpdateBuffer(e, t, r) {
+    if (!this.device)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    const i = (r == null ? void 0 : r.usage) ?? "vertex", a = globalThis.GPUBufferUsage;
+    if (!a)
+      throw new Error(
+        "[gpu] GPUBufferUsage not available (missing WebGPU runtime)"
+      );
+    const n = i === "index" ? a.INDEX | a.COPY_DST : i === "uniform" ? a.UNIFORM | a.COPY_DST : a.VERTEX | a.COPY_DST, s = t.byteLength;
+    let c = this.buffers.get(e);
+    if (!c || c.size < s) {
+      if (c)
+        try {
+          c.destroy();
+        } catch {
+        }
+      c = this.device.createBuffer({
+        size: Math.max(4, s),
+        usage: n
+      }), this.buffers.set(e, c);
+    }
+    this.device.queue.writeBuffer(
+      c,
+      0,
+      t.buffer,
+      t.byteOffset,
+      t.byteLength
+    );
+  }
+  deleteBuffer(e) {
+    const t = this.buffers.get(e);
+    if (t) {
+      try {
+        t.destroy();
+      } catch {
+      }
+      this.buffers.delete(e);
+    }
+  }
+  createOrUpdateTexture1D(e, t, r) {
+    if (!this.device)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    const i = (r == null ? void 0 : r.width) ?? Math.floor(t.length / 4), a = (r == null ? void 0 : r.format) ?? "rgba8unorm", n = globalThis.GPUTextureUsage;
+    if (!n)
+      throw new Error(
+        "[gpu] GPUTextureUsage not available (missing WebGPU runtime)"
+      );
+    let s = this.textures.get(e);
+    s || (s = this.device.createTexture({
+      size: { width: i, height: 1, depthOrArrayLayers: 1 },
+      format: a,
+      dimension: "1d",
+      usage: n.TEXTURE_BINDING | n.COPY_DST
+    }), this.textures.set(e, s), this.heatmapBindGroups.delete(e)), this.device.queue.writeTexture(
+      { texture: s },
+      t,
+      { bytesPerRow: i * 4 },
+      { width: i, height: 1, depthOrArrayLayers: 1 }
+    );
+  }
+  deleteTexture(e) {
+    const t = this.textures.get(e);
+    if (t) {
+      try {
+        t.destroy();
+      } catch {
+      }
+      this.textures.delete(e), this.heatmapBindGroups.delete(e);
+    }
+  }
+  /**
+   * Initialize all pipelines lazily
+   */
+  ensurePipelines() {
+    this.trianglePipeline || (this.trianglePipeline = F(this.device, this.format)), this.linePipeline || (this.linePipeline = V(this.device, this.format)), this.pointPipeline || (this.pointPipeline = W(this.device, this.format)), this.bandPipeline || (this.bandPipeline = Y(this.device, this.format)), this.heatmapPipeline || (this.heatmapPipeline = K(this.device, this.format));
+  }
+  render(e, t) {
+    if (!this.device || !this.context || !this.format)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    this.viewport || this.setViewport(t.viewport), this.ensurePipelines();
+    const r = this.device.createCommandEncoder(), i = this.context.getCurrentTexture().createView(), a = r.beginRenderPass({
+      colorAttachments: [
+        {
+          view: i,
+          clearValue: {
+            r: t.clearColor[0],
+            g: t.clearColor[1],
+            b: t.clearColor[2],
+            a: t.clearColor[3]
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    }), n = { xMin: -1, xMax: 1, yMin: -1, yMax: 1 };
+    for (const s of e.items) {
+      if (!s.visible) continue;
+      const c = this.buffers.get(s.bufferId);
+      c && this.renderDrawCall(a, s, c, n);
+    }
+    a.end(), this.device.queue.submit([r.finish()]);
+  }
+  /**
+   * Render with explicit bounds (for integration with chart system)
+   */
+  renderWithBounds(e, t, r) {
+    if (!this.device || !this.context || !this.format)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    this.viewport || this.setViewport(t.viewport), this.ensurePipelines();
+    const i = this.device.createCommandEncoder(), a = this.context.getCurrentTexture().createView(), n = i.beginRenderPass({
+      colorAttachments: [
+        {
+          view: a,
+          clearValue: {
+            r: t.clearColor[0],
+            g: t.clearColor[1],
+            b: t.clearColor[2],
+            a: t.clearColor[3]
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    });
+    for (const s of e.items) {
+      if (!s.visible) continue;
+      const c = this.buffers.get(s.bufferId);
+      if (!c) continue;
+      const u = s.yBounds ? { ...r, yMin: s.yBounds.min, yMax: s.yBounds.max } : r;
+      this.renderDrawCall(n, s, c, u);
+    }
+    n.end(), this.device.queue.submit([i.finish()]);
+  }
+  /**
+   * Render a single draw call
+   */
+  renderDrawCall(e, t, r, i) {
+    const a = J(i), n = ee(t.style);
+    switch (t.kind) {
+      case "triangles":
+      case "bar":
+        this.renderSolidTriangles(e, r, t.count, a, n);
+        break;
+      case "line":
+        this.renderLine(e, r, t.count, a, n);
+        break;
+      case "scatter":
+      case "points":
+        this.renderPoints(e, r, t.count, a, n, t.style);
+        break;
+      case "line+scatter":
+        this.renderLine(e, r, t.count, a, n), this.renderPoints(e, r, t.count, a, n, t.style);
+        break;
+      case "step":
+        if (t.stepBufferId && t.stepCount) {
+          const c = this.buffers.get(t.stepBufferId);
+          c && this.renderLine(e, c, t.stepCount, a, n);
+        } else
+          this.renderLine(e, r, t.count, a, n);
+        break;
+      case "step+scatter":
+        if (t.stepBufferId && t.stepCount) {
+          const c = this.buffers.get(t.stepBufferId);
+          c && this.renderLine(e, c, t.stepCount, a, n);
+        } else
+          this.renderLine(e, r, t.count, a, n);
+        this.renderPoints(e, r, t.count, a, n, t.style);
+        break;
+      case "band":
+        const s = [
+          n[0],
+          n[1],
+          n[2],
+          n[3] * 0.4
+        ];
+        this.renderBand(e, r, t.count, a, s);
+        break;
+      case "heatmap":
+        this.renderHeatmap(e, r, t.count, a, t.style, t.textureId);
+        break;
+    }
+  }
+  /** Triangle list with line-pipeline uniforms (xy vertices, uniform color). */
+  renderSolidTriangles(e, t, r, i, a) {
+    A(this.device, this.linePipeline.uniformBuffer, {
+      scale: i.scale,
+      translate: i.translate,
+      color: a
+    }), e.setPipeline(this.linePipeline.pipeline), e.setBindGroup(0, this.linePipeline.bindGroup), e.setVertexBuffer(0, t), e.draw(r);
+  }
+  renderLine(e, t, r, i, a) {
+    A(this.device, this.linePipeline.uniformBuffer, {
+      scale: i.scale,
+      translate: i.translate,
+      color: a
+    }), e.setPipeline(this.linePipeline.pipeline), e.setBindGroup(0, this.linePipeline.bindGroup), e.setVertexBuffer(0, t), e.draw(r);
+  }
+  renderPoints(e, t, r, i, a, n) {
+    var p;
+    const s = ((n == null ? void 0 : n.pointSize) ?? 4) * (((p = this.viewport) == null ? void 0 : p.dpr) ?? 1), c = X[(n == null ? void 0 : n.symbol) ?? "circle"] ?? 0, u = [
+      this.canvas.width,
+      this.canvas.height
+    ];
+    N(this.device, this.pointPipeline.uniformBuffer, {
+      scale: i.scale,
+      translate: i.translate,
+      color: a,
+      pointSize: s,
+      symbol: c,
+      viewport: u
+    }), e.setPipeline(this.pointPipeline.pipeline), e.setBindGroup(0, this.pointPipeline.bindGroup), e.setVertexBuffer(0, t), e.setVertexBuffer(1, this.pointPipeline.quadBuffer), e.draw(6, r);
+  }
+  renderBand(e, t, r, i, a) {
+    $(this.device, this.bandPipeline.uniformBuffer, {
+      scale: i.scale,
+      translate: i.translate,
+      color: a
+    }), e.setPipeline(this.bandPipeline.pipeline), e.setBindGroup(0, this.bandPipeline.bindGroup), e.setVertexBuffer(0, t), e.draw(r);
+  }
+  renderHeatmap(e, t, r, i, a, n) {
+    if (!n) return;
+    const s = this.textures.get(n);
+    if (!s) return;
+    const c = (a == null ? void 0 : a.zBounds) ?? { min: 0, max: 1 };
+    Q(this.device, this.heatmapPipeline.uniformBuffer, {
+      scale: i.scale,
+      translate: i.translate,
+      minValue: c.min,
+      maxValue: c.max
+    });
+    let u = this.heatmapBindGroups.get(n);
+    u || (u = Z(
+      this.device,
+      this.heatmapPipeline.bindGroupLayout,
+      this.heatmapPipeline.uniformBuffer,
+      this.heatmapPipeline.sampler,
+      s
+    ), this.heatmapBindGroups.set(n, u)), e.setPipeline(this.heatmapPipeline.pipeline), e.setBindGroup(0, u), e.setVertexBuffer(0, t), e.draw(r);
+  }
+  destroy() {
+    for (const e of Array.from(this.buffers.keys()))
+      this.deleteBuffer(e);
+    for (const e of Array.from(this.textures.keys()))
+      this.deleteTexture(e);
+    this.trianglePipeline = null, this.linePipeline = null, this.pointPipeline = null, this.bandPipeline = null, this.heatmapPipeline = null, this.heatmapBindGroups.clear(), this.device = void 0, this.adapter = void 0, this.context = void 0, this.format = null;
+  }
+}
+const ge = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebGPUBackend: v
+}, Symbol.toStringTag, { value: "Module" })), te = `
+precision highp float;
+attribute vec2 aPosition;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+
+void main() {
+  vec2 pos = aPosition * uScale + uTranslate;
+  gl_Position = vec4(pos, 0.0, 1.0);
+}
+`, re = `
+precision highp float;
+uniform vec4 uColor;
+
+void main() {
+  gl_FragColor = uColor;
+}
+`, ie = `
+precision highp float;
+attribute vec2 aPosition;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+uniform float uPointSize;
+
+void main() {
+  vec2 pos = aPosition * uScale + uTranslate;
+  gl_Position = vec4(pos, 0.0, 1.0);
+  gl_PointSize = uPointSize;
+}
+`, ae = `
+precision highp float;
+uniform vec4 uColor;
+uniform int uSymbol;
+
+float sdCircle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float sdBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+float sdTriangle(vec2 p, float r) {
+  const float k = sqrt(3.0);
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+  p.x -= clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+
+float sdDiamond(vec2 p, float r) {
+  return (abs(p.x) + abs(p.y)) - r;
+}
+
+float sdCross(vec2 p, float r, float thickness) {
+  vec2 d = abs(p);
+  float s1 = sdBox(d, vec2(r, thickness));
+  float s2 = sdBox(d, vec2(thickness, r));
+  return min(s1, s2);
+}
+
+float sdX(vec2 p, float r, float thickness) {
+  float c = cos(0.785398);
+  float s = sin(0.785398);
+  mat2 m = mat2(c, -s, s, c);
+  return sdCross(m * p, r, thickness);
+}
+
+float sdStar(vec2 p, float r, float rf) {
+  const vec2 k1 = vec2(0.80901699, -0.58778525);
+  const vec2 k2 = vec2(-k1.x, k1.y);
+  p.x = abs(p.x);
+  p -= 2.0 * max(dot(k1, p), 0.0) * k1;
+  p -= 2.0 * max(dot(k2, p), 0.0) * k2;
+  p.x = abs(p.x);
+  p.y -= r;
+  vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0, 1);
+  float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+
+void main() {
+  vec2 p = gl_PointCoord - vec2(0.5);
+  float d = 0.0;
+
+  if (uSymbol == 0) {
+    d = sdCircle(p, 0.45);
+  } else if (uSymbol == 1) {
+    d = sdBox(p, vec2(0.35));
+  } else if (uSymbol == 2) {
+    d = sdDiamond(p, 0.45);
+  } else if (uSymbol == 3) {
+    d = sdTriangle(vec2(p.x, p.y + 0.1), 0.4);
+  } else if (uSymbol == 4) {
+    d = sdTriangle(vec2(p.x, -p.y + 0.1), 0.4);
+  } else if (uSymbol == 5) {
+    d = sdCross(p, 0.45, 0.15);
+  } else if (uSymbol == 6) {
+    d = sdX(p, 0.45, 0.15);
+  } else if (uSymbol == 7) {
+    d = sdStar(p, 0.45, 0.4);
+  }
+
+  if (d > 0.02) discard;
+
+  float alpha = 1.0 - smoothstep(0.0, 0.02, d);
+  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);
+}
+`, ne = `
+precision highp float;
+attribute vec2 aPosition;
+attribute float aValue;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+varying float vValue;
+
+void main() {
+  gl_Position = vec4(aPosition * uScale + uTranslate, 0.0, 1.0);
+  vValue = aValue;
+}
+`, oe = `
+precision highp float;
+varying float vValue;
+uniform float uMinValue;
+uniform float uMaxValue;
+uniform sampler2D uColormap;
+
+void main() {
+  float range = uMaxValue - uMinValue;
+  float t = (vValue - uMinValue) / (range != 0.0 ? range : 1.0);
+  t = clamp(t, 0.0, 1.0);
+  gl_FragColor = texture2D(uColormap, vec2(t, 0.5));
+}
+`;
+function C(o, e, t) {
+  const r = o.createShader(e);
+  if (!r)
+    throw new Error("[WebGL] Failed to create shader");
+  if (o.shaderSource(r, t), o.compileShader(r), !o.getShaderParameter(r, o.COMPILE_STATUS)) {
+    const i = o.getShaderInfoLog(r);
+    throw o.deleteShader(r), new Error(`[WebGL] Shader compilation error: ${i}`);
+  }
+  return r;
+}
+function se(o, e, t) {
+  const r = o.createProgram();
+  if (!r)
+    throw new Error("[WebGL] Failed to create program");
+  if (o.attachShader(r, e), o.attachShader(r, t), o.linkProgram(r), !o.getProgramParameter(r, o.LINK_STATUS)) {
+    const i = o.getProgramInfoLog(r);
+    throw o.deleteProgram(r), new Error(`[WebGL] Program link error: ${i}`);
+  }
+  return r;
+}
+function S(o, e, t, r, i) {
+  const a = C(o, o.VERTEX_SHADER, e), n = C(o, o.FRAGMENT_SHADER, t), s = se(o, a, n);
+  o.deleteShader(a), o.deleteShader(n);
+  const c = {};
+  for (const p of r)
+    c[p] = o.getAttribLocation(s, p);
+  const u = {};
+  for (const p of i)
+    u[p] = o.getUniformLocation(s, p);
+  return { program: s, attributes: c, uniforms: u };
+}
+function ce(o) {
+  const e = S(
+    o,
+    te,
+    re,
+    ["aPosition"],
+    ["uScale", "uTranslate", "uColor"]
+  ), t = S(
+    o,
+    ie,
+    ae,
+    ["aPosition"],
+    ["uScale", "uTranslate", "uColor", "uPointSize", "uSymbol"]
+  ), r = S(
+    o,
+    ne,
+    oe,
+    ["aPosition", "aValue"],
+    ["uScale", "uTranslate", "uMinValue", "uMaxValue", "uColormap"]
+  );
+  return { line: e, point: t, heatmap: r };
+}
+function le(o, e) {
+  o.deleteProgram(e.line.program), o.deleteProgram(e.point.program), o.deleteProgram(e.heatmap.program);
+}
+const ue = {
+  circle: 0,
+  square: 1,
+  diamond: 2,
+  triangle: 3,
+  triangleDown: 4,
+  cross: 5,
+  x: 6,
+  star: 7
+};
+function fe(o) {
+  const e = o.xMax - o.xMin, t = o.yMax - o.yMin, r = e > 0 ? 2 / e : 1, i = t > 0 ? 2 / t : 1, a = -1 - o.xMin * r, n = -1 - o.yMin * i;
+  return {
+    scale: [r, i],
+    translate: [a, n]
+  };
+}
+function pe(o) {
+  const e = (o == null ? void 0 : o.color) ?? [1, 0, 0.3, 1], t = (o == null ? void 0 : o.opacity) ?? 1;
+  return Array.isArray(e) ? [e[0], e[1], e[2], (e[3] ?? 1) * t] : [1, 0, 0.3, t];
+}
+class y {
+  constructor(e, t = {}) {
+    l(this, "info");
+    l(this, "canvas");
+    l(this, "opts");
+    l(this, "gl", null);
+    l(this, "viewport", null);
+    l(this, "dpr", 1);
+    l(this, "programs", null);
+    l(this, "buffers", /* @__PURE__ */ new Map());
+    l(this, "textures", /* @__PURE__ */ new Map());
+    this.canvas = e, this.opts = t, this.info = {
+      type: "webgl",
+      available: y.isSupported()
+    };
+  }
+  static isSupported() {
+    if (typeof document > "u") return !1;
+    try {
+      const e = document.createElement("canvas");
+      return !!(e.getContext("webgl") || e.getContext("experimental-webgl"));
+    } catch {
+      return !1;
+    }
+  }
+  async init() {
+    if (!this.info.available)
+      throw new Error("[gpu] WebGL not supported");
+    const e = this.canvas.getContext("webgl", {
+      alpha: !0,
+      antialias: this.opts.antialias ?? !0,
+      preserveDrawingBuffer: this.opts.preserveDrawingBuffer ?? !0,
+      powerPreference: this.opts.powerPreference ?? "high-performance"
+    });
+    if (!e)
+      throw new Error("[gpu] Failed to get WebGL context");
+    this.gl = e, e.enable(e.BLEND), e.blendFunc(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA), this.programs = ce(e);
+  }
+  setViewport(e) {
+    this.viewport = e, this.dpr = e.dpr;
+    const t = Math.max(1, Math.floor(e.width * e.dpr)), r = Math.max(1, Math.floor(e.height * e.dpr));
+    this.canvas.width !== t && (this.canvas.width = t), this.canvas.height !== r && (this.canvas.height = r), this.gl && this.gl.viewport(0, 0, t, r);
+  }
+  createOrUpdateBuffer(e, t, r) {
+    if (!this.gl)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const i = this.gl;
+    let a = this.buffers.get(e);
+    a || (a = i.createBuffer(), this.buffers.set(e, a));
+    const n = (r == null ? void 0 : r.usage) === "index" ? i.ELEMENT_ARRAY_BUFFER : i.ARRAY_BUFFER;
+    i.bindBuffer(n, a), i.bufferData(n, t, i.DYNAMIC_DRAW), i.bindBuffer(n, null);
+  }
+  deleteBuffer(e) {
+    if (!this.gl) return;
+    const t = this.buffers.get(e);
+    t && (this.gl.deleteBuffer(t), this.buffers.delete(e));
+  }
+  createOrUpdateTexture1D(e, t, r) {
+    if (!this.gl)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const i = this.gl, a = (r == null ? void 0 : r.width) ?? Math.floor(t.length / 4);
+    let n = this.textures.get(e);
+    n || (n = i.createTexture(), this.textures.set(e, n)), i.bindTexture(i.TEXTURE_2D, n), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, a, 1, 0, i.RGBA, i.UNSIGNED_BYTE, t), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.bindTexture(i.TEXTURE_2D, null);
+  }
+  deleteTexture(e) {
+    if (!this.gl) return;
+    const t = this.textures.get(e);
+    t && (this.gl.deleteTexture(t), this.textures.delete(e));
+  }
+  render(e, t) {
+    this.renderWithBounds(e, t, { xMin: -1, xMax: 1, yMin: -1, yMax: 1 });
+  }
+  renderWithBounds(e, t, r) {
+    if (!this.gl || !this.programs)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const i = this.gl;
+    this.viewport || this.setViewport(t.viewport), i.clearColor(
+      t.clearColor[0],
+      t.clearColor[1],
+      t.clearColor[2],
+      t.clearColor[3]
+    ), i.clear(i.COLOR_BUFFER_BIT);
+    for (const a of e.items) {
+      if (!a.visible) continue;
+      const n = this.buffers.get(a.bufferId);
+      if (!n) continue;
+      const s = a.yBounds ? { ...r, yMin: a.yBounds.min, yMax: a.yBounds.max } : r;
+      this.renderDrawCall(a, n, s);
+    }
+  }
+  renderDrawCall(e, t, r) {
+    const i = fe(r), a = pe(e.style);
+    switch (e.kind) {
+      case "line":
+      case "step":
+        this.renderLine(t, e.count, i, a);
+        break;
+      case "scatter":
+      case "points":
+        this.renderPoints(t, e.count, i, a, e.style);
+        break;
+      case "line+scatter":
+        this.renderLine(t, e.count, i, a), this.renderPoints(t, e.count, i, a, e.style);
+        break;
+      case "step+scatter":
+        if (e.stepBufferId && e.stepCount) {
+          const s = this.buffers.get(e.stepBufferId);
+          s && this.renderLine(s, e.stepCount, i, a);
+        } else
+          this.renderLine(t, e.count, i, a);
+        this.renderPoints(t, e.count, i, a, e.style);
+        break;
+      case "band":
+        const n = [
+          a[0],
+          a[1],
+          a[2],
+          a[3] * 0.4
+        ];
+        this.renderBand(t, e.count, i, n);
+        break;
+      case "triangles":
+      case "bar":
+        this.renderTriangles(t, e.count, i, a);
+        break;
+      case "heatmap":
+        this.renderHeatmap(t, e.count, i, e.style, e.textureId);
+        break;
+    }
+  }
+  renderLine(e, t, r, i) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, r.scale[0], r.scale[1]), a.uniform2f(n.uniforms.uTranslate, r.translate[0], r.translate[1]), a.uniform4f(n.uniforms.uColor, i[0], i[1], i[2], i[3]), a.drawArrays(a.LINE_STRIP, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderPoints(e, t, r, i, a) {
+    const n = this.gl, s = this.programs.point, c = ((a == null ? void 0 : a.pointSize) ?? 4) * this.dpr, u = ue[(a == null ? void 0 : a.symbol) ?? "circle"] ?? 0;
+    n.useProgram(s.program), n.bindBuffer(n.ARRAY_BUFFER, e), n.enableVertexAttribArray(s.attributes.aPosition), n.vertexAttribPointer(s.attributes.aPosition, 2, n.FLOAT, !1, 0, 0), n.uniform2f(s.uniforms.uScale, r.scale[0], r.scale[1]), n.uniform2f(s.uniforms.uTranslate, r.translate[0], r.translate[1]), n.uniform4f(s.uniforms.uColor, i[0], i[1], i[2], i[3]), n.uniform1f(s.uniforms.uPointSize, c), n.uniform1i(s.uniforms.uSymbol, u), n.drawArrays(n.POINTS, 0, t), n.disableVertexAttribArray(s.attributes.aPosition);
+  }
+  renderBand(e, t, r, i) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, r.scale[0], r.scale[1]), a.uniform2f(n.uniforms.uTranslate, r.translate[0], r.translate[1]), a.uniform4f(n.uniforms.uColor, i[0], i[1], i[2], i[3]), a.drawArrays(a.TRIANGLE_STRIP, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderTriangles(e, t, r, i) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, r.scale[0], r.scale[1]), a.uniform2f(n.uniforms.uTranslate, r.translate[0], r.translate[1]), a.uniform4f(n.uniforms.uColor, i[0], i[1], i[2], i[3]), a.drawArrays(a.TRIANGLES, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderHeatmap(e, t, r, i, a) {
+    if (!a) return;
+    const n = this.textures.get(a);
+    if (!n) return;
+    const s = this.gl, c = this.programs.heatmap, u = (i == null ? void 0 : i.zBounds) ?? { min: 0, max: 1 };
+    s.useProgram(c.program), s.bindBuffer(s.ARRAY_BUFFER, e), s.enableVertexAttribArray(c.attributes.aPosition), s.vertexAttribPointer(c.attributes.aPosition, 2, s.FLOAT, !1, 12, 0), c.attributes.aValue !== -1 && (s.enableVertexAttribArray(c.attributes.aValue), s.vertexAttribPointer(c.attributes.aValue, 1, s.FLOAT, !1, 12, 8)), s.uniform2f(c.uniforms.uScale, r.scale[0], r.scale[1]), s.uniform2f(c.uniforms.uTranslate, r.translate[0], r.translate[1]), s.uniform1f(c.uniforms.uMinValue, u.min), s.uniform1f(c.uniforms.uMaxValue, u.max), s.activeTexture(s.TEXTURE0), s.bindTexture(s.TEXTURE_2D, n), s.uniform1i(c.uniforms.uColormap, 0), s.drawArrays(s.TRIANGLES, 0, t), s.disableVertexAttribArray(c.attributes.aPosition), c.attributes.aValue !== -1 && s.disableVertexAttribArray(c.attributes.aValue);
+  }
+  destroy() {
+    if (!this.gl) return;
+    const e = this.gl;
+    for (const t of this.buffers.values())
+      e.deleteBuffer(t);
+    this.buffers.clear();
+    for (const t of this.textures.values())
+      e.deleteTexture(t);
+    this.textures.clear(), this.programs && (le(e, this.programs), this.programs = null), this.gl = null;
+  }
+}
+const me = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebGLBackend: y
+}, Symbol.toStringTag, { value: "Module" }));
+function m(o) {
+  if (!o)
+    return [1, 0, 0.3, 1];
+  if (Array.isArray(o))
+    return [o[0], o[1], o[2], o[3] ?? 1];
+  const e = o;
+  if (e.startsWith("#")) {
+    const r = e.slice(1);
+    if (r.length === 3) {
+      const i = parseInt(r[0] + r[0], 16) / 255, a = parseInt(r[1] + r[1], 16) / 255, n = parseInt(r[2] + r[2], 16) / 255;
+      return [i, a, n, 1];
+    }
+    if (r.length === 6) {
+      const i = parseInt(r.slice(0, 2), 16) / 255, a = parseInt(r.slice(2, 4), 16) / 255, n = parseInt(r.slice(4, 6), 16) / 255;
+      return [i, a, n, 1];
+    }
+    if (r.length === 8) {
+      const i = parseInt(r.slice(0, 2), 16) / 255, a = parseInt(r.slice(2, 4), 16) / 255, n = parseInt(r.slice(4, 6), 16) / 255, s = parseInt(r.slice(6, 8), 16) / 255;
+      return [i, a, n, s];
+    }
+  }
+  const t = e.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+  if (t) {
+    const r = parseInt(t[1]) / 255, i = parseInt(t[2]) / 255, a = parseInt(t[3]) / 255, n = t[4] ? parseFloat(t[4]) : 1;
+    return [r, i, a, n];
+  }
+  return [1, 0, 0.3, 1];
+}
+function de(o, e) {
+  const t = m(o.color), r = o.opacity ?? 1, i = [t[0], t[1], t[2], t[3] * r];
+  return e === "scatter" || e === "line+scatter" || e === "step+scatter" ? {
+    color: i,
+    opacity: r,
+    pointSize: o.pointSize ?? 4,
+    symbol: o.symbol ?? "circle"
+  } : {
+    color: i,
+    opacity: r,
+    lineWidth: o.lineWidth ?? 1
+  };
+}
+class U {
+  constructor(e) {
+    l(this, "backend");
+    l(this, "seriesBufferMap", /* @__PURE__ */ new Map());
+    l(this, "seriesStepBufferMap", /* @__PURE__ */ new Map());
+    l(this, "seriesTextureMap", /* @__PURE__ */ new Map());
+    this.backend = e;
+  }
+  /**
+   * Get buffer ID for a series
+   */
+  getBufferId(e) {
+    return this.seriesBufferMap.has(e) || this.seriesBufferMap.set(e, `series:${e}`), this.seriesBufferMap.get(e);
+  }
+  /**
+   * Get step buffer ID for a series
+   */
+  getStepBufferId(e) {
+    return this.seriesStepBufferMap.has(e) || this.seriesStepBufferMap.set(e, `series:${e}:step`), this.seriesStepBufferMap.get(e);
+  }
+  /**
+   * Get texture ID for a series
+   */
+  getTextureId(e) {
+    return this.seriesTextureMap.has(e) || this.seriesTextureMap.set(e, `texture:${e}`), this.seriesTextureMap.get(e);
+  }
+  /**
+   * Update series data in GPU buffers
+   */
+  updateSeries(e) {
+    const t = this.getBufferId(e.id);
+    if (this.backend.createOrUpdateBuffer(t, e.data, { usage: "vertex" }), e.stepData && (e.type === "step" || e.type === "step+scatter")) {
+      const r = this.getStepBufferId(e.id);
+      this.backend.createOrUpdateBuffer(r, e.stepData, { usage: "vertex" });
+    }
+    if (e.type === "heatmap" && e.colormapData) {
+      const r = this.getTextureId(e.id);
+      this.backend.createOrUpdateTexture1D(r, e.colormapData, {
+        width: e.colormapData.length / 4
+      });
+    }
+  }
+  /**
+   * Remove a series from GPU resources
+   */
+  removeSeries(e) {
+    const t = this.seriesBufferMap.get(e);
+    t && (this.backend.deleteBuffer(t), this.seriesBufferMap.delete(e));
+    const r = this.seriesStepBufferMap.get(e);
+    r && (this.backend.deleteBuffer(r), this.seriesStepBufferMap.delete(e));
+    const i = this.seriesTextureMap.get(e);
+    i && (this.backend.deleteTexture(i), this.seriesTextureMap.delete(e));
+  }
+  /**
+   * Build draw list from series array
+   */
+  buildDrawList(e) {
+    const t = [];
+    for (const r of e) {
+      this.updateSeries(r);
+      const i = this.getBufferId(r.id), a = r.data.length / 2, n = {
+        id: r.id,
+        kind: r.type,
+        bufferId: i,
+        count: r.type === "heatmap" ? r.data.length / 3 : a,
+        visible: r.visible,
+        style: de(r.style, r.type),
+        yBounds: r.yBounds
+      };
+      r.stepData && (r.type === "step" || r.type === "step+scatter") && (n.stepBufferId = this.getStepBufferId(r.id), n.stepCount = r.stepData.length / 2), r.type === "heatmap" && (n.textureId = this.getTextureId(r.id), n.style = {
+        zBounds: r.zBounds,
+        colormap: r.colormap
+      }), t.push(n);
+    }
+    return { items: t };
+  }
+  /**
+   * Cleanup all resources
+   */
+  destroy() {
+    for (const e of this.seriesBufferMap.values())
+      this.backend.deleteBuffer(e);
+    for (const e of this.seriesStepBufferMap.values())
+      this.backend.deleteBuffer(e);
+    for (const e of this.seriesTextureMap.values())
+      this.backend.deleteTexture(e);
+    this.seriesBufferMap.clear(), this.seriesStepBufferMap.clear(), this.seriesTextureMap.clear();
+  }
+}
+class he {
+  constructor(e, t = {}) {
+    l(this, "canvas");
+    l(this, "options");
+    l(this, "backend", null);
+    l(this, "adapter", null);
+    l(this, "dpr");
+    l(this, "isInitialized", !1);
+    l(this, "backendType", null);
+    // Buffer management
+    l(this, "bufferDataMap", /* @__PURE__ */ new Map());
+    l(this, "stepBufferDataMap", /* @__PURE__ */ new Map());
+    l(this, "colormapDataMap", /* @__PURE__ */ new Map());
+    this.canvas = e, this.options = t, this.dpr = window.devicePixelRatio || 1;
+  }
+  /**
+   * Initialize the renderer
+   */
+  async init() {
+    const e = this.options.backend ?? "auto";
+    if ((e === "webgpu" || e === "auto") && v.isSupported())
+      try {
+        const t = new v(this.canvas, {
+          powerPreference: this.options.powerPreference ?? "high-performance"
+        });
+        return await t.init(), this.backend = t, this.backendType = "webgpu", this.adapter = new U(t), this.isInitialized = !0, this.resize(), !0;
+      } catch (t) {
+        console.warn("[GpuRenderer] WebGPU init failed:", t);
+      }
+    if ((e === "webgl" || e === "auto") && y.isSupported())
+      try {
+        const t = new y(this.canvas, {
+          powerPreference: this.options.powerPreference ?? "high-performance"
+        });
+        return await t.init(), this.backend = t, this.backendType = "webgl", this.adapter = new U(t), this.isInitialized = !0, this.resize(), console.info("[GpuRenderer] Using WebGL backend (WebGPU not available)"), !0;
+      } catch (t) {
+        console.warn("[GpuRenderer] WebGL init failed:", t);
+      }
+    return !1;
+  }
+  /**
+   * Check if renderer is available
+   */
+  get available() {
+    return this.isInitialized;
+  }
+  /**
+   * Get the active backend type
+   */
+  get activeBackend() {
+    return this.backendType;
+  }
+  /**
+   * Set device pixel ratio
+   */
+  setDPR(e) {
+    this.dpr = e, this.resize();
+  }
+  /**
+   * Check if vertex data exists for a buffer id
+   */
+  hasBuffer(e) {
+    return this.bufferDataMap.has(e) || this.stepBufferDataMap.has(e);
+  }
+  hasColormap(e) {
+    return this.colormapDataMap.has(e);
+  }
+  /**
+   * Render from NativeWebGLRenderer-compatible series descriptors (chart integration path).
+   */
+  renderNativeSeries(e, t) {
+    var n, s, c, u, p, g;
+    if (!this.isInitialized || !this.backend) return;
+    const r = [];
+    for (const f of e) {
+      if (!f.visible) continue;
+      if (f.type === "boxplot") {
+        this.appendBoxplotDraws(f, r);
+        continue;
+      }
+      if (f.type === "waterfall") {
+        this.appendWaterfallDraws(f, r);
+        continue;
+      }
+      if (f.count === 0) continue;
+      const w = this.bufferDataMap.get(f.id);
+      if (!w) continue;
+      this.backend.createOrUpdateBuffer(f.id, w, { usage: "vertex" });
+      const x = m(
+        typeof ((n = f.style) == null ? void 0 : n.color) == "string" ? f.style.color : "#00f2ff"
+      ), P = ((s = f.style) == null ? void 0 : s.opacity) ?? 1, T = [
+        x[0],
+        x[1],
+        x[2],
+        x[3] * P
+      ], d = this.mapNativeDrawKind(f.type), h = {
+        id: f.id,
+        kind: d,
+        bufferId: f.id,
+        count: f.count,
+        visible: !0,
+        yBounds: f.yBounds
+      };
+      if (d === "scatter" || d === "line+scatter" || d === "step+scatter" || d === "points")
+        h.style = {
+          color: T,
+          opacity: P,
+          pointSize: ((c = f.style) == null ? void 0 : c.pointSize) ?? 4,
+          symbol: ((u = f.style) == null ? void 0 : u.symbol) ?? "circle"
+        };
+      else if (d === "heatmap") {
+        h.textureId = `${f.id}_colormap`, h.style = {
+          zBounds: f.zBounds,
+          colormap: f.colormap
+        };
+        const b = this.colormapDataMap.get(`${f.id}_colormap`);
+        b && this.backend.createOrUpdateTexture1D(h.textureId, b, {
+          width: b.length / 4
+        });
+      } else
+        h.style = {
+          color: T,
+          opacity: P,
+          lineWidth: ((p = f.style) == null ? void 0 : p.width) ?? ((g = f.style) == null ? void 0 : g.lineWidth) ?? 1
+        };
+      if ((d === "step" || d === "step+scatter") && f.stepBuffer && f.stepCount) {
+        const b = `${f.id}_step`, M = this.stepBufferDataMap.get(b);
+        M && (this.backend.createOrUpdateBuffer(b, M, { usage: "vertex" }), h.stepBufferId = b, h.stepCount = f.stepCount);
+      }
+      r.push(h);
+    }
+    const i = t.dpr ?? this.dpr, a = {
+      viewport: {
+        width: this.canvas.clientWidth,
+        height: this.canvas.clientHeight,
+        dpr: i
+      },
+      clearColor: t.backgroundColor ?? [0.1, 0.1, 0.18, 1],
+      bounds: t.bounds,
+      plotArea: t.plotArea
+    };
+    "renderWithBounds" in this.backend ? this.backend.renderWithBounds({ items: r }, a, t.bounds) : this.backend.render({ items: r }, a);
+  }
+  appendBoxplotDraws(e, t) {
+    var n, s, c;
+    const r = this.seriesColor(e.style), i = { color: r, opacity: ((n = e.style) == null ? void 0 : n.opacity) ?? 1, lineWidth: ((s = e.style) == null ? void 0 : s.width) ?? 1 }, a = { color: r, opacity: (((c = e.style) == null ? void 0 : c.opacity) ?? 1) * 0.85, lineWidth: 1 };
+    this.pushDraw(t, `${e.id}_box_faces`, "bar", e.boxCount ?? 0, a, e.yBounds), this.pushDraw(t, `${e.id}_box_lines`, "line", e.boxLinesCount ?? 0, i, e.yBounds);
+  }
+  appendWaterfallDraws(e, t) {
+    const r = e.style ?? {}, i = this.colorFromHex(r.positiveColor ?? "#22c55e", 0.9), a = this.colorFromHex(r.negativeColor ?? "#ef4444", 0.9), n = this.colorFromHex(r.subtotalColor ?? "#3b82f6", 0.9), s = this.colorFromHex(r.connectorColor ?? "#64748b", 0.6);
+    this.pushDraw(t, `${e.id}_wf_positive`, "bar", e.wfPositiveCount ?? 0, { color: i, opacity: 0.9, lineWidth: 1 }, e.yBounds), this.pushDraw(t, `${e.id}_wf_negative`, "bar", e.wfNegativeCount ?? 0, { color: a, opacity: 0.9, lineWidth: 1 }, e.yBounds), this.pushDraw(t, `${e.id}_wf_subtotal`, "bar", e.wfSubtotalCount ?? 0, { color: n, opacity: 0.9, lineWidth: 1 }, e.yBounds), r.showConnectors !== !1 && this.pushDraw(t, `${e.id}_wf_connectors`, "line", e.wfConnectorCount ?? 0, { color: s, opacity: 0.6, lineWidth: 1 }, e.yBounds);
+  }
+  pushDraw(e, t, r, i, a, n) {
+    if (i <= 0) return;
+    const s = this.bufferDataMap.get(t);
+    !s || !this.backend || (this.backend.createOrUpdateBuffer(t, s, { usage: "vertex" }), e.push({
+      id: t,
+      kind: r,
+      bufferId: t,
+      count: i,
+      visible: !0,
+      style: a,
+      yBounds: n
+    }));
+  }
+  seriesColor(e) {
+    const t = m(typeof (e == null ? void 0 : e.color) == "string" ? e.color : "#00f2ff"), r = (e == null ? void 0 : e.opacity) ?? 1;
+    return [t[0], t[1], t[2], t[3] * r];
+  }
+  colorFromHex(e, t) {
+    const r = m(e);
+    return [r[0], r[1], r[2], r[3] * t];
+  }
+  mapNativeDrawKind(e) {
+    switch (e) {
+      case "scatter":
+        return "scatter";
+      case "line+scatter":
+        return "line+scatter";
+      case "step":
+        return "step";
+      case "step+scatter":
+        return "step+scatter";
+      case "band":
+        return "band";
+      case "bar":
+        return "bar";
+      case "heatmap":
+        return "heatmap";
+      default:
+        return "line";
+    }
+  }
+  /**
+   * Create or update a buffer
+   */
+  createBuffer(e, t) {
+    this.bufferDataMap.set(e, t);
+  }
+  /**
+   * Update a buffer partially
+   */
+  updateBuffer(e, t, r) {
+    const i = this.bufferDataMap.get(e);
+    if (!i) return !1;
+    const a = r / 4;
+    return i.set(t, a), !0;
+  }
+  /**
+   * Get a buffer's data
+   */
+  getBuffer(e) {
+    return this.bufferDataMap.get(e);
+  }
+  /**
+   * Delete a buffer
+   */
+  deleteBuffer(e) {
+    this.bufferDataMap.delete(e), this.backend && this.backend.deleteBuffer(e);
+  }
+  /**
+   * Create or update a step buffer
+   */
+  createStepBuffer(e, t) {
+    this.stepBufferDataMap.set(e, t);
+  }
+  /**
+   * Create colormap texture
+   */
+  createColormapTexture(e, t) {
+    this.colormapDataMap.set(e, t), this.backend && this.backend.createOrUpdateTexture1D(e, t, {
+      width: t.length / 4
+    });
+  }
+  /**
+   * Render a frame
+   */
+  render(e, t) {
+    if (!this.isInitialized || !this.backend) return;
+    const r = this.buildDrawList(e), i = {
+      viewport: {
+        width: this.canvas.clientWidth,
+        height: this.canvas.clientHeight,
+        dpr: this.dpr
+      },
+      clearColor: t.backgroundColor ?? [0.1, 0.1, 0.18, 1],
+      bounds: t.bounds,
+      plotArea: t.plotArea
+    };
+    "renderWithBounds" in this.backend ? this.backend.renderWithBounds(r, i, t.bounds) : this.backend.render(r, i);
+  }
+  /**
+   * Build draw list from series data
+   */
+  buildDrawList(e) {
+    const t = [];
+    for (const r of e) {
+      const i = this.bufferDataMap.get(r.id);
+      if (!i) continue;
+      this.backend.createOrUpdateBuffer(r.id, i, { usage: "vertex" });
+      const a = r.type === "heatmap" ? i.length / 3 : i.length / 2, n = m(r.style.color), s = r.style.opacity ?? 1, c = [
+        n[0],
+        n[1],
+        n[2],
+        n[3] * s
+      ], u = {
+        id: r.id,
+        kind: r.type,
+        bufferId: r.id,
+        count: a,
+        visible: r.visible,
+        yBounds: r.yBounds
+      };
+      if (r.type === "scatter" || r.type === "line+scatter" || r.type === "step+scatter")
+        u.style = {
+          color: c,
+          opacity: s,
+          pointSize: r.style.pointSize ?? 4,
+          symbol: r.style.symbol ?? "circle"
+        };
+      else if (r.type === "heatmap") {
+        u.textureId = `colormap:${r.id}`, u.style = {
+          zBounds: r.zBounds,
+          colormap: r.colormap
+        };
+        const p = this.colormapDataMap.get(r.id);
+        p && this.backend.createOrUpdateTexture1D(u.textureId, p, {
+          width: p.length / 4
+        });
+      } else
+        u.style = {
+          color: c,
+          opacity: s,
+          lineWidth: r.style.lineWidth ?? 1
+        };
+      if ((r.type === "step" || r.type === "step+scatter") && this.stepBufferDataMap.has(r.id)) {
+        const p = this.stepBufferDataMap.get(r.id), g = `${r.id}:step`;
+        this.backend.createOrUpdateBuffer(g, p, { usage: "vertex" }), u.stepBufferId = g, u.stepCount = p.length / 2;
+      }
+      t.push(u);
+    }
+    return { items: t };
+  }
+  /**
+   * Handle canvas resize
+   */
+  resize() {
+    if (!this.backend) return;
+    const e = this.canvas.getBoundingClientRect();
+    this.backend.setViewport({
+      width: e.width,
+      height: e.height,
+      dpr: this.dpr
+    });
+  }
+  /**
+   * Get renderer limits
+   */
+  getLimits() {
+    return {
+      backend: this.backendType,
+      available: this.isInitialized
+    };
+  }
+  /**
+   * Destroy the renderer
+   */
+  destroy() {
+    var e, t;
+    (e = this.adapter) == null || e.destroy(), (t = this.backend) == null || t.destroy(), this.bufferDataMap.clear(), this.stepBufferDataMap.clear(), this.colormapDataMap.clear(), this.adapter = null, this.backend = null, this.isInitialized = !1, this.backendType = null;
+  }
+}
+async function ve(o, e) {
+  const t = new he(o, e);
+  return await t.init() ? t : null;
+}
+export {
+  he as G,
+  U as S,
+  v as W,
+  y as a,
+  ge as b,
+  ve as c,
+  me as d,
+  m as p
+};
+//# sourceMappingURL=gpuRenderer-BpaMYz-k.js.map